引言
上一篇我们完成了2D渲染器，接下来要实现3D几何体的绘制。其实3D比2D没有多太多内容，无非就是多了几步空间变换和一个视角控制的部分。首先，我们设置一下视角，为之后的三维渲染做准备。
空间变换与相机
这里我们来简单谈谈空间变换。它的概念在unity渲染管线那篇文章中有详细介绍，大概就是要从模型空间变换到世界空间、变换到视角空间、变换到裁剪空间、变换到ndc空间、变换到屏幕坐标。因为这部分属于图形学入门的知识，再加上自己太懒不想打太多数学符号，因此直接上几张自己曾经做过的白板ppt：
好了，相信你对这几个空间变换有了一定的了解，那么接下来我们就补充一下Matrix类：
1 void Matrix::lookat(Vector3D camPos,Vector3D tarPos,Vector3D up){
2 Vector3D xAxis,yAxis,zAxis;
3 zAxis=-(tarPos-camPos);
4 zAxis.normalize();
5 xAxis=up.product(zAxis);
6 xAxis.normalize();
7 yAxis=zAxis.product(xAxis);
8 yAxis.normalize();
9 normalize();
10 ele[0][0]=xAxis.x;
11 ele[0][1]=xAxis.y;
12 ele[0][2]=xAxis.z;
13 ele[1][0]=yAxis.x;
14 ele[1][1]=yAxis.y;
15 ele[1][2]=yAxis.z;
16 ele[2][0]=zAxis.x;
17 ele[2][1]=zAxis.y;
18 ele[2][2]=zAxis.z;
19 ele[0][3]=-(xAxis.dot(camPos));
20 ele[1][3]=-(yAxis.dot(camPos));
21 ele[2][3]=-(zAxis.dot(camPos));
22 }
23
24 void Matrix::perspective(float fovy, float aspect, float near, float far){
25 ele[0][0]=1/(aspect*tanf(fovy/2));
26 ele[1][1]=1/(tanf(fovy/2));
27 ele[2][2]=-((far+near)/(far-near));
28 ele[2][3]=-(2*far*near)/(far-near);
29 ele[3][2]=-1;
30 }
31
32 void Matrix::viewPort(int left,int top,int width,int height){
33 normalize();
34 ele[0][0]=static_cast<float>(width)/2.0f;
35 ele[1][1]=-static_cast<float>(height)/2.0f;
36 ele[0][3]=static_cast<float>(left)+static_cast<float>(width)/2.0f;
37 ele[1][3]=static_cast<float>(top)+static_cast<float>(height)/2.0f;
38 }
其中lookat矩阵是从世界空间转换到视角空间的矩阵，perspective矩阵是从视角空间转换到裁剪空间的矩阵，viewport是从ndc空间转换到屏幕坐标的矩阵，要注意的是中间其实还有一步从裁剪空间坐标转移到ndc空间的变换，方法很简单，只需要给x、y、z、w都除以w即可，因此我没有单写它的矩阵，但大家千万不要忘了这一步。
在三维世界中，相机是一个非常重要的物体，它决定了视口的视野。由于一般情况下游戏引擎中的相机以对象的形式呈现，因此我把这里的相机单独做成了一个类。
1 #ifndef MAINCAMERA_H
2 #define MAINCAMERA_H
3 #include"vector3d.h"
4
5 class maincamera
6 {
7 public:
8 Vector3D pos,goal,up;
9 float fov,asp,near,far;
10 public:
11 maincamera();
12 maincamera(Vector3D mpos,Vector3D mgoal,Vector3D mup,float mfov,float masp,float mnear,float mfar);
13 void rotateY(float angle);
14 };
首先相机作为一种对象（游戏物体），成员参数必须包括它在世界空间中的位置（pos）和旋转角度（这里使用的goal和up，分别表示相机看向的点以及相机自身的z轴方向，通过这两个向量可以唯一确定下来相机的旋转角度）。此外，在空间变换中我们知道：相机空间向裁剪空间变换时，其裁剪矩阵由相机的张角（fov）、asp（宽高比）、near（近裁剪面距离）、far（远裁剪面距离）来决定，因此这四个变量也必须要定义。
成员函数比较简单，构造函数种可以对相机的transform和属性参数进行设置，这里定义了一个rotateY函数，作用就是绕着Y轴旋转angle的角度，每帧调用rotateY就可以起到一种环绕浏览的效果。
1 #include "maincamera.h"
2 #include "vector4d.h"
3 #include "matrix.h"
4 #include "stdio.h"
5
6 maincamera::maincamera()
7 {
8 pos=Vector3D(0,4,-8);
9 goal=Vector3D(0,0,0);
10 up=Vector3D(0,1,0);
11 fov=45*3.14/180.f;
12 asp=1280/767.f;
13 near=1.f;
14 far=50.f;
15 }
16 maincamera::maincamera(Vector3D mpos, Vector3D mgoal, Vector3D mup, float mfov, float masp, float mnear, float mfar)
17 {
18 pos=mpos;
19 goal=mgoal;
20 up=mup;
21 fov=mfov;
22 asp=masp;
23 near=mnear;
24 far=mfar;
25 }
26
27 void maincamera::rotateY(float angle)
28 {
29 Vector4D pos4(pos.x,pos.y,pos.z,1);
30 Matrix rot;
31 rot.normalize();
32 rot.rotationY(angle);
33 pos4=rot*pos4;
34 pos.setX(pos4.x);
35 pos.setY(pos4.y);
36 pos.setZ(pos4.z);
37 }
现在我们得到了一个相机类。相机需要在执行渲染管线之前被创建出来，因此我们在renderroute类的loop中实例化一个相机类：maincamera *camera=new maincamera; 然后在渲染循环中把相机传入：pipeline->drawIndex(Pipeline::Fill,camera);
此时我们需要考虑的事情是：相机数据在管线中的什么位置会被用到。回顾渲染流水线的流程，我们可以知道，相机这个概念最早出现在顶点着色器中。在VS里，我们要将顶点从模型空间变换到裁剪空间，其中从世界空间变换到相机空间、从相机空间变换到裁剪空间这两大变换都需要相机数据。此时我们更改一下BasicShader类：
1 #ifndef BASICSHADER_H
2 #define BASICSHADER_H
3 #include "shader.h"
4 #include "polygon.h"
5 #include "matrix.h"
6
7 class BasicShader: public Shader
8 {
9 private:
10 Matrix Mm2w;
11 Matrix Mw2v;
12 Matrix Mv2p;
13 public:
14 BasicShader();
15 ~BasicShader(){}
16 virtual void setCam(Vector3D pos,Vector3D goal,Vector3D up,float fov,float asp,float near,float far);
17 virtual V2F vertexShader(const Vertex &in);
18 virtual Vector4D fragmentShader(const V2F &in);
19 };
20
21 #endif // BASICSHADER_H
其实就增加了三个变换矩阵：Mm2w是模型转世界，Mw2v是世界转相机，Mv2p是相机转裁剪。此外我们还增加了一个setCam函数，通过相机数据来设置上述的三大矩阵——通过pos,goal,up来构造Mw2v矩阵，通过fov,asp,near,far来构造Mv2p矩阵。因为是要构造矩阵，因此可以在matrix类里补充这两个构造矩阵的函数。
根据空间变换的内容，我们可以得到.cpp文件中setCam函数的具体写法：
1 #include "basicshader.h"
2
3 BasicShader::BasicShader()
4 {
5 Mm2w.normalize();
6 Mw2v.normalize();
7 Mv2p.normalize();
8 }
9 void BasicShader::setCam(Vector3D pos,Vector3D goal,Vector3D up,float fov,float asp,float near,float far)
10 {
11 Mw2v.lookat(pos,goal,up);
12 Mv2p.perspective(fov,asp,near,far);
13 }
14 V2F BasicShader::vertexShader(const Vertex &in){
15 V2F ret;
16 ret.posM2W=Mm2w*in.position;
17 ret.posV2P=Mw2v*ret.posM2W;
18 ret.posV2P=Mv2p*ret.posV2P;
19 ret.color=in.color;
20 ret.normal=in.normal;
21 ret.texcoord = in.texcoord;
22 return ret;
23 }
在.cpp文件中我们来获取一下相机参数，这样可以构造出Mw2v和Mv2p两个矩阵了。拥有这些矩阵以后，我们便可以在顶点着色器中编写空间变换的代码了，如上述代码所示。之后我们来修改一下渲染管线中的内容：
1 void Pipeline::drawIndex(RenderMode mode,maincamera *camera)
2 {
3 if(m_indices.empty())return;
4 m_shader->setCam(camera->pos,camera->goal,camera->up,camera->fov,camera->asp,camera->near,camera->far);
5 for(unsigned int i=0;i<m_indices.size() 3="">vertexShader(vv1),v2=m_shader->vertexShader(vv2),v3=m_shader->vertexShader(vv3);
6 v1.posV2P/=v1.posV2P.w;
7 v2.posV2P/=v2.posV2P.w;
8 v3.posV2P/=v3.posV2P.w;
9 v1.posV2P=viewPortMatrix*v1.posV2P;
10 v2.posV2P=viewPortMatrix*v2.posV2P;
11 v3.posV2P=viewPortMatrix*v3.posV2P;
12 m_backBuffer->Cover(static_cast<int>(v1.posV2P.x),static_cast<int>(v1.posV2P.y),v1.color);
13 m_backBuffer->Cover(static_cast<int>(v2.posV2P.x),static_cast<int>(v2.posV2P.y),v2.color);
14 m_backBuffer->Cover(static_cast<int>(v3.posV2P.x),static_cast<int>(v3.posV2P.y),v3.color);
15 if(mode==Wire)
16 {
17 bresenham(v1,v2);
18 bresenham(v1,v3);
19 bresenham(v2,v3);
20 }
21 else if(mode==Fill)
22 {
23 edgeWalkingFillRasterization(v1,v2,v3,1);
24 //edgeWalkingFillRasterization(v1,v2,v3,2);
25 }
26 }
27 }
解析一下上面的代码，在进入管线之后我们要把相机参数给到对应的shader中，然后执行顶点着色器，完成空间变换。此时得到的V2F顶点位于裁剪空间当中，为了得到它们的屏幕坐标，首先要做一下齐次除法（直接除以w，即从裁剪空间变换到ndc空间），然后再乘一下从裁剪空间到屏幕空间中转化的矩阵viewPortMatrix。乘完之后，就得到了每个点的屏幕坐标。要注意的是，qt会对超出屏幕范围的点进行取模运算，这不是我们想要的结果，而且对于超出范围过多的点会导致爆栈，因此我们在光栅化的过程中，我们直接把屏幕之外的片元进行丢弃。
好了，我们的二维转三维的工作就完成了。接下来我们可以在renderRoute中自由定义一个mesh，装一下自己喜欢的几何体形状，然后在while循环中每帧调用相机绕y轴旋转的函数：
1 while(!stopped)
2 {
3 pipeline->clearBuffer(Vector4D(0,0,0,1.0f));
4 pipeline->drawIndex(Pipeline::Fill,camera);
5 pipeline->swapBuffer();
6 emit frameOut(pipeline->output());
7 camera->rotateY(0.01f);
8 }
现在距离转换还差最后一步：深度缓冲。因为我们只能看见离视角最近的内容，看不到远方的被遮挡的，因此我们可以在framebuffer中定义一个深度缓冲，在每次写入像素的时候都做一个如下的判断：
if(current.posV2P.z<=m_backBuffer->depth[xx][yy])
（PS：深度其实可以用屏幕坐标下的z值来表示）
得到的效果如下：
纹理映射
讲道理，纹理映射本是一个很复杂的内容，但是因为前期的框架搭建比较良好+受cpu渲染性能影响没办法引入什么高端的纹理映射算法，因此这部分变得比较简洁。首先话不多说，先定义一个纹理类Texture：
1 #ifndef TEXTURE_H
2 #define TEXTURE_H
3 #include"vector2d.h"
4 #include"vector4d.h"
5 #include<QMainWindow>
6 #include <QString>
7
8 class Textures
9 {
10 private:
11 int width,height,channel;
12 QImage *pixelBuffer;
13 public:
14 Textures();
15 ~Textures();
16 void loadImage(const QString &path);17 Vector4D sample(const Vector2D &texcoord);
18 };
19
20 #endif // TEXTURE_H
这些成员大家应该都比较熟悉了。简单介绍下方法成员，loadImage是从你的磁盘中读入图片，sample就是根据传入的uv坐标，在纹理图上进行采样并返回采样结果。直接上.cpp文件：
1 #include "textures.h"
2 #include "QDebug"
3
4 Textures::Textures()
5 {
6 width=0;
7 height=0;
8 channel=0;
9 pixelBuffer=nullptr;
10 }
11
12 void Textures::loadImage(const QString &path)
13 {
14 pixelBuffer=new QImage();
15 pixelBuffer->load(path);
16 width=pixelBuffer->width();
17 height=pixelBuffer->height();
18 channel=3;
19 }
20
21 Vector4D Textures::sample(const Vector2D &texcoord)
22 {
23 Vector4D result(0.0,0.0,0.0,1.0);
24 unsigned int x = 0, y = 0;
25 double factorU = 0, factorV = 0;
26 if(texcoord.x >= 0.0f && texcoord.x <= 1.0f && texcoord.y >= 0.0f && texcoord.y <= 1.0f)
27 {
28 double trueU = texcoord.x * (width - 1);
29 double trueV = texcoord.y * (height - 1);
30 x = static_cast<unsigned int>(trueU);
31 y = static_cast<unsigned int>(trueV);
32 factorU = trueU - x;
33 factorV = trueV - y;
34 }
35 else
36 {
37 float u = texcoord.x,v = texcoord.y;
38 if(texcoord.x > 1.0f)
39 u = texcoord.x - static_cast<int>(texcoord.x);
40 else if(texcoord.x < 0.0f)
41 u = 1.0f - (static_cast<int>(texcoord.x) - texcoord.x);
42 if(texcoord.y > 1.0f)
43 v = texcoord.y - static_cast<int>(texcoord.y);
44 else if(texcoord.y < 0.0f)
45 v = 1.0f - (static_cast<int>(texcoord.y) - texcoord.y);
46
47 double trueU = u * (width - 1);
48 double trueV = v * (height - 1);
49 x = static_cast<unsigned int>(trueU);
50 y = static_cast<unsigned int>(trueV);
51 factorU = trueU - x;
52 factorV = trueV - y;
53 }
54 Vector3D texels[4];
55
56 pixelBuffer->pixelColor(x,y).red();
57 texels[0].x = static_cast<float>(pixelBuffer->pixelColor(x,y).red()) * 1.0f/255;
58 texels[0].y = static_cast<float>(pixelBuffer->pixelColor(x,y).green()) * 1.0f/255;
59 texels[0].z = static_cast<float>(pixelBuffer->pixelColor(x,y).blue()) * 1.0f/255;
75
76 77 result = texels[0];
78
79 return result;
80 }
loadImage里读取图片的部分是Qt的固定写法，sample函数主要做了两部分：修正uv和采样。修正uv主要指的是如果uv坐标超出了范围，那么要自动进行循环拓展；采样部分比较简单，就是根据uv来对应到图片中的像素。这里本来写了双线性纹理采样，后来发现效果很不明显，而且很吃性能，所以就给去掉了。
那么如何让顶点知道自己用的是哪张纹理图呢？这里我们可以给顶点Vertex和V2F类都增加一个成员变量textureID，用来标识纹理，然后在Shader中把纹理存起来，在片元着色器中根据顶点的textureID编号来选择要采样的纹理：
1 BasicShader::BasicShader()
2 {
3 Mm2w.normalize();
4 Mw2v.normalize();
5 Mv2p.normalize();
6 tex1->loadImage("D:/ice.jpg");
7 tex2->loadImage("D:/metal.jpg");
8 tex3->loadImage("D:/floor.jpg");
9 tex4->loadImage("D:/wall.jpg");
10 }
11
12 Vector4D BasicShader::fragmentShader(const V2F &in){
13 Vector4D retColor;
14 if(in.textureID==1)
15 retColor = tex1->sample(in.texcoord);
16 if(in.textureID==2)
17 retColor = tex2->sample(in.texcoord);
18 if(in.textureID==3)
19 retColor = tex3->sample(in.texcoord);
20 if(in.textureID==4)
21 retColor = tex4->sample(in.texcoord);
22 return retColor;
23 }
最后我们可以得到一个这样的效果：
怎么感觉正方体浮在表面上？仔细观察你会发现地板的纹理在来回扭动，使得正方体的变化和地板的纹理没有对应上，就会给人一种正方体浮在表面上的感觉。这个原因很简单，那就是在投影视角下，uv不再是线性的了。这个问题的解决方式很简单：在顶点着色器中，我们给texcoord除以一下w，这时候uv才会呈线性，此时我们再进行sample采样就能得到正确的结果。（在除以w之后，还要把w记录下来，然后在scanLinePerRow中别忘了再把w乘回来。如果你不在顶点着色器中记录w，渲染管线会在变换到ndc空间时把w置1，之后你再获取w就全是1了）
现在纹理正常了。
收尾——光照
最后我们来看一下光照模型。这里我们直接使用简易的兰伯特模型（因为性能实在罩不住了，太卡了）我们定义一个light类：
1 #ifndef LIGHT_H
2 #define LIGHT_H
3 #include "vector4d.h"
4
5 class Light
6 {
7 public:
8 int kind;
9 float intensity;
10 Vector4D m_pos;
11 Vector4D m_col;
12 public:
13 Light(){}
14 Light(Vector4D pos,Vector4D col,int k,float i){kind=k;intensity=i;m_col=col;m_pos=pos;}
15 Light(Light *l){kind=l->kind;intensity=l->intensity;m_col=l->m_col;m_pos=l->m_pos;}
16 ~Light(){}
17 };
18
19 #endif // LIGHT_H
光照主要就是这几个属性：光照类型（已废弃）、光照强度、光源位置、光源颜色。方法只有个构造函数，.cpp文件直接空白。
接下来我们需要在renderRoute中把光源初始化出来，然后改写一下pipeline中drawIndex方法，把光源的指针传入到渲染管线，然后渲染管线再将光源传入到shader中，注意这步的传入并不是用的函数传参，而是我直接在shader中定义了一个光源成员变量，渲染管线只需要把这个成员变量修改一下即可。（这几步零零散散的改了好几处，而且每处都是一两句代码，所以我就不放具体修改的代码了）
接下来我们开始编写片元着色器，代码如下：
1 Vector4D BasicShader::fragmentShader(const V2F &in){
2 Vector4D retColor;
3 if(in.textureID==1)
4 retColor = tex1->sample(in.texcoord);
5 if(in.textureID==2)
6 retColor = tex2->sample(in.texcoord);
7 if(in.textureID==3)
8 retColor = tex3->sample(in.texcoord);
9 if(in.textureID==4)
10 retColor = tex4->sample(in.texcoord);
11 Vector4D n=Vector4D(in.normal.x,in.normal.y,in.normal.z,1);
12 Vector4D l=lights->m_pos-in.posM2W;
13 n.normalize();
14 l.normalize();
15 Vector4D last=Vector4D(lights->m_col.x*retColor.x,lights->m_col.y*retColor.y,lights->m_col.z*retColor.z,1);
16 float tmp=n.dot(l);
17 if(tmp<0)tmp=0;
18 tmp=powf(tmp,0.8f);
19 if(tmp>0.2f)
20 retColor=last*tmp;
21 else
22 retColor=last*0.2f;
23 tmp*=lights->intensity;
24 retColor.w=1;
25 return retColor;
26 }
首先我们获取到片元的法线，然后获取光源到片元的向量，接下来便可以使用兰伯特模型公式：
Ild = kI(N·L)
其中N表示顶点法向量，L表示从顶点指向光源位置的单位向量（主意指向，不要弄反了）。之后我们再乘一下光照强度，然后再根据效果调整一下强度曲线即可。
以下是最终效果图：
至此，软渲染器的制作完成。
原文链接: https://www.cnblogs.com/puluoji/p/14727605.html
欢迎关注
微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处：https://www.ccppcoding.com/archives/210182
非原创文章文中已经注明原地址，如有侵权，联系删除
关注公众号【高性能架构探索】，第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处！
