Inside CG transformation (II).

上一篇先解决了CG中的第一步变换，接下来来看viewMatrix。

视图变换实际上是坐标系的变换，将世界坐标系变换到眼坐标系（view ），这样做可以方便后面的投影(Projection)操作，因为投影是在眼坐标系中进行的。

建立眼坐标系用gluLookAt函数来实现，我们看看函数原型：
gluLookAt(double eyex, double eyey, double eyez, double centerx, double centery, double centerz, double upx, double upy, double upz）

这些参数中包括三种信息：眼睛的位置eye，视点中心位置center和向上的向量up。注意up不是y轴，只是指明了y轴的大致方向。

设眼睛的位置为原点，向量（eye-center）所得的向量为Z轴，y叉乘z得到x轴，再由x轴和z轴叉乘，反算出y轴。这就是眼坐标系的三个方向，设其单位向量为u、v、n。

然后就是坐标系之间的变换，这一点可以通过两种思路来完成：
1. 将眼坐标系变换到同世界坐标系重合。
2.代数的方法。

对于1而言，又有两种思路：
1. 代数上已经证明的公式：先移动eye的位置到世界坐标系的原点，再进行正交变换；
2. 由基本的变换合成，如下：
1）移动眼睛的位置到世界坐标系原点；
2）将眼坐标系绕世界坐标系x轴旋转，使得眼坐标系的z轴位于世界坐标系xoz平面；
3）将眼坐标系绕世界坐标系y轴旋转，使得眼坐标系的z轴和世界坐标系z轴重合；
4）将眼坐标系绕世界坐标系z轴旋转，使得眼坐标系的x、y轴和世界坐标系x、y轴重合；
这个步骤也需要很多的草稿纸，O(∩_∩)O

对于2，代数的方法，显得更简洁一些，看下图：


图中，对于任意的P点，向量减OP-Oeye= eyeP。再考虑eyeP向量，将其对眼坐标系的x/y/z轴进行投影，呵呵，就能得到P点在新坐标系中的坐标。投影很简单，用点乘即可。
于是，对于P点的新坐标P'（x',y',z'):
x' =(OP-Oeye).u = OP.u - Oeye.u =(x,y,z).(u[0],u[1],u[2]) -Oeye.(u[0],u[1],u[2]);
其中，u为眼坐标x轴方向的单位向量, x为P点的x坐标，u[0]为u向量的x值；其他类似。

y、z类似，我想你应该能写出矩阵来了吧，此处矩阵略过，直接看代码吧。

/* Build a row-major (C-style) 4x4 matrix transform based on the parameters for gluLookAt. */
static void buildLookAtMatrix(double eyex, double eyey, double eyez,
double centerx, double centery, double centerz,
double upx, double upy, double upz,float m[16])
{
double x[3], y[3], z[3], mag;

/* Difference eye and center vectors to make Z vector. */
z[0] = eyex - centerx;
z[1] = eyey - centery;
z[2] = eyez - centerz;
/* Normalize Z. */
mag = sqrt(z[0]*z[0] + z[1]*z[1] + z[2]*z[2]);
if (mag) {
z[0] /= mag;
z[1] /= mag;
z[2] /= mag;
}

/* Up vector makes Y vector. */
y[0] = upx;
y[1] = upy;
y[2] = upz;

/* X vector = Y cross Z. */
x[0] = y[1]*z[2] - y[2]*z[1];
x[1] = -y[0]*z[2] + y[2]*z[0];
x[2] = y[0]*z[1] - y[1]*z[0];

/* Recompute Y = Z cross X. */
y[0] = z[1]*x[2] - z[2]*x[1];
y[1] = -z[0]*x[2] + z[2]*x[0];
y[2] = z[0]*x[1] - z[1]*x[0];

/* Normalize X. */
mag = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
if (mag) {
x[0] /= mag;
x[1] /= mag;
x[2] /= mag;
}

/* Normalize Y. */
mag = sqrt(y[0]*y[0] + y[1]*y[1] + y[2]*y[2]);
if (mag) {
y[0] /= mag;
y[1] /= mag;
y[2] /= mag;
}

/* Build resulting view matrix. */
m[0*4+0] = x[0]; m[0*4+1] = x[1];
m[0*4+2] = x[2]; m[0*4+3] = -x[0]*eyex + -x[1]*eyey + -x[2]*eyez;

m[1*4+0] = y[0]; m[1*4+1] = y[1];
m[1*4+2] = y[2]; m[1*4+3] = -y[0]*eyex + -y[1]*eyey + -y[2]*eyez;

m[2*4+0] = z[0]; m[2*4+1] = z[1];
m[2*4+2] = z[2]; m[2*4+3] = -z[0]*eyex + -z[1]*eyey + -z[2]*eyez;

m[3*4+0] = 0.0; m[3*4+1] = 0.0; m[3*4+2] = 0.0; m[3*4+3] = 1.0;
}

到此，view矩阵已经OK了。