Ray,Simple Camera and Object

color ray_color(const ray& r) {
    //将光线转换为单位向量
    vec3 unit_direction=unit_vector(r.direction());
    //将y坐标的范围从[-1,1]映射到[0,1]，便于之后按比例混合颜色
    //由于主函数规定的视口高度为2，以视口中心为0，则高度的范围就是【-1，1】
    auto a=0.5*(unit_direction.y+1.0);
    //返回白色和蓝色混合后的颜色
    return (1.0-a)*color(1.0,1.0,1.0)+a*color(0.5,0.7,1.0);
}

/**
 *
 * @param center 球体中心
 * @param radius 球半径
 * @param r 光线
 * @return 是否在球上/内部
 */
bool hit_sphere(const point3& center,double radius,const ray& r) {
    auto delta_a=dot(r.direction(),r.direction());
    auto delta_b=-2*dot(r.direction(),(center-r.origin()));
    auto delta_c=dot(center-r.origin(),r.direction())-radius*radius;
    return sqrt(delta_b*delta_b-4*delta_a*delta_c)>=0;
}

color ray_color(const ray& r) {
    //如果当前点在球上/内部，则返回红色，否则返回渐变背景颜色
    if (hit_sphere(point3(0,0,-1),0.5,r))return color(1.0,0.0,0.0);

    //将光线转换为单位向量
    vec3 unit_direction=unit_vector(r.direction());
    //将y坐标的范围从[-1,1]映射到[0,1]，便于之后按比例混合颜色
    //由于主函数规定的视口高度为2，以视口中心为0，则高度的范围就是【-1，1】
    auto a=0.5*(unit_direction.y+1.0);
    //返回白色和蓝色混合后的颜色
    return (1.0-a)*color(1.0,1.0,1.0)+a*color(0.5,0.7,1.0);
}

/**
 * @param center 球体中心
 * @param radius 球半径
 * @param r 光线
 * @return 射线方程 P(t)=A+td 中的t，即光线从起点经过了多长的路径到达了指定像素
 */
double hit_sphere(const point3& center,double radius,const ray& r) {
    auto delta_a=dot(r.direction(),r.direction());
    auto delta_b=-2.0*dot(r.direction(),(center-r.origin()));
    auto delta_c=dot(center-r.origin(),r.direction())-radius*radius;

    auto discriminant=delta_b*delta_b-4.0*delta_a*delta_c;
    if (discriminant<0.0)return -1.0;
    //射线和球面的交点可能存在一个或多个，但在绘制时近处的会遮挡远处的，因此此处返回值更小的根。
    else return (-delta_b-std::sqrt(discriminant))/(2.0*delta_a);
}

color ray_color(const ray& r) {
    //计算当前光线如果能与球面相交，则经过了多长的距离
    auto t=hit_sphere(point3(0.0,0.0,-1),0.5,r);
    if (t>0.0) {
        //计算当前光线从起点经过t的距离和球面相交时，交点的坐标并归一化。
        //由于计算法线是相对物体自身，所以需要减去球体的中心坐标，以模拟当前位于原点（局部坐标）
        auto p=unit_vector(r.at(t)-point3(0.0,0.0,-1.0));
        return 0.5*color(p.r+1.0,p.g+1.0,p.b+1.0);
    }

    //将光线转换为单位向量
    vec3 unit_direction=unit_vector(r.direction());
    //将y坐标的范围从[-1,1]映射到[0,1]，便于之后按比例混合颜色
    //由于主函数规定的视口高度为2，以视口中心为0，则高度的范围就是【-1，1】
    auto a=0.5*(unit_direction.y+1.0);
    //返回白色和蓝色混合后的颜色
    return (1.0-a)*color(1.0,1.0,1.0)+a*color(0.5,0.7,1.0);
}

/**
 * @param center 球体中心
 * @param radius 球半径
 * @param r 光线
 * @return 射线方程 P(t)=A+td 中的t，即光线从起点经过了多长的路径到达了指定像素
 */
