学习笔记 on wanfeng

PBRT（Reflection Models）

Thu, 25 Dec 2025 14:10:44 +0800

未完结

因为直接看了第7章，第4章还没看，需要先回去看一下4.3.1的BRDF、BTDF、BSSRDF

BXDF框架

BSDF

BRDF

很熟悉了，只定义了反射如何进行

Hemispherical–Directional Reflectance（半球–方向反射率）

从BRDF延申出的一个概念，把光照设置为常量1，这时候的渲染方程就变成了这个东西

它的意义是不关心光照，不关心各个方向的Radiance（均匀分布的光照），只关心材质本身往W0方向的Radiance

它可以用来检查物理守恒，物理正确的材质必须满足：

hemispherical–hemispherical reflectance（半球–半球反射率）

描述了一个面在所有入射方向上平均收到光照后，向所有方向反射的平均能量比例

这不就是把上一个半球–方向反射率求了一个半球积分后的平均么

上述两个东西，感觉是用在表达材质的反射效果的一个指标，并不是渲染需要的东西，写论文用的东西？

BTDF

T 表示transmittance ，BTDF用于描述透射的分布

这里特别提到BTDF并没有reciprocity 的特性，就是不能反着来

BTDF和BRDF被统称为BSDF，因为他们都可以表达为

最终BSDF作用到渲染中为（注意这里绝对值符号是PBRT自己加的，他们意思是并不会修改模型的法线朝向模型外侧，可能有他们的考虑）

整了半天4.3.1 原来并没有介绍具体的BSDF模型，只是引入了概念

BSSRDF

今天属于是理清楚了 scattering是各种各样的改变光方向的行为的统称，并不是额外的效果。。。

折射是透射的一种，透射是更上层的概念，透射就是进入某种介质的行为。。。

bidirectional scattering surface reflectance distribution function (BSSRDF) 描述的是此表面反射的理论框架

参数多了一个Pi，也就是Pi对着色点P0的贡献比例，比BSDF多一个维度，BSDF只考虑当前着色点

看这张图能看出光先进入物体内部，不断散射后从着色点穿出后到达摄像机

计算过程需要遍历每一个Pi，BSSDF定义这个Pi点的贡献值

内层积分定义一个Pi点的渲染贡献，外层积分累积所有Pi点

下图展示了(a) 漫反射 (b)高光反射 (c) 镜面反射（接近）（d）逆反射的Lobe

另外也理解了各项同性和异性，同性就是指如上图的摄像机位置，如果绕着法线进行旋转，得到的结果应该是一致的

基础理论

为可见光的波长（量级为米级）远小于渲染场景中物体的尺寸（毫米到米级），因此波动相关的现象通常不会在渲染图像中体现.

但要深入理解光线撞击表面时的行为，就需要借助波动光学的理论，而且在几何光学的模拟框架中融入波动光学的结论，已经成为计算机图形学的常用设计模式。

当光线照射到物体表面时，会激发材料原子外层的电子，使其发生快速振荡；振荡的电荷会产生次级电场振荡，这些次级振荡会发生相长干涉和相消干涉，这就是原子反射光线的核心机制。而干涉的具体表现，则由原子的种类和原子间的结合方式决定。

材料种类

电介质（Dielectrics）

这是一大类电绝缘体，包括玻璃、水、矿物油、空气等气态、液态、固态物质。这类材料中，电子与原子的结合非常牢固，不会自由移动。

导体（Conductors）

包括金属、合金以及类金属（如石墨）。这类材料的原子晶格中存在自由电子，入射电磁波激发的电子振荡可以让电子在较大范围内移动；同时，电子在晶格中移动时会以热量的形式耗散部分入射能量，导致光线在深入材料的过程中被快速吸收。

关键特性：光线通常在材料表面0.1 米的深度内被完全吸收，只有极薄的金属薄膜才能透射可观的光线。

半导体（Semiconductors）

如硅、锗，兼具电介质和导体的特性。例如硅在可见光波段表现出金属的特性，但在红外波段是透明的，因此可用于红外相机的光学元件。

PBRT后面介绍了IOR（折射率）的原理就是光速与在真空中的光速的比值，两种介质的折射率差值越大，分界面的反射效果越强。

反射定律

这张图解释了反射是如何计算的，分解成平行于法线和垂直于法线的两个向量后很容易计算

折射定律

经过一些推导最终折射的向量可以通过下面这个公式计算

折射需要有一个注意的地方：从折射率高进入折射率低（从水中看向空气）时，入射角度过大会导致折射算出来sin大于1了，此时发生的是全内反射，没有折射了

菲涅耳方程

上述的折射和反射是会同时发生的，对于导体来说，折射会迅速消失。

菲涅耳方程用来计算反射光的比例

这块东西解释了入射波可以分解为垂直（垂直于入射向量和法线组成的平面）和平行两个，单独进行建模。菲涅尔方程描述了给定已知振幅的入射波时，反射波振幅与入射波振幅之间的关系。（这些内容没必要特别细看）

电介质、导体和半导体均遵循相同的菲涅尔方程。

对于电介质，就按照上边的公式计算

对于导体，折射率之比变成用复数表示，然后各种解释，不太理解，看这里最终eta是一个复数，而不是简单的float比值，这种东西就不细看了

常见BXDF

完美模型

Diffuse Reflection（完美漫反射）

介绍了最简单的Lambertian model，完全均匀反射率的漫反射表面使用的模型

下图解释了为什么要除以/Pi。因为这样才能保证使总反射能量=R（反射率，用RGB就是albedo）

Conductor BRDF（完美反射）

导体的BRDF依据两个观点：

镜面反射定律为每条光线分配特定的反射方向，菲涅耳方程则确定反射光的分布范围。

任何残余光线都会折射进入导体，并被迅速吸收转化为热能

所以光滑导体只考虑BRDF、采样只会采样反射方向、PDF=1

非常简单，对W0有贡献的点只有反射方向，所以不需要算积分了，F()是菲涅尔方程

计算积分时的采样函数不需要什么工具，而是直接找反射方向，然后用菲涅尔公式计算反射比值，返回对这个方向的采样结果，另外PDF直接取1即可

Dielectric BSDF（完美反射+完美折射）

不像导体，这里就必须考虑反射和折射了

设置采样方向的方法是根据入射光角度，计算菲涅耳方程的反射比例，然后去一个随机数来概率选择BRDF还是BTDF

等比例选择BRDF和BTDF

根据反射比例来选择BRDF和BTDF，效果明显变好了，因为少了很多低贡献的采样

采样方式代码，会根据概率选择BRDF和BTDF

此时的PDF为

如果选择反射，和导体的采样方向一样

如果选择折射

Thin Dielectric BSDF（薄电介质，比如玻璃（跳过））

先理解薄电介质的物理背景（为什么需要单独建模）：

普通电介质（DielectricBxDF）只模拟 “单界面”（比如空气 - 玻璃），但实际的薄玻璃有两个平行界面（空气→玻璃→空气）：

光线入射到第一层界面：一部分反射，一部分透射进入玻璃；
透射光到达第二层界面：一部分透射出去，一部分反射回玻璃内部；
反射回的光又会在第一层界面反射 / 透射…… 这个过程无限递归（如图 9.16）；
薄电介质的核心假设：玻璃厚度极薄，光线的空间偏移可忽略，只需计算 “所有内部反射的总贡献”。

这个模型主要就是：多层内部反射的总反射率可以用几何级数求和简化（避免追踪无限次反射）

具体就先不看了！

Non-Symmetric Scattering and Refraction（跳过）

BTDF不能和BRDF一样反转使用，反转后必须修正系数才能保证物理正确。

这就不看了，看了一时半会也用不着

粗糙模型

微平面理论的关键洞见在于：无需对每个微平面进行显式几何建模，而是通过统计方法描述其集体行为

微面反射模型需考虑的三个重要几何效应。

(a)遮蔽效应：目标微面因被其他微面遮挡而不可见。

(b)阴影效应：类似地，光线无法抵达该微面。

(c)反射间效应：光线在到达观察者前会在微面间发生多次反射。

用法线分布来描述微表面，这里提到要让一小块微平面dA上方的面积投影下面积等于dA的面积

GGX法线分布

还有一种Beckmann法线分布

GGX的有点是拖尾，它的尾巴比较长，如下图橙色尾巴很长。而beckmannNDF在90°时已经衰减为非常接近0。如果把高出定义为高光，那backmannNDF高光周围会迅速衰减。而GGX会缓慢衰减，形成光晕的效果

后面介绍的过于理论了，感觉对目前帮助不大，先能进入行业再说，否则也没什么意义

PBRT（Monte Carlo Integration）

Mon, 22 Dec 2025 13:17:37 +0800

蒙特卡洛积分

开头一句话就解释了为什么渲染要用蒙特卡洛积分

虽然梯形积分法或高斯求积等标准数值积分技术在求解低维光滑积分时效果显著，但对于渲染中常见的高维不连续积分，其收敛速度却明显不足。蒙特卡洛积分技术为此提供了解决方案，通过随机采样评估积分，其收敛速度与被积函数的维度无关

概率论Review

读一遍，关键是回顾一下PMF/PDF CDF都是什么

随机变量

p(X)表达概率，称为PMF

这个是真忘了

对于连续随机变量，PMF取值始终是0，所以另外引入了PDF（概率密度函数）来表达连续性随机变量的概率情况

计算PDF的理论方法就是，在随机域上对PDF进行积分的结果得=1，反退出来的PDF函数是什么

另外PDF是累积分布函数的导数

PDF作用就很好理解了，他表示当前取值的概率密度，计算ab范围内的概率，就进行积分就是一段区域内的概率

期望，X的期望就可以通过积分X*PDF来计算

The Monte Carlo Estimator

蒙特卡洛公式的期望就等于原始需要计算的积分

蒙特卡洛公式，代码流程就是从PDF表示的分布中随机采样，计算积分值 / pdf值，多个采样点求和后除以采样数

可以看出一般形式的蒙特卡洛公式的期望仍然等于要求的积分

Error in Monte Carlo Estimators 蒙特卡洛积分的误差

使用方差与收敛时间评估蒙特卡洛积分

回顾方差的含义就是函数与其期望值的预期平方偏差

经典公式

多个独立随机变量的方差可以直接求和得到总的方差

蒙特卡洛积分相当于多个独立的随机变量的和，他的方差相当于每个随机变量的方差的和，因为另外因为蒙特卡洛积分要除以/N（样本数量），所以蒙特卡洛积分的方差会随着样本数量的增加而线性递减。

下面这段话是想说明蒙特卡洛算法的收敛速度不受维度影响，因此成为高维积分唯一实用的数值积分算法，TODO: 其实不是特别理解在说什么

使用方差线性递减这一特性，使用方差与运行实践来评估一个蒙特卡洛，方差和运行时间越小越好

并非所有积分估计量的期望值都等于积分本身。这类估计量被称为有偏估计量

虽然有偏，但随着样本数 N→∞N \to \inftyN→∞，误差会趋近 0，这类估计器称为一致（consistent）估计器

在积分估计中，有偏估计器虽然期望值不等于真实值，但可能方差更小、收敛更快，而且一致估计器随着样本数增加仍能得到正确结果；在 Monte Carlo 渲染中，绝大多数估计器是无偏的，光子映射是一个例外。

MSE（均方误差）：估计值与真实值之间的平方误差的期望（方差是估计值与估计值比较，均方误差是估计值与实际值比较）

对于无偏估计，那MSE就等于方差，否则即为方差与估计量偏差平方之和。

最后这点东西介绍，需要明白蒙特卡洛积分本身也是一个随机变量（因为他通过采样多个独立的随机变量来进行的），所以可以求蒙特卡洛的方差和均方误差，求法就是用样本进行估计，下边两幅图就是如何通过样本估计蒙特卡洛的方差和均方误差

这里提到的应该就是用样本估计随机变量的方差（也就是如何量化一个蒙特卡洛积分的方差）

利用样本估计的方差，是实际方差的估计值，所以本身也有方差

另外提到了MSE如何估计

Improving Efficiency 提升效率

Stratified Sampling 分层采样

简单理解就是把积分域划分为多个区域，每个区域按照自己的PDF去进行蒙特卡洛积分

把随机采样改成了在每个子区域随机采样，

下图i代表第i个积分区域，j代表第j个样本

随机采样结果

分层采样结果，对比能看出噪声更小了

分层采样的缺点与维度有关，维度太多分层也变得复杂

Importance Sampling 重要性采样

重要性抽样是一种强大的方差缩减技术，其原理基于蒙特卡洛估计量的特性

原理：若样本取自与被积函数函数形式相似的分布，则收敛速度更快。

如果被积函数是上图，PDF用下图，那最终得到的蒙特卡洛的方差要比随机采样好很多

PDF中间高，说明在这些点采样的概率高，在采样时也就更逼近真实的数据，很好理解的效果好

Multiple Importance Sampling 多重重要性采样

在面对被积函数是多个函数相乘（比如渲染方程就是BRDF Li cos 三项)的情况下的优化方案

首先举个例子，假如有两个PDF，刚好对应两个f(x)，如果我们使用PDFa作为采样的PDF时，最终样本都会只剩下fb(x)，因为PDFa与fa(x)更好成比例

此时蒙特卡洛积分的方差完全由fb(x)的方差决定，但他的方差可能是很高的，另外这是不可控的，因为被积函数是不能变动的。所以单纯依赖被积函数某一项的形状设计PDF，是不可靠的

MIS就是用来解决这个问题的

MIS的采样方案是

也就是用光源相关的PDF采样一次，用BRDF相关的PDF采样一次，并乘以各自的权重。

总结成公式就是

那权重如何计算呢（MIS 的权重来自一个要求：在保持无偏的前提下，让方差尽可能小。）PBRT 默认使用的是 Balance Heuristic。

抛开每种PDF生成的样本数量不谈，权重就是 PDF/所有PDF

更进一步，乘个幂次

紧接着提到单样本模型（Single-Sample MIS），其实就是上边的n都=1，就是每个PDF都只采样一次，方差就很低了

MIS Compensation 多重重要性采样补偿

比如一个渲染场景，光源项PDF与BRDF的PDF两个PDF进行多重重要性采样

这个东西必须学习完MIS并且实践后才能感悟他在干什么，这里先简单理解一下

此时的蒙特卡洛估计的MIS

BRDF在高光方向大量采样，但是这里的光源=0，最终采样样本=0

光源方向采样也因为权重被削弱

MIS虽然考虑到了不同的PDF的配合，但是如果一个PDF大量覆盖了积分接近0的区域，方差并不是最优

BSDF PDF 在“根本没有光”的方向仍然给了概率，总之就是在MIS的情况下，仍然会让积分区域接近0的位置分布大量的采样

一种MIS补偿方案是锐化概率分布，就是说在概率很小的地方，直接让他概率为0，不进行采样

低于阈值的概率 → 直接砍掉
剩下的概率 → 重新归一化
结果：PDF 更“尖锐”（sharpened）

Russian Roulette

跳过贡献度较小的样本，提升蒙特卡洛性能，同时保证无偏

C通常是0，q是一个[0-1]均匀分布的随机变量，有1-q的概率继续计算，有q的概率停止

可以看出来这样做并没有改变蒙特卡洛积分的无偏性

Splitting

同样需要结合具体场景来学习，这里先简单过一下

对于一个二重积分

每次采样都需要重新计算x样本和y样本

每次都要重新采 x

如果 x 很贵（比如一次主光线 / 路径前缀）

Splitting：核心思想

x 很贵，y 很便宜，那就：

先采一次 x

对这个 x，多采几个 y

Sampling Using the Inversion Method 逆变换法采样

已知PDF情况下，解决如何按照这个PDF进行采样的方法：反演变换法从CDF来进行采样

一句话解释思路就是：1. 根据$\xi$ 得到一个[0-1]直接的随机数，然后让 CDF函数 = 这个值，反向求出X

CDF图像的斜率就是PDF值，斜率越大，说明这个采样点的概率越大，同时斜率越大的区域在Y坐标被均匀采样的概率越大，总结结果就是用一个均匀分布采样结果为 PDF越大的区域越容易被采样

离散情况

利用均匀采样配合权重来按照权重进行采样，最终结果是按照权重来提高概率，算法本质是均匀采样

需要前边的公式，$\xi$ 是[0-1]之间均匀分布的随机变量， X是离散的随机变量，这个公式展示了如何从$\xi$去随机选择哪个X作为样本。也就是说用均匀分布的随机变量来采样X

这一操作在CDF图像上就是$\xi$ 取值作为Y轴位置，向右看对齐到哪一列就去Xi

这个东西的作用是在一个权重数组中，通过均匀分布来选择其中一个 最终结果不是均匀采样的，而是按照权重大小来进行的，但是过程本质利用的是均匀采样

这个代码最终返回一个权重索引，满足

连续情况

利用PDF对应的CDF来进行

从PDF采样的步骤：

计算CDF
还是利用均匀分布产生的随机数
构建等式$\xi$ = CDF(X)，反过来就算出来X是什么了

Transforming between Distributions

把上一章讲的逆变换法推演到任意情况，随机变量X的信息都知道，现在利用X对随机变量Y=f(X）进行抽样的方法

感觉目前不会遇到这样的问题，先跳过，不然学了也是忘

RayTracingTheNextWeek

Sat, 15 Nov 2025 12:22:52 +0800

Motion Blur

思路是给Ray定义一个时间，表示光线的行进时间，判断光线与模型求交时，先用Ray的持续时间来计算模型在当前时间的位置，在新的位置上计算求交，因为发送的射线的时间是随机设置的，所有他们与球求交的是空间上不一致的，所以移动的物体就会出现模糊，本质也就是渲染时，不同像素收集到的是不同时间段的模型颜色，真实相机拍摄运动物体时，快门从打开到关闭的这段时间（比如 1/100 秒）内，物体一直在移动，传感器会记录下这段时间内物体在不同位置的所有光线信息，所以这种近似属于Hack

Bounding Volume Hierarchies

BVH_node 可以继承 : public hittable，与 sphere 的继承一样。相机遍历hittable_list时，会执行BVH_node本身的hit函数，函数内就有树形检索逻辑，加快击中判定

构建BVH的流程，是一个递归函数，用start和end表示要处理的objects范围，递归时，设置为原来的一半作为子节点

bvh_node(std::vector<shared_ptr<hittable>>& objects, size_t start, size_t end) {
    // 随机选择一个轴方向
    int axis = random_int(0,2);
    // 排序器
    auto comparator = (axis == 0) ? box_x_compare
                    : (axis == 1) ? box_y_compare
                                  : box_z_compare;

    size_t object_span = end - start;

    if (object_span == 1) { // 只有一个物体
        left = right = objects[start];
    } else if (object_span == 2) { // 有两个物体
        left = objects[start];
        right = objects[start+1];
    } else {
        // 在某个轴方向对objects进行排序
        std::sort(std::begin(objects) + start, std::begin(objects) + end, comparator);
        // 划分为两半
        auto mid = start + object_span/2;
        // 递归构建子节点
        left = make_shared<bvh_node>(objects, start, mid);
        right = make_shared<bvh_node>(objects, mid, end);
    }
	// 更新包围盒
    bbox = aabb(left->bounding_box(), right->bounding_box());
}

进一步优化，每次都选择最长的轴方向进行划分，因为物体在最长轴上的离散度最高，这样划分包围盒的重叠最少

bvh_node(std::vector<shared_ptr<hittable>>& objects, size_t start, size_t end) {
        // Build the bounding box of the span of source objects.
        bbox = aabb::empty;
        for (size_t object_index=start; object_index < end; object_index++)
            bbox = aabb(bbox, objects[object_index]->bounding_box());

        int axis = bbox.longest_axis();
        // 排序器
        auto comparator = (axis == 0) ? box_x_compare
                        : (axis == 1) ? box_y_compare
                                      : box_z_compare;

        size_t object_span = end - start;

        if (object_span == 1) { // 只有一个物体
            left = right = objects[start];
        } else if (object_span == 2) { // 有两个物体
            left = objects[start];
            right = objects[start+1];
        } else {
            // 在某个轴方向对objects进行排序
            std::sort(std::begin(objects) + start, std::begin(objects) + end, comparator);
            // 划分为两半
            auto mid = start + object_span/2;
            // 递归构建子节点
            left = make_shared<bvh_node>(objects, start, mid);
            right = make_shared<bvh_node>(objects, mid, end);
        }

        bbox = aabb(left->bounding_box(), right->bounding_box());
    }

纹理

生成球的UV

做法是3D坐标转为球面坐标，再转为UV坐标

3D坐标与球面坐标的转换

四边形

一个点Q+两个方向UV来定义一个四边形

求交运算

找到四边形对应的平面
光线与平面相交
确定交点在四边形内

四边形所在平面方程

定义平面：

法向量：

已知平面的法向量n，另外四边形的uv向量与法线n垂直（也就是说说u*v（叉乘）后的方向就是法线方向，这样就求出了ABC）

进一步，点Q落在平面上（已经知道ABC就是法向量的xyz，这样就可以通过带入法线和Q求解D，就求解了平面的方程）

光线与平面求交

点位置可以表示为光线P+td

求解D时，是用法线和点位置求解的，上一步已经求出D是多少了。现在反过来就可以求t

现在点位置用Ray表示后，求解D的方程表示为：

求解t得到光线相交于平面的时间

判定点是否在四边形内部

判断前需要在2D平面有一个基准坐标系，来表达任何点在平面上的位置

直接用Q点表示原点，UV向量来表示坐标系（不平行即可）

此时平面上任意一点可以表达为（$\alpha,\beta$）

突然用公式求解出（$\alpha,\beta$）的值

推导流程

求解出$（\alpha,\beta）$后，按下图判断点是否在四边形内部

发光材质

给材质一个发光函数，根据击中的位置，返回一个发光颜色。

class material {
  public:
    virtual ~material() = default;
    virtual color emitted(double u, double v, const point3& p) const {
        return color(0,0,0);   
    }

    virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const {
        return false;
    }
};

击中物体计算颜色时，首先进行自发光判断，再进行scatter递归

color ray_color(const ray& r, int depth, const hittable& world) const {
    // If we've exceeded the ray bounce limit, no more light is gathered.
    if (depth <= 0)
        return color(0,0,0);
    hit_record rec;
    // If the ray hits nothing, return the background color.
    if (!world.hit(r, interval(0.001, infinity), rec))
        return background;
    ray scattered;
    color attenuation;
    color color_from_emission = rec.mat->emitted(rec.u, rec.v, rec.p);
    if (!rec.mat->scatter(r, rec, attenuation, scattered))
        return color_from_emission;
    color color_from_scatter = attenuation * ray_color(scattered, depth-1, world);
    return color_from_emission + color_from_scatter;
}

平移和旋转

这里介绍的平移旋转并不是对模型进行平移旋转，而是模拟光线与平移后的模型击中来计算着色，也就是说移动光线，达到平移物品的目的

平移变换 (Translation)

平移是最简单的变换。

目标：我们想让一个物体沿着向量 offset 移动。
方法

：
1. 变换光线：在判断光线 r 是否与平移后的物体相交时，我们先将光线 反向平移 offset 个单位，得到一条新的光线 offset_r。
2. 求交：用这条 offset_r 光线与原始位置的物体进行相交测试。
3. 逆变换交点：如果 offset_r 与原始物体相交于点 p，那么这个交点在世界空间中就位于 p + offset 的位置。我们将计算出的交点 rec.p 进行正向平移，得到最终的交点。

旋转变换 (Rotation)

旋转比平移复杂，因为它涉及到三角函数，并且还需要变换光线的方向向量和表面法向量。

目标：我们想让一个物体绕 Y 轴旋转 θ 角。
方法

：
1. 变换光线：在判断光线 r 是否与旋转后的物体相交时，我们先将光线的原点和方向都进行 反向旋转 -θ（即顺时针旋转 θ）。
2. 求交：用这条变换后的光线与原始朝向的物体进行相交测试。
3. 逆变换交点和法向量
  
  ：
  - 如果相交，得到的交点 p 和法向量 normal 是在物体的局部空间中的。
  - 我们需要将它们正向旋转 θ（逆时针旋转 θ），变换回世界空间，作为最终的结果。

RayTracingOneWeek

Wed, 12 Nov 2025 13:26:10 +0800

Ray-Sphere Intersection

显式：“谁等于谁的函数”。
隐式：“变量们满足某个共同等式”

球公式用向量形式表达为：

$$ (\mathbf{C} - \mathbf{P}) \cdot (\mathbf{C} - \mathbf{P}) = (C_x - x)^2 + (C_y - y)^2 + (C_z - z)^2 $$

也就是

$$ (\mathbf{C} - \mathbf{P}) \cdot (\mathbf{C} - \mathbf{P}) = r^2 $$

给一个点P(t)，如果与圆相加，说明这个公式有解

$$ (\mathbf{C} - \mathbf{P}(t)) \cdot (\mathbf{C} - \mathbf{P}(t)) = r^2 $$

P(t)可以用Ray来表示，Ray = Q + td

经过一系列变换，最后用求根公式可以直接算出t的取值，或者用判别式直接获取解的个数

// 判断r是否与这个球体相交
bool hit_sphere(const point3& center, double radius, const ray& r) {
    auto a = dot(r.direction(),r.direction());

    auto b = -2*dot(r.direction(),center-r.origin());

    auto c = dot(center-r.origin(),center-r.origin()) - radius * radius;

    auto discriminant = b*b - 4 *a *c;
    return discriminant > 0;
}

1
2
3

if(hit_sphere(point3(0,0,-1),0.2,r)){
    return color(1,0,0);
}

// 返回t
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) {
        return -1.0;
    } else {
        return (-b - std::sqrt(discriminant) ) / (2.0*a);
    }
}

Simplifying Code

求根公式中，把原始b带入发现可以化简

抗锯齿

像素中心击中物体就是一种颜色，没有击中就是另一种颜色，没有过度，锯齿就会出现。（对一个像素进行着色，一条光线只取一个点的颜色，但是一个像素对应世界位置的一片颜色不一定是一样的，而是连续的）

初始采样点为像素中心，每个像素多次调用git_ray(),他会在一个像素中随机进行采样

    vec3 sample_square() const {
        // Returns the vector to a random point in the [-.5,-.5]-[+.5,+.5] unit square.
        return vec3(random_double() - 0.5, random_double() - 0.5, 0);
    }
    ray get_ray(int i, int j) const {
        // Construct a camera ray originating from the origin and directed at randomly sampled
        // point around the pixel location 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 = center;
        auto ray_direction = pixel_sample - ray_origin;

        return ray(ray_origin, ray_direction);
    }

漫反射材质

hit后，不是直接返回颜色，而是继续发射一根随机半球方向的光线继续进行光线追踪，击中物体后累加，另外需要设置递归深度防止无限递归

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

Fixing Shadow Acne

如果光线起点恰好位于表面正下方（浮点数的舍入误差），它可能会再次与该表面相交。

镜面反射

v+2B就是静面反射向量，B可以通过dot(v,n)*n来求

1
2
3

inline vec3 reflect(const vec3& v, const vec3& n) {
    return v - 2*dot(v,n)*n;
}

RT实现这种间接光照太容易了

电介质材质（折射）

当从折射率高的一边看向折射率低的一边，如果入射角度过大，用反射定律计算出来的折射光线角度超过了90°，这时候就应该只进行反射，而不进行折射。（教程有折射相关的内容，本质就是把反射替换成折射来进行二次弹射）

Defocus Blur 景深/散焦模糊

成像平面的距离改用焦距来定义，所以在成像平面位置的渲染才是清晰的

// 根据fov和Near计算视口宽高
auto theta = degrees_to_radians(vfov);
auto h = std::tan(theta/2);
auto viewport_height = 2 * h * focus_dist;
auto viewport_width = viewport_height * (double(image_width)/image_height);

// 构建光线时，先在像素内部随机采样，获得一个摄像终点，但是射线起点不再是相机的位置，而是以相机位置为中心的一个圆盘（可调整半径）上的任意一点作为摄像起点
ray get_ray(int i, int j) const {
    // Construct a camera ray originating from the defocus disk and directed at a randomly
    // sampled point around the pixel location 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) ? center : defocus_disk_sample();
    auto ray_direction = pixel_sample - ray_origin;

    return ray(ray_origin, ray_direction);
}

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() > 0.9) {
                shared_ptr<material> sphere_material;

                if (choose_mat < 0.8) {
                    // diffuse
                    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) {
                    // metal
                    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 {
                    // glass
                    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       = 1200;
    cam.samples_per_pixel = 500;
    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);
}

每个像素采样500次，并且深度为50的结果

博客日记（记录看大佬博客的一些思考）

Tue, 11 Nov 2025 13:43:46 +0800

API差异图

2025.12.16

https://zhuanlan.zhihu.com/p/582237962 全局光照浅析

现实中的反射大部分情况下并不是mirror reflections也不是diffuse reflections，而是介于两者之间，这种反射叫做glossy reflections，对应的材质也叫做glossy 。这下把这些名词都对应上了~

Caustics焦散在图形学中的定义是指光线经过高光物体的反射或折射，然后弹射到漫反射表面，再弹射到眼睛的效果，如上图中书下面阴影中高亮的部分。Caustics很难实现，即便在离线渲染中使用path tracing也很难实现，通常会借助Photon Mapping光子映射技术来实现Caustics。 第一次接触这个词！

下图可以看到在书下面的阴影中也有很亮的地方，叫做焦散

下面是几种离线渲染的全局光照方案

Whitted-Style Ray Tracing

从视点发射光线。
光线碰撞到物体表面，如果表面材质是diffuse材质则光线停止传播，否则沿着反射方向继续传播。
每个碰撞点都需要发射一条shadow ray做遮挡查询。
shading point需要累加所有碰撞点的Irradiance，作为最终的光照结果。

Whitted-Style Ray Tracing算法无法实现右边的glossy reflection效果，因为光线是按照镜面反射的方式传播的，真实世界大部分物体都不是mirror materail。

原来 Mirror和Glossy是要区分的。另外Games101讲的Whitted-Style Ray Tracing原来就是丐版的pathTracing，因为只进行镜面反射，所以没法实现glossy的反射

因为漫反射不递归，所以漫反射全局光照效果肯定是没有的

Distributed Ray Tracing

基本思路和Whitted-Style Ray Tracing一样，只是为了解决漫反射光线传播，在每一个碰撞点上的半球空间都会发射多条光线来模拟漫反射。

算法的缺点非常明显就是计算量爆炸，这个算法即便是离线渲染也是不能接受的，不过这个算法应该是最朴素也是效果最好的光线追踪算法，说不定以后硬件性能爆炸，这个算法也有回春的一天。

Path Tracing

这个算法的最大问题是光线命中光源的概率很低，因此会有很多噪点。

通过加大光源面积和投射光线的数量可以缓解这个问题。另外可以把每个碰撞点的光照分为直接光照和间接光照，直接光照从光源中进行采样以保证命中概率，并且直接光照会做shadow ray，而间接光照还是使用上面的算法，这样噪点仅存在于间接光照的部分

Bidirectional Path Tracing

这里能看出PathTracing的缺点：如果场景主要是间接光照照亮的，那PathTracing效果就会很差

有的时候光源的环境很复杂，使用上面的Path Tracing依然会获得很低的光源命中率，如下图：

现实中这种情形，照亮场景的应该是间接光照，而间接光照的命中率又很低，所以上面的算法不太适用这种场景

双向路径跟踪算法（Bidirectional Path Tracing，BDPT）在路径跟踪算法的基础之上，额外从光源出发创建光路，再连接从照相机追溯的光路和从光源出发的光路上的点，创建多条光路，并根据光线从这些光路传播的概率，合并各个光路传递的辐射亮度，即进行所谓的多重重要性抽样（multiple importance sampling），计算光线最后进入照相机生成图像的光照结果，如下图：

光子映射Photon Mapping

Path Tracing算法最大的问题就是光路命中光源的概率太低，即便是使用大量的SPP也会产生很多高频的噪点。另外在光线传播的过程中光路都是随机生成的，Caustics这种需要先弹射到镜面然后再弹射到漫反射物体的命中概率就更低了，因此Path Tracing很难模拟Caustics效果。

光子映射的基本算法分成两个Pass。

Pass1-光源从随机方向发射光子，并在一切表面上弹射，如果弹射的表面是diffuse材质则记录光子信息包括光子的POS，光子的能量POWER，光子的入射方向Dir，可以把这些光子理解成为次级光源，使用俄罗斯轮盘算法结束光子的递归弹射，这样可以保证能量守恒。这些光子信息与视点无关，所以可以保存起来供后续pass使用，这也是空间换时间的算法。
Pass2-从相机射出的光线，打到非diffuse材质表面进行反射或折射，打到diffuse材质表面则根据收集半径检索附近的光子进行间接光照计算。

下面是实时渲染的全局光照解决方案

Light Probe(Irradiance Volume)

light probe就是在空间中摆放很多的probe，这些probe可以当成次级光源，在离线的时候将irradiance保存到probe中，通常使用球鞋函数来缓存光照信息。

这样空间中的每个点都可以找到离它最近的四个probe，这四个probe可以构成一个四面体，然后计算四面体的重心位置，通过重心位置和坐标点进行差值来计算最终的光照信息，如下图：

DDGI其实就是Irradiance Volume的实时版本，它利用实时光线追踪来计算probe信息，而Irradiance Volume是离线计算的，从这点上来说DDGI是完全支持动态光源的算法，但是它依赖可以做实时光线追踪的硬件或者是使用Ray Marching。另外DDGI使用了切比雪夫不等式来预测probe是否被遮挡，减缓漏光问题。DDGI的核心是优化Irradiance volume的更新

漏光的原因是采样到了实际上被遮挡的探针，DDGI使用切比雪夫不等式原来就是用来预测Probe是否被遮挡

下面还介绍了LPV、VXGI，这个等实现时再看

GIBS

GIBS与VXGI不同之处是VXGI将场景的物体表面离散成了voxel，而GIBS将场景表面离散成了surfel。描述一个surfel的基本数据结构是位置，法线和半径，这就定义了一个2D的圆形表面

PRT

PRT就是将光照方程进行拆解，然后用球谐函数记录每个部分，利用球谐函数的性质还原光照方程，因为light transport部分包含场景的遮挡关系且这部分是预计算的所以PRT只支持静态场景动态光源。

SSGI

ssgi是基于屏幕空间的全局光照算法，利用深度信息进行Ray Marching，效率不如SDF，但是不需要额外的存储空间，因为是基于屏幕空间的光照算法，所以缺少屏幕外的光照信息。

Lumen

ue5的lumen主要是实现了一套软光线追踪算法，其中涉及的内容几乎包括了上面所有介绍的实时全局光照算法，会单独写一篇文章介绍，这里就不详细介绍了。

总结一下实时全局光照算法，基本分为三个步骤：

离散化场景空间或物体表面，probe，voxel，surfel，均匀网格，还有一个lumen的mesh card后面介绍。
计算Irradiance cache。
利用Irradiance cache还原光照方程。

另外有一个东西是 SDF实现的raymarch不太了解

2025.11.21 丛越

https://zhuanlan.zhihu.com/p/73016473

看了人家的管线设计才发现自己费那么多劲琢磨架构是多么的无知，当前阶段还是多输入少输出吧

原来Buffer还能这么复用（在不同时段通过别名资源重用内存）

GPU驱动管线（下一步学习计划！）

Vulkan的内存模型

Vulkan 的内存分为 Host 和 Device 两大类，下图可以看到哪些是Device可见的，哪些是Host可见的

并行 Command

尽管从 API 层面来看 Command 是依次录制的，但 GPU 在执行时是将 Queue 中的指令同时分发给 GPU 多核中的 Pipeline 执行，这就是 GPU 的并行计算机制。而这种并行，是不会保证执行的顺序，所以对于提交到 GPU 执行的 Command，需要了解以下几个事实：

Command 在 Command Buffer 中顺序并不代表在 GPU 内部执行的顺序。
提交到同一 Command Queue 中不同 Command Buffer 的顺序并不代表在 GPU 内部执行的顺序。
不同 Command Queue 的提交顺序不代表在 GPU 内部执行的顺序。

Pipeline Barrier

TODO： https://zhuanlan.zhihu.com/p/100162469

下面图片的每个块表示一个Pipeline Stage

2025.11.11 SaeruHikari

GBuffer压缩

Gbuffer是可以压缩的(https://zhuanlan.zhihu.com/p/95824400)。

GBuffer会带来显卡的带宽压力, 所以现在的游戏一般会把GBuffer压缩到2~3张。比如把法线压缩到2通道并在使用时进行Decode, 或者不保存PosW到GBuffer, 而是在使用时使用深度重建。可以参照顽皮狗在Sig16分享的方案:

不同的BRDF方案

可以学习并实践一下不同的BRDF方案，而不是就还是Lambert + Cook-Torrance

Diffuse

首先看漫反射部分, 目前比较流行的公式有这些可选:

Lambert
Burley(Disney)[sig2012]
Renormalized Disney Diffuse[sig2014]
PBR diffuse for GGX_Smith[GDC 2017]
MultiScattering Diffuse BRDF[sig2018]

在五个模型都尝试一遍过后选择了RenormalizedDisneyDiffuse。

这里特别要提一句的是MultiScattering版本的diffuse BRDF, 在今年的sig也有对它实现的补充以及改进分享。但是实测之后发现效果并不好, 因为多散射对diffuse的影响实在太小, 这个模型并不能带来太多可见的改善。

而Frostbite在14年sig[3]提出的Renormalized Disney Diffuse是带来观感改善较大的一个:

Moving Frostbite To PBRwww.ea.com/frostbite/news/moving-frostbite-to-pb

它主要对Burley模型进行了改进, 根据视角入射角对Diffuse进行补正来维持能量守恒, 在视角移动时产生的视觉效果更加细腻(当然光源太复杂就没那么明显了…)。

Specular

接下来来到BRDF里最重要, 组装起来也最好玩的Specular BRDF项:

(Cook-Torrance)

D(h): 法线分布函数, 描述微面元法线分布的概率, 具有正确朝向，能够将来自l的光反射到v的表面点的相对于表面面积的浓度。
F(l,h) : 菲涅尔方程, 描述不同的表面角下表面所反射的光线所占的比率。
G(l,v,h) : 几何函数/几何遮蔽，描述微平面自成阴影的属性，即m = h的未被遮蔽的表面点的百分比。
**分母 4(n·l)(n·v）：**校正因子，作为微观几何的局部空间和整个宏观表面的局部空间之间变换的微平面量的校正。

这里不再细致解释, 列出常用的模型, 这些模型在UE4几乎都有实现, 可以到BRDF.ush去参考(抄):

Specular D:

Blinn-Phong[1977]
GGX/GTR[2007/2012] (GGX(GTR2)作为GTR的特例)
以及各种各向异性版本…

SpecularF

Cook-Torrance[1982]
Schlick[1994] (一般选用这个, 便宜且曲线非常贴紧参考值)

SpecularG

Cook-Torrance[1982]
Smith[1967] (被拓展为l, v的联合遮蔽函数, 具有多种变体)

TAA

一直没管过引擎的走样问题。。。待学习完善

RGD

https://zhuanlan.zhihu.com/p/97022384 这里有RGD的实现思路，学习RGD可以参考

反射

https://link.zhihu.com/?target=https%3A//github.com/rttrorg/rttr ， SaeruHikari用的这个反射

多线程渲染?

博客提到的多线程是指多个queue，和我现在实现不一样啊

2025.11.12

匿名资源、临时资源

这个东西我的项目有进行规整，所有资源都做了保存（应该：无名未注册的资源会被保持在一个池内, 并由系统进行自动化的复用。）

RDG

蓝色表示PassNode, 白色圆角表示ResourceNode, 实际资源存储在Container中。

纹理、Buffer、Pass创建都是走的RDG

RDG需要处理多帧资源比如TAA

Games104：物理引擎的基础理论

Tue, 04 Nov 2025 11:04:19 +0800

主要讲了欧拉积分、碰撞检测方法、碰撞结算方法物理世界的对象:

Static
Dynamic
Trigger(参与GamePlay但是与物理世界无关)
Kinematic（动力学Actor）

Actor Shapes

欧拉积分

黎曼积分定义为：

$$ \int_a^b f(t) \, dt = \lim_{n\to\infty} \sum_{i=0}^{n-1} f(t_i^*) \, \Delta t $$

其中：

区间 $[a,b]$ 被划分为很多小区间；
每个小区间长度为 $\Delta t = \frac{b-a}{n}$；
$f(t_i^*)$ 是函数在区间上的一个采样值；
积分就是“采样 × 宽度”的极限

显式欧拉法 = 左端点采样（Left Riemann Sum） 隐式欧拉法 = 右端点采样（Right Riemann Sum）

显式欧拉积分

用当前状态的参数来近似 $\Delta T$ ，比如$t_0时速度为5，那就假设$$\Delta T$内都是5来模拟积分。显式欧拉法 = 用左端点采样的黎曼积分近似。

这样求积分的问题是：力不守恒，用因为时间段内力不是恒定的。如下图所示，如果总是以某一点的力的方向来求解，那物体总是朝着切线方向位移，来不及改变力的方向（因为在$\Delta T$时间内力是恒定的）

隐式欧拉方法

用未来的状态来计算$\Delta T$时间内的数据。隐式欧拉法 = 用右侧端点采样的黎曼积分近似。

显然能量衰减了，我在$\Delta T$时间内又不是一直这么小

半隐式欧拉法

有点像Hack…..

这种方法数学上很稳定 $\Delta T$取0.05就能很好模拟圆周运动了

刚体运动学

这块课程很杂，应该需要用到什么学什么，这里先听课

碰撞检测

一般分两步：

AABB检测
计算碰撞点

Broad Phase

BVH检测

排序检测

Narrow Phase

用球的半径来检测

闵可夫斯基和（Minkowski Sum）

两个点集内全部互相加

红色三角形表示Minkowski Sum的结果

再定义减法

最妙的来了，如果红色图像包了原点，那就碰撞了

如何判断这个多边形过原点呢？

分离轴原理(SAT)

碰撞处理

处理碰撞后分离

Hack

约束求解

需要再看

Scene Query

查询碰撞点、查询Sweep、查询Overlap

raycast查询碰撞点：比如子弹

Sweep

Overlap：比如爆炸范围overlap了那些Actor

优化

模拟优化

CCD：连续碰撞检测，离散检测可能会穿过薄面

确定性模拟：不同的机器计算结果应该一致，比如显卡、移动端等差别

Games104：引擎工具链

Wed, 29 Oct 2025 14:42:31 +0800

讲了 GUI架构、Asset的序列化和反序列化、Redo undo实现、反射等技术

反射

为什么需要反射

我定义一个定向光组件，刚开始有方向和强度，我想在GUI实时修改，就需要在imgui添加两个按钮来调整，但是定向光的属性越来越多，我并不希望每次都要修改imgui界面来修改，这种就可以让imgui拿到定向光的反射来自动生成

C++实现

Piccolo 借助 Clang AST，相当于直接复用了编译器的语法分析，通过在需要反射的类和属性上做标记，让clang AST分析后就会带上这个标记，从而知道了这些信息。再下一步就是生成对应的反射类（就是自动生成的一些cpp文件，这些文件就包含了GetSet方法来设置原本被反射的类的信息

这节内容主要是反射了解一下

Beyond Polygons 超越多边形

Wed, 29 Oct 2025 13:51:52 +0800

这里主要说出了三角形渲染，还有其他的渲染方式，主要是了解各种优化渲染技巧

天空盒

…

光场渲染

Radiance 捕获与计算摄影

Radiance（辐射亮度）可以在：
- 不同位置
- 不同方向
- 不同时间
- 不同光照条件下进行捕获。
计算摄影领域研究如何从这些捕获的数据中提取有用结果，例如高动态范围成像（HDR）、光照重建等。

基于图像的物体表示

Lumigraph 和 光场渲染（Light-field Rendering）：
- 通过一组离散观察点捕获物体。
- 给定一个新视角，通过在已存储视图之间插值生成新视图。
- 类似于全息摄影（Holography）：用二维视图数组表示物体。
优点：
- 能够表示任意复杂表面与光照。
- 显示速率几乎恒定，与物体几何复杂度无关。
缺点：
- 数据量大，需要存储大量视图。

Sprite和图层

Sprite（精灵图）：

屏幕上可移动的图像元素，例如鼠标光标、游戏角色。
不一定是矩形，支持透明像素。
简单sprite：每个像素直接映射到屏幕像素。
动画sprite：通过显示不同的sprite序列生成动画。

通用sprite：

将纹理渲染到始终面向观众的多边形（通常是四边形）上。
支持大小调整和拉伸。
Alpha通道提供透明度和边缘抗锯齿。
可包含深度信息，使sprite有三维位置。

场景可以看作是一系列sprite层：

典型例子：二维序列帧动画（cel animation）。
每层都有深度信息，用于确定前后关系。

渲染顺序：

画家算法（Painter’s Algorithm）：从后向前渲染，无需z-buffer。
相机移动时：
- 物体变大 → 可使用相同sprite或mipmap处理。
- 前景与背景的相对覆盖可通过修改sprite层位置调整。

广告牌技术

基于观察方向来修改纹理矩形朝向的技术被称为广告牌技术（billboarding），这个矩形被称为广告牌（billboard）

这就是通过两个向量构建正交基的办法：首先，计算 right 向量：

$$ \mathbf{r} = \mathbf{u} \times \mathbf{n} $$

然后，用 right 向量 和法线重新计算一个正交的 up 向量：

$$ \mathbf{u}' = \mathbf{n} \times \mathbf{r} $$

最终得到一个标准正交基：

$$ \{\mathbf{r}, \mathbf{u}', \mathbf{n}\} $$

这样 $\mathbf{r}$、$\mathbf{u}’$ 和 $\mathbf{n}$ 三个向量两两垂直。

有了这些初步的准备，剩下的主要任务就是决定用什么表面法线和up向量来定义广告牌的方向。构建正交基 + 平移 + 缩放的操作，其核心目的就是生成模型变换矩阵（Model Matrix），也就是把广告牌从局部模型空间变换到世界空间的矩阵。

屏幕对齐（screen-aligned）的广告牌

法线向量：
$$ \mathbf{n} = -\mathbf{v}_n $$
- $\mathbf{v}_n$ 是视平面法线，指向远离观察点。
- 法线指向观察者。
Up 向量：
$$ \mathbf{u} = \text{camera up vector} $$
- 定义了广告牌在视平面上的上方向。
Right 向量：
$$ \mathbf{r} = \mathbf{u} \times \mathbf{n} $$
- 由 up 和法线叉乘得到，完成正交基。
旋转矩阵：
$$ R = [\mathbf{r} \;\; \mathbf{u} \;\; \mathbf{n}] $$

面向世界（world oriented）的广告牌

两种不同对齐方式的广告牌的俯视图。根据不同的对齐方法，五块广告牌的朝向也不同。

特性	屏幕对齐（Screen-aligned）	面向视点（Viewpoint-oriented）
法线方向	固定指向视平面	指向观察者
扭曲情况	对所有sprite相同，远处可能被拉伸	遵循真实透视，投影形变正确
使用场景	小sprite、文本注释、地图标记	粒子效果、火焰、烟雾、爆炸等
渲染复杂度	低	高，需要每帧计算法线

Wang [1839, 1840]详细介绍了微软飞行模拟器产品中所使用的云建模和渲染技术。每片云都由5到400块广告牌组成，但是只需要16种不同的基本sprite纹理即可实现各种各样的云，因为这些基本的sprite纹理可以使用非均匀缩放和旋转来进行修改，从而组合形成各种各样类型的云。还会根据距离云中心的距离来修改该点的透明度，从而模拟云的形成和消散。为了节省处理时间，远处的云都被渲染为一组环绕场景的8个全景纹理，类似于天空盒。

轴向广告牌

最后一种常见类型的广告牌被称为轴向广告牌（axial billboarding）。在这个方案中，被纹理化的物体通常并不会直接面对观察者。相反，它可以围绕一些固定的世界空间轴进行旋转，并在这个范围内尽可能多地面向观察者。

当观察者在场景中移动时，灌木广告牌会发生旋转以面向前方。在这个例子中，灌木从南面被照亮，因此不断变化的视野会使得整体着色随着旋转而发生变化。

广告牌类型	法线朝向	Up 向量	特点	示例
屏幕对齐（Screen-aligned）	固定视平面法线	相机 up	固定旋转矩阵，适合小sprite/文本	HUD、标记
面向视点（Viewpoint-oriented）	指向观察者	尽量对齐世界 up	可保持透视形变	粒子效果、火焰、爆炸
轴向（Axial）	尽量面向观察者，但绕固定轴	世界 up	保持直立，适合圆柱形对称物体	远景树木、光柱、激光束

Impostor

Impostor 是一个广告牌，通过渲染复杂物体到纹理上，然后将纹理映射到广告牌上，替代原始几何体。

在左边，通过视锥体从侧面观察物体，从而创建了一个impostor。观察方向朝向物体的中心点\mathbf{c}，使用这个相机设置渲染一副图像，并将其用作impostor纹理。如右侧所示，将imposter纹理应用于一个四边形上。impostor的中心等于原始物体的中心，法线（从imposter中心发出）直接指向视点。

位移技术

通过图像编码几何信息：不仅是颜色，也包括高度、深度、法线

优势：

减少几何复杂度
与传统impostor或sprite相比，渲染更真实

应用场景：

远景人群、粒子系统、点云
复杂表面细节建模（纹理化模拟几何）

粒子系统

等学习GPU粒子时再记录

定义：由独立微小物体组成的集合，通过算法控制运动和生命周期（创建、移动、修改、删除）。

应用：火、烟、爆炸、水流、星系等自然现象和特效。

渲染：

每个粒子可以是单像素、轨迹线段或四边形广告牌（sprite）。
圆形粒子可只考虑位置，不必考虑旋转方向。
可以用几何着色器生成，也可用顶点着色器生成，后者更高效。

纹理：可使用颜色、法线、法线贴图等。

点渲染

概念：使用点（point）作为基本图元来表示物体表面，然后通过高斯滤波填补点之间的空隙。
历史：
- 1985 年，Levoy 和 Whitted 首次提出。
- 约 15 年后再次兴起，原因：
  1. 计算能力提升，支持交互速率渲染；
  2. 激光扫描仪等设备提供高密度点云数据（RGB-D、LIDAR、Kinect、iPhone TrueDepth、Tango、自动驾驶激光雷达等）。
点云数据：每个点通常包含位置、颜色/强度，有时还有分类信息（建筑、路面等）。

体素

体素化输入来源

点云：扫描设备生成的任意位置点。
多边形网格：通过 GPU 加速体素化。
医学影像：通过切片堆叠生成体素。
图像集合：可通过视觉外壳（visual hull）或轮廓切割生成体素。

常见体素化方法

六正交视图体素化（Karabassi et al.）：
- 从六个方向（上下左右前后）渲染深度。
- 标记不可见体素为内部体素。
- 优点：可识别内部体素；缺点：漏掉六视图不可见特征。
视觉外壳体素化（Loop et al.）：
- 基于相机捕获的轮廓图像生成体素。
- 只在可见像素位置生成体素，适合人体重建。
切片渲染体素化（Eisemann & Decoret）：
- 使用 32bit 渲染目标存储多层体素（slicemap）。
- 优点：可在 GPU 上一次渲染多层。
- 局限：只生成表面体素，无法识别内部体素。
现代 GPU 体素化：
- 计算着色器 + 图像加载/存储操作：
  - 支持随机读写纹理。
  - 可进行保守光栅化，记录与体素重叠的三角形。
- 可直接构建 SVO（Sparse Voxel Octree）：
  - 自上而下体素化非空节点。
  - 自下而上 mipmap 填充结构。
- 动态场景处理：
  - 渐进式更新体素（progressive voxelization）。
  - 使用深度缓冲清除/设置体素。

体素类型

实体体素：内部体素和外部体素完全分离。
26-分离体素：内部体素不与外部体素共享面、边或顶点。
6-分离体素：内部体素与外部体素共享边角（更保守的表面表示）。

存储方式

体素数据通常存储在三维数组或三维纹理中。
每个体素可用 bit 或更高精度数据表示状态（内部/外部、密度、颜色、法线等）。

渲染方法

直接立方体渲染：
- 将每个体素绘制为立方体。
- 相邻立方体共享面可剔除，减少多边形数量。
- 可使用快速贪心算法进一步合并小面片。
表面提取（Surface Extraction）：
- Marching Cubes：
  - 每个体素的 8 个角点确定表面穿过位置。
  - 通过查表生成三角形网格。
  - 可插值顶点位置以获得平滑表面。
- 水平集（Level Set）：
  - 体素存储到表面的距离（正内部，负外部）。
  - 可直接进行光线追踪或调整网格顶点位置。
稀疏体素光线投射：
- 针对稀疏体素数据直接进行光线投射。
- GPU 高效实现，支持交互式帧率。
锥形追踪（Cone Tracing）：
- 类似 mipmap 的采样方法。
- 支持软阴影、景深、可变法线滤波。
- 利用体素规则性进行区域采样。

优化与数据结构

八叉树（Octree）：
- 优点：易构建，支持稀疏数据。
- 缺点：树遍历开销大，动态变化不便。
VDB 树 / 索引表：
- 提高 GPU 光线追踪性能。
- 支持动态体素变化。
- 可分块流式加载，处理大规模场景。

Image Space Effects 图像空间特效

Tue, 28 Oct 2025 11:59:27 +0800

图像处理

这里介绍的就是什么是后处理，以及用三角形代替四边形的方法，这个我在OpenGL渲染器已经在使用了

紧接着介绍图像处理的高斯滤波器是一种常用的滤波核，其形状是著名的钟形曲线：

$$ \operatorname{Gaussian}(x)=\left(\frac{1}{\sigma \sqrt{2 \pi}}\right) e^{-\frac{r^{2}}{2 \sigma^{2}}} \tag{12.1} $$

将（b）中的权重乘上（c）中的权重，可以得到与（a）相同的权重，这表明两个滤波器实际上是等效的，因此是可分离的。使用（a）对一个像素进行滤波需要25个样本，而单独使用（b）和（c）对一个像素进行滤波分别只要5个样本，总共10个样本，这大大降低了计算量。

边界像素怎么取？在 GPU 后处理里，一般有以下几种方式来“处理边界外的像素”：

策略	名称	含义	视觉效果
Clamp to Edge（边界钳制）	最常用	超出范围的采样坐标自动钳制到最近的边界像素	✅ 边缘平滑、不会产生黑框
Repeat（平铺）	重复采样	超出范围部分从另一侧重头取样	🚫 不适合模糊，会出现重复图案
Mirror（镜像）	对称反射	超出边界部分以边界为轴镜像反射	✅ 比 clamp 更平滑，但略贵
Constant / Black（填充0）	超出范围直接返回黑色或常量	🚫 会产生黑边、亮度损失

因为Shader中采样本身就可以不在像素中心，他可以自动插值，所以3*3的滤波核不需要采样9次，而是把采样点放在两个像素之间。通过调整样本的权重，以及样本采样的位置达到原来滤波核的效果。（比如采样点偏向权重高的一边，那自然插值就会分配更高的权重）

下面讲了：

圆盘滤波器能产生漂亮的虚化，但代价高；可用复数技巧实现高效近似。
ComputerShader做这种操作效果更好（线程组共享内容，随意写入）
“移动平均（Moving Average）”技巧：对每行（或列）第一个像素计算完整滤波和；后续像素只需：加上进入核的新样本；减去离开核的旧样本；每个像素的模糊结果都能在 O(1) 时间更新。
下采样：先通过原图生成一张分辨率更低的图片，在低分辨率下进行滤波，再放大回去，效果类似，速度更快

双边滤波

图像处理中，双边滤波指的是 滤波权重同时考虑两个“方面”：

方面	解释
空间距离（Spatial）	像素离中心的物理距离：越近权重越大（普通高斯模糊的做法）
颜色差异 / 强度差异（Range / Intensity）	像素颜色或亮度差异：越相近权重越大，越不同权重越小（边缘保留）

使用像素着色器进行图像处理操作。其中左上角为原始图像，在其基础上进行了各种处理。右上角为高斯差分运算（Gaussian difference operation），左下角为边缘检测，右下角为边缘检测与原始图像混合后的合成图像。

乒乓缓冲区（后处理Pass的资源管理方式）

使用 两个离屏缓冲区（Framebuffer / Texture） 交替作为输入和输出。
流程示例：

Pass	输入	输出
第1个Pass	缓冲区 A	缓冲区 B
第2个Pass	缓冲区 B	缓冲区 A
第3个Pass	缓冲区 A	缓冲区 B

每个 Pass 都可以使用前一个 Pass 的输出作为输入，同时写入另一个缓冲区。
优点：不需要为每个中间结果创建新的纹理，节省 GPU 内存和管理成本。

重投影技术

利用上一帧已经渲染的数据来渲染本帧

反向重投影

会计算当前帧（t）和前一帧（t−1）的顶点位置。使用顶点着色中的z和w分量，像素着色器可以为t和t - 1时刻计算插值z/w，如果两帧之间的距离足够近，那么可以在前一帧的颜色缓冲中来对位置$\mathbf{p}_{i}^{t-1}$的颜色进行双线性查找，并使用这个颜色值来代替当前帧的颜色值，而不是重新计算一个新的着色值。

淡绿色的位置上一帧也是可见的，所以可以重用，暗绿色上一帧不可见，所以需要计算

为了获得更好的质量，还可以使用一个运行时平均滤波器（running-average filter）[1264, 1556]，它会逐步淘汰旧的着色值。它特别适用于空间抗锯齿（spatial antialiasing）、软阴影和全局光照。这个滤波器的描述如下：

$$ \mathbf{c}_{f}\left(\mathbf{p}^{t}\right)=\alpha \mathbf{c}\left(\mathbf{p}^{t}\right)+(1-\alpha) \mathbf{c}\left(\mathbf{p}^{t-1}\right) \tag{12.2} $$

其中$\mathbf{c}\left(\mathbf{p}^{t}\right)$是点$\mathbf{p}^{t}$上的新着色值，$\mathbf{c}\left(\mathbf{p}^{t-1}\right)$是前一帧中的重投影颜色，$\mathbf{c}_{f}\left(\mathbf{p}^{t}\right) $是应用滤波器之后的最终颜色。Nehab等人在某些用例中使用$α = 3/5$，但是他建议根据具体的渲染内容来尝试使用不同的值。

正向重投影

正向重投影则是从第t - 1帧的像素开始，并将它们投影到第t帧中，因此不需要进行两次顶点着色。这意味着来自第t−1帧的像素会被分散到第t帧中，而反向重投影方法则会收集从第t−1帧到第t帧的像素值。反向重投影方法还需要处理那些变得可见的遮挡区域，通常会通过一些启发式的空洞填充方法来完成，即使用周围像素的信息来推断出缺失区域的值。Yu等人[1952]使用正向重投影方法，以一种廉价的方式来计算景深效果。Didyk等人[350]基于运动向量（motion vector），在第t−1帧中自适应地生成网格来避免空洞，而不是使用经典的空洞填充方法。这个网格是通过深度测试来进行渲染的，然后会将其投影到第t帧中，这意味着遮挡问题和折叠问题，是作为带深度测试的自适应三角形网格光栅化的一部分来进行处理的。Didyk等人将他们的方法从左眼重投影到右眼，从而为虚拟现实生成一对立体图像，这两个图像之间的相关性通常会很高。后来，Didyk等人[351]提出了一种感知驱动的方法（perceptually motivated method）来执行时域采样，例如：将帧率从40 Hz增加到120 Hz。

镜头光晕和泛光

光学现象

光晕（Halo）
- 由镜头晶体结构的径向纤维引起。
- 外缘红色，内部紫色，环绕光源。
- 尺寸恒定，与光源距离无关。
绒毛状光环（Ciliary corona）
- 由透镜密度波动造成。
- 表现为从光源向外辐射的射线。
其他次要效果
- 光圈叶片 → 多边形图案
- 玻璃凹槽 → 条状光线
- CCD溢出 → 泛光效果
- 这些统称为 炫光效果（glare effect）

数字化实现

(1) 基本思路

将光源或高亮像素分离出来（bright-pass filter）。
对这些像素进行模糊处理（通常高斯模糊，也可以是径向或尖峰形状）。
将模糊后的结果叠加回原图。
可以下采样以降低计算量（½ 到 1/8 分辨率），再上采样回原图。

(2) 镜头光晕纹理（Lens Flare Texture）

使用纹理（例如一系列小正方块）模拟光晕效果。
光源远离屏幕中心 → 光晕小且透明
光源靠近屏幕中心 → 光晕大且不透明
可以结合 屏幕空间可见性 调整亮度（遮挡检测）。

(3) 条纹（Star streaks）

使用 steerable filter 在给定方向上累加像素值。
通常结合乒乓缓冲区和下采样，实现高效渲染。
常用于光源周围的线性光条或星状光晕。

(4) 泛光（Bloom）

只保留过亮区域，暗部变黑 → bright-pass。
对 bright-pass 图像进行模糊（高斯或锐化型）。
模糊结果叠加回原图（加法混合）。
可结合 HDR 渲染：先 tone-mapping，再叠加 bloom。

(5) 优化技巧

低分辨率渲染：减少模糊计算量，扩大相对核尺寸。
多级下采样：可产生更广泛的模糊效果。
遮挡采样：如 Maughan 的 GPU 遮挡采样，调整光晕亮度。
累积历史帧：对动画物体形成条纹光晕或持久感。

典型渲染流程（后处理管线）

场景渲染 → 得到 HDR 场景缓冲。
Bright-pass 提取高亮像素。
模糊处理
- 可以径向模糊（halo）
- 可以方向模糊（star streaks）
- 使用低分辨率或乒乓缓冲区优化
光晕纹理叠加
- 根据光源位置、遮挡信息调整大小与亮度
合成
- bloom 或 lens flare 结果加到原图
- tone mapping & HDR → LDR

景深

累积缓冲区方法（Accumulate Buffer）

通过移动镜头位置（保持焦点固定），多次渲染图像并累积平均。
焦点附近的像素保持清晰，远近场模糊。
可以收敛到物理正确的ground-truth景深图像。
缺点：渲染成本高，不适合实时应用。

分层渲染：

焦点层：清晰聚焦。
远场层：模糊处理。
近场层：模糊处理。
通过改变裁剪平面和模糊处理，将层组合，形成景深。
缺点：物体跨越多层时会产生突变；模糊不随距离连续变化。

焦点外像素被扩散到弥散圆内。

散射（Scatter）方法：

将像素颜色散射到弥散圆覆盖的邻域像素。
GPU上直接散射困难 → 可用Sprite渲染或可分离滤波。

聚集（Gather / Backward Mapping）方法：

对每个像素，采样其弥散圆内的邻域像素颜色并聚合。
可使用深度信息来调整模糊半径，效率高且可预测。

现代算法通常结合前景/背景分层 + 可分离滤波 + 聚集方法。

散射（scatter）操作是获取像素的着色值，并将其扩散到邻近区域的像素上，例如通过渲染一个圆形的sprite。在聚集操作中，相邻区域的值被采样并用于影响某一个像素。GPU的像素着色器经过优化，可以通过纹理采样来执行聚集操作。

近场与远场模糊处理

近场：
- 独立图像渲染并模糊。
- 使用alpha通道控制混合，避免清晰边缘被模糊。
远场：
- 使用弥散圆半径插值焦点图像。
组合：
- 根据弥散圆半径插值焦点、远场图像。
- 使用近场alpha覆盖合成，形成自然的景深。

运动模糊

本质：运动模糊是由于物体或相机在快门打开时间内移动，导致图像在时间上被平均，从而产生模糊。
电影中的运动模糊：
- 电影每秒24帧（FPS），快门通常在1/40s-1/60s。
- 每一帧画面本身已经有运动模糊，所以即使24 FPS，画面也看起来平滑。
- 快门时间越短（如1/500s），会产生“hyperkinetic”效果，看起来非常快、清晰。
实时图形中的问题：
- FPS 低于一定值时，运动显得跳跃。
- 高速物体在没有运动模糊时出现“时间锯齿”（temporal aliasing）。

多帧累积（Frame Accumulation）

思路：在一段时间内累积若干帧并求平均。
问题：
- 会降低帧率（每帧需渲染多次）。
- 快速移动物体容易出现鬼影。
优化：
- 滑动累积（sliding accumulation）：只渲染新帧，减去最早帧，累加当前帧。

b. 速度缓冲区（Velocity Buffer / Motion Vector）

每个像素记录当前帧与上一帧在屏幕空间的位置差（速度向量）。
用法：
1. 渲染当前帧图像。
2. 根据速度缓冲区进行像素方向上的模糊。
3. 可在GPU中通过滤波、瓦片处理加速（tile-based max velocity）。
优点：
- 只需渲染一帧。
- 可处理复杂场景的物体运动。
- 支持遮挡处理（前景物体不被背景模糊覆盖）。

几何方法（Geometry-based Motion Blur）

对快速移动物体生成拉伸的几何（如剑挥动）。
缺点：
- 计算复杂。
- 需要对每个物体处理纹理和高光。

结合景深与运动模糊

通过对速度向量和弥散圆结合，统一处理景深模糊和运动模糊。
可使用随机采样、交错采样、快速重建等技术减少采样噪声。

Games104：高级动画技术：动画树、IK和表情动画

Sat, 25 Oct 2025 15:45:35 +0800

这节主要讲了动画在实践时需要的一些技术

动画混合

在一个Clip内部，使用KeyFrame之间进行插值

Clip之间进行插值，就涉及到如何设置两个Clip的权重，这里静态到走路可以用速度进行插值

Clip之间插值取哪一的KeyFrame进行插值呢？

混合空间

1D/2D混合空间

一维混合就是类似从走到跑的混合，只需要一个速度变量就可以进行权重插值

二维混合空间就需要x,y两个参数来确定很多的动画的插值

Delaunay Triangulation（德劳内三角剖分）：解决众多动画中那些动画参与插值（并不是所有动画都需要参与）

二维插值的问题

假设你有 2D Blend Space，点 (x, y) 表示某个动作（如走、跑、斜向走）。
当角色的当前参数 (px, py) 落在这些点之间时，需要根据它周围的动画点计算混合权重。
问题是：怎么快速找到 (px, py) 所在的区域，并确定参与混合的动画点？

三角剖分的思路

把二维平面上的所有动画点用三角形连起来（Delaunay Triangulation），满足：
- 没有点在任意三角形的外接圆内（Delaunay性质）。
- 三角形形状尽量接近等边三角形，避免“瘦长三角形”，这样插值更稳定。
这样每个三角形的顶点就是 参与插值的动画点。

Skeleton Masked Blending

用来解决两个动画分别作用于不同的骨骼的情况（一个动画控制上半身，一个动画控制下半身）

Additive Blending

Blending做完后还可以再加一个修饰

动作状态机（ASM）

动画混合树

IK

这块东西在Games105详细记录过了

面部动画

就是用很多的表情单元进行混合

直接混合也不行

真实存AU存的是一个表情相对于正常面部的便宜

动画重定向

Global Illumination 全局光照

Sat, 25 Oct 2025 13:59:45 +0800

渲染过程最终计算的是radiance，到目前为止，我们一直在使用反射方程（reflectance equation）来对其进行计算：

$$ L_{o}(\mathbf{p}, \mathbf{v})=\int_{\mathbf{l} \in \Omega} f(\mathbf{l}, \mathbf{v}) L_{i}(\mathbf{p}, \mathbf{l})(\mathbf{n} \cdot \mathbf{l})^{+} d \mathbf{l} \tag{11.1} $$

其中$L_{o}(\mathbf{p}, \mathbf{v})$是表面位置$\mathbf{p}$在观察方向$\mathbf{v}$上的出射radiance；$\Omega$是表面位置$\mathbf{p}$的上半球范围；$f(\mathbf{l}, \mathbf{v})$是观察方向$\mathbf{v}$和当前光线入射方向$\mathbf{l}$上的BRDF；$L_{i}(\mathbf{p}, \mathbf{l})$是从光线方向$\mathbf{l}$到达表面位置$\mathbf{p}$的入射radiance；$(\mathbf{n} \cdot \mathbf{l})^{+}$是光线方向$\mathbf{l}$和表面法线$\mathbf{n}$之间的点积，并将负数结果clamp到0，即将来自表面下方的光线过滤掉。

通用全局光照算法

通用 = 适用于所有类型的光照交互，不局限于特定材质或光源类型。

它强调的是算法完整求解渲染方程，可以模拟现实世界中各种光线传输现象，而不是仅仅处理直接光或特定反射类型。

辐射度

目标：模拟漫反射表面间的光线反弹，尤其是面光源产生的软阴影。
假设：所有间接光来自漫反射表面（不适合镜面或高光材质）。
基本思想：光在环境中弹射，直到达到稳定平衡，每个表面可以视为光源。
光传输路径：通常记作 $LD*E$（光源 $L$ → 漫反射 $D$ → 眼睛 $E$）。

算法实现

面片划分
- 场景表面分割为若干面片（patch），每个面片计算一个平均辐射度值。（就是把Mesh分成一个一个片来计算）
- 面片大小不必与原始三角形网格一致，但要足够小以捕捉阴影和光照细节。
辐射度方程
$$ B_{i} = B_i^e + \rho_{\mathrm{ss}} \sum_j F_{ij} B_j $$
- $B_i$：面片 $i$ 的辐射度
- $B_i^e$：面片自身发出的辐射度
- $\rho_{\mathrm{ss}}$：次表面反照率
- $F_{ij}$：形状因子（form factor），表示面片 $i$ 发出的光有多少到达面片 $j$
通俗理解
1. 自己发光的部分 → $B_i^e$
  - 面片本身是光源时才有
2. 其他面片反射来的光 → $\rho_{\mathrm{ss}} \sum_j F_{ij} B_j$
  - 房间里其他面片反射的光经过漫反射照到面片 $i$
3. 总和 → $B_i$
  - 面片 $i$ 的最终辐射度就是“自己发光 + 别人反射的光”
形状因子（描述一个面片受到另一个面片的影响程度）

$$ F_{ij} = \frac{1}{A_i} \int_{A_i} \int_{A_j} V(i,j) \frac{\cos \theta_i \cos \theta_j}{\pi d_{ij}^2} \, da_i da_j $$
- $A_i$：面片面积
- $V(i,j)$：可见性函数（1 = 可见，0 = 被遮挡）
- $\theta_i, \theta_j$：法线与连线的夹角
- $d_{ij}$：两面片中心距离
求解方法
- 形状因子计算完成后，所有面片方程组成一个线性系统（一个由线性方程组成的数学模型）
- 解线性系统得到每个面片的辐射度
限制与应用
- 扩展性差，面片数量大时矩阵求解开销高
- 不适合高光或镜面材质
- 现代实时系统借鉴思想：预计算形状因子，然后在运行时进行光线传播

辐射度算法是一种基于有限元的全局光照方法，适合漫反射环境，通过面片划分、形状因子计算和线性系统求解，模拟间接光照。虽然计算量大，但其理论基础和预计算思想对实时渲染设计仍有重要参考价值。

光线追踪

这块倒是原理比较熟悉了

环境光遮蔽

上一小节中所介绍的通用全局光照算法，它们的计算成本都很高。虽然它们可以产生各种复杂的效果，但是生成一幅图像往往需要好几个小时。我们将首先介绍一些最简单的，但是在视觉上很有说服力的方法，并在本章节逐步探索实时替代方案，逐步构建更加复杂的效果。

AO的话也比较熟悉了，跳过。在GameEngine真正实现时，再回来看

漫反射全局光照

这部分针对漫反射的全局光照的各种技术进行介绍

表面预照明（静态场景，固定法线）

静态场景烘培

对于一个法线已知的Lambertian表面，其irradiance可以预先计算出来。在运行过程中，将这个值乘以实际的表面颜色（例如纹理颜色），从而获得反射的radiance。根据表面颜色的确切形式，可能还需要额外除以\pi 来确保能量守恒。

除了限制最为严格的硬件平台之外，如今已经很少使用预计算irradiance的方法了。因为根据定义，irradiance是针对给定的法线方向进行计算的，这意味着我们无法对物体的表面法线进行修改，我们无法使用法线映射来提供高频的表面细节。这也意味着只能对平面进行预计算irradiance。如果我们需要在动态几何物体上使用烘焙光照，我们就需要其他的方法来存储这些光照信息。这些限制条件促使人们寻找一种方法，来存储带有方向分量的预计算光照。

定向表面预照明（静态场景，法线可变）

1️⃣ 为什么需要定向表面预照明

对 Lambertian 漫反射表面，简单的环境光照（irradiance）只存储一个标量就够了，但如果要：
- 使用 法线贴图（normal map）提高细节
- 给动态几何提供间接光
就需要存储 irradiance 随表面法线变化 的信息，也就是方向性信息。

2️⃣ 常用表示方法

球谐函数（Spherical Harmonics, SH）
- 可以存储完整的半球或球面光照函数。
- 优点：插值简单，支持动态法线。
- 缺点：系数多（3阶SH每通道9个系数），可能有振铃现象（振铃现象就是在用有限阶球谐函数近似光照时，高频细节无法精确表达，在边界或高对比区域出现的伪波纹或亮暗误差）。
- 优化变体：
  - Chen 的方法：将主要方向光用一个方向+颜色存储，其余用二阶SH编码 → 18个系数，降低存储。
  - H-basis：仅对半球编码，可用更少系数（6个）获得三阶SH精度。
半球基（AHD / Half-angle Basis）
- 《半条命2》使用：每个样本 3 颜色通道，总共 9 个系数。
- 简单，成本低，效果可接受。
切线空间高斯 / 环境波瓣
- Crytek 和《教团：1886》方法：
  - 存储 平均光线方向 + 颜色 + 混合因子。
  - 用球面高斯波瓣（cos^n 权重）表示光照分布。
- 优点：高质量、可做漫反射和镜面高光卷积。
- 缺点：存储和计算成本高。
环境立方 / 环境骰子
- 用几个方向的余弦波瓣表示光照（cos² 或 cos⁴）。
- 优点：存储少（6-12个方向），局部支持好，重建质量接近二阶SH。
- 已应用在《半条命2》《使命召唤》《孤岛惊魂3》等游戏。

预计算传输 PRT（静态场景，但光源可变）

虽然上述的预计算光照看起来很惊艳，但是它本质上还是静态的。

如果我们假设场景中的几何物体没有发生变化，只有光照发生了变化，那么我们可以对光线与模型的相互作用进行预计算。物体之间的影响（例如相互反射或者次表面散射），可以预先进行一定程度的分析，并将结果存储下来，而不需要对实际的radiance进行操作。接收入射光线，并将其转换为整个场景的radiance分布，这个函数被称为传输函数（transfer function）。这样的方法被称为预计算传输（precomputed transfer）或者预计算radiance传输（precomputed radiance transfer，PRT）。

简单讲就是对于每种光源都可以提前对他单独进行预计算，最终场景光照可以由这些单独的光源预计算结果进行累加即可

使用预计算radiance传输的渲染示例。会预先计算三个显示器的完整光照传输，分别获得一个归一化的“单位”响应。由于光线传输的线性叠加特点，这些单独的解可以分别乘以显示器的颜色（本例中是粉色、黄色和蓝色），从而获得最终的光照效果。

上述过程可以写出如下数学形式：

$$ L(\mathbf{p})=\sum_{i} L_{i}(\mathbf{p}) \mathbf{w}_{i} \tag{11.36} $$

其中$L(\mathbf{p})$是点$\mathbf{p}$的最终radiance；$L_{i}(\mathbf{p})$是来自显示器$i$的预计算单位（归一化）贡献；$\mathbf{w}_{i}$是该显示器的当前亮度。这个方程在数学意义上定义了一个向量空间（vector space），$L_i$是这个空间中的基向量。任何可能的光照效果，都可以通过这些光源贡献的线性组合来生成。

存储方法

光照信息存储的目的

无论是完全预计算的光照（例如光照贴图）还是只预计算部分传输信息（PRT等），都需要将结果数据存储在 GPU友好的形式。
存储的形式必须便于 运行时高效访问，以便着色器能快速获取光照信息。

光照贴图（Lightmap）

定义：存储预计算光照的纹理。术语上可以涵盖irradiance贴图或其他光照存储。
特点：
- GPU上使用纹理机制进行访问，通常经过双线性过滤。
- 有些表示方法（如AHD）是非线性的，插值后需要归一化。
- 光照贴图通常 不使用 mipmap，因为贴图分辨率已经很低，每个纹素覆盖面积大（约 20×20 cm）。
参数化要求：
- 模型网格需要唯一的参数化（unique parameterization），每个三角形都有自己的纹理区域。
- 网格通常被分成 chart 或 shell，然后打包到同一纹理中。
- 需要注意 chart 之间不重叠，并保证过滤占用空间独立，以防颜色溢出。
接缝问题：
- 因为 chart 独立展开，纹素边界可能不连续。
- 可以通过手动放置接缝、后处理或者约束优化来减小可见瑕疵。
光照信息被烘焙到一个场景中，将光照贴图应用到物体表面上从而实现光照。光照贴图使用了一个唯一的参数化。场景会被划分成多个元素，这些元素被展开并打包成一个共同的纹理。例如：右图左下角的小块对应了地面，它展示了两个立方体的阴影。

顶点光照存储

预计算光照也可以存储在顶点上，但：
- 光照质量依赖网格细分程度。
- 网格过粗会导致光照表现不准确，过细会增加计算成本。
- 在现代GPU上，顶点之间传递大量光照参数会降低效率，因此很少使用。

体积光照存储（Irradiance Volume / Light Probe）

概念：
- 在场景中预计算空间中多个点的光照信息。
- 可用于动态物体，也可用于静态物体。也就是说光照信息分布在场景中，而不是物体上，即使新物体来了也能直接用
存储方式：
- 原始方法：每个样本点存储小纹理。
- 现代方法：存储在三维纹理或其他体积结构中，可用GPU加速过滤。
常用表示方法：
- 二阶或三阶 球谐函数（SH）
- 球面高斯函数
- 环境立方体贴图（cube map）
采样方法：
- 可用最近探针插值，或者基于四面体网格/点云+重心坐标的插值（图11.30、11.31）。
- 精度依赖探针密度和网格结构。
注意问题：
- 光照体素可能跨越不同光照特征的表面，需要处理边界问题。
- 体积存储比光照贴图占用更多内存（立方关系）。
Unity引擎使用了一个四面体网格，来从一组探针中插值出光照信息。

对于静态和动态的几何物体，通常会使用不同的光照存储方法。例如：静态物体可以使用光照贴图，而动态物体则可以从体积结构中获得光照信息。虽然这样做很流行，但是这种方案可能会导致不同类型的几何物体之间产生不一致的外观表现。其中一些差异可以通过正则化（regularization）来消除，即在这些表示方法中对光照信息进行平均。

动态漫反射全局光照

预计算光照的局限性

优点：能产生高质量的光照效果。
缺点：
- 需要离线烘焙，耗时长（可能几个小时甚至更多）。
- 烘焙-调整-再烘焙循环非常耗费时间，影响工作效率。
- 不适用于动态几何或用户生成的场景，因为场景会在运行时变化。

为了适应场景动态变化，需要即时计算间接光照（无需长时间预计算），主要方法包括：

即时辐射度（Instant Radiosity）

思路：从光源向场景投射光线，每个被光线照到的点放置一个 虚拟点光源（VPL, Virtual Point Light） 来模拟间接照明。
实现：Tabellion & Lamorlette（《怪物史莱克2》）
- 对场景表面做一次直接光照 Pass 并存储纹理。
- 渲染时使用这些缓存数据生成一次弹射的间接光照。
优点：一次弹射即可产生合理效果。
缺点：仍然是部分离线，需要一定计算。

反射阴影贴图（Reflective Shadow Maps, RSM）

基于光源视角渲染的阴影贴图，不仅存储深度，还存储 法线、反照率、直接光照 等信息。
纹素视作虚拟点光源，在渲染时生成单次弹射的间接光照。
优化：
- 不使用全部像素作为点光源，而是用 重要性驱动选择子集。
- 可在屏幕空间 splat 虚拟光源，而不是每个着色点都选取纹素。
缺点：
- 无法提供间接光照的遮挡信息（近似效果）。
- 间接光源数量不足时，会出现闪烁。
- 数量太多则性能挑战大。

其他改进

双抛物面阴影贴图：逐步添加间接光源，保证每帧只用少量阴影贴图。
点场景表示 + 不完美阴影贴图（imperfect shadow maps）：小贴图 + 后处理过滤，实现间接光照遮挡效果。
游戏应用示例：
- 《Dust 514》使用多纹理图层收集间接光照。
- UE 风筝 Demo 用类似方法处理地形间接光照。

光照传播体积（LPV）

场景被离散成一个规则的三维网格，每个单元格内都会维护一个穿过它的定向radiance分布，他使用二阶球谐函数来处理这些信息

LPV 的基本流程

注入光照（Injection）：
- 将直接光照注入与表面接触的体素（volume cell）中。
- 注入值是表面反射光（根据材质颜色调节）。
- 可以使用 反射阴影贴图（RSM） 或其他方法找到这些体素。
光照传播（Propagation）：
- 每个体素分析邻居体素的 radiance 分布，更新自身 radiance。
- 每次迭代光照只传播一个体素的距离，所以需要多次迭代才能覆盖更大空间。
- 优点：每个体素都有完整 radiance 场，任意 BRDF 都可用。
级联体积（Cascaded LPV）：
- 为了覆盖更大空间并节省内存，使用嵌套、逐渐变大的体素层级。
- 光照注入和传播在每个层级独立进行，查找光照时选用最细可用层级。
遮挡信息（Occlusion）：
- 初始 LPV 不考虑间接光遮挡。
- 后续改进引入 RSM 深度信息 或 相机深度缓冲，为体素添加遮挡近似。

体素化全局光照（Voxel Cone Tracing, VXGI）

体素化场景：将场景几何体用稀疏体素八叉树（Sparse Voxel Octree, SVO）表示，每个体素存储反射的光照信息（Radiance）。

光照注入：

使用反射阴影贴图（RSM）或直接光照信息注入到最低层体素。
再通过层次传播向上累积，形成整个体素空间的光照场。

圆锥追踪近似射线积分：

为了避免追踪大量射线，使用 圆锥（Cone）近似 来取代理想射线。
沿圆锥轴线在八叉树上进行层次查找，并根据体素覆盖率调节光照衰减。
多个圆锥组合可以模拟漫反射间接光。

性能优化

稀疏八叉树访问开销大：
- 查找叶子节点需要多次内存访问，GPU 上容易导致 warp 停滞。
级联三维纹理替代八叉树：
- 类似 级联光照传播体积（LPV），每层覆盖更大的空间。
- 只需一次纹理查找即可获得多层级信息。
屏幕空间过滤：
- 每像素只追踪一个圆锥，通过屏幕空间滤波得到最终漫反射响应。

VXGI 的优点

可支持 动态全局光照（直接光 + 间接光）。
允许 动态物体和光源。
能处理 复杂遮挡和半透明间接光（虽然近似）。

体素锥形追踪使用一系列体素树中的过滤查找，来对一个精确的锥形追踪进行近似。左图显示的是三维轨迹的二维模拟。右图展示了体素化几何的分层表示，从左到右每一列所展示的体素树，其层次越来越粗糙。在右图每一行中，展示了用于为给定样本提供覆盖率的层次结构节点。选择合适的级别进行使用，从而使得较粗级别节点的大小大于当前查找的大小，较细级别节点的大小小于当前查找的大小。会使用一个类似于三线性滤波的过程，来在这两个选定的级别之间进行插值。

镜面全局光照

漫反射 VS 光泽材质的不同需求

特性	漫反射	光泽/镜面材质
光照分布	宽余弦波瓣（整个半球）	狭窄镜面波瓣（小立体角）
光照采样	半球内积分	只需有限方向光线
实时渲染要求	低频、粗略表示即可	需高频、精确方向信息

漫反射光照可以用二阶球谐函数、LPV 或 VXGI 等低频方法表示。
光泽材质要求高频 radiance 表示，否则镜面反射高光会出现明显瑕疵。

局部环境贴图（反射探针）

最早将环境贴图与空间中特定点相绑定的游戏之一是《半条命2》，在他们的系统中，会由艺术家首先在整个场景中放置采样位置。在预处理阶段中，会在每个位置上渲染一个立方体贴图。在进行高光计算的时候，物体会使用最近位置上的结果来作为入射radiance的表示。相邻的物体可能会使用不同的环境贴图，这将会导致视觉效果的不匹配，但是艺术家可以手动调整立方体贴图所覆盖的范围。

常规环境贴图（EM）假设环境在“无限远”，即每个表面点采样反射方向时，环境似乎以这个点为中心。

对于小物体或者贴图正好从物体中心生成，结果几乎精确；但大多数物体：

EM 是在某个中心点生成的（reflection probe）
高光表面离中心点越远 → 反射方向采样的结果就偏离真实情况 → 高光不真实

视差矫正：

假设入射光来自一个有限大小的球体或盒子（reflection proxy），而不是无限远。

用户可以定义半径/大小。
代理物体可以是球、盒子等形状，包围渲染到 EM 中的几何。

计算校正方向：

对于某个表面点 $\mathbf{p}$：
1. 计算反射方向 $\mathbf{r}$（传统方式）
2. 视作从表面点沿 $\mathbf{r}$ 发射一条射线，与反射代理相交
3. 计算交点 $\mathbf{x}$
4. 新方向 $\mathbf{r}’ = \mathbf{x} - \mathbf{c}$，其中 $\mathbf{c}$ 是环境贴图的中心
使用 $\mathbf{r}’$ 去 EM 采样，而不是直接使用 $\mathbf{r}$

左边是常规的环境映射，它使用蓝色圆圈进行表示（它也可以是任何表示形式，例如立方体贴图）。左图中的效果是通过使用反射观察方向$\mathbf{r}$访问环境贴图来确定的。仅仅使用这个方向作为参数，蓝色圆圈EM会被视为半径无限大且遥远的。对于黑色圆表面上的任何点，EM好像都以该点为中心。右图中，我们希望EM能够把周围的黑色房间表示为本地的，而不是无限远的。蓝色圆圈EM是在房间的中心处生成的。要像访问房间一样访问这个EM，会从位置$\mathbf{p}$处，沿着反射观察方向发射一根反射光线，这个光线会在着色器中与一个简单的代理物体（房间周围的红色框）相交。这个交点与EM的中心形成一个新的方向$\mathbf{r}^{\prime}$，然后会像常规的环境映射一样，使用这个方向$\mathbf{r}^{\prime}$来访问EM。通过求解$\mathbf{r}^{\prime}$，这个过程会将EM视为具有一个实际的物理形状，即图中的红框。这个红色代理框的假设会在房间的左下角和右下角失效，因为代理形状与实际房间的几何形状并不匹配。

视差矫正从上图就很好理解，我反射采样点是R方向，但是物体并不在立方体贴图中间，如果按左图采样的方向是错的（他是假设着色点在立方体中心来采样的），按右图来看，他重新获取采样方向R’，才是正确的采样结果

多探针组合

当一个区域被多个探针覆盖时，需要一种规则来组合它们：
- 优先级法：用户可以为探针设置优先级，高优先级探针覆盖低优先级探针
- 平滑插值法：在相邻探针之间做线性/权重插值，保证过渡自然
问题：简单的组合规则无法完全消除瑕疵，尤其是在高光或抛光材质上，容易出现反射拉伸或不自然。

反射代理形状问题

反射代理（reflection proxy）通常是简化的几何形状（球、盒子、平面），很少能完全匹配真实场景几何。
结果：
- 反射拉伸：高光表面上，反射看起来被拉伸或不真实
- BRDF不完全正确：渲染到环境贴图的物体可能在不同位置看起来不一样
- 漏光（light leaking）：光线可能穿过代理，导致一些遮挡丢失
缓解方法：
- 定向遮蔽（directional occlusion）
- 预计算漫反射光照：将环境贴图反射值除以平均漫反射光照，只保留高频成分，再在着色时乘回漫反射

深度辅助方法

Szirmay-Kalos：每个探针存储深度贴图，查找时做光线追踪 → 精度更高，但成本大
McGuire：用探针深度缓冲追踪光线，如果主探针信息不足，选择备用探针继续追踪 → 提升可靠性和精度

预过滤环境贴图问题

对光泽材质（glossy BRDF）：
- EM通常是预过滤的，每个 mipmap 层表示不同卷积半径的入射辐射
- 问题：视差校正会让反射方向在代理形状上的分布变化，使得卷积略不准确
- Pesce 和 Iwanicki 分析了这些问题并提出了潜在解决方案

反射代理形状的灵活性

代理不必是闭合或凸形，可以是：
- 平面矩形
- 简单盒子
- 球形代理
复杂代理能更精确表示周围几何，但会增加计算开销

反射探针的实时更新

传统方法：局部反射探针一般在离线阶段渲染和预过滤，生成高质量立方体贴图。
问题：
- 开放世界游戏中，时间变化、动态几何体和大量环境探针使得离线渲染不现实
- 存储大量环境贴图会消耗磁盘空间
解决方案：
- 一部分探针在加载阶段预渲染
- 其他探针在进入相机视野时动态渲染

低帧率更新：动态物体的反射不需要每帧都更新

可以定义每帧更新的探针数量
使用启发式方法决定更新顺序，例如：探针到相机的距离、上次更新时间等

拆分立方体贴图渲染：一个立方体贴图的6个面可以分布到6帧渲染，降低每帧开销

高质量卷积通常需要多次采样，不适合高帧率实时更新

解决方法：

重要性采样（Colbert & Krivanek）：用少量样本（约64）进行近似滤波
mipmap层级采样：根据启发式选择每个样本的 mipmap 层
基函数滤波（Manson & Sloan）：先简单下采样+滤波，再组合 mipmap 构建最终贴图

纹理压缩：

HDR 探针可压缩为 BC6H 半精度浮点格式
减少显存占用和带宽消耗

G-buffer辅助渲染：

离线生成场景的 G-buffer
运行时只需计算光照和卷积
可以在预生成 G-buffer 上渲染动态几何体，降低 CPU 开销

基于体素的方法

体素锥形追踪，无论是使用稀疏八叉树进行存储[307]，还是其级联版本（章节11.5.7）[1190]，同样可以用于渲染高光效果

对于光泽材质而言，使用锥形追踪的效率要高得多。在镜面光照的情况下，BRDF的波瓣会很狭窄，只需要考虑一个来自较小立体角的radiance，因此我们不再需要同时追踪多个圆锥区域，在大多数情况下，一个着色点只需要追踪一个圆锥就足够了。只有较为粗糙材质上的高光效果，才可能需要追踪多个圆锥，但是又因为这样的反射效果十分模糊，在这种情况下，我们只需要使用局部反射探针即可，根本不需要执行锥形追踪。

就是Voxel Cone Tracing来进行着色，因为glossy表面的lobe很狭窄，相比于漫反射效率要高得多

平面反射

方法 A：反射场景副本

对每个反射的物体创建一个副本
将副本沿平面镜像变换到反射位置
渲染副本物体生成反射图像
光源也需进行镜像处理：
- 光源位置和方向也要镜像
将生成的图像用作反射贴图或者直接绘制到反射表面

方法 B：反射观察者

不改变场景中的物体，而是反射观察者（摄像机）位置和观察方向
通过修改投影矩阵，实现从镜面后的视角渲染场景
优点：不需要复制场景物体
关键点：仍需镜像光源位置/方向

屏幕空间方法

这里讲的就是SSR，以及SSR的优化策略

统一方法

到目前为止我们所介绍的方法，它们可以组合成一个能够渲染漂亮图像的完整系统。然而，这些系统交错在一起，缺乏路径追踪的优雅性和概念简洁性。渲染方程的不同方面都会以不同的方式进行处理，在每个方面都做出了不同程度的妥协。尽管最终的生成图像看起来很逼真，但是在很多情况下，这些方法依然会失败，导致视错觉的中断。由于上述的这些原因，实时路径追踪一直是研究工作的重点。

混合渲染管线（Hybrid Rendering Pipeline）：更加合理、但不那么纯粹的方法是，使用路径跟踪方法来处理光栅化渲染框架内难以实现的效果。我们对相机可见的三角形进行光栅化，但是在计算反射效果的时候，我们不再依赖近似的反射代理或者不完整的屏幕空间信息，而是通过路径追踪来计算。我们不再尝试模拟具有模糊效果的面光源阴影，而是直接通过向光源追踪光线并计算正确的遮挡信息。

为了生成高质量的图像，可能需要对每个像素追踪成百上千条光线。即使是使用最优的BVH、最高效的树遍历算法和最快速的GPU，目前也只能在最简单的场景中实时做到这一点，而在稍微复杂一点的场景中则根本无法实现。在可用的性能限制下，我们所生成的图像会具有非常多的噪点，根本无法用于显示。然而幸运的是，这些充满噪声的图像可以使用降噪算法来进行处理，从而产生基本无噪声的图像，如图11.42和图24.2所示。最近在实时光追降噪领域取得了令人印象深刻的进展，并且开发出了一些算法，可以在每像素仅追踪一根光线的情况下（1spp），创建视觉上接近高质量的、路径追踪生成的图像 [95, 200, 247, 1124, 1563]。

Local Illumination 局部光照

Wed, 22 Oct 2025 14:19:43 +0800

内容包括：1. 将点光源拓展到面光源，并且介绍了一些在Lambertian表面或Glossy表面的实现方案 2.环境光照针对高光和漫反射的模拟的各种实现方案 3. 引入SH预计算的概念

局部光照 (Local Illumination)

局部光照模型只考虑光源直接照射到表面点的光照贡献，忽略：

来自其他物体表面反射的间接光（Global Illumination 的一部分）
场景中可能存在的全局光能量传播效应（如颜色反弹、光子映射、环境光照等）

也就是说，它计算的 $L_o$ 只来自：

$$ L_o(\mathbf{p}, \mathbf{v}) = \sum_{\text{光源 } i} \int_{\omega_{L_i}} f_r(\mathbf{p}, \mathbf{l}, \mathbf{v}) L_i(\mathbf{p}, \mathbf{l}) (\mathbf{n}\cdot\mathbf{l})^+ d\mathbf{l} $$

积分域 $\omega_{L_i}$ = 光源 i 在半球上所占立体角
如果光源面积很小 → 可以近似为点光源
只计算直接光照 → 计算量低，适合实时渲染

面光源

这一节主要是对一些面光源的积分运算在diffuse和glossy表面的实时渲染近似方案

球体使用了GGX BRDF来进行渲染，从左到右，球体材质的表面粗糙度递增。最右侧图像和最左侧图像是一样的，只是将其垂直翻转了过来。请注意，在低粗糙度的材质上，由大圆盘灯引起的高光和着色效果，与较小光源在高粗糙度材质上所引起的高光效果，在视觉上面十分相似。

这张图意思是使用点光源，并且调整粗糙度后，可以用来近似面光源的镜面效果。

Lambertian表面

对于Lambertian表面这种特殊情况，直接使用点光源来表示面光源是很精确的。对于这样的表面，其出射的radiance与irradiance成正比：

$$ L_{o}(\mathbf{v})=\frac{\rho_{\mathrm{ss}}}{\pi} E \tag{10.2} $$

也就是说对于Lambertian表面只要接受到的irrandance一致，那最终的radiance就是一样的。所以可以直接用点光源代替面光源（只是在Lambertian表面）

向量irradiance

这里说的一堆东西是一种用点光源代替面光源近似计算的实现方案，使用它的方法求出来的净辐照度来代替对整个面光源的积分运算

向量irradiance（vector irradiance）的概念对于当面光源存在时，理解irradiance的行为十分有用。向量irradiance的概念由Gershun [526]提出，他将其称之为光源向量（light vector），Arvo [73]将这个概念进一步推广。利用向量irradiance，可以将任意大小和任意形状的面光源，精确地转换为点光源或者方向光。

这里的向量irradiance计算过程

$$ \mathbf{e}(\mathbf{p})=\int_{\mathbf{l} \in \Theta} L_{i}(\mathbf{p}, \mathbf{l}) \mathbf{l} d \mathbf{l} \tag{10.4} $$

左图：点$\mathbf{p}$被各种具有形状、大小、radiance分布的光源所包围，其中黄色的明亮程度代表了光源发射出的radiance数量。以点$\mathbf{p}$为起点的橙色箭头代表了向量，它指向任何存在入射radiance的方向，每个向量的长度，等于来自该方向上的radiance乘以箭头所覆盖的无限小的立体角。原则上应当存在无穷多个箭头。右图：向量irradiance（橙色大箭头）是左图中所有橙色向量的总和。向量irradiance可以用来计算任意平面在点$\mathbf{p}$处的净irradiance。

其中$\mathbf{n}$是平面的表面法线。通过平面的净irradiance，是指流经平面“正面”（表面法线$\mathbf{n}$所指向的方向）和流经平面“背面”的irradiance之差。虽然说净irradiance本身对于着色计算来说没有什么用处，但是如果说没有任何radiance被发射通过平面的“背面”的话（换句话说，对于所分析的光线分布，光线方向$\mathbf{l}$和表面法线$\mathbf{n}$之间的夹角都不会超过$90^{\circ}$，所有的入射光线都来自于着色点的正半球方向），即$E(\mathbf{p},-\mathbf{n})=0$，那么此时有：

$$ E(\mathbf{p}, \mathbf{n})=\mathbf{n} \cdot \mathbf{e}(\mathbf{p}) \tag{10.6} $$

如果入射radiance $L_i$与波长无关的假设不成立的话，那么在一般情况下，我们就不能再定义单个向量irradiance $\mathbf{e}$了。然而，彩色光通常在所有点上都具有相同的相对光谱分布，这意味着我们可以将$L_i$分解为颜色$\mathbf{c}^{\prime}$，以及与波长无关的radiance分布$L_i^{\prime}$。在这种情况下，我们可以计算$L_i^{\prime}$的向量irradiance $\mathbf{e}$，并对方程10.6进行一些扩展，将$\mathbf{n} \cdot \mathbf{e}$乘上颜色$\mathbf{c}^{\prime}$。这样做的结果与计算方向光irradiance的方程相同，只是做了以下替换：

$$ \begin{aligned} \mathbf{l}_{c} & =\frac{\mathbf{e}(\mathbf{p})}{\|\mathbf{e}(\mathbf{p})\|}, \\ \mathbf{c}_{\text {light }} & =\mathbf{c}^{\prime} \frac{\|\mathbf{e}(\mathbf{p})\|}{\pi} .\end{aligned} \tag{10.7} $$

到此为止，我们已经可以将任意形状和任意大小的面光源转换为方向光，同时不会引入任何误差。

对于一些简单情况，用于求取向量irradiance的方程10.4可以求出解析解。例如：想象现在有一个以$\mathbf{p}_l$为中心、半径为$r_l$的球形光源。球面上的每一点都会向各个方向发出具有恒定radiance $L_l$的光线。对于这种光源，将方程10.4和方程10.7联立，可以获得如下结果：

$$ \begin{aligned} \mathbf{l}_{c} & =\frac{\mathbf{p}_{l}-\mathbf{p}}{\left\|\mathbf{p}_{l}-\mathbf{p}\right\|}, \\ \mathbf{c}_{\text {light }} & =\frac{r_{l}^{2}}{\left\|\mathbf{p}_{l}-\mathbf{p}\right\|^{2}} L_{l} .\end{aligned} \tag{10.8} $$

上述方程，与具有$\mathbf{c}{\text {light }{0}}=L_{l}, r_{0}=r_{l}$和标准距离平方反比衰减函数的泛光灯（章节5.2.2）完全相同。可以对这个衰减函数进行一些修正，使得光线从球体表面才开始发生衰减，并在光源的最大影响距离处衰减到0，有关这些调整的更多细节，详见章节5.2.2。

Glossy表面

与 Lambertian 表面（仅依赖入射辐照度总量）不同，非 Lambertian 表面（如光泽、高光表面）的出射亮度，不仅依赖入射光总量，还依赖入射光的方向分布—— 面光源在这类表面的核心视觉效果是 “与光源形状相似、边缘随粗糙度模糊的高光”

在实时渲染中，大多数对面光源光照效果的实用近似，都是基于了这样的一个想法：为每个着色点都寻找一个等效的精确光源，从而模拟非无穷小光源的效果。这种方法经常被用于实时渲染中，以解决各种各样的问题

粗糙度修正

核心逻辑：找到面光源入射辐照度的 “有效圆锥体” 和 BRDF 镜面波瓣的 “有效圆锥体”，用两个圆锥体的立体角之和，修正材质的粗糙度参数，让镜面波瓣 “变宽”，模拟面光源的柔和高光。
典型实现：Karis 将该思路应用于 GGX BRDF，修改粗糙度参数$(\alpha_g’ = \left(\alpha_{g}+\frac{r_{l}}{2\left|\mathbf{p}_{l}-\mathbf{p}\right|}\right)^{\mp})$（限制在 0-1 之间）。
优缺点：计算成本低，对中等光泽表面效果好；但对镜面级光滑表面失效（无法模拟锐利高光），且微表面 BRDF 的宽衰减特性会导致效果失真。

代表性点技术

核心逻辑：基于 “积分中值定理”，用面光源上对表面能量贡献最大的一个 “代表性点”，替代整个面光源（将面光源简化为一个点光源），类似蒙特卡洛积分的重要性采样思想。
关键操作：
- 选择代表性点：优先选 “与反射光线夹角最小” 或 “距离反射光线最近” 的点（Karis 改进后更高效）；
- 能量修正：通过简单公式缩放光线强度，保证能量守恒。
优缺点：推导简单、适用于多种光源形状；但会导致粗糙表面的高光偏 “尖锐”（与真实值有偏差），需额外优化。
扩展优化：Iwanicki 和 Pesce 通过拟合数值积分结果，引入软阈值、缩放因子等参数；de Carpentier 针对微表面 BRDF，改用 “最大化$(\mathbf{n} \cdot \mathbf{h})$（法线与半向量点积）” 选择代表性点，优化掠射角下的高光形状。

线性变换余弦（LTC）法：高精度通用解决方案

核心逻辑：用 “3×3 矩阵变换的余弦波瓣”（LTC）近似任意 BRDF 的镜面波瓣，通过矩阵对余弦波瓣进行缩放、拉伸、旋转，适配不同 BRDF 和光源形状；再利用逆矩阵变换积分定义域，将复杂积分转化为简单余弦波瓣的积分（可复用成熟算法）。
关键优势：
- 通用性强：适用于任意纹理多边形面光源（卡片、圆盘、管状等）和一般 BRDF；
- 准确性高：离线构建 BRDF 参数（粗糙度、入射角）的查找表，实时通过查找表快速求解。
缺点：计算成本高于前两种方法，但准确性更优。

一般光源形状的适配的处理

光源形状	适用场景	关键处理方式
球形光源	基础简化光源	粗糙度修正、代表性点技术（核心适配对象）
管状（胶囊）光源	模拟荧光灯管	Lambertian 表面可用 Picott 的封闭积分解；非 Lambertian 表面用代表性点技术叠加点光源
平面光源（卡片 / 圆盘 / 多边形）	柔光箱、反光板、发光面板等	- 简单近似：Drobot 的代表性点方法（找积分最大值附近的点）；- 精确解析：Arvo 的辐照度张量 + 轮廓积分（实时成本高）；- 实用优化：Lecocq 的 O (1) 轮廓积分近似

环境光照

在实践中，通常我们会认为直接光具有较高的radiance和相对较小的立体角，而间接光往往会以中等或者较低的radiance，来覆盖半球方向上的其余部分。基于这种划分方式和理由，我们可以将二者分开进行处理。

恒定环境光

核心假设：入射辐射度 $L_A$ 不随方向变化（全方向恒定），是最基础的环境光照模型。

对不同表面的贡献
1. Lambertian（漫反射）表面
- 特点：出射辐射度贡献恒定，与表面法线 $\mathbf{n}$ 和观察方向 $\mathbf{v}$ 无关。
- 公式：
$$ L_o(\mathbf{v}) = \rho_{\mathrm{ss}} L_A $$
- 简化逻辑：漫反射的 BRDF 为 $\frac{\rho_{\mathrm{ss}}}{\pi}$，半球积分为 $\int_{\Omega} (\mathbf{n} \cdot \mathbf{l}) d\mathbf{l} = \pi$，因此最终 $\frac{\rho_{\mathrm{ss}}}{\pi} \cdot L_A \cdot \pi = \rho_{\mathrm{ss}} L_A$。
1. 任意 BRDF 表面
- 特点：贡献依赖定向反照率 $R(\mathbf{v})$。
- 定向反照率定义：
$$ R(\mathbf{v}) = \int_{\Omega} f(\mathbf{l}, \mathbf{v}) (\mathbf{n} \cdot \mathbf{l}) \, d\mathbf{l} $$
- 出射辐射度公式：
$$ L_o(\mathbf{v}) = L_A \cdot R(\mathbf{v}) $$
1. 老版本简化（近似方案）
- 假设：定向反照率 $R(\mathbf{v})$ 为恒定值（称为环境颜色 $\mathbf{c}_{\mathrm{amb}}$）。
- 公式：
$$ L_o(\mathbf{v}) = \mathbf{c}_{\mathrm{amb}} \cdot L_A $$

球面函数和半球函数

把环境光照 $L_A$ 视为一个常数，这意味着：

每个方向来的光强都是相同的。

但真实世界中并非如此。一个点从不同方向接收到的光强往往不同，例如：

左边可能是红墙 → 红色光；
右边可能是绿树 → 绿色光；
上方可能被遮挡 → 几乎没有光。

因此，要描述这种“方向依赖的入射辐射度（radiance）”，我们需要一个定义在**方向空间（sphere）**上的函数。

我们把所有方向的集合记为：

$$ S = \{\omega \in \mathbb{R}^3 : ||\omega|| = 1\} $$

于是，一个方向依赖的入射辐射度可以写为：

$$ L_i(\omega) : S \rightarrow \mathbb{R}^+ $$

它表示从方向 $\omega$ 入射的 radiance。

这个函数定义在球面上（而非位置上），因此叫球面函数（spherical function）。

对于一个 Lambertian 表面，其出射辐射度与入射辐射度的关系是：

$$ L_o = \frac{\rho}{\pi} \int_{H(\mathbf{n})} L_i(\omega_i) (\mathbf{n} \cdot \omega_i) d\omega_i $$

其中：

$H(\mathbf{n})$：法线方向上的半球；
$(\mathbf{n} \cdot \omega_i)$：余弦项；
这个积分就是radiance 与余弦波瓣的卷积。

因此，为了实时渲染，我们往往预计算：

$$ E(\mathbf{n}) = \int_{H(\mathbf{n})} L_i(\omega_i) (\mathbf{n} \cdot \omega_i) d\omega_i $$

并把它称为 irradiance function，它是球面函数的卷积结果。预计算每个法线半球的irradiance。

球面函数是定义在球面上的连续函数，不可能直接存储。所以我们要找一种“基底”，用有限个系数表示它。这就类似于在平面上用傅立叶级数展开周期函数。

例如： $f(\omega) = \sum_{l,m} c_{lm} Y_{lm}(\omega)$，其中 $Y_{lm}$ 是球谐函数（Spherical Harmonics）。

这类基底称为：

球面基底（Spherical Base）
包括球谐函数、Haar 小波基、径向基、环境高光基底（AHD）等。

投影（Projection）：把函数 $L_i(\omega)$ 投影到基底空间，求出系数：

$$ c_{lm} = \int_S L_i(\omega) Y_{lm}(\omega) d\omega $$

重建（Reconstruction）：通过这些系数恢复函数：

$$ \tilde{L_i}(\omega) = \sum_{l,m} c_{lm} Y_{lm}(\omega) $$

总结一下：一个定义在球面上的函数 $f(\omega)$，可以用一组球面基函数 $Y_l^m(\omega)$ 的线性组合来近似表示。你只需要计算保存这些线性组合的系数，在任何方向上（角度）都可以通过这些系数 + 基函数重建出近似值。

球面基底的简单表示形式

表格（采样点）表示球面函数

方法：直接在球面上选若干方向 $\omega_i$，存储每个方向上的函数值 $f(\omega_i)$。
重建：当需要某个方向 $\omega$ 的值时，找到附近的样本点，用插值（如双线性或三线性）求出近似值。
优点：
- 非常直观，易于理解和实现；
- 表征能力强，只要采样足够密集，几乎可以精确还原原函数；
- 函数相加/相乘简单：直接对对应采样点的值相加或相乘。
缺点：
- 样本少时重建误差大；
- 旋转不变性差（函数旋转后，插值结果可能不准确，导致闪烁或脉动瑕疵）；
- 高频函数需要大量样本，存储和计算量大；
- 卷积等操作复杂，计算成本和样本数量成正比。

环境立方体（Ambient Cube, AC）
- 思想：用 6 个值（立方体六个面）表示球面函数。
- 公式：
$$ F_{AC}(\mathbf{d}) = \mathbf{d} \cdot \operatorname{sel}_+(\mathbf{c}_+, \mathbf{c}_-, \mathbf{d}) $$
- $\mathbf{d}$ 是方向向量；
- $\mathbf{c}+$ 和 $\mathbf{c}-$ 是立方体六个面的值；
- $\operatorname{sel}_+$ 根据方向的正负性选择对应面。
- 特点：
  - 只需三个波瓣参与计算（x、y、z方向）；
  - 在软件重建上可能比 GPU 双线性过滤更快；
  - 精度低，但实现简单；
  - 可以和球谐 SH 互相转换（Sloan 提供方法）。
环境骰子（Ambient Dice, AD）：

基底由二十面体顶点方向上的平方和四次余弦波瓣组成；
需要存储 12 个值中的 6 个来重建；
重建质量比环境立方体高，但逻辑稍复杂。

球面基底

基函数的一个例子。在这个例子中，输入值为0-5之间的一个数，函数会返回0-1之间一个值，左侧的图展示了这样一个函数。中间的图展示了一组基函数（每种颜色都代表了一个不同的基函数）。右图则展示了使用基函数来对目标函数的近似，通过将每个基函数乘以一个权重并将它们相加来完成这个近似。右图中的每个基函数都按照各自的权重进行了缩放，图中的黑色线条代表了基函数求和之后的结果，这是对原始函数的近似结果；图中灰色线条代表了原始函数，用于和近似函数进行比较。

球面径向基函数（SRBF）

定义：一类沿轴旋转对称的函数，只依赖于 方向之间的夹角。
- 输入参数 = 方向 $\mathbf{v}$ 与波瓣方向 $\mathbf{d}$ 的夹角。
构建方法：
- 将球面覆盖上若干固定方向的“波瓣”（lobe）；
- 每个波瓣有大小/尖锐度参数；
- 函数值 = 所有波瓣在该方向上的值加权求和。
优点：
- 可以获得比双线性插值更高质量的重建；
- 可通过固定波瓣方向，简化投影（只需拟合权重）。

球面高斯（SG, Spherical Gaussian）

定义：一种常用的 SRBF，类似 von Mises-Fisher 分布：

$$ G(\mathbf{v}, \mathbf{d}, \lambda) = e^{\lambda(\mathbf{v} \cdot \mathbf{d}-1)} $$

$\mathbf{v}$：计算方向
$\mathbf{d}$：波瓣主方向
$\lambda$：尖锐度/扩散参数
球面函数表示：

$$ F_G(\mathbf{v}) = \sum_k w_k G(\mathbf{v}, \mathbf{d}_k, \lambda_k) $$

通过拟合 $w_k$ 来最小化重建误差。
如果波瓣方向和扩散参数固定，投影成基就简单 → 线性最小二乘法。
如果方向/扩散参数可变 → 非线性优化，难度大。

球谐函数（spherical harmonic，SH）

球谐函数（spherical harmonic，SH）是球面上的一组正交的基函数。一组基函数的正交集（orthogonal set）具有如下特点：任意两个不同基函数之间的内积（inner product）为零。内积是一个类似于点积的概念。两个向量之间的内积就是它们的点积，即各个分量对应相乘再相加的结果。我们可以类似地推导出两个函数的内积的定义，即将这两个函数相乘再进行积分，其数学表达如下：

$$ \left\langle f_{i}(\mathbf{n}), f_{j}(\mathbf{n})\right\rangle \equiv \int_{\mathbf{n} \in \Theta} f_{i}(\mathbf{n}) f_{j}(\mathbf{n}) d \mathbf{n} $$

下面说的是为了说明什么是标准正交基，以及他的优势对比普通基底

标准正交集（orthonormal set）也是一个正交集，其附加条件是该集合中的任意一个函数与自身的内积都为1。更加正式的表述方式为，一组函数${f_j()}$是标准正交的条件是：

$$ \left\langle f_{i}(), f_{j}()\right\rangle=\left\{\begin{array}{ll}0, & \text { where } i \neq j, \\ 1, & \text { where } i=j .\end{array}\right. $$

展示了一个类似于图10.18的例子，不同之处在于，其中的基函数都是标准正交的。请注意，图10.20中的所展示的标准正交基函数都是互不重叠的，这个条件对于非负函数的标准正交集合是十分必要的，因为任何的重叠都意味着内积非零。而对于那些在部分范围内为负的基函数，则可以发生重叠，它们仍然可以形成标准正交集。这种重叠通常会得到更好的近似结果，因为它允许使用更加平滑的基底。而那些互不重叠的基函数，往往会导致近似结果的不连续性。

标准正交基的优点在于，想要找到最接近目标函数的近似值十分简单。为了完成投影操作，每个基函数的权重系数都是目标函数$f_{\text {target }}() $与相应基函数的内积：

$$ \begin{array}{c}k_{j}=\left\langle f_{\text {target }}(), f_{j}()\right\rangle, \\[2mm] f_{\text {target }}() \approx \sum_{j=1}^{n} k_{j} f_{j}() .\end{array} \tag{10.23} $$

SH的基

SH 的特点

旋转不变性：
- 基函数在旋转下有解析变换公式，旋转投影函数方便。
计算成本低：
- 基函数是 $x, y, z$ 坐标的多项式。
全局支持：
- 类似球面高斯，每个基函数影响球面上所有方向。
频带排列：
- 第 0 频带：常数函数
- 第 1 频带：线性函数
- 第 2 频带：二次函数
- … → 低频分量变化慢，高频分量变化快
- 光照积分等低频函数可以用少量系数表示（比如 irradiance）。
积分和乘积解析：
- 两个函数在球面上的积分可以转化为它们系数的点积 → 高效计算光照积分。

其他球面表示方法

除了 SH，还有：

方法	特点	用途
线性变换余弦（LTC）	近似 BRDF	高效积分
球面小波（spherical wavelet）	空间局部性 + 频率局部性	高频函数压缩
球面分段常数基函数	球面划分为常数区域	环境光照表示
双聚类近似（biclustering）	矩阵分解方法	环境光照压缩

半球基底

为什么要用半球基底

上节讲的 SH、球面高斯等基底都是定义在 整个球面 上。
但是很多光照相关函数 天然只定义在半球（例如 BRDF、入射辐照度、到达表面的光照），另一半球（向下）是零。
如果用全球基底来表示半球函数，会 浪费一半的表示能力。
因此研究者提出了 直接在半球域上构造的基底。

AHD基底

最简单的半球表示方法：

A：恒定环境光
H：高光方向光
D：入射光集中的方向

存储：

8 个参数（2 个角度 + 6 个 RGB 颜色）

投影：

非线性 → 通常先投影到 SH，再用最优方向确定余弦波瓣方向 → 最小二乘求权重

用途：

表面 irrandiance 存储
游戏应用：《雷神之锤3》《使命召唤》

半条命2基底（Radiosity Normal Mapping）

用 3 个 互相垂直的基向量表示半球函数
基向量在切线空间中：

$$ \mathbf{m}_0, \mathbf{m}_1, \mathbf{m}_2 $$

重建公式：

$$ E(\mathbf{n}) = \frac{\sum_{k=0}^{2} \max(\mathbf{m}_k \cdot \mathbf{n}, 0)^2 E_k}{\sum_{k=0}^{2} \max(\mathbf{m}_k \cdot \mathbf{n}, 0)^2} \quad \text{(10.25)} $$

优化后可简化为线性加权形式：

$$ E(\mathbf{n}) = \sum_{k=0}^{2} d_k E_k \quad \text{(10.27)} $$

特点：
- 存储少、计算快
- 可与法线贴图结合
- 实际效果优于低阶 SH

半球谐波 / H-Basis

将 SH 特化到半球域：

半球谐波（HSH）：类似 SH，但只定义在半球
可以使用 Zernike 多项式（单位圆盘上的正交函数）来表示半球函数

H-Basis（Habel）：

混合部分球谐函数 + HSH
正交
计算效率较高
可以对系数向量进行矩阵运算完成旋转

环境映射

将一个球面函数记录在一个或者多个图像中的做法，被称为环境映射（environment mapping）

经纬度映射

就是把环境光贴图表达为经纬度采样，计算要采样方向的经纬度，去对应位置读取

起源：1976年，Blinn 和 Newell 实现了第一个环境映射算法。

原理：

把球面上的环境信息“展开”到二维纹理。
类似地球上的经纬度系统：
- $\phi$（经度） → $[-π, π]$
- $\rho$（纬度） → $[0, π]$
将反射向量 $\mathbf{r} = (r_x, r_y, r_z)$ 转换为球坐标：
$$ \rho = \arccos(r_z), \quad \phi = \text{atan2}(r_y, r_x) \quad \text{(10.30)} $$
用 $(\rho, \phi)$ 来访问纹理，获取环境颜色。

注意：

纬度-经度映射 ≠ Mercator 投影：
- 纬度-经度映射保持纬度线之间的距离恒定。
- Mercator 投影在两极会极度拉伸。

球面映射

球面映射把环境光照记录在一个圆形纹理图像中，就像在一个完全反射的球体上看到环境一样。这个纹理也称为光照探针（light probe），因为它捕捉了球体位置处的光照。

计算流程

固定观察向量 $\mathbf{v} = (0,0,1)$：球面贴图是在一个固定视角下拍摄或者生成的，反映了这个方向的环境信息。
求半角向量 $\mathbf{n}$：反射观察向量 $\mathbf{r}$ 和原始观察向量 $\mathbf{v}$ 的和：
$$ \mathbf{n} = \frac{(r_x, r_y, r_z + 1)}{\sqrt{r_x^2 + r_y^2 + (r_z + 1)^2}} $$
映射到纹理坐标 $(u,v)$：
$$ u = \frac{r_x}{2 m} + 0.5, \quad v = \frac{r_y}{2 m} + 0.5 $$
- 这里 $m = \sqrt{r_x^2 + r_y^2 + (r_z + 1)^2}$
- 将 $[-1,1]$ 范围映射到 $[0,1]$
纹理查找：
- 使用 $(u,v)$ 在球面贴图中查找对应的入射辐射 $L_i(\mathbf{r})$

立方体映射

将环境投影到以相机位置为中心的立方体六个面上，每个面90° FOV。

六张正方形纹理分别对应立方体的 +X、-X、+Y、-Y、+Z、-Z。

访问纹理时，直接用方向向量 $\mathbf{r}$ 指向哪个面，再根据面内坐标取值即可。 这个在LearnOpenGL中实现过

基于图像的高光照明

这里讲的就是LearnOpenGL的IBL实现，高光就是反射的一个范围内都能接收到

环境映射最初是作为一种镜面渲染技术发展起来的，但是也可以将它扩展到光泽（glossy）反射中。当用于模拟无限远处光源的镜面效果时，这样的环境贴图也被称为高光探针（specular light probe）。（这里的镜面反射就是只有反射方向的颜色，光泽反射就是反射的一个范围内都能接收到）

先解释一下lobe是什么，lobe说的都是BRDF的lobe

对于一个 给定的入射方向 $\mathbf{l}$，BRDF $f_r(\mathbf{l}, \mathbf{v})$ 会定义出 所有出射方向 $\mathbf{v}$ 上的反射强度。
**波瓣（lobe）**就是指这个方向空间中 反射值显著非零的区域。
- 理想镜面 → 波瓣无限尖锐，只在反射方向上非零。
- 光泽表面 → 波瓣稍宽，附近方向也有非零反射。
- 漫反射 → 波瓣非常宽，几乎整个半球都有非零反射。
下图展示镜面和高光的区别

径向对称的镜面波瓣：反射方向在lobe中心

径向对称的镜面波瓣是一种渲染的假设，但会存在地平线裁剪问题

对于上边这种情况，观察球的表面时lobe会被地平线裁剪，这时候经径向对称的镜面波瓣假设是错的，会让表面高光过亮

环境贴图 + mipmap 模拟粗糙度

Heidrich 和 Seidel 方法：用一个环境贴图来模拟表面模糊反射。
粗糙度的处理：
- 环境立方体贴图生成多级 mipmap。
- 低级别 mipmap：高分辨率，对应光滑表面（高光尖锐）。
- 高级别 mipmap：低分辨率，对应粗糙表面（高光模糊）。
- 渲染时，通过 反射向量索引贴图 并选择对应 mipmap 层，实现不同粗糙度的反射。

图10.36显示了不同粗糙度波瓣对应的 mipmap 层级及渲染结果。

卷积环境贴图

想要生成预过滤的环境贴图意味着，要对与方向$\mathbf{v}$相关的每个纹素上，计算环境radiance与镜面波瓣$D$的积分：

$$ \int_{\Omega} D(\mathbf{l}, \mathbf{v}) L_{i}(\mathbf{l}) d \mathbf{l}. $$

这个积分是一个球面卷积（spherical convolution），由于其中的$L_i$只能通过环境贴图的表格形式获得，因此这个积分通常无法解析求解，只能通过数值方法进行求解。一种流行的数值方法是采用蒙特卡罗方法：

$$ \int_{\Omega} D(\mathbf{l}, \mathbf{v}) L_{i}(\mathbf{l}) d \mathbf{l} \approx \lim _{N \rightarrow \infty} \frac{1}{N} \sum_{k=1}^{N} \frac{D\left(\mathbf{l}_{k}, \mathbf{v}\right) L_{i}\left(\mathbf{l}_{k}\right)}{p\left(\mathbf{l}_{k}, \mathbf{v}\right)} \tag{10.36} $$

蒙特卡罗积分

通过随机采样球面方向近似积分：
$$ \int_\Omega D(\mathbf{l}, \mathbf{v}) L_i(\mathbf{l}) \, d\mathbf{l} \approx \frac{1}{N} \sum_{k=1}^{N} \frac{D(\mathbf{l}_k, \mathbf{v}) L_i(\mathbf{l}_k)}{p(\mathbf{l}_k, \mathbf{v})} $$
- $\mathbf{l}_k$ 是球面样本方向
- $p(\mathbf{l}_k, \mathbf{v})$ 是采样概率密度
问题：
- 高光波瓣很尖，很多样本 $D(\mathbf{l}_k, \mathbf{v})\approx 0$ → 浪费计算
- 第一级 mipmap（高分辨率，低粗糙度）尤其慢

重要性采样（Importance Sampling）

通过选择采样概率 $p(\mathbf{l}_k, \mathbf{v})$ 更贴近波瓣形状
减少无效样本，降低方差
可以结合 环境贴图的 radiance 分布 和镜面波瓣进一步优化
适合 离线渲染 或生成 ground-truth 数据

用锥形 / 区域采样降低方差

不用单点采样，而是用 锥形区域 样本代替一个方向
可以对应 mipmap 层级进行近似
会引入偏差，但显著降低样本数，甚至可以 GPU 实时计算
示例技术：
- McGuire 等人：实时近似卷积，通过混合不同 mipmap 层级来重建波瓣
- Hensley 等人：使用 SAT（前缀和）加速积分
- Kautz / Manson & Sloan：B 样条滤波生成 mipmap，提高精度与速度

缺点：

忽略了 shadowing-masking 和半向量菲涅尔。
仅适合粗略镜面近似或 Phong 模型。
会产生误差，如地平线裁剪或掠射角下波瓣尖锐变化

split-sum

改进：将镜面环境光积分拆分为两个部分：
1. 环境光卷积：波瓣 $D$ 与环境光 $L_i$ 的积分，依赖于反射方向和粗糙度，可预计算到立方体贴图 mipmap。
2. 半球定向反射率 $R_\text{spec}$：包含 BRDF 权重（菲涅尔、shadowing-masking），依赖于视角、粗糙度，可预计算到二维或三维查找表。
优势：
- 对任意微表面 BRDF 都适用，不只是 Phong。
- 运行时快速查表即可获得高光结果。
注意：
- 假设波瓣径向对称（仍会有误差）。
- 可以通过轻微调整查询方向来补偿半球裁剪误差。

不对称和各向异性波瓣

传统预过滤环境贴图的假设

早期方法（如 10.5.1）假设镜面波瓣是径向对称，仅依赖于反射向量。
这种方法在 Phong 或简单各向同性 BRDF 下有效。
波瓣的径向对称意味着：
- 波瓣围绕反射向量旋转时，形状不变。
- 高光大小只由粗糙度决定，与光线方向旋转无关。

微表面 BRDF 的复杂性

微表面 BRDF（如 GGX）是围绕半向量 $\mathbf{h}=(\mathbf{l}+\mathbf{v})/|\mathbf{l}+\mathbf{v}|$ 定义的。
半向量依赖入射方向 $\mathbf{l}$，环境光下 $\mathbf{l}$ 并不唯一。
因此即便各向同性，也无法满足反射向量径向对称。
直接将微表面 BRDF 转换为径向对称波瓣会引入较大误差（高光形状偏离真实情况，尤其在掠射视角）。
- 图10.38 显示 GGX 原生波瓣（红） vs. 径向对称近似波瓣（绿），差异明显。

改进方法

Kautz & McCool：
1. 使用单个最佳样本拟合 BRDF，而不是恒定修正因子。
2. 对多个样本平均，近似半向量模型的拉伸高光。
- 引入能量修正因子，补偿径向对称近似的能量损失。
Iwanicki & Pesce：
- 对 GGX BRDF 做环境立方体贴图近似，利用 Nelder-Mead 最小化优化样本位置。
- 可以结合 GPU 各向异性过滤加速采样。
Revie / McAuley：
- 在延迟渲染和毛皮渲染中，调整单个样本位置以匹配复杂 BRDF 峰值。
McAllister / Lafortune BRDF：
- 利用 Lafortune BRDF（多个广义 Phong 波瓣叠加）表达复杂材质。
- 依然可以用传统预过滤环境贴图和 mipmap 编码不同 Phong 指数。

irradiance环境映射

上一小节中我们讨论了如何使用预过滤环境贴图来实现光泽反射，这些贴图同样也可以用于实现漫反射

计算irradiance环境贴图的过程。在原始环境纹理（本例中是一个立方体贴图）中对表面法线周围的余弦加权半球进行采样，并对采样结果进行求和，从而获得与视图无关的irradiance。图中绿色的方块代表了立方体贴图的横截面，红色的虚线代表了纹素之间的边界。这里使用的是一个立方体贴图，但实际上任何环境表示都是可以使用的。

球谐irradiance

漫反射光照低频：irradiance 随表面法线变化平滑，适合用低阶 SH 表示。

低阶 SH 足够：前 9 个系数（每个 RGB 通道）就能表示环境光，误差约 1%；间接光照甚至只需 4 个系数（12 个浮点数）。

卷积方法高效：

从 radiance 贴图计算 irradiance 实际上是与 clamped 余弦函数卷积。
卷积在 SH 空间中可通过系数相乘快速完成：
$$ k_{E j} = k_{\cos^+ j}' \, k_{L j} $$
$k_{L j}$ 是 radiance 的 SH 系数，$k_{\cos^+ j}’$ 是 clamped 余弦函数系数的缩放

紧凑：比立方体贴图或抛物线贴图节省存储。

高效：渲染时可通过多项式计算重建 irradiance，而无需纹理采样。

动态光源支持：

新光源的 SH 系数可以累加到已有 SH 系数中，无需重算整个贴图。
点光源、圆盘光源、球光源等均有解析 SH 表达式，可快速叠加。

其他方法

方法	特点	优缺点
半球光照（hemisphere lighting）	使用天空颜色 $L_{sky}$ 和地面颜色 $L_{ground}$ 两种均匀radiance表示上半球和下半球	简单、存储少、计算快；精度低
环境立方体（ambient cube）	将半球光照扩展为6个方向的立方体	较SH更直观，可用于快速计算；存储略大
球面高斯函数	对irradiance使用旋转对称的高斯函数表示	平滑，适合低频光照
H-basis	只能表示一个半球方向	有局限，法线向下时不可用
SH（球谐函数）	低频光照的紧凑表示，可做卷积、动态光源累加	高频光照不足，振铃现象存在

Games104：游戏引擎的动画技术基础

Mon, 20 Oct 2025 15:00:44 +0800

蒙皮动画

这里讲的就是科普了一下

坐标系

实际存储的数据是关节数据

Root关节一般存在脚底，为了方便计算移速、跳跃高度。髋关节是第一个子关节

T-pose和A-pose：

A-pose 下，肩关节旋转角度为 0°，肘部微弯 15°，手掌自然朝向大腿关节，旋转轴处于中性位置，绑定师可以更精确地绘制顶点权重，控制手臂摆动和肌肉变形，提高工作效率和质量。T-pose 中，肩部会受到挤压，当手臂放下时，可能会出现肌肉穿模等问题。A-pose 则能避免这种情况，其腋下、胯部等容易穿帮的区域自然展开，为后续的动画制作提供了更好的基础，减少了调整和修正的工作量。

3D空间的旋转

这块东西在Games105数学原理博客部分已总结

欧拉角

分别沿着三个轴旋转，旋转矩阵可以合并成一个

缺点：

顺序依赖
万向锁，直接用公式也能解释，把y轴旋转带入后，整个旋转公式只剩下x轴旋转部分了，z轴的都没了

欧拉角的插值有问题

四元数

在二维平面上可以用复数代表旋转。另外旋转的叠加可以直接通过Product运算算出

拓展到3D旋转

欧拉角转四元数

用四元数旋转一个顶点

总结后：直接表达成旋转矩阵如下

用四元数表达从U旋转到V

可以通过下面的公式计算出对应的旋转四元数是多少

四元数表达给定轴的旋转

蒙皮动画

骨骼信息

旋转，大部分都是以旋转为主

平移

平移还是有用的，比如站立和蹲下是时Root和髋关节就发生了平移

放缩

所以Joint Pose就是，其中旋转矩阵可以通过四元数转化而来（注意这个变换不需要透视除法）

另外骨骼信息存储的都在局部坐标系，也就是说骨骼信息存储的实际是它相对于父骨骼的变换信息，而不是相对于整个模型。

如果使用局部坐标系：

只需更新父骨骼的变换，就能自动影响子骨骼。
方便做层级动画，比如抬手动作只需要改手臂局部变换，身体会自动跟随。

如果存储在模型坐标系：

每个骨骼的世界变换必须单独存储或重复计算。
当父骨骼旋转时，需要手动更新所有子骨骼的世界位置，计算复杂且容易出错。

动画混合（比如走路 + 挥手）通常对局部骨骼变换进行插值或加权，而不是对世界位置插值：

局部空间插值保持层次一致性，不会出现骨骼分离或错位。
世界空间插值容易导致骨骼错位或姿势破坏，因为子骨骼的位置依赖父骨骼。

蒙皮矩阵

现在已经理解了骨骼信息如何存储，下面介绍骨骼信息如何作用到顶点上

下图说明即使骨骼移动，顶点与骨骼的相对位置并不会变化

Bind Pose：默认姿态用于绑定骨骼和顶点

下面三个参数分别是某个顶点：

绑定姿态下的模型空间位置
绑定姿态下的局部空间位置
绑定姿态下的骨骼在模型空间的位置

顶点相对于骨骼的位置在任何时候都不会变，并且等于骨骼在模型空间位置的逆矩阵 x 顶点在模型空间中的位置

顶点的位置 = BindPose下顶点位置先转到骨骼的局部坐标系再跟着骨骼运动后的位置

在存储骨骼信息时，需要存储Inverse BindPose Matrix，它是把变换矩阵一路从父节点传递下来，得到当前骨骼的模型坐标系下的变换信息，然后求逆。

Inverse BindPose Matrix的作用是把一个在模型坐标系下的顶点坐标（bindpose下的）转移到这根骨骼上，所以不管任何时候，转移后得到的结果都应该是一样的

把顶点信息（bindpose下）转移到骨骼后，再乘以现在的骨骼变换矩阵，就得到了顶点的现在的位置（实际位置），这样也就得到了一帧动画下这个顶点的位置

蒙皮变换

总结下：在骨骼蒙皮动画中，每个顶点在 Bind Pose（绑定姿态） 下的模型空间位置，通过 Skinning Matrix（即 $M_i \cdot B_i^{-1}$ 的加权和）进行变换后，就得到了该顶点在当前动画帧下的最终渲染位置。

$$ v_\text{final} = \sum_i w_i \, (M_i \cdot B_i^{-1}) \, v_\text{bind} $$

$v_\text{bind}$ —— 顶点在绑定姿态下的模型空间坐标
$B_i^{-1}$ —— 骨骼绑定姿态的逆矩阵（Inverse Bind Pose）
$M_i$ —— 当前帧骨骼的变换矩阵
$w_i$ —— 顶点对骨骼的权重

另外再乘上Model变换矩阵，就转移到世界坐标系，所以传递给GPU的变换信息应该是下面这个整体的变换公式

多个骨骼影响的加权平均应该放在模型坐标系

动画的插值

Games105（2）已经详细记录

四元数的NLearp插值的角速度不同

解决上述问题的办法

动画的Runtime Pipeline

计算运行时间
计算插值
计算骨骼信息
计算蒙皮矩阵
更新顶点信息

动画压缩

5S的动画数据要求2GB存储空间

骨骼信息大量变化的都是旋转

Physically Based Shading(2) 基于物理的着色

Mon, 20 Oct 2025 13:29:19 +0800

概括

理解了渲染方程设计理由
分清楚了表面反射（镜面反射）和局部次表面反射（漫反射）
知道了常用的BRDF，以及漫反射BRDF项还有很多更好的模型

光的物理学

光的本质

在物理光学中，光被视为一种电磁横波，即由电场和磁场的振荡组成；
电场与磁场：
- 相互垂直；
- 都垂直于光的传播方向；
- 振幅比值恒定；
这种波的传播速度称为相位速度（phase velocity），在真空中就是光速 c ≈ 3×10⁵ km/s。

光的波长决定颜色：可见光波长范围约为 400–700 nm；
单色光（monochromatic light）：只有一个波长（如理想化的正弦波）；
多色光（polychromatic light）：包含多个波长，是现实中的常见情况；
例如蜘蛛丝约为 1 µm，约等于 2–3 个波长大小。

光的能量与电场强度

光波携带能量；
能量流强度（irradiance, $E$）与电场振幅的平方成正比；
渲染中关注的是时间平均能量流，即平均 irradiance；
因为电场比磁场对物质的影响更大，渲染只关注电场部分。

波的叠加与干涉

光波可以线性叠加；
不同相位的叠加导致不同结果：
1. 相长干涉（constructive interference）：
  - 相位一致 → 叠加强；
  - irradiance 增为 $n^2$ 倍；
2. 相消干涉（destructive interference）：
  - 相位相反 → 互相抵消；
  - irradiance 变为 0；
3. 不相干叠加（incoherent addition）：
  - 相位随机；
  - irradiance 线性叠加为 $nE_1$，即“1+1=2”。
这些现象并不违反能量守恒，因为：
- 在空间不同位置上会交替出现相长与相消；
- 总能量守恒。

n个具有相同频率、相同偏振和相同振幅的单色光，它们以三种不同的方式进行叠加。从左到右分别是：相长干涉，相消干涉和不相干叠加。每种情况的下面都展示了对应组合波的振幅和irradiance

光与物质的相互作用

当物体中的电荷振荡时会发出电磁波（即发光）；
- 能量形式如热能、电能被转化为光能；
- 渲染中将其视为光源；
当光照射到物质上：
- 电场驱动物质内电荷振荡；
- 振荡电荷再次发出光 → 散射（scattering）；
散射出的光与原光频率相同（除荧光、磷光等少数情况）；
一个分子会向各方向散射，但多数光保持接近原传播方向；
散射效率依赖于波长；
实际中光与分子群体相互作用，可能产生相干干涉效应；
这些多分子散射的情况是之后章节的重点。

粒子

这里讲的是瑞丽散射和米氏散射，不同的散射情况与粒子大小与光的波长的比较有关，我在OpenGL渲染器的大气渲染原理部分已经记录过了

介质

光在均匀介质（homogeneous medium）中进行传播是另一种重要的情况，均匀介质是指一个充满均匀分布的相同分子的空间。这里所说的均匀分布，并不是指分子间距要像晶体一样完全规则，如果液体和非晶体是纯净物（所有的分子都是相同的），并且没有间隙或者气泡的话，也可以认为它们在光学上是均匀的。

在均匀介质中，光的传播核心特点是散射波的相消干涉：

分子散射产生的次级波会整齐排列，除原始传播方向外，所有其他方向的散射波会因相位相反相互抵消（相消干涉）；
原始波与所有单分子散射波叠加后，最终波形与原始波基本一致，仅相位速度和（部分情况下的）振幅发生改变；
相消干涉完全抑制了散射现象，因此均匀介质不会表现出明显的散射效果。

四个装有不同吸收性质液体的小容器。从左到右分别是：纯净水，石榴汁，茶，咖啡

非均匀介质可简化为 “嵌有散射粒子的均匀介质”，其光学行为的核心是 “相消干涉的破坏”：

从左到右分别是：水，加了几滴牛奶的水，加了大约10%牛奶的水，全脂牛奶，乳白色玻璃。大多数牛奶的散射粒子都要比可见光的波长大，因此它的散射主要是无色的，在中间的图像上有明显的淡蓝色。在最右侧图像中，乳白色玻璃中的散射粒子要比可见光的波长小，因此蓝光的散射强度要比红光强；同时由于明暗背景的分割，透射光在左边更加明显，而散射光则在右边更加明显。

介质对光的影响本质是散射与吸收的组合效应：均匀介质通过相消干涉抑制散射，其光学性质由复折射率（n+iκ）描述；非均匀介质因结构无序破坏相消干涉，散射成为主要特征，且散射 / 吸收的效果均与尺度、粒子尺寸、波长密切相关。这一规律是理解自然现象（如天空蓝、水的蓝色、牛奶的白色）和渲染技术中介质模拟的基础。

散射和吸收现象都与尺度有关。在小场景中不产生任何明显散射的介质，在较大的尺度上也可能会有相当明显的散射现象。例如：当在房间内观察一杯水时，光在空气中的散射与在水中的吸收是几乎不可见的；然而在一个较大尺度的环境中，这两种效果可能都会十分显著，如图9.7所示。

左图中：在超过几米的范围内，水会对光产生强烈的吸收作用，尤其是红光，因此整体看起来会很蓝。右图中：光在没有严重空气污染或者雾的情况下，也会在数英里尺度的空气中发生散射。

具有不同吸收作用和散射作用组合的液体容器。

表面

从光学角度来看，物体的表面（surface）是一个二维界面，它分隔了具有不同折射率的空间体积。在一般的渲染情况下，由空气组成的外部空间，其折射率约为1.003，为简单起见，通常假设空气的折射率为1；而内部空间的折射率则取决于构成物体的物质。

一个光波撞击一个平面，平面两侧物质的折射率分别为n_1 和n_2。左侧图展示了入射波的侧视图，这个入射波从左上角进入，红色的强度代表了波的相位。表面下方的波间距与(n_1/n_2)成正比，本例中为0.5。相位沿着表面排列，因此间距的变化会弯曲（折射）透射波的方向。图中三角形的构造展示了Snell定律的推导过程。为了清晰起见，右上方的图显示了反射波的情况，它与入射波具有相同的波间距，因此其方向与表面法线具有相同的夹角。右下方展示了入射波、透射波和反射波方向的矢量图。

最终结果如图9.9所示。反射波和入射波的方向，与表面法线之间具有相同的夹角$\theta_i$；透射波的方向会以$\theta_t$的角度进行弯曲（折射），它与$\theta_{i}$的关系如下：

$$ \sin \left(\theta_{t}\right)=\frac{n_{1}}{n_{2}} \sin \left(\theta_{i}\right). \tag{9.1} $$

上边主要描述了在光在表面发生的反射与折射，下面描述的是微表面模型

左侧展示了两个表面的照片，右侧使用示意图的形式，展示了它们所对应的微观几何结构。上方的表面拥有略微粗糙的微观几何形状，入射光线击中了表面上不同的点，每个点的法线方向略有差异，并在一个狭窄的锥形方向上被反射，其宏观效果是具有轻微模糊的反射。下方表面具有更加粗糙的微观几何形状，入射光线照射到的表面点，具有明显不同的法线方向，反射光线会以一个较宽的锥体进行扩散，从而导致宏观的反射效果变得更加模糊。

在渲染中，我们并不会对微观几何形状进行明确的建模，而是会以一种统计的方式对其进行处理，将该表面视为一个具有微观结构法线的随机分布。因此，我们将表面建模为，会在一个连续方向上（译者注：一定的立体角范围内），对光线进行反射和折射。其中这个连续方向的宽度（锥形范围的大小，或者是立体角的大小），以及反射细节和折射细节的模糊程度，取决于微观几何法线的统计方差，即表面微尺度的粗糙度（roughness），如图9.13所示。

次表面散射

进入物体内部的折射光线，会继续与内部物质发生相互作用。前面我们提到，金属具有较高的吸收率和较高的反射率，即金属表面会反射大部分的入射光线，进入金属内部的折射光线也会被迅速吸收；相比之下，非金属物体则会表现出广泛的散射行为和吸收行为

这种次表面散射（subsurface scatter）的光线，会以相对于入射点的不同距离从表面射出，这个进出距离（entry-exit distances）的分布取决于材料中散射粒子的密度和性质，这些距离与着色尺度（像素的大小，以及着色样本之间的距离）之间的关系是很重要的。如果这个进出距离比着色尺度要小，那么可以假定它们为零，这样我们就可以将次表面散射与表面反射整合到同一个局部着色模型中，即某个着色点上的出射光线，只依赖于该点的入射光线。由于次表面散射与表面反射具有明显不同的外观表现，因此可以很容易地将它们划分为单独的着色选项，使用镜面项（specular term）控制表面反射现象，使用漫反射项（diffuse term）控制局部次表面散射（local subsurface scattering）现象。

就是说镜面项是表面反射结果，漫反射项是次表面反射的结果（前提是光进入表面的距离很小）。光线进出的距离很长（＞着色尺度）—— 比如牛奶、蜡烛、玉石、厚玻璃这些材料，光在内部跑了毫米级甚至厘米级距离才出来（比如用手电筒照牛奶杯，对面会透出光，还会有颜色渐变）；这种 “远距离的次表面散射”，就不能再用简单的漫反射项模拟了，需要专门的次表面散射模型（比如 SSS 材质、BSSRDF 模型），因为它的出射光不仅和入射点有关，还和周围区域的入射光有关（比如玉石的 “通透感”“温润感”，就是这种长距离 SSS 的效果）。

值得注意的是，局部次表面散射技术和全局次表面散射技术模拟的是完全相同的物理现象。每种情况下的最佳选择（即到底使用哪种模型和技术），不仅取决于材质的属性，还取决于观察的尺度。例如：当渲染一个孩子在玩塑料玩具的场景时，我们很可能需要使用全局次表面散射技术来准确地渲染孩子的皮肤，而对于塑料玩具而言，可能一个局部的漫反射着色模型就足够了。这是因为皮肤中的散射距离，要比在塑料中的散射距离大得多，但是如果相机足够远的话，皮肤的散射距离也可能会小于一个像素，此时局部的着色模型对于儿童和玩具而言都是十分准确的。相反，在一个极端的特写镜头中，塑料也可能会表现出明显的非局部次表面散射现象，这时候就需要全局次表面散射技术来对玩具进行准确地渲染。

在观察尺度大于次表面散射尺度时，用漫反射来控制局部sss即可，但是观察尺度很小时，局部sss就不够了，需要全局sss（也就是漫反射不能只考虑当前像素，光进入物体距离大于一个像素）

相机

在渲染的时候，我们会计算从表面着色点到相机位置的radiance。这模拟了一个简化了的成像系统，例如胶片相机、数码相机或者人眼。

成像设备中都有一个传感器表面，由许多小单元组成（像素级别）：
- 人眼 → 视杆细胞、视锥细胞；
- 数码相机 → 光电二极管（photodiode）；
- 胶片 → 感光颗粒；
这些传感器测量的是打到它们表面的irradiance（照度）；
- 即单位面积上接收到的能量流强度。

问题：irradiance 本身不能直接形成图像

单个传感器只能测到“有多少光打在它上面”，但它不区分光来自哪个方向。如果不加控制（例如完全裸露的感光平面），所有方向的光都会混在一起，导致图像失焦或模糊。

光圈与透镜的作用

为了让传感器只响应特定方向的光，成像系统会加上以下结构：

不透光外壳：阻挡多余方向的光；
小孔（aperture, 光圈）：只允许部分方向的光进入；
透镜（lens）：将来自场景某点的光聚焦到传感器的对应像素。

这样，每个传感器只接收来自：

一小块场景区域；
一小组入射方向。

换句话说，每个传感器对光具有了方向性响应（directionally specific）。

irradiance → radiance 的关系

传感器测量的irradiance，其实是：
$$ E = \int L(x, \omega_i) \cos\theta_i\, d\omega_i $$
——即所有入射方向上radiance的加权平均；
但由于相机光圈和镜头只允许一小范围的方向入射，实际上每个像素感受到的就是该方向上的平均radiance。

The BRDF

最终，基于物理的渲染可以归结为沿着一组观察射线，计算进入相机的radiance。对于一个给定的观察射线，我们需要计算的是$L_{i}(\mathbf{c},-\mathbf{v})$，其中$\mathbf{c}$是相机的位置，$-\mathbf{v}$是沿着观察射线的方向。

不考虑介质的影响，认为进入相机的radiance，与其观察方向上离开最近物体表面的radiance是相等的

所以着色计算就转到了计算物体表面p向方向v的radiance。

不考虑透明物体和全局次表面散射的情况；我们所关注的是局部反射现象，它将照射到当前着色点的光线，重新发射回外部，这些现象包括表面反射以及局部次表面散射，它们只依赖于入射光方向$\mathbf{l}$和指向外部的观察方向$\mathbf{v}$。

双向反射分布函数（bidirectional reflectance distribution function，BRDF）描述了着色点表面的局部反射系数，记为$f(\mathbf{l}, \mathbf{v})$。

光线的入射方向和出射方向各有两个自由度。
一种常用的参数化表示包括两个角度：
- 仰角 $$\theta$$：相对于表面法线 $\mathbf{n}$
- 方位角 $$\phi$$：相对于表面法线 $\mathbf{n}$ 的水平旋转
在一般情况下，BRDF 是一个包含 四个标量变量 的函数：
- 两个描述入射方向 ($$\theta_i, \phi_i$$)
- 两个描述出射方向 ($$\theta_o, \phi_o$$)
各向同性 (Isotropic) BRDF 是一个重要特例：
- 当光线入射方向和出射方向围绕表面法线 $$\mathbf{n}$$ 旋转时，BRDF 保持不变，只依赖于入射和出射方向之间的相对角度。
- 对各向同性 BRDF，只需要 三个标量变量：
  - 入射方向仰角 $$\theta_i$$
  - 出射方向仰角 $$\theta_o$$
  - 入射与出射方向的相对方位角 $$\phi = \phi_o - \phi_i$$
换句话说，如果将一个具有均匀各向同性材质的物体放在转盘上旋转，在给定光线和相机条件下，物体表面在所有旋转角度上看起来都是相同的。

由于忽略了荧光（fluorescence）和磷光（phosphorescence）等现象，我们可以假设，给定波长的入射光会以相同波长被反射出来。
反射光的光量会根据波长变化，可以用两种方式模拟：
1. 将波长视为 BRDF 的额外输入变量；
2. 将 BRDF 视为返回光谱分布的值。

在实时渲染中，通常使用第二种方法，实时渲染器一般将光谱分布表示为一个RGB三元组，这意味着BRDF会返回一个RGB值

为了计算着色点的出射光线 $$L_{o}(\mathbf{p}, \mathbf{v})$$，我们将 BRDF 项合并到反射方程（reflectance equation）中：

$$ L_{o}(\mathbf{p}, \mathbf{v}) = \int_{\mathbf{l} \in \Omega} f(\mathbf{l}, \mathbf{v})\, L_{i}(\mathbf{p}, \mathbf{l})\, (\mathbf{n} \cdot \mathbf{l})\, d \mathbf{l} \tag{9.3} $$

公式说明：
- 积分下标 $$\mathbf{l} \in \Omega$$ 表示对以着色点 $$\mathbf{p}$$ 为球心、表面法线 $$\mathbf{n}$$ 为方向的单位半球上所有入射光方向 $$\mathbf{l}$$ 积分；
- 入射光方向 $$\mathbf{l}$$ 在半球范围内连续扫描，并非单一光线；
- $$d\mathbf{l}$$ 表示入射方向 $$\mathbf{l}$$ 周围的单位立体角微分；
- 出射 radiance 等于入射 radiance 乘以 BRDF 再乘以 $$\mathbf{n} \cdot \mathbf{l}$$ 点积的积分。
- $Li(\mathbf{p}, \mathbf{l})$是 入射 radiance，表示从方向 $\mathbf{l}$ 到达点 $\mathbf{p}$ 的光强度

在第一行中，左侧展示了一个Lambertian BRDF（一个简单半球）；中间展示了在Lambertian项中添加了Blinn-Phong高光的结果；右侧展示了Cook-Torrance BRDF [285, 1779]，值得注意的是，镜面高光并不是最强的反射方向。在第二行中，左侧是Ward各向异性模型的特写，在这种情况下，反射方向是一个倾斜的镜面波瓣；中间展示了Hapke/Lommel-Seeliger“月面（lunar surface）”BRDF [664]，它具有强烈的后反射；右侧展示了 Lommel-Seeliger散射，尘埃表面会将光线散射到掠射角上（grazing angle）。

表面反射的BRDF模型

这部分LearnOpenGL的PBR模型部分已经记录，就是NDF项如何建模使用

次表面散射的BRDF模型

这里知道了BRDF的漫反射部分（也就是这本书中介绍的局部次表面散射部分）除了最简单的Lambertian漫反射模型，还有很多更复杂的模型，但是实时渲染用Lambertian足够了

对于 Lambertian 漫反射，BRDF 定义为：

$$ f_r(\mathbf{l}, \mathbf{v}) = \frac{\rho}{\pi} $$

其中：

$\mathbf{l}$ = 入射光方向
$\mathbf{v}$ = 出射方向（视线方向）
$\rho$ = 漫反射反射率（albedo），范围 [0,1]
$\pi$ = 正则化因子，保证能量守恒

布料的BRDF模型

布料材质特点

微观几何结构复杂：纤维、丝线、编织结构等
表面光学特性特殊：
- 各向异性镜面高光
- 粗糙散射（次表面散射导致边缘亮）
- 观察角依赖的颜色变化（多色纤维引起）
高频空间变化显著（纹理、老化、瑕疵、皱褶等）

结论：默认通用BRDF（Lambert + GGX）无法准确模拟这些特性。

布料BRDF的三大类

经验模型（Empirical）
- 根据观察设计，非物理正确
- 示例：
  - 《神秘海域2》漫反射BRDF + rim/inner/lambert项
  - 《神秘海域4》使用 wrap lighting 近似次表面散射
  - 迪士尼的 sheen 项模拟粗糙散射
微表面模型（Microfacet / Micro-surface）
- 使用 NDF 描述纤维表面微结构
- 示例：
  - Ashikhmin 逆高斯 NDF 模拟天鹅绒
  - 《教团：1886》使用改进微表面BRDF + 天鹅绒 NDF
  - Imageworks 提供可附加光泽项的逆NDF
微圆柱体模型（Micro-cylinder / Fiber-based）
- 假设表面由大量一维纤维/线段组成
- 示例：
  - Kajiya-Kay / Banks 模型
  - 《神秘海域4》用于丝绸、高光纤维
  - Dreamworks 和 Sadeghi 的模型增加了可控参数和masking-shadowing
  - 可借鉴头发BSDF（PxrSurface、Marschner模型）

布料材质光学特性特殊，通用BRDF适用性有限

不同布料类型（天鹅绒、丝绸、棉花、羊毛等）需要不同BRDF或BSDF来模拟

模型选择依据材质：

经验模型 → 视觉效果优先、易控制
微表面模型 → 模拟高光、粗糙散射
微圆柱体模型 → 精确描述纤维方向性、masking-shadowing

波动光学的BRDF模型

这。。了解即可

几何光学的假设与局限

几何光学把光当作射线，适用于表面特征要么非常小（< 波长），要么非常大（> 100 倍波长）的情况。
现实世界表面在1~100倍波长的尺度上具有不规则性，这部分被称为纳米几何（nanogeometry）。
纳米几何对反射率的影响无法用几何光学模拟，需要使用波动光学。

衍射（Diffraction）

纳米几何会导致光发生衍射，Huygens-Fresnel原理解释了光如何在表面点作为新球面波源传播并相干干涉。
表面高度的不规则性决定了镜面反射与衍射光的分布：
- 较大尺度的不规则性 → 小扩散角度
- 较小尺度的不规则性 → 大扩散角度
周期性纳米结构（如CD、DVD、昆虫翅膀）可产生显著的彩虹色衍射。
最近的研究表明，衍射在许多普通材质中也存在，只是传统渲染模型未考虑。

薄膜干涉（Thin-film interference）

发生在厚度接近光波长的薄膜上，例如油渍、肥皂泡。
原理：薄膜顶部反射光与底部反射光的光路差导致相长/相消干涉。
产生的效果：
- 高光随观察角度变化，出现彩虹色或微妙色偏。
相干长度决定了干涉是否可见：
- 可见光的相干长度约 1 微米，因此厚度超过 1 微米的薄膜通常不会产生可见干涉。
实时渲染中：
- 可以用查表或近似方法高效实现一阶、二阶光路干涉。
- 已经被许多现代渲染器（RenderMan、Imageworks）采用，增强材质真实感。

总结

几何光学适用于宏观微表面，但无法处理纳米尺度的光学效应。
波动光学补充了几何光学的不足：
1. 衍射：纳米几何导致光在各方向散射和干涉。
2. 薄膜干涉：薄层材质产生随角度变化的彩虹高光或微妙色偏。
在渲染中，这些效应虽然属于“细节”，但对真实感有显著提升，现代材质模型和渲染器已开始支持这些效果。

分层材质

概念：现实中的材质通常由多层组成，例如灰尘、水、冰、雪、涂层或生物材料。
透明涂层（Clear Coat）：
- 最常见且视觉重要的分层案例。
- 透明光滑层覆盖在基底材质上，如木材上涂清漆。
- 二次反射效果显著，尤其在金属基底上。
- 可以有颜色（通过Beer-Lambert定律模拟光吸收）。
- 支持逐层法线，但实时渲染中较少用。
分层材质模型实例：
- 迪士尼Principled Shader、虚幻引擎、PxrSurface材质、Dreamworks/Imageworks。
- Weidlich & Wilkie模型：多层叠加，追踪单次反射/折射，计算成本低，适合实时。
- Jakob等框架：支持层间多次反射，精确但不适合实时渲染。
- 游戏《使命召唤：无限战争》：可叠加任意层，支持折射、散射、层间吸收及逐层法线，实时渲染复杂材质。

材质混合（Material Blending）

概念：将多种材质的BRDF参数结合在一起。
方法：
- 使用蒙版纹理控制不同材质混合区域。
- 可在运行时或预烘焙完成。
- 可混合法线贴图，通过高度贴图或细节法线叠加实现。
应用：
- 展示动态伤害效果
- 用户自定义装备/服装
- 增加角色与环境视觉多样性
性能优化：
- 对蒙版边界材质，优先混合BRDF参数而非计算两次着色。

材质过滤（Material Filtering）

概念：纹理在GPU上通过mipmap和滤波进行采样，但假设参数与最终颜色线性，非线性参数可能产生瑕疵。
主要问题：
- 法线贴图和粗糙度贴图的线性mipmap可能导致高光闪烁或亮度异常。
解决方法：
1. 法线分布过滤：
  - 理想方法：对NDF进行平均，而非对法线或粗糙度单独平均。
  - Toksvig方法：通过平均法线长度修正粗糙度（公式9.76），适合Blinn-Phong/Beckmann NDF。
  - LEAN/CLEAN/LEADR映射：基于法线协方差矩阵，处理各向同性或各向异性。
2. 方差映射：
  - 预计算法线方差存储到纹理中，用于修正粗糙度，兼顾GPU滤波。
  - 可用于多法线叠加（如细节法线）。
3. 高频表面和闪闪发光材质：
  - 闪烁现象由每像素覆盖少量凸起引起。
  - 实时渲染方法：
    - Wang & Bowles：产生视觉闪光效果（雪花等）。
    - Zirr & Kaplanyan：模拟多尺度法线分布，空间和时间上稳定。

Physically Based Shading (1) 光与颜色

Mon, 20 Oct 2025 11:41:15 +0800

Light and Color 光与颜色

这一章节除了辐射度量学，toneMapping、颜色分级我感觉会用到，其他更多是科普内容，比如为什么用RGB就能代替可见光

光量

任何基于物理的渲染方法，其第一步都是以一种精确的方式，来对光进行量化（quantify）。

辐射度量学

在不同的课程中接触了这个东西几次，每次都有不一样的理解😝，下图展示了光的波长范围与人可见光的范围

各个辐射量（radiometric quantity）的存在是为了对电磁辐射的各个方面进行测量和度量，例如：总能量、功率（随时间变化的能量）以及相对于面积、方向或者二者的功率密度等

在辐射度量学中，最基本的单位是辐射通量（radiant flux）Φ，辐射通量是指辐射能量随时间的流动变化，又叫做功率（power），其单位为瓦特(watts，W)。==理解为做功的功率即可==
辐照度（irradiance）是辐射通量相对于面积的密度，即$ d \Phi / d A$。irradiance是相对于一个面积来进行定义的，这个面积可能是空间中的一个假想区域，但是在渲染中一般都是物体的表面。irradiance的单位是瓦特每平方米（$W/m^2$）。==理解为功率在单位面积上的大小==，
辐射强度（radiant intensity），即辐射通量相对于方向的密度，更准确地说，是相对于立体角的密度$（d \Phi / d \omega）$。它的单位是瓦特每立体弧度$（W/sr）$
最后，辐射度（radiance）L是对单条光线中电磁辐射的度量。更精确地说，它是辐射通量相对于面积和立体角的密度$（d^{2} \Phi / d A d \omega）$。这里的面积位于垂直于光线的平面上，如果想要在其他方向上对表面施加辐射，则必须使用余弦因子进行校正。==进一步把irradiance划分到单位立体角==

立体角可以理解为立体空间的一个立体方向截取一个单位球体的面片面积

radiance是传感器（例如眼睛或者相机）所直接测量的对象，因此它对渲染而言至关重要。计算着色方程的目的就是沿着给定的光线，计算从着色点到相机的radiance；沿着这条光线计算出来的结果L。radiance的公制单位是瓦特每平方米每立体弧度$（W/m^2sr）$

环境中的radiance可以被认为是五个变量（或者六个变量，将波长考虑在内）的函数，它被称为辐射分布（radiance distribution）；其中有三个变量指定了位置，另外两个变量指定了方向，这个分布函数描述了在空间中任何地方传播的任何光线。根据上面的描述，我们可以这样来理解渲染过程：将眼睛和屏幕定义为一个点和一组方向（例如从眼睛出发，穿过每个像素的光线），然后使用这个函数，在这组方向上对眼睛所在的位置进行评估。

在着色方程中，radiance通常会以$L_{o}(\mathbf{x}, \mathbf{d})$或者

$$L_{i}(\mathbf{x}, \mathbf{d})$$

的形式出现，它代表了从点x发出，或者进入点x的radiance具体是多少。方向向量$\mathbf{d}$表示了光线的方向。radiance的一个重要特性是，在忽略了雾等大气效应影响的前提下，radiance不会受到传播距离的影响。换句话说，无论一个表面与相机的距离有多远，它们都将具有相同的radiance。当距离相机越远时，这个表面所覆盖的像素就越少，但是来自表面上每个像素的radiance是恒定的。

多数光波中都包含了许多不同波长的单色光，这通常可以被可视化为一个光谱功率分布（spectral power distribution，SPD），它是一个展示了光线能量如何在不同波长之间分布的图片。（三种不同光波的光谱功率分布（SPD）。第一行是一个绿色激光的SPD，它有一个非常狭窄的光谱分布，其波形类似于图9.1中的简单正弦波。第二行的SPD是由相同的绿色激光，外加两个额外的激光所组成的，分别是红色激光和蓝色激光。将这些激光的波长和相对强度转换到RGB激光投影显示器上，会显示出中性白色。第三行的SPD是标准的D65光源，这是一个典型的中性白色参考值，旨在代表室外的自然光照，类似第三行的SPD，其能量连续地分布在可见光谱上，是典型的自然光。）

==在下图中人眼对于第二行和第三行的感知是一样的，这就是为什么只用三个数字就可以精确地表示任何颜色的原因==

光度学

辐射度量学仅仅对物理量进行了研究，它完全没有考虑人眼的感知。与此相关的一个领域被称为光度学（photometry），它与辐射度量学类似，不同之处在于，它会根据人眼的敏感度，对辐射度量学中的一切事物进行加权处理。通过乘以CIE光度曲线（CIE photometric curve），辐射度量学中的计算结果可以被转换为相应的光度单位。CIE光度曲线是一条以555纳米为中心的钟形曲线，它代表了人眼对各种波长光线的响应程度。

这个转换曲线与测量单位，是光度学理论和辐射度量学理论之间的唯一区别。每个辐射物理量都有一个对应的光度学物理量

Luminance通常用来描述平面的亮度。例如：高动态范围（high dynamic range，HDR）电视屏幕的峰值亮度通常在500到1000尼特（nit）之间。相比之下，晴朗天空的亮度大约为8000尼特，60瓦的电灯泡约为12万尼特，地平线上的太阳约为60万尼特。==所以尼特相当于Radiance==

色度学

人眼对于颜色的感知与光线的SPD（光谱功率分布，上上一节提到）密切相关。同时我们还知道了，二者之间并不是简单的一一对应关系。第二行和第三行所展示的SPD完全不同，但给人的感知却是完全相同的。色度学（colorimetry）研究的就是SPD和颜色感知之间的关系。

人眼可以分辨大约1000万种不同的颜色。对于颜色感知，人眼的视网膜上有着三种不同类型的视锥感受器（细胞），每种感受器对于不同波长的光线都有不同的反应。其他动物的眼睛则有着不同数量的颜色感受器，有些动物的眼睛甚至多达15个。因此，对于一个给定的SPD，我们的大脑只会从这些感受器中接收到三种不同的信号，这就是为什么只用三个数字就可以精确地表示任何颜色的原因

书中描述了一组实验来说明人类如何用科学方法量化 “颜色感知”。从人眼的生理特性出发，通过实验建立标准，最终用简单的数值（比如 XYZ、xy）精准描述任何颜色，解决了 “不同光线（SPD）可能看起来一样” 的问题。用 XYZ 表达任何颜色的核心原理，不管光线的光谱多复杂，只要编码（XYZ）相同，人眼感知到的颜色就完全一致。

CIE 1931 色度图（图 8.8）是一张「人类可见颜色的 “地图”」—— 把所有我们肉眼能分辨的颜色，都精准定位在一张二维图上，核心作用是直观展示 “颜色的位置、范围和关系”，方便标准化对比和应用（比如屏幕、打印机的颜色匹配）。

图上的黑色轮廓线，就是 “人类可见颜色的全部范围“。
白色三角形：代表某类设备的「色域范围」。三角形的三个顶点，对应设备能发出的 “三种基础色”（比如屏幕的红、绿、蓝像素，打印机的青、品红、黄墨水）；
三角形内部的所有颜色，都是这台设备能精准还原的颜色；
三角形外部、但在黑色轮廓内的颜色，这台设备 “显示 / 打印不出来”（会被近似替代）；
黑点：代表「标准白光」

色度图仅仅描述了一个平面，它仅包含了颜色的色调信息，想要完整地描述一个颜色，还需要第三个维度Y，即亮度luminance。这三个坐标在一起，定义了所谓的xyY坐标系。色度图对于理解颜色在渲染中的使用，以及理解渲染系统中的限制而言非常重要。电视或者计算机显示器会通过使用R、G、B颜色值来呈现颜色，每个颜色通道都会控制一个显示原色（display primary），这个原色会发出具有特定SPD的光线。三种原色都会按其各自的颜色值进行缩放，这些颜色值被叠加在一起，从而生成一个被观众所感知的单一SPD。

在图形渲染中有几个值得关注的RGB色域空间，每个空间都由R、G、B三原色和一个白点进行定义。为了对它们进行比较，我们将使用一种不同类型的色度图，它被称为CIE 1976 UCS （uniform chromaticity scale）色度图。它是CIELUV颜色空间的一部分，CIE将CIELUV颜色空间（以及另一个颜色空间CIELAB）作为XYZ颜色空间的替代方案

上边这些东西总结起来用于解释为什么RGB的vec3就可以用来渲染颜色，因为不管光线的波长组合多复杂（也就是 SPD 多不一样），只要它们给人眼的颜色感知相同，就都能用同一组 RGB 数值代替。

使用RGB颜色进行渲染

严格来说，RGB颜色值代表的是感知量，而不是真实的物理量，使用RGB颜色值来进行基于物理的渲染，在技术上来说是一个分类错误。正确的方法应当是在光谱物理量上执行所有的渲染计算，然后通过密集采样或者是投影到适当的基底上，并在最后将其转换为用于屏幕输出的RGB颜色值。

展示了一种用于激光投影仪屏幕的材料，它在激光投影仪光线波长的窄带处，具有较高的反射率，而在其他大多数波长上的反射率都较低。这使得这个屏幕表面会反射投影仪所发出的大部分光线，同时会吸收来自其他光源的大部分光线。在这种情况下，RGB渲染器将会产生严重的渲染错误。==一个极端例子展示RGB会错误渲染的场景==

然而，对于大多数渲染系统而言，尤其是那些并不是用于预测模拟的交互式应用程序而言，RGB渲染的效果得出奇的好。即使是动画电影的离线渲染中，也只是在最近才开始使用光谱渲染，而且只是少数情况，大部分离线渲染仍然使用的是RGB渲染。

从场景到屏幕

对于一个给定的虚拟场景，基于物理的渲染有着这样一个目标，即计算场景中可能存在的真实radiance。然而计算完成之后，渲染的工作还远未完成，我们仍然需要确定最终的结果，即显示器帧缓冲中的像素值。在本小节中，我们将讨论与此有关的一些因素。

HDR显示器通常会使用Rec. 2020和Rec. 2100标准。其中Rec. 2020定义了一个具有更宽色域的颜色空间，如图8.12所示，并且它与Rec. 709和sRGB色彩空间具有相同的白点（D65）。

虽然峰值亮度（peak luminance）和色域规格（gamut specification）对于编码而言十分重要，但是对于实际的显示设备而言，它们多少有些不切实际（aspirational）。因此，HDR显示器会在内部执行从标准规格到实际显示功能的色调映射（tone mapping）与色域映射（gamut mapping）。这个映射过程也可能会受到应用程序所传递过来的原始数据的影响，这些原始数据可能会指明实际的动态范围和色域范围

色调映射 toneMapping

在伽马矫正时，即将线性的radiance值，转换为用于显示设备的非线性编码值的过程。显示编码所使用的函数是显示器光电转换函数（electrical optical transfer function，EOTF）的逆函数，它确保了输入的线性值与显示器发出的线性radiance相匹配。在我们前面的讨论中，忽略了发生在渲染和显示编码之间的一个重要步骤，下面我们将对这个步骤进行介绍和讨论。

这个步骤叫做色调映射（tone mapping）或者色调再现（tone reproduction），它是指将场景的radiance转换为显示器radiance的过程。在这个步骤中所应用的转换函数称为端到端转换函数（end-to-end transfer function）或者场景到屏幕转换函数（scene-to-screen transform）。图像状态（image state）的概念是理解色调映射的关键[1602]，有两种基本的图像状态：场景参考（scene-referred）图像是根据场景中的radiance进行定义的，显示参考（display-referred）图像是根据显示器的radiance进行定义的。图像状态与编码无关，在这两种状态下的图像，都可以进行线性编码或者非线性编码。图8.13展示了图像状态、色调映射和显示编码是如何在成像管线中进行组合的，这个成像管线用于将最初渲染生成的颜色值，转换为最终用于显示的颜色值。

同一个场景使用了四种不同的色调变换。这些结果的差异主要体现在图中的绿色圆圈区域，因为那里的场景像素值特别高。左上角：直接裁剪（同时使用了sRGB OETF）；右上角：Reinhard方法[1478]；左下角：Duiker方法[392]；右下角：寒霜方法（保持色相的版本）[497]。Reinhard，Duiker和寒霜的变换，都可以保留因裁剪而丢失的高光信息。然而，Reinhard曲线倾向于降低图像中较暗部分的饱和度[628, 629]，而Duiker变换则增加了较暗区域的饱和度，后者有时会被认为是更好的特性[630]。通过一些特殊设计，寒霜变换保持了饱和度和色相，避免了强烈的色相偏移，请仔细观察其他三张图片左下角的圆圈区域。

曝光

动态曝光：用上述方法（对数平均 / 直方图 / 光照强度）实时计算每帧曝光，适配场景光照变化（比如从室内到室外，曝光自动降低，避免过曝）；
静态曝光：多数游戏的选择 —— 美术人员根据场景固定光照（比如室内、室外、夜景）手动设置曝光值，避免动态曝光的意外波动（比如突然出现极亮像素导致画面骤暗）；
核心原则：无论哪种策略，曝光都是 “线性缩放”—— 只改变亮度的整体范围，不破坏线性空间的计算规则（后续色调映射才做非线性变换）。

曝光的本质是「场景亮度到显示亮度的 “预处理缩放”」，核心是找到一个稳定、合理的缩放因子。核心目标让场景的关键细节（中间调、灰卡对应的亮度）落在显示器的敏感区间，同时尽可能保留高光和阴影细节，符合人眼感知。

颜色分级

这个内容动手实践一下应该就好懂了

在章节8.2.2中，我们提到了择优图像再现（preferred image reproduction）的概念，即生成在某种意义上看起来比原始场景更好的图像。它通常会涉及到对图像颜色的创造性处理，这个过程被称为颜色分级（color grading），或者调色、校色等，它们的含义实际上都是一样的。

数字颜色分级已经在电影工业中使用了一段时间，早期的例子包括电影《逃狱三王（O Brother, Where Art Thou？）》（2000）和《天使爱美丽（Amelie）》（2001）。颜色分级通常是通过交互式的操作，来对场景图像的颜色进行调整，直到实现想要的创意“外观”，然后再将相同的操作序列，重新应用到一个镜头或者一个序列中的所有图像上。颜色分级技术从电影传播到游戏领域中，现在在游戏中被广泛应用[392, 424, 756, 856, 1222]。

Selan [1601]展示了如何将来自一个颜色分级，或者图像编辑应用的任意颜色转换，“烘焙”到一个三维颜色查找表（LUT）中。通过将RGB颜色值作为xyz坐标输入，来从这个表中快速查找对应的新颜色；这种方式可以用于从颜色到颜色的任何映射，不过这个过程会受到LUT分辨率的限制。Selan的烘焙过程从一个相同LUT开始，这个LUT会将每个输入的颜色，映射到相同的输出颜色，然后再将其“切片”从而创建一个二维图像。然后将这个切片的LUT图像加载到一个颜色分级应用程序中，并对其应用定义目标创意外观所需要的操作。需要注意的是，只能对LUT应用颜色操作，需要避免模糊等空间操作。然后将编辑好的LUT保存下来，“打包”到一个三维GPU纹理中，并在渲染的过程中进行使用，从而动态地对渲染像素应用相同的颜色转换。Iwanicki [806]提出了一种聪明的方法，当在LUT中存储颜色变换的时候，可以使用最小化的最小二乘法，来减少采样误差。

在后来的出版物中，Selan [806]对两种执行颜色分级的方法进行了区分。第一种方法是对显示参考的图像数据进行颜色分级操作。第二种方法通过显示变换，对结果进行预览，然后再对场景参考的数据进行颜色分级操作。虽然显示参考的颜色分级方法更加容易操作和实现，但是对场景参考的数据进行颜色分级操作，可以生成更高保真度（fidelity）的结果。

当实时应用程序首次使用颜色分级技术时，显示参考方法占据了主导地位[756, 856]。然而，场景参考方法由于其更高的视觉质量，而获得了更多的关注[198, 497, 672]，如图8.16所示。对场景参考的图像数据应用颜色分级操作，还可以将色调映射曲线烘焙到颜色分级LUT中[672]，从而节省一些计算量，就像在游戏《神秘海域4》中所做的那样[198]。

游戏《神秘海域4》中的场景画面。最上面的截图没有使用颜色分级，下面两个截图各自应用了一个颜色分级操作。为了便于说明，我们选择了一个极端的颜色分级操作（将原始图像乘以一个高饱和度的青色）。在左下角的截图中，将颜色分级应用在了显示参考图像上（即色调映射之后）；而在右下角的截图中，将颜色分级应用在了场景参考图像上（即色调映射之前）

在进行LUT查找之前，还必须将场景参考的数据重新映射到$[0,1]$范围中[1601]。在寒霜引擎[497]中，使用了感知量化曲线OETF来实现这个目的，尽管可以使用一些更加简单的曲线。Duiker [392]使用了一个对数曲线，而Hable [635]则建议使用一次或者两次的平方根运算来实现。

GAMES105 计算机角色动画基础（前向运动学、逆向运动学、关键帧动画与插值）

Sun, 19 Oct 2025 14:25:28 +0800

前向运动学

单链

每个关节的局部坐标系与全局坐标系重合

父关节的旋转会让子关节也跟着旋转子关节的朝向就是夫关节朝向乘以自身的旋转只旋转R0时,Q1在Q0的局部坐标系下的坐标并不会变一直是l0,如果想求Q1的世界坐标,就是父关节的世界坐标加朝向*l0 这一套东西就是用传播来更新,比如Q4的局部坐标系的某一个点,可以算出他在Q3的局部坐标系的位置,Q3的位置又能计算出他在Q2的位置,最终得到这个点在Q0的位置,最终再换算到世界坐标系,就得到了Q4局部坐标系下某一点在全局坐标系下的位置这块比较好理解 BVH文件,用欧拉角表示旋转

HIERARCHY
ROOT RootJoint  // 主结点
{
    OFFSET   0.000000   0.000000   0.000000
    CHANNELS 6 Xposition Yposition Zposition Xrotation Yrotation Zrotation // 主节点的位置和旋转信息
    JOINT lHip // 主关节内的子关节
    {
        OFFSET   0.100000  -0.051395   0.000000 // 子关节相对于主关节局部坐标系的偏移量
        CHANNELS 3 Xrotation Yrotation Zrotation // 欧拉角表示的旋转
        JOINT lKnee // 子关节的子关节 一层一层嵌套
        {
            OFFSET   0.000000  -0.410000   0.000000
            CHANNELS 3 Xrotation Yrotation Zrotation
            JOINT lAnkle
            {
                OFFSET   0.000000  -0.390000   0.000000
                CHANNELS 3 Xrotation Yrotation Zrotation
                JOINT lToeJoint
                {
                    OFFSET   0.000000  -0.050000   0.130000
                    CHANNELS 3 Xrotation Yrotation Zrotation
                    End Site
                    {
                        OFFSET   0.010000   0.002000   0.060000
                    }
                }
            }
        }
    }

一行MOTION信息按照上边给的关节顺序和通道数给出一帧的旋转信息

  1.471305   0.917570   2.607916   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000  45.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000 -45.000000   0.000000   0.000000   0.000000   0.000000   0.000000   0.000000

前向运动学作业

1. 解析BVH文件

BVH存储的是每个关节相对于父关节的旋转(欧拉角)和位置偏移

def part1_calculate_T_pose(bvh_file_path):
    """
    输入： bvh 文件路径
    输出:
        joint_name: List[str]，字符串列表，包含着所有关节的名字
        joint_parent: List[int]，整数列表，包含着所有关节的父关节的索引,根节点的父关节索引为-1
        joint_offset: np.ndarray，形状为(M, 3)的numpy数组，包含着所有关节的偏移量
    """
    joint_name = []
    joint_parent = []
    joint_offset = []
    parent_stack = []  # 用于跟踪当前关节的父级层次
    current_parent = -1  # 根节点的父节点索引为-1

    # 读取BVH文件内容
    with open(bvh_file_path, 'r') as f:
        lines = [line.strip() for line in f if line.strip()]

    # 定位层次结构部分（HIERARCHY到MOTION之间的内容）
    hierarchy_start = None
    hierarchy_end = None
    for i, line in enumerate(lines):
        if line.upper() == 'HIERARCHY':
            hierarchy_start = i + 1
        elif line.upper() == 'MOTION' and hierarchy_start is not None:
            hierarchy_end = i
            break

    if hierarchy_start is None or hierarchy_end is None:
        raise ValueError("BVH文件格式错误，未找到层次结构或运动数据部分")

    # 解析层次结构
    for line in lines[hierarchy_start:hierarchy_end]:
        tokens = line.split()
        if not tokens:
            continue

        if tokens[0].upper() == 'ROOT':
            # 处理根节点
            joint_name.append(tokens[1])
            joint_parent.append(-1)
            parent_stack.append(len(joint_name) - 1)
            current_parent = len(joint_name) - 1

        elif tokens[0].upper() == 'JOINT':
            # 处理子关节
            joint_name.append(tokens[1])
            joint_parent.append(current_parent)
            parent_stack.append(len(joint_name) - 1)
            current_parent = len(joint_name) - 1

        elif tokens[0].upper() == 'OFFSET':
            # 处理偏移量（T姿态下的位置偏移）
            offset = np.array([float(tokens[1]), float(tokens[2]), float(tokens[3])])
            joint_offset.append(offset)

        elif tokens[0].upper() == 'END' and tokens[1].upper() == 'SITE':
            # 处理末端节点
            end_joint_name = f"{joint_name[current_parent]}_end"
            joint_name.append(end_joint_name)
            joint_parent.append(current_parent)
            parent_stack.append(len(joint_name) - 1)
            current_parent = len(joint_name) - 1

        elif tokens[0] == '}':
            # 层级结束，返回上一级父节点
            if parent_stack:
                parent_stack.pop()
                current_parent = parent_stack[-1] if parent_stack else -1

    # 转换为numpy数组
    joint_offset = np.array(joint_offset)

    return joint_name, joint_parent, joint_offset

2. 前向运动学计算

读入BVH文件中每一帧的动作数据, 计算每个关节在世界坐标系下的旋转和位置。

def part2_forward_kinematics(joint_name, joint_parent, joint_offset, motion_data, frame_id):
    """请填写以下内容
    输入: part1 获得的关节名字，父节点列表，偏移量列表
        motion_data: np.ndarray，形状为(N,X)的numpy数组，其中N为帧数，X为Channel数
        frame_id: int，需要返回的帧的索引
    输出:
        joint_positions: np.ndarray，形状为(M, 3)的numpy数组，包含着所有关节的全局位置
        joint_orientations: np.ndarray，形状为(M, 4)的numpy数组，包含着所有关节的全局旋转(四元数)
    Tips:
        1. joint_orientations的四元数顺序为(x, y, z, w)
        2. from_euler时注意使用大写的XYZ
    """
    bone_num = len(joint_name)

    # 记录所有关节的全局位置
    joint_positions = np.empty((bone_num, 3))
    # 记录所有关节的全局旋转(四元数)
    joint_orientations = np.empty((bone_num, 4))
    # 一帧的所有旋转数据和主关节的位置信息
    motion_data_oneFrame = motion_data[frame_id]

    # 主关节的位置信息
    joint_positions[0] = motion_data_oneFrame[:3]
    # 主关节的旋转(从欧拉角转为四元数)
    joint_orientations[0] = R.from_euler('XYZ', motion_data_oneFrame[3:6], degrees=True).as_quat()

    frame_count = 1
    for i in range(1, bone_num):
        # 当前关节的父关节id
        p = joint_parent[i]
        cur_rotate = None
        if joint_name[i].endswith('_end'):
            # _end表示一条关节链的终点位置
            cur_rotate = R.from_euler('XYZ', [0., 0., 0.], degrees=True)
        else:
            cur_rotate = R.from_euler('XYZ', motion_data_oneFrame[3 + frame_count * 3: 6 + frame_count * 3],
                                      degrees=True)
            frame_count += 1

        # 父关节的旋转信息
        p_orient = R.from_quat(joint_orientations[p])
        # 当前位置的旋转 = 父关节的旋转 * 当前关节的旋转
        joint_orientations[i] = (p_orient * cur_rotate).as_quat()
        # 当前位置 = 父关节的全局位置 + 父关节的旋转 * 当前关节在父关节旋转方向上的偏移
        joint_positions[i] = joint_positions[p] + np.dot(R.from_quat(joint_orientations[p]).as_matrix(),
                                                         joint_offset[i])

    return joint_positions, joint_orientations

3. 运动重定向

读入一个A-Pose的文件, 将A-pose的bvh重定向到T-pose上意思是骨骼信息来自T-pose,但是一帧的旋转信息来自A-pose的文件. retarget_motion_data = part3_retarget_func(T_pose_bvh_path, A_pose_bvh_path)用来把A-pose给出的旋转信息重定向到T-pose的骨骼上. 处理办法就是遍历到肩膀肘手腕时要额外处理旋转信息

def part3_retarget_func(T_pose_bvh_path, A_pose_bvh_path):
    """
    将 A-pose的bvh重定向到T-pose上
    输入: 两个bvh文件的路径
    输出: 
        motion_data: np.ndarray，形状为(N,X)的numpy数组，其中N为帧数，X为Channel数。retarget后的运动数据
    Tips:
        两个bvh的joint name顺序可能不一致哦(
        as_euler时也需要大写的XYZ
    """

    def index_bone_to_channel(index, flag):
        if flag == 't':
            end_bone_index = end_bone_index_t
        else:
            end_bone_index = end_bone_index_a
        for i in range(len(end_bone_index)):
            if end_bone_index[i] > index:
                return index - i
        return index - len(end_bone_index)

    def get_t2a_offset(bone_name):
        l_bone = ['lShoulder', 'lElbow', 'lWrist']
        r_bone = ['rShoulder', 'rElbow', 'rWrist']
        if bone_name in l_bone:
            return R.from_euler('XYZ', [0., 0., 45.], degrees=True)
        if bone_name in r_bone:
            return R.from_euler('XYZ', [0., 0., -45.], degrees=True)
        return R.from_euler('XYZ', [0., 0., 0.], degrees=True)

    motion_data = load_motion_data(A_pose_bvh_path)

    t_name, t_parent, t_offset = part1_calculate_T_pose(T_pose_bvh_path)
    a_name, a_parent, a_offset = part1_calculate_T_pose(A_pose_bvh_path)

    end_bone_index_t = []
    for i in range(len(t_name)):
        if t_name[i].endswith('_end'):
            end_bone_index_t.append(i)

    end_bone_index_a = []
    for i in range(len(a_name)):
        if a_name[i].endswith('_end'):
            end_bone_index_a.append(i)

    for m_i in range(len(motion_data)):
        frame = motion_data[m_i]
        cur_frame = np.empty(frame.shape[0])
        cur_frame[:3] = frame[:3]
        for t_i in range(len(t_name)):
            cur_bone = t_name[t_i]
            a_i = a_name.index(t_name[t_i])
            if cur_bone.endswith('_end'):
                continue
            channel_t_i = index_bone_to_channel(t_i, 't')
            channel_a_i = index_bone_to_channel(a_i, 'a')

            # retarget
            local_rotation = frame[3 + channel_a_i * 3: 6 + channel_a_i * 3]
            if cur_bone in ['lShoulder', 'lElbow', 'lWrist', 'rShoulder', 'rElbow', 'rWrist']:
                p_bone_name = t_name[t_parent[t_i]]
                Q_pi = get_t2a_offset(p_bone_name)
                Q_i = get_t2a_offset(cur_bone)
                local_rotation = (Q_pi * R.from_euler('XYZ', local_rotation, degrees=True) * Q_i.inv()).as_euler('XYZ',
                                                                                                                 degrees=True)
            cur_frame[3 + channel_t_i * 3: 6 + channel_t_i * 3] = local_rotation

        motion_data[m_i] = cur_frame

    return motion_data

逆向运动学

已知运动结果求每一个关节的旋转 IK问题可以有解、无解、多解

双关节问题

下图两个虚线圆的交点就是关节1应该去的位置，到达后旋转关节1，肯定能让关节2到达指定位置

另外一种思路：

移动关节1，让0-2的距离= 0到x的距离再旋转关节0即可在三维下绕着0x为轴旋转即可

多关节最优化问题

只考虑末端点到达指定位置的问题，建模成 通过各个关节的旋转，得到末端点位置的这个函数 求解问题就是：就是找到各关节的旋转使得目标点位置-公式求解的末端点位置=0 这个方程有没有根等价的可以转化为一个优化问题，优化问题取极值求解问题到这里就变成了函数求极值的问题

优化问题下降方法

1. 循环坐标下降法 CCD

认为参数的坐标轴方向为下降方向，不断交换坐标轴。其实就是每次只更新一个参数（一个旋转角度） CCD放在IK来解释就是每次只旋转一个关节下图就是只旋转3，让3-4朝向正确（也就是寻找了x离目标位置最近的位置）

下一步旋转关节2 依此类推之后再回到4关节进行循环

2. 梯度下降（雅可比转置法）

CCD没有考虑到目标函数的性质，直接找负梯度方向就可以更快的下降也就是说每个参数的更新方向都是下降最快的方向参数的更新公式红色的这一项是控制梯度更新是往正方向还是负方向（因为下降过头还得回来）前边梯度的倒数构成的矩阵也可以叫做雅可比矩阵（f对每个参数求导的结果组成的矩阵）下降梯度法也可以就雅可比转置法。对于IK问题，他输出是一个点，是三维的输出（x,y,z）所以雅可比矩阵应该是三维的

雅可比矩阵计算方法

调库！！！
有限差分（用前向运动学运动依次来获得数据填充矩阵，看不懂。。。。）
几何方法（针对单自由度关节）这里应该是当一个关节旋转一个很小的角度时，把罗德里格斯旋转公式求出目标点，取极限求出来的就是雅可比矩阵的一项（针对ball 3自由度的关节）很难理解的，选择不理解，知道是可以的就行

3. 高斯-牛顿法

最优化学过。。忘了，这里选择不回忆

4. 雅可比逆方法

。。。听个响听个。。

角色的IK

更复杂的优化问题。每个目标点都对应上一节一个优化目标，最后相加。还需要加一个正则项，约束各个关节的旋转

逆向运动学作业

def load_motion_data(bvh_file_path):
    """part2 辅助函数，读取bvh文件"""
    with open(bvh_file_path, 'r') as f:
        lines = f.readlines()
        for i in range(len(lines)):
            if lines[i].startswith('Frame Time'):
                break
        motion_data = []
        for line in lines[i + 1:]:
            data = [float(x) for x in line.split()]
            if len(data) == 0:
                break
            motion_data.append(np.array(data).reshape(1, -1))
        motion_data = np.concatenate(motion_data, axis=0)
    return motion_data


def rotation_matrix(a, b):
    a = a / np.linalg.norm(a)
    b = b / np.linalg.norm(b)
    n = np.cross(a, b)
    # 旋转矩阵是正交矩阵，矩阵的每一行每一列的模，都为1；并且任意两个列向量或者任意两个行向量都是正交的。
    # n=n/np.linalg.norm(n)
    # 计算夹角
    cos_theta = np.dot(a, b)
    sin_theta = np.linalg.norm(n)
    theta = np.arctan2(sin_theta, cos_theta)
    # 构造旋转矩阵
    c = np.cos(theta)
    s = np.sin(theta)
    v = 1 - c
    rotation_matrix = np.array([[n[0] * n[0] * v + c, n[0] * n[1] * v - n[2] * s, n[0] * n[2] * v + n[1] * s],
                                [n[0] * n[1] * v + n[2] * s, n[1] * n[1] * v + c, n[1] * n[2] * v - n[0] * s],
                                [n[0] * n[2] * v - n[1] * s, n[1] * n[2] * v + n[0] * s, n[2] * n[2] * v + c]])
    return rotation_matrix


def inv_safe(data):
    # return R.from_quat(data).inv()
    if np.allclose(data, [0, 0, 0, 0]):
        return np.eye(3)
    else:
        return np.linalg.inv(R.from_quat(data).as_matrix())


def from_quat_safe(data):
    # return R.from_quat(data)
    if np.allclose(data, [0, 0, 0, 0]):
        return np.eye(3)
    else:
        return R.from_quat(data).as_matrix()


def part1_inverse_kinematics(meta_data, joint_positions, joint_orientations, target_pose):
    """
    完成函数，计算逆运动学
    输入:
        meta_data: 为了方便，将一些固定信息进行了打包，见上面的meta_data类
        joint_positions: 当前的关节位置，是一个numpy数组，shape为(M, 3)，M为关节数
        joint_orientations: 当前的关节朝向，是一个numpy数组，shape为(M, 4)，M为关节数
        target_pose: 目标位置，是一个numpy数组，shape为(3,)
    输出:
        经过IK后的姿态
        joint_positions: 计算得到的关节位置，是一个numpy数组，shape为(M, 3)，M为关节数
        joint_orientations: 计算得到的关节朝向，是一个numpy数组，shape为(M, 4)，M为关节数
    """
    path, path_name, path1, path2 = meta_data.get_path_from_root_to_end()
    parent_idx = meta_data.joint_parent
    # local_rotation是用于最后计算不在链上的节点
    no_caled_orientation = copy.deepcopy(joint_orientations)
    local_rotation = [
        R.from_matrix(inv_safe(joint_orientations[parent_idx[i]]) * from_quat_safe(joint_orientations[i])).as_quat() for
        i
        in range(len(joint_orientations))]
    local_rotation[0] = R.from_matrix(from_quat_safe(joint_orientations[0])).as_quat()
    local_position = [joint_positions[i] - joint_positions[parent_idx[i]] for i
                      in range(len(joint_orientations))]
    local_position[0] = joint_positions[0]
path_end_id = path1[0]  ## lWrist_end 就是手掌 只是加了end不叫hand而已
for k in range(0, 300):
    # k：循环次数
    # 正向的，path1是从手到root之前
    for idx in range(0, len(path1)):
        # idx：路径上的第几个节点了，第0个是手，最后一个是root
        path_joint_id = path1[idx]

        vec_to_end = joint_positions[path_end_id] - joint_positions[path_joint_id]
        vec_to_target = target_pose - joint_positions[path_joint_id]
        # 获取end->target的旋转矩阵
        # debug
        # rot_matrix=rotation_matrix(np.array([1,0,0]),np.array([1,1,0]))
        rot_matrix = rotation_matrix(vec_to_end, vec_to_target)

        # 计算前的朝向。这个朝向实际上是累乘到父节点的
        initial_orientation = from_quat_safe(joint_orientations[path_joint_id])
        # 旋转矩阵，格式换算
        rot_matrix_R = R.from_matrix(rot_matrix).as_matrix()
        # 计算后的朝向
        calculated_orientation = rot_matrix_R.dot(initial_orientation)
        # 写回结果列表
        joint_orientations[path_joint_id] = R.from_matrix(calculated_orientation).as_quat()

        # 子节点的朝向也会有所变化
        # idx-1 就是当前节点的下一个更接近尾端的节点，一直向前迭代到1
        for i in range(idx - 1, 0, -1):
            path_joint_id = path1[i]
            # 遍历路径后的节点,都乘上旋转
            joint_orientations[path_joint_id] = R.from_matrix(
                rot_matrix_R.dot(from_quat_safe(joint_orientations[path_joint_id]))).as_quat()

        path_joint_id = path1[idx]
        # 修改子节点的位置
        for i in range(idx - 1, -1, -1):
            # path_joint_id=path1[i]
            # 节点id
            next_joint_id = path1[i]
            # 指向下个节点的向量
            vec_to_next = joint_positions[next_joint_id] - joint_positions[path_joint_id]
            # 左乘，改变向量
            calculated_vec_to_next_dir = rot_matrix.dot(vec_to_next)
            # 防止长度不对
            calculated_vec_to_next = calculated_vec_to_next_dir / np.linalg.norm(
                calculated_vec_to_next_dir) * np.linalg.norm(vec_to_next)
            # 还原回去
            joint_positions[next_joint_id] = calculated_vec_to_next + joint_positions[path_joint_id]

    # path2是从脚到root，所以要倒着
    # debug
    # for idx in range(len(path2)-1,len(path2)-3,-1): # len(path2)-1 --> 0
    for idx in range(len(path2) - 1, 0, -1):  # len(path2)-1 --> 0
        path_joint_id = path2[idx]
        parient_joint_id = max(parent_idx[path_joint_id], 0)

        vec_to_end = joint_positions[path_end_id] - joint_positions[path_joint_id]
        vec_to_target = target_pose - joint_positions[path_joint_id]
        # 获取end->target的旋转矩阵
        # debug
        # rot_matrix=rotation_matrix(np.array([0.72,0.35,0]),np.array([0.5,0.35,0]))
        # rot_matrix=np.linalg.inv(rot_matrix)
        rot_matrix = rotation_matrix(vec_to_end, vec_to_target)

        # 计算前的朝向。注意path2是反方向的，要改父节点才行
        initial_orientation = from_quat_safe(joint_orientations[path_joint_id])
        # 旋转矩阵，格式换算
        rot_matrix_R = R.from_matrix(rot_matrix).as_matrix()
        # 计算后的朝向
        calculated_orientation = rot_matrix_R.dot(initial_orientation)
        # 写回结果列表
        joint_orientations[path_joint_id] = R.from_matrix(calculated_orientation).as_quat()

        # 其他节点的朝向也会有所变化
        for i in range(idx + 1, len(path2)):
            path_joint_id = path2[i]
            joint_orientations[path_joint_id] = R.from_matrix(
                rot_matrix_R.dot(from_quat_safe(joint_orientations[path_joint_id]))).as_quat()

        # idx-1 就是当前节点的下一个更接近尾端的节点，一直向前迭代到1
        for i in range(len(path1) - 1, 0, -1):
            path_joint_id = path1[i]
            # 遍历路径后的节点,都乘上旋转
            joint_orientations[path_joint_id] = R.from_matrix(
                rot_matrix_R.dot(from_quat_safe(joint_orientations[path_joint_id]))).as_quat()

        path_joint_id = path2[max(idx - 1, 0)]
        # 修改父节点，或者说更靠近手的那些节点的位置
        # path2上的
        for i in range(idx, len(path2)):
            # path_joint_id=path1[i]
            # 节点id
            prev_joint_id = path2[i]
            # 指向上一个节点的向量
            vec_to_next = joint_positions[prev_joint_id] - joint_positions[path_joint_id]
            # 左乘，改变向量
            calculated_vec_to_next_dir = rot_matrix.dot(vec_to_next)
            # 防止长度不对
            calculated_vec_to_next = calculated_vec_to_next_dir / np.linalg.norm(
                calculated_vec_to_next_dir) * np.linalg.norm(vec_to_next)
            # 还原回去
            joint_positions[prev_joint_id] = joint_positions[path_joint_id] + calculated_vec_to_next
        # path1上的
        for i in range(len(path1) - 1, -1, -1):
            # path_joint_id=path1[i]
            # 节点id
            prev_joint_id = path1[i]
            # 指向上一个节点的向量
            vec_to_next = joint_positions[prev_joint_id] - joint_positions[path_joint_id]
            # 左乘，改变向量
            calculated_vec_to_next_dir = rot_matrix.dot(vec_to_next)
            # 防止长度不对
            calculated_vec_to_next = calculated_vec_to_next_dir / np.linalg.norm(
                calculated_vec_to_next_dir) * np.linalg.norm(vec_to_next)
            # 还原回去
            joint_positions[prev_joint_id] = calculated_vec_to_next + joint_positions[path_joint_id]

    # debug
    # rot_matrix=rotation_matrix(np.array([1,0,0]),np.array([1,0,1]))
    # joint_orientations[0]=R.from_matrix(rot_matrix).as_quat()
    # joint_orientations[1]=R.from_matrix(rot_matrix).as_quat()
    joint_orientations[path_end_id] = joint_orientations[path1[1]]
    cur_dis = np.linalg.norm(joint_positions[path_end_id] - target_pose)
    if cur_dis < 0.01:
        break
print("距离", cur_dis, "迭代了", k, "次")
# 更新不在链上的节点
for k in range(len(joint_orientations)):
    if k in path:
        pass
    elif k == 0:
        # 要单独处理，不然跟节点的-1就会变成从最后一个节点开始算
        pass
    else:
        # 先获取局部旋转
        # 这里如果直接存的就是矩阵就会有问题？
        local_rot_matrix = R.from_quat(local_rotation[k]).as_matrix()
        # 再获取我们已经计算了的父节点的旋转
        parent_rot_matrix = from_quat_safe(joint_orientations[parent_idx[k]])
        # 乘起来
        # re=local_rot_matrix.dot(parent_rot_matrix)
        re = parent_rot_matrix.dot(local_rot_matrix)
        joint_orientations[k] = R.from_matrix(re).as_quat()

        # 父节点没旋转的时候是：
        initial_o = from_quat_safe(no_caled_orientation[parent_idx[k]])
        # 父节点的旋转*delta_orientation=子节点旋转
        # 反求delta_orientation
        delta_orientation = np.dot(re, np.linalg.inv(initial_o))
        # 父节点的位置加原本基础上的旋转
        joint_positions[k] = joint_positions[parent_idx[k]] + delta_orientation.dot(local_position[k])

return joint_positions, joint_orientations

关键帧插值

给出一系列离散的值后，寻找一个f(x),首先满足已有的点都在f(x)上，另外要能计算其他的未给出的x的f(x)

梯度函数

也可以是离当前点最近的点的值作为f(x)

线性插值函数

直接用直线连接已知点

线性插值的平滑性

多项式插值 Polynomial Interpolation

计算参数就是把已知点带进去然后用矩阵求解。这里就能看出需要多少个采样点把矩阵求逆就可以求出参数a

Runge’s phenomenon：当使用等距节点对某些光滑函数进行高次多项式插值时，随着插值多项式次数的增加，多项式在区间端点附近会出现剧烈的振荡，导致插值误差不仅不减小，反而会急剧增大，最终完全偏离原函数。下图靠近两边的点中间插值出现了非常巨大的震荡（原因是接近1时，x的高次方会变得很大，如果还是使用等距插值就会出问题）

样条插值 Spline Interpolation

只在单独几个采样点上用低阶多项式插值常用的是Cubic Splines （三次样条插值）计算时只需要相邻的两个采样点计算依次多项式参数。如果总采样点是N+1，那一共有N段，每段都是一个三次多项式。每个多项式4个未知参数。所以一共有4N个未知参数。 2个采样点信息没办法求出4个未知数。样条采样引入了别的规则。

两段之间的采样点的在两个多项式的导数相同
二阶导也相同
对整条曲线的边缘点的一阶二阶导数一些额外限制

三次埃尔米特样条 Cubic Hermite Splines

Cubic Splines问题是只要移动一个点，都可能发生整条曲线的变化，求解也比较昂贵

Cubic Hermite Splines的做法是除了给出两个采样点外，还需要额外告诉两个点的导数

总结就是 4个方程4个未知数矩阵的逆都一步到位了，一次矩阵乘法就直接求解4个位置系数还可以把多项式直接写出矩阵形式

旋转的插值

旋转的四种表示方法：

旋转矩阵
欧拉角
轴角
四元数

下面两种旋转表达旋转速度插值不是恒定的用四元数的slerp来恒定速度（但线性插值并单位化四元数来插值不恒定）

GAMES105 计算机角色动画基础（数学基础）

Sun, 19 Oct 2025 14:24:24 +0800

线性代数

向量

点乘 Dot Product

叉乘 Cross Product

叉乘作用:寻找同时与AB都垂直的方向(AB平面的法线方向)

向量旋转(叉乘应用)

理论上在ab两个向量的角平分面上任何一个方向都可以作为旋转轴来进行旋转 这时候找ab叉乘方向作为轴进行旋转,旋转最少

如何旋转一个向量

例如绕着u为轴进行旋转可以把旋转拆分成两部分 v方向是 UcrossA的方向(其实就是圆盘的切线方向,也就是说叉乘可以求切线方向),t方向是UcrossV(与切线垂直) 从俯视图来看这个推导结果就是Rodrigues’s rotation formula(罗德里格斯旋转公式)

正交基

正交基的要求一个向量可以用正交基的线性组合来表示两个向量的点乘可以展开最后一项为0了叉乘也可以,去掉叉乘自己=0的项,化简后

矩阵

一些会用到的特殊矩阵(单位/对角/对称/反对称)

转置

运算

一些运算工具叉乘计算可以用矩阵来表示,这里的a用一个反对称阵来表示了把叉乘计算转为矩阵运算后,旋转一个向量的罗德里格斯旋转公式可以表示为Ra,这里的R就是空间中沿着某个单位轴u,旋转的旋转矩阵

正交矩阵

定义:矩阵的每一列都是互相正交的向量正交阵的逆=正交阵的转置正交阵转置*正交阵 = 单位阵

矩阵的行列式

三×四列矩阵的行列式怎么算😄 行列式的性质叉乘同样可以用行列式来计算

特征值

比较重要的结论是,3x3的正交阵肯定有一个特征值是1或-1

刚体变换 Rigid Transformation

缩放

相当于把向量乘以一个对角阵,每一行表示缩放比例

平移

平移可以直接加

旋转

旋转矩阵有一些性质.旋转矩阵是正交阵,行列式一定是+1,刚性变化,不会改变向量的模长旋转的组合,毕竟是左乘肯定得反着写沿着坐标轴旋转的旋转矩阵分别沿着3个轴旋转结果,与沿着某个计算出来的轴旋转可以得到一样的结果旋转矩阵肯定有一个特征值为1的特征值. RU=1*U(特征值的概念),这里的特征向量U在左乘R后保持不变,可以理解为U方向就是旋转轴旋转轴和旋转角度可以通过各种线性代数公式推导出来.R-1=RT所以左右同乘以RT.得到某个反对称阵 * 对称轴U = 0. 反对称阵可以写成叉乘叉乘=0表示两个向量共线所以说这个反对称阵对应的叉乘的u’单位化后就是对称轴.谁想出来的😄

坐标转换

全局和模型坐标系的转换

3D旋转

旋转的插值不能线性插值.下面这种插值是错的得出结论,用旋转矩阵来表达旋转时的缺点

欧拉角（Euler Angles）来表示旋转

欧拉角（Euler Angles）是 3D 旋转中最直观的表示方式（通过绕三个正交轴的依次旋转角度定义）但它存在一个致命缺陷 ——万向锁（Gimbal Lock，也称 Gimbal Lock）万向锁把中间变换设置为90°时,另外两个旋转变换都只会在同一个方向上进行旋转,这就是万向锁.
https://www.bilibili.com/video/BV1Nr4y1j7kn/?spm_id_from=333.337.search-card.all.click&vd_source=9df9034e2f1978b1018f5b387ec3eacd解释的很好,其实调整第一个轴,结果却在最后一个轴上旋转的原因是: 调整第一个轴本来就是在第一个轴上旋转,但是调整后又经过第二个轴的旋转,把他带到了第三个轴的旋转上看上去就像是在第三个轴旋转.

欧拉角的优缺点:

旋转轴和旋转角度来表示旋转

前边说过了优缺点:

四元数 Quaternions

复数与二维旋转

复数表示为

复数用向量来表示就是复平面:x轴为实轴,y轴为虚轴复数的乘法: 可以看出复数的可以写出一个矩阵和一个向量的结果.矩阵代表z1,向量代表z2. 也就是说z1乘以z2等价于给z2左乘一个变换矩阵

把表示z1的这个变换矩阵做一个变形从下图可以看出根号下平方和表示这个复数的模长并且带入刚才的矩阵左边部分是一个缩放矩阵,右边刚好是2D旋转公式. 所以说一个复数可以看作是先旋转角度再缩放的变换矩阵

所以我们要对一个向量旋转时,先把他看成一个复数给他左乘一个复数就能达到旋转效果或者可以理解为2D旋转公式中的这个旋转矩阵是可以写出复数形式的

三维旋转

轴角式:绕着某个旋转轴进行旋转欧拉角:就是上边讲的那个,用它的缺点就是有万向锁,四元数来解决它在轴角表示法中,确定一个旋转需要一个旋转轴(3个自由度)旋转角度(1个自由度),四个自由度来表示

旋转分解:把向量v分解为平行于旋转轴和垂直于旋转轴的两个分量分解过程有具体公式实现下面就只需要分别讨论两个分量的旋转对于垂直分量,就是在底面投影形成的一个圆形上的旋转,w可以通过叉乘获得在底盘上可以把旋转结果分解到垂直的两个方向上对于平行分量来说,它并没有旋转,所以最终组合两个分量并化简额,其实就是上边讲的Rodrigues旋转公式(⊙﹏⊙)

四元数定义

四元数的性质: 四元数可以写出一个向量可以用四元数来表示向量和标量用向量表示后,乘法就表示为四元数没有交换律,有结合律单位四元数的逆=共轭类似于单位复数可以组成复平面的一个圆,单位四元数也可以组成4D空间的球壳对于任何一个单位四元数都可以写出下面这个形式 它和轴角表示的u和斯塔有相同的信息量.这样的对应可得一个轴角表示可以转化为一个四元数表示

如果把一个需要被旋转的向量表示为纯四元数(标量=0),那么旋转q作用到它的计算方式为四元数可以旋转叠加

四元数的插值

在球壳上才是合法的单位四元数,所以线性插值的qt是不合法的所以每次插值都需要进行单位化,但是插值速度是不恒定的为了实现常数速度的插值,需要用slerp 其中a和b可以推导出来四元数的优点

GAMES202 高质量实时渲染（Assignment 3）

Sun, 19 Oct 2025 14:05:15 +0800

作业介绍

首先看一下整体渲染流程

绘制光源
绘制shadowMap
diffuse、depth、normal、shadow、worldPos五个GBuffer信息
最后利用上边的信息来真正进行渲染

        // Draw light
        light.meshRender.mesh.transform.translate = light.entity.lightPos;
        light.meshRender.draw(this.camera, null, updatedParamters);

        // Shadow pass
        gl.bindFramebuffer(gl.FRAMEBUFFER, light.entity.fbo);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        for (let i = 0; i < this.shadowMeshes.length; i++) {
            this.shadowMeshes[i].draw(this.camera, light.entity.fbo, updatedParamters);
            // this.shadowMeshes[i].draw(this.camera);
        }
        // return;

        // Buffer pass
        gl.bindFramebuffer(gl.FRAMEBUFFER, this.camera.fbo);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        for (let i = 0; i < this.bufferMeshes.length; i++) {
            this.bufferMeshes[i].draw(this.camera, this.camera.fbo, updatedParamters);
            // this.bufferMeshes[i].draw(this.camera);
        }
        // return

        // Camera pass
        for (let i = 0; i < this.meshes.length; i++) {
            this.meshes[i].draw(this.camera, null, updatedParamters);
        }

直接光照

EvalDiffuse(wi, wo, uv)

通过入射方向、出射方向、漫反射率纹理图uv坐标来计算BRDF的返回值，因为是计算diffuse的BRDF，所以它是一个常数分母π保证了反射光的总能量不超过入射光能量

vec3 EvalDiffuse(vec3 wi, vec3 wo, vec2 uv) {
  vec3 albedo = GetGBufferDiffuse(uv);
  vec3 normal = GetGBufferNormalWorld(uv);
  // 这里把cos项和BRDF项放在一起了
  float cosTheta = max(0,dot(normal,wi));
  return albedo * cosTheta * INV_PI;
}

这样就得到了渲染方程中的BRDF项

EvalDirectionalLight(vec2 uv)

这里需要计算一个着色点的直接光照项（需要通过shadowMap来考虑阴影）

vec3 EvalDirectionalLight(vec2 uv) {
    vec3 Le = GetGBufferuShadow(uv) * uLightRadiance;
  return Le;
}

其中GetGBufferuShadow方法返回的就是Visbility项，它在上一轮渲染中存储了每个像素的可见性信息

float GetGBufferuShadow(vec2 uv) {
  float visibility = texture2D(uGShadow, uv).x;
  return visibility;
}

最后修改main函数，它还做了伽马矫正

void main() {
  float s = InitRand(gl_FragCoord.xy);

  vec3 L = vec3(0.0);
  vec3 color = vec3(0.0);
  vec3 worldPos = vPosWorld.xyz;
  vec2 screenUV = GetScreenCoordinate(vPosWorld.xyz);
  vec3 wi = normalize(uLightDir);
  vec3 wo = normalize(uCameraPos - worldPos);

  // 直接光照
  L = EvalDiffuse(wi, wo, screenUV) * EvalDirectionalLight(screenUV);
  // gamma矫正
  color = pow(clamp(L, vec3(0.0), vec3(1.0)), vec3(1.0 / 2.2));
  gl_FragColor = vec4(vec3(color.rgb), 1.0);
}

我的电脑是mac，根据网上只有mac电脑会出下如下问题，根据视角移动会不断变换出错的位置我们先把可见性设置为1，避免阴影生成，看看是什么情况举个例子：假设地板深度值为0.5001，上方模型为0.5002。在16位深度缓冲区中，两者可能被四舍五入为相同值（如0.500），导致GPU随机选择显示其中一个67。此时地板可能因浮点舍入误差被误判为更小Z值，从而错误覆盖模型。

NDC坐标下的Z值并不是线性的，越靠近近平面的地方，精度越高，远的地方精度越低，参考下图所以说当我把摄像机离得特别近时，这种问题慢慢就得到了缓解，因为接近近平面精度比较高所以说这种问题的一种解决思路就是调整远近平面的距离，越小，精度高的范围越大，出现z-fighting可能性越低

1
2
3

	// Add camera
	// const camera = new THREE.PerspectiveCamera(75, gl.canvas.clientWidth / gl.canvas.clientHeight, 1e-3, 1000);
	const camera = new THREE.PerspectiveCamera(75, gl.canvas.clientWidth / gl.canvas.clientHeight, 5e-2, 1e2);

为了验证这一说法的正确性，我们拉远镜头，就看出来这种问题又出现了，说明远处z值精度小不过这种解决方案只适合玩具，调整NF参数属于是把整个项目的东西都改了，还有一种解决思路就是在有这种重叠放置的地方进行手动偏移

间接光照

bool RayMarch(vec3 ori, vec3 dir, out vec3 hitPos)

这一步需要实现linear RayMarch，通过一条光线，求出击中点的坐标基本思路就是从着色点沿着光照方向每次向前一小步，查看这一点对应的深度值，并于深度缓冲中的深度值做比较，如果这一点深度值比深度缓冲中深度值大了，说明他已经处于可见物体的内部

bool RayMarch(vec3 ori, vec3 dir, out vec3 hitPos) {
  const int totalStepTimes = 60;
  const float threshold = 0.0001;
  float step = 0.05;
  vec3 stepDir = normalize(dir) * step;
  vec3 curPos = ori;
  for(int i = 0; i < totalStepTimes; i++) {
    vec2 screenUV = GetScreenCoordinate(curPos);
    float rayDepth = GetDepth(curPos);
    float gBufferDepth = GetGBufferDepth(screenUV);

    // 已经在可见物体内部
    if(rayDepth > gBufferDepth + threshold){
      hitPos = curPos;
      return true;
    }
    curPos += stepDir;
  }
}

现在已经有方法对光线求交了，下面就来实现间接光照

void main() {
  float s = InitRand(gl_FragCoord.xy);

  vec3 worldPos = vPosWorld.xyz;
  vec2 screenUV = GetScreenCoordinate(vPosWorld.xyz);
  vec3 wi = normalize(uLightDir);
  vec3 wo = normalize(uCameraPos - worldPos);
  vec3 normal = GetGBufferNormalWorld(screenUV);
  // 着色点的直接光照
  vec3 L = vec3(0.0);
  L = EvalDiffuse(wi, wo, screenUV) * EvalDirectionalLight(screenUV);

  // 着色点的间接光照
  vec3 L_ind = vec3(0.0);
  for(int i = 0; i < SAMPLE_NUM; i++){
    float pdf;
    vec3 localDir = SampleHemisphereCos(s, pdf);
    vec3 b1, b2;
    // 通过空间法线得到两个切线，从而建立切线空间坐标系
    LocalBasis(normal, b1, b2);
    // 通过BTN矩阵将局部坐标系转为世界坐标系
    vec3 dir = normalize(mat3(b1, b2, normal) * localDir);

    vec3 hit_pos = vec3(0.0);
    // 向采样方向发出光线
    if(RayMarch(worldPos, dir, hit_pos)){
      vec2 hitScreenUV = GetScreenCoordinate(hit_pos);
      // 通过蒙特卡洛积分来近似渲染方程的积分值
      L_ind += EvalDiffuse(dir, wo, screenUV) / pdf * EvalDiffuse(wi, dir, hitScreenUV) * EvalDirectionalLight(hitScreenUV);
    }
  }

  L_ind /= float(SAMPLE_NUM);
  L = L + L_ind;

  vec3 color = pow(clamp(L, vec3(0.0), vec3(1.0)), vec3(1.0 / 2.2));
  gl_FragColor = vec4(vec3(color.rgb), 1.0);
}

方块场景

洞穴场景渲染只渲染间接光所以SSR我理解也是在做光线追踪，但只利用了屏幕空间的信息，也就是真正被渲染的位置的信息，被覆盖掉的着色点是不会考虑的，这当然要比直接做光线追踪快很多。课程后边有实时光线渲染，目前还不知道如何实现的。

目前从方块场景能看出一些问题按照目前的一次弹射渲染逻辑，理论上阴影的颜色就应该是黑色（因为即使有击中点，这一点计算出来的直接光照也必然是黑色），而现在有点漏光了说明它判断击中点时，判断了B4位置的颜色，而实际上，它直接穿过了模型，打到了模型的正面，说明步长太大了。参考其他博客的解决思路

https://zhuanlan.zhihu.com/p/668194020 代码的思路跟前面的差不多，每一次步进时，判断下一步位置的深度与gBuffer的深度的关系，如果下一步的位置在gBuffer的前面（nextDepth<gDepth），则可以步进。如果下一步的深度没有gBuffer的深，就判断一下深度相差多少，有没有给定的阈值大。如果比阈值大，那么就直接返回 false ，否则，这个时候就可以执行SSR了。先让当前位置步进一个step，返回给 hitPos ，然后返回真。

bool RayMarch(vec3 ori, vec3 dir, out vec3 hitPos) {
  const float EPS = 1e-2;
  const int totalStepTimes = 20;
  const float threshold = 0.1;
  bool result = false, firstIn = false;
  float step = 0.8;
  vec3 curPos = ori;
  vec3 nextPos;
  for(int i = 0; i < totalStepTimes; i++) {
    nextPos = curPos+dir*step;
    vec2 uvScreen = GetScreenCoordinate(curPos);
    if(any(bvec4(lessThan(uvScreen, vec2(0.0)), greaterThan(uvScreen, vec2(1.0))))) break;
    if(GetDepth(nextPos) < GetGBufferDepth(GetScreenCoordinate(nextPos))){
      curPos += dir * step;
      if(firstIn) step *= 0.5;
      continue;
    }
    firstIn = true;
    if(step < EPS){
      float s1 = GetGBufferDepth(GetScreenCoordinate(curPos)) - GetDepth(curPos) + EPS;
      float s2 = GetDepth(nextPos) - GetGBufferDepth(GetScreenCoordinate(nextPos)) + EPS;
      if(s1 < threshold && s2 < threshold){
        hitPos = curPos + 2.0 * dir * step * s1 / (s1 + s2);
        result = true;
      }
      break;
    }
    if(firstIn) step *= 0.5;
  }
  return result;
}

使用大佬的优化算法，帧数一下就起来了

下面再介绍一下光线求交的加速方法，就是为深度图设置MipMap，上一层存入下一层4个像素的最小深度，也就是离屏幕更近的距离，如果一条光线在上一层中比最小距离更近，那它肯定不会在下一层中相交于物体，这样就可以省去很多if

具体的代码需要涉及到OpenGL如何生成这样的纹理，或者可能根本不支持这种mipmap，毕竟默认的mipmap并不是存最小值，而是平均值，可能需要自己写入缓存然后保存FBO，然后把它当作一张纹理来使用。我就不写了，目前阶段以学习理论为主

GAMES202 高质量实时渲染（Assignment 2）

Sun, 19 Oct 2025 14:04:46 +0800

作业介绍

物体在不同光照下的表现不同，PRT(Precomputed Radiance Transfer) 是一个计算物体在不同光照下表现的方法。光线在一个环境中，会经历反射，折射，散射，甚至还会物体的内部进行散射。为了模拟具有真实感的渲染结果，传统的Path Tracing 方法需要考虑来自各个方向的光线、所有可能的传播形式并且收敛速度极慢。PRT 通过一种预计算方法，该方法在离线渲染的 Path Tracing 工具链中预计算 lighting 以及 light transport 并将它们用球谐函数拟合后储存，这样就将时间开销转移到了离线中。最后通过使用这些预计算好的数据，我们可以轻松达到实时渲染严苛的时间要求，同时渲染结果可以呈现出全局光照的效果。

PRT 方法存在的限制包括： • 不能计算随机动态场景的全局光照 • 场景中物体不可变动

本次作业的工作主要分为两个部分：cpp 端的离线预计算部分以及在 WebGL框架上使用预计算数据部分

PRT课上最终得出的结论是对渲染方程的计算，可以先把光照和其余部分分别计算球谐展开后系数相乘（针对BRDF是diffuse的情况），所以我们只需要针对光照算球谐展开的系数，然后针对其余部分算一个球谐展开的系数，传递给顶点着色器后相乘就是顶点的着色

环境光贴图预计算

要做的就是把L(wi)项用球谐函数表示，因为球谐函数都一样，不一样的只有系数，所以只需要预计算出系数，系数求法如下，针对球谐函数的任何一项求他的系数都是算一个积分根据作业提示，需要完成函数，输入为天空盒的6个面图片

    std::vector<Eigen::Array3f> PrecomputeCubemapSH(const std::vector<std::unique_ptr<float[]>> &images,
                                                    const int &width, const int &height,
                                                    const int &channel)
    {

下面这一步是把6张贴图每个像素的方向向量都存起来了

        std::vector<Eigen::Vector3f> cubemapDirs;
        cubemapDirs.reserve(6 * width * height);
        for (int i = 0; i < 6; i++)
        {
            Eigen::Vector3f faceDirX = cubemapFaceDirections[i][0];
            Eigen::Vector3f faceDirY = cubemapFaceDirections[i][1];
            Eigen::Vector3f faceDirZ = cubemapFaceDirections[i][2];
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    float u = 2 * ((x + 0.5) / width) - 1;
                    float v = 2 * ((y + 0.5) / height) - 1;
                    Eigen::Vector3f dir = (faceDirX * u + faceDirY * v + faceDirZ).normalized();
                    cubemapDirs.push_back(dir);
                }
            }
        }

接着对系数数组初始化

// 表示球谐系数的个数
        constexpr int SHNum = (SHOrder + 1) * (SHOrder + 1);
        std::vector<Eigen::Array3f> SHCoeffiecents(SHNum);
        for (int i = 0; i < SHNum; i++)
            SHCoeffiecents[i] = Eigen::Array3f(0);

最后遍历每个方向向量进行计算系数

        for (int i = 0; i < 6; i++)
        {
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    // TODO: here you need to compute light sh of each face of cubemap of each pixel
                    // TODO: 此处你需要计算每个像素下cubemap某个面的球谐系数
            ![请添加图片描述](f30ab4af6a6c4b1d9ba4c82953bd31d1.png)
        Eigen::Vector3f dir = cubemapDirs[i * width * height + y * width + x];
                    int index = (y * width + x) * channel;
                    Eigen::Array3f Le(images[i][index + 0], images[i][index + 1],
                                      images[i][index + 2]);
                }
            }
        }

计算方法就是遍历每一个像素，通过黎曼积分的方法来说，每个像素点都对每个球谐函数的系数有贡献

        for (int i = 0; i < 6; i++)
        {
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    // TODO: here you need to compute light sh of each face of cubemap of each pixel
                    // TODO: 此处你需要计算每个像素下cubemap某个面的球谐系数
                    Eigen::Vector3f dir = cubemapDirs[i * width * height + y * width + x];
                    int index = (y * width + x) * channel;
                    // 当前像素的RGB值
                    Eigen::Array3f Le(images[i][index + 0], images[i][index + 1],
                                      images[i][index + 2]);
                    // 计算当前像素的面积
                    float delta_wi = CalcArea(x, y, width, height);
                    Eigen::Vector3d _dir(Eigen::Vector3d(dir[0], dir[1], dir[2]).normalized());//这里dir要变成Eigen::Vector3d类型
                    // 计算当前像素点对每个基函数系数的黎曼积分求法的贡献
                    for(int l = 0;l < SHNum; l++){
                        for(int m = -l; m <= l; m++){
                            SHCoeffiecents[sh::GetIndex(l,m)] += Le * sh::EvalSH(l,m,_dir)*delta_wi;
                        }
                    }
                }
            }
        }

对于作业提到的伽马矫正，可以参考我之前的博客伽马矫正

传输项的预计算

对于漫反射传输项来说，分为 unshadowed, shadowed, interreflection 三种情况，我们将分别计算这三种情况的漫反射传输球谐系数。

Diffuse unshadowed

这种情况下渲染方程的BRDF项为常数，此时渲染方程为 Li项已经处理掉了，就剩下max()项了作业中只需要写出transport部分在给定一个方向时的值

                if (m_Type == Type::Unshadowed)
                {
                    // TODO: here you need to calculate unshadowed transport term of a given direction
                    // TODO: 此处你需要计算给定方向下的unshadowed传输项球谐函数值
                    return 0;
                }

这里就只剩一个点乘和max了

                float dot_product = wi.dot(n);
                if (m_Type == Type::Unshadowed)
                {
                    // TODO: here you need to calculate unshadowed transport term of a given direction
                    // TODO: 此处你需要计算给定方向下的unshadowed传输项球谐函数值
                    return dot_product > 0 ? dot_product : 0;
                }

Indoor的数据

0.518558 0.510921 0.498186
-0.0139227 -0.0198673 -0.0233177
-0.0229861 -0.0361469 -0.0237983
0.0263383 0.0681837 0.0585552
-0.0508792 -0.0607283 -0.0570984
0.0515054 0.035726 0.0207611
0.0147266 0.0112063 -0.026747
0.00411617 0.0257427 0.0428588
0.0642155 0.0399902 0.0190308

每一行代表一个基函数的参数，可以理解为把原光照函数投影到某一个基函数后的RGB分量分别为多少

Diffuse shadowed

相对于unshadowed，就多出来一项Visibility

                    // 从顶点位置发射一条光线，与场景相交说明被遮挡了
                    if(dot_product > 0.0f && !scene->rayIntersect(Ray3f(v, wi.normalized())))
                    {
                        return dot_product;
                    }else{
                        return 0.0f;
                    }

当定义好函数后调用了

`1`	`auto shCoeff = sh::ProjectFunction(SHOrder, shFunc, m_SampleCount);`

这行代码根据SH的阶数、被展开的函数、采样数来得到展开后SH的系数到这里光照项和转移项都分别计算了它们的SH展开的系数并存储在txt文件中（通过跑该程序）

7905
0.213508 0.153329 0.206834 -0.0845127 -0.060769 0.144391 0.0588847 -0.0591535 -0.0178413 
0.219123 0.147477 0.190788 -0.134417 -0.0519802 0.135719 0.0171978 -0.101493 0.0164001 
0.206635 0.160885 0.201914 -0.0758193 -0.0472086 0.167402 0.0471802 -0.052247 -0.00859244 
0.185821 0.153003 0.162114 -0.119748 -0.0931989 0.143295 0.00899377 -0.0984071 -0.0184536 
0.206635 0.160885 0.201914 -0.0758193 -0.0472086 0.167402 0.0471802 -0.052247 -0.00859244

每一行代表一个顶点的球谐展开系数。因为T部分不仅与入射方向有关，也与顶点的具体位置有关，所以每固定一个顶点，球谐展开系数都是不一样的

Diffuse Inter-reflection(bonus)

这里就需要考虑光线的多次弹射，渲染方程变成计算一个顶点的系数时，不仅考虑到来自环境光的光照，还考虑来自别的地方弹射过来的光的影响，仿照光线追踪的写法，从着色点射出采样光线，若击中物体，则把光线反过来求出它对着色点的贡献（如果递归的写就可以求出击中物体的值，递归到最后一层就是本身着色点的值）

std::unique_ptr<std::vector<double>> computeInterreflectionSH(Eigen::MatrixXf* directTSHCoeffs, const Point3f& pos, const Normal3f& normal, const Scene* scene, int bounces)
{
    std::unique_ptr<std::vector<double>> coeffs(new std::vector<double>());
    coeffs->assign(SHCoeffLength, 0.0);

    if (bounces > m_Bounce)
        return coeffs;

    const int sample_side = static_cast<int>(floor(sqrt(m_SampleCount)));
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> rng(0.0, 1.0);
    for (int t = 0; t < sample_side; t++) {
        for (int p = 0; p < sample_side; p++) {
            double alpha = (t + rng(gen)) / sample_side;
            double beta = (p + rng(gen)) / sample_side;
            double phi = 2.0 * M_PI * beta;
            double theta = acos(2.0 * alpha - 1.0);
	    //这边模仿ProjectFunction函数写

            Eigen::Array3d d = sh::ToVector(phi, theta);
            const auto wi = Vector3f(d.x(), d.y(), d.z());
            double H = wi.normalized().dot(normal);
            Intersection its;
            if (H > 0.0 && scene->rayIntersect(Ray3f(pos, wi.normalized()), its))
            {
                MatrixXf normals = its.mesh->getVertexNormals();
                Point3f idx = its.tri_index;
                Point3f hitPos = its.p;
                Vector3f bary = its.bary;

                Normal3f hitNormal =
                    Normal3f(normals.col(idx.x()).normalized() * bary.x() +
                        normals.col(idx.y()).normalized() * bary.y() +
                        normals.col(idx.z()).normalized() * bary.z())
                    .normalized();

                auto nextBouncesCoeffs = computeInterreflectionSH(directTSHCoeffs, hitPos, hitNormal, scene, bounces + 1);

                for (int i = 0; i < SHCoeffLength; i++)
                {
                    auto interpolateSH = (directTSHCoeffs->col(idx.x()).coeffRef(i) * bary.x() +
                        directTSHCoeffs->col(idx.y()).coeffRef(i) * bary.y() +
                        directTSHCoeffs->col(idx.z()).coeffRef(i) * bary.z());

                    (*coeffs)[i] += (interpolateSH + (*nextBouncesCoeffs)[i]) * H;
                }
            }
        }
    }

    for (unsigned int i = 0; i < coeffs->size(); i++) {
        (*coeffs)[i] /= sample_side * sample_side;
    }

    return coeffs;
}

            for (int i = 0; i < mesh->getVertexCount(); i++)
            {
                const Point3f& v = mesh->getVertexPositions().col(i);
                const Normal3f& n = mesh->getVertexNormals().col(i).normalized();
                auto indirectCoeffs = computeInterreflectionSH(&m_TransportSHCoeffs, v, n, scene, 1);
                for (int j = 0; j < SHCoeffLength; j++)
                {
                    m_TransportSHCoeffs.col(i).coeffRef(j) += (*indirectCoeffs)[j];
                }
                std::cout << "computing interreflection light sh coeffs, current vertex idx: " << i << " total vertex idx: " << mesh->getVertexCount() << std::endl;
            }

实时球谐光照计算

这里我不展示如何跑通代码，只展示主要的逻辑点。跑通代码可以参考博客：https://zhuanlan.zhihu.com/p/596050050

对于预计算数据使用就是在顶点着色器中，要求一个顶点的着色，就要把光照项的每一个系数与T项对应的系数相乘后相加即可

从下面代码可以看出，三个颜色通道单独计算

//prtVertex.glsl

attribute vec3 aVertexPosition;
attribute vec3 aNormalPosition;
attribute mat3 aPrecomputeLT;

uniform mat4 uModelMatrix;
uniform mat4 uViewMatrix;
uniform mat4 uProjectionMatrix;
uniform mat3 uPrecomputeL[3];

varying highp vec3 vNormal;
varying highp mat3 vPrecomputeLT;
varying highp vec3 vColor;

float L_dot_LT(mat3 PrecomputeL, mat3 PrecomputeLT) {
  vec3 L_0 = PrecomputeL[0];
  vec3 L_1 = PrecomputeL[1];
  vec3 L_2 = PrecomputeL[2];
  vec3 LT_0 = PrecomputeLT[0];
  vec3 LT_1 = PrecomputeLT[1];
  vec3 LT_2 = PrecomputeLT[2];
  return dot(L_0, LT_0) + dot(L_1, LT_1) + dot(L_2, LT_2);
}

void main(void) {
  // 无实际作用，避免aNormalPosition被优化后产生警告
  vNormal = (uModelMatrix * vec4(aNormalPosition, 0.0)).xyz;

  for(int i = 0; i < 3; i++)
  {
    vColor[i] = L_dot_LT(aPrecomputeLT, uPrecomputeL[i]);
  }

  gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * vec4(aVertexPosition, 1.0);
}

以R通道举例一行（顶点的系数）乘一列（环境光贴图系数的R通道）结果作为着色点的R通道值

至于还有一个作业要做旋转。我的理解是如果环境光贴图进行了旋转，其实修改的就只是环境光贴图的球谐展开的系数，其他的不会变，而且因为球谐函数的特性，很容易就能求旋转后的系数。先理解了就行

GAMES202 高质量实时渲染（Assignment 1）

Sun, 19 Oct 2025 14:03:49 +0800

Homework1

shadow Map

首先需要完成MVP矩阵的构造，在这里的mvp用来表示如果一个模型在shadowmap视角下的位置

    CalcLightMVP(translate, scale) {
        let lightMVP = mat4.create();
        let modelMatrix = mat4.create();
        let viewMatrix = mat4.create();
        let projectionMatrix = mat4.create();

        // Model transform
        mat4.translate(modelMatrix,modelMatrix,translate);
        mat4.scale(modelMatrix,modelMatrix,scale);
        // View transform
        mat4.lookAt(viewMatrix, this.lightPos, this.focalPoint, this.lightUp);
        // Projection transform
        mat4.ortho(projectionMatrix, -100,100,-100,100,0.1,400); // 实测far要得400可以覆盖到整个平面
        mat4.multiply(lightMVP, projectionMatrix, viewMatrix);
        mat4.multiply(lightMVP, lightMVP, modelMatrix);
        return lightMVP;
    }

他在顶点着色器中使用，目的是传递每个顶点位置在光源视角下坐标 vPositionFromLight = uLightMVP * vec4(aVertexPosition, 1.0); 在片段着色器中，先实现比较的函数

float useShadowMap(sampler2D shadowMap, vec4 shadowCoord){
  // shadowmap中存储的深度
  float lightDepth = unpack(texture2D(shadowMap, shadowCoord.xy));
  // 着色点深度
  float shadowDepth = shadowCoord.z;
  float visibility = 1.0;
  // 被挡住了
  if (shadowDepth > lightDepth) {
    visibility = 0.0;
  }
  return visibility;
}

在主函数中，需要先对光源坐标处理一下，因为它是经过透视投影处理后的NDC坐标，而shadowMap上取值其实需要的是UV坐标（0，1）之间，所以需要先转到[0,1]之间 ⚠️：透视除法在透视投影时才需要，我看别的博客都写了，其实是不需要的

  float visibility = 1.0;
  // 透视投影时才需要
  // vec3 shadowCoord = vPositionFromLight.xyz / vPositionFromLight.w;
  vec3 shadowCoord = (vPositionFromLight.xyz+1.0)/2.0;
  visibility = useShadowMap(uShadowMap, vec4(shadowCoord, 1.0));

居然没出现自阴影问题，我们手动创建一个，首先光源位置修改在engine.js中lightPos

	// Add lights
	// light - is open shadow map == true
	let lightPos = [0, 90, 80];
	let focalPoint = [0, 0, 0];
	let lightUp = [0, 1, 0]
	const directionLight = new DirectionalLight(5000, [1, 1, 1], lightPos, focalPoint, lightUp, true, renderer.gl);
	renderer.addLight(directionLight);

把光源变斜一点，就会发现场景从远到近逐渐出现自阴影现象 y = 40 y=30 y=20 y=10这时候整个地板都出错了加一个自偏移，就解决了

1
2
3

  if (shadowDepth  > lightDepth + 0.01) {
    visibility = 0.0;
  }

下面是偏移量改为0.05的效果，效果就太差了，偏移量应该根据光照的角度动态调整

走样的情况，下面就用PCF来解决～

PCF(Percentage Closer Filter)

简单理解就是不只判断shadowmap的一个位置，而是一圈位置的平均。作业中提供了两种采样，它的作用就是减少计算量，没必要真的一个一个便利来取均值，偏移记录在了vec2 poissonDisk[NUM_SAMPLES]; 下面是我的实现

float PCF(sampler2D shadowMap, vec4 coords) {
  poissonDiskSamples(coords.xy);
  // 采样数
  float numSamples = 0.0;
  // 没有遮挡的采样数
  float numUnBlock = 0.0;
  // 过滤核大小
  float filterSize = 5.0;
  float mapSize = 2048.0;
  // 过滤核范围
  float filterRange = filterSize / mapSize;
  for(int i = 0;i<NUM_SAMPLES;i++){
    vec2 samplexCoor = coords.xy + poissonDisk[i] * filterRange;
    // 采样时可能会越界
    if(samplexCoor.x > 0.0 && samplexCoor.x < 1.0 && samplexCoor.y > 0.0 && samplexCoor.y < 1.0) {
      numSamples++;
      if(useShadowMap(shadowMap,vec4(samplexCoor,coords.z,1.0)) == 1.0) {
        numUnBlock++;
      }
    }
  }
  return numUnBlock/numSamples;
}

锯齿位置的变化（过滤核大小为5）当改为20时改为100时，出现了大量噪点

PCSS(Percentage Closer Soft Shadow)

用PCF来做软阴影，一句话来说就是动态修改过滤核的尺寸，达到不同的因子区域不同的软硬程度

第一步需要在一定范围内搜索深度比着色点进的点，从而得到一个平均深度

float findBlocker( sampler2D shadowMap,  vec2 uv, float zReceiver ) {
	int numSamples = 0;
  float sumDepth = 0.0;
  float searchSize = 15.0;
  float mapSize = 2048.0;
  float searchRange = searchSize / mapSize;
  for( int i = 0; i < BLOCKER_SEARCH_NUM_SAMPLES; i ++ ) {
    vec2 sampleCoor = uv + poissonDisk[i] * searchRange;
    // 采样时可能会越界
    if(sampleCoor.x > 0.0 && sampleCoor.x < 1.0 && sampleCoor.y > 0.0 && sampleCoor.y < 1.0) {
      float depth = unpack(texture2D(shadowMap, sampleCoor));
      if(depth < zReceiver) {
        sumDepth += depth;
        numSamples++;
      }
    }
  }
  if(numSamples > 0) {
    return sumDepth / float(numSamples);
  } else {
    return zReceiver;
  }
}

下来就计算半影尺寸并把它作为过滤核尺寸来进行PCF

float PCSS(sampler2D shadowMap, vec4 coords){
  uniformDiskSamples(coords.xy);
  // STEP 1: avgblocker depth
  float avgBlockerDepth = findBlocker(shadowMap, coords.xy, coords.z);
  // STEP 2: penumbra size
  // 假设光源尺寸为50
  float Wlight = 50.0;
  float penumbraSize = (coords.z - avgBlockerDepth) * Wlight / avgBlockerDepth;
  // STEP 3: filtering
  // 把半影尺寸当做过滤核大小
  return PCF(shadowMap, coords,penumbraSize);
}

光源尺寸越大，阴影软硬区分程度越大，因为计算出的过滤核尺寸区分度越大 Wlight = 50 Wlight = 100 设置过小时，反而看不出什么效果

GAMES202 GAMES202 高质量实时渲染（Real-Time Ray-Tracing）

Sun, 19 Oct 2025 14:02:08 +0800

RTX

RTX实际做的事：一个像素用一个样本来采样SPP

考虑了一次弹射，第一次primary Ray其实没有必要（从摄像机到着色点），只需要做一遍光栅化就可以实现一整个屏幕的primaryRay。所以一个SPP只需要考虑3条光线

降噪

时间滤波

1SPP噪声非常大。实时光线追踪在算法上并没有区别，主要原因是硬件的突破，让光线追踪达到了实时水平。所以实时光线追踪最关键的技术是降噪！从这幅图可以看出，降噪的效果非常好。降噪的方法有很多，但是应用到实时的降噪技术很少实时降噪使用的是时间上的滤波。当前帧需要前一帧已经滤波。假设运动是连续的。有一个vector叫做motion vector，记录每个点上一帧的位置也就是当前帧用的spp，使用了上一帧的spp，上一帧的spp也用了上上帧的spp，所以作用到当前帧的spp，远大于1。下面首先介绍一个概念，G-buffer，这东西就是延迟渲染用的

Back projection

求一个像素的内容，在上一帧中的位置首先求一个点的世界坐标：

可以提前存储在G-buffer
通过MVP+viewport的逆变换变回世界坐标
我们是知道每个世界坐标是如何变换的，所以通过逆变换来找到这个坐标上一帧的坐标，再把世界坐标转为屏幕坐标即可得到上一帧对应像素的像素值，进行线性插值，通常a取0.1-0.2，也就是80%以上都是上一帧得到的下面对比一下groundtruth和降噪结果

有一些该暗的地方仍然是亮的。基于时间的滤波是有问题的，有一下几点：

第一帧/切换场景
当前帧的物体在上一帧不存在
- 当前帧的物体在上一帧被遮挡了（G-buffer中没有存储）会出现脱尾

解决思路：

混合当前帧和上一帧数据之前，把上一帧的结果拉到当前帧周围
检测要不要用上一帧的数据
1. 检测上一帧位置是否为同一个物体
2. 优化混合系数
3. 增大空间滤波但是这样处理噪声又出现了

滤波实现

空间滤波

滤波操作为低通滤波，保留低频信息，移除高频信息

高斯滤波

双边滤波（考虑边界）

高斯滤波会把图像均匀地糊掉，边界也会模糊，公式的第二项表示如果两边颜色差值很大，贡献就会变小

联合双边滤波

使用G-buffer来更好地指导滤波用深度、颜色、法向量来指导滤波如何实现大的滤波核呢？先水平再垂直，效率从

Progressively Growing Sizes

RTRT滤波解决方案

SVGF

3个factors指导的滤波

深度 - 法线
颜色差异

RAE

工业界问题及解法

TAA 时间上的抗锯齿

每一帧采样一个像素的四个角之一，剩余三个角用之前的数据。这样就相当于MSAA了（静止场景）

MSAA vs SSAA

SSAA就是高分辨率渲染再变小 MSAA分辨率不变，在一个像素中采样多次，甚至可以在临近像素复用

SMAA

超级分辨率

延迟渲染

节省shading的时间

GAMES202 高质量实时渲染（Real-Time Physically Based Materials）

Sun, 19 Oct 2025 14:01:31 +0800

Micorfacet BRDF

F项：Fresnel term

Fresnel项（Fresnel term）用于描述光在界面上反射的强度随入射角变化的现象。对于绝缘体材质对于导电材质 Snell’s Law（斯涅尔定律）描述的是光在两种介质交界面上传播时的折射行为如果分为RGB三个通道，三个通道有自己的折射率。 Rs：垂直偏振（s-polarized）反射率 Rp：平行偏振（p-polarized）反射率因为自然光通常是非偏振光（即含有相等的 s 和 p 偏振分量），所以实际使用时我们取两者的平均来得到总反射率：两者通过平均得到Fresnel平均反射率。 R0是垂直入射下的反射率，可以通过两种介质的折射率获得，他是一个三通道。进一步可以用Schlick’s Approximation来近似出θ角度下的反射率

G项：shadowing-masking term（geometry term）

为了解决微表面的自遮挡问题下图左边表示光线被遮挡（shadowing），右图是视线被遮挡（masking）如果没有G项，当视角和法线接近90°时，BRDF分母会接近0，所以BRDF会变得巨大，导致球体一圈变成白色常用的G项为The Smith shadowing-masking term 把shadowing和masking两种情况分开考虑他是基于NDF的值来考虑G项的值的

D项：Normal Distribution Function（NDF）

微表面上看法线方向并不是统一的当法线分布更多在半程向量时，反射光强度更大

glossy和diffuse的表面法线分布情况，glossy的表面分布比较集中有不同的模型来描述法线分布

Benckmann、GGX

Beckmann NDF

两个系数来控制分布。阿尔法控制表面的粗糙程度。sita控制半程向量和法向量的夹角圆心是着色点，红色是微观法线。黑线是宏观着色点法线。他们的夹角就是sita，把红线延长到上面的一条线上。用tansita来定义分布所以说Beckmann NDF是定义在tanθ上的高斯分布

GGX NDF

它的尾巴比较长，如下图橙色尾巴很长。而beckmannNDF在90°时已经衰减为非常接近0。如果把高出定义为高光，那backmannNDF高光周围会迅速衰减。而GGX会缓慢衰减，形成光晕的效果下图可以看出backmann高光周围比较尖锐。GGX比较平滑所以说GGX的长尾可以带来自然过渡的效果。

GGX的拓展定义参数gamma,调整尾巴衰减速度

Multiple Bounces

现在已经学习了BRDF的FGD三项的构成。但是这样渲染出来还有问题。随着roughness的增加，模型逐渐变暗了。下面一行是在做能量损失实验，说明roughness越大，能量损失越多了这种能量损失体现在，越粗糙的表面法线分布更容易被挡住所以要考虑多次bounces，有相关的论文，但是对于实时渲染太慢了所以现在有了基于经验补全的方式，kulla-Conty Approximation 首先根据渲染方程，假设输入的L=1，计算输出的能量是多少所以1-E(u0)就是损失的能量（E与观察方向有关系，所以不同的视角下损失能量是不一样的），最后补上这部分能量。具体怎么算出来就不看了。最终损失能量依赖于观察方向和粗糙度两个变量。所以直接预计算打表即可。补充前后对比

LTC(Shading Microfacet Models using Linearly Transformed Cosines)

LTC 最初是由 Tobias Ritschel 等人在论文《LTC - A Fast and Efficient Approximation of Fresnel Terms and Distribution of Normal Vectors for Real-Time Rendering》提出的，它被设计为一种方法来近似反射分布函数（BRDF） Fresnel项和法线分布函数（例如 GGX）是微面模型的关键组成部分，这些函数非常复杂，计算成本较高。LTC 使用线性时间编码（Linear Time Coding）来近似这些复杂的分布，使得实时渲染时可以快速计算这些项。综上LTC是一种对BRDF项的预计算

首先，它是有限制的。主要是在GGX的法线分布下、没有阴影、多边形光源主要思想是任何BRDF lobe 都可以通过一个变换转化为一个余弦函数实际实现比较复杂，课程没提到

Disney’s Principled BRDF

首先介绍了为什么有了微表面BRDF还需要Disney的BRDF 它被称为principled的BRDF，可以通过调整参数来达到想要的效果，所以他是艺术家友好的介绍一下里边的名词

subsurface（次表面反射）：光线进入表面后并不会直接反射回去，而是穿透表面并在内部多次散射，最终可能以不同的方向从表面射出。
metallic（金属性）
specular（镜面）
specularTint（镜面颜色）：specularTint 是一个与镜面反射（Specular Reflection）相关的参数，用来控制反射光的颜色如何与材质本身的颜色混合。也就是说镜面反射光不是单纯的白色，而且受表面材质颜色的影响
anisotropic（各向异性）：述材料或表面在不同方向上具有不同物理特性的术语
sheen（沿着球的表面有绒毛雾化效果）
clearcoat（添加一层镀膜）

Non-Photorealistic Rendering(NPR)

Outline Rendering 描边

先来看看有哪些Outline，B表示自己的边界，S表示两个面交界处形成的边界，C是折痕，M是材质边界知道了边界，下来就需要描边，可以通过Shading或者图像处理来完成。首先来介绍Shading方法，哪些像素点是S边上呢，根据观察，就是法线与观察方向=之间夹角接近垂直的像素点。可以设置夹角的阈值，来改变边的粗细另外就是外扩法，之前learnOpenGL里有另外看一下从图像上来处理

Color blocks 色块效果

直接把渲染结果量化，就是连续值变成离散

Strokes Surface Stylization 素描效果

GAMES202 高质量实时渲染（Real-Time Global Illumination）

Sun, 19 Oct 2025 14:00:35 +0800

简单理解就是已经被照亮的点作为光源再去照亮别的点

在3D空间的全局光照

Reflective Shadow Maps（RSM）

用非直接光照照亮点p需要什么：

那些点被光源直接照亮（从shadowMap中得到）
其他点对点p的贡献是什么 shadowMap中每个纹素就是一个面光源（因为shadowMap描述的就是那些地方被直接照到），紧接着要求p点的间接光照其实就是求shadowMap每个纹素代表的面光源对p点的贡献

把纹素作为面光源来求渲染方程现在问题就是从纹素反射出来的Radiance如何计算

BRDF项在当前场景中认为是diffuse的
BRDF可以认为是出射的Radiance与入射的irradiance的比例，所以L可以算出这样写的好处是带入渲染方程后把dA项消掉了，这样就不需要patch的面积大小了，公式就变成了有几个问题：
V项没了，因为计算量太大，要计算对于每个着色点从任何一个纹素看向着色点是否被遮挡
方程下边变成4次方，是论文作者对距离衰减做了平方衰减处理，课程中说这是错的，应该是平方，如果说错了直播吃键盘😄（看到第9节课，老师真吃键盘了）

有一些纹素一定不会对着色点有贡献 1. 可见性 2. 方向 3. 距离这个问题就引出了这篇论文的假设，如何知道那些纹素离着色点比较近，论文中认为在shaowMap上比较近，那么世界坐标下就离的比较近（大胆的假设） RSM需要存储的东西 RSM在工业界通常用在手电筒 RSM的优点：

易于实现缺点：
直接光源有多少就得有多少张shadowMap
可见行没法做
很多的假设
采样率和质量的tradeoff

Light Propagation Volumes (LPV)

关键点：Radiance沿直线传播时不会发生变化z 关键做法：把整个场景体积进行切割，成为一个个体素（类比纹素）下图红色箭头就是间接光照的来源，就是求黄色点接收到的红色radiance的计算步骤：

那些点接收到了直接光照
把这些点放在场景到的一个网格中
在网格中传播radiance 通过RSM得到一系列虚拟光源对场景划分3D网格（可以使用3D纹理，定义每个UV是3D空间的哪个网格）计算一个格子中向任何方向上的radiance是多少，并用SH压缩，LPV需要存储场景中每个体素（voxel）的辐射度分布，直接存储全方向的辐射度会导致内存爆炸。通过SH投影（通常用2阶或3阶），可将6D的光照函数压缩为少量系数（如9个或16个），极大降低内存需求。这一步我理解就是把每个次级光源都归为了每个网格的属性，这里记录了每个网格向各个方向的Radiance 一个格子的radiance向上下左右方向进行传播，这一步结束后每个格子的radiance就都记录好了对于一个着色点来说，就可以直接使用当前格子接受到的Radiance来计算间接光照了但是有问题，墙的一边不可能照亮墙的另一边，那把一堵墙放在同一个网格中，那计算着色时墙两边的Radiance都会被考虑，就会出现漏光这样就会出现漏光现象，这就要考虑网格划分粒度了

Voxel Global Illumination (VXGI)

把整个场景网格化，想象成MC用方块搭起来的场景，并做了层级处理，比如上一层的一个格子在下一次划分为8个格子，最终建立起一颗树第一步：用RSM的方法找到直接光照的网格，并记录每个网格接收到的光源的入射方向和法线，并更新到各个层级，高层级整合低层级的光源入射方向和法线开始着色：对于glossy的着色点，光源到达后会反射为一个圆锥的范围从着色点发射锥体，沿锥体轴线步进采样。看场景中那些体素在椎体范围内，那它就对该着色点有贡献（这是利用光路可逆的思想，反过来这些碰到的体素就会通过椎体射到着色点）对于diffuse的着色点

在屏幕空间的全局光照

屏幕空间：只使用屏幕信息，对图像进行后期处理

Screen Space Ambient Occlusion（SSAO）

一种全局光照的近似 key diea 1：

不知道间接光照，假设为一个常数
但不是所有方向都能接收到，会被别的物体挡住显然AO的环境光更好经典从渲染方程中解释把V项拆出去了，拆出去的（蓝色）项就像当于把四面八方的可见行进行了平均，剩下的（橙色）项中L项在SSAO中已经假设为常数，另外还假设BRDF是diffuse的，所以全是常数了其中cossita还没解释用cos项把球面上的积分转为圆面上的积分（把立体角的面积投影到底面圆上进行积分）数学结束，SSAO就是把间接光当常数、BRDF也是diffuse的理论分析结束，现在问题就是如何在屏幕空间求一个着色点四面八方看哪些地方被挡住了 SSAO假设任何一个着色点在周围半径为R的球中进行采样，每个点与对应像素的zbuffer进行比较，如果大，说明这个点被挡住了就是红色但是上图有一个点判断错了用一整个球来采样还有问题，墙体内部的点不需要考虑，只需要半球采样即可

采样越多越准确 AO做法是先低采样得到AO 然后进行模糊 SSAO的一个问题是会出现假遮挡现象，因为在摄像机视角下，看着被遮挡了，但实际上两者距离是很远的进一步有技术叫HBAO，只考虑一定范围内的遮挡

Screen Space Directional Occlusion(SSDO)

是对SSAO的提升，SSAO考虑间接光照是是一样的，但是通过RSM，我们是可以求出间接光照的

下图看出AO只是简单的变暗，而DO考虑的反射物的颜色，让阴影变蓝了

与SSAO想法相反，DO认为如果打出去的光线没有物体挡住，那它才应该没有间接光照的贡献，只有直接光照的贡献，反而打到的物体才会反射回来光实际做法也和SSAO一样，半球面采样，使用Zbuffer来判断采样点是否被挡住，下图ABD点都得到是被遮挡了考虑ABD的间接光照对C点的贡献 DO也有假遮挡问题，A点没有被挡住，但是从视角上看是被挡住了，所以被认为对C点有间接光照贡献只能做小范围的全局光照

Screen Space Reflection（SSR）

在屏幕空间中做光线追踪现在在屏幕空间已经有了红框的东西，现在SSR就只需要加上白框的东西 SSR的思路 Linear Raymarch 目标是找到光线与场景的交点

选定步长，每走一步检查深度还有加速方法，首先对zbuffer生成mipmap 但与常规mipmap不相同，上一层级的一个像素是下一层级4个像素的最小值，而不是平均值存最小值的目的就是，如果一个光线与上层不相交，那下层更不用考虑了，因为下层离得更远算法为首先走一步，每交点，就胆子大一点就在上一层一口气走两步，还没交点走4步，有交点了再慢慢走 SSR也有问题，因为屏幕空间只有最前面的数据，所以藏在背后的但是反射出来应该能看见的物体就渲染不出来了

GAMES202 高质量实时渲染（Real-Time Environment Mapping）

Sun, 19 Oct 2025 13:59:44 +0800

Shading from Environment Lighting

使用环境光计算shading的操作叫做IBL(Image based lighting) ，光照不是来自光源，而是环境贴图下面在不考虑阴影的情况下来看渲染方程，接受来自整个半球面的光来进行渲染之前的做法是使用蒙特卡洛积分来估计积分，但是太慢了放在实时渲染中（采样表现并不好，（但是随着发展形势逐渐变化了），这里就讲避免采样的方法）根据上图，联系上节课如何对visibility拆分的情况，这里的光照项也可以提出去这种操作反应到贴图上就是对贴图进行了过滤，在渲染之前先得到滤波核处理过的贴图这种操作相当于把多次采样近似为先滤波后的镜面反射方向的一次采样到这里对于光照项避免了采样，下来来看BRDF项避免采样的方法，如今已经有更好的方法，这里只是学思想，主要思想就是我们想直接打表来预存每个变量下的积分值，但是维度太高了，这里在分析如何降维微表面模型的BRDF的方程这里主要考虑菲涅耳项和法线分布项的近似 F项 G项看这两幅图，说明如果我们想预计算BRDF函数，实际上只需要3个变量，一张三维的表，但是三维还是太麻烦了 F项还可以进一步简化，这样写之后把R0拆出来了，因为它基本是一个常数这样等式右边的连个积分都可写成一个二维表来进行预计算在这张2d纹理任何一点的值，就是BRDF积分出来的结果，直接渲染方程都不用积分了下图可以看见这种简化方法得到的结果与真实采样得到的结果十分相似，但计算量小了很多这种方法叫做split sum，它是unreal引擎PBR🐮b的基础～（没有采样就没有噪点）我感觉实时渲染目前了解的很多都是如何把计算进行简化的同时偏差并不大！

shadow from environment lighting

可以把环境光贴图当作很多光源，每个光源都需要shadowMap，这是很困难的

Spherical Harmonics (SH)

Spherical Harmonics (SH)（球面谐函数）是一类在球面坐标系中定义的特殊函数

l决定了波动的“频率”或阶数
m 控制了波动的方向性，特别是如何沿着经度这个东西就是用来把一个二维函数展开成SH的线性组合（类似一维的傅里叶变换）

每一项前边的系数用下式来计算（两个函数乘起来求积分），这种求系数叫做投影，同样通过这些系数也可以恢复原来的函数

说了这么多东西，想表达的就是计算时BRDF是低频时，就可以把它比做低通滤波器，所以不管光照项算出来多高频，最终都会被抵消，所以并不需要高频。所以可以用球谐函数前三阶来近似光照项

总结一下上边这些东西。球谐函数的作用是把一个函数展开成从低频到高频的基函数组的线性组合，渲染方程中如果BRDF是diffuse的，那它就是个低通滤波，即使光照是高频的，它的高频信号计算后也会消失，所以直接用球谐函数前几阶来代替它即可。上面这些东西还只是shading，还没有解决shadow

Precomputed Radiance Transfer (PRT)

在实时渲染下，人们更愿意把渲染方程写成下面，PRT假设光照会变，别的不会变的情况上图是考虑下图这一点的数据这三张图就代表了在这一点任何方向的lighting、visibility、brdf。直接对应相乘再相加就是这一点的shading，但是每个像素都这么大的计算了，显然效率太低了
这三项都可以表示为球面函数，那直接把上边三张图对应像素值相乘就可以了 PRT的基本思想就是把渲染方程看成下面的两部分 lighting和light transport PRT的做法就是：（它假设场景所有东西都不变，就光照可以改变）

把lighting进行球谐函数展开，在预计算时就可以算好，因为每个像素的lighting部分都是来自同一张环境光贴图所有点位的值
transport部分也可以预计算球谐函数展开如果BRDF是diffuse的，那可以把它当作一个常数（即任何方向都均匀反射），下图先提出BRDF的常数，然后把光照项换成求和式，之后交换了求和与积分的顺序（在CG中可以认为任何时候求和和积分都可以交换顺序）到这里发现积分内的含义就和之前求球谐函数展开后各项系数的方程是长一样的，所以可以把后边剩下的项先变成球谐函数，然后i不同就是不同项的系数，这样这个积分项就变成了一个离散的一维数组最终渲染方程变成了两个东西的点乘但是预计算后边这一部分就说明整个场景的物体是不能动的。另外球谐函数的一个优点是旋转后可以很快算出系数的变化，所以支持光照的旋转。

最终渲染方程只需要一个light的数组和一个transport的数组来计算另外还有glossy的物体没有处理。 diffuse的BRDF可以当作一个常数，而glossy的BRDF与摄像机的位置o也有关系，不同的摄像机位置o得出的T数组是不一样的因为现在最终的结果与摄像机视角o有关了，进一步把T(o)也进行球谐函数展开最终light项仍然是一个数组，而transport项变成了二维的

SH选择不同的阶的时间复杂度

GAMES202 高质量实时渲染（Real Time Shadows）

Sun, 19 Oct 2025 13:58:35 +0800

Shadow Mapping

这块东西在我OpenGL学习笔记中有详细介绍

https://blog.csdn.net/lzh804121985/article/details/147256140?spm=1001.2014.3001.5502

shadowMapping的问题

阴影痤疮(Shadow Acne)、或者叫自阴影出现该问题的原因可以看下图，光源视角下的一个像素内高度认为是同一个，下一个像素的位置，会被认为比前一个Z值更远，所以平坦的地板会交替出现高低不平的地方，这样就会出现阴影简单解决就是认为z插值在一个范围内就不算在阴影中，虽然能解决这个问题，但是引入了新的问题，阴影发生了偏移。如果bias设置的过大，在靠近脚的地方，就不会出现阴影。在工业界称为“彼得潘效应"(Peter Panning) 对于这种不接触的阴影，解决方法是shadowmapping中不仅存最小深度的表面，还存储第二小深度的表面另外在learnOpenGL提到，在渲染深度贴图时，使用正面剔除，让深度贴图存储的是物体的内面来解决彼得潘问题。因为我们只需要深度贴图的深度值，对于实体物体无论我们用它们的正面还是背面都没问题。使用背面深度不会有错误，因为阴影在物体内部有错误我们也看不见。

另外阴影还有走样问题，毕竟阴影计算就是一个像素一个像素来做的

shadow mapping背后的数学

在实时渲染中，经常会用到一些不等式，但人们更多关注的是不等式相等时成立的条件，也就是说，不等式在什么条件下近似相等。实时渲染中，经常用到的一个约等如下：满足下列两个条件之一时，实时渲染领域认为他们近似相等：当g(x)满足：

g(x)积分域足够小
g(x)足够smooth，g(x)值变化不大，比较平坦

下面来到渲染方程根据上边的不等式，就可以把最后一项（V）提出来这样变换后，渲染方程就变成了正常做shading之后，再乘以一个表示可见不可见的项这时的G(x)就是渲染方程的被积函数

PCF（Percentage Closer Filtering）

以点P为例，并不只找shadowmap中对应的一个像素，而是找一圈的像素，与这些像素都进行比较，最后将比较结果进行平均比较结果就是一个全是1，0的矩阵，最终得到的数就不是非0即1的数了

PCSS（Percentage closer soft shadows）

PCF它原本是用来解决阴影的走样问题的，后来人们又发现它可以用来生成软阴影，就是PCSS 首先来回顾一下软阴影和硬阴影到这里就可以理解软阴影在阴影不同位置有不同的软硬程度就可以通过PCF的滤波核的大小来控制，越大越模糊，越小越硬 w(半影)与光源大小、物体位置之间呈现相似三角形的关系，w就可以用来表示软硬程度。半影举例越大，滤波核尺寸就应该设计的更大，让阴影更软

总结PCSS的算法流程：1. 在一个范围搜索遮挡物，并计算平均深度。2. 用平均深度求出半影距离3. 在对应的滤波核尺寸下进行PCF 上边的步骤1需要选取一个合适的范围，下图就展示了如何选取一个范围来进行遮挡物搜素，假设了ShadowMap在近平面，用光源的大小来决定搜素范围在PCSS第一步和第三步中，为了计算一个像素点的着色，需要考虑多个纹素，从而导致速度慢。如果采用稀疏采样，又会有噪点产生

VSSM（Variance Soft Shadow Mapping）

针对PCSS效率问题，提出VSSM

优化步骤3

PCF和PCSS的 PC（percentage closer）的理解就是在深度纹理的一片区域内，有多少比例的纹素比着色点深度小这就相当于看多少人比我考试分数高，就需要遍历所有同学的成绩 VSSM的解决方案就是用成绩分布（正态分布）来估计（⚠️VSSM并没有用正态分布，这里这样说只是方便理解，后边提到切比雪夫不等式就好理解了）定义一个正态分布需要均值和方差，这个可以快速计算均值可以通过mipmap（因为上一级map到下一级map就是把相邻的正方形进行平均，到最后就整合为了一个平均值）、SAT（是一种用于高效计算矩形区域内元素总和的数据结构）来求，方差则是用一个概率论公式来求得到正态分布分布后，求小于着色点深度的纹素百分比，其实就是阴影部分的线下面积下来VASS还对这种计算进行了简化。直接使用不等式来近似只要给定均值、方差、和要比较的位置t，就有下面的不等式成立，在渲染中就直接用方差、期望、t来估计红色部分的面积，然后马上就能得出剩余部分的面积（t必须大于中间线才好使）至此，对PCSS步骤三的优化结束，在生成shadowMap时，为了计算方差，还需要额外生成一张平方shadowMap，总体来说甚至都不需要进行loop就可以知道一片区域有多少纹素深度小于着色点深度

优化步骤1

为了设置合理大小的过滤核，对一个区域内遮挡物的深度进行平均，需要遍历纹素，效率并不高

例如下图，如果着色点的深度为7，那么这些纹素的深度只有蓝色的是遮挡物，就需要平均他们，而红色不参与计算对蓝色部分和红色部分求均值后，满足下式这里求N1/N就可以直接用刚才步骤三的不等式（用方差、均值、t来估计大于t的比例），之后1减去它就是N2/N。

但我们还不知道红色部分的均值，在VSSM中直接假设红色部分均值就是t（大胆的假设，假设的依据是阴影位置大概率是个平面） VSSM的效果另外课程还提到目前PCSS是压过VSSM的，因为人们对噪声的容忍度越来越高，在图像层面进行降噪手段变强了

SAT（Summed Area Tables）

SAT是给一片区域立刻得到它的均值的一种数据结构

SAT是对原数据的预处理得到的数据，在一维场景下，每个index记录都是前缀和（提前记录好），现在要求中间某一段的和，就直接拿出SAT在范围查询边界（左边是边界-1）的数据相减就行了在二维情况下蓝色的范围查询，可以转化为左上角都是(0,0)的框加减操作

VSSM的问题

VSSM中作了很多假设，有一个就是假设一片区域纹素是符合正态分布的例如右图深度只有3个峰值，不符合正态分布下图就是说本来只有一小部分没遮住，但是假设为正态分布变成了很大一部分，就会让阴影边白有一些地方变白了

Moment Shadow Mapping

为了解决VSSM分布描述不准确的问题，提出MSM，使用更高阶矩来描述分布大概意思就是用数据的高阶来更好的拟合PCF的效果，下图表明用4阶矩下的分布就很好的达到了PCF的效果缺点很明显空间很大

Distance Field Soft Shadows

首先看一下Distance functions是什么,它描述了空间中任意一点到物体表面的最小距离，离得越远值越小，表示到图上就是变白在任何一个点上，以它记录的值为半径画圆，都不可能碰到物体，如果做光线追踪，那可以直接移动到圆的表面上去，这就是SFD的一个应用下来用它来生成软阴影是它的另外一个阴影用SDF可以大概描述多大的范围被物体挡住了，圆圈内为安全距离，不会有物体挡住，用这个圈的大小来定义visbility的大小，从而实现软阴影在不同的位置找圆做切线，最小的切线就是需要的安全距离求角度是一个acrsin的计算，比较慢，人们用一个替代来简化其中根据不同的k值来达到不同的效果显而易见的优缺点空间换时间，但这是不考虑生成距离场的时间

GAMES101 现代计算机图形学入门 Assignment7

Sun, 19 Oct 2025 13:32:46 +0800

作业介绍

本次作业只需要实现渲染方程，首先需要理解渲染公式其次需要知道利用蒙特卡洛公式求积分的方法求渲染公式的积分部分需要在半球面采样，为了提高准确度，换元为在光源面积上采样

在作业中也给出了伪代码

代码实现

代码参考https://zhuanlan.zhihu.com/p/606074595

注释写的很清楚了

Vector3f Scene::castRay(const Ray& ray, int depth) const
{
    Vector3f hitColor = this->backgroundColor;
    // 获取光线ray与场景中物体的交点
    Intersection shade_point_inter = Scene::intersect(ray);
    // 如果有交点
    if (shade_point_inter.happened){
        // 交点坐标
        Vector3f p = shade_point_inter.coords;
        // 从摄像机到点P的方向
        Vector3f wo = ray.direction;
        // p点的法线
        Vector3f N = shade_point_inter.normal;
        Vector3f L_dir(0), L_indir(0);

        //光照的采样 获取位置和概率密度函数
        Intersection light_point_inter;
        float pdf_light;
        sampleLight(light_point_inter, pdf_light);
        //Get x,ws,NN,emit from inter
        // 光照采样点的坐标
        Vector3f x = light_point_inter.coords;
        // 从点P到光照采样点的方向
        Vector3f ws = normalize(x-p);
        // 光照采样点的法线
        Vector3f NN = light_point_inter.normal;
        // ？
        Vector3f emit = light_point_inter.emit;
        // 点p到光照采样点的距离
        float distance_pTox = (x - p).norm();
        //创建从p->采样点的光照
        Vector3f p_deviation = (dotProduct(ray.direction, N) < 0) ?
                               p + N * EPSILON :
                               p - N * EPSILON ;

        Ray ray_pTox(p_deviation, ws);
        //判断是否中间有别的物体挡住了
        Intersection blocked_point_inter = Scene::intersect(ray_pTox);
        // 如果没有被挡住就算一次L
        if (abs(distance_pTox - blocked_point_inter.distance < 0.01 ))
        {
            L_dir = emit * shade_point_inter.m->eval(wo, ws, N) * dotProduct(ws, N) * dotProduct(-ws, NN) / (distance_pTox * distance_pTox * pdf_light);
        }
        // 俄罗斯轮盘赌来停止递归
        float ksi = get_random_float();
        if (ksi < RussianRoulette)
        {
            // 采样获得wi方向来进一步递归
            Vector3f wi = normalize(shade_point_inter.m->sample(wo, N));
            // 创建对应的光线
            Ray ray_pTowi(p_deviation, wi);
            //光线碰到了不发光的物体，需要递归处理
            Intersection bounce_point_inter = Scene::intersect(ray_pTowi);
            // 如果光线碰到了物体就需要递归处理了
            if (bounce_point_inter.happened && !bounce_point_inter.m->hasEmission())
            {
                float pdf = shade_point_inter.m->pdf(wo, wi, N);
                if(pdf> EPSILON)
                    L_indir = castRay(ray_pTowi, depth + 1) * shade_point_inter.m->eval(wo, wi, N) * dotProduct(wi, N) / (pdf *RussianRoulette);
            }
        }
        // 结合直接光照和间接光照获得该点的颜色值
        hitColor = shade_point_inter.m->getEmission() + L_dir + L_indir;
    }
    return hitColor;
}

GAMES101 现代计算机图形学入门 Assignment6

Sun, 19 Oct 2025 13:24:41 +0800

作业介绍

在上次作业中，每一次计算光线交点时，都需要与场景中所有的物体进行求交运行，这显然是不合理的，这次作业用BVH划分后进行加速

预处理

需要根据上次作业的内容以及这次作业对代码结构的调整，写入eye ray计算方法和三角形与光线求交，下面给出具体代码 void Renderer::Render(const Scene& scene)中，光线被定义成了一个类，填入参数

        for (uint32_t i = 0; i < scene.width; ++i) {
            // generate primary ray direction
            float x = (2 * (i + 0.5) / (float)scene.width - 1) *
                      imageAspectRatio * scale;
            float y = (1 - 2 * (j + 0.5) / (float)scene.height) * scale;
            Vector3f dir = Vector3f(x, y, -1); // Don't forget to normalize this direction!
            dir = normalize(dir);
            Ray ray(eye_pos, dir);
            framebuffer[m++] = scene.castRay(ray, 0);
        }

inline Intersection Triangle::getIntersection(Ray ray)中，交点定义为了一个类，填入参数即可

    // TODO find ray triangle intersection
    inter.normal = normal;
    inter.coords = ray(t_tmp);
    inter.distance = t_tmp;
    inter.happened = true;
    inter.m = m;
    inter.obj = this;

Bounds3::IntersectP

这里就需要完成光线与包围盒是否相交的操作，我这里代码并没用后两个参数，AABB的好处就是平面法向量很简单，一个点和一个法向量确定一个平面，再联立光线参数方程，就可以解出来t（这个方法比较垃圾，下面有更好的方法）

inline bool Bounds3::IntersectP(const Ray& ray, const Vector3f& invDir,
                                const std::array<int, 3>& dirIsNeg) const
{
    // invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division
    // dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic
    // TODO test if ray bound intersects
    // xyz方向的法向量
    Vector3f nX(1,0,0);
    Vector3f nY(0,1,0);
    Vector3f nZ(0,0,1);
    // x方向两个t
    float tx1 = dotProduct(pMin-ray.origin,nX)/ dotProduct(ray.direction,nX);
    float tx2 = dotProduct(pMax-ray.origin,nX)/ dotProduct(ray.direction,nX);
    // y方向两个t
    float ty1 = dotProduct(pMin-ray.origin,nY)/ dotProduct(ray.direction,nY);
    float ty2 = dotProduct(pMax-ray.origin,nY)/ dotProduct(ray.direction,nY);
    // z方向两个t
    float tz1 = dotProduct(pMin-ray.origin,nZ)/ dotProduct(ray.direction,nZ);
    float tz2 = dotProduct(pMax-ray.origin,nZ)/ dotProduct(ray.direction,nZ);
    // 保证1<2
    if (tx1 > tx2){
        float temp = tx1;
        tx1 = tx2;
        tx2 = temp;
    }
    if (ty1 > ty2){
        float temp = ty1;
        ty1 = ty2;
        ty2 = temp;
    }
    if (tz1 > tz2){
        float temp = tz1;
        tz1 = tz2;
        tz2 = temp;
    }
    float maxEnter = std::max(tx1,std::max(ty1,tz1));
    float minExit = std::min(tx2,std::min(ty2,tz2));
    return minExit > 0 && maxEnter <= minExit;
}

看了别人的解答，我这个确实比较垃，直接根据x轴上光线起点与对面的距离再除以x方向上的光的速度，就可以得到t了（速度就是光线的方向向量的x分量）

https://zhuanlan.zhihu.com/p/545253020

inline bool Bounds3::IntersectP(const Ray& ray, const Vector3f& invDir,
                                const std::array<int, 3>& dirIsNeg) const
{
    // invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division
    // 计算进入x,y,z截面的最早和最晚时间

    float t_min_x = (pMin.x - ray.origin.x) * invDir[0];
    float t_min_y = (pMin.y - ray.origin.y) * invDir[1];
    float t_min_z = (pMin.z - ray.origin.z) * invDir[2];
    float t_max_x = (pMax.x - ray.origin.x) * invDir[0];
    float t_max_y = (pMax.y - ray.origin.y) * invDir[1];
    float t_max_z = (pMax.z - ray.origin.z) * invDir[2];
    // dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic
    // 如果方向是负的，就交换最早和最晚时间
    if (!dirIsNeg[0])
    {
        float t = t_min_x;
        t_min_x = t_max_x;
        t_max_x = t;
    }
    if (!dirIsNeg[1])
    {
        float t = t_min_y;
        t_min_y = t_max_y;
        t_max_y = t;
    }
    if (!dirIsNeg[2])
    {
        float t = t_min_z;
        t_min_z = t_max_z;
        t_max_z = t;
    }
    // 小小取其大，大大取其小
    float t_enter = std::max(t_min_x, std::max(t_min_y, t_min_z));
    float t_exit = std::min(t_max_x, std::min(t_max_y, t_max_z));
    // TODO test if ray bound intersects
    // 检测包围盒是否存在
    if (t_exit>=0&&t_enter<t_exit)
    {
        return true;
    }
    else
    {
        return false;
    }
}

BVHAccel::getIntersection

BVH树构建好后，通过树上的遍历，找到离光源最近的物体的交点，代码其实就是二叉树的遍历

Intersection BVHAccel::getIntersection(BVHBuildNode* node, const Ray& ray) const
{
    // TODO Traverse the BVH to find intersection
    std::array<int,3> dirIsNeg;
    dirIsNeg[0] = (ray.direction[0]>0);
    dirIsNeg[1] = (ray.direction[1]>0);
    dirIsNeg[2] = (ray.direction[2]>0);
    Intersection inter;
    if (!node->bounds.IntersectP(ray, ray.direction_inv, dirIsNeg)){
        return inter;
    }
    if(node->left == nullptr && node->right == nullptr){
        return node->object->getIntersection(ray);
    }
    Intersection leftInter = getIntersection(node->left, ray);
    Intersection rightInter = getIntersection(node->right, ray);
    // 返回离光源最近的
    return leftInter.distance < rightInter.distance ? leftInter : rightInter;
}

最终运行代码得到如图结果

其他代码

BVH树的构造

BVH在分叉中点选取时，参考的是物体包围盒质心（Centroid）在质心包围盒（Centroid Bounds）最大延伸轴上的排序位置

// 构建BVH树
BVHBuildNode* BVHAccel::recursiveBuild(std::vector<Object*> objects)
{
    BVHBuildNode* node = new BVHBuildNode();

    // Compute bounds of all primitives in BVH node
    Bounds3 bounds;
    // 获取当前层所有物体的包围盒
    for (int i = 0; i < objects.size(); ++i)
        bounds = Union(bounds, objects[i]->getBounds());
    // 只有一个物体了，就设置叶子节点
    if (objects.size() == 1) {
        // Create leaf _BVHBuildNode_
        node->bounds = objects[0]->getBounds();
        node->object = objects[0];
        node->left = nullptr;
        node->right = nullptr;
        return node;
    }
    // 有两个物体，就设置左右两个叶子节点
    else if (objects.size() == 2) {
        node->left = recursiveBuild(std::vector{objects[0]});
        node->right = recursiveBuild(std::vector{objects[1]});

        node->bounds = Union(node->left->bounds, node->right->bounds);
        return node;
    }
    // 正常情况就找中间的物体，然后分成左右两部分，再进行递归
    else {
        Bounds3 centroidBounds;
        for (int i = 0; i < objects.size(); ++i)
            centroidBounds =
                Union(centroidBounds, objects[i]->getBounds().Centroid());
        int dim = centroidBounds.maxExtent();
        switch (dim) {
        case 0:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().x <
                       f2->getBounds().Centroid().x;
            });
            break;
        case 1:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().y <
                       f2->getBounds().Centroid().y;
            });
            break;
        case 2:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().z <
                       f2->getBounds().Centroid().z;
            });
            break;
        }

        auto beginning = objects.begin();
        auto middling = objects.begin() + (objects.size() / 2);
        auto ending = objects.end();

        auto leftshapes = std::vector<Object*>(beginning, middling);
        auto rightshapes = std::vector<Object*>(middling, ending);

        assert(objects.size() == (leftshapes.size() + rightshapes.size()));

        node->left = recursiveBuild(leftshapes);
        node->right = recursiveBuild(rightshapes);

        node->bounds = Union(node->left->bounds, node->right->bounds);
    }

    return node;
}

GAMES101 现代计算机图形学入门 Assignment5

Sun, 19 Oct 2025 13:24:12 +0800

作业介绍

eye ray（计算像素坐标实际对应的空间坐标）

这里首先需要回顾一下光栅化过程中的各种space转换

Model Space 模型自身的局部坐标系，类如.obj文件中定义的顶点位置，并不会随着在空间中移动而修改
World Space 全局坐标系，所有物体在此空间中进行定位和交互
View Space 以摄像机为原点的坐标系，看向-Z方向
Clip Space 经投影矩阵（Projection Matrix）变换后的标准化坐标空间（范围[-1,1]）
Screen Space 经过视口转换映射到屏幕上
Raster Space 用于表示最终渲染图像中每个像素的位置‌

遍历像素是在Raster Space中进行的，第一步要计算摄像机看向每个像素时，实际上看向的空间坐标。（在这里意识到之前学习的一个误区，经过视口变化后，xy坐标范围从[-1,1]变化为[0,width/heigth]，而z坐标并不是变成从0开始，然后向-z变化，而是主要看最大深度和最小深度是如何设置的）

x和y都加0.5移动到像素中心
$x+0.5/width，y+0.5/height$ 缩小到[0,1]
下一步 $2 * ( i+0.5 )/width - 1$,扩大2倍左移一个单位，这样就移动到了[-1,1] （由于屏幕原点在左上角，y越往下越大，但是在NDC空间，y越往下越小，所以要反转y坐标）
因为原来屏幕不一定是正方形，需要给x*宽高比（此时已经在NDC坐标下）
最后将NDC坐标转换为摄像机视角下的坐标（给了fov，就是给了znear的位置），给x、y乘以tan(deg2rad(scene.fov * 0.5f)），这样就得到了当眼睛看向一个像素时，它实际上在znear上的位置
确实没有必要继续逆转换了，因为znear上的坐标在透视投影过程中并不会变化给出这部分的完整代码

    for (int j = 0; j < scene.height; ++j)
    {
        for (int i = 0; i < scene.width; ++i)
        {
            // generate primary ray direction
            float x;
            float y;
            // TODO: Find the x and y positions of the current pixel to get the direction
            // vector that passes through it.
            // Also, don't forget to multiply both of them with the variable *scale*, and
            // x (horizontal) variable with the *imageAspectRatio*
            // 映射到[-1,1]
            x = 2 * (i + 0.5) / scene.width - 1;
            y = 1 - 2 * (j + 0.5) / scene.height;
            // 找到对应znear的坐标
            x = x * scale * imageAspectRatio;
            y = y * scale;
            Vector3f dir = Vector3f(x, y, -1); // Don't forget to normalize this direction!
            normalize(dir);
            framebuffer[m++] = castRay(eye_pos, dir, scene, 0);
        }
        UpdateProgress(j / (float)scene.height);
    }

rayTriangleIntersect 三角形与光线求交

这里比较容易，因为有现成的公式，如果有交点，那这个交点可以用重心坐标表示，所以可以得出图中的等式，直接代码实现即可，最后记得判断结果的合理性（t要大于0，重心坐标三个分量都要大于0，等式已经限定了三者相加为1）完整代码

bool rayTriangleIntersect(const Vector3f& v0, const Vector3f& v1, const Vector3f& v2, const Vector3f& orig,
                          const Vector3f& dir, float& tnear, float& u, float& v)
{
    Vector3f e1 = v1-v0;
    Vector3f e2 = v2-v0;
    Vector3f s = orig - v0;
    Vector3f s1 = crossProduct(dir,e2);
    Vector3f s2 = crossProduct(s,e1);
    Vector3f tmp(dotProduct(s2,e2), dotProduct(s1,s), dotProduct(s2,dir));
    Vector3f ans = tmp/ dotProduct(s1,e1);
    tnear = ans.x;
    u = ans.y;
    v = ans.z;
    if (tnear > 0 && u>=0 && v>=0 && 1-u-v>0){
        return true;
    }
    return false;
}

上边两步做完后，作业就结束了，输出的图如下

其他代码

Object及其派生

class Object
{
public:
    Object()
        : materialType(DIFFUSE_AND_GLOSSY)
        , ior(1.3)
        , Kd(0.8)
        , Ks(0.2)
        , diffuseColor(0.2)
        , specularExponent(25)
    {}
    virtual ~Object() = default;
    // 光线与Object是否有交点
    virtual bool intersect(const Vector3f&, const Vector3f&, float&, uint32_t&, Vector2f&) const = 0;
    // 负责计算交点处的表面属性
    virtual void getSurfaceProperties(const Vector3f&, const Vector3f&, const uint32_t&, const Vector2f&, Vector3f&,
                                      Vector2f&) const = 0;
    // 返回Object的漫反射颜色
    virtual Vector3f evalDiffuseColor(const Vector2f&) const
    {
        return diffuseColor;
    }
    // material properties
    MaterialType materialType;
    // 折射率
    float ior;
    // 漫反射和高光反射系数
    float Kd, Ks;
    // 漫反射颜色
    Vector3f diffuseColor;
    // 高光指数（Phong模型参数），控制高光区域的大小和锐利程度（值越大，高光越集中）‌
    float specularExponent;
};

Object有两个实现类Sphere和MeshTriangle 首先看看 Sphere

class Sphere : public Object
{
public:
    Sphere(const Vector3f& c, const float& r)
        : center(c)
        , radius(r)
        , radius2(r * r)
    {}
    // 实现求交 就是光线的方程与球的隐式方程联立求解
    bool intersect(const Vector3f& orig, const Vector3f& dir, float& tnear, uint32_t&, Vector2f&) const override
    {
        // analytic solution
        Vector3f L = orig - center;
        float a = dotProduct(dir, dir);
        float b = 2 * dotProduct(dir, L);
        float c = dotProduct(L, L) - radius2;
        float t0, t1;
        if (!solveQuadratic(a, b, c, t0, t1))
            return false;
        if (t0 < 0)
            t0 = t1;
        if (t0 < 0)
            return false;
        tnear = t0;
        return true;
    }
    // 返回的是法线
    void getSurfaceProperties(const Vector3f& P, const Vector3f&, const uint32_t&, const Vector2f&,
                              Vector3f& N, Vector2f&) const override
    {
        // 球表面一点的法线就是这一点与圆心连接的线
        N = normalize(P - center);
    }
    Vector3f center;
    float radius, radius2;
};

其中求交问题参考下图，就是联立求解，solveQuadratic用来求二次方程的根紧接着看一下MeshTriangle

class MeshTriangle : public Object
{
public:
    // 参数为顶点数组、索引数组、三角形数量、对应的纹理坐标
    MeshTriangle(const Vector3f* verts, const uint32_t* vertsIndex, const uint32_t& numTris, const Vector2f* st)
    {
        uint32_t maxIndex = 0;
        for (uint32_t i = 0; i < numTris * 3; ++i)
            if (vertsIndex[i] > maxIndex)
                maxIndex = vertsIndex[i];
        maxIndex += 1;
        vertices = std::unique_ptr<Vector3f[]>(new Vector3f[maxIndex]);
        memcpy(vertices.get(), verts, sizeof(Vector3f) * maxIndex);
        vertexIndex = std::unique_ptr<uint32_t[]>(new uint32_t[numTris * 3]);
        memcpy(vertexIndex.get(), vertsIndex, sizeof(uint32_t) * numTris * 3);
        numTriangles = numTris;
        stCoordinates = std::unique_ptr<Vector2f[]>(new Vector2f[maxIndex]);
        memcpy(stCoordinates.get(), st, sizeof(Vector2f) * maxIndex);
    }
    // 求交 就是上边实现的功能
    bool intersect(const Vector3f& orig, const Vector3f& dir, float& tnear, uint32_t& index,
                   Vector2f& uv) const override
    {
        bool intersect = false;
        for (uint32_t k = 0; k < numTriangles; ++k)
        {
            const Vector3f& v0 = vertices[vertexIndex[k * 3]];
            const Vector3f& v1 = vertices[vertexIndex[k * 3 + 1]];
            const Vector3f& v2 = vertices[vertexIndex[k * 3 + 2]];
            float t, u, v;
            if (rayTriangleIntersect(v0, v1, v2, orig, dir, t, u, v) && t < tnear)
            {
                tnear = t;
                uv.x = u;
                uv.y = v;
                index = k;
                intersect |= true;
            }
        }

        return intersect;
    }

    void getSurfaceProperties(const Vector3f&, const Vector3f&, const uint32_t& index, const Vector2f& uv, Vector3f& N,
                              Vector2f& st) const override
    {
        const Vector3f& v0 = vertices[vertexIndex[index * 3]];
        const Vector3f& v1 = vertices[vertexIndex[index * 3 + 1]];
        const Vector3f& v2 = vertices[vertexIndex[index * 3 + 2]];
        Vector3f e0 = normalize(v1 - v0);
        Vector3f e1 = normalize(v2 - v1);
        // 直接用了顶点法线作为内部的法线
        N = normalize(crossProduct(e0, e1));
        const Vector2f& st0 = stCoordinates[vertexIndex[index * 3]];
        const Vector2f& st1 = stCoordinates[vertexIndex[index * 3 + 1]];
        const Vector2f& st2 = stCoordinates[vertexIndex[index * 3 + 2]];
        // 插值出来的纹理坐标
        st = st0 * (1 - uv.x - uv.y) + st1 * uv.x + st2 * uv.y;
    }
    // 生成一个缩放后的棋盘格纹理，颜色在橙色和黄色之间交替
    Vector3f evalDiffuseColor(const Vector2f& st) const override
    {
        float scale = 5;
        float pattern = (fmodf(st.x * scale, 1) > 0.5) ^ (fmodf(st.y * scale, 1) > 0.5);
        return lerp(Vector3f(0.815, 0.235, 0.031), Vector3f(0.937, 0.937, 0.231), pattern);
    }
    std::unique_ptr<Vector3f[]> vertices;
    uint32_t numTriangles;
    std::unique_ptr<uint32_t[]> vertexIndex;
    std::unique_ptr<Vector2f[]> stCoordinates;
};

Renerer.cpp

这里就是实现整体渲染逻辑的地方

trace

求交运行的地方，从代码可以看出每个像素都需要和场景中的每个物体进行求交，效率较低，下一次作业就是加速这快东西

std::optional<hit_payload> trace(
        const Vector3f &orig, const Vector3f &dir,
        const std::vector<std::unique_ptr<Object> > &objects)
{
    float tNear = kInfinity;
    std::optional<hit_payload> payload;
    // 用场景中所有的物体与光线进行求交
    for (const auto & object : objects)
    {
        float tNearK = kInfinity;
        uint32_t indexK;
        Vector2f uvK;
        if (object->intersect(orig, dir, tNearK, indexK, uvK) && tNearK < tNear)
        {
            payload.emplace();
            payload->hit_obj = object.get();
            payload->tNear = tNearK;
            payload->index = indexK;
            payload->uv = uvK;
            tNear = tNearK;
        }
    }
    return payload;
}

castRay

光线追踪的整体逻辑，递归函数很好理解，出口也很明显，具体逻辑都写注释了

Vector3f castRay(
        const Vector3f &orig, const Vector3f &dir, const Scene& scene,
        int depth)
{
	// 递归出口
    if (depth > scene.maxDepth) {
        return Vector3f(0.0,0.0,0.0);
    }

    Vector3f hitColor = scene.backgroundColor;
    if (auto payload = trace(orig, dir, scene.get_objects()); payload)
    {
        Vector3f hitPoint = orig + dir * payload->tNear;
        Vector3f N; // normal
        Vector2f st; // st coordinates
        // 获取该点位的法线和纹理坐标
        payload->hit_obj->getSurfaceProperties(hitPoint, dir, payload->index, payload->uv, N, st);
        // 根据材质不同进行不同的处理
        switch (payload->hit_obj->materialType) {
            // 反射+折射
            case REFLECTION_AND_REFRACTION:
            {
                // 获得反射方向
                Vector3f reflectionDirection = normalize(reflect(dir, N));
                // 获得折射方向
                Vector3f refractionDirection = normalize(refract(dir, N, payload->hit_obj->ior));
                // 当光线击中物体表面后，反射光线的起点如果直接使用 hitPoint（命中点），由于浮点数精度限制，新光线可能会误判为与同一物体再次相交（即“自交”），导致渲染错误（如表面黑斑或无限递归）。 根据反射方向与表面法线 N 的关系，将起点沿法线方向 ‌轻微偏移‌，使其略微离开原始表面，避免自交。
                Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?
                                             hitPoint - N * scene.epsilon :
                                             hitPoint + N * scene.epsilon;
                Vector3f refractionRayOrig = (dotProduct(refractionDirection, N) < 0) ?
                                             hitPoint - N * scene.epsilon :
                                             hitPoint + N * scene.epsilon;
                // 递归计算这次反射和折射后映射到该位置的颜色
                Vector3f reflectionColor = castRay(reflectionRayOrig, reflectionDirection, scene, depth + 1);
                Vector3f refractionColor = castRay(refractionRayOrig, refractionDirection, scene, depth + 1);
                // 菲涅尔效应（Fresnel Effect）动态混合反射和折射颜色。菲涅尔效应表明，光线与表面交互时，反射和折射的比例取决于入射角：当光线 ‌垂直入射‌（入射角接近 0°）时，反射比例 kr 较小，折射占主导。
                float kr = fresnel(dir, N, payload->hit_obj->ior);
                hitColor = reflectionColor * kr + refractionColor * (1 - kr);
                break;
            }
            // 只有反射
            case REFLECTION:
            {
                float kr = fresnel(dir, N, payload->hit_obj->ior);
                Vector3f reflectionDirection = reflect(dir, N);
                Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?
                                             hitPoint + N * scene.epsilon :
                                             hitPoint - N * scene.epsilon;
                hitColor = castRay(reflectionRayOrig, reflectionDirection, scene, depth + 1) * kr;
                break;
            }
            // BPhong光照模型了进行默认，这里重点要看一下阴影是如何产生的
            default:
            {
                // [comment]
                // We use the Phong illumation model int the default case. The phong model
                // is composed of a diffuse and a specular reflection component.
                // [/comment]
                Vector3f lightAmt = 0, specularColor = 0;
                Vector3f shadowPointOrig = (dotProduct(dir, N) < 0) ?
                                           hitPoint + N * scene.epsilon :
                                           hitPoint - N * scene.epsilon;
                // [comment]
                // Loop over all lights in the scene and sum their contribution up
                // We also apply the lambert cosine law
                // [/comment]
                for (auto& light : scene.get_lights()) {
                    Vector3f lightDir = light->position - hitPoint;
                    // square of the distance between hitPoint and the light
                    float lightDistance2 = dotProduct(lightDir, lightDir);
                    lightDir = normalize(lightDir);
                    float LdotN = std::max(0.f, dotProduct(lightDir, N));
                    // is the point in shadow, and is the nearest occluding object closer to the object than the light itself?
                    // 在一个只考虑光照模型的hitpoint上，以这个点为起始点，向光源方向发出光线，查看是否被遮挡，如果遮挡物距离比光影距离近，则生成阴影
                    auto shadow_res = trace(shadowPointOrig, lightDir, scene.get_objects());
                    bool inShadow = shadow_res && (shadow_res->tNear * shadow_res->tNear < lightDistance2);
                    // 如果被遮挡，则漫反射贡献将变为0
                    lightAmt += inShadow ? 0 : light->intensity * LdotN;
                    Vector3f reflectionDirection = reflect(-lightDir, N);

                    specularColor += powf(std::max(0.f, -dotProduct(reflectionDirection, dir)),
                        payload->hit_obj->specularExponent) * light->intensity;
                }

                hitColor = lightAmt * payload->hit_obj->evalDiffuseColor(st) * payload->hit_obj->Kd + specularColor * payload->hit_obj->Ks;
                break;
            }
        }
    }
    return hitColor;
}

GAMES101 现代计算机图形学入门 Assignment4

Sun, 19 Oct 2025 13:23:42 +0800

作业介绍

本期作业将在新的代码上完成，就是绘制四个控制点表示的贝塞尔曲线，本次作业的原理很简单，另外我目前并不想把时间花费到写出实现代码上，所以本次代码来自网络，会标明出处

cv::Point2f recursive_bezier(const std::vectorcv::Point2f &control_points, float t)

参考https://blog.csdn.net/ycrsw/article/details/124117190?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522409267016115dce86afca8873f30f1ba%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=409267016115dce86afca8873f30f1ba&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~~all~~top_positive~default-1-124117190-null-null.142^v102^pc_search_result_base4&utm_term=games101%E4%BD%9C%E4%B8%9A4&spm=1018.2226.3001.4187

该方法用于返回确定t时，需要绘制的点的坐标

bool recursive_bezier(const std::vector<cv::Point2f> &control_points, std::vector<cv::Point2f> &points1, std::vector<cv::Point2f> &points2, float t, cv::Mat &window){
    int size;
    size = points1.size();

    if(size == 1){
        window.at<cv::Vec3b>(points1[0].y, points1[0].x)[1] = 255;//设置该点的绿通道为255
        points2 = control_points;
        points1.clear();//结束计算后记得初始化容器
        return true;
    }
    for(int i = 0; i < size - 1; i++)
        points2.push_back((1 - t) * points1[i] + t * points1[i + 1]);
    points1.clear();
    return false;
}

void bezier(const std::vectorcv::Point2f &control_points, cv::Mat &window)

当t不断变化下，点也不断变化，从而绘制出曲线

void bezier(const std::vector<cv::Point2f> &control_points, cv::Mat &window)
{
    // TODO: Iterate through all t = 0 to t = 1 with small steps, and call de Casteljau's 
    // recursive Bezier algorithm.
    int size = control_points.size();
    std::vector<cv::Point2f> points1 = control_points, points2;
    bool flag = true, bflag;
    for (double t = 0.0; t <= 1.0; t += 0.001)
    {
        bflag = false;
        while(!bflag){
            if(flag)
                bflag = recursive_bezier(control_points, points1, points2, t, window);
            else
                bflag = recursive_bezier(control_points, points2, points1, t, window);
            flag = !flag;
        }
    }
}

本次作业主要懂贝塞尔曲线的原理，以及递归代码如何写即可

GAMES101 现代计算机图形学入门 Assignment3

Sun, 19 Oct 2025 13:22:54 +0800

作业描述

上节课已经对光栅化的操作有了了解，这节课直接引入了模型和纹理，其实本质就是引入了很多的顶点，操作其实没什么变化

和上次一样，只不过要插值更多的东西
copy以前的投影矩阵即可
实现Blinn-Phong的光照模型，本质就是对每个像素的颜色值进行处理，把插值出来的颜色作为了漫反射的系数，另外还需要考虑高光反射和环境光
把材质搬进来，漫反射系数不再使用插值算法，而是由材质提供
Bump mapping
待学习

法向量、纹理颜色插值

通过重心坐标进行插值,每个像素点的重心坐标计算公式如下，$A_A$是面积重心坐标计算代码如下

static std::tuple<float, float, float> computeBarycentric2D(float x, float y, const Vector4f* v){
    float c1 = (x*(v[1].y() - v[2].y()) + (v[2].x() - v[1].x())*y + v[1].x()*v[2].y() - v[2].x()*v[1].y()) / (v[0].x()*(v[1].y() - v[2].y()) + (v[2].x() - v[1].x())*v[0].y() + v[1].x()*v[2].y() - v[2].x()*v[1].y());
    float c2 = (x*(v[2].y() - v[0].y()) + (v[0].x() - v[2].x())*y + v[2].x()*v[0].y() - v[0].x()*v[2].y()) / (v[1].x()*(v[2].y() - v[0].y()) + (v[0].x() - v[2].x())*v[1].y() + v[2].x()*v[0].y() - v[0].x()*v[2].y());
    float c3 = (x*(v[0].y() - v[1].y()) + (v[1].x() - v[0].x())*y + v[0].x()*v[1].y() - v[1].x()*v[0].y()) / (v[2].x()*(v[0].y() - v[1].y()) + (v[1].x() - v[0].x())*v[2].y() + v[0].x()*v[1].y() - v[1].x()*v[0].y());
    return {c1,c2,c3};
}

插值算法使用如下

static Eigen::Vector3f interpolate(float alpha, float beta, float gamma, const Eigen::Vector3f& vert1, const Eigen::Vector3f& vert2, const Eigen::Vector3f& vert3, float weight)
{
    return (alpha * vert1 + beta * vert2 + gamma * vert3) / weight;
}

具体的使用如下

//color interpolate
auto interpolated_color = interpolate(alpha,beta,gamma,t.color[0],t.color[1],t.color[2],1);
//normal vector interpolate
auto interpolated_normal = interpolate(alpha,beta,gamma,t.normal[0],t.normal[1],t.normal[2],1).normalized();
//texture coordinates interpolate
auto interpolated_texcoords = interpolate(alpha,beta,gamma,t.tex_coords[0],t.tex_coords[1],t.tex_coords[2],1);
//shading point coordinates interpolate  这个东西是为了记录每个像素点是在哪个方向上观察他的，同于计算光照
auto interpolated_shadingcoords = interpolate(alpha,beta,gamma,view_pos[0],view_pos[1],view_pos[2],1);

Blinn-Phong的光照模型

听过课肯定都懂了，直接写进代码即可

Eigen::Vector3f phong_fragment_shader(const fragment_shader_payload& payload)
{
    // ka kd ks 是三种光的系数
    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    // l1 l2表示有两个光源，里边的内容是位置和强度
    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    // 环境光强度
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    // 高光的指数，越大对角度越敏感
    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    Eigen::Vector3f result_color = {0, 0, 0};
    for (auto& light : lights)
    {
        // 计算点到光源的向量
        Eigen::Vector3f light_vec = light.position - point;
        // 计算点到光源的距离
        float r = light_vec.norm();
        // 归一化从点到光源的向量
        Eigen::Vector3f light_dir = light_vec.normalized();

        // 漫反射
        Eigen::Vector3f diffuse = kd.cwiseProduct(light.intensity / (r * r)) * std::max(0.0f, normal.dot(light_dir));

        // 高光反射
        // 计算从表面点到观察者的向量
        Eigen::Vector3f view_dir = (eye_pos - point).normalized();
        // 计算半程向量
        Eigen::Vector3f halfVector = (light_dir + view_dir).normalized();
        Eigen::Vector3f specular = ks.cwiseProduct(light.intensity / (r * r)) * std::pow(std::max(0.0f, normal.dot(halfVector)), p);

        result_color += (diffuse + specular + ka.cwiseProduct(amb_light_intensity));
    }

    return result_color * 255.f;
}

这里边环境光是对于每个光源自带的么，为什么每个光源都要计算一次，而不是全局计算一次，有无懂哥？

纹理颜色视为公式中的 kd

根据插值出来的纹理坐标为每个像素提供对应在纹理图片中的颜色，与上一步区别就是漫反射系数换成了纹理颜色

Eigen::Vector3f texture_fragment_shader(const fragment_shader_payload& payload)
{
    Eigen::Vector3f return_color = {0, 0, 0};
    if (payload.texture)
    {
        // TODO: Get the texture value at the texture coordinates of the current fragment
        return_color = payload.texture->getColor(payload.tex_coords.x(),payload.tex_coords.y());

    }
    Eigen::Vector3f texture_color;
    texture_color << return_color.x(), return_color.y(), return_color.z();

    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = texture_color / 255.f;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = texture_color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    Eigen::Vector3f result_color = {0, 0, 0};

    for (auto& light : lights)
    {
        // TODO: For each light source in the code, calculate what the *ambient*, *diffuse*, and *specular*
        // components are. Then, accumulate that result on the *result_color* object.
        // 计算点到光源的向量
        Eigen::Vector3f light_vec = light.position - point;
        // 计算点到光源的距离
        float r = light_vec.norm();
        // 归一化从点到光源的向量
        Eigen::Vector3f light_dir = light_vec.normalized();

        // 漫反射
        Eigen::Vector3f diffuse = kd.cwiseProduct(light.intensity / (r * r)) * std::max(0.0f, normal.dot(light_dir));

        // 高光反射
        // 计算从表面点到观察者的向量
        Eigen::Vector3f view_dir = (eye_pos - point).normalized();
        // 计算半程向量
        Eigen::Vector3f halfVector = (light_dir + view_dir).normalized();
        Eigen::Vector3f specular = ks.cwiseProduct(light.intensity / (r * r)) * std::pow(std::max(0.0f, normal.dot(halfVector)), p);

        result_color += (diffuse + specular + ka.cwiseProduct(amb_light_intensity));

    }

    return result_color * 255.f;
}

Bump mapping

源码给了一个示例来参考通过扰动表面法线方向‌（而非实际修改几何形状）来制造光照上的明暗变化按照上述代码对传进来的像素的法线进行处理，最后的颜色就是法线值

    float x = normal.x();
    float y = normal.y();
    float z = normal.z();
    Eigen::Vector3f t{ x * y / std::sqrt(x * x + z * z), std::sqrt(x * x + z * z), z*y / std::sqrt(x * x + z * z) };
    Eigen::Vector3f b = normal.cross(t);
    Eigen::Matrix3f TBN;
    TBN <<  t.x(), b.x(), normal.x(),
            t.y(), b.y(), normal.y(),
            t.z(), b.z(), normal.z();
    float u = payload.tex_coords.x();
    float v = payload.tex_coords.y();
    float w = payload.texture->width;
    float h = payload.texture->height;
    float dU = kh * kn * (payload.texture->getColor(u + 1 / w , v).norm() - payload.texture->getColor(u, v).norm());
    float dV = kh * kn * (payload.texture->getColor(u, v + 1 / h).norm() - payload.texture->getColor(u, v).norm());
    Eigen::Vector3f ln{-dU, -dV, 1};
    Eigen::Vector3f result_color = (TBN * ln).normalized();

完整代码如下

Eigen::Vector3f bump_fragment_shader(const fragment_shader_payload& payload)
{

    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;


    float kh = 0.2, kn = 0.1;
    // 这个地方是为了后面用局部坐标系，让n始终朝向001，课上讲过
    float x = normal.x();
    float y = normal.y();
    float z = normal.z();
    Eigen::Vector3f t{ x * y / std::sqrt(x * x + z * z), std::sqrt(x * x + z * z), z*y / std::sqrt(x * x + z * z) };
    Eigen::Vector3f b = normal.cross(t);
    Eigen::Matrix3f TBN;
    TBN <<  t.x(), b.x(), normal.x(),
            t.y(), b.y(), normal.y(),
            t.z(), b.z(), normal.z();
    float u = payload.tex_coords.x();
    float v = payload.tex_coords.y();
    float w = payload.texture->width;
    float h = payload.texture->height;
    float dU = kh * kn * (payload.texture->getColor(u + 1 / w , v).norm() - payload.texture->getColor(u, v).norm());
    float dV = kh * kn * (payload.texture->getColor(u, v + 1 / h).norm() - payload.texture->getColor(u, v).norm());
    Eigen::Vector3f ln{-dU, -dV, 1};
    Eigen::Vector3f result_color = (TBN * ln).normalized();
    return result_color * 255.f;
}

displacement mapping

这种应用层面的东西目前不是很想深究，不过它比bump mapping多的就是它是真的会修改三角形位置

Eigen::Vector3f displacement_fragment_shader(const fragment_shader_payload& payload)
{

    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    float kh = 0.2, kn = 0.1;

    float x = normal.x();
    float y = normal.y();
    float z = normal.z();
    Eigen::Vector3f t{ x * y / std::sqrt(x * x + z * z), std::sqrt(x * x + z * z), z*y / std::sqrt(x * x + z * z) };
    Eigen::Vector3f b = normal.cross(t);
    Eigen::Matrix3f TBN;
    TBN <<  t.x(), b.x(), normal.x(),
            t.y(), b.y(), normal.y(),
            t.z(), b.z(), normal.z();
    float u = payload.tex_coords.x();
    float v = payload.tex_coords.y();
    float w = payload.texture->width;
    float h = payload.texture->height;
    float dU = kh * kn * (payload.texture->getColor(u + 1 / w , v).norm() - payload.texture->getColor(u, v).norm());
    float dV = kh * kn * (payload.texture->getColor(u, v + 1 / h).norm() - payload.texture->getColor(u, v).norm());
    Eigen::Vector3f ln{-dU, -dV, 1};
    //与凹凸贴图的区别就在于这句话
    point += (kn * normal * payload.texture->getColor(u , v).norm());
    normal = (TBN * ln).normalized();
    Eigen::Vector3f result_color = {0, 0, 0};

    for (auto& light : lights)
    {
        Eigen::Vector3f l = (light.position - point).normalized();      // 光
        Eigen::Vector3f v = (eye_pos - point).normalized();		        // 眼
        Eigen::Vector3f h = (l + v).normalized();                       // 半程向量
        double r_2 = (light.position - point).dot(light.position - point);
        Eigen::Vector3f Ld = kd.cwiseProduct(light.intensity / r_2) * std::max(0.0f, normal.dot(l));    //cwiseProduct()函数允许Matrix直接进行点对点乘法,而不用转换至Array。
        Eigen::Vector3f Ls = ks.cwiseProduct(light.intensity / r_2) * std::pow(std::max(0.0f, normal.dot(h)), p);
        result_color += (Ld + Ls);
    }
    Eigen::Vector3f La = ka.cwiseProduct(amb_light_intensity);
    result_color += La;
    return result_color * 255.f;
}

GAMES101 现代计算机图形学入门 Assignment2

Sun, 19 Oct 2025 13:22:24 +0800

作业介绍

上节课通过MVP+视口变换把三角形三个顶点从空间坐标转移到了屏幕上的坐标，并绘制三角形，这节课将通过光栅化技术，构造实心的三角形

视口变换？

说是上节课实现了这个，但是任务中并没有，源码中已经实现了视口变换，这里就看一下它如何实现的

        //Viewport transformation
        for (auto & vert : v)
        {
            vert.x() = 0.5*width*(vert.x()+1.0);
            vert.y() = 0.5*height*(vert.y()+1.0);
            vert.z() = vert.z() * f1 + f2;
        }

以x举例，NDC坐标下x的范围为[-1,1]，首先+1，将范围固定到[0,2],下一步乘0.5乘width,就固定到了[0,width]的范围，也就是屏幕的范围。y坐标同理（y坐标可能需要反转，因为屏幕坐标y可能是向下走的）。下面看对z坐标的变化。这里我其实不是理解在干什么，下边是deepseek的解释：视口变换的 ‌z坐标处理‌ 通常是将归一化设备坐标（NDC）的z值映射到深度缓冲的合法范围（如[0,1]）。然而，在你的代码中，f1和f2的设置（f1 = 24.95, f2 = 25.05）表明z坐标被映射到了‌非标准的线性深度范围‌，而非常规的[0,1]

1
2
3

float f1 = (50 - 0.1) / 2.0;
float f2 = (50 + 0.1) / 2.0;
vert.z() = vert.z() * f1 + f2;

源码分析

这里只需要看一下rst::rasterizer::draw(pos_buf_id pos_buffer, ind_buf_id ind_buffer, col_buf_id col_buffer, Primitive type)这个函数干了什么

void rst::rasterizer::draw(pos_buf_id pos_buffer, ind_buf_id ind_buffer, col_buf_id col_buffer, Primitive type)
{
    auto& buf = pos_buf[pos_buffer.pos_id];
    auto& ind = ind_buf[ind_buffer.ind_id];
    auto& col = col_buf[col_buffer.col_id];

    float f1 = (50 - 0.1) / 2.0;
    float f2 = (50 + 0.1) / 2.0;
	// MVP矩阵
    Eigen::Matrix4f mvp = projection * view * model;
    // 对每个顶点进行MVP+视口变换+设置颜色
    for (auto& i : ind)
    {
    	// 定义一个三角形，设置它的属性，此时设置的已经是在屏幕上的三角形
        Triangle t;
        Eigen::Vector4f v[] = {
                mvp * to_vec4(buf[i[0]], 1.0f),
                mvp * to_vec4(buf[i[1]], 1.0f),
                mvp * to_vec4(buf[i[2]], 1.0f)
        };
        //Homogeneous division
        for (auto& vec : v) {
            vec /= vec.w();
        }
        //Viewport transformation
        for (auto & vert : v)
        {
            vert.x() = 0.5*width*(vert.x()+1.0);
            vert.y() = 0.5*height*(vert.y()+1.0);
            vert.z() = vert.z() * f1 + f2;
        }

        for (int i = 0; i < 3; ++i)
        {
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
        }

        auto col_x = col[i[0]];
        auto col_y = col[i[1]];
        auto col_z = col[i[2]];

        t.setColor(0, col_x[0], col_x[1], col_x[2]);
        t.setColor(1, col_y[0], col_y[1], col_y[2]);
        t.setColor(2, col_z[0], col_z[1], col_z[2]);
		// 这里就是要实现的函数，传入的就是三角形
        rasterize_triangle(t);
    }
}

光栅化

整体流程就是计算这个三角形需要涉及到哪些像素点，并对这些像素点设置属性，最后所有需要处理的像素点信息都存到了一个buffer中，调Opencv相关功能把它画出来，这里需要干的事就是给每个像素需要的东西计算出来

bounding box

画一个三角形没必要遍历所有像素点来找属于该三角形的像素点，只需要线框选一个范围，在这个范围内进行遍历即可，最简单的办法就是找三个坐标最左最右最上最下四个标记点，框选即可，具体做法如下（取值时还会向外扩展一个像素，这是为了‌确保覆盖所有可能被三角形覆盖的像素，因为浮点数本来就是不准确的）

    int minX = std::floor((std::min({t.v[0].x(),t.v[1].x(),t.v[2].x()}))-0.5);
    int maxX = std::ceil(std::max({t.v[0].x(),t.v[1].x(),t.v[2].x()})+0.5);
    int minY = std::floor(std::min({t.v[0].y(),t.v[1].y(),t.v[2].y()})-0.5);
    int maxY = std::ceil(std::max({t.v[0].y(),t.v[1].y(),t.v[2].y()})+0.5);

如何判定像素点在三角形内部

通过上一步已经确定了三角形的大概范围，下一步就是需要判断具体哪些像素确实需要处理，实现思路主要是通过叉乘计算，连接三角形顶点和像素点形成三个向量，用这三个向量分别叉乘三角形的三条边，如果得到的向量方向相同，说明像素点在三角形内部。具体实现如下，写的比较繁琐，但是好理解

static bool insideTriangle(int x, int y, const Vector3f* _v)
{   
    // TODO : Implement this function to check if the point (x, y) is inside the triangle represented by _v[0], _v[1], _v[2]
    // 设置三条边对应的向量
    Eigen::Vector3i triangleEdgeVector1(_v[1].x()-_v[0].x(),_v[1].y()-_v[0].y(),0);
    Eigen::Vector3i triangleEdgeVector2(_v[2].x()-_v[1].x(),_v[2].y()-_v[1].y(),0);
    Eigen::Vector3i triangleEdgeVector3(_v[0].x()-_v[2].x(),_v[0].y()-_v[2].y(),0);

    Eigen::Vector3i p1(x-_v[0].x(),y-_v[0].y(),0);
    Eigen::Vector3i p2(x-_v[1].x(),y-_v[1].y(),0);
    Eigen::Vector3i p3(x-_v[2].x(),y-_v[2].y(),0);

    bool flag1 = triangleEdgeVector1.cross(p1).z() > 0;
    bool flag2 = triangleEdgeVector2.cross(p2).z() > 0;
    bool flag3 = triangleEdgeVector3.cross(p3).z() >0;
    if(flag1 == flag2 && flag2 == flag3) return true;
    return false;
}

像素点处理

经过上一步，已经确定了哪些像素点在三角形内部，下来就是对这些像素点进行处理，首先确定需要处理哪些东西

z坐标（因为从摄像机看，进处的物体会挡住远处的物体，所以只需要渲染离屏幕更近的颜色，实现就是用z-buffer技术，其实本质就是缓存每个像素点当前最近的距离，如果遍历的像素点比buffer还近就替换他）
颜色

颜色处理

如果你看到下节课，颜色是通过三个顶点颜色进行插值获得的，这节作业还没用到，看源码，每个三角形的三个顶点都被设置成了同一个颜色，所以这里只需要把颜色设置为顶点颜色即可

Z坐标处理

按照学习的内容，z坐标应该为三个顶点z坐标插值得到，但是这里并不是，并且算法也是直接给出，并不是课程内容。z坐标计算如下，computeBarycentric2D用来获取当前像素点的重心坐标，下节课会讲到的。至于z坐标的处理方式，用到一个透视校正为什么需要透视校正而不是直接插值，我目前还不懂，问的ai？‌ 在透视投影中，物体在近大远小的效果下，其深度（z 值）的分布是 ‌非线性的‌。若直接在屏幕空间线性插值深度，会导致以下问题：

远处物体的深度插值过于密集，近处过于稀疏。
深度测试（Z-test）不准确，产生渲染错误（如 Z-fighting）。

所以这里就直接调用了，不研究了

auto[alpha, beta, gamma] = computeBarycentric2D(i, j, t.v);
float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
z_interpolated *= w_reciprocal;

完整代码

⚠️：z-buffer缓存记得处理

void rst::rasterizer::rasterize_triangle(const Triangle& t) {
    // 三个顶点的齐次坐标
    auto v = t.toVector4();
    // iterate through the pixel and find if the current pixel is inside the triangle   取边界时要向外扩展一个像素
    int minX = std::floor((std::min({t.v[0].x(),t.v[1].x(),t.v[2].x()}))-0.5);
    int maxX = std::ceil(std::max({t.v[0].x(),t.v[1].x(),t.v[2].x()})+0.5);
    int minY = std::floor(std::min({t.v[0].y(),t.v[1].y(),t.v[2].y()})-0.5);
    int maxY = std::ceil(std::max({t.v[0].y(),t.v[1].y(),t.v[2].y()})+0.5);
    for(int i = minX; i<=maxX;i++){
        for(int j = minY;j<=maxY;j++){
            // 如果划分到三角形内
            if(insideTriangle(i,j,t.v)){
                // If so, use the following code to get the interpolated z value.
                auto[alpha, beta, gamma] = computeBarycentric2D(i, j, t.v);
                float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                z_interpolated *= w_reciprocal;
                if(z_interpolated < depth_buf[get_index(i,j)]){
                    // TODO : set the current pixel (use the set_pixel function) to the color of the triangle (use getColor function) if it should be painted.
                    set_pixel(Vector3f(i,j,z_interpolated),t.getColor());
                    depth_buf[get_index(i,j)] = z_interpolated;
                }
            }
        }
    }
}

GAMES101 现代计算机图形学入门 Assignment1

Sun, 19 Oct 2025 13:21:54 +0800

作业介绍

给出三个点的空间坐标，通过MVP矩阵将点投影到平面上，并绘制出三角形

MVP变换

Model Transformation（模型变换）：将物体从局部坐标系（Local Space）转换到世界坐标系（World Space），通过以下操作实现：

平移（Translate）‌：调整物体在世界空间中的位置；
旋转（Rotate）‌：改变物体的朝向；
缩放（Scale）‌：控制物体的大小‌

View Transformation（视图变换）：将摄像机移动原点‌；形成以摄像机为中心的视角 ‌调整摄像机朝向‌：默认摄像机看向-Z轴方向，Y轴为垂直向上方向； ‌同步变换物体‌：保持物体与摄像机的相对位置关系‌

Projection Transformation（投影变换）：

将观察空间中的三维物体投影到二维裁剪空间（Clip Space），分为两种类型：

‌正交投影（Orthographic Projection）‌

保持物体平行性，无近大远小效果。‌

透视投影（Perspective Projection）‌

模拟人眼视觉效果，产生近大远小的深度感。

作业代码逻辑解析

main函数分析

int main(int argc, const char** argv)
{
	// 旋转角度
    float angle = 0;
    bool command_line = false;
    std::string filename = "output.png";
    if (argc >= 3) {
        command_line = true;
        angle = std::stof(argv[2]); // -r by default
        if (argc == 4) {
            filename = std::string(argv[3]);
        }
        else
            return 0;
    }
    rst::rasterizer r(700, 700);
	// 摄像机位置
    Eigen::Vector3f eye_pos = {0, 0, 5};
	// 三角形的三个顶点
    std::vector<Eigen::Vector3f> pos{{2, 0, -2}, {0, 2, -2}, {-2, 0, -2}};
	// 顶点顺序
    std::vector<Eigen::Vector3i> ind{{0, 1, 2}};
	// 顶点坐标和顺序加载到光栅器
    auto pos_id = r.load_positions(pos);
    auto ind_id = r.load_indices(ind);
    int key = 0;
    int frame_count = 0;
    if (command_line) {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);
        // 设置MVP三个矩阵
        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));
		// 画出图形
        r.draw(pos_id, ind_id, rst::Primitive::Triangle);
        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::imwrite(filename, image);
        return 0;
    }
    while (key != 27) {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);
        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));
        r.draw(pos_id, ind_id, rst::Primitive::Triangle);
        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::imshow("image", image);
        key = cv::waitKey(10);
        std::cout << "frame count: " << frame_count++ << '\n';
        if (key == 'a') {
            angle += 10;
        }
        else if (key == 'd') {
            angle -= 10;
        }
    }
    return 0;
}

这次作业主要就是实现MVP矩阵，一部分代码就是把MVP矩阵装进光栅化器中。所以别的代码已经没必要看了，在下次作业中再细看

模型变换：get_model_matrix(float rotation_angle)

实现model变换，可以进行缩放、平移、旋转，作业这里只需要进行绕z轴的旋转，在上次作业中，上一篇博客已经提到了如何进行三位物体的旋转，绕各个轴都有对应的变换矩阵，直接左乘到坐标向量即可。

Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();
    Eigen::Matrix4f rotationMatrix;
    rotationMatrix << cos(rotation_angle/180* MY_PI),-sin(rotation_angle/180* MY_PI),0,0, sin(rotation_angle/180*MY_PI),cos(rotation_angle/180* MY_PI),0,0,0,0,1,0,0,0,0,1;
    return rotationMatrix;
}

视图变换：get_view_matrix(Eigen::Vector3f eye_pos)

本次作业并没有让完成这部分，已经被写好了，这里写分析一下代码，视图变换主要作用就是如何把摄像机放在世界远点来进行观察，main函数中已经定义了Eigen::Vector3f eye_pos = {0, 0, 5};

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos)
{
    Eigen::Matrix4f view = Eigen::Matrix4f::Identity();
    Eigen::Matrix4f translate;
    translate << 1, 0, 0, -eye_pos[0], 0, 1, 0, -eye_pos[1], 0, 0, 1,
        -eye_pos[2], 0, 0, 0, 1;
    view = translate * view;
    return view;
}

其中可以看出视图变换的矩阵为，说明只进行了平移操作，摄像机的向上方向和看的方向都为默认。为其他所以物体的坐标都左乘这个矩阵，就实现了所有物体以摄像机为原点的位置坐标

投影变换：get_projection_matrix(float eye_fov, float aspect_ratio, float，zNear, float zFar)

本节图片来自https://zhuanlan.zhihu.com/p/620496517

在给定的参数描述下，就可以确定整个需要投影的空间位置，如下图所示，目标就是把这个立方体区域转换到NDC坐标第一步的目标是将该区域变为长方体区域，在进行转换时，离得远的物体就会相应的变小

从+x向-x方向看结构如下图，压缩比例应该为n/z,所以 y = ny/z,x同理设计一个变换矩阵左乘后同时除以z，根据齐次坐标的性质，仍表示同一个坐标，这样每个坐标的x，y都处理好了，就剩下z未处理，其中包含a,b,c,d4个未知数

z坐标获得与上次作业旋转公式推导的方法相似，取几个在变化过程中不会变z的坐标来求解近平面上（$x^1,y^1,n,1$）与中心点（$0,0,n,1$），远平面（$x^2,y^2,f,1$）和中心点$0,0,f,1$），通过这些点，以及全部近面和远面中心点z不会变这些信息，可以算出a,b,c,d如何取值，最终得到的变换矩阵为但是并没有结束，此时以及得到如下图所示的情况，下一步还需要把空间移动到NDC，就是将长方体变为坐标值在 $[-1,1]^3$ 的立方体。（从这里开始，其实就是正交投影的过程）以上图坐标为例，平移的方向和距离用t表示很好理解，就是把整个空间的中心挪到坐标原点

$$ t = \left( -\frac{l + r}{2},\ -\frac{b + t}{2},\ -\frac{n + f}{2} \right) $$

下一步就是把所有坐标都进行单位化，就是把长方体的变长都变成1，对坐标进行统一缩小，缩小矩阵如下结合上边的平移后得到正交投影的变化矩阵结合透视和正交的矩阵就可以得到最终的投影矩阵

代码实现

代码来自https://blog.csdn.net/qq_41265365/article/details/124229095，懒得算了，就是把三个矩阵合并成了一个写的

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    Eigen::Matrix4f Mpersp;
    float fovY = eye_fov*MY_PI/180.0;
    float cota = 1.f/tanf(fovY/2);
    float zD = zNear-zFar;
    Mpersp << -cota/aspect_ratio, 0, 0, 0,
            0, -cota, 0, 0,
            0, 0, (zNear+zFar)/zD, -2*zNear*zFar/zD,
            0, 0, 1, 0;
    return Mpersp;
}

GAMES101 现代计算机图形学入门 Assignment0

Sun, 19 Oct 2025 13:14:45 +0800

Assignment0

前边一大半主要是安装虚拟机保证运行一致，这里就跳过了，到实际的问题：点旋转和平移

使用Eigen表示向量

点$P=(2,1)$ 表示为 Eigen::Vector3f point(2, 1, 1);，最后一位是用于齐次坐标，为1时表示是一个点

点旋转矩阵

**二维点旋转矩阵**比较简单，推导主要是通过设A、B、C、D四个变量，找两个特殊点求解

三维点旋转矩阵可分解为分别绕三个轴旋转注意：上述提到的公式都是按照逆时针旋转的矩阵，顺时针相当于逆时针旋转$-θ$，本题只涉及二维点旋转

平移

平移可以简单通过加法实现，但是如果想统一格式，用一个矩阵表示点的所有变换操作，就需要用到齐次坐标，利用齐次坐标表示转换矩阵，可以把旋转缩放平移同时塞到一个矩阵中。下图为只进行平移操作的齐次转换矩阵旋转矩阵的齐次坐标表达为：平移 (1,2)，只需要把tx换为1，ty换为2，得到平移矩阵的齐次坐标表达为：

旋转和平移组合

得到最终旋转+平移的矩阵为：

代码实现

std::sin和std::cos的参数为弧度制，用角度/180*Π得到。例如cos45°可以表达为std::cos(45.0/180.0*acos(-1)),其中acos(-1)就等于Π

    // 作业0实现
    std::cout << "作业0实现" << std::endl;
    Eigen::Vector3f point(2, 1, 1);
    Eigen::Matrix3f rotate;
    std::cout << "转换矩阵" << std::endl;
    rotate <<  std::cos(45.0/180.0*acos(-1)),-std::sin(45.0/180.0*acos(-1)),1,std::sin(45.0/180.0* acos(-1)),std::cos(45.0/180.0*acos(-1)),2,0,0,1;
    std::cout << rotate << std::endl;
    Eigen::Vector3f res = rotate*point;
    std::cout << "结果" << std::endl;
    std::cout << res << std::endl;

GAMES101 现代计算机图形学入门 Camera Lenses Light Fields Color and Perception

Sun, 19 Oct 2025 12:49:13 +0800

Cameras

小孔成像小孔成像是可以拍照的，但是没有景深效果

视场 Field of View (FOV)

传感器的高度与传感器和小孔之间的距离决定FOV的大小通常都是固定传感器尺寸，控制焦距来控制FOV 不同焦距下的视场

曝光 Exposure

决定曝光的变量在摄像机中决定曝光的变量第一行是光圈、第二行是快门速度、第三行是IOS设置 IOS的介绍光圈，N越大直径越小快门因为快门打开需要时间，那高速运动物体就会出问题

镜头

理想情况焦距物距像距的关系景深就是像距没有落到感光元件上这节主要是科普摄像机的东西

光场 Light Field

人眼前放一块幕布，投影这个图形，对人来说看到的是一样的

全光函数

用全光函数表示人能看到的东西从简单来看引入颜色引入时间，变为电影引入位置。全息电影用七个维度衡量看到的所有东西，光场从这里开始

从任意一个位置看向任何一个位置，都可以从光场中提取光的信息并不需要知道光场内是什么物体，只需要光场的信息，在盒子表面任何一点任何一个位置的信息

颜色 Color

GAMES101 现代计算机图形学入门 Animation/Simulation

Sun, 19 Oct 2025 12:48:02 +0800

一些科普

Keyframe Animator

Physical Simulation

利用物理公式来模拟

质点弹簧系统 Mass Spring Rope

下面开始描述这个系统胡克定律描述弹簧或弹性体所受的回复力 F 与形变量 x 成正比， $k_s$是劲度系数，但是弹簧本身也有长度考虑弹簧原始长度，$\frac{b - a}{|b - a|}$这个向量用来表示方向，但问题是这样写，弹簧一旦拉开就不会不停的运动下去（动能和势能相互转化），所以还需要引入摩擦力引入摩擦力之前先引入一些符号表示位置、速度、加速度给物体一个相反与速度方向的力，但还有问题，这样会导致所有的运动都停下来，假设AB两个物体同步向右走，他俩都有速度，但相对之间没有速度，所以应该没摩擦力，但是用下面的公式，只要物体有速度，就会受到摩擦力而停止我们在逐渐完善弹簧系统，摩擦力应该跟着物体AB的相对运动而产生，下图用两个物体速度差来表示相对速度，另外还需要考虑这个速度差是沿着弹簧方向才行，所以点乘$\frac{b - a}{|b - a|}$来投影到ba方向下面看一些弹簧结构模型的行为是由结构连接来决定的，下面看如果一块布这样设计，很明显是不合理的，图中展示了2种原因（布可以抵抗切变力但这个结构不行，布会对抗对折）先来改进切变，加入蓝色弹簧来抵抗再加另外一个方向，但不能解决第二个问题最终版

粒子系统

运动学 Forward Kinematics

已知角度求P的位置

逆运动学Inverse Kinematics

已知P的位置求角度

Rigging

Motion Capture

![请添

第二次课 cont.

Single Particle Simulation

首先学习单粒子运动，假设粒子的运动由一个速度向量场决定，速度向量场的速度由位置和时间决定要计算粒子在某个时间的位置，需要解下图所示的常微分方程用欧拉公式来解微分方程，用上一步的数据来计算下一步的位置欧拉方程的误差与步长大小有关欧拉方程的不稳定性，在一个螺旋速度场中，本来应该旋转，但是不管步长选的多小都一定会飞出去。第二幅图的运动模拟也不合理。如何解决呢，有人提出了中点法，先用欧拉算出a点，但不用a点，取中点b，考虑b点的速度，应用b点的速度回去重新算欧拉进一步，有人用中点思想，算两次欧拉方法，不是回原点重新算，而是去中点算，如果算出来和第一次算出来差不多就不算了，说明步长够小了还有隐式的欧拉方法 Runge-Kutta Families Position-Based / Verlet Integration 刚体（不会发生形变）模拟

流体模拟 Fluid Simulation

这门课的动画模拟更多都是在科普。

GAMES101 现代计算机图形学入门 Ray Tracing

Sun, 19 Oct 2025 12:43:12 +0800

Shadow Mapping

如果使用光栅化，对一个像素shading时考虑光源，考虑摄影机位置，但是没有考虑模型其他位置对该位置的影响，因为在光源与该像素点之间有别的东西挡住，那光源就会被挡住，形成阴影。shading解决不了阴影问题该算法为图像空间算法。生成阴影并不需要模型的几何位置信息，当前该算法还是存在走样现象该算法的关键思想是：一个点不在阴影的前提是摄像机能看见这个点，并且光源能看见这个点算法步骤：

Render from Light：把光源当作摄像机，做一遍光栅化，从而得到光源会看到什么东西，只需要记录看到点的深度
从设定好的摄像机位置去真正的渲染场景得到摄像机视角的深度Buffer，如下图橙线下的点两次都看见了，而红线上的点只有光源嫩看见，摄像机是看不见的

举一个实际的例子上图左上角有一个点光源，下图则展示了从点光源看向模型的样子当然这一步只需要记录每个点的深度最终再回到摄像机的视角，绿色就是摄像机和光源都能看见的位置，不是绿色的位置就是阴影的位置 shadow maps的问题首先解释一下硬软阴影区别，看两幅图就能理解

硬阴影：
软阴影：产生软阴影是因为光源具有体积，导致，有的地方完全看不到光源（本影, Umbra），有的地方能看到一部分光源（半影，Penumbra）。所以阴影的边缘会有过渡的情况，从而产生软阴影，就像上图中太阳与地球的示意一样（全日食与半日食）。

Ray Tracing

Why Ray Tracing

为什么需要光线追踪？

光栅化不能很好地处理全局效果，如软阴影（光栅化可通过Shadow Mapping实现硬阴影（老师说目前也有技术实现软），由于缺乏全局信息，需要多次计算，如上一节提到的把光源当作摄像机先计算一遍深度缓存）。另外是当光多次弹射时，光栅化不好处理
光栅化很块，但是质量低
光线追踪很准确，光栅化主要用于实时，光线追踪用于离线

图形学对光线的假设

光线沿直线传播
光线和光线不会碰撞
光线从光源出发经过各种反射到达人眼（光路可逆，光线追踪利用的就是光路的可逆性）

Ray Casting 光线投射

如下图所示，摄像机连出一根线到屏幕的一个像素点，点到达物体表面时，该点也能连接到光源，就可以计算出这一点的光的强度来进行着色具体例子如下图从眼睛发出线打到一个像素，紧接着达到场景中的某个位置上（eye ray），只考虑与场景最近的一个交点，所以后边的虚线就不考虑了（在作业5中可知，生成eve ray的流程：屏幕是Raster Space（光栅空间），为了找到摄像机到每个栅格真正代表的空间坐标，需要将Raster Space还原成NDC space再进一步还原成）紧接着连接一条线到光源位置（shadow ray），有了法线、入射方向、观察方向，就可以利用光照模型来计算着色了（例如 Blinn Phong model）

Recursive Ray Tracing（Whitted风格）

上一节的模型仍然只考虑了光线只反射一次的情况，还是从上一节的图开始，假设eye ray打到的是一个玻璃球，可能会发生折射和反射，每一个弹射点都进行着色计算（都连接到光源），每个着色都会被加到这个像素点的着色上去。里边具体的技术点会在后边讲到

Ray-Surface Intersection （隐式几何与光线求交）

首先用数学定义一下光线：光线被定义为由起点和方向的向量，点光源的描述如下，这样定义的目的是将光线与物体求交点的问题转化为求t值的问题从简单的开始，光线如何与球求交点，其实就是点P在球面上，也在光线上，联立即可最终可以解出来t的大小，t取小的一个，表示第一个交点

Ray Intersection With Triangle Mesh（显示几何与光线求交）

由上边内容可知，给出一个隐式的几何，求光线与几何的交点，就是联立后求t的值，那显式的表达呢？如下图，如何判断光线与mesh有交点呢？一个一个三角形求光线与三角形的交点么？太慢了虽然太慢了，但是还是要先学习一下怎么求一个光线与三角形的交点。基本思路就是先找出光线与三角形所在平面的交点，之后判断这个交点是不是在三角形内部。首先来看一下平面如何定义，一个向量和一个点就可以定义一个平面如何判断一个点P是否在平面上呢？只要下图两点形成的向量与平面法向量垂直即可所以又回到了上一节的联立，点P在平面上，也在光线上，进行联立求解，最后得到光线与平面的交点，再判断点是否在三角形内，就可以得到光线与三角形的交点。 Möller Trumbore Algorithm 那有没有方法直接判断呢？如果光线与三角形有交点，那这个交点就可以用重心坐标表示，直接建立如下等式，用克莱默法则求解方程组就可以直接求出来（三个未知数，三个方程，所以是可以解出来的）

Accelerating Ray-Surface Intersection（加速求交方法）

现在已经知道了光线与三角形求交，那如何判断光线与mesh的交点呢。一个一个三角形遍历太慢了。如下图三角形实在太多了。这就引入了Accelerating Ray-Surface Intersection 先介绍一个概念 Bounding Volumes，如果光线都打不到包围盒，更打不到mesh了想象一下一个box相对的两个面是一个无限大的平面（称为对面），box就是三个对面的交集，通常使用的是Axis-Aligned Bounding Box (AABB) (轴对⻬包围盒)，这个东西就是这个盒子的边都是和坐标轴对齐的，简化计算。下面就来看下光线与包围盒的求交问题（与包围盒有交点，才去考虑与包围盒内部的Mesh求交）先从二维平面情况下看, $x_0$和$x_1$是一个对面，$y_0$和$y_1$是一个对面从$x_0$和$x_1$对面上看可以求出两个交点从$y_0$和$y_1$对面上看也可以求出两个交点求交集后，就求出光线进入和出去盒子的时间

从三维情况下开，3组对面的时间t进行求交集，当进入时间小于离开时间，就是有交点另外，用上诉算法算出来的t可能是负数，用下图进行处理，总结来说，进入小于退出，退出大于0即可最后解释一下为什么要用AABB盒，光线与平面求交点是有公式的，如下图General。对准坐标轴后计算更容易，下图为计算量对比。

Uniform Spatial Partitions (Grids) 均匀网格

通过上节的加速算法，我们已经知道如果把物体包在盒子里，先判断与盒子求交，再考虑与盒子内物体求交，但采用包围盒并不一定会提升性能，例如下面两种情况

整个场景只有一个极其复杂的单一人物模型，那么只对这一个物体做包围盒的话，相当于对效率没有任何提升
整个场景充斥着大量的细小模型，如草，花之类的，每个模型可能只有很少的面，如果此时对每个物体求包围盒，得到的包围盒数量会相当之多，对于光线追踪效率来说效率提升有限。

所以还要对包围盒进行进一步的处理首先来进行预处理 4. 找到包围盒 5. 画出格子（盒子内部再分成很多的格子） 6. 标记有物体的格子预处理完成后，光线从一侧打进来，只会处理被标记的格子，如果有标记，就算一下是否有交点，这就避免了和包围盒中所有的物体求交，这种方法主要就是解决了，包围盒中有多个物体，只要光线打到了具体一个范围时，才判断是否有交点。 Uniform Grids表现比较好的场景如下但分布特别不均匀的场景，就不适合用上述方法

Spatial Partitions 不均匀的网格

在物体比较少地方没必要用统一大小的格子，那如何进行场景划分呢，有如下3中方式第一种Oct-Tree，也就是八叉树，每次将空间分为8个相等的部分，再递归的对子空间进行划分。因为图中是2维例子，所以只划分了4部分。当划分的子空间足够小或是空间中三角形面的数量很少的时候会停止划分。这种方法的显著缺点是，随着维度的上升划分的空间数量会呈指数级增长。

第二种KD-Tree，其每次将空间划分为两部分，且划分依次沿着 x − a x i s ， y − a x i s ， z − a x i s x-axis，y-axis，z-axisx−axis，y−axis，z−axis （保持最规整的空间区域），如图中所示，第一次横着将2维空间分为上下，第二次再竖着将上下两个子空间分别划分为左右部分，依次递归划分，终止条件与八叉树类似。

第三种BSP-Tree，其与KD-Tree类似，唯一不同的是划分不再沿着固定一轴，可以任意方向划分，缺点自然是划分的空间没有规则性，求交困难。在与轴对齐更好计算的场景下不适用

本节知识主要以KD-Tree来建立给定一个场景，先建立KD-Tree，做好加速结构，再进行光线求交。下面从预处理开始介绍，竖直先来一刀水平再来一刀，蓝绿都需要做，这里演示只砍绿色再来两刀明白了KD-Tree的流程之后，介绍一下KD-Tree的数据结构实际的三角形object只存在叶子结点上下一步介绍光线来了之后如何与KD-Tree交互，如下图的这条光线首先判断与最大的盒子是否有交点，如下图所示是有的紧接着判断A结点的子结点1是否有交点，此时发现确实有交点，1是叶子结点，那光线就必须和这个盒子里的物体进行计算求交之后又发现与右边也有交点，那么就需要继续看子结点子结点2也有交点，是叶子结点，那就得和2中所有物体求交，后续流程一样

Bounding Volume Hierarchy（BVH）

KD-Tree并不完美，缺点是判断包围盒与三角面的是否相交较难，因此划分的过程不是那么想象的简单，其次同一个三角面可能被不同的包围盒同时占有，这两个不同包围盒内的叶节点会同时存储这一个三角形面。 BVH不再通过场景进行划分，而是通过物体来划分，得到了广泛应用。首先把一个包围盒内的三角形组织成两部分，并对两部分三角形重新求包围盒，如下图之后重复操作，划分到一个叶子结点只有比如5个三角形就停止，这样一个三角形只会出现在一个包围盒里。避免了KD-Tree一个三角形可能出现在不同的叶子结点里的问题那如何进行结点划分呢？首先向KD-Tree学习，每次选一个x、y、z其中一个轴进行划分。技巧：每次都找最长的轴进行划分，例如场景在x轴上是一个长条，就利用x轴划分。如何分成两半呢（如何保证划分后两部分三角形数量差不多呢）？通过三角形的重心坐标，在x轴上排序（其实不用排序，有更好的找中位数算法叫快速旋转算法，可以在O(n)时间内找到中位数），就知道中间那个三角形是哪个了，这样就进行了划分。下来介绍光线与BVH求交的过程，用代码演示划分空间vs划分物体到这里，求交的内容就结束了

Basic Radiometry（辐射度量学）

在之前实现 Blinn-Phong模型时，光照强度I设置为10，但是10是什么呢？

whited-style光线追踪只考虑了光滑面的镜面反射与折射，并没有对漫反射的光线进行追踪，而是直接返回当前着色点颜色
在计算光源直接照射的贡献时，使用了Blinn-Phong模型，而Blinn-Phong模型本身就是一个不准确的经验模型，使用的这种模型的whited-style光线追踪自身自然也是不正确的

为此，更好的渲染模型路径追踪出现了，而在这之前，我们必须掌握一些辐射度量学的知识，它是对光照的一套测量系统和单位，能够准确的描述光线的物理性质。辐射度量学是物理上准确定义光照的方法。首先来引入一些概念

引入定义

Radiant Energy and Flux (Power) 辐射能量和辐射通量/功率

辐射能量就是光源射出来的电磁能量，单位为焦耳（功） Radiant flux(power) 辐射能量的基础之上除以时间，也就是单位时间的能量（功率、流明）在计算机图形学来看，主要关注一下三个东西

Radiant Intensity 辐射强度

从一个点光源发射的每单位立体角下的功率，光源向四面八方辐射能量，在单位立体角上的功率就是辐射强度那什么是立体角呢？首先2维下的角度就是弧度/半径，3维空间中立体角就是一块面积/半径的平方，立体角就是用来描述空间中角有多大，一个球体总的立体角就是4pi 下图描述了单位立体角。在微分下，形成的一个很小的面积的立体角，是一个微分立体角dw，计算公式如下最终可以得到辐射强度 = 辐射功率/4pi

Irradiance

每单位照射面积dA所接收到的power/flux 光源能量在距离上有r平方的衰减，可以用irradiance来解释，远处单位面积更大，按r平方衰减，Intensity并没有变化，单位角也没有变化，变化的是单位面积，进而影响了Irradiance

Radiance

Radiance是单位立体角、单位面积上的power Incident Radiance是到达表面的irradiance 在 per 立体角下 Exiting Radiance 是开表面辐射强度在per单位面积上最后看一下Irradiance和Radiance的关系

Irradiance是单位面积上的总能量
Radiance是总能量在单位立体角上的大小，就是在Irradiance上增加了方向性（radiance在方向上积分就是Irradiance）

BRDF

Bidirectional Reflectance Distribute Function 双向反射分布函数，在介绍完上边概念的定义后，可以这样理解光线的反射，一个微分面积元在接受到一定方向上的亮度后，再向不同方向把能量辐射出去，所谓BRDF就是描述一个从不同方向入射之后，反射光线分布情况的函数

下图为BRDF的方程，只需要两个参数入射光方向 ωi，反射光方向 ωr，函数值为反射光的radiance与入射光的irradiance的比值摄像机所在方向上的反射光，是由来自不同方向入射光线的irradiance经过反射得到的，不同方向上的入射光线的irradiance的贡献由BRDF函数决定但是入射光的radiance不仅仅来自光源，也可能是其他物体的反射光恰好反射到了该点，这是一个递归的过程进一步，如果这个点本身就会发光，需要额外加上这部分，最终的渲染方程为下图如何理解渲染方程呢？从反射方程来看，如果有多个光源，就把这些radiance进行累加如果有一个面光源，对这个面对应的立体角进行积分那么更进一步再在场景当中加入其它物体，使得物体之间发生光线交互之后是什么情况呢。如下图所示，可以把其它物体同样考虑成面光源，对其所占立体角进行积分即可，只不过对其它物体的立体角积分不像是面光源所有入射方向都有radiance，物体的立体角可能只有个别几个方向有入射的radiance（即多次物体间光线反射之后才恰好照射到着色点），其它方向没有，但本质上都可以视作是面光源。最终整理方程，只有入射和反射的radiance不知道，其他项都是知道的简化形式经过一系列变化后得到，L是所要求的反射光，E是自己的发光，K是一个算子最终可以得到最终最终整理成如下形式，E是自身发光，KE是光源反射一次结果（光源直接照射），Blinn-phong模型就只考虑到这一层，K2E是弹射一次的光照….. 下图展示了处理弹射次数变多时的变化，场景越来越亮并且逐渐收敛

这一部分就结束了，主要就是从辐射度量学角度来计算光照。直接光照和弹射后的光照混合就形成了全局光照

Monte carlo Path Tracing 蒙特卡洛路径追踪

Monte Carlo Integration 蒙特卡洛积分

蒙特卡洛是用来解一个原函数不好解析的定积分计算它的基本思想就是通过随机采样获得很多f(x)来进行估计更一般情况下，概率函数取任意一个，用下边公式就可以求一个定积分

Path Tracing 路径追踪

之前已经学习了Whitted-Style Ray Tracing，从摄像机射出光线遇到物体进行镜面反射或折射，每次弹射都与光源连线，但这里面有一些不符合物理的情况问题一： Whitted-Style假设反射时完美的，没有任何模糊或扩散，但是对于Glossy表面，现实中光线会在一个范围内散射，而不是单一方向的镜面反射问题二：光的漫反射应该真正的向四面八方反射开，例如下边右图柱子被墙壁的红色光反射到而呈现了红色所以最终得到Whitted-Style Ray Tracing是错的

用蒙特卡洛积分解渲染方程

考虑下图场景解渲染方程，就是求在半球上的积分，所以可以用蒙特卡洛来解被积函数如下，在立体角上积分，整体为半球选择概率密度函数如下最终要求的就是，在不同的立体角上进行采样，最终利用蒙特卡洛公式来估计积分值用算法描述就是要求p点向wo方向的辐射，首先通过概率密度函数随机选择N个样本，对于每个选中的方向wi，从p点连接到wi形成一条光线，如果这个方向打到了光源，就用公式进行累加（这里的描述只考虑直接光照），如果没打到就是采样结果为0 上边已经解决了直接光照问题，下来再解决全局光照，p点在wi方向上并没有看到光源，但是看到了Q点，这时候把P点当作摄像机，Q点当作要处理的点，对Q点进行上边介绍的处理，就能算出Q点对P点的贡献全局光照的算法描述如下，注意红色位置到这里还是有问题问题一：点越打越多，比如采样10次，如果10次采样都打到了物体上，那每个采样点又会采样10次问题一的解决就是只采样一次用N=1来进行积分就叫做Path Tracing，虽然在一个点位只会采样一次，但是整体路径可以进行多次，也就是从像素出发的线不只一条，但接触到物体时只采样一次问题二：没有设置递归出口，可是真实情况光就是会弹射无数次，引入俄罗斯轮盘赌来解决，以一定的概率停止递归

根据期望，这种概率性做法最终的期望还是Lo 最终最终的算法步骤如下：下面看一下用这个算法生成的图，算法是正确的，但是像素采样点设置很少时（low SPP）效果并不好，在High SPP下速度又太慢

Sampling the Light 光源采样

需要的采样数与光源大小有关系，如果射出的采样光没有打到光源，贡献就是0 解决效率问题思想就是在点P不再四面八方采样，而是在光源上进行采样，现在存在的问题蒙特卡洛积分的采样概率密度函数是在P点半球面的采样，需要把公式转换成在光源上采样的形式从数学上说就是dw的积分改为dA积分，需要先研究dw和dA的关系，就是用两者的关系进行换元最终重写渲染方程，就是把在立体角上的采样换成了在光源面积上采样到这还有一个小小问题如果光源被挡住呢？点光源路径追踪不好处理，建议改成小面积的面光源

最后来感受一下Path Tracing的强大

如何渲染一张图：要么光栅化要么光线追踪

GAMES101 现代计算机图形学入门 Geometry

Sun, 19 Oct 2025 12:37:17 +0800

Implicit and explicit

Implicit

是并不会告诉任何点的信息，只会告诉该曲面上所有点满足的关系

$$ f(x,y,z)=0 $$

判断所给出的隐式方程描述的是一个怎样的形状十分困难
可以十分容易的判断出一点与曲面的关系

example for Implicit

代数方法描述
Constructive Solid Geometry（CSG 通过基本几何的运算定义新的几何）
Signed Distance Functions（空间任何点到物体表面的最短距离来描述，用正负表示在物体外还是内）在2D情况，看下图就很好理解了

图片来自https://blog.csdn.net/CODE_RabbitV/article/details/140288664

当两个距离函数进行融合后后，找到所有值为0的位置，就是融合后的物体表面

分形

explicit

所有曲面的点被直接给出，或者可以通过映射关系直接得到 例如：

$$ f(u,v) = ((2+cosu)cosv,(2+cosu)sinv,sinu) $$

把uv都遍历一遍就可以拿到所有的(x,y,z)

因根据需要选择一种表达方式

Exampl For Explicit

Point Cloud（点云）全是点组成的模型
Polygon Mesh（多边形面）计算机中用三角形面表示的文件 .obj文件

Curves 曲线

贝塞尔曲线（Bézier Curves）

给定一系列控制点，画出曲线，下图是实际例子 de Casteljau实现考虑3个控制点（quadratic Bezier）给定一个比例t，把两个线段都根据t截开

得到的两个点连起来再执行相同操作最后只有一个点了，就确定了曲线一个点的位置把所有的t都找一遍，就画出了曲线，见下图，想象一下绿色和蓝色的线跟着t的变化一直变化，就会画出蓝色的线可以用表达式表达出每个点，用t去截线段，其实就是做一个插值计算最终总结，给定n+1个控制点，比例t的情况下，可以得到n阶的贝塞尔曲线贝塞尔曲线的一些性质：

必定经过起始与终止控制点
必定经与起始与终止线段相切
具有仿射变换性质，可以通过移动控制点移动整条曲线
凸包性质，曲线一定不会超出所有控制点构成的多边形范围什么是凸包（convex hull）？想象墙上有许多图钉，我们需要用一根橡皮筋把这些图钉围住，于是我们开始会让橡皮筋尽可能的撑大，然后松手放开橡皮筋，它所形成的多边形即为凸包，如图中蓝色曲线所示

贝塞尔曲线在控制点过多时，不好控制，如下图所示于是就有了Piecewise Bézier Curves，取一部分点做，然后结合起来，如下图贝塞尔曲线的连续性 C0连续，就是控制点重合 C1连续就是达到了曲面光滑，实现方法看下图红线

Surfaces 曲面

贝塞尔曲面

通过贝塞尔曲线获得贝塞尔曲面的方法：如下图已经画出了四条贝塞尔曲线，在t取某一值下生成的4个点，把这4个点作为控制点再画一条曲线，这样t变化时，这条线就绘制成了一个面

Mesh Operation

Mesh subdivision 曲面细分

引入更多的三角形，

Loop Subdivision

增多三角形数量，如下如
调整细分后新的三角形顶点处理，更新一条边的中心点，如下图的白点，对这个点的处理，通过上下左右四个顶点加权平均（这个权重是具体的算法，这里不做解释）
旧的顶点呢，如下图白点就是一个旧顶点，更新算法包括自己本来的位置，以及周围顶点进行加权平均

Catmull-Clark Subdivision

一般的模型不一定全是三角形，就没法用loop subdivision，Catmull-Clark可用于一般情况，如下图有正方形也有三角形先定义两个表达，非四边形面和奇异点（度不等于 4的点）如上图框所示，每条边和每个面都取钟中点，然后把这些点连起来，如下图所示连接后，奇异点变多了，非四边形都消失了，此时奇异点是4个，但是如果继续细分，奇异点数目并不会继续增加，如下图还是4个与loop一样，调整完后需要对顶点位置进行处理，处理方法如下下图为两种方法对比

Mesh Simplification 曲面简化

当模型距离很远时，模型的细节就没必要表现出来

Collapsing An Edge 边坍缩

那哪些边可以进行坍缩，如果度量呢？下图进行了度量，首先5个顶点进行平均效果并不好，用2次误差方法来实现：即坍缩之后蓝色新顶点所在的位置与原来各个平面的垂直距离之和。

为模型每条边赋值，其值为坍缩这条边之后，代替两个老顶点的新顶点所能得到的最小二次误差度量
选取权值最小的边做坍缩，新顶点位置为原来计算得出使得二次误差最小的位置
坍缩完之后，与之相连其他的边的位置会改动，更新这些边的权值
重复上述步骤，直到到达终止条件一些坍缩的实例几何部分就这些东西了～

GAMES101 现代计算机图形学入门 Shading

Sun, 19 Oct 2025 00:57:01 +0800

什么是shading？

shading 负责计算物体表面每个采样点的颜色，具体考虑光照、材质属性、观察角度等因素，生成具有真实感的视觉效果（如漫反射、镜面高光、环境光等）‌，之前的光栅化将是几何图元（如三角形）转换为屏幕上的像素，确定哪些像素被图元覆盖，是几何层面的处理

Blinn-Phong Reflectance Model(A Simple Shading Model)

Blinn-Phong 反射模型（Blinn-Phong Reflectance Model）是一种用于计算机图形学中模拟物体表面光照效果的着色模型.该模型主要由**环境光(Ambient)、漫反射(Diffuse)和高光反射(Specular)**三部分组成。定义一些基本向量，默认为单位向量：

Viewer Direction ：观察方向,用v 表示
Surface normal：法线方向，使用n表示
Light direction：光线方向，用l表示

Diffuse Reflection（漫反射）

是投射在粗糙表面上的光向各个方向反射的现象。当一束平行的入射光线射到粗糙的表面时，表面会把光线向着四面八方反射，所以入射线虽然互相平行，由于各点的法线方向不一致，造成反射光线向不同的方向无规则地反射，这种反射称之为“漫反射”或“漫射”。正是因为反射是完全随机的，因此可以认为漫反射光在任何反射方向上的分布都是一样的。漫反射强度影响因素：

入射光线与法线的夹角 lambert's cosine law: 当夹角为θ时，能量要乘cosθ = l.dot(v)(单位向量)
入射光线自身的强度入射光自身的强度与距离有关结合两个影响因素，得到漫反射能量公式 $$L_d = k_d (I / r^2) \max(0, \mathbf{n} \cdot \mathbf{l})$$

其中$k_d$表示反射系数指光（入射光）投向物体时，其表面反射光的强度与入射光的强度之比值，受入射光的投射角度、强度、波长、物体表面材料的性质以及反射光的测量角度等因素影响。一般来讲，在颜色系列中，黑色的反射系数较小，为0.03，白色的反射系数较大，为0.8 最后，漫反射与观察方向v没有关系，漫反射能量会均匀反射到各个方向上去。

Specular highlights(高光/镜面反射)

若物体表面很光滑，光线会被反射，如图所示R为镜面反射方向，观察方向v与反射方向R接近时，能看见反射光，反射光强度与R和v的夹角有关 R和v的夹角 等价于l和v的half vector与法线方向n之间的夹角，通过向量相加的平行四边形法则获取到half vector，再单位化最终得到镜面反射能量公式

$$ \begin{align*} L_s &= k_s (I / r^2) \max(0, \cos\alpha)^p \\ &= k_s (I / r^2) \max(0, \mathbf{n} \cdot \mathbf{h})^p \end{align*} $$

其中$k_s$为镜面反射系数，通常取白色的系数

因为镜面反射对角度很敏感，所以设置参数p来控制夹角的影响

Ambient Term（环境光）

环境光不依赖任何项，任何方向射入，任何方向观察都不影响环境光的强度（该模型的简化，精确计算需要用到全局光照技术）最后，展示结合效果

Shading Frequencies（着色频率）

3个几何形状完全相同的球，为什么着色结果各不相同？计算作色的频率不同，球1一个平面取一个法线，做一次着色，球3每个像素都求法线后都做一次着色

shade each triangle(flat shading)：每个三角形求一个法线（边向量叉积），对整个三角形进行相同的shading，当三角形面很多，效果也不一定差，反而计算量少
shade each vertex（Gouraud shading）：三角形的三个顶点都求法线，三个顶点进行shading，三角形内部用插值填充
shade each pixel(Phong shading)：每个像素都求法线，每个像素都进行shading

如何求顶点的法线？利用顶点关联的面的法线进行加权平均

Graphics（Real time Rendering）Pipeline

Pipeline：从场景到图的流程 ⚠️：Shading根据Shading Frequencies（着色频率）的不同发生在不同阶段，如果是每个顶点进行着色，就发生在顶点处理阶段，如果是每个像素shading么就在光栅化之后，下面图也解释的shader编程中的vertexShader和fragmentShader GPU模型

Texture Mapping

考虑球和地板，不同的位置有不同的颜色，每个位置都有自己的漫反射系数，引入纹理映射对每一个点定义不同的属性模型上任意一个三角形的顶点，都能在纹理图找到对应的顶点。至于如何一一对应，是美工的任务。纹理图通过UV坐标来进行定位（UV取值范围都是0-1之间），这样每个三角形的顶点都对应一个UV坐标如果我已经知道每个三角形顶点对于的UV坐标，那如何知道三角形内部每个点的UV坐标呢？（插值解决）

如何插值？

为什么要用插值？因为我们希望处理完顶点后，三角形内部进行平滑的过度首先引入重心坐标 Barycentric Coordinates 重心坐标可以表示为顶点的线性组合（如下图所示），三角形内任意一点的坐标(x,y)，找到满足$\alpha+\beta+\gamma=1$ 和 (x, y) = $\alpha A + \beta B + \gamma C$的（$\alpha$,$\beta$,$\gamma$）, 就可以用（$\alpha$,$\beta$,$\gamma$）表示该点的重心坐标重心坐标（$\alpha$,$\beta$,$\gamma$）可以通过面积比求出，如下图由此可得三角形的重心的重心坐标为(1/3,1/3,1/3), 除此之外，也有直接的公式求出任意一点的重心坐标，如下图其实重心坐标显示出的内容就是该点对于三角形三个顶点的权重应该是多少。（$\alpha$,$\beta$,$\gamma$）就分别是A、B、C顶点的权重。 ⚠️：投影后重心坐标会变化

Texture Magnification（纹理图太小）

A pixel on a texture - a texel(纹理元素、纹素) 场景：纹理图片22，但需要把它渲染到44的屏幕，那在渲染中间像素时，他的UV坐标无法对应texel，所以需要处理，下图为三种处理方式

Nearest

落在哪个texel附近，就选择哪个texel

Bilinear Interpolation

综合考虑周围4个texel的值，水平方向得到两个插值，再垂直方向再做一次插值，所以叫双线性插值，插值函数就是

$$lerp(x,v_0,v_1) = v_0 + x(v_1 - v_0)$$

Bicubic

更复杂的插值，取周围16的texel

Texture Magnification（纹理图太大）

例如纹理图被重复使用用来帖地板如果只进行简单操作，得到结果为问题的原因：在远处一个Pixel就覆盖了多个texel，下图大框是Pixel，在远处，一个像素就覆盖了多个纹理，很大范围只采样一次，就会导致信息丢失，导致走样。最简单解决思路就是Supersampling，采样点增多，获得的信息就多，但计算量太大

Mipmap

为一张纹理图生成多个低分辨率纹理图，每次分辨率减半，将4个相邻像素点求均值合为一个像素点。从存储容量上看，根据等比数列求和，存储只增加了$1/3$ 那在映射时应该选择哪一Level 作为纹理呢？利用屏幕相邻的像素点的距离估计纹理的大小，如图红色像素距离上和右两个像素的距离反应到纹理图上的距离变大的程度来选择，取最大

但通过$D = log_2L$计算的是一个连续值，并不一定直接表面使用第几层，如何处理？使用三线性插值，例如D=1.8，就在第1层和第2层分别做一次双线性插值，最后根据D的大小，对两次插值结果再插值一次

使用该技术得到结果，如下图所示，远处仍然比较模糊

各向异性过滤

Mipmap所规定的区域查询必须是正方形，而纹理映射中可不仅仅只有正方形，如下图所示，某些像素对应的纹理图位置并不是正方形，针对这种情况，有时候需要水平方向的高Level，有时候需要竖直方向上的高Level，因此也启发了各向异性过滤，生成各种方向上压缩的材质，最终存储容量收敛到原来的3倍看下图一个像素点在纹理上对应的并不是一个正方形区域，使用Mipmap就不合适了

纹理的应用

Environment Map

纹理不一定非得一副图片，可以用纹理描述环境光效果

Bump Mapping 凹凸贴图

欺骗人眼，看着像是用模型做出来的凹凸效果，其实只是材质的原因。在贴图上定义每个点的高度进而改变法向量，这就回影响shading，因为法线参与了color生成过程。

Displacement Mapping 位移贴图

真的去移动了顶点，Bump会露馅，因为最外圈显然是一个完整的球。Bump Maps是逻辑上的高度改变，它实则并没有改变内部的模型，是假的改变；而Displacement Map则是物理上的高度改变。它真正改变了模型。二者的区别就在此处，可以通过物体阴影的边缘发现这点

3维纹理

GAMES101 现代计算机图形学入门 Transformation & Rasterization

Sun, 19 Oct 2025 00:47:26 +0800

线性代数复习

向量

首先介绍一下向量，有长度有方向，起始位置不固定向量归一化，就是获得向量方向上的单位向量，后续课程各种操作都是在单位向量上进行向量加法

点乘和叉乘

向量点乘，在后续课程中用来计算cosθ，如果两个单位向量点乘结果就是cosθ 在坐标系中的使用，就是对应坐标相乘再相加点乘可以用来投影向量叉乘在坐标系中的使用，有公式在图形中的使用是可以判断一个点是否在三角形内部，在光栅化时用来判断一个像素是否需要被渲染

矩阵

矩阵就不说了，比较容易

Transformation（变换）

Model Transformation

模型变换可以做缩放、旋转、平移通过矩阵计算实现的缩放旋转

笔记保存

games101课程光栅化之前的笔记，发现还是直接写博客方便，后续用CSDN完成笔记，前边部分先贴在这里，以后再补充 这是之前遗留的笔记，放在这里保存