二：点、向量、颜色

既然是光追，肯定离不开点和方向于颜色，在大多数工程中，颜色和方向是四维的向量，但是对于这个工程，三位向量可以满足需求，我们定义一个类来表示它们：

//防止被重复引用，用ifndef去包裹所有代码。
#ifndef VEC3_H
#define VEC3_H

//需要一些cmath类里面的数学函数
#include <cmath>

#include <iostream>

//精确引用，只需要开方函数就只引入最小的命名空间
using std::sqrt;

class vec3 {
    public:
    	// 空构造，默认构造一个（0，0，0）向量
        vec3() : e{0,0,0} {}
    
    	// 传入三个参数的构造。
        vec3(double e0, double e1, double e2) : e{e0, e1, e2} {}
		
    	//定义x，y，z分量。这样就可以用 向量.x() 直接拿取x分量。
        double x() const { return e[0]; }
        double y() const { return e[1]; }
        double z() const { return e[2]; }

    	//下面进行运算符重载。
    
    	//单目 '-' 运算符 ，会对三维向量的每一维取反。
        vec3 operator-() const { return vec3(-e[0], -e[1], -e[2]); }
    
    	// '[]' 运算符的const版本，返回右值。
    	double operator[](int i) const { return e[i]; }
    
    	// '[]' 运算符普通版本，返回左值
        double& operator[](int i) { return e[i]; }

    	// '+='运算符，const保护参数不被修改，返回引用允许操作符嵌套。
        vec3& operator+=(const vec3 &v) {
            e[0] += v.e[0];
            e[1] += v.e[1];
            e[2] += v.e[2];
            return *this;
        }
		
    	// '*='运算符
        vec3& operator*=(const double t) {
            e[0] *= t;
            e[1] *= t;
            e[2] *= t;
            return *this;
        }

    	// '/='运算符，直接使用*=去定义'/='。
        vec3& operator/=(const 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 sqrt(length_squared());
        }

    public:
    	// 向量中的数组也直接暴露出去了，这里是float也没问题，看你的喜好。
        double e[3];
};

// 给vec3类多起几个名字。
using point3 = vec3;   // 3D point，在指定三维空间中的点的时候使用这种别名。
using color = vec3;    // RGB color，在指定颜色的时候使用这种别名。

#endif

类外补充

接下来是一些加减乘除等操作，其中的有些操作并不可以写在类内，比如double类型*vec3类型，所以统一写在类外：

// vec3 类外函数

//重载输出流符号"<<"
inline std::ostream& operator<<(std::ostream &out, const vec3 &v) { 
    //当用户使用 cout << vec3的时候，输出vec3中的各个分量值。
    return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
}
//重载+运算符，它的返回值不是引用，这很合理，我们永远不会把 “a + b”这样的东西放在赋值符号左侧
inline vec3 operator+(const vec3 &u, const vec3 &v) {
    return vec3(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 vec3(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 vec3(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 vec3(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/(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 vec3(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 unit_vector(vec3 v) {
    return v / v.length();
}

抽离与简化

在第一章时，有三行将0-1的通道映射到0-255的代码，这部分代码是固定的，可以统一将它们抽离出去，创建、color.h文件，以后的关于渲染颜色的代码统一放到这里：

#ifndef COLOR_H
#define COLOR_H

#include "vec3.h"

#include <iostream>

//一个全局的函数，接受一个输出流参数，和一个color参数
void write_color(std::ostream &out, color pixel_color) {
	//把之前的代码两步并作一步，直接转到[0,255]区间然后直接输出出去。
    out << static_cast<int>(255.999 * pixel_color.x()) << ' '
        << static_cast<int>(255.999 * pixel_color.y()) << ' '
        << static_cast<int>(255.999 * pixel_color.z()) << '\n';
}

#endif

接下来main函数的代码将相当简洁：

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

#include <iostream>

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

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

    for (int j = image_height-1; j >= 0; --j) {
        std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
        for (int i = 0; i < image_width; ++i) {
           
            //直接调用vec3类有参构造构造一个对象
            color pixel_color(double(i)/(image_width-1), double(j)/(image_height-1), 0.25);
            
            //写颜色！如此的简单！
            write_color(std::cout, pixel_color);
        }
    }

    std::cerr << "\nDone.\n";
}

参考文献

https://raytracing.github.io/books/RayTracingInOneWeekend.html

参考自《RayTracingInOneWeekend》第3节