double hit_sphere(const point3& center,double radius,const ray& r) {
    auto oc=center-r.origin();
    auto delta_a=dot(r.direction(),r.direction());
    auto h=dot(r.direction(),oc);
    auto delta_c=dot(oc,oc)-radius*radius;

    auto discriminant=h*h-delta_a*delta_c;
    if (discriminant<0.0)return -1.0;
    else return (h-std::sqrt(discriminant))/(delta_a);
}

//所有可击中对象的父类
class hittable {
public:
    //使用默认的析构函数
    virtual ~hittable() = default;
    virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const = 0;
};

//单次碰撞的切片数据
class hit_record {
public:
    //碰撞交点在世界空间下的坐标
    point3 position;
    //碰撞交点和光线起点的距离
    double t;
    //法线向量
    vec3 normal;
};

//单次碰撞的切片数据
class hit_record {
public:
    //碰撞交点在世界空间下的坐标
    point3 position;
    //碰撞交点和光线起点的距离
    double t;
    //法线,与光源来源相反
    vec3 normal;
    //光线来源方向
    bool front_face;

    //计算光线来源方向和法线
    void set_face_normal(const ray& r,const vec3& outware_normal) {
        //如果碰撞点向外法线和光线方向相反（夹角大于90度），则点积小于0，记为true
        front_face=dot(r.direction(),outware_normal)<0;
        //如果碰撞点向外法线和光线方向相同，则法线需要反转，以保证法线始终和光线来源相反
        normal=front_face?outware_normal:-outware_normal;
    }
};

    //判断是否击中
    //rec是输出参数
    bool hit(const ray &r, double t_min, double t_max, hit_record &rec) const override {
        auto oc=center-r.origin();
        auto delta_a=dot(r.direction(),r.direction());
        auto h=dot(r.direction(),oc);
        auto delta_c=dot(oc,oc)-radius*radius;

        //判断交点数量
        auto discriminant=h*h-delta_a*delta_c;
        if (discriminant<0)return false;

        //检查交点是否在range t_min,t_max 内
        auto root=(h-std::sqrt(discriminant))/delta_a;
        if (root<t_min||root>t_max){
            //检查较大根
            root=(h+std::sqrt(discriminant))/delta_a;
            if (root<t_min||root>t_max)return false;
        }
        //这里直接把数据写进函数参数的rec
        rec.t=root;
        rec.position=r.at(root);
        rec.set_face_normal(r,(rec.position-center)/radius);

        return true;
    }

//
// Created by Klingsor on 2026/6/4.
//

#ifndef RT1WEEK_HITTABLE_LIST_H
#define RT1WEEK_HITTABLE_LIST_H

#include <memory>
#include <vector>
#include "hittable.h"
#include "../core/ray.h"
using std::make_shared;
using std::shared_ptr;

//可击中对象列表
//继承hittable是为了可以将列表也视为一个可击中对象，以便在需要时进行嵌套
class hittable_list : public hittable {
public:
    //使用shared指针简化操作，实际项目不推荐
    std::vector<shared_ptr<hittable>> objects;

    //创建一个空的可击中列表在语义上是合理的，因此需要无参构造函数
    hittable_list(){};
    hittable_list(shared_ptr<hittable> object){ add(object); }

    void add(shared_ptr<hittable> object){ objects.push_back(object); }
    void clear(){objects.clear();}

    bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const override {
        hit_record temp_record;
        //当前最近的碰撞点和视点的距离
        double closest_so_f=t_max;
        //当前是否存在能够碰撞的点
        bool isHit=false;

        //遍历当前列表中的所有可击中对象，返回最近的碰撞切片
        for (const auto& object : objects) {
            if (object->hit(r,t_min,closest_so_f,temp_record)) {
                isHit=true;
                rec=temp_record;
                closest_so_f=rec.t;
            }
        }
        return isHit;
    }

};

