这次我们来看一个从零开始用 C++ 实现渲染器的系列教程，重点是第七讲：光源与阴影。对于想深入理解图形学底层原理，特别是想亲手实现一套光照和阴影系统的开发者来说，这是一个非常硬核的实践项目。它不是教你调用现成的游戏引擎 API，而是带你从数学公式和算法开始，一步步构建出平行光、点光源、聚光灯，并实现阴影和辐照度计算。

如果你对 C++ 图形编程感兴趣，想搞清楚 Phong 光照模型、阴影贴图这些概念背后的代码实现，这篇文章会带你梳理清楚核心思路、代码结构和验证方法。我们将重点关注如何用 C++ 组织光源数据、如何计算光照贡献、如何实现阴影映射算法，以及如何验证渲染结果的正确性。

1. 核心能力速览

2. 适用场景与使用边界

这个“从零打造渲染器”系列教程，特别是光源与阴影这一讲，主要适用于以下几类开发者：

1. 图形学初学者：已经了解过向量、矩阵、基本颜色混合，想深入理解光照模型和阴影算法是如何被代码实现的。
2. 计算机专业学生：需要完成图形学课程大作业或毕业设计，一个完整的光照渲染器是很好的实践项目。
3. 希望巩固基础的工程师：即使在使用 Unity 或 Unreal Engine，了解底层光照和阴影计算也能帮助更好地调试和优化。
4. 技术面试准备者：实现一个软渲染器是图形学岗位面试中常见的高级话题，能体现扎实的功底。

使用边界与注意事项：

• 非生产级：这是一个教学项目，旨在阐明原理，其性能、功能完整性和鲁棒性无法与工业级渲染引擎（如 OGRE、Unity URP/HDRP）相提并论。
• 纯软件渲染：所有计算在 CPU 上完成，不涉及 GPU 编程（如 Shader）。这是为了剥离硬件复杂性，专注于算法本身。
• 版权与素材：项目中使用的测试模型（如 .obj 文件）、纹理图片需确保拥有合法使用权或使用开源资源，避免版权纠纷。

3. 环境准备与前置条件

要跟随此教程进行实践，你需要准备一个基础的 C++ 开发环境。由于是纯 CPU 计算，对显卡没有要求，重点在于编译器和必要的数学库。

1. 操作系统：Windows (推荐 Win10/11)、Linux 或 macOS 均可。教程示例代码通常跨平台。
2. C++ 编译器：
   • Windows: 安装 MinGW-w64 或使用 Visual Studio (社区版即可)。确保编译器支持 C++11 或更高标准。
   • Linux: 使用系统包管理器安装g++或clang++。
   • macOS: 安装 Xcode Command Line Tools。
3. 构建工具 (可选但推荐)：使用 CMake 可以更方便地管理项目，特别是当项目文件增多时。也可以直接使用编译器命令行。
4. 图像输出库 (可选)：为了将计算结果保存为图片，可能需要一个轻量级库，例如：
   • stb_image_write：单头文件库，用于写入 PNG、BMP 等格式。
   • 教程初期可能直接输出为简单的.ppm(Portable PixMap) 格式，这是一种纯文本的图片格式，无需额外库支持，便于调试。
5. 线性代数库 (可选)：你可以自己实现Vec3,Mat4等类，也可以使用现成的库如Eigen或GLM。对于学习而言，自己实现一遍向量和矩阵运算收益最大。
6. 代码编辑器/IDE：Visual Studio Code、CLion、Visual Studio 等任选。

通用检查清单：

• [ ] 确认g++ --version或clang++ --version命令能正确输出版本信息。
• [ ] 确认已安装 CMake (如使用)。
• [ ] 准备一个干净的工程目录，用于存放源代码、模型和输出图片。

4. 项目结构与代码组织思路

在开始编码前，理解一个简单渲染器的典型架构至关重要。这能帮助你在阅读或编写代码时，知道每个模块的职责。

一个最小化的渲染器可能包含以下模块：

