2 - 一个周末搞定光追 Part2

发表于 2024-08-14 更新于 2025-06-19 分类于 C - 图形学， 02 - 软光追阅读次数： Waline：本文字数： 19k 阅读时长 ≈ 16 分钟

开始学习大名鼎鼎的光追三部曲系列中的：Ray Tracing in One Weekend！希望我能坚持下去吧。

抗锯齿

如果继续放大图片，会发现锯齿状的瑕疵影响观感，因此需要进行抗锯齿操作。我们需要采样光打到像素中心的周围几格像素，然后整合到像素中心。

随机数生成工具

在 C++11 之前，可以使用 std::rand() 函数生成随机数：

   
inline double random_double()
{
	return std::rand() / (RAND_MAX + 1.0);
}

inline double random_double(double min, double max)
{
	return min + (max - min) * random_double();
}

前者生成 [0,1) 内的随机实数，后者生成 [min, max) 内的随机实数。

C++11 提供随机数生成库 <ramdom>，用它可以生成标准的随机数：

   
inline double random_double()
{
	static std::uniform_real_distribution<double> distribution(0.0, 1.0);
	static std::mt19937 generator;
	return distribution(generator);
}

这些函数将被写入 rtweekend.h 的工具函数中。

生成多重采样的像素

我们将通过随机采样像素周围的几个像素取均值，生成具有多重采样的像素。

首先，需要更新 write_color() 以考虑我们以后的更改，这里写入的颜色将是随机采样后的均值，范围可能会超，因此要限制到 [0, 1]。

在 Interval 类中添加帮手函数 clamp() 如下：

   
double clamp(double x) const
{
	if (x < min) return min;
	if (x > max) return max;
	return x;
}

在 write_color() 中添加 Interval 类实例，然后应用 clamp() 方法：

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

    // 将属于[0, 1]的RGB分量变换到[0, 255]上
    static const Interval intensity(0.000, 0.999);
    int rByte = static_cast<int>(256 * intensity.clamp(r));
    int gByte = static_cast<int>(256 * intensity.clamp(g));
    int bByte = static_cast<int>(256 * intensity.clamp(b));

    // 写到输出流out中
    out << rByte << ' ' << gByte << ' ' << bByte << '\n';
}

然后需要更新 Camera 类，定义一个新函数 get_ray(i, j)，它将为每个像素生成不同的采样，并通过帮手函数 sample_square() 去进行采样工作。修改后的 Camera 类如下：

   
#pragma once

#include "../rtweekend.h"
#include "../ray/hittable.hpp"

class Camera
{
public:
	...
	int samples_per_pixel = 10;			// 每像素采样数, 即SPP
	
    ...
	void render(const Hittable& world)
	{
		std::cout << std::format("P3\n{} {}\n255\n", imgWidth, imgHeight);
		for (int j = 0; j < imgHeight; ++j)
		{
			for (int i = 0; i < imgWidth; ++i)
			{
				Color final_pixel_color(0, 0, 0);
				for (int sampleCnt = 0; sampleCnt < samples_per_pixel; ++sampleCnt)
				{
					Ray r = get_ray(i, j);
					final_pixel_color += ray_color(r, world);
				}
				writeColor(std::cout, pixel_sample_scale * final_pixel_color);
			}
		}
	}

private:
	...
	double pixel_sample_scale;			// spp / 1
	...

	void initialize()
	{
		...
		pixel_sample_scale = 1.0 / samples_per_pixel;
		...
	}

	// 随机生成一条从摄像机原点出发, 到达像素(i,j)周围的光线
	Ray get_ray(int i, int j) const
	{
		Vec3 offset = sample_square();
		Point3 pixel_sample = pixel00_pos + ((i + offset.x()) * pixel_delta_u) + ((j + offset.y()) * pixel_delta_v);

		Point3 ray_origin = center;
		Vec3 ray_direction = pixel_sample - ray_origin;

		return Ray(ray_origin, ray_direction);
	}

	// 返回位于[-.5,-.5]-[+.5,+.5]间的随机2D偏移量
	Vec3 sample_square() const
	{
		return Vec3(random_double() - 0.5, random_double() - 0.5, 0);
	}

	Color ray_color(const Ray& r, const Hittable& world) const {...}
};

看看抗锯齿前后对比：

漫反射材质

接下来可以创建一些现实中的材质了，我们将从漫反射材质开始。

简单漫反射模型

对于漫反射材质的物体，反射光线的方向是随机的，例如向两个漫反射表面发射三束光可能会发生如下反射：

实际上，光线还可能被吸收而不是反射。表面越暗，光越有可能被吸收。这里准备一个简单的漫反射模型，光线反射至各角度的可能性均等：

接下来在 Vec3 类中添加一些生成随机向量的工具方法：

   
// 生成随机数
static Vec3 random()
{
	return Vec3(random_double(), random_double(), random_double());
}

static Vec3 random(double min, double max)
{
	return Vec3(random_double(min, max), random_double(min, max), random_double(min, max));
}

然后我们需要知道如何只让反射光线反射到表面以上半球区域。这里采用简单的 “拒绝” 方法，只需重复随机生成采样，拒绝到不符要求的采样，直到生成的采样符合要求。其中最简单的方法就是：

在单位球里随机生成一个向量；
标准化这个向量；
如果这个向量朝向错误的半球，反转它即可。

根据这个方法，我们在单位立方体里随机生成一个向量，如果向量在单位球外就抛弃：

在 Vec3 类中添加的工具函数如下：

   
inline Vec3 random_in_unit_sphere()
{
	while (true)
	{
		Vec3 p = Vec3::random(-1, 1);
		if (p.lengthSquared() < 1)
		{
			return p;
		}
	}
}

然后标准化这个向量：

在 Vec3 类中添加的工具函数如下：

   
inline Vec3 random_unit_vector()
{
	return unitVector(random_in_unit_sphere());
}

最后需要判断它的朝向是否正确，可以和表面法向量比较：

可以根据两向量点乘的结果判断朝向是否正确，在 Vec3 中添加工具函数如下：

   
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;
	}
	return -on_unit_sphere;
}

如果光线击中一个材质反弹后能保留 100% 的颜色，那么这个光就是白色的。如果不保留它本身的颜色，那么就是黑色的。这里我们保留 50% 的颜色，修改 ray_color：

   
Color ray_color(const Ray& r, const Hittable& world) const
{
    // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv 和光线相交物体 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    HitRecord rec;
    if (world.hit(r, Interval(0, infinity), rec))
    {
        // 生成随机反射方向
        Vec3 direction = random_on_hemisphere(rec.normal);
        // 开始下一轮反射
        return 0.5 * ray_color(Ray(rec.position, direction), world);
    }
    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 和光线相交物体 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv 背景 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    Vec3 dir = r.direction();
    // a in [-1, 1] -> a in [0, 1]
    double a = 0.5 * (dir.y() + 1.0);
    // 线性混合
    return (1.0 - a) * Color(1.0, 1.0, 1.0) + a * Color(0.5, 0.7, 1.0);
    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 背景 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}

效果如下：

限制子光线的数量

在 ray_color() 中我们还没设置递归退出条件，这将导致程序运行时间过长。于是修改 Camera 类，添加递归退出条件：

   
#pragma once

#include "../rtweekend.h"
#include "../ray/hittable.hpp"

class Camera
{
    public:
    double aspectRadio = 1.0;			// 图像的宽高比
    int imgWidth = 100;					// 图像宽度
    int samples_per_pixel = 10;			// 每像素采样数, 即SPP
    int max_depth = 10;					// 光线的最大弹射次数

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

        std::cout << std::format("P3\n{} {}\n255\n", imgWidth, imgHeight);
        for (int j = 0; j < imgHeight; ++j)
        {
            for (int i = 0; i < imgWidth; ++i)
            {
                Color final_pixel_color(0, 0, 0);
                for (int sampleCnt = 0; sampleCnt < samples_per_pixel; ++sampleCnt)
                {
                    Ray r = get_ray(i, j);
                    final_pixel_color += ray_color(r, max_depth, world);
                }
                writeColor(std::cout, pixel_sample_scale * final_pixel_color);
            }
        }
    }

    private:
    int imgHeight;						// 图像高度
    double pixel_sample_scale;			// spp / 1
    Point3 center;						// 相机位置
    Point3 pixel00_pos;					// 像素(0, 0)的位置
    Vec3 pixel_delta_u;					// 定位像素用的辅助向量
    Vec3 pixel_delta_v;

    void initialize()
    {
        imgHeight = static_cast<int>(imgWidth / aspectRadio);
        imgHeight = (imgHeight < 1) ? 1 : imgHeight;				// 确保高度至少为1

        center = Point3(0, 0, 0);

        pixel_sample_scale = 1.0 / samples_per_pixel;

        // 相机设定
        double focalLength = 1.0;									// 焦距

        // 视口设定
        double viewportHeight = 2.0;
        double viewportWidth = viewportHeight * static_cast<double>(imgWidth) / imgHeight;

        // 4个辅助向量
        Vec3 viewport_u = Vec3(viewportWidth, 0, 0);
        Vec3 viewport_v = Vec3(0, -viewportHeight, 0);
        pixel_delta_u = viewport_u / imgWidth;
        pixel_delta_v = viewport_v / imgHeight;

        // 计算第一个像素位置
        Point3 viewport_upper_left = center - Point3(0, 0, focalLength) - viewport_u / 2 - viewport_v / 2;
        pixel00_pos = viewport_upper_left + 0.5 * (pixel_delta_u + pixel_delta_v);
    }

    // 随机生成一条从摄像机原点出发, 到达像素(i,j)周围的光线
    Ray get_ray(int i, int j) const
    {
        Vec3 offset = sample_square();
        Point3 pixel_sample = pixel00_pos + ((i + offset.x()) * pixel_delta_u) + ((j + offset.y()) * pixel_delta_v);

        Point3 ray_origin = center;
        Vec3 ray_direction = pixel_sample - ray_origin;

        return Ray(ray_origin, ray_direction);
    }

    // 返回位于[-.5,-.5]-[+.5,+.5]间的随机2D偏移量
    Vec3 sample_square() const
    {
        return Vec3(random_double() - 0.5, random_double() - 0.5, 0);
    }

    Color ray_color(const Ray& r, int depth, const Hittable& world) const
    {
        // 递归退出
        if (depth <= 0)
        {
            return Color(0, 0, 0);
        }

        // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv 和光线相交物体 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
        HitRecord rec;
        if (world.hit(r, Interval(0, infinity), rec))
        {
            // 生成随机反射方向
            Vec3 direction = random_on_hemisphere(rec.normal);
            // 开始下一轮反射
            return 0.5 * ray_color(Ray(rec.position, direction), depth - 1, world);
        }
        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 和光线相交物体 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

        // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv 背景 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
        Vec3 dir = r.direction();
        // a in [-1, 1] -> a in [0, 1]
        double a = 0.5 * (dir.y() + 1.0);
        // 线性混合
        return (1.0 - a) * Color(1.0, 1.0, 1.0) + a * Color(0.5, 0.7, 1.0);
        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 背景 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    }
};

摄像机的参数设置如下：

   
cam.aspectRadio = 16.0 / 9.0;
cam.imgWidth = 400;
cam.samples_per_pixel = 100;
cam.max_depth = 50;

得到的结果如下：

修复阴影失真问题

由于浮点数运算存在误差，反弹光线的原点会出现偏移，使得球表面上也产生” 阴影 “。这里直接修改 ray_color()，限制光线打到物体的判断范围即可：

   
HitRecord rec;
if (world.hit(r, Interval(0.001, infinity), rec))
{
	// 生成随机反射方向
	Vec3 direction = random_on_hemisphere(rec.normal);
	// 开始下一轮反射
	return 0.5 * ray_color(Ray(rec.position, direction), depth - 1, world);
}

修复阴影失真（Shadow Acne）问题后的结果如下：

Lambertian 反射

接下来试试更准确的漫反射模型，Lambertian 分布模型。这个模型将反射光线以的比例散射，其中是反射光线和表面法线的夹角。也就是说反射光更容易朝靠近表面法线的方向散射，而不容易朝远离表面法线的方向散射，这种反射模型比之前的更现实。

我们可以通过在表面法向量处添加一个随机单位向量以创建该反射分布。对于着色点，着色点上的表面法向量，由于有内外表面区分，只有两个单位球和这个表面相切。这两个单位球一个放在方向，另一个放在方向。对于方向的球，球心是，也就是在外表面的球，如下图：

我们想要在这个单位球上取随机点，然后在方向上反射光线，修改 ray_color() 如下：

   
HitRecord rec;
if (world.hit(r, Interval(0.001, infinity), rec))
{
	// Lambert反射模型 (内外表面单位球均考虑)
	Vec3 direction = rec.normal + random_unit_vector();
	// 只考虑外表面单位球: Vec3 direction = rec.normal + random_on_hemisphere(rec.normal);
	// 开始下一轮反射
	return 0.5 * ray_color(Ray(rec.position, direction), depth - 1, world);
}

结果如下（右边是内外表面单位球均考虑）：

可以发现新反射模型更加强调阴影和天空的反射，看起来更舒服一些。

Gamma 校正

首先看看让光保留 10%，30%，50%，70%，90% 的结果：

可以发现中间 50% 的还是太暗了，这是因为几乎所有电脑程序都假设这张图已经被 Gamma 校正过了。没有经过变换的图片数据应该存在线性空间，经过变换的图片数据应该存在 Gamma 空间，这里直接把线性空间的数据当成 Gamma 空间的了，因此图片会偏暗。

接下来将图片的数据从线性空间变换到 Gamma 空间。这里使用”gamma 2“的逆变换，在 color.hpp 中添加相关工具函数，并修改 write_color()：

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

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

    // 将数据从线性空间变换到Gamma空间
    r = linear_to_gamma(r);
    g = linear_to_gamma(g);
    b = linear_to_gamma(b);

    // 将属于[0, 1]的RGB分量变换到[0, 255]上
    static const Interval intensity(0.000, 0.999);
    int rByte = static_cast<int>(256 * intensity.clamp(r));
    int gByte = static_cast<int>(256 * intensity.clamp(g));
    int bByte = static_cast<int>(256 * intensity.clamp(b));

    // 写到输出流out中
    out << rByte << ' ' << gByte << ' ' << bByte << '\n';
}

然后渲染一下，整体变亮了：

金属材质

接下来开始让物体拥有金属材质，不过在此之前先定义一个材质的抽象类，它需要完成以下两件事情：

产生一个散射光（或者说吸收了入射光）
如果发生散射，应说明有多少光被减弱。

抽象类 Material 如下：

   
#pragma once

#include "../rtweekend.h"

class HitRecord;

class Material
{
public:
	virtual ~Material() = default;

	virtual bool scatter(const Ray& r_in, const HitRecord& rec, Color& attenuation, Ray& scattered) const
	{
		return false;
	}
};

描述光线和物体求交的数据结构

就是我们之前写的 HitRecord 类，在这里添加 Material 类的声明，然后在 HitRecord 中添加材质类的共享智能指针：

   
// 不添加定义, 避免循环引用
class Material;

class HitRecord 
{
public:
	Point3 position;
	Vec3 normal;
	shared_ptr<Material> material;
	double t;
	bool front_face;

	
	void set_face_normal(const Ray& r, const Vec3& outward_normal) 
	{
		// 注意: 总认为outward_normal是单位向量
		front_face = dot(r.direction(), outward_normal) < 0.0;
		normal = front_face ? outward_normal : -outward_normal;
	}
};

当入射光线打到物体表面时，在 HitRecord 中的材质指针将获取并赋值为物体表面的材质，之后 ray_color() 会访问材质指针，调用 scatter() 方法以了解哪些光应该被散射。这需要我们在 Sphere 类中进行一些修改：

   
class Sphere : public Hittable
{
public:
	Sphere(const Point3& center, double radius)
		: center(center), radius(std::fmax(0, radius))
	{
		// TODO: 在这里初始化材质指针 material
	}

	bool hit(const Ray& r, Interval ray_t, HitRecord& rec) const override
	{
		...
		// 记录相交信息
		rec.t = root;
		rec.position = r.at(rec.t);
		Vec3 outward_normal = (rec.position - center) / radius;	// 利用定义简化法线计算
		rec.set_face_normal(r, outward_normal);
		rec.material = material;

		return true;
	}

private:
	Point3 center;
	double radius;
	shared_ptr<Material> material;
};

为光散射和反射建模

这里会用到 albedo 项（反照率）描述材质的反射率，它和材质颜色不一样，也能随入射光方向变化。

Lambertian 漫反射用的反射率散射并削弱部分光，也有可能以的概率不散射光。这里我们简单一点，让光总是被散射。实现 Lambertian 材质类如下：

   
#pragma once

#include "material.hpp"

class Lambertian : public Material
{
public:
	Lambertian(const Color& albedo) : albedo(albedo) {}

	bool scatter(const Ray& r_in, const HitRecord& rec, Color& attenuation, Ray& scattered) const override
	{
		// Lambert反射模型 (内外表面单位球均考虑)
		Vec3 scatter_direction = rec.normal + random_unit_vector();
		// 只考虑外表面单位球: Vec3 direction = rec.normal + random_on_hemisphere(rec.normal);
		scattered = Ray(rec.position, scatter_direction);
		attenuation = albedo;
		return true;
	}

private:
	Color albedo;
};

实际上也能以的概率散射一些光，那么 attenuation 就得是。

考虑刚刚写的 scatter_direction，发现结果有概率为 0 向量（随机生成了一个 -rec.normal），出现边界问题，我们还得处理它。在 Vec3 类中添加如下方法：

   
bool near_zero() const
{
	// 如果该向量很接近0就返回true
	double s = 1e-8;
	return ((std::fabs(e[0]) < s) && (std::fabs(e[1]) < s) && (std::fabs(e[2]) < s));
}

然后改一下 Lambertian 类：

   
bool scatter(const Ray& r_in, const HitRecord& rec, Color& attenuation, Ray& scattered) const override
{
	// Lambert反射模型 (内外表面单位球均考虑)
	Vec3 scatter_direction = rec.normal + random_unit_vector();
	// 只考虑外表面单位球: Vec3 direction = rec.normal + random_on_hemisphere(rec.normal);

	// 处理边界问题
	if (scatter_direction.near_zero())
	{
		scatter_direction = rec.normal;
	}

	scattered = Ray(rec.position, scatter_direction);
	attenuation = albedo;
	return true;
}

镜面光反射

对于金属材质，它不会发生漫反射，而会发生如下图所示的镜面反射：

可以发现反射光的方向就是。其中，是单位向量，而不一定是。为了得到向量，需要将投影到上，也就是（不是单位向量还要除以它的长度），最后取反方向即可。在 Vec3 类中添加如下函数：

   
// 返回入射方向v,单位向量n的镜面反射向量
inline Vec3 reflect(const Vec3& v, const Vec3& n)
{
	// 点乘结果是大小, 因此还要乘个向量n
	return v - 2 * dot(v, n) * n;
}

然后就能再新建一个 Metal 材质类了：

   
#pragma once

#include "material.hpp"

class Metal : public Material
{
public:
	Metal(const Color& albedo) : albedo(albedo) {}

	bool scatter(const Ray& r_in, const HitRecord& rec, Color& attenuation, Ray& scattered) const
	{
		Vec3 reflected_direction = reflect(r_in.direction(), rec.normal);
		scattered = Ray(rec.position, reflected_direction);
		attenuation = albedo;
		return true;
	}

private:
	Color albedo;
};

最后修改 ray_color()，以适配我们刚刚写的类：

   
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv 和光线相交物体 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
HitRecord rec;
if (world.hit(r, Interval(0.001, infinity), rec))
{
	Ray scattered;
	Color attenuation;
	if (rec.material->scatter(r, rec, attenuation, scattered))
	{
		return attenuation * ray_color(scattered, depth - 1, world);
	}
	return Color(0, 0, 0);
}
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 和光线相交物体 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

别忘了 Sphere 类中的 TODO：

Sphere(const Point3& center, double radius, shared_ptr<Material> material)
    : center(center), radius(std::fmax(0, radius)), material(material) {}

添加金属球

终于能在场景里添加金属球了：

   
// main.cpp
// 材质设定
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));

// 场景设定
HittableList world;
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.2), 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));

最终结果如下：

模糊反射

也能随机镜面反射的方向从而达到模糊反射的效果，在反射方向向量的末端生成一个以 fuzz 为半径的球，将球面上随机一点作为新的模糊反射方向。如下图：

fuzz 越大，最终反射结果就越模糊。此外：

反射光线须是单位向量，这样才有意义。
还有反射至物体内表面的可能，这时我们直接认为这束光被物体吸收了即可。

修改 Metal 类，让它支持模糊反射：

   
class Metal : public Material
{
public:
	Metal(const Color& albedo, double fuzz) : albedo(albedo), fuzz(fuzz < 1 ? fuzz : 1) {}

	bool scatter(const Ray& r_in, const HitRecord& rec, Color& attenuation, Ray& scattered) const
	{
		Vec3 reflected_direction = reflect(r_in.direction(), rec.normal);
		reflected_direction = unitVector(reflected_direction) + (fuzz * random_unit_vector());
		scattered = Ray(rec.position, reflected_direction);
		attenuation = albedo;
		return (dot(scattered.direction(), rec.normal) > 0);
	}

private:
	Color albedo;
	double fuzz;
};

然后将左边球的模糊度调成 0.3，右边调成 1 看看：

介质材质

像水、玻璃、钻石等透明材质统称为介质（dielectrics）。当光打到它们，会产生反射和折射光线，我们将会随机处理这两种光线，在着色点只产生一条反射 / 折射光线。折射光线的量取决于折射率。例如玻璃的折射率通常是 1.5~1.7，钻石约 2.4，空气为 1.000293。

计算折射光

折射可由斯涅尔定律（Snell’s Law）描述：

为了决定折射光的方向，需要计算出：在折射面有折射光线，法线以及折射角。可以将折射光线分解为平行法线的和垂直法线的两个分量：两个分量的计算方式如下：如果我们限制入射光线和入射表面法向量是单位向量，那么有那么就能重写成：知道如何计算折射光后，就能开始写代码了。在 Vec3 类中添加如下工具函数：

   
// 利用斯涅尔定律计算反射光线
inline Vec3 refract(const Vec3& v, const Vec3& n, double etaI_div_etaR)
{
	double cos_theta = std::fmin(dot(-v, n), 1.0);
	Vec3 r_out_perp = etaI_div_etaR * (v + cos_theta * n);
	Vec3 r_out_parallel = -std::sqrt(std::fabs(1.0 - r_out_perp.lengthSquared())) * n;
	return r_out_perp + r_out_parallel;
}

然后就能新建 Dielectric 材质类了：

   
#pragma once

#include "material.hpp"

class Dielectric : public Material
{
public:
	Dielectric(double refraction_index) : refraction_index(refraction_index) {}

	bool scatter(const Ray& r_in, const HitRecord& 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 = unitVector(r_in.direction());
		Vec3 refracted = refract(unit_direction, rec.normal, ri);

		scattered = Ray(rec.position, refracted);
		return true;
	}

private:
	double refraction_index;
};

然后修改左边的球为玻璃材质的，看看效果：

全反射

当入射光线角度超过临界角时会发生全反射（Total Internal Reflection），可以根据斯涅尔定律判断发生全反射的条件：

   
if (ri * sin_theta > 1.0)
{
    // 必须全反射
}
else
{
    // 可以折射
}

可以通过三角学公式计算 sin_theta：其中接下来在 Dielectric 类中应用有关全反射的修改：

   
bool scatter(const Ray& r_in, const HitRecord& 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 = unitVector(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;
    if (cannot_refract)
    {
        direction = reflect(unit_direction, rec.normal);
    }
    else
    {
        direction = refract(unit_direction, rec.normal, ri);
    }

    scattered = Ray(rec.position, direction);
    return true;
}

为了体现出全反射的效果，在这里将世界的介质视为水（反射率 1.33），球的材质视为空气（反射率 1），那么初始化的反射率就是 1.00 / 1.33。最终成果如下：

可以发现这个空气泡泡有时候反射，有时候折射。

菲涅尔？Schlick！

为了让介质材质的结果变得更真实，引入菲涅尔方程，它描述了光线经过两个介质的界面时，反射和透射的光强比重。但菲涅尔方程计算十分复杂，这里使用 Schlick 近似来近似计算菲涅尔方程。

   
bool scatter(const Ray& r_in, const HitRecord& 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 = unitVector(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;
    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.position, direction);
    return true;
}

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

最后修改左边的球，让它成为中空玻璃球（往里面再套一个玻璃球）：

   
// 材质设定
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_bubble = make_shared<Dielectric>(1.00 / 1.50);
auto material_right = make_shared<Metal>(Color(0.8, 0.6, 0.2), 1.0);

// 场景设定
HittableList world;
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.2), 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.4, material_bubble));
world.add(make_shared<Sphere>(Point3(1.0, 0.0, -1.0), 0.5, material_right));

结果如下：

参考资料

Ray Tracing in One Weekend