double hit_sphere(const point3& center,double radius,const ray& r){
    vec3 oc = center - r.origin();
    auto a = dot(r.direction(),r.direction());
    auto b = -2.0 * dot(r.direction(),oc);
    auto c = dot(oc,oc) - radius*radius;
    auto discriminant = b*b - 4*a*c;
	//判断delta值，并计算t（这里计算的是较小的t）
    if(discriminant < 0.0){
        return -1.0;
    }else{
        return (-b - std::sqrt(discriminant)) / (2.0*a);
    }
}

color ray_color(ray & r){
    auto t = hit_sphere(point3(0,0,-1),0.5,r);
    //根据t的分量进行上色
    if(t > 0.0){
        vec3 N = unit_vector(r.at(t) - point3(0,0,-1));
        return 0.5*color(N.x()+1,N.y()+1,N.z()+1);
    }

    vec3 unit_direction = unit_vector(r.direction());
    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);
}

double hit_sphere(const point3& center,double radius,const ray& r){
    vec3 oc = center - r.origin();
    auto a = dot(r.direction(),r.direction());
    auto b = -2.0 * dot(r.direction(),oc);
    auto c = dot(oc,oc) - radius*radius;
    auto discriminant = b*b - 4*a*c;

    if(discriminant < 0.0){
        return -1.0;
    }else{
        return (-b - std::sqrt(discriminant)) / (2.0*a);
    }
}

double hit_sphere(const point3& center,double radius,const ray& r){
    vec3 oc = center - r.origin();
    auto a = r.direction().length_squared();
    auto h = dot(r.direction(),oc);
    auto c = oc.length_squared() - radius*radius;
    auto discriminant = h*h - a*c;

    if(discriminant < 0.0){
        return -1.0;
    }else{
        return (h - std::sqrt(discriminant)) / a;
    }
}

#ifndef RENDER_C___HITTABLE_H
#define RENDER_C___HITTABLE_H

#include "ray.h"

//用于存储光线与物体相交的重要信息
class hit_record{
public:
    point3 p;
    vec3 normal;
    double t;
};

class hittable{
public:
    virtual ~hittable() = default;
    //纯虚函数，用来实现函数的多态性
    virtual bool hit(const ray& r, double ray_min,double ray_max,hit_record& rec) const = 0;
};

#endif //RENDER_C___HITTABLE_H

#ifndef RENDER_C___SPHERE_H
#define RENDER_C___SPHERE_H

#include "vec3.h"
#include "hittable.h"

class sphere: public hittable{
public:
    sphere(const point3& center, double radius) : center(center), radius(std::fmax(0,radius)) {}
	//fmax返回两个浮点数参数较大的一个，fmin同理
    bool hit(const ray& r, double ray_min,double ray_max,hit_record& rec) const override{
        vec3 oc = center - r.origin();						// override 重写基类的虚函数
        auto a = r.direction().length_squared();
        auto h = dot(r.direction(),oc);
        auto c = oc.length_squared() - radius*radius;

        auto discriminant = h*h - a*c;
        if(discriminant < 0.0){
            return false;
        }

        //解t并进行判断
        auto sqrtd = std::sqrt(discriminant);
        auto root = (h - sqrtd) / a;
        if(root <= ray_min || ray_max <= root){
            root = (h + sqrtd) / a;
            if(root <= ray_min || ray_max <= root)
                return false;
        }
        
        rec.t = root;
        rec.p = r.at(rec.t);
        rec.normal = (rec.p - center) / radius;
        
        return true;
    }
    
private:
    point3 center;
    double radius;
};


#endif //RENDER_C___SPHERE_H

bool front_face;
if(dot(ray_direction,outward_normal) > 0.0){
    // 光线在球体内部
    normal = -outward_normal;	//实际的法线方向，需要翻转
    front_face = false;
}else{
    // 光线在球体外部
    normal = outward_normal;
    front_face = true;
}

class hit_record{
public:
    point3 p;
    vec3 normal;
    double t;
    bool front_face;

    void set_face_normal(const ray& r,const vec3& outward_normal){
        //设置交点的法线方向
        front_face = dot(r.direction(),outward_normal) < 0;
        normal = front_face ? outward_normal : -outward_normal;
    }
};

class sphere : public hittable {
  public:
    ...
    bool hit(const ray& r, double ray_tmin, double ray_tmax, hit_record& rec) const {
        ...

        rec.t = root;
        rec.p = r.at(rec.t);
        vec3 outward_normal = (rec.p - center) / radius;
        rec.set_face_normal(r, outward_normal);

        return true;
    }
    ...
};

#ifndef RENDER_C___HITTABLE_LIST_H
#define RENDER_C___HITTABLE_LIST_H

#include "hittable.h"

#include <memory>
#include <vector>

using std::make_shared;
using std::shared_ptr;

class hittable_list : public hittable {
public:
    std::vector<shared_ptr<hittable>> objects;
	// 创建了一个可击中对象的数组
    hittable_list(){}
    hittable_list(shared_ptr<hittable> object) {add(object);}

    void clear() {objects.clear();}

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

    bool hit(const ray& r, double ray_tmin, double ray_tmax, hit_record& rec) const override{
        hit_record temp_rec;
        bool hit_anything = false;
        auto closest_so_far = ray_tmax;

        for(const auto& object : objects){
            if(object->hit(r,ray_tmin,closest_so_far,temp_rec)){
                hit_anything = true;
                closest_so_far = temp_rec.t;
                rec = temp_rec;
            }
        }
        return hit_anything;
    }
};

#endif //RENDER_C___HITTABLE_LIST_H

auto double_ptr = make_shared<double>(0.41);
auto vec3_ptr = make_shared<vec3>(1.1,1.2,1.3);
auto sphere_ptr = make_shared<sphere>(point3(0,0,0),1.0)

std::vector<shared_ptr<hittable>> objects;
//添加一个值
objects.push_back(object);
//删除所有值
objects.clear();
//数组大小
objects.size();
//访问
objects[]

#ifndef RENDER_C___RTWEEKEND_H
#define RENDER_C___RTWEEKEND_H

#include <cmath>
#include <iostream>
#include <limits>
#include <memory>

using std::make_shared;
using std::shared_ptr;

//常量设置
const double infinity = std::numeric_limits<double>::infinity();
const double pi = 3.1415926535897932385;

//实用函数
inline double degree_to_radius(double degrees){
    return degrees * pi / 180.0;
}

//常用文件头
#include "color.h"
#include "ray.h"
#include "vec3.h"

#endif //RENDER_C___RTWEEKEND_H

//这里我们修改了一下头文件还有ray_color函数
#include "rtweekend.h"
#include "hittable.h"
#include "hittable_list.h"
#include "sphere.h"

#include <iostream>

color ray_color(ray & r,const hittable& world){
    hit_record rec;
    if(world.hit(r,0,infinity,rec)){		//只有t在(0,+无穷)的时候才成立
        return 0.5*(rec.normal + color(1,1,1));
    }

    vec3 unit_direction = unit_vector(r.direction());
    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(){
    auto aspect_radio = 16.0/9.0;	//长宽比
    int image_width = 400;

    //计算图像的高度，并确保图像的高度至少为1（单位长度）
    int image_height = int (image_width / aspect_radio);
    image_height = (image_height < 1) ? 1 : image_height;

    //球体列表
    hittable_list world;

    world.add(make_shared<sphere>(point3(0,0,-1),0.5));
    world.add(make_shared<sphere>(point3(0,-100.5,-1),100));

    //确保视口的宽高比和图像的宽高比一样
    auto focal_length = 1.0;
    auto viewport_height = 2.0;
    auto viewport_width = viewport_height * (double(image_width)/image_height);
    auto camera_center = point3(0,0,0);

    //设置视口向量与单位长度
    auto viewport_u = vec3(viewport_width,0,0);
    auto viewport_v = vec3(0,-viewport_height,0);
    auto pixel_delta_u = viewport_u/image_width;
    auto pixel_delta_v = viewport_v/image_height;

    //计算像素点位
    auto viewport_upper_left = camera_center - vec3(0,0,focal_length) - viewport_v/2 - viewport_u/2;
    auto pixel00_loc = viewport_upper_left + 0.5*(pixel_delta_u+pixel_delta_v);


    //渲染器
    std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";
    for(int j=0;j<image_height;j++){
        std::clog << "\rScanlines remaining: " << (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);

            color pixel_color = ray_color(r,world);
            write_color(std::cout,pixel_color);
        }
    }
    std::clog << "\rDone.                   \n";
}

#ifndef RENDER_C___INTERVAL_H
#define RENDER_C___INTERVAL_H

#include "rtweekend.h"

class interval{
public:
    double min,max;
    //默认区间是空的
    interval() : min(+infinity),max(-infinity) {}

    interval(double min,double max): min(min),max(max) {}

    double size() const{
        return max - min;
    }
    //闭区间
    bool contains(double x) const {
        return min <= x && x <= max;
    }
    //开区间
    bool surrounds(double x) const{
        return min < x && x < max;
    }

