OpenGL矩阵和矩阵堆栈与基础变换的理解和使用

• 矩阵
  矩阵是一种功能非常强大的数学工具，它大大简化了了求解变量之间有复杂关系的方程式或者方程组的过程。矩阵在坐标变换中运用得非常广泛。例如：如果在空间有一个点，由x，y和z坐标定义，将它围绕任意点沿任意方向旋转一定的角度后，我们需要知道这个点现在的位置，就要用到矩阵。因为新的x坐标不仅与原来的x坐标和其他旋转参数有关，还与y和z坐标值有关。这种变量与解之间的相关性就是矩阵最擅长解决的问题。

• 基础变换
  由于我们的屏幕是2D的，在把3D图形数据显示在2D屏幕上的这个过程中，我们需要对顶点数据进行几何变换：视图变换、模型变换和投影变换。

  变 换	应 ⽤
  视图	指定观察者位置
  模型	在场景中移动物体
  模型视图	描述视图/模型变换的⼆二元性
  投影	改变视景体⼤大⼩小和设置它的投影⽅方式
  视口	伪变化,对窗⼝口上最终输出进⾏行行缩放

• 模型视图矩阵
  模型视图矩阵是一个4x4矩阵，它表示一个变换后的坐标系，我们可以用来放置对象和确定对象的方向。我们为图元提供的顶点将作为一个单列矩阵的形式来使用，并乘以一个模型视图矩阵来获得一个相对于视觉坐标系的经过变换的新坐标。

  • 我们可以调用math3d库中m3dTranslationMatrix44函数来使用变换矩阵

    void m3dTranslationMatrix44(M3DMatrix44f m, float x, float y, float z)
    

  • 旋转

    void m3dRotationMatrix44(M3DMatrix44f m, float angle, float x, float y, float z);
    

  • 缩放

    void m3dScaleMatrix44(M3DMatrix44f m, float xScale, float yScale, float zScale)
    

  • 综合变换：将两个矩阵相乘并返回结果

    void m3dMatrixMultiply44(M3DMatrix44f product, const M3DMatrix44f a, const M3DMatrix44f b);
    

  提示：如果不知道参数是什么意思，可以进入看源码，非常的清晰。

• 投影矩阵
  投影分为正投影和透视投影。

  • 正投影会产生一个平行投影，这种投影在绘制从远处观察不产生任何透视缩短的特定物体时非常有用。

    // 用这个函数设置正投影
    GLFrustum::SetOrthographic(GLfloat xMin, GLfloat xMax,   GLfloat yMin, GLfloat yMax, GLfloat zMin, GLfloat zMax);
    

  • 透视投影会有一个3D效果，看起来更加逼真，渲染3D图形时常用透视投影。

    // 用这个函数设置透视投影
    GLFrustum::SetPerspective(float fFov, float fAspect, float fNear, float fFar);
    

• 顶点变换管线
  

  原始顶点数据到显示在窗口上的变化过程，这个过程都是用矩阵记录每一次放射变换，然后应用到顶点数据上。 屏幕快照 2019-05-21 22.43.51.png

• 使用矩阵例子

// GLTool.h头文件包含了大部分GLTool中类似C语言的独立函数
#include "GLTools.h"
// 矩阵⼯工具类,⽤用来快速设置正/透视投影
#include "GLFrustum.h"
// 三⻆角形批次类,帮助类,利利⽤用它可以传输顶点/光照/纹理理/颜⾊色数据到存储着⾊色器器中
#include "GLBatch.h"
#include "StopWatch.h"
// 数学库
#include <math.h>
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

// 设置图元绘制时的投影方式
GLFrustum           viewFrustum;
//  存储着⾊色器器管理理⼯工具类.
GLShaderManager     shaderManager;
GLTriangleBatch     torusBatch;


// 设置视口和投影矩阵
void ChangeSize(int w, int h)
{
    //防止除以零
    if(h == 0)
        h = 1;
    
    //将视口设置为窗口尺寸
    glViewport(0, 0, w, h);
    
    //设置透视投影
    viewFrustum.SetPerspective(35.0f, float(w)/float(h), 1.0f, 1000.0f);
}

//召唤场景
void RenderScene(void)
{
    //清除屏幕、深度缓存区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //1.建立基于时间变化的动画
    static CStopWatch rotTimer;
    //当前时间 * 60s
    float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
    
    //2.矩阵变量
    /*
     mTranslate: 平移
     mRotate: 旋转
     mModelview: 模型视图
     mModelViewProjection: 模型视图投影MVP
     */
    M3DMatrix44f mTranslate, mRotate, mModelview, mModelViewProjection;
    
    //创建一个4*4矩阵变量，将花托沿着Z轴负方向移动2.5个单位长度
    m3dTranslationMatrix44(mTranslate, 0.0f, 0.0f, -2.5f);
    
    //创建一个4*4矩阵变量，将花托在Y轴上渲染yRot度，yRot根据经过时间设置动画帧率
     m3dRotationMatrix44(mRotate, m3dDegToRad(yRot), 0.0f, 1.0f, 0.0f);
    
    //为mModerView 通过矩阵旋转矩阵、移动矩阵相乘，将结果添加到mModerView上
    m3dMatrixMultiply44(mModelview, mTranslate, mRotate);
    
    // 将投影矩阵乘以模型视图矩阵，将变化结果通过矩阵乘法应用到mModelViewProjection矩阵上
    //注意顺序: 投影 * 模型 != 模型 * 投影
     m3dMatrixMultiply44(mModelViewProjection, viewFrustum.GetProjectionMatrix(),mModelview);
  
    //绘图颜色
    GLfloat vBlack[] = { 0.0f, 0.0f, 0.0f, 1.0f };
    
    //通过平面着色器提交矩阵，和颜色。
    shaderManager.UseStockShader(GLT_SHADER_FLAT, mModelViewProjection, vBlack);
    //开始绘图
    torusBatch.Draw();
    
    // 交换缓冲区，并立即刷新
    glutSwapBuffers();
    glutPostRedisplay();
}

void SetupRC()
{
    //1.
    glClearColor(0.8f, 0.8f, 0.8f, 1.0f );
    shaderManager.InitializeStockShaders();
    glEnable(GL_DEPTH_TEST);
   
    //2.形成一个球
    gltMakeSphere(torusBatch, 0.4f, 10, 20);
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}

int main(int argc, char* argv[])
{
    gltSetWorkingDirectory(argv[0]);
    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
    glutInitWindowSize(800, 600);
    glutCreateWindow("ModelViewProjection Example");
    glutReshapeFunc(ChangeSize);
    glutDisplayFunc(RenderScene);
    
    
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
        return 1;
    }
    
    SetupRC();
    
    glutMainLoop();
    return 0;
}

• 矩阵堆栈介绍
  1. 矩阵堆栈常用函数

  //这个类的构造函数允许指定堆栈的最大深度，默认的堆栈深度为64，这个矩阵堆栈在初始化时已经在堆栈中包含了单元矩阵。
  GLMatrixStack::GLMatrixStack(int iStackDepth = 64);
  //在堆栈顶部载⼊一个单元矩阵
  void GLMatrixStack::LoadIdentity(void);
  //在堆栈顶部载入任何矩阵.参数:4*4矩阵
  void GLMatrixStack::LoadMatrix(const M3DMatrix44f m);
  //矩阵乘以矩阵堆栈顶部矩阵，相乘结果存储到堆栈的顶部
  void GLMatrixStack::MultMatrix(const M3DMatrix44f);
  //使用GetMatrix 函数获取矩阵堆栈顶部的值，这个函数可以进行两次重载，以适应GLShaderMananger的使⽤用，或者仅仅是获取顶部矩阵的副本
  const M3DMatrix44f & GLMatrixStack::GetMatrix(void);
  void GLMatrixStack::GetMatrix(M3DMatrix44f mMatrix);
  

  2. 压栈.出栈
     一个矩阵的真正价值在于通过压栈操作存储一个状态，然后通过出栈恢复这个状态。

  //将当前矩阵压⼊入堆栈
  void GLMatrixStack::PushMatrix(void);
  //将M3DMatrix44f 矩阵对象压入当前矩阵堆栈
  void PushMatrix(const M3DMatrix44f mMatrix);
  //将GLFame 对象压入矩阵对象
  void PushMatrix(GLFame &frame);
  //出栈(出栈指的是移除顶部的矩阵对象) 
  void GLMatrixStack::PopMatrix(void);
  

  3.仿射变换
  GLMatrixStack类也内建了对创建旋转、平移和缩放矩阵的支持。相应的函数如下：

  //Rotate 函数angle参数是传递的度数，而不是弧度
  void MatrixStack::Rotate(GLfloat angle,GLfloat x,GLfloat y,GLfloat z);
  void MatrixStack::Translate(GLfloat x,GLfloat y,GLfloat z);
  void MatrixStack::Scale(GLfloat x,GLfloat y,GLfloat z);
  

  这三个函数都可以创建相应的矩阵，然后用这个矩阵乘以矩阵堆栈顶部的元素，实际上就是对当前矩阵添加变换。

• 矩阵堆栈的使用完整例子，代码如下：

#include "GLTools.h"
#include "GLShaderManager.h"
#include "GLFrustum.h"
#include "GLBatch.h"
#include "GLMatrixStack.h"
#include "GLGeometryTransform.h"
#include "StopWatch.h"

#include <math.h>
#include <stdio.h>

#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

GLShaderManager     shaderManager;          // 着色器管理器
GLMatrixStack       modelViewMatrix;        // 模型视图矩阵
GLMatrixStack       projectionMatrix;       // 投影矩阵
GLFrustum           viewFrustum;            // 视景体
GLGeometryTransform transformPipeline;      // 几何图形变换管道
GLTriangleBatch     torusBatch;             // 花托批处理
//角色帧 照相机角色帧
GLFrame             cameraFrame;

void SetupRC()
{
    // 初始化着色器管理器
    shaderManager.InitializeStockShaders();
    
    //开启深度测试
    glEnable(GL_DEPTH_TEST);
    
    //设置清屏颜色到颜色缓存区
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    
    //绘制甜甜圈
    gltMakeTorus(torusBatch, 0.4f, 0.15f, 30, 30);
    
}


// 屏幕更改大小或已初始化
void ChangeSize(int nWidth, int nHeight)
{
    glViewport(0, 0, nWidth, nHeight);
    
    // 创建投影矩阵，。
    viewFrustum.SetPerspective(35.0f, float(nWidth)/float(nHeight), 1.0f, 100.0f);
    
    //并将其加载到投影矩阵堆栈上
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    
    // 设置变换管道以使用两个矩阵堆栈（变换矩阵modelViewMatrix ，投影矩阵projectionMatrix）
    //初始化GLGeometryTransform 的实例transformPipeline.通过将它的内部指针设置为模型视图矩阵堆栈 和 投影矩阵堆栈实例，来完成初始化
    //当然这个操作也可以在SetupRC 函数中完成，但是在窗口大小改变时或者窗口创建时设置它们并没有坏处。而且这样可以一次性完成矩阵和管线的设置。
    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
}


//进行调用以绘制场景
void RenderScene(void)
{
    static GLfloat vTorusColor[] = { 1.0f, 0.0f, 0.0f, 1.0f };
    
    // 基于时间动画
    static CStopWatch   rotTimer;
    float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
    
    // 清除颜色缓存区和深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //**3、设置照相机矩阵
    M3DMatrix44f mCamera;
    //**3、从camraFrame中获取一个4*4的矩阵；
    cameraFrame.GetCameraMatrix(mCamera);
    //**3、将照相机矩阵压入模型视图堆栈中
    modelViewMatrix.PushMatrix(mCamera);
    
    // 绘制旋转甜甜圈
    //modelViewMatrix 顶部矩阵沿着z轴移动2.5单位
    modelViewMatrix.Translate(0.0f, 0.0f, -2.5f);
    
    modelViewMatrix.PushMatrix();
    
    //modelViewMatrix 顶部矩阵旋转yRot度
    modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);
  
    //使用平面着色器 变换管道中的投影矩阵 和 变换矩阵 相乘的矩阵，指定甜甜圈颜色
    shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(),vTorusColor);
    
    //开始绘制
    torusBatch.Draw();
    
    // 恢复modelViewMatrix矩阵，移除矩阵堆栈
    //使用PopMatrix推出刚刚变换的矩阵，然后恢复到单位矩阵
    modelViewMatrix.PopMatrix();
    
    //**恢复矩阵**   push跟pop一一对应，push几次就要pop几次。
    modelViewMatrix.PopMatrix();
    
    // 执行缓存区交换
    glutSwapBuffers();
    
    // 告诉glut在显示一遍
    glutPostRedisplay();
}


int main(int argc, char* argv[])
{
    gltSetWorkingDirectory(argv[0]);
    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800,600);
    
    glutCreateWindow("OpenGL SphereWorld");
    
    glutReshapeFunc(ChangeSize);
    glutDisplayFunc(RenderScene);
    
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
        return 1;
    }
    
    SetupRC();
    glutMainLoop();    
    return 0;
}