软件光栅器(Directx11)三之世界矩阵，相机变换矩阵，透视投影矩阵，透视除法,视口变换矩阵

其实各大矩阵具体的推导过程我就不给出了，我直接给出矩阵具体的形式和实现代码，以及那些大牛推导矩阵详细的文章：

一，世界矩阵(WorldMatrix)

我一般称世界矩阵为SRT矩阵，SRT分别是"Scale","rotate","translate"三个单词的缩写,也就是世界矩阵由缩放矩阵，旋转矩阵，平移矩阵构成的

(1)缩放矩阵(ScaleMatrix)

假设在X轴缩放Sx倍,在Y轴缩放Sy倍,在Z轴缩放Sz倍,缩放如下所示:

点乘以矩阵的公式如下:

\

实现代码:

[cpp]  view plain  copy

1. //构造一个缩放矩阵  
2. Matrix BuildScaleMatrix(float x, float y, float z)  
3. {  
4.     Matrix ScaleMa;  
5.     //清除为0  
6.     ZeroMemory(&ScaleMa, sizeof(ScaleMa));  
7.   
8.     ScaleMa.ma[0][0] = x;  
9.     ScaleMa.ma[1][1] = y;  
10.     ScaleMa.ma[2][2] = z;  
11.     ScaleMa.ma[3][3] = 1.0f;  
12.     return  ScaleMa;  
13. }  

(2)旋转矩阵(RotateMatrix)

在说明旋转矩阵之前，我得说明一下，在左手坐标系如何判断哪个方向为顺时针方向旋转。

先来看下面的图(本人画工有点差，请见谅)，我们先用左手的拇指朝向Y的正方向，则四指所绕的方向也就是饶Y轴渲染的顺时针方向了，其它轴的顺时针方向同理也就是这样判断。（其他轴的顺时针旋转方向以及右手坐标系的顺时针也是用这样的方法判断，只不过右手坐标系下改为了使用右手）

一,绕X轴顺时针旋转Θ度数

实现代码:

[cpp]  view plain  copy

1. //构造一个绕X轴的旋转矩阵,形参为角度,顺时针  
2. Matrix BuildRotateXMatrix(float x)  
3. {  
4.     Matrix RotateXMa;  
5.     //清除为0  
6.     ZeroMemory(&RotateXMa, sizeof(RotateXMa));  
7.   
8.     //度数转化为弧度，math库的函数的参数都是弧度  
9.     float angle = (x *MATH_PI) / (180.0f);  
10.   
11.     RotateXMa.ma[0][0] = 1.0f;  
12.     RotateXMa.ma[3][3] = 1.0f;  
13.   
14.     float cs = (float)cos(angle);  
15.     float ss = (float)sin(angle);  
16.     RotateXMa.ma[1][1] = cs;  
17.     RotateXMa.ma[2][2] = cs;  
18.     RotateXMa.ma[1][2] = ss;  
19.     RotateXMa.ma[2][1] = -ss;  
20.   
21.     return RotateXMa;  
22. }  

二,绕Y轴顺时针旋转Θ度数

实现代码:

[cpp]  view plain  copy

1. //构造一个绕Y轴的旋转矩阵,形参为角度，顺时针  
2. Matrix BuildRotateYMatrix(float y)  
3. {  
4.     Matrix RotateYMa;  
5.     //清除为0  
6.     ZeroMemory(&RotateYMa, sizeof(RotateYMa));  
7.   
8.     //度数转化为弧度，math库的函数的参数都是弧度  
9.     float angle = (y *MATH_PI) / (180.0f);  
10.   
11.     RotateYMa.ma[1][1] = 1.0f;  
12.     RotateYMa.ma[3][3] = 1.0f;  
13.   
14.     float cs = (float)cos(angle);  
15.     float ss = (float)sin(angle);  
16.     RotateYMa.ma[0][0] = cs;  
17.     RotateYMa.ma[2][2] = cs;  
18.     RotateYMa.ma[0][2] = -ss;  
19.     RotateYMa.ma[2][0] = ss;  
20.   
21.     return RotateYMa;  
22. }  

三,绕Z轴顺时针旋转Θ度数

实现代码:

[cpp]  view plain  copy

1. //构造一个绕Z轴的旋转矩阵,形参为角度，顺时针  
2. Matrix BuildRotateZMatrix(float z)  
3. {  
4.     Matrix RotateZMa;  
5.     //清除为0  
6.     ZeroMemory(&RotateZMa, sizeof(RotateZMa));  
7.   
8.     RotateZMa.ma[2][2] = 1.0f;  
9.     RotateZMa.ma[3][3] = 1.0f;  
10.   
11.     //度数转化为弧度，math库的函数的参数都是弧度  
12.     float angle = (z *MATH_PI) / (180.0f);  
13.   
14.     float cs = (float)cos(angle);  
15.     float ss = (float)sin(angle);  
16.     RotateZMa.ma[0][0] = cs;  
17.     RotateZMa.ma[1][1] = cs;  
18.     RotateZMa.ma[0][1] = ss;  
19.     RotateZMa.ma[1][0] = -ss;  
20.   
21.     return RotateZMa;  
22. }  

(3)移动矩阵(TranslateMatrix)

假设某个顶点在X轴方向移动dx个单位,Y轴移动dy个单位,在Z轴移动dz个单位

实现代码:

[cpp]  view plain  copy

1. //构造一个移动矩阵  
2. Matrix BuildTranslateMatrix(float x,float y,float z)  
3. {  
4.     Matrix TranslateMa;  
5.     //清除为0  
6.     ZeroMemory(&TranslateMa, sizeof(TranslateMa));  
7.     TranslateMa.ma[0][0] = 1.0f;  
8.     TranslateMa.ma[1][1] = 1.0f;  
9.     TranslateMa.ma[2][2] = 1.0f;  
10.     TranslateMa.ma[3][3] = 1.0f;  
11.   
12.     TranslateMa.ma[3][0] = x;  
13.     TranslateMa.ma[3][1] = y;  
14.     TranslateMa.ma[3][2] = z;  
15.     return TranslateMa;  
16. }  

关于缩放矩阵，旋转矩阵，移动矩阵的详细推导见《Introduction+to+3D+Game+Programming+with+DirectX+11》第三章

二，相机变换矩阵(ViewMatrix)

在此之前看看UVN相机模型，如图所示：

注视向量N的方向跟相机空间(ViewSpace)的Z轴方向是一致的，而竖直向量V的方向与相机空间(ViewSpace)的Y轴方向是一致的，右向量U的方向与相机空间(ViewSpace)的X轴方向是一致的。

计算UVN向量的公式如下:

这里的“X”为叉乘的意思，并且一样可以通过左手规则(因为本格软件光栅器用的是模拟的为Directx11,为左手坐标系)得到叉乘向量的方向，也就是用左手从叉乘符号左边那个向量绕向叉乘符号右边的那个向量，拇指所指方向即为叉乘得到向量的方向。

相机矩阵如下所示：

实现代码:

[cpp]  view plain  copy

1. //建立一个左手坐标系的相机变换矩阵  
2. Matrix MatrixLookAtLH(Point* Eye, Point* LookAt, Vector* Up)  
3. {  
4.     Vector N;  
5.     Vector U;  
6.     Vector V;  
7.   
8.     //求出注视向量N  
9.     N.x = LookAt->x - Eye->x;  
10.     N.y = LookAt->y - Eye->y;  
11.     N.z = LookAt->z - Eye->z;  
12.     N.w = 0.0f;  
13.   
14.     //用叉乘求出右向量U，U=UpxN;  
15.     U = VectorCrossProduct(Up, &N);  
16.   
17.     //用叉乘求出V，V=NxU  
18.     V = VectorCrossProduct(&N, &U);  
19.   
20.     //规格化UVN三个向量  
21.     VectorNormalize(&U);  
22.     VectorNormalize(&V);  
23.     VectorNormalize(&N);  
24.   
25.     //求出-EyeU -EyeV -EyeN  
26.     float x1 = -VectorDotProduct(Eye, &U);  
27.     float y1 = -VectorDotProduct(Eye, &V);  
28.     float z1 = -VectorDotProduct(Eye, &N);  
29.   
30.     //求出相机变换矩阵  
31.     Matrix mViewMatrix;  
32.     ZeroMemory(&mViewMatrix, sizeof(mViewMatrix));  
33.     mViewMatrix.ma[0][0] = U.x;  
34.     mViewMatrix.ma[1][0] = U.y;  
35.     mViewMatrix.ma[2][0] = U.z;  
36.     mViewMatrix.ma[3][0] = x1;  
37.   
38.     mViewMatrix.ma[0][1] = V.x;  
39.     mViewMatrix.ma[1][1] = V.y;  
40.     mViewMatrix.ma[2][1] = V.z;  
41.     mViewMatrix.ma[3][1] = y1;  
42.   
43.     mViewMatrix.ma[0][2] = N.x;  
44.     mViewMatrix.ma[1][2] = N.y;  
45.     mViewMatrix.ma[2][2] = N.z;  
46.     mViewMatrix.ma[3][2] = z1;  
47.   
48.     mViewMatrix.ma[3][3] = 1.0f;  
49.       
50.     return mViewMatrix;  
51. }  

具体推导见文章： 推导相机变换矩阵

三，透视投影矩阵(PerspectiveMatrix)

在推导透视投影矩阵前先看看视截体(Frustum)是怎么样的:

我的渲染器，近截面和投影平面是同一个平面，视截体在YZ平面的投影如下面图所示,

n为原点到近截面的距离,f为原点到远截面的距离，α为视截体在YZ平面投影的FOV视角，r为投影平面的宽高比,则透视投影矩阵为:

实现代码:

[cpp]  view plain  copy

1. //建立一个左手坐标系的透视投影矩阵,注意为左手坐标系下的，视平面和近截面为同一个平面,FOV视角为YZ屏幕的  
2. Matrix MatrixPerspectiveFovLH(float FovYZ,float ScreenAspect,float ScreenNear,float ScreenFar)  
3. {  
4.     Matrix mProjMatrix;  
5.       
6.     //清除为0  
7.     ZeroMemory(&mProjMatrix, sizeof(mProjMatrix));  
8.   
9.     //度数转化为弧度，math库的函数的参数都是弧度  
10.     float angle = (FovYZ *MATH_PI)/ (180.0f);  
11.   
12.     //半角  
13.     angle /= 2.0f;  
14.   
15.     //求出各类参数  
16.     float s1 = 1 / (ScreenAspect*(float)tan(angle));  
17.     float s2 = 1 / tan(angle);  
18.     float a = ScreenFar / (ScreenFar - ScreenNear);  
19.     float b = -(ScreenNear*ScreenFar) / (ScreenFar - ScreenNear);  
20.       
21.     mProjMatrix.ma[0][0] = s1;  
22.     mProjMatrix.ma[1][1] = s2;  
23.     mProjMatrix.ma[2][2] = a;  
24.     mProjMatrix.ma[3][2] = b;  
25.     mProjMatrix.ma[2][3] = 1.0f;  
26.   
27.     return mProjMatrix;  
28. }  

具体推导参见文章:  

深入探索透视投影变换 和  深入探索透视投影变换(续)

四，透视除法:

透视除法的本质：

假设有一个向量为(x,y,z,w),进行透视除法也就是把向量的每个参数除以向量的第四个参数,得到(x/w,y/w,z/w,1)

参见  深入探索透视投影变换 和  深入探索透视投影变换(续)

实现代码:

[cpp]  view plain  copy

1. //对点集进行透视除法,会后变到NDC空间  
2. void PerspectiveDivede(vector<Vertex>& pList)  
3. {  
4.     for (vector<Vertex>::iterator it = pList.begin(); it != pList.end(); ++it)  
5.     {  
6.         (*it).x = (*it).x / (*it).w;  
7.         (*it).y = (*it).y / (*it).w;  
8.         (*it).z = (*it).z / (*it).w;  
9.         (*it).w = (*it).w / (*it).w;  
10.     }  
11. }  

五，视口变换矩阵(ViewPortMatrix)

实际上在D3D11中，不需要我们手动进行视口变换的，D3D11给我们提供了一个接口,我们在这个接口填充参数，然后D3D11在内部自动帮我们进行视口变换了，那个接口如下图所示:

生成相应的视口矩阵:

解释一下上面的参数，TopLeftX和TopLeftY为视平面在左上角的坐标点，一般来说都为0。Width为视平面的宽度，Height为视平面的高度，MinDepth为顶点的最小深度(Z缓存),

MaxDepth为顶点的最大深度(Z缓存),一般来说MinDepth为0，MaxDepth为1.

所以一般视口变换矩阵为下面所示:

实现代码:

[cpp]  view plain  copy

1. }  
2.   
3. //一般而言，视口变换矩阵的TopLeftX=0,TopLeftY=0,MaxDepth=1.0,MinDepth=0.0  
4. Matrix  MatrixViewPort(float ScreenWidth, float ScreenHeight, float MaxDepth, float MinDepth, float TopLeftX, float TopLeftY)  
5. {  
6.     Matrix MatrixViewPort;  
7.   
8.     //清除为0  
9.     ZeroMemory(&MatrixViewPort, sizeof(MatrixViewPort));  
10.   
11.     MatrixViewPort.ma[0][0] = ScreenWidth / 2.0f;  
12.     MatrixViewPort.ma[1][1] = -ScreenHeight/ 2.0f;  
13.     MatrixViewPort.ma[2][2] = MaxDepth - MinDepth;  
14.     MatrixViewPort.ma[3][0] = TopLeftX + ScreenWidth / 2.0f;  
15.     MatrixViewPort.ma[3][1] = TopLeftY+ ScreenHeight / 2.0f;  
16.     MatrixViewPort.ma[3][2] = MinDepth;  
17.     MatrixViewPort.ma[3][3] = 1.0f;  
18.   
19.     return MatrixViewPort;  
20. }  

具体推导参见《Introduction+to+3D+Game+Programming+with+DirectX+11》的第十六章的16.1小节

实现代码: