#include "rtweekend.h"

#include "camera.h"
#include "hittable.h"
#include "hittable_list.h"
#include "material.h"
#include "sphere.h"

int main(){
    hittable_list world;

    auto ground_material = make_shared<lambertian>(color(0.5,0.5,0.5));
    world.add(make_shared<sphere>(point3(0,-1000,0),1000,ground_material));

    for(int a = -11;a < 11;a++){
        for(int b = -11;b < 11;b++){
            auto choose_mat = random_double();
            point3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());

            if((center - point3(4,0.2,0)).length() > 1.0){
                shared_ptr<material> sphere_material;

                if(choose_mat < 0.8){
                    //漫反射
                    auto albedo = color::random() * color::random();
                    sphere_material = make_shared<lambertian>(albedo);
                    world.add(make_shared<sphere>(center,0.2,sphere_material));
                }else if(choose_mat < 0.95) {
                    //金属
                    auto albedo = color::random(0.5,1);
                    auto fuzz = random_double(0,0.5);
                    sphere_material = make_shared<metal>(albedo,fuzz);
                    world.add(make_shared<sphere>(center,0.2,sphere_material));
                }else{
                    //玻璃
                    sphere_material = make_shared<dielectric>(1.5);
                    world.add(make_shared<sphere>(center,0.2,sphere_material));
                }
            }
        }
    }

    auto material1 = make_shared<dielectric>(1.5);
    world.add(make_shared<sphere>(point3(0,1,0),1.0,material1));

    auto material2 = make_shared<lambertian>(color(0.4, 0.2, 0.1));
    world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));

    auto material3 = make_shared<metal>(color(0.7, 0.6, 0.5), 0.0);
    world.add(make_shared<sphere>(point3(4, 1, 0), 1.0, material3));

    camera cam;

    cam.aspect_ratio      = 16.0 / 9.0;
    cam.image_width       = 800;
    cam.samples_per_pixel = 100;
    cam.max_depth         = 50;


    cam.vfov     = 20;
    cam.lookfrom = point3(13,2,3);
    cam.lookat   = point3(0,0,0);
    cam.vup      = vec3(0,1,0);

    cam.defocus_angle = 0.6;
    cam.focus_dist    = 10.0;

    cam.render(world);
}

class camera{
public:
    double aspect_radio = 1.0;      //图像的宽高比
    int    image_width = 100;       //图像宽度的像素数
    int    samples_per_pixel = 10;  //每个像素的采样次数
    int    max_depth = 10;          //光线追踪的最大递归深度

    double vfov = 90;               //垂直视角（视场）
	...
private:
	...
    void initialize(){
        image_height = int(image_width/aspect_radio);
        image_height = (image_height < 1) ? 1 : image_height;

        pixel_samples_scale = 1.0 / samples_per_pixel;

        camera_center = point3 (0,0,0);

        //确认视窗的设置
        auto focal_length = 1.0;    //焦距设置
        auto theta = degree_to_radius(vfov);
        auto h = std::tan(theta/2);
        auto viewport_height = 2*h*focal_length;
        auto viewport_width = viewport_height*(double (image_width)/image_height);

        //视图边缘的向量计算
        auto viewport_u = vec3(viewport_width,0,0);
        auto viewport_v = vec3(0,-viewport_height,0);
        //计算视图的像素间的水平竖直增量
        pixel_delta_u = viewport_u/image_width;
        pixel_delta_v = viewport_v/image_height;

        //计算左上角第一个像素中心的坐标
        auto viewport_upper_left = camera_center - vec3(0,0,focal_length) - viewport_v/2 - viewport_u/2;
        pixel00_loc = viewport_upper_left + 0.5*(pixel_delta_u+pixel_delta_v);
    }
	...
};

class camera{
public:
    double aspect_radio = 1.0;      //图像的宽高比
    int    image_width = 100;       //图像宽度的像素数
    int    samples_per_pixel = 10;  //每个像素的采样次数
    int    max_depth = 10;          //光线追踪的最大递归深度

    double vfov = 90;               //垂直视角（视场）
    point3 lookfrom = point3 (0,0,0);   //相机位置
    point3 lookat = point3 (0,0,-1);    //观察点
    vec3   vup = vec3(0,1,0);           //相机相对向上的位置
	...
private:
    int image_height;           //渲染图像的高度
    double pixel_samples_scale; //每次采样的颜色权重
    point3 camera_center;       //相机的中心
    point3 pixel00_loc;         //像素(0,0)的位置
    vec3 pixel_delta_u;         //向右的偏移值
    vec3 pixel_delta_v;         //向下的偏移值
    vec3 u,v,w;                 //相机的相对坐标系

    void initialize(){
        image_height = int(image_width/aspect_radio);
        image_height = (image_height < 1) ? 1 : image_height;

        pixel_samples_scale = 1.0 / samples_per_pixel;

        camera_center = lookfrom;

        //确认视窗的设置
        auto focal_length = (lookfrom - lookat).length();    //焦距设置
        auto theta = degree_to_radius(vfov);
        auto h = std::tan(theta/2);
        auto viewport_height = 2*h*focal_length;
        auto viewport_width = viewport_height*(double (image_width)/image_height);

        //计算摄像机的相对基底
        w = unit_vector(lookfrom-lookat);
        u = unit_vector(cross(vup,w));
        v = cross(w,u);;

        //视图边缘的向量计算
        auto viewport_u = viewport_width * u;
        auto viewport_v = viewport_height * -v;
        //计算视图的像素间的水平竖直增量
        pixel_delta_u = viewport_u/image_width;
        pixel_delta_v = viewport_v/image_height;

        //计算左上角第一个像素中心的坐标
        auto viewport_upper_left = camera_center - (focal_length * w) - viewport_v/2 - viewport_u/2;
        pixel00_loc = viewport_upper_left + 0.5*(pixel_delta_u+pixel_delta_v);
    }
	...
};

int main(){
    ...
    cam.vfov = 90;
    cam.lookfrom = point3 (-2,2,1);
    cam.lookat = point3 (0,0,1);
    cam.vup = vec3 (0,1,0);
	...
}

cam.vfov = 20;

//vec3.h
inline vec3 random_in_unit_disk(){
    while (true){
        auto p = vec3(random_double(-1,1),random_double(-1,1),0);
        if(p.length_squared() < 1)
            return p;
    }
}

class camera{
public:
    double aspect_ratio = 1.0;      //图像的宽高比
    int    image_width = 100;       //图像宽度的像素数
    int    samples_per_pixel = 10;  //每个像素的采样次数
    int    max_depth = 10;          //光线追踪的最大递归深度

    double vfov = 90;               //垂直视角（视场）
    point3 lookfrom = point3 (0,0,0);   //相机位置
    point3 lookat = point3 (0,0,-1);    //观察点
    vec3   vup = vec3(0,1,0);           //相机相对向上的位置

    double defocus_angle = 0;       //锥角
    double focus_dist = 0;          //从相机中心到焦点平面中心的距离
	...
private:
    int image_height;           //渲染图像的高度
    double pixel_samples_scale; //每次采样的颜色权重
    point3 camera_center;       //相机的中心
    point3 pixel00_loc;         //像素(0,0)的位置
    vec3 pixel_delta_u;         //向右的偏移值
    vec3 pixel_delta_v;         //向下的偏移值
    vec3 u,v,w;                 //相机的相对坐标系
    vec3 defocus_disk_u;        //散焦圆盘水平向量
    vec3 defocus_disk_v;        //散焦圆盘垂直向量

