Courses on wanfeng

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方法来设置原本被反射的类的信息

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

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存的是一个表情相对于正常面部的便宜

动画重定向

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存储空间

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

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完成笔记，前边部分先贴在这里，以后再补充 这是之前遗留的笔记，放在这里保存