首先实现3D软件渲染器需构建向量、矩阵、帧缓冲和光栅化基础，接着通过模型、视图、投影变换将三维顶点转为屏幕坐标，再用Bresenham算法绘制三角形线框，最终输出PPM图像验证结果。
想用C++从零开始实现一个简单的3D软件渲染器，不需要依赖OpenGL或DirectX，关键在于理解图形管线的基本流程，并手动实现核心步骤：模型变换、视图变换、投影、光栅化和像素绘制。下面是一个极简但完整的实现思路，适合入门3D图形学。
1. 定义基本数据结构
首先需要向量和矩阵来处理3D空间中的点和变换。
Vec3类用于表示三维点或向量：
立即学习“C++免费学习笔记（深入）”；
struct Vec3 {
float x, y, z;
Vec3(float x=0, float y=0, float z=0) : x(x), y(y), z(z) {}
Vec3 operator+(const Vec3& v) const { return Vec3(x+v.x, y+v.y, z+v.z); }
Vec3 operator*(float f) const { return Vec3(x*f, y*f, z*f); }
};
颜色可以用简单的RGB结构：
struct Color {
unsigned char r, g, b;
Color(unsigned char r=0, unsigned char g=0, unsigned char b=0) : r(r), g(g), b(b) {}
};
2. 创建帧缓冲区
用二维数组模拟屏幕，每个像素存储颜色值。
例如创建一个800x600的图像缓冲：
class FrameBuffer {
public:
int width, height;
std::vector buffer;
FrameBuffer(int w, int h) : width(w), height(h), buffer(w * h, Color(0,0,0)) {}
void setPixel(int x, int y, const Color& c) {
if (x >= 0 && x < width && y >= 0 && y < height) {
buffer[y * width + x] = c;
}
}
void savePPM(const std::string& filename) {
std::ofstream out(filename);
out << "P3\n" << width << " " << height << "\n255\n";
for (int i = 0; i < width * height; ++i) {
out << (int)buffer[i].r << " "
<< (int)buffer[i].g << " "
<< (int)buffer[i].b << "\n";
}
}};
3. 实现三角形光栅化
最简单的光栅化方式是扫描线填充，但这里使用更直观的“边界函数”方法或暴力遍历 bounding box。
以下是一个简化版的画线框三角形函数（可扩展为填充）：
void drawTriangle(FrameBuffer& fb, Vec3 v0, Vec3 v1, Vec3 v2, const Color& c) {
// 投影到屏幕：只取x,y，忽略z（正交投影示例）
int x0 = (int)(v0.x + fb.width/2);
int y0 = (int)(v0.y + fb.height/2);
int x1 = (int)(v1.x + fb.width/2);
int y1 = (int)(v1.y + fb.height/2);
int x2 = (int)(v2.x + fb.width/2);
int y2 = (int)(v2.y + fb.height/2);
// 使用Bresenham画三条边
auto drawLine = [&](int x0, int y0, int x1, int y1) {
int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
int err = dx + dy;
while (true) {
fb.setPixel(x0, y0, c);
if (x0 == x1 && y0 == y1) break;
int e2 = 2 * err;
if (e2 >= dy) { err += dy; x0 += sx; }
if (e2 <= dx) { err += dx; y0 += sy; }
}
};
drawLine(x0, y0, x1, y1);
drawLine(x1, y1, x2, y2);
drawLine(x2, y2, x0, y0);}
4. 简单的3D变换与投影
将3D顶点转换为屏幕坐标：
- 模型变换：平移、旋转物体
- 视图变换：摄像机位置（可先固定）
- 投影：透视除法模拟远小近大
简单透视投影示例：
Vec3 project(Vec3 v, float fov = 250.0f, float zNear = 1.0f) {
float z = v.z + 5.0f; // 摄像机在z=-5，物体在原点附近
if (z < zNear) z = zNear;
float scale = fov / z;
return Vec3(v.x * scale, v.y * scale, z);
}
5. 主循环：绘制一个旋转的立方体
定义立方体的8个顶点和12条边组成的12个三角形面（每个面两个三角形）。
主函数中：
int main() {
FrameBuffer fb(800, 600);
// 定义立方体顶点（单位立方体）
Vec3 verts[8] = {
{-1,-1,-1}, {1,-1,-1}, {1,1,-1}, {-1,1,-1},
{-1,-1,1}, {1,-1,1}, {1,1,1}, {-1,1,1}
};
// 定义面（每两个三角形组成一个面）
int faces[12][3] = {
{0,1,2}, {0,2,3}, // 前
{4,5,6}, {4,6,7}, // 后
{0,1,5}, {0,5,4}, // 下
{2,3,7}, {2,7,6}, // 上
{0,3,7}, {0,7,4}, // 左
{1,2,6}, {1,6,5} // 右
};
float angle = 1.0f; // 旋转角度
for (int i = 0; i < 8; ++i) {
// 绕y轴旋转
float x = verts[i].x;
float z = verts[i].z;
verts[i].x = x * cos(angle) - z * sin(angle);
verts[i].z = x * sin(angle) + z * cos(angle);
}
for (int i = 0; i < 12; ++i) {
Vec3 v0 = project(verts[faces[i][0]]);
Vec3 v1 = project(verts[faces[i][1]]);
Vec3 v2 = project(verts[faces[i][2]]);
drawTriangle(fb, v0, v1, v2, Color(255,255,255));
}
fb.savePPM("output.ppm");
return 0;}
编译运行后会生成一个PPM图像文件，能看到一个旋转的线框立方体。
6. 后续可扩展方向
- 填充三角形：使用重心坐标插值实现平滑着色
- Z缓冲：解决遮挡问题
- 光照模型：实现Lambert漫反射
- 纹理映射：将图片贴到三角形上
- 矩阵类：封装4x4变换矩阵，支持齐次坐标
基本上就这些。从画点、线到三角形，再到变换和投影，你已经走完了软件渲染的第一步。不复杂但容易忽略的是坐标系转换和深度处理。继续深入，你会自然接触到现代GPU的工作原理。
