3D坐标系和点

3D 空间通常用 3 个坐标轴即 x、 y 和 z 来表示。OpenGL 中的坐标系大都是右手坐标系。

3D 空间中的点可以通过使用形如(2, 8, −3)的符号列出 x、y、z 的值来表示。不过，如果用齐次坐标——一种在 19 世纪初首次描述的表示法来表示点会更有用。在每个点的齐次坐标有 4 个值，前 3 个值表示 x、y 和 z，第四个值 w 总是非零值，通常为 1。因此，我们会将之前的点表示为(2, 8, −3, 1)。

齐次坐标将会使我们的图形计算更高效。

用来存储齐次 3D 坐标的 GLSL 数据类型是 vec4（“ vec”代表向量， 同时也可以用来表示点）。GLM 库包含适合在 C++/OpenGL 应用程序中创建和存储含有 3 个和 4 个坐标的（齐次） 点的类，分别叫作 vec3 和 vec4。

矩阵

$$\left[\begin{array}{cccc}{A}_{00}& A_{01}& A_{02}& A_{03}\\ A_{10}& A_{11}& A_{12}& A_{13}\\ A_{20}& A_{21}& A_{22}& A_{23}\\ A_{30}& A_{31}& A_{32}& A_{33}\end{array}\right]$$

GLSL语言中的mat4数据类型用来存储4×4矩阵。同样，GLM库中有mat4类用以实例化并存储4×4矩阵。

单位矩阵

一条对角线的值为1，其余值全为0。

$$\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

任何值乘以单位矩阵都不会改变。

单位矩阵也可以简单地记为一个对角线矩阵：E_n = diag(1,1,…,1)
根据矩阵乘法的定义，单位矩阵的重要性质为：AE_n = A；E_nA = A

在GLM中，调用构造函数glm::mat4 m(1.0f);以在变量m中生成单位矩阵。

转置矩阵

矩阵转置的计算是通过交换矩阵的行与列完成的。转置，就是旋转置换的意思；给定一个mxn的矩阵，则A的转置就是nxm的矩阵，用 A^T 表示。例如：

$$\left[\begin{array}{cccc}{A}_{00}& A_{01}& A_{02}& A_{03}\\ A_{10}& A_{11}& A_{12}& A_{13}\\ A_{20}& A_{21}& A_{22}& A_{23}\\ A_{30}& A_{31}& A_{32}& A_{33}\end{array}\right]={\left[\begin{array}{cccc}{A}_{00}& A_{10}& A_{20}& A_{30}\\ A_{01}& A_{11}& A_{21}& A_{31}\\ A_{02}& A_{12}& A_{22}& A_{32}\\ A_{03}& A_{13}& A_{23}& A_{33}\end{array}\right]}^{\mathbf{T}}$$

转置矩阵特性：
1、(A^ᵀ)^ᵀ = A
2、(A+B)^ᵀ = A^ᵀ + B^ᵀ
3、对任意数r，(rA)^ᵀ = rA^ᵀ
4、(AB)^ᵀ = B^ᵀA^ᵀ

GLSL库和GLM库都有转置函数，分别是transpose(mat4)和glm::transpose(mat4)。

逆矩阵

一个4×4矩阵的逆矩阵是另一个4×4矩阵，用 M^-1 表示。

在矩阵乘法中有如下性质：
M×M^-1 = M^-1×M = 单位矩阵 E
若 AB = BA = E，则 A 是可逆的，B 是 A 的逆矩阵（B=A^-1）。
若A可逆，则A^-1亦可逆，且：(A^-1)^-1 = A
若A可逆，则A^T亦可逆，且：(A^T)^-1=(A^-1)^T
若A、B为同阶方阵且均可逆，则AB亦可逆，且：(AB)^-1=B^-1A^-1

GLSL和GLM都提供了mat4.inverse()函数完成矩阵的逆矩阵运算。

逆转置矩阵

要对向量 V 使用变换矩阵 M 进行与对点相同的变换，一般需要计算 M 的逆转置矩阵，记为 (M^-1)^T，并用所得矩阵乘 V。在某些情况下， M=(M^-1)^T，在这些情况下只要用 M 就可以了。

矩阵的运算

矩阵加法(+)

$$\left[\begin{array}{cccc}A+a& B+b& C+c& D+d\\ E+e& F+f& G+g& H+h\\ I+i& J+j& K+k& L+l\\ M+m& N+n& O+o& P+p\end{array}\right]=\left[\begin{array}{cccc}A& B& C& D\\ E& F& G& H\\ I& J& K& L\\ M& N& O& P\end{array}\right]+\left[\begin{array}{cccc}a& b& c& d\\ e& f& g& h\\ i& j& k& l\\ m& n& o& p\end{array}\right]$$

GLSL 和 GLM 都支持使用重载后的加法“+”运算符，进行矩阵加法。

矩阵乘法(×)

$\left[\begin{array}{cccc}A& B& C& D\\ E& F& G& H\\ I& J& K& L\\ M& N& O& P\end{array}\right]\times \left[\begin{array}{cccc}a& b& c& d\\ e& f& g& h\\ i& j& k& l\\ m& n& o& p\end{array}\right]=$
$\left[\begin{array}{cccc}Aa+Be+Ci+Dm& Ab+Bf+Cj+Dn& Ac+Bg+Ck+Do& Ad+Bh+Cl+Dp\\ Ea+Fe+Gi+Hm& Eb+Ff+Gj+Hn& Ec+Fg+Gk+Ho& Ed+Fh+Gl+Hp\\ Ia+Je+Ki+Lm& Ib+Jf+Kj+Ln& Ic+Jg+Kk+Lo& Id+Jh+Kl+Lp\\ Ma+Ne+Oi+Pm& Mb+Nf+Oj+Pn& Mc+Ng+Ok+Po& Md+Nh+Ol+Pp\end{array}\right]$

矩阵相乘也经常叫作合并。
我们需要经常将相同的一系列矩阵变换应用到场景中的每个点上。通过预先一次计算好这些矩阵的合并，就可以成倍减少总的矩阵运算量。

GLSL 和 GLM 都支持使用重载后的乘法“ * ”运算符，进行矩阵乘法。

点与矩阵相乘（点 左乘 矩阵），得到新点：

${\left[\begin{array}{cccc}A& B& C& D\\ E& F& G& H\\ I& J& K& L\\ M& N& O& P\end{array}\right]}_{4\times 4}\times {\left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)}_{4\times 1}={\left(\begin{array}{c}Ax+By+Cz+D\\ Ex+Fy+Gz+H\\ Ix+Jy+Kz+L\\ Mx+Ny+Oz+H\end{array}\right)}_{4\times 1}$

我们用齐次坐标将点(X, Y, Z)表示为列数为1的矩阵。
注意，矩阵乘法不满足 交换律 。（很容易证明交换律不成立）

矩阵乘法满足 结合律：(很容易证明结合律成立)
Now Point = M₁×(M₂×(M₃×Point)) == (M₁×M₂×M₃)×Point（ = M_123合并×Point）

常用的变换矩阵

变换矩阵的重要特性之一就是它们都是 4× 4 矩阵。这是因为我们决定使用齐次坐标系。否则，各变换矩阵可能会有不同的维度并且无法相乘。正如我们所见，确保变换矩阵大小相同并不只是为了方便，同时让它们可以任意组合，进行预先计算变换矩阵以提升性能。

平移矩阵

平移矩阵用于将物体从一个位置移至另一位置。

下面展示了平移矩阵和它与齐次坐标点相乘的效果——平移矩阵变换：(若非齐次坐标，无法进行)
$$\left[\begin{array}{cccc}1& 0& 0& T_x\\ 0& 1& 0& T_y\\ 0& 0& 1& T_z\\ 0& 0& 0& 1\end{array}\right]\times \left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)=\left(\begin{array}{c}x+T_x\\ y+T_y\\ z+T_z\\ 1\end{array}\right)$$

( )是代表单列矩阵，也能用向量vector代表，[ ]是代表矩阵matrix。