    void initialize(){
        image_height = int(image_width/aspect_ratio);
        image_height = (image_height < 1) ? 1 : image_height;

        pixel_samples_scale = 1.0 / samples_per_pixel;

        camera_center = lookfrom;

        //确认视窗的设置
//        auto focal_length = (lookfrom - lookat).length();    //焦距设置
        auto theta = degree_to_radius(vfov);
        auto h = std::tan(theta/2);
        auto viewport_height = 2*h*focus_dist;   //确保视口和焦点平面重合
        auto viewport_width = viewport_height*(double (image_width)/image_height);

        //计算摄像机的相对基底
        w = unit_vector(lookfrom-lookat);
        u = unit_vector(cross(vup,w));
        v = cross(w,u);

        //视图边缘的向量计算
        auto viewport_u = viewport_width * u;
        auto viewport_v = viewport_height * -v;
        //计算视图的像素间的水平竖直增量
        pixel_delta_u = viewport_u/image_width;
        pixel_delta_v = viewport_v/image_height;

        //计算左上角第一个像素中心的坐标
        auto viewport_upper_left = camera_center - (focus_dist * w) - viewport_v/2 - viewport_u/2;
        pixel00_loc = viewport_upper_left + 0.5*(pixel_delta_u+pixel_delta_v);

        //计算相机散焦圆盘的基向量
        auto defocus_radius = focus_dist * std::tan(degree_to_radius(defocus_angle/2));
        defocus_disk_u = u*defocus_radius;
        defocus_disk_v = v*defocus_radius;
    }

    ray get_ray(int i,int j){
       //构造一个从散焦圆盘开始的随机采样射线，指向(i,j)像素周围的采样点

       auto offset = sample_square();
       auto pixel_sample = pixel00_loc + ((i+offset.x())*pixel_delta_u) + ((j+offset.y())*pixel_delta_v);

       auto ray_origin = (defocus_angle <= 0) ? camera_center :defocus_disk_sample();
       auto ray_direction = pixel_sample - ray_origin;

       return ray(ray_origin,ray_direction);
    }
	...
    point3 defocus_disk_sample() const {
        // 返回散焦盘的上的随机点
        auto p = random_in_unit_disk();
        return camera_center + (p[0]*defocus_disk_u) + (p[1]*defocus_disk_v);
    }
	...
};

R = R_parallel + R_vertical
后续简写成:
R = R_p + R_v

R_p = (R*n)*n 	//这里的n已经单位化了，所以不用除|n|，直接*n即可
R_v = R - R_p = R - (R*n)*n
R*n = -cos(theta0)
R_v0 = eta/eta0 * (R + cos(theta)*n)

R_p0 = -sqrt(1 - |R_v0|)*n
//最终合并得到R0
R_v0 = eta/eta0 * (R + (-R*n)*n)	//这里替换掉cos方便计算
R0 = R_p0 + R_v0

//vec3.h
inline vec3 refract(const vec3& uv,const vec3& n,double etai_over_etat){
    auto cos_theta = std::fmin(dot(-uv,n),1.0);
    vec3 r_out_perp = etai_over_etat * (uv + cos_theta*n);
    vec3 r_out_parallel = -std::sqrt(std::fabs(1.0-r_out_perp.length_squared()))*n;
    return r_out_perp + r_out_parallel;
}

class dielectric : public material{
public:
    dielectric(double refraction_index) : refraction_index(refraction_index) {}

    bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override {
        attenuation = color(1.0,1.0,1.0);
        double ri = rec.front_face ? (1.0/refraction_index) : refraction_index;
        
        vec3 unit_direction = unit_vector(r_in.direction());
        vec3 refracted = refract(unit_direction,refracted,ri);
        
        scattered = ray(rec.p,refracted);
        return true;
    }
private:
    double refraction_index;    //在真空中的折射率，或者材料的折射比例
};