    static const interval empty,universe;
};

const interval interval::empty = interval(+infinity,-infinity);
const interval interval::universe = interval(-infinity,+infinity);

#endif //RENDER_C___INTERVAL_H

//hittable.h
class hittable {
  public:
    ...
    virtual bool hit(const ray& r, interval ray_t, hit_record& rec) const = 0;
};

//hittable_list.h
class hittable_list : public hittable {
  public:
    ...
    bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
        hit_record temp_rec;
        bool hit_anything = false;
        auto closest_so_far = ray_t.max;

        for (const auto& object : objects) {
            if (object->hit(r, interval(ray_t.min, closest_so_far), temp_rec)) {
                hit_anything = true;
                closest_so_far = temp_rec.t;
                rec = temp_rec;
            }
        }

        return hit_anything;
    }
    ...
};

//sphere.h
class sphere : public hittable {
  public:
    ...
    bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
        ...

        auto root = (h - sqrtd) / a;
        if (!ray_t.surrounds(root)) {
            root = (h + sqrtd) / a;
            if (!ray_t.surrounds(root))
                return false;
        }
        ...
    }
    ...
};

color ray_color(const ray& r, const hittable& world) {
    hit_record rec;
    if (world.hit(r, interval(0, infinity), rec)) {
        return 0.5 * (rec.normal + color(1,1,1));
    }

    vec3 unit_direction = unit_vector(r.direction());
    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);
}

bool hit_sphere(const point3& center,double radius,const ray& r){
    vec3 oc = center - r.origin();		//计算(point(C)-point(Q))
    auto a = dot(r.direction(),r.direction());
    auto b = -2.0 * dot(r.direction(),oc);
    auto c = dot(oc,oc) - radius*radius;
    auto discriminant = b*b - 4*a*c;
    return (discriminant >= 0);
}

color ray_color(ray & r){
    if(hit_sphere(point3(0,0,-1),0.5,r))
        return {1,0,0};

    vec3 unit_direction = unit_vector(r.direction());
    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);
}

auto aspect_radio = 16.0/9.0;	//长宽比
int image_width = 400;

//计算图像的高度，并确保图像的高度至少为1（单位长度）
int image_height = int (image_width / aspect_radio);
image_height = (image_height < 1) ? 1 : image_height;

//确保视口的宽高比和图像的宽高比一样
auto viewport_height = 2.0;
auto viewport_width = viewport_height * (double(image_width)/image_height);

#include "color.h"
#include "vec3.h"
#include "ray.h"

#include <iostream>

color ray_color(const ray& r){
    return {0,0,0};
}

int main(){
    auto aspect_radio = 16.0/9.0;	//长宽比
    int image_width = 400;

    //计算图像的高度，并确保图像的高度至少为1（单位长度）
    int image_height = int (image_width / aspect_radio);
    image_height = (image_height < 1) ? 1 : image_height;

    //确保视口的宽高比和图像的宽高比一样
    auto focal_length = 1.0;
    auto viewport_height = 2.0;
    auto viewport_width = viewport_height * (double(image_width)/image_height);
    auto camera_center = point3(0,0,0);

    //设置视口向量与单位长度
    auto viewport_u = vec3(viewport_width,0,0);
    auto viewport_v = vec3(0,-viewport_height,0);
    auto pixel_delta_u = viewport_u/image_width;
    auto pixel_delta_v = viewport_v/image_height;

    //计算像素点位
    auto viewport_upper_left = camera_center - vec3(0,0,focal_length) - viewport_v/2 - viewport_u/2;
    auto pixel00_loc = viewport_upper_left + 0.5*(pixel_delta_u+pixel_delta_v);


    //渲染器
    std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";
    for(int j=0;j<image_height;j++){
        std::clog << "\rScanlines remaining: " << (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);

            color pixel_color = ray_color(r);
            write_color(std::cout,pixel_color);
        }
    }
    std::clog << "\rDone.                   \n";
}

color ray_color(ray & r){
    vec3 unit_direction = unit_vector(r.direction());
    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);
}

#ifndef RENDER_C___VEC3_H
#define RENDER_C___VEC3_H

#include <cmath>
#include <iostream>
// 向量类
class vec3 {
public:
    double e[3];

    vec3(): e{0,0,0} {}
    vec3(double e0,double e1,double e2): e{e0,e1,e2} {}

    double x() const{ return e[0]; }
    double y() const{ return e[1]; }
    double z() const{ return e[2]; }