平移矩阵变换的结果：
点(x, y, z)平移到了位置(x+T_x, y+T_y, z+T_z)

例如，将一组点向上沿Y轴正方向移动5个单位，可以通过给一个单位矩阵的T_y位置放入5来构建平移矩阵。之后只需将想要移动的点与矩阵左乘就可以了。

GLM中有一些函数是用于构建与点相乘的平移矩阵的。相关操作有：

• mat4 glm::translate(mat4 const& m, vec3 const& v) 通过3元素向量，构建4×4平移变换矩阵；
• mat4 × vec4 // 4×4矩阵 × 4元素向量 => 新4元素向量。

一般是用单位矩阵来使3元素平移向量生成平移变换矩阵：
glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(x,y,z));
结果如下：
$\left[\begin{array}{cccc}1& 0& 0& x\\ 0& 1& 0& y\\ 0& 0& 1& z\\ 0& 0& 0& 1\end{array}\right]$
可见，刚好满足平移变换矩阵的格式。

注：对于vec3 类型，要用它可以与乘以的 4×4 矩阵兼容，需要将其转换为 vec4 类型，这个转换是用 vec4(vec3, 1.0)完成的。

从 3 元素的向量创建一个 4×4 的转换矩阵：
mat<4,4,T,Q> glm::translate(mat<4,4,T,Q> const& m, vec<3,T,Q> const& v)
m - 输入矩阵乘以这个平移矩阵。
v - 平移向量的坐标。
$\left[\begin{array}{cccc}{v}_x& 0& 0& 0\\ 0& v_y& 0& 0\\ 0& 0& v_z& 0\\ 0& 0& 0& 1\end{array}\right]=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]\left(\begin{array}{c}{v}_x\\ v_y\\ v_z\\ 1\end{array}\right)$
平移变换矩阵：glm::mat4 t = glm::translate(glm::mat4(1.0f), glm::vec3(v_x, v_y, v_z));

缩放矩阵

缩放矩阵用于改变物体的大小或者将点向原点相反方向移动。虽然缩放点这个操作乍一看有点奇怪，不过 OpenGL 中的物体都是用一组或多组的点定义的。因此，缩放物体涉及缩放它的点的集合。

下面展示了缩放矩阵的形式和当它与齐次坐标点相乘的效果——经过缩放值修改后的新点。
$$\left(\begin{array}{c}x\ast S_x\\ y\ast S_y\\ z\ast S_z\\ 1\end{array}\right)=\left[\begin{array}{cccc}{S}_x& 0& 0& 0\\ 0& S_y& 0& 0\\ 0& 0& S_z& 0\\ 0& 0& 0& 1\end{array}\right]\times \left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)$$
GLM中有一些函数是用于构建与点相乘的缩放矩阵的。相关操作有：
glm::scale(x, y, z) 构建缩放(x, y, z)的矩阵。以上式子的表示为:mat4 * vec4

缩放还可以用来 切换坐标系：
例如，可以用缩放来在给定右手坐标系的情况下确定左手坐标。

从上图可以看到通过反转Z坐标就可以从右手坐标切换为左手坐标。因此，用来切换坐标系的缩放矩阵变换是：
$$\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& -1& 0\\ 0& 0& 0& 1\end{array}\right]$$

旋转矩阵

旋转会稍微复杂一些，因为在 3D 空间中旋转物体需要指定旋转轴和旋转的角度或弧度。

数学家莱昂哈德· 欧拉表明，围绕任何轴的旋转都可以表示为绕 X、Y、Z 轴旋转的组合。围绕这 3 个轴的旋转角度被称为欧拉角。 这个被称为欧拉定理的发现，对我们很有用，因为对于每个坐标轴的旋转可以用矩阵变换来表示。