#endif //RT1WEEK_HITTABLE_LIST_H

#include <iostream>
#include <fstream>
#include "math/rtweek.h"
#include "shape/hittable_list.h"
#include "shape/sphere.h"
#include "shape/hittable.h"


color ray_color(const ray& r,const hittable_list& world) {
    //检查当前射线是否和实体对象相交
    hit_record temp_rec;
    if (world.hit(r,0.001,infinity,temp_rec)) {
        //返回交点的法线映射的颜色
        return 0.5*(temp_rec.normal+color(1.0,1.0,1.0));
    }


    //如果没有交点，则绘制渐变背景
    //将光线转换为单位向量
    vec3 unit_direction=unit_vector(r.direction());
    //将y坐标的范围从[-1,1]映射到[0,1]，便于之后按比例混合颜色
    //由于主函数规定的视口高度为2，以视口中心为0，则高度的范围就是【-1，1】
    auto a=0.5*(unit_direction.y+1.0);
    //返回白色和蓝色混合后的颜色
    return (1.0-a)*color(1.0,1.0,1.0)+a*color(0.5,0.7,1.0);
}

int main() {
    //输出流对象
    //使用fstram替代cout标准输出，以避免异常的不可见字符
    std::ofstream out("image.ppm", std::ios::out | std::ios::binary);
    if (!out) {
        std::cerr << R"(创建文件失败)" << std::endl;
        return 1;
    }

    //Image
    auto aspect_ratio=16.0/9.0;
    int image_width=400;
    int image_height=image_width/aspect_ratio<1?1:image_width/aspect_ratio;

    //Camera
    auto focal_length=1.0;     //焦距
    auto view_height=2.0;      //视口高度
    auto view_width=view_height*((double)image_width/image_height);  //视口宽度
    auto camera_center=point3(0,0,0);    //相机/视点坐标

    //从视口左边缘到右边缘、上边缘到下边缘的向量
    auto view_u=vec3(view_width,0.0,0.0);
    auto view_v=vec3(0.0,-view_height,0.0);

    //像素在水平和垂直方向上的步进增量
    //这表示每向右/下移动一个像素，在3d空间中需要移动的距离
    //3d空间是指视口所在的3d空间。我们将焦距设为1，这里的步进增量也是相对这个单位1定义的坐标系
    auto pixel_delta_u=view_u/image_width;
    auto pixel_delta_v=view_v/image_height;

    //获得视口左上角顶点在3d空间中的坐标
    auto view_upper_left=camera_center-vec3(0,0,focal_length)-view_v/2-view_u/2;
    //获得视口左上角顶点像素的像素中心
    auto pixel00_loc=view_upper_left+0.5*(pixel_delta_u+pixel_delta_v);

    //world
    //创建可击中对象列表并添加两个shpere
    hittable_list world;
    world.add(make_shared<sphere>(point3(0.0,0.0,-1.0),0.5));
    world.add(make_shared<sphere>(point3(0.0,-100.5,-1.0),100));

    //Render && PPMInput
    out<<"P3\n"<<image_width<<' '<<image_height<<'\n'<<"255\n";

    for (int j=0;j<image_height;j++) {
        //输出进度,\r表示光标回到当前行行首
        std::clog<<"\r当前进度："<<(image_height-j)<<' '<<std::flush;
        for (int i=0;i<image_width;i++) {
            //计算当前像素中心，光线会从视点指向当前像素中心
            auto pixel_center=pixel00_loc+i*pixel_delta_u+j*pixel_delta_v;
            //计算指向当前像素的光线的方向
            auto ray_direction=pixel_center-camera_center;
            //声明当前光线的实例
            ray r(camera_center,ray_direction);
            //使用ray_color方法得到当前像素的颜色
            auto pixel_color=ray_color(r,world);
            //将颜色输出到文件
            write_color(out,pixel_color);
        }
    }
    std::clog<<"\r结束                                     \n";
    out.close();
    return 0;
}