    vec3 operator-() const {return {-e[0],-e[1],-e[2]};}
    double operator[](int i) const { return e[i];}
    double & operator[](int i) {return e[i];}

    vec3& operator+=(const vec3& v){
        e[0] += v.e[0];
        e[1] += v.e[1];
        e[2] += v.e[2];
        return *this;
    }

    vec3& operator*=(double t){
        e[0] *= t;
        e[1] *= t;
        e[2] *= t;
        return *this;
    }

    vec3& operator/=(double t){
        return *this *= 1/t;
    }

    double length_squared() const{
        return e[0]*e[0]+e[1]*e[1]+e[2]*e[2];
    }

    double length() const {
        return std::sqrt(length_squared());
    }
};

// 设置别名
using point3 = vec3;

// 设置内联函数
inline std::ostream& operator<<(std::ostream& out,const vec3& v){
    return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
}

inline vec3 operator+(const vec3& u,const vec3& v){
    return {u.e[0]+v.e[0],u.e[1]+v.e[1],u.e[2]+v.e[2]};
}

inline vec3 operator-(const vec3& u,const vec3& v){
    return {u.e[0]-v.e[0],u.e[1]-v.e[1],u.e[2]-v.e[2]};
}

inline vec3 operator*(const vec3& u,const vec3& v){
    return {u.e[0]*v.e[0],u.e[1]*v.e[1],u.e[2]*v.e[2]};
}

inline vec3 operator*(double t,const vec3& v){
    return {t*v.e[0],t*v.e[1],t*v.e[2]};
}

inline vec3 operator*(const vec3& v,double t){
    return t*v;
}

inline vec3 operator/(const vec3& v,double t){
    return (1/t)*v;
}

inline double dot(const vec3& u,const vec3& v){
    return u.e[0]*v.e[0] + u.e[1]*v.e[1] + u.e[2]*v.e[2]; 
}

inline vec3 cross(const vec3& u,const vec3& v){
    return {u.e[1]*v.e[2]-u.e[2]*v.e[1],u.e[2]*v.e[0]-u.e[0]*v.e[2],u.e[0]*v.e[1]-u.e[1]*v.e[0]};
}

inline vec3 uint_vector(const vec3& v){
    return v/v.length();
}

#endif //RENDER_C___VEC3_H

#ifndef RENDER_C___COLOR_H
#define RENDER_C___COLOR_H

#include "vec3.h"

using color = vec3;

void write_color(std::ostream& out,const color& pixel_color){
    auto r = pixel_color.x();
    auto g = pixel_color.y();
    auto b = pixel_color.z();

    int rbyte = int (255.999 * r);
    int gbyte = int (255.999 * g);
    int bbyte = int (255.999 * b);
    
    out << rbyte << ' ' << gbyte << ' ' << bbyte << '\n';
}

#endif //RENDER_C___COLOR_H

#include "color.h"
#include "vec3.h"

#include <iostream>

int main(){
    int image_width = 256;
    int image_height = 256;

    std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
    for (int j=0;j<image_height;j++){
        std::clog << "\rScanlines remaining: "<< (image_height-j) << '\r' << std::flush;
        for(int i =0;i<image_width;i++){
            auto pixel_color = color(double(i)/(image_width-1),double(j)/(image_height-1),0);
            write_color(std::cout,pixel_color);
        }
    }
    std::clog << "\rDone\n";
}

#ifndef RENDER_C___RAY_H
#define RENDER_C___RAY_H

#include "vec3.h"

class ray{
public:
    ray(){}

    ray(const point3& origin,const vec3& direction): orig(origin),dir(direction){}

    const point3& origin() const {return orig;}
    const vec3& direction() const {return dir;}

    point3 at(double t) const{
        return orig + t*dir;
    }
private:
    point3 orig;
    vec3 dir;
};

#endif //RENDER_C___RAY_H

#include <iostream>
int main(){
    int image_width = 256;
    int image_height = 256;

    std::cout << "P3\n" << image_width << " " << image_width << "\n255\n";

    for (int j =0 ;j<image_height;j++){
        for(int i=0;i<image_width;i++){
            auto r = double (i)/(image_width-1);
            auto g = double (j)/(image_height -1);
            auto b = 0.0;

            int ir = int (255.999 *r);
            int ig = int (255.999 *g);
            int ib = int (255.999 *b);
			// 255.999确保在浮点数计算中的极小误差在转换为整数的过程中不会被放大，可以理解成这是一种技巧，用来避免色彩的丢失
            std::cout << ir << ' ' << ig << ' ' << ib << '\n';
        }
    }
}