YourRendererProject/ ├── src/ │ ├── main.cpp // 程序入口，设置场景，调用渲染循环 │ ├── vector.h/cpp // 三维向量 Vec3 实现（点、方向、颜色） │ ├── matrix.h/cpp // 4x4 矩阵 Mat4 实现（变换矩阵） │ ├── geometry.h/cpp // 三角形、射线、包围盒等几何结构 │ ├── model.h/cpp // 加载和存储 .obj 模型数据（顶点、法线、纹理坐标） │ ├── camera.h/cpp // 相机类，管理视图和投影矩阵 │ ├── light.h/cpp // **本讲核心**：定义 Light 基类及各种光源子类 │ ├── shader.h/cpp // **着色逻辑核心**：包含顶点着色和片段着色（光照计算） │ ├── rasterizer.h/cpp // 光栅化器，负责将三角形画到像素缓冲区 │ └── texture.h/cpp // 纹理加载与采样 ├── include/ // 头文件（如果采用头文件与源文件分离） ├── resources/ // 资源文件 │ ├── models/ // .obj 模型文件 │ └── textures/ // 纹理图片 ├── output/ // 渲染输出的图片 └── CMakeLists.txt // CMake 构建脚本

本讲（光源与阴影）的核心工作将集中在light.h/cpp和shader.h/cpp中：

• light.h/cpp：定义光源的属性（位置、方向、颜色、强度、衰减系数等）。
• shader.h/cpp：在片段着色阶段，根据光源属性、表面法线、视线方向等，计算该像素最终的颜色。阴影计算也在这里或作为一个独立通道完成。

5. 光源类型的实现详解

接下来，我们深入三种经典光源的 C++ 实现。我们将基于一个抽象的Light基类进行扩展。

5.1 定义光源基类

首先，定义一个光源基类，包含所有光源共有的属性。

// light.h #ifndef LIGHT_H #define LIGHT_H #include "vector.h" // 假设你有自己的 Vec3 类 class Light { public: enum Type { DIRECTIONAL, POINT, SPOT }; Light(const Vec3& color, float intensity) : m_color(color), m_intensity(intensity) {} virtual ~Light() = default; // 纯虚函数：计算给定世界空间点的光照贡献（颜色） // 参数：point (世界空间位置), normal (世界空间法线), viewDir (指向相机的方向) virtual Vec3 illuminate(const Vec3& point, const Vec3& normal, const Vec3& viewDir) const = 0; // 获取光源类型（用于阴影计算等） virtual Type getType() const = 0; // 获取光源位置（方向光返回无穷远点，或用于阴影矩阵计算） virtual Vec3 getPosition() const = 0; // 获取光源方向（点光源可能返回零向量或指向点的方向） virtual Vec3 getDirection(const Vec3& point) const = 0; protected: Vec3 m_color; // 光源颜色 (RGB) float m_intensity; // 光源强度 }; #endif // LIGHT_H

5.2 平行光 (Directional Light) 实现

平行光模拟无限远处的光源，如太阳。所有光线方向平行。

// directional_light.h #ifndef DIRECTIONAL_LIGHT_H #define DIRECTIONAL_LIGHT_H #include "light.h" class DirectionalLight : public Light { public: // 方向需要是单位向量，指向光源的方向（与光线传播方向相反） DirectionalLight(const Vec3& direction, const Vec3& color, float intensity) : Light(color, intensity), m_direction(direction.normalized()) {} Type getType() const override { return DIRECTIONAL; } Vec3 getPosition() const override { // 平行光没有具体位置，可以返回一个远点，或者抛出异常。 // 在阴影映射中，我们需要一个“虚拟”位置来构建光源视图矩阵。 // 这里返回一个沿着光线反方向很远的位置。 return Vec3(0, 100, 100); // 示例值，实际应根据场景包围盒计算 } Vec3 getDirection(const Vec3& point) const override { // 对于平行光，方向与点无关，是恒定的。 // 注意：m_direction 是指向光源的，但光照计算通常需要指向表面的光线方向。 // 我们返回光线方向（从表面指向光源）。 return -m_direction; // 光线方向 = -光源方向 } Vec3 illuminate(const Vec3& point, const Vec3& normal, const Vec3& viewDir) const override { // 1. 计算光线方向 (lightDir) Vec3 lightDir = getDirection(point); // 单位向量，从表面指向光源 // 2. 漫反射计算 (Lambert) float diff = std::max(normal.dot(lightDir), 0.0f); Vec3 diffuse = m_color * m_intensity * diff; // 3. 镜面反射计算 (Blinn-Phong) Vec3 halfway = (lightDir + viewDir).normalized(); float spec = std::pow(std::max(normal.dot(halfway), 0.0f), 32.0f); // 32是光泽度 Vec3 specular = m_color * m_intensity * spec; // 4. 环境光 (简单常数) Vec3 ambient = m_color * 0.1f; // 5. 返回最终光照颜色 (这里假设物体是白色的，材质颜色为Vec3(1,1,1)) // 实际应结合物体材质颜色 (kd, ks) Vec3 materialColor(1.0f, 1.0f, 1.0f); return materialColor * (ambient + diffuse + specular); } private: Vec3 m_direction; // 指向光源的方向（单位向量） };