int main(){
    ...
    auto material_ground = make_shared<lambertian>(color(0.8, 0.8, 0.0));
    auto material_center = make_shared<lambertian>(color(0.1, 0.2, 0.5));
    auto material_left   = make_shared<metal>(color(0.8, 0.8, 0.8),0.3);
    auto material_right  = make_shared<metal>(color(0.8, 0.6, 0.2),0.0);
    auto material_front = make_shared<dielectric>(1.50);

    world.add(make_shared<sphere>(point3( 0.0, -100.5, -1.0), 100.0, material_ground));
    world.add(make_shared<sphere>(point3( 0.0, 0.0, -1.5),   0.5, material_center));
    world.add(make_shared<sphere>(point3(-1.0, 0.0, -1.0),   0.5, material_left));
    world.add(make_shared<sphere>(point3( 1.0, -0.3, -1.0),   0.2, material_right));
    world.add(make_shared<sphere>(point3(0.0,-0.2,-1.0),0.3,material_front));
	...
}

class dielectric : public material{
public:
    dielectric(double refraction_index) : refraction_index(refraction_index) {}

    bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override {
        attenuation = color(1.0,1.0,1.0);
        double ri = rec.front_face ? (1.0/refraction_index) : refraction_index;

        vec3 unit_direction = unit_vector(r_in.direction());
        double cos_theta = std::fmin(dot(-unit_direction,rec.normal),1.0);
        double sin_theta = std::sqrt(1.0 - cos_theta*cos_theta);

        bool cannot_refract = ri * sin_theta > 1.0;
        vec3 direction;

        //如果发生折射,还要根据Schlick近似,判断是否反射，如果反射率大于随机值则反射
        if(cannot_refract || reflectance(cos_theta,ri) > random_double())
            direction = reflect(unit_direction,rec.normal);
        else
            direction = refract(unit_direction,rec.normal,ri);

        scattered = ray(rec.p,direction);
        return true;
    }
private:
    double refraction_index;    //在真空中的折射率，或者材料的折射比例

    static double reflectance(double cosine,double refraction_index){
        //使用Schlick近似计算反射率
        auto r0 = (1 - refraction_index) / (1 + refraction_index);
        r0 = r0*r0;
        return r0 + (1-r0)*std::pow((1 - cosine),5);
    }
};

int main(){
    ...
    auto material_ground = make_shared<lambertian>(color(0.8, 0.8, 0.0));
    auto material_center = make_shared<lambertian>(color(0.1, 0.2, 0.5));
    auto material_left   = make_shared<dielectric>(1.50);
    auto material_right  = make_shared<metal>(color(0.8, 0.6, 0.2),0.0);
    auto material_bubble = make_shared<dielectric>(1.00/1.50);

    world.add(make_shared<sphere>(point3( 0.0, -100.5, -1.0), 100.0, material_ground));
    world.add(make_shared<sphere>(point3( 0.0, 0.0, -1.0),   0.5, material_center));
    world.add(make_shared<sphere>(point3(-1.0, 0.0, -1.0),   0.5, material_left));
    world.add(make_shared<sphere>(point3( 1.0, 0.0, -1.0),   0.5, material_right));
    world.add(make_shared<sphere>(point3(-1.0, 0.0, -1.0),   0.4, material_bubble));
	...
}

#ifndef RENDER_C___MATERIAL_H
#define RENDER_C___MATERIAL_H

#include "hittable.h"

class material{
public:
    virtual ~material() = default;
    
    virtual bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const{
        return false;
    }
};

#endif //RENDER_C___MATERIAL_H

class material;

class hit_record{
public:
    point3 p;
    vec3 normal;
    shared_ptr<material> mat;	//附带了击中材料的材质的信息
    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:
    sphere(const point3& center, double radius) : center(center), radius(std::fmax(0,radius)) {
        
    }

    bool hit(const ray& r,interval ray_t,hit_record& rec) const override{
        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 false;
        }

        //解t并进行判断
        auto sqrtd = std::sqrt(discriminant);
        auto root = (h - sqrtd) / a;
        if(!ray_t.surrounds(root)){
            root = (h + sqrtd) / a;
            if(!ray_t.surrounds(root))
                return false;
        }

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

        return true;
    }

private:
    point3 center;
    double radius;
    shared_ptr<material> mat;
};

class lambertian: public material{
public:
    lambertian(const color& albedo) : albedo(albedo) {}

    bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override{
        auto scatter_direction = rec.normal + random_unit_vector();
        scattered = ray(rec.p,scatter_direction);
        attenuation = albedo;
        return true;
    }
private:
    color albedo;
};

bool near_zero() const {
    //判断各个分量是不是趋近于0
    auto s = 1e-8;
    return (std::fabs(e[0]) < s) && (std::fabs(e[1]) < s) && (std::fabs(e[2]) < s);
}

bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override{
    auto scatter_direction = rec.normal + random_unit_vector();
    
    //拦截危险向量
    if(scatter_direction.near_zero())
        scatter_direction = rec.normal;
    
    scattered = ray(rec.p,scatter_direction);
    attenuation = albedo;
    return true;
}

//vec3.h
inline vec3 reflect(const vec3& v, const vec3& n){
    //点积是v在n上的投影长度，即b的长度,*-2n则是为了校准方向
    return v - 2* dot(v,n)*n;
}

class metal: public material{
public:
    metal(const color& albedo) : albedo(albedo){}

    bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override{
        vec3 reflected = reflect(r_in.direction(),rec.normal);
        scattered = ray(rec.p,reflected);
        attenuation = albedo;
        return true;
    }
private:
    color albedo;
};

color ray_color(const ray& r,int depth, const hittable& world) const {
        //如果不进行光线的追踪，就不会光线返回
        if(depth <= 0)
            return {0,0,0};

        hit_record rec;

        if (world.hit(r, interval(0.001, infinity), rec)) {
            ray scattered;
            color attenuation;
            if(rec.mat->scatter(r,rec,attenuation,scattered))
                return attenuation* ray_color(scattered,depth-1,world);
            return {0,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);
    }

class sphere : public hittable {
  public:    sphere(const point3& center, double radius, shared_ptr<material> mat)
      : center(center), radius(std::fmax(0,radius)), mat(mat) {}
    ...
};

int main(){
    hittable_list world;

    auto material_ground = make_shared<lambertian>(color(0.8, 0.8, 0.0));
    auto material_center = make_shared<lambertian>(color(0.1, 0.2, 0.5));
    auto material_left   = make_shared<metal>(color(0.8, 0.8, 0.8));
    auto material_right  = make_shared<metal>(color(0.8, 0.6, 0.2));

    world.add(make_shared<sphere>(point3( 0.0, -100.5, -1.0), 100.0, material_ground));
    world.add(make_shared<sphere>(point3( 0.0,    0.0, -1.5),   0.5, material_center));
    world.add(make_shared<sphere>(point3(-1.0,    0.0, -1.0),   0.5, material_left));
    world.add(make_shared<sphere>(point3( 1.0,    -0.3, -1.0),   0.2, material_right));
	...
    cam.render(world);
}

class metal: public material{
public:
    metal(const color& albedo) : albedo(albedo){}

    bool scatter(const ray& r_in,hit_record& rec,color& attenuation, ray& scattered) const override{
        vec3 reflected = reflect(r_in.direction(),rec.normal);
        reflected = unit_vector(reflected) + (fuzz*random_unit_vector());
        scattered = ray(rec.p,reflected);
        attenuation = albedo;
        return (dot(scattered.direction(),rec.normal) > 0);
    }
private:
    color albedo;
    double fuzz;
};

int main(){
	...
    world.add(make_shared<sphere>(point3( 0.0, -100.5, -1.0), 100.0, material_ground));
    world.add(make_shared<sphere>(point3( 0.0,    0.0, -1.5),   0.5, material_center));
    world.add(make_shared<sphere>(point3(-1.0,    0.0, -1.0),   0.5, material_left));
    world.add(make_shared<sphere>(point3( 1.0,    -0.3, -1.0),   0.2, material_right));
	...
}

//vec3.h
inline vec3 random_unit_vector(){
    while(true){
        auto p = vec3::random(-1,1);
        auto lensq = p.length_squared();
        if(lensq <= 1){
            return p/ sqrt(lensq);
        }
    }
}

//vec3.h
inline vec3 random_on_hemisphere(const vec3& normal){
    vec3 on_unit_sphere = random_unit_vector();
    if (dot(on_unit_sphere,normal) > 0.0)
        return on_unit_sphere;
    else
        return -on_unit_sphere;
}

color ray_color(const ray& r, const hittable& world) const {
        hit_record rec;

        if (world.hit(r, interval(0, infinity), rec)) {
            vec3 direction = random_on_hemisphere(rec.normal);
            return 0.5 * ray_color(ray(rec.p, direction), world);
        }

        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);
    }

class camera{
public:
    double aspect_radio = 1.0;      //图像的宽高比
    int    image_width = 100;       //图像宽度的像素数
    int    samples_per_pixel = 10;  //每个像素的采样次数
    int    max_depth = 10;          //光线追踪的最大递归深度

    void render(const hittable& world){
        initialize();

        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++){
                color pixel_color(0,0,0);
                for(int sample = 0;sample < samples_per_pixel; sample++){
                    ray r = get_ray(i,j);
                    pixel_color += ray_color(r,max_depth,world);
                }
                write_color(std::cout,pixel_color*pixel_samples_scale);
            }
        }
        std::clog << "\rDone.                   \n";
    }
	...
private:
	...

    color ray_color(const ray& r,int depth, const hittable& world) const {
        //如果不进行光线的追踪，就不会光线返回
        if(depth <= 0)
            return {0,0,0};

        hit_record rec;

        if (world.hit(r, interval(0, infinity), rec)) {
            vec3 direction = random_on_hemisphere(rec.normal);
            return 0.5 * ray_color(ray(rec.p, direction), depth - 1,world);
        }

        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(){
 	...
    cam.aspect_radio = 16.0/9.0;
    cam.image_width = 800;
    cam.samples_per_pixel = 100;
    cam.max_depth = 50;

    cam.render(world);
}

color ray_color(const ray& r,int depth, const hittable& world) const {
       //如果不进行光线的追踪，就不会光线返回
       if(depth <= 0)
           return {0,0,0};

       hit_record rec;

       if (world.hit(r, interval(0.001, infinity), rec)) {
           vec3 direction = random_on_hemisphere(rec.normal);
           return 0.5 * ray_color(ray(rec.p, direction), depth - 1,world);
       }

       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);
   }

color ray_color(const ray& r,int depth, const hittable& world) const {
        //如果不进行光线的追踪，就不会光线返回
        if(depth <= 0)
            return {0,0,0};

        hit_record rec;

        if (world.hit(r, interval(0.001, infinity), rec)) {
            //我们只需要在这里添加一个法向量即可
            vec3 direction = rec.normal + random_on_hemisphere(rec.normal);
            return 0.5 * ray_color(ray(rec.p, direction), depth - 1,world);
        }

        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);
    }

inline double linear_to_gamma(double linear_component){
    if(linear_component >0)
        return std::sqrt(linear_component);
    return 0;
}

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();

    //从线性空间到伽马空间的转换
    r = linear_to_gamma(r);
    g = linear_to_gamma(g);
    b = linear_to_gamma(b);

    //使用区间RGB[0,1]计算RGB值
    static const interval intensity(0.000,0.999);
    int rbyte = int (256*intensity.clamp(r));
    int gbyte = int (256*intensity.clamp(g));
    int bbyte = int (256*intensity.clamp(b));

    out << rbyte << ' ' << gbyte << ' ' << bbyte << '\n';
}