ⓐ绕 X 轴旋转θ度：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ z^{\prime }\\ 1\end{array}\right)=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& cos\theta & -sin\theta & 0\\ 0& sin\theta & cos\theta & 0\\ 0& 0& 0& 1\end{array}\right]\times \left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)$$
ⓑ绕 Y 轴旋转θ度：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ z^{\prime }\\ 1\end{array}\right)=\left[\begin{array}{cccc}cos\theta & 0& sin\theta & 0\\ 0& 1& 0& 0\\ -sin\theta & 0& cos\theta & 0\\ 0& 0& 0& 1\end{array}\right]\times \left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)$$
ⓒ绕 Z 轴旋转θ度：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ z^{\prime }\\ 1\end{array}\right)=\left[\begin{array}{cccc}cos\theta & -sin\theta & 0& 0\\ sin\theta & cos\theta & 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]\times \left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)$$
因sin²θ+cos²θ=1，cosθ=cos(-θ)，sinθ=-sinθ，所以显然有：基础旋转矩阵与它们的逆转置矩阵相等。

粗略推导 [旋转矩阵]
我们这里只推导点绕Z轴旋转的旋转矩阵，绕其他轴旋转的推导过程类似。

空间中任意一点 p(x₀,y₀,z₀) 绕 Z 轴旋转 β 角到点 p’(x’₀,y’₀,z’₀)，对应的在XOY平面上的垂直投影点分别为点 P(x,y,z) 和 点 P’(x’,y’,z’)，有：
 
$\{\begin{array}{l}x=r\ast cos\alpha \\ y=r\ast sin\alpha \end{array}$
 
$\{\begin{array}{l}{x}^{\prime }=r\ast cos(\alpha +\beta )=r\ast cos\alpha \ast cos\beta -r\ast sin\alpha \ast sin\beta =x\ast cos\beta -y\ast sin\beta \\ y^{\prime }=r\ast sin(\alpha +\beta )=r\ast sin\alpha \ast sin\beta +r\ast cos\alpha \ast cos\beta =x\ast sin\beta +y\ast cos\beta \end{array}$
 
$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right)=\left[\begin{array}{cc}cos\beta & -sin\beta \\ sin\beta & cos\beta \end{array}\right]\left(\begin{array}{c}x\\ y\end{array}\right)$
 
绕 Z 轴旋转，z坐标是不变的，即：
$\begin{array}{c}{z}^{\prime }=z\end{array}$
则有：
$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ z^{\prime }\end{array}\right)=\left[\begin{array}{ccc}cos\beta & -sin\beta & 0\\ sin\beta & cos\beta & 0\\ 0& 0& 1\end{array}\right]\left(\begin{array}{c}x\\ y\\ z\end{array}\right)$
用齐次坐标表示为：
$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ z^{\prime }\\ 1\end{array}\right)=\left[\begin{array}{cccc}cos\beta & -sin\beta & 0& 0\\ sin\beta & cos\beta & 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]\left(\begin{array}{c}x\\ y\\ z\\ 1\end{array}\right)$

欧拉角在某些 3D 图形应用中会导致一些问题。因此，通常在计算旋转时推荐使用四元数。不过欧拉角足以满足我们的大部分需求。

透视矩阵

$$\left[\begin{array}{cccc}A& 0& 0& 0\\ 0& q& 0& 0\\ 0& 0& B& C\\ 0& 0& 0& 0\end{array}\right]$$
其中，
$$\begin{gathered} q=\frac{1}{\tan (\frac{fieldOfView}{2})}A=\frac{q}{aspectRatio} \\ ▫ \\ B=\frac{Z_{near}+Z_{far}}{Z_{near}-Z_{far}}C=\frac{2\ast (Z_{near}\ast Z_{far})}{Z_{near}-Z_{far}} \end{gathered}$$

glm::perspective(<fieldOfView>, <aspectRatio>, <nearPlane>, <farPlane>);
<fieldOfView>=FOV角，<aspectRatio>=W/H，
<nearPlane>=Z_near，<farPlane>=Z_far

正射投影矩阵

$$\left[\begin{array}{cccc}\frac{2}{R-L}& 0& 0& -\frac{R+L}{R-L}\\ & & & \\ 0& \frac{2}{T-B}& 0& -\frac{T+B}{T-B}\\ & & & \\ 0& 0& \frac{1}{Z_{far}-Z_{near}}& -\frac{Z_{near}}{Z_{far}-Z_{near}}\\ & & & \\ 0& 0& 0& 1\end{array}\right]$$

LookAt矩阵

$$\begin{gathered} \overrightarrow{fwd}=normalize(\overrightarrow{eye}-\overrightarrow{target}) \\ \overrightarrow{side}=normalize(\overrightarrow{-fwd}\times \overrightarrow{up}) \\ \overrightarrow{up}=normalize(\overrightarrow{side}\times \overrightarrow{(-fwd)}) \\ ———————————————————— \\ \left[\begin{array}{cccc}\overrightarrow{sid{e}_x}& \overrightarrow{sid{e}_y}& \overrightarrow{sid{e}_z}& \overrightarrow{-(side\cdot \stackrel{⃗}{eye)}}\\ \overrightarrow{u{p}_x}& \overrightarrow{u{p}_y}& \overrightarrow{u{p}_z}& \overrightarrow{-(up\cdot \stackrel{⃗}{eye)}}\\ \overrightarrow{-fw{d}_x}& \overrightarrow{-fw{d}_y}& \overrightarrow{-fw{d}_z}& \overrightarrow{-(-fwd\cdot \stackrel{⃗}{eye)}}\\ 0& 0& 0& 1\end{array}\right] \end{gathered}$$
在GLM中已经有一个用来构建LookAt矩阵的函数glm::lookAt(eye, center, up)。

template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4,4,T,Q> lookAt(
	const vec<3,T,Q>& eye,    // eye position in worldspace
	const vec<3,T,Q>& center, // the point where we look at
	const vec<3,T,Q>& up      // the vector of upwords(your head is up)
)
——————————————————————————————————————
作用：基于默认的左右手法则构建一个LookAt矩阵。
参数：
   eye 相机位置
center 相机注视的位置(即目标位置)
    up 归一化的向上失量，指明相机的方位
模板参数：
T 一个浮点标量类型
Q 一个限定符，值是枚举常量值

理解参数——up向量：
把相机想象成自己的脑袋，那么：
eye - 脑袋的位置；
center - 脑袋看的方向；
up - 脑袋看物体的姿态(因为可以歪着头看同一个物体)。

该函数定义一个视图矩阵，其中：
eye - 相机在世界坐标的位置；
center - 相机镜头对准的物体在世界坐标的位置；
up - 指明世界坐标中相机向上的方位(并不是说此时相机的向上方位！

此向量基本上是一个定义世界“向上”方向的向量。
它不得与从视点到参考点的视线平行。
在几乎所有正常情况下，这将是向量(0, 1, 0)，即朝向正Y。

向量

假设有向量 A(u, v, w) 和 B(x, y, z)。
归一化（将长度为为1）：
$$\hat{A}=\frac{\vec{A}}{|A|}=\frac{\vec{A}}{\sqrt{u^2+v^2+w^2}}$$
glm/GLSL：normalize(vec3 or vec4)

加法和减法

$$\vec{A}\pm \vec{B}=(u\pm x,v\pm y,w\pm z)=\overrightarrow{BA}$$

点积

$$\vec{A}\cdot \vec{B}=ux+vy+wz$$
glm/GLSL：dot(vec3/vec4, vec3/vec4)

点积最重要也最基本的应用就是求两向量夹角。高向量V和W，计算其夹角θ：
$$\begin{gathered} \vec{V}\cdot \vec{W}=|\vec{V}||\vec{W}|cos\theta \\ cos\theta =\frac{\vec{V}\cdot \vec{W}}{|\vec{V}||\vec{W}|} \end{gathered}$$
因此，如果 V 和 W 是归一化向量（有着单位长度的向量，这里用“^”标记），则有：
$$\begin{gathered} cos\theta =\hat{V}\cdot \hat{W} \\ \theta =\arccos (\hat{V}\cdot \hat{W}) \end{gathered}$$
点积同时还有许多其他用途：

• 求向量的大小：$\sqrt{\vec{V}\cdot \vec{V}}$
• 判断两向量是否正交，若正交，则$\vec{V}\cdot \vec{W}=0$
• 判断两向量是否同向，若同向，则$\vec{V}\cdot \vec{W}=|\vec{V}||\vec{W}|$；若反向，则$\vec{V}\cdot \vec{W}=-|\vec{V}||\vec{W}|$
• 判断两向量夹角是否在-90°~+90° 范围内（不包含边界），若是，则$\vec{V}\cdot \vec{W}>0$
• 求点到平面的最小有符号距离：$\hat{n}\cdot \vec{P}+D_0$

一般平面的表示法为：a(x-x₀) + b(y-y₀) + c(z-z₀) = 0

对于平面的一般方程 ax + by + cz + d = 0，可表示为平面S(a, b, c, d)。
平面S(a, b, c, d)的法向量公式：
$$\vec{n}=(a,b,c)$$
点P(x_p, y_p, z_p)到平面S(a, b, c, d)的距离公式：
$$D_p=\frac{|a{x}_p+b{y}_p+c{z}_p+d|}{\sqrt{a^2+b^2+c^2}}$$
由以上两公式可以推出，平面S单位法向量：
$$\hat{n}=(\frac{a}{\sqrt{a^2+b^2+c^2}},\frac{b}{\sqrt{a^2+b^2+c^2}},\frac{c}{\sqrt{a^2+b^2+c^2}})$$
原点到平面S的有符号距离：
$$D_0=\frac{d}{\sqrt{a^2+b^2+c^2}}$$
推出，点P到平面S的有符号距离，可以用点积（方便程序函数运算）表示为：
$$D_{ps}=\hat{n}\cdot \vec{P}+D_0$$

叉积

$$\vec{A}\times \vec{B}=(vz-wy,wx-uz,uy-vx)$$
glm/GLSL：corss(vec3,vec3)

通过叉积来获得法向量的能力对我们后面要学习的光照部分非常重要。为了确定光照效果，我们需要知道所渲染模型的外向法向量。使用叉积计算来获得其中一面的外向法向量。其所得法向量的方向遵循右手定则。

$$\begin{gathered} \vec{P}=\overrightarrow{V_2}-\overrightarrow{V_1} \\ \vec{Q}=\overrightarrow{V_3}-\overrightarrow{V_1} \\ \vec{N}=\vec{P}\times \vec{Q} \end{gathered}$$

局部空间和世界空间——模型矩阵M

当建立物体的 3D 模型时，我们通常以最方便的定位方式描述模型。如果模型是球形的，那么我们很可能将球心定位于原点(0,0,0)并赋予它一个易于处理的半径，比如 1。模型定义的空间叫作局部空间(local space)或模型空间(model space)。OpenGL 官方文档使用的术语是物体空间(object space)。

我们刚刚定义的球可能用作一个大模型的一部分，如机器人的头部。这个机器人当然也定义在它自身的局部空间。我们可以用上图所示的矩阵变换即通过缩放、旋转和平移，将球放在机器人模型的空间。通过这种方式，可以分层次地构建复杂模型。

使用同样的方式，通过设定物体在模拟世界中的朝向和大小，可以将物体放在模拟世界的空间中，这个空间叫作世界空间。在世界空间中为对象定位及定向的矩阵称为模型矩阵，通常记为 M。

视觉空间和合成相机——模型-视图矩阵MV

观察 3D 世界需要：
（a）将相机放入世界的某个位置；
（b）调整相机的角度，通常需要一套它自己的直角坐标轴 u、 v、 n（由向量 U，V，N 构成）；
（c）定义一个视体（view volume）；
（d）将视体内的对象投影到投影平面（projection plane）上。

OpenGL 有一个固定在原点(0,0,0)并朝向 z 轴负方向的相机：

为了应用 OpenGL 相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置（如物体应该在由下图所示相机 U、 V、 N 向量定义的“相机空间”中的位置）。给定世界空间中的点 P_w，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置 C_w 看到的样子。我们通过计算它在相机空间中的位置 P_C 实现。

已知 OpenGL 相机位置永远固定在点(0,0,0)，那么我们如何变换来实现上述功能？

需要做的变换如下：
（1）将 P_W 平移，其向量为负的期望相机位置。
（2）将 P_W 旋转，其角度为负的期望相机欧拉角。

为了模拟以某种方式移动的相机的表现，我们需要向相反的方向移动物体本身。例如，将相机向右移动会导致场景中的物体看起来像是向左移动，对应地，针对 OpenGL 的固定相机，我们可以通过把对象向左移动，让相机看起来向右移动了。对于旋转，类似。

我们可以构建一个单一变换矩阵以完成旋转和平移，这个矩阵叫作视图变换(viewing transform)矩阵，记作 V。矩阵 V 合并了矩阵 T（包含负相机期望位置的平移矩阵）和 R（包含负相机期望欧拉角的旋转矩阵）。在本例中，我们从右向左计算，先平移世界空间中的点 P_W，之后旋转：
$$P_C=\vec{R}(\vec{T}{P}_W)=(\overrightarrow{RT})P_W=\vec{V}{P}_W$$

通常，将 V 矩阵与模型矩阵 M 的积定义为模型-视图(Model-View, MV)矩阵，记作 MV：MV = VM。之后，点 P_M 通过如下步骤就可以从自己的模型空间直接转换至相机空间：P_C = MVP_M 。

在复杂场景中，当我们需要对每个顶点，而非一个点做这个变换的时候，这种方法的好处就很明显了。通过预先计算 MV，空间中每个点的变换都只需要进行一次矩阵乘法计算。之后，我们会看到，可以将这个过程延伸到更多合并矩阵的计算中，以大量减少点的计算量。

用GLSL函数构建变换矩阵

GLSL 中用于初始化 mat4 矩阵的语法以列为单位读入值。其前 4 个参数会放入第一列，接
下来 4 个参数放入下一列，直到第四列，如下所示：

mat4 translationMatrix =
	mat4(1.0, 0.0, 0.0, 0.0, // 注意，这是最左列（第一列），而非第一行
		 0.0, 1.0, 0.0, 0.0,
		 0.0, 0.0, 1.0, 0.0,
		 tx,  ty,  tz,  1.0);

// 构建并返回平移矩阵
mat4 buildTranslate(float x, float y, float z) { 
	mat4 trans = mat4(1.0, 0.0, 0.0, 0.0,
					  0.0, 1.0, 0.0, 0.0,
					  0.0, 0.0, 1.0, 0.0,
					  x, y, z, 1.0);
	return trans;
}

// 构建并返回绕 x 轴的旋转矩阵
mat4 buildRotateX(float rad) { 
	mat4 xrot = mat4(1.0, 0.0, 0.0, 0.0,
					 0.0, cos(rad), -sin(rad), 0.0,
					 0.0, sin(rad), cos(rad), 0.0,
					 0.0, 0.0, 0.0, 1.0);
	return xrot;
}

// 构建并返回绕 y 轴的旋转矩阵
mat4 buildRotateY(float rad) { 
	mat4 yrot = mat4(cos(rad), 0.0, sin(rad), 0.0,
					 0.0, 1.0, 0.0, 0.0,
					-sin(rad), 0.0, cos(rad), 0.0,
					 0.0, 0.0, 0.0, 1.0);
	return yrot;
}

// 构建并返回绕 z 轴的旋转矩阵
mat4 buildRotateZ(float rad) { 
	mat4 zrot = mat4(cos(rad), -sin(rad), 0.0, 0.0,
					 sin(rad), cos(rad), 0.0, 0.0,
					 0.0, 0.0, 1.0, 0.0,
					 0.0, 0.0, 0.0, 1.0 );
	return zrot;
}

// 构建并返回缩放矩阵
mat4 buildScale(float x, float y, float z) { 
	mat4 scale = mat4(x, 0.0, 0.0, 0.0,
					  0.0, y, 0.0, 0.0,
					  0.0, 0.0, z, 0.0,
					  0.0, 0.0, 0.0, 1.0 );
	return scale;
}