5.3 点光源 (Point Light) 实现

点光源从一个点向所有方向均匀发光，光照强度随距离衰减。

// point_light.h #ifndef POINT_LIGHT_H #define POINT_LIGHT_H #include "light.h" class PointLight : public Light { public: // attenuation: 衰减系数 (constant, linear, quadratic) PointLight(const Vec3& position, const Vec3& color, float intensity, const Vec3& attenuation = Vec3(1.0f, 0.09f, 0.032f)) : Light(color, intensity), m_position(position), m_attenuation(attenuation) {} Type getType() const override { return POINT; } Vec3 getPosition() const override { return m_position; } Vec3 getDirection(const Vec3& point) const override { // 光线方向：从表面点指向光源位置 return (m_position - point).normalized(); } Vec3 illuminate(const Vec3& point, const Vec3& normal, const Vec3& viewDir) const override { // 1. 计算光线方向和距离 Vec3 lightDir = getDirection(point); float distance = (m_position - point).length(); // 2. 计算衰减因子 float attenuation = 1.0f / (m_attenuation.x + m_attenuation.y * distance + m_attenuation.z * distance * distance); // 3. 漫反射 float diff = std::max(normal.dot(lightDir), 0.0f); Vec3 diffuse = m_color * m_intensity * diff * attenuation; // 4. 镜面反射 (Blinn-Phong) Vec3 halfway = (lightDir + viewDir).normalized(); float spec = std::pow(std::max(normal.dot(halfway), 0.0f), 32.0f); Vec3 specular = m_color * m_intensity * spec * attenuation; // 5. 环境光 Vec3 ambient = m_color * 0.1f * attenuation; // 环境光也衰减？通常不，这里仅为示例 Vec3 materialColor(1.0f, 1.0f, 1.0f); return materialColor * (ambient + diffuse + specular); } private: Vec3 m_position; Vec3 m_attenuation; // (constant, linear, quadratic) };

5.4 聚光灯 (Spotlight) 实现

聚光灯从一个点朝特定方向发射锥形光，有内锥角和外锥角，边缘有平滑衰减。

// spotlight.h #ifndef SPOTLIGHT_H #define SPOTLIGHT_H #include "point_light.h" // 继承点光源，因为也有位置和衰减 class Spotlight : public PointLight { public: Spotlight(const Vec3& position, const Vec3& direction, const Vec3& color, float intensity, float cutOff, float outerCutOff, // 内锥角、外锥角（弧度） const Vec3& attenuation = Vec3(1.0f, 0.09f, 0.032f)) : PointLight(position, color, intensity, attenuation), m_direction(direction.normalized()), m_cutOff(std::cos(cutOff)), m_outerCutOff(std::cos(outerCutOff)) {} Type getType() const override { return SPOT; } Vec3 getDirection(const Vec3& point) const override { // 光线方向：从表面点指向光源位置 return (getPosition() - point).normalized(); } Vec3 illuminate(const Vec3& point, const Vec3& normal, const Vec3& viewDir) const override { // 1. 先计算点光源的基础光照（包含衰减） Vec3 baseColor = PointLight::illuminate(point, normal, viewDir); // 2. 计算聚光灯因子 Vec3 lightDir = getDirection(point); // 从表面指向光源 float theta = lightDir.dot(-m_direction); // 光线方向与聚光灯方向的夹角余弦 float epsilon = m_cutOff - m_outerCutOff; // 平滑过渡因子：在内外锥角之间从1衰减到0 float intensity = std::clamp((theta - m_outerCutOff) / epsilon, 0.0f, 1.0f); // 3. 如果 theta 小于外锥角余弦，则完全在光锥外，无光照 if(theta < m_outerCutOff) { intensity = 0.0f; } // 4. 应用聚光灯强度因子 // 注意：baseColor 已经包含了衰减和基础光照计算。 // 我们需要将漫反射和镜面反射部分乘以 intensity，环境光部分通常不受影响。 // 为了简化，这里对整个 baseColor 应用 intensity（除了环境光）。 // 更精确的做法是分离光照分量。 Vec3 ambient = m_color * 0.1f * (1.0f / (m_attenuation.x + m_attenuation.y * distance + m_attenuation.z * distance * distance)); // 重新计算衰减后的环境光 Vec3 diffuseSpecular = baseColor - ambient; return ambient + diffuseSpecular * intensity; } private: Vec3 m_direction; // 聚光灯指向的方向（单位向量） float m_cutOff; // 内锥角余弦值 float m_outerCutOff; // 外锥角余弦值 };

6. 阴影映射的实现思路

阴影是判断一个点是否被光源直接照到的结果。阴影映射是实时渲染中最常用的技术之一。其核心思想是：从光源视角渲染一次场景，记录下每个像素距离光源的最近深度，然后在主相机渲染时，将像素点转换到光源视角，比较其深度与记录的深度，如果大于记录深度，则在阴影中。

6.1 阴影映射算法步骤

1. 深度贴图渲染 (Depth Pass)：

   • 将相机移动到光源位置，看向场景。
   • 使用一个只输出深度（距离）的着色器渲染整个场景，结果存储在一张纹理中（深度贴图）。

2. 主场景渲染 (Main Pass)：

   • 用主相机正常渲染。
   • 对于每个需要渲染的片段（像素）： a. 将其世界坐标转换到光源的裁剪空间。 b. 将裁剪空间坐标进行透视除法，归一化到 [0,1] 范围，得到深度贴图中的纹理坐标 (u,v)。 c. 从深度贴图中采样，得到该纹理坐标处记录的最小深度值。 d. 计算当前片段在光源视角下的深度值。 e. 比较：如果当前片段深度 > 记录的最小深度 + 一个微小偏差 (bias)，则认为该点在阴影中。

3. 阴影计算：如果点在阴影中，则只应用环境光（或很弱的漫反射），不应用该光源的漫反射和镜面反射光。

6.2 在 C++ 软渲染器中实现阴影的挑战与简化

在 GPU 管线中，阴影映射依赖光栅化、深度测试和纹理采样，这些都有硬件高效支持。在 CPU 软渲染器中实现完整的阴影映射性能开销极大。因此，教学项目通常会进行简化：

• 简化方案1：预计算阴影：对于静态场景和静态光源，可以预先计算好阴影信息（例如烘焙到顶点颜色或一张纹理中），渲染时直接使用。
• 简化方案2：实现简化阴影映射：
  • 为平行光实现一个正交投影的深度贴图。
  • 使用一个离屏的“深度缓冲区”（二维浮点数组）代替纹理。
  • 先以光源为相机，用软件光栅化渲染一遍场景，只记录最小深度值到深度缓冲区。
  • 主渲染时，对每个像素，手动进行坐标变换和深度比较。
• 简化方案3：平面投影阴影：对于平行光照射到平面上的情况，可以使用简单的几何投影公式计算阴影多边形，并将其渲染为黑色半透明。这种方法简单快速，但局限性大。

核心代码结构示意：

// shadow_map.h class ShadowMap { public: ShadowMap(int width, int height); ~ShadowMap(); // 开始从光源视角渲染深度 void beginRender(const Mat4& lightViewProjMatrix); // 更新深度缓冲区（在光栅化三角形时调用） void updateDepth(const Vec3& screenPos, float depth); // 结束深度渲染 void endRender(); // 查询一个点是否在阴影中 bool inShadow(const Vec3& worldPoint, const Mat4& lightViewProjMatrix) const; private: int m_width, m_height; std::vector<float> m_depthBuffer; // 深度缓冲区 Mat4 m_lightViewProj; // 当前深度贴图对应的光源VP矩阵 }; // 在片段着色器中 Vec3 fragmentShader(...) { Vec3 color = calculateAmbient(); if(!shadowMap.inShadow(worldPos, lightViewProjMatrix)) { color += calculateDiffuse(...) + calculateSpecular(...); } return color; }

7. Irradiance 概念与实现

辐照度是单位面积上接收到的光通量，是全局光照和 PBR 渲染中的重要概念。在本教程的语境中，理解 Irradiance 有助于从“一个点被照亮”上升到“一个面元接收到的总光照能量”。

在局部光照模型（如 Phong）中，我们计算的是某个点上的光照。而 Irradiance 更常用于环境光照，例如：

• Irradiance Environment Map：将环境光（如天空盒）的辐照度预计算并存储在一张低分辨率的立方体贴图或球谐系数中，渲染时快速采样，用于实现逼真的环境漫反射。
• 在软渲染器中实践：一个简单的实践是，将场景置于一个巨大的球体或立方体内部，其内表面贴有环境纹理（HDR 图像）。在渲染物体表面时，根据表面法线方向，采样这张环境纹理的对应颜色，并乘以一个系数，作为环境光的 Irradiance。这比固定的环境光常数真实得多。

简化实现思路：

1. 准备一张 HDR 环境贴图（可以是等距柱状投影图）。
2. 在着色器中，对于表面点 P 的法线 N，将 N 作为方向向量。
3. 将这个方向向量转换为环境贴图的纹理坐标 (u, v)。
4. 从环境贴图中采样颜色envColor。
5. 将envColor乘以一个缩放系数（如1.0 / PI），作为该点的 Irradiance，用于替代固定的环境光颜色。

// 伪代码：在片段着色器中采样环境贴图作为 Irradiance Vec3 sampleIrradiance(const Vec3& normal) { // 假设环境贴图是等距柱状投影 (Equirectangular) // 将法线向量转换为球面坐标 (phi, theta) float phi = std::atan2(normal.z, normal.x); float theta = std::acos(normal.y); // 将球面坐标归一化到 [0,1] 纹理坐标 float u = 0.5f + phi / (2.0f * M_PI); float v = theta / M_PI; // 从环境贴图纹理中采样 (需要实现纹理类) Vec3 envColor = m_environmentMap->sample(u, v); return envColor * (1.0f / M_PI); // 简化的 Irradiance }

8. 功能测试与效果验证

如何验证你的光源和阴影代码是否正确工作？以下是一套系统的测试流程。

8.1 构建测试场景

1. 准备简单模型：使用一个立方体 (cube.obj) 和一个平面 (plane.obj) 作为测试场景。平面作为地面，立方体放在平面上。
2. 设置相机：将相机放在场景斜上方，确保能看到模型和可能产生的阴影。
3. 编写测试主程序：

   int main() { // 1. 初始化渲染器、加载模型 Rasterizer renderer(800, 600); Model cube("resources/models/cube.obj"); Model plane("resources/models/plane.obj"); // 2. 设置相机 Camera camera(Vec3(0, 2, 5), Vec3(0, 0, 0), Vec3(0, 1, 0), 45.0f, 800.0f/600.0f); // 3. 创建光源 // 测试平行光 DirectionalLight dirLight(Vec3(-1, -1, -1).normalized(), Vec3(1, 1, 1), 1.0f); // 测试点光源 PointLight pointLight(Vec3(2, 3, 2), Vec3(1, 0.8, 0.8), 1.5f); // 测试聚光灯 Spotlight spotLight(Vec3(0, 5, 0), Vec3(0, -1, 0), Vec3(0.9, 0.9, 1.0), 2.0f, radians(12.5f), radians(17.5f)); std::vector<Light*> lights = { &dirLight, &pointLight, &spotLight }; // 4. 创建着色器并设置光源 PhongShader shader; shader.setLights(lights); shader.setViewPos(camera.getPosition()); // 5. 渲染循环（单帧） renderer.clear(); renderer.setShader(&shader); renderer.setViewProjMatrix(camera.getViewMatrix(), camera.getProjectionMatrix()); // 渲染平面和立方体 renderer.drawModel(plane); renderer.drawModel(cube); // 6. 保存结果 renderer.saveToPNG("output/test_lighting.png"); return 0; }

8.2 分步验证

1. 验证环境光：关闭所有光源，只保留环境光项。渲染结果应该是一个均匀暗淡的物体轮廓。
2. 验证漫反射（平行光）：
   • 只开启一个白色的平行光，强度设为 1.0。
   • 旋转光源方向，观察立方体各个面的明暗变化。面向光源的面应该最亮，背对光源的面应该为黑色（只有环境光）。
   • 符合 Lambert 余弦定律。
3. 验证镜面反射：
   • 保持平行光开启，调整相机位置。
   • 观察立方体上是否出现高光点。高光点应出现在视线方向与反射光方向接近的区域。
   • 移动相机，高光点位置应随之移动。
4. 验证点光源衰减：
   • 只开启一个点光源，将其放在立方体附近。
   • 渲染后，观察立方体靠近光源的一面是否更亮，远离的一面更暗。
   • 尝试增大衰减系数中的二次项 (m_attenuation.z)，远离光源的部分应更快变暗。
5. 验证聚光灯锥角：
   • 只开启一个聚光灯，从上方垂直照射平面。
   • 渲染平面，应该看到一个圆形光斑。
   • 调整cutOff和outerCutOff角度，观察光斑大小和边缘柔化程度的变化。
6. 验证阴影（如果已实现）：
   • 开启平行光和阴影映射。
   • 渲染立方体和平面。立方体应在平面上投下阴影。
   • 移动立方体，阴影位置应正确变化。
   • 检查阴影是否有严重的“阴影粉刺”现象，这需要通过调整深度偏差 (bias) 来解决。

8.3 判断成功的标准

• 视觉正确性：渲染出的图像符合物理直觉。亮部、暗部、高光、阴影区域关系正确。
• 交互一致性：改变光源参数（位置、方向、颜色、强度）或相机位置，渲染结果发生符合预期的变化。
• 数学验证：可以输出某个特定像素（如立方体正面中心）计算出的光照分量值（环境、漫反射、镜面反射），与手动计算的结果进行比对。

9. 常见问题与排查方法

在实现过程中，你几乎一定会遇到下面这些问题。

10. 最佳实践与进阶方向

当你成功实现了基础的光照和阴影后，可以考虑以下优化和扩展，让项目更具深度。

1. 代码结构优化：

   • 使用智能指针管理光源：std::vector<std::unique_ptr<Light>>避免内存泄漏。
   • 将着色器参数结构体化：创建一个ShaderParams结构体，包含所有 uniform 变量（MVP矩阵、光源列表、相机位置等），便于传递和管理。
   • 实现材质系统：创建Material类，包含漫反射颜色、镜面反射颜色、光泽度、折射率等属性，与光源解耦。

2. 性能优化：

   • 背面剔除：在光栅化前，在屏幕空间或视锥空间进行三角形背面剔除，减少约50%的片段计算。
   • 深度测试提前：在片段着色器之前进行深度测试（Z-Buffer），避免对不可见像素进行昂贵的光照计算。
   • 光源裁剪：对于点光源和聚光灯，计算其影响范围（视锥或球体），只对范围内的物体进行该光源的光照计算。

3. 效果增强：

   • 多光源支持：在着色器中循环遍历所有光源，累加它们的光照贡献。注意性能开销。
   • Gamma 校正：在将最终颜色写入图像前，进行 Gamma 校正（通常取 2.2 的幂），使颜色在显示器上显示更符合人眼感知。
   • 阴影优化：
     • PCF 软阴影：在深度比较时，对深度贴图进行多次采样并平均，实现边缘柔化的软阴影。
     • CSM 级联阴影映射：针对平行光，使用多张不同精度的深度贴图覆盖近、中、远距离，解决阴影走样问题。

4. 向 PBR 迈进：

   • 将 Phong 模型替换为更物理的Cook-Torrance或Disney BRDF模型。
   • 引入基于图像的光照，使用 HDR 环境贴图计算高质量的漫反射 Irradiance 和镜面反射 Specular。
   • 实现法线贴图和粗糙度/金属度贴图，大幅提升表面细节。

实现一个完整的光照与阴影系统是理解现代渲染管线的关键一步。从这个项目出发，你可以选择深入优化软渲染器，也可以带着对底层原理的深刻理解，转向学习 OpenGL、Vulkan 等现代图形 API，那时你会发现很多概念都变得亲切而清晰。建议将你的代码托管到 GitHub，并撰写详细的 README，这不仅是学习的记录，也是你技术能力的有力证明。