一文带你速通GPU光线追踪渲染
原文出处：一文带你速通GPU光线追踪渲染
丨 导语 基于实践，带你半小时手写一个GPU加速的光线追踪渲染器。核显也能高达 200 帧。
1 前言
本文教你使用 Python 来从零开始、一步一步地实现一个基于物理 (Physically Based Rendering, PBR) 的光线追踪渲染器，然后用它构建一个场景，渲染出有真实感的画面。本文也会尽可能的用更多的自然语言、图和公式讲解其中的物理和数学原理。
本文基于笔者的项目 https://github.com/HK-SHAO/RayTracingPBR
1.1 什么是并行计算
当前许多计算密集型任务（例如图像渲染、物理仿真和人工智能等任务）高度依托于并行数值计算。这些任务大多可以被分解为可以被并行处理的最简单的数学运算，通常我们会把它们交给多核心的 CPU 或 GPU 来进行处理，利用多核来加速任务效率。
如何区分 CPU 和 GPU 的计算能力？形象点来说，CPU 的若干个大核心就像是几个“博士生”为你处理复杂任务，而 GPU 就像是有成百上千个“小学生”（英伟达的 4090 GPU 拥有超过一万个 CUDA 核心）为你同时处理任务。所以通常，我们会使用 GPU 来加速并行计算。
GPU 拥有大量处理单元，可以同时处理大量任务
1.2 并行离我们远吗
并不远！并行计算时时刻刻都在发生，包括我们每天在看的视频、玩的游戏都需要经过大量并行计算。而多媒体创作本身，例如我们在使用相机拍下照片的瞬间、用剪辑软件或特效软件处理视频、影视特效对物体的仿真和渲染、AI 模型的训练和使用（相信不少人已经了解了由 Novel AI 和 niji·journey 等 AI 模型创作的不少令人惊人的画作）等等也需要大量并行计算的任务。
 |
 |
|---|---|
| 你能一眼分辨出这是 AI 画的吗？ | 你能一眼分辨出这是游戏渲染的吗？ |
1.3 为什么用 Taichi
很久以前，我曾构想过一个专门进行数值计算和可视化的工具 Plotter ，它将循环和分支结构视为对矩阵的处理，并且当时使用 JavaScript 实现了这个工具的原型，创作了一些简单的数学可视化效果。
 |
 |
|---|---|
| 高中和大学的时候做的一些数学绘图小玩具 | 用我自己写的小工具画的 Julia 集 |
但是它的问题是效率非常低下。后来我接触了游戏开发，并入门了着色器，然后震惊于并行计算带来的极高计算效率，但是使用着色器任然存在许多桎梏，它的兼容性和灵活度并不是很好。
再后来我了解了 Taichi ，作为领域特定语言，能够让你以更好的灵活度和简便的语法轻松玩转并行编程，无需配置复杂的 C++/CUDA 环境、使用冗长的语法并处理各种编译和运行时问题。
下面是一段 Taichi 代码的示意图，相信你能从其中感受到 Taichi 的简洁和灵活性。
用蒙特卡洛算法计算圆周率，图片来自 Taichi 官网
1.4 安装 Taichi
在开始之前，你需要先安装 Python ，然后使用 Python 的包管理器 pip 来安装 Taichi 。
在 Python 官网 下载安装 Python 后，使用 pip install taichi -U 安装 Taichi 。
之后，你可以使用 ti gallery 来验证是否安装成功，并查看一些 taichi 程序的演示。
1.5 运行 Taichi 程序
现在，我会教你使用 Taichi 定义一个向量场，然后使用 GPU 绘制一片紫色并显示在窗口中。
你也许已经知道，显示设备显示图像的原理是每个像素以混合不同强度的红绿蓝 (RGB) 三色光的方式[[4]]显示五彩斑斓的颜色，而在计算机中也最常用 RGB 色彩空间来处理颜色。紫色是由红色光与蓝色光混合而成，绿色光的强度为 0 ，所以我们用 vec3(1, 0, 1) 表示紫色。
放大看显示器，实际上是由 RGB像素构成的[[4:1]]
我们将图像视为一个二维的、由像素组成的向量场[[5]]，每个像素都有一个颜色值，用一个三维的向量表示 RGB 三个分量的强度，且每个分量被标准化到 0 和 1 之间，用 0 表示强度最弱，用 1 表示强度最强。在 Taichi 中，我们先用 ti.init(arch=ti.gpu) 初始化 Taichi ，并告诉它我们要将程序在 GPU 中加速运行，然后使用 ti.Vector.field 来定义一个向量场。
这个场的大小便是图像的分辨率，在这里我们设置为常见的 1920x1080 ，即 1920 个像素宽、1080 个像素高的图像。然后，我们在用 ti.kernel 装饰 Taichi 运行时的入口（这里是 render 函数），使用 Taichi 的并行 for 为每个像素赋予紫色 vec3(1, 0, 1) 。最后我们用 ti.ui.Window 创建一个窗口[[6]]，并用 canvas.set_image 将这个场绘制到窗口的画布中。
创建一个 00.py 文本文件，输入下面的代码。
from taichi.math import * # 导入 Taichi 数学库
import taichi as ti # 导入 Taichi 库
ti.init(arch=ti.gpu) # 初始化 Taichi ，GPU 加速
image_resolution = (1920, 1080) # 图像分辨率
image_pixels = ti.Vector.field(3, float, image_resolution) # 图像的像素场
@ti.kernel
def render(): # 渲染函数
for i, j in image_pixels: # 并行遍历像素场
image_pixels[i, j] = vec3(1, 0, 1) # 设置像素颜色为紫色
window = ti.ui.Window("Taichi Renderer", image_resolution) # 创建窗口
canvas = window.get_canvas() # 获取画布
while window.running:
render() # 调用渲染函数
canvas.set_image(image_pixels) # 为画布设置图像
window.show() # 显示窗口
在当前路径下，使用终端命令 ti 00.py 运行这个 Taichi 程序，你便可以看到一个紫色的窗口。
你的第一个 Taichi 图形程序：紫色的窗口
2 让我们正式开始
别忘了我们的目标是创建一个光线追踪渲染器，但是凡事都得一步一步地来不是吗？现在你已经会运行 Taichi 程序，并成功在画布里绘制出了一片纯紫色，这已经是一个很好的开始了。
接下来我们要建立坐标系，并对坐标值进行归一化，这是我们能够自由控制画面中物体位置的基础。
什么是归一化？通常是指将数值压缩到 0 到 1 之间，或者 -1 到 1 之间。在这里，我们的图像分辨率是 image_resolution = (1920, 1080) ，但这个数值是可以被我们自由变更的，因此我们将第 i 行、第 j 列的像素的坐标值归一化为 u = i / image_resolution[0] 和 v = j / image_resolution[1] ，这样我们就可以使用归一化的 uv 坐标来描述像素位置了。
之后，我们将红色强度设置为 u ，绿色强度设置为 v ，蓝色强度设置为 0 ，这样我们就可以看到一个渐变的彩色图像，并且沿着 u 轴从左到右红色强度上升，沿着 v 轴从下到上绿色强度上升。
彩色的画布，沿着 u 轴从左到右红色强度上升，沿着 v 轴从下到上绿色强度上升
创建一个 01.py 文本文件，在 00.py 基础上加入下面的代码。
@ti.kernel
def render(): ## 渲染函数
for i, j in image_pixels: ## 并行遍历像素场
u = i / image_resolution[0] ## 计算归一化的 u 坐标
v = j / image_resolution[1] ## 计算归一化的 v 坐标
image_pixels[i, j] = vec3(u, v, 0) ## 设置像素颜色
在当前路径下，使用终端命令 ti 01.py 运行这个 Taichi 程序，你便可以看到一个彩色的窗口。
3 使画面动起来
一副静态画面有什么好看的呢？让我们更进一步，使画面动起来吧。
我们需要做的是获取当前程序运行经过的时间，然后将这个时间传入 render 函数，让它影响蓝色分量的强度。我们希望画面整体蓝色强度会随着时间周期性的变化。
别忘了归一化，程序经过的时间是以秒为单位不断增加的，但是我们的蓝色分量必须在 0 和 1 之间，在这之外的值会被截断。因此，我们使用 sin(t) 函数将时间归一化到 -1 到 1 之间，再缩放并平移到 0 到 1 之间，这只需要 0.5*sin(t) + 0.5。
创建一个 02.py 文本文件，在 01.py 基础上加入下面的代码。
@ti.kernel
def render(time: float): # 渲染函数
for i, j in image_pixels: # 并行遍历像素场
...
blue = 0.5 * sin(time) + 0.5 # 计算蓝色分量
image_pixels[i, j] = vec3(u, v, blue) # 设置像素颜色
...
start_time = time.time() # 获取程序开始时时间
while window.running:
delta_time = time.time() - start_time # 计算时间差
render(delta_time) # 调用渲染函数
...
在当前路径下，使用终端命令 ti 02.py 运行这个 Taichi 程序，可以看到一个不断变化色彩的窗口。
这副画面的色调会随着时间周期性变化
4 光子与光线
光线追踪渲染利用了光路可逆的原理，我们将光的传播逆向表达，从每个像素发出光线，光击中材质表面后改变了自身的强度、颜色和方向，然后继续传播，直到光线被完全吸收或者到达了光源。最后我们将累积的颜色显示在这个像素上，便渲染出了场景。
接下来，我们来到了光线追踪最基础的一步——定义光线。光线是光子沿射线传播的路径，在基于光线追踪的渲染器中，我们假定光线仅沿着一条直线传播，因此光线可以用一个起点
和一个方向 来表示，其中 应是一个单位向量。这样，光子在三维空间中所在的位置可以用表示，其中 t 是光从起点开始传播的距离。
光线的起点和方向
用一个四维向量 vec4 表示光线的颜色&强度，这方便我们后面对光的处理。在这里，我们使用面向对象 (OOP) 的建模方法，利用 Taichi 的 ti.dataclass 装饰器写一个光线类，at 函数传入 t 计算光所在位置。
@ti.dataclass
class Ray: ## 光线类
origin: vec3 ## 光线起点
direction: vec3 ## 光线方向
color: vec4 ## 光的颜色
@ti.func
def at(r, t: float) -> vec3: ## 计算光子所在位置
return r.origin + t * r.direction
5 建立坐标系
为什么要建立坐标系？因为接下来我们要在虚拟的三维空间中定义我们摄像机的位置，在这之前，我们已经用 uv 坐标建立了一个二维的坐标系了，我们还需要一个 z 轴正方向。使用过三维软件、游戏引擎的同学可能知道，图形学中常使用右手系来建立三维空间坐标。
因此，从屏幕向你眼睛的方向，z 轴分量是负的。我们将视点（好比眼睛的位置）放在原点 (0, 0, 0)，画布（相当于你的屏幕）的中心位置为 (0, 0, -1)，从视点向画布中每个像素发射一条光线。
建立右手系坐标系，将画布放到 z 负半轴方向
在 render 函数中，初始化视点和画布的位置，然后创建一条光线。在这里，我们使用了 normalize 函数将向量化为仅表示方向的单位向量。
代码如下
lower_left_corner = vec3(-2, -1, -1) ## 视野左下角
horizontal = vec3(4, 0, 0) ## 视野水平方向
vertical = vec3(0, 2, 0) ## 视野垂直方向
origin = vec3(0, 0, 0) ## 视点
ro = origin ## 光线起点
rd = normalize(lower_left_corner + u*horizontal + v*vertical - ro) ## 光线方向
ray = Ray(ro, rd) ## 创建光线
6 画一片蓝天
有了光线之后，我们尝试使用光线方向的 y 分量来混合白色和蓝色，从而得到一片随时间变化的蓝天。mix 函数是对向量的插值（混合），用数学公式表达是
用 ti.func 装饰这个函数是一个 Taichi 函数，这样我们才可以在 Taichi 的 ti.kernel 中使用它。
@ti.func
def sky_color(ray, time) -> vec3:
t = 0.5 * ray.direction.y + 0.5 ## 将 y 分量归一化
blue = 0.5 * sin(time) + 0.5 ## 计算蓝色分量
return mix(vec3(1.0, 1.0, blue), vec3(0.5, 0.7, 1.0), t) ## 混合两种颜色
在 render 函数中，我们将光线传入 sky_color 函数，得到背景颜色，再将背景颜色赋值给像素。
ray.color.rgb = sky_color(ray, time) ## 获取天空颜色
image_pixels[i, j] = ray.color.rgb ## 设置像素颜色
一片渐变的蓝天，随时间改变颜色
7 往地图放入物体
7.1 符号距离场函数
接下来我们要往虚拟世界里放入一些几何物体，最简单的物体是一个半径为 r 的球，我们用一个函数来表示这个球，这个函数称为符号距离场函数 (Signed Distance Field，SDF) 。它表示的是某点到物体表面的距离，如果距离为负数，表示这个点在物体内部，如果距离为正数，表示这个点在物体外部，如果距离为零，表示这个点刚好在物体表面上。用
转化为 Python 代码就是
@ti.func
def sd_sphere(p: vec3, r: float) -> float: ## SDF 球体
return length(p) - r
使用 SDF 表示物体的好处是，我们可以很方便地计算出物体的表面法线，这在后面的光照计算中会用到。此外， SDF 函数不仅能够表达简单的集合物体，也可以表达复杂的物体，还可以使用简单的运算对多个物体进行变换、组合和重复等操作[[7]]，这使得我们可以很方便地创建出复杂的场景，如下图所示
 |
 |
 |
|---|---|---|
| 扭曲物体 | 重复物体 | 并集、差集、交集 |
图片来自 https://iquilezles.org/articles/distfunctions/
7.2 光线步进求交
有了用 SDF 表示的球体之后，接下来就是让光线前进，然后找到光线与物体最近的交点。我们可以使用光线步进 (Ray Marching) 的方法来找到交点，即沿着光线方向，每次前进一小步，然后计算出这一步的有向距离 (SD) 值，一直前进直到 SD 值与 0 相差非常小 abs(SD) < PRECISION ，就认为光线到达了物体的表面。
可是每次前进的步长是多少呢？如果步长太大，光线可能会跳过物体表面，如果步长太小，光线前进的速度就会极慢，这样就会带来非常多冗余的计算，使得画面帧数下降。
一个聪明的做法是让光线每次前进的距离刚好等于 SD 的绝对值，因为它是当前点到物体表面的最短距离。最好的情况下，光线只需要前进一两次就可以刚好到达表面。
当光线偏离物体很远时，光线也很快就会传播到无穷远处，当光线步进的距离足够远而仍然没有到达物体表面，就认为这条光线没有击中任何物体，那我们就可以认为它击中了天空。
下面是三维空间的一个二维切面，可视化这个算法中光线步进和与物体求交的过程。
 |
 |
|---|---|
| 较好的情况下很快到达物体表面 | 没有交点的情况很快就发散 |
图片截取自 https://www.shadertoy.com/view/lslXD8
一种比较差的情况是光线刚好与物体“擦肩而过”，这个时步进次数会急剧上升，好在光线总会离开物体表面附近，我们可以设置一个最大步进次数，当步进次数超过这个值时，也认为这条光线没有击中任何物体。
图片截取自 https://www.shadertoy.com/view/lslXD8
首先，我需要定义一个光线击中物体的数据类
@ti.dataclass
class HitRecord: ## 光子碰撞记录类
position: vec3 ## 光子碰撞的位置
distance: float ## 光子步进的距离
hit: ti.i32 ## 是否击中到物体
接着，声明一个阈值 PRECISION ，当光子距离物体表面足够近时，便认为击中了物体表面。还需要一个最大的步进次数 MAX_RAYMARCH 和最大步进距离 TMAX ，如果超出这两个值，便认为这条光线没有击中任何物体。此外，还需要一个 TMIN 让每次求交时光线起始位置向光线方向移动一小步，避免在下次求交时光线又立刻与物体相交 (abs(sd) < PRECISION) 。
TMIN = 0.001 ## 光开始传播的起始偏移，避免光线自相交
TMAX = 2000.0 ## 最大单次光线传播距离
PRECISION = 0.0001 ## 必须要小于 TMIN，否则光线会自相交产生阴影痤疮
MAX_RAYMARCH = 512 ## 最大光线步进次数
与物体求交的函数如下
@ti.func
def raycast(ray) -> HitRecord: ## 光线步进求交
record = HitRecord(ray.origin, TMIN, False) ## 初始化光子碰撞记录
for _ in range(MAX_RAYMARCH): ## 光线步进
record.position = ray.at(record.distance) ## 计算光子所在位置
## 计算光子与球体的有向距离，将球体位移到了 (0, 0, -1)，半径为 0.5
sd = sd_sphere(record.position - vec3(0, 0, -1), 0.5)
dis = abs(sd) ## 绝对值为无符号距离
if dis < PRECISION: ## 如果光子与球体的距离小于精度即为击中
record.hit = True ## 设置击中状态
break
record.distance += dis ## 光子继续步进
if record.distance > TMAX: ## 如果光子步进距离大于最大步进距离
break
return record ## 返回光子碰撞记录
最后在 render 函数里执行 raycast 函数，如果击中了物体，就将像素点的颜色设置为红色，否则设置为天空的颜色。
record = raycast(ray) ## 光线步进求交
if record.hit:
ray.color.rgb = vec3(1.0, 0.0, 0.0) ## 设置为红色
else:
ray.color.rgb = sky_color(ray, time) ## 获取天空颜色
好的！运行你的代码，你会看到我们成功地在屏幕上渲染出了一个形状。但似乎有点奇怪？为什么我们看到的球体不是圆形的，而是椭圆形的？
我们看到场景中的球并不是一个标准的圆
这是因为我们设置的窗口比例是 1920:1080 而我们在虚拟世界里定义的画布长宽并不是这个比例，而是 2:1 （如下面代码所示），你注意到了吗？要更好的解决这个问题，下一节我们会创建一个摄像机类。
lower_left_corner = vec3(-2, -1, -1) ## 视野左下角
horizontal = vec3(4, 0, 0) ## 视野水平方向
vertical = vec3(0, 2, 0) ## 视野垂直方向
origin = vec3(0, 0, 0) ## 视点
8 创建摄像机类
我们的目标是传入 uv 坐标，从摄像机类获取光线的起点 ro 和方向 rd 。
现实中，摄像机除了有位置 (lookfrom) 、朝向 (lookat, vup) 之外，还有视野 (vfov)、传感器（画布）长宽比(aspect)、光圈直径 (aperture)、合焦距离 (focus) 等。
8.1 视野 FOV
当摄像机传感器的长宽比与显示长宽比一致时，画面才不会出现不自然的拉伸。 视场 (Field of View, FOV) 指的是摄像机能够观测的范围。vfov 表示的是摄像机在纵向能够看到的角度，通常人眼的极限 vfov 为 135 度，30 度是一个较为舒适的感知范围。如果你了解摄影，50 mm 全画幅镜头的 vfov 大约为 30 度[[8]]
由于窗口可以调整长宽比，因此横向视野 hfov 可以取决于窗口长宽比和 vfov ，只需要设置 vfov 即可。
人眼纵向的视野，出处见图片左下角
8.2 光圈与焦平面
为简化模型，我们将画布平面视为焦平面，因此摄像机到画布中心的距离为合焦距离 focus ，然后以 lookat 为原点，normalize(lookfrom - lookat) 为 z 轴正方向，建立右手系。
光线从光圈内任意一点 ro 出发，向焦平面上某一点前进，因此我们只需要利用已有的量，建立从 uv 坐标系到世界空间坐标系下焦平面上的点 rp 的映射，就可以表示出光线的方向 normalize(rp - ro) 。
光线应该从光圈的哪个位置出发？在现实中，进入光圈的光线在光圈内的分布应该是均匀的，按照光路可逆原理，我们也应该在光圈内均匀的选取位置发射光线，但在我们的程序中，我们无法一次采样光圈内的所有点，因此我们只能使用 蒙特卡洛方法 (Monte Carlo method) 在光圈内随机采样一个点。
在一个单位圆内随机撒豆子，豆子有一定概率落在扇形内
如何在在单位圆内均匀的随机采样一个点呢？想象我们往单位圆内随机撒豆子，一个豆子落到半径为
，角度为 的扇形的概率是扇形的面积 比上单位圆面积 ，这就是它的概率分布函数我们希望分布是均匀的，也就是概率分布函数的导数——概率密度函数
是常数，但是是一个关于 的函数，并不是一个常数，因此如果让 在 取值的话采样并不均匀，如下图所示
在单位圆的撒下的豆子并不是均匀分布的
如果令 ，那么概率密度函数 就是一个常数了
因此我们只需要使用随机变量
和 ，就可以得到在单位圆内均匀的随机采样一个点，它的坐标 如下
现在，豆子均匀的分布在单位圆内
在 taichi 中，可以用 ti.random() 非常轻松的获取处于 [0, 1) 范围内均匀的随机数[[9]]
@ti.func
def random_in_unit_disk(): ## 单位圆内随机取一点
x = ti.random()
a = ti.random() * 2 * pi
return sqrt(x) * vec2(sin(a), cos(a))
8.3 实现摄像机
我为这个摄像机模型总结了一幅图，根据这幅图可以直观的写出代码
我们的摄像机类代码如下
@ti.dataclass
class Camera: # 摄像机类
lookfrom: vec3 # 视点位置
lookat: vec3 # 目标位置
vup: vec3 # 向上的方向
vfov: float # 纵向视野
aspect: float # 传感器长宽比
aperture: float # 光圈大小
focus: float # 对焦距离
@ti.func
def get_ray(c, uv: vec2, color: vec4) -> Ray:
# 根据 vfov 和画布长宽比计算出半高和半宽
theta = radians(c.vfov) # 角度转弧度
half_height = tan(theta * 0.5)
half_width = c.aspect * half_height
# 以目标位置到摄像机位置为 Z 轴正方向
z = normalize(c.lookfrom - c.lookat)
# 计算出摄像机传感器的 XY 轴正方向
x = normalize(cross(c.vup, z))
y = cross(z, x)
# 计算出画布左下角
lower_left_corner = c.lookfrom - half_width * c.focus*x \
- half_height * c.focus*y \
- c.focus*z
horizontal = 2.0 * half_width * c.focus * x
vertical = 2.0 * half_height * c.focus * y
# 模拟光进入镜头光圈
lens_radius = c.aperture * 0.5
rud = lens_radius * random_in_unit_disk()
offset = x * rud.x + y * rud.y
# 计算光线起点和方向
ro = c.lookfrom + offset
rp = lower_left_corner + uv.x*horizontal \
+ uv.y*vertical
rd = normalize(rp - ro)
return Ray(ro, rd, color)
之后在 render 函数中初始化摄像机并获取光线
camera = Camera()
camera.lookfrom = vec3(0, 0, 4) ## 设置摄像机位置
camera.lookat = vec3(0, 0, 2) ## 设置目标位置
camera.vup = vec3(0, 1, 0) ## 设置向上的方向
camera.aspect = aspect_ratio ## 设置长宽比
camera.vfov = 30 ## 设置视野
camera.aperture = 0.01 ## 设置光圈大小
camera.focus = 4 ## 设置对焦距离
ray = camera.get_ray(uv, vec4(1.0)) ## 生成光线
现在让我们看看运行的效果。很好，我们终于看到了一个完美的圆
一个完美的圆（实际上是球在平面上的投影）
9 计算物体法线
计算物体表面法线对光线追踪渲染非常重要，因为我们要根据物体表面法线决定光碰撞到物体表面时如何与之发生反应，也就是光的颜色、强弱和方向如何改变，之后才能进行下一步追踪。
法线是垂直于物体表面某点的单位向量，利用 SDF 表示的物体表面，可以比较容易的计算出法线。
9.1 梯度与法线
我们知道 SDF 函数在某点的值表示的是该点到物体表面的距离，而函数某点的梯度表示的是函数增长最快的方向。对于 SDF 函数来说，梯度方向就是远离物体表面的方向。如果某点在物体表面上，那么这一点的梯度方向刚好是物体表面法线 的方向，也就是
而梯度的定义是
Taichi 支持可微编程[10]，拥有一个强大的自动微分系统，可以很方便的自动计算梯度。但为了方便读者理解，这里我仍然先采用传统的办法，即利用数值微分计算梯度
因为计算法线只需要知道梯度方向，并不需要知道大小，所以求法线可以进一步化简为
它的 Taichi 代码看起来很简洁
@ti.func
def calc_normal(p: vec3):
eps = 0.0001
h = vec2(eps, 0)
return normalize( vec3( f(p+h.xyy) - f(p-h.xyy), \
f(p+h.yxy) - f(p-h.yxy), \
f(p+h.yyx) - f(p-h.yyx)) )
9.2 优化求法线的效率
在 iq 的这篇文章 中，有一种四面体技术[[11]]可以很好的减少计算量，所以我在这里改用为这种方法。此外，如果我们想在地图中放入若干不同的物体，不同的物体有不同位置和材质，因此在求法线时我们要传入具体是哪个物体
@ti.func
def calc_normal(obj, p: vec3) -> vec3: ## 计算物体法线
e = vec2(1, -1) * 0.5773 * 0.0005
return normalize( e.xyy*signed_distance(obj, p + e.xyy) + \
e.yyx*signed_distance(obj, p + e.yyx) + \
e.yxy*signed_distance(obj, p + e.yxy) + \
e.xxx*signed_distance(obj, p + e.xxx) )
9.3 可视化法线
由于法线是一个单位向量，每个分量都可以在 [-1, 1] 之间，如果我们要可视化法线，需要先将其每个分量映射到 [0, 1] 之间，然后将其作为颜色值赋予像素。与前面映射 函数到 [0, 1] 的方法一样，这也是将物体表面法线储存为一张图片（法线贴图）的方法。
normal = calc_normal(record.obj, record.position) ## 计算法线
ray.color.rgb = 0.5 + 0.5 * normal ## 设置为法线颜色
让我们欣赏一下这个五彩斑斓的球体，它看起来很漂亮
将法线映射为球表面的颜色
10 基础变换和材质
我们会为物体赋予最简单的材质——反照率 (albedo) 以及一个最基础的变换——位置 (position) 。为方便读者理解，这里先放上 taichi 结构体类的定义代码。
@ti.dataclass
class Material:
albedo: vec3 ## 材质颜色
@ti.dataclass
class Transform:
position: vec3 ## 物体位置
@ti.dataclass
class Object:
sd: float ## 到物体表面的符号距离
mtl: Material ## 物体材质
trs: Transform ## 物体变换
10.1 基础反照率
反照率可以粗略表示为光线入射物体表面后，物体出射光的颜色与物体入射光之比。因此在光线追踪时，出射光的颜色就是
ray.color.rgb *= record.obj.mtl.albedo
10.2 位移物体
位移物体相当于对物体的 SDF 函数进行平移，在求 SDF 距离值阶段对传入的点减去物体位置
@ti.func
def signed_distance(obj, pos: vec3) -> float:
p = pos - obj.trs.position ## 计算物体位移后的点
r = 0.5 ## 球体半径
sd = sd_sphere(p, r) ## 计算 SDF 值
return sd
11 移动摄像机
在之前的章节，我们已经为我们的 taichi 程序创建了一个摄像机类。为了方便我们在不同位置和角度观察物体，这一章我们会利用 taichi GGUI 内置的 ti.ui.Camera() 来创建一个 freelook 摄像机[[6:1]]，并将它与我们渲染程序中的摄像机类进行绑定。
创建摄像机很简单，在初始化画布后实例化一个摄像机，然后为其设置初始位置
camera = ti.ui.Camera() ## 创建摄像机
camera.position(0, 0, 4) ## 设置摄像机初始位置
在运行的循环中，每帧根据用户输入更新摄像机
while window.running:
## 从用户输入更新摄像机，设置移动速度为 0.03 ，按住鼠标左键旋转视角
camera.track_user_inputs(window, movement_speed=0.03, hold_key=ti.ui.LMB)
分别为 render 函数声明形参并传入实参
@ti.kernel
def render(
time: float,
camera_position: vec3,
camera_lookat: vec3,
camera_up: vec3): ## 渲染函数
...
循环内每帧传入摄像机的位置、朝向和上方向
while window.running:
## 从用户输入更新摄像机，设置移动速度为 0.03 ，按住鼠标左键旋转视角
camera.track_user_inputs(window, movement_speed=0.03, hold_key=ti.ui.LMB)
delta_time = time.time() - start_time ## 计算时间差
render(
delta_time,
camera.curr_position,
camera.curr_lookat,
camera.curr_up) ## 调用渲染函数
canvas.set_image(image_pixels) ## 为画布设置图像
window.show() ## 显示窗口
这样我们就可以以 FPS 游戏的方式，按住鼠标左键和 W A S D Q E 来自由移动摄像机啦。
12 更多形状和物体
这一章，我们为 Object 类加入物体的形状属性，以支持物体拥有不同的形状（在本章，我们先添加一个简单的 Box 形状）。在 Transform 类加入物体的缩放，以改变物体在各个轴上的大小。然后创建一个 Object.field(shape=objects_num) 场，在里面添加不同的物体。最后写一个 nearest_object 函数，为计算光线与场景中所有物体最近的一个交点，利用 SDF 函数的特性，寻找距离点 最近的物体。
## 举形状类型
SHAPE_NONE = 0 ## 无形状
SHAPE_SPHERE = 1 ## 球体
SHAPE_BOX = 2 ## 箱体
@ti.dataclass
class Object:
type: ti.u32
...
12.1 物体形状和缩放
由于物体有了不同形状和大小，所以物体的 SDF 函数需要根据类型进行选择，还需要根据缩放来控制 SDF 物体的大小。对 signed_distance 函数的更改如下
@ti.dataclass
class Transform:
scale: vec3
...
@ti.func
def signed_distance(obj, pos: vec3) -> float: ## 对物体求 SDF 距离
position = obj.trs.position ## 位置空间变换（下一步再实现旋转变换）
scale = obj.trs.scale ## 用缩放控制物体大小
p = pos - position
## 为不同形状选择不同的 SDF 函数
if obj.type == SHAPE_SPHERE:
obj.sd = sd_sphere(p, scale.x)
elif obj.type == SHAPE_BOX:
obj.sd = sd_box(p, scale)
else:
obj.sd = sd_sphere(p, scale.x)
return obj.sd ## 返回符号距离
其中 Box 的 SDF 函数[[7:1]]可以在iq 大佬的文章 中查到如下
@ti.func
def sd_box(p: vec3, b: vec3) -> float: ## SDF 盒子
q = abs(p) - b
return length(max(q, 0)) + min(max(q.x, max(q.y, q.z)), 0)
12.2 欧几里得空间
为什么应用物体的变换，不使用一个包含缩放、旋转和剪切的 3 X 3 变换矩阵呢？iq 大佬在它的文章中指出，不同轴向非均匀的缩放会扭曲欧几里得空间[[7:2]]，这使得 SDF 函数在求交阶段可能变得不可靠。
While rotations, uniform scaling and translations are exact operations, non-uniform scaling distorts the euclidean spaces and can only be bound.
如果使用
的方式，将点 P 从世界空间变换到物体空间，并左乘变换矩阵的逆，确实对 SDF 函数进行了正确的变换，但是这带来的问题是光线步进求交时，SDF 值并不是世界空间下的 SDF 值，因此求交的结果可能不正确。如下图所示，经过缩放变换的物体，在“窄”的那一侧会裂开，因为光线没能跟物体正确求交。
光线直接穿过了物体，没能跟物体表面相交，因此物体看起来裂开了
左图：物体没有进行缩放变换，正常求交
右图：物体进行了缩放变换，光线会在“窄”的一侧穿过物体
12.3 物体场
接着，创建一个 Object.field 场，用于存储所有的物体。这里我在地图中多加了一个盒子，它在球体后面，被球挡住了，需要移动摄像机才能看到。
objects_num = 2 ## 地图中物体的数量
objects = Object.field(shape=objects_num)
objects[0] = Object(type=SHAPE_SPHERE,
trs=Transform(vec3(0, 0, -1), vec3(0.5)),
mtl=Material(vec3(1, 0, 0)))
objects[1] = Object(type=SHAPE_BOX,
trs=Transform(vec3(0, 0, -2), vec3(0.2, 0.3, 0.5)),
mtl=Material(vec3(0, 1, 0)))
12.5 更改求交函数
最后，在光线步进求交阶段，光线每步进一次，就寻找距离这一点最近的物体，如果距离最近的物体表面接近于 0 ，就判定为光线与物体表面相交了，改进的 raycast 函数如下
@ti.func
def raycast(ray) -> HitRecord: ## 光线步进求交
record = HitRecord(ray.origin, TMIN, False) ## 初始化光子碰撞记录
for _ in range(MAX_RAYMARCH): ## 光线步进
record.position = ray.at(record.distance) ## 计算光子所在位置
record.obj = nearest_object(record.position) ## 计算光子与球体的有向距离
...
12.6 寻找最近物体
那么如何寻找距离某点最近的物体呢？最简单粗暴和有效的方法是遍历所有的物体，计算所有物体的 SDF 值，然后返回 SDF 值最小的那个物体。这里我们使用了一个 nearest_object 函数，该函数的实现如下
@ti.func
def nearest_object(p: vec3) -> Object: ## 求最近的物体
o = Object(sd=MAP_SIZE) ## 设置一个最大的 SDF 值，即地图边界
for i in range(objects_num):
oi = objects[i]
oi.sd = signed_distance(oi, p)
if abs(oi.sd) < abs(o.sd): o = oi
return o
实际上，存在内存上优化的求交加速算法（例如 BVH 等），本文就不赘述了。感兴趣可以点赞支持一下，我再写一篇文章讲讲～
12.7 探索场景
到这一步，我们就可以运行程序，然后自由移动摄像机看看场景中的两个颜色不同的物体。
两个不同的物体，一个红色球和一个绿色的盒子
由于只进行了一次光线追踪，没有多次光线反弹之后的间接光和光强损耗，场景中的物体看起来非常的平面，没有影子和阴影。这在后面的章节会逐步完善。接下来我们继续测试一下法线
左：由于摄像机光圈和对焦距离的存在，产生了散景模糊
右：从另一个角度查看场景中的球和盒子
摄像机可以进入物体内部吗？答案是肯定的。在前面物体求交阶段，我们对符号距离值做了绝对值处理，因此物体内部会被当作外部来处理，这样就可以进入物体内部了。
如果物体是空心的（物体只有薄薄的一层表面），那物体内部的法线是怎样的呢？如何判断某点是在物体内部还是外部？我们控制摄像机进入盒子看看
盒子内部，将梯度当作法线，内表面法线仍然是朝向物体外面的
从上图可以看到，物体内表面的法线仍然是朝向物体外面的，回顾 [计算物体法线]这一章节，这是因为 SDF 函数的梯度方向永远是朝着 SDF 值增大的方向，而 SDF 物体内部的 SDF 函数值是负的。因此，如果要判断某点是在物体内部还是外部，只需要判断 SDF 值的符号即可。
13 内外表面法线
在处理透明的物体（例如玻璃、钻石、塑料等材质）时，物体内外有不同的折射率，光线会根据折射率之比改变方向。因此我们必须得知道光线正在进入物体内部，还是正在穿出物体。怎么做呢？如下图所示
光线穿入物体和穿出物体
还记得向量的点乘吗？由于无论内表面还是外表面，法线方向永远都是朝物体外面，这带来的好处是当光线方向与法线方向点乘大于零时，光线正在从内表面穿出物体，当光线方向与法线方向点乘小于零时，光线正在从外表面穿入物体。