3D Computer Grapihcs Using OpenGL - 11 Model View Projection Matrices

本节我们将绘制一个3维物体，立方体。

如果要渲染3D物体，我们需要了解MVP（Model View Projection），它表示三个转换矩阵。实际上这个名字不够明确，更加确切的释义如下：

• Model - Model to World  模型空间到世界空间
• View - World to View      世界空间到视图空间
• Projection - View to Projection   视图空间到投影空间

要实现这三个转换矩阵，我们需要借助glm数学库提供的一些方便的结构体和函数。

重构

我们先对程序结构进行修改，对工程右键>Add > New Filter， 创建一个Primitives 文件夹，在其中创建两个文件，一个Vertex.h，一个ShapeData.h

Vertex.h中定义了一个Vertex结构体，它包含两个glm::vec3成员，分别表示位置和颜色。

 #pragma once
 #include <glm\glm.hpp>

 struct Vertex
 {
     glm::vec3 position;
     glm::vec3 color;
 };

ShapeData.h中定义了一个ShapeData结构体，包含四个成员变量，分别是

• Vertex* 类型：顶点数组指针
• Gluint类型：顶点数量
• GLushort* 类型：索引数组指针
• GLuint 类型：索引数组长度

另外还提供了构造函数，清理函数

 #pragma once
 #include <GL\glew.h>
 #include "Vertex.h"

 struct ShapeData
 {
     ShapeData() :
         vertices(), numVertices(), indices(), numIndices() {}

     Vertex* vertices;
     GLuint numVertices;
     GLushort* indices;
     GLuint numIndices;

     GLsizeiptr vertexBufferSize() const
     {
         return numVertices * sizeof(Vertex);
     }
     GLsizeiptr indexBufferSize() const
     {
         return numIndices * sizeof(GLushort);
     }

     void cleanUp()
     {
         delete[] vertices;
         delete[] indices;
         numVertices = numIndices = ;
     }
 };

此外还加入了一个新的类，ShapeGenerator

ShapeGenerator.h

 #pragma once
 #include <ShapeData.h>

 class ShapeGenerator
 {
 public:
     static ShapeData makeCube();
 };

ShapeGenerator.cpp

 #include "ShapeGenerator.h"
 #include "Vertex.h"

 #define NUM_ARRAY_ELEMENTS(a) sizeof(a) / sizeof(*a)

 ShapeData ShapeGenerator::makeCube()
 {
     ShapeData ret;
     Vertex stackVerts[]=
     {
         glm::vec3(-1.0f, +1.0f, +1.0f), //
         glm::vec3(+1.0f, 0.0f, 0.0f),   //Color
         glm::vec3(+1.0f, +1.0f, +1.0f), //
         glm::vec3(0.0f, +1.0f, 0.0f),    //Color
         glm::vec3(+1.0f, +1.0f, -1.0f), //
         glm::vec3(0.0f, 0.0f, +1.0f), //Color
         glm::vec3(-1.0f, +1.0f, -1.0f), //
         glm::vec3(+1.0f, +1.0f, +1.0f), //Color

         glm::vec3(-1.0f, +1.0f, -1.0f), //
         glm::vec3(+1.0f, 0.0f, +1.0f),   //Color
         glm::vec3(+1.0f, +1.0f, -1.0f), //
         glm::vec3(0.0f, 0.5f, 0.2f),    //Color
         glm::vec3(+1.0f, -1.0f, -1.0f), //
         glm::vec3(0.8f, 0.6f, 0.4f), //Color
         glm::vec3(-1.0f, -1.0f, -1.0f), //
         glm::vec3(0.3f, +1.0f, +0.5f), //Color

         glm::vec3(+1.0f, +1.0f, -1.0f), //
         glm::vec3(0.2f, 0.5f, 0.2f),  //Color
         glm::vec3(+1.0f, +1.0f, +1.0f), //
         glm::vec3(0.9f, 0.3f, 0.7f),    //Color
         glm::vec3(+1.0f, -1.0f, +1.0f), //
         glm::vec3(0.3f, 0.7f, 0.5f),    //Color
         glm::vec3(+1.0f, -1.0f, -1.0f), //
         glm::vec3(0.5f, 0.7f, 0.5f),  //Color

         glm::vec3(-1.0f, +1.0f, +1.0f), //
         glm::vec3(0.7f, 0.8f, 0.2f),   //Color
         glm::vec3(-1.0f, +1.0f, -1.0f), //
         glm::vec3(0.5f, 0.7f, 0.3f),    //Color
         glm::vec3(-1.0f, -1.0f, -1.0f), //
         glm::vec3(0.8f, 0.6f, 0.4f), //Color
         glm::vec3(-1.0f, -1.0f, +1.0f), //
         glm::vec3(0.3f, +1.0f, +0.5f), //Color

         glm::vec3(+1.0f, +1.0f, +1.0f), //
         glm::vec3(0.7f, 0.8f, 0.2f),   //Color
         glm::vec3(-1.0f, +1.0f, +1.0f), //
         glm::vec3(0.5f, 0.7f, 0.3f),    //Color
         glm::vec3(-1.0f, -1.0f, +1.0f), //
         glm::vec3(0.8f, 0.6f, 0.4f), //Color
         glm::vec3(+1.0f, -1.0f, +1.0f), //
         glm::vec3(0.3f, +1.0f, +0.5f), //Color

         glm::vec3(+1.0f, -1.0f, -1.0f), //
         glm::vec3(0.7f, 0.8f, 0.2f),   //Color
         glm::vec3(-1.0f, -1.0f, -1.0f), //
         glm::vec3(0.5f, 0.7f, 0.3f),    //Color
         glm::vec3(-1.0f, -1.0f, +1.0f), //
         glm::vec3(0.8f, 0.6f, 0.4f), //Color
         glm::vec3(+1.0f, -1.0f, +1.0f), //
         glm::vec3(0.3f, +1.0f, +0.5f), //Color
     };

     ret.numVertices = NUM_ARRAY_ELEMENTS(stackVerts);
     ret.vertices = new Vertex[ret.numVertices];
     memcpy(ret.vertices, stackVerts, sizeof(stackVerts));

     unsigned short stackIndices[] =
     {
         ,,,,,,
         ,,,,,,
         ,,,,,,
         ,,,,,,
         ,,,,,,
         ,,,,,,
     };

     ret.numIndices = NUM_ARRAY_ELEMENTS(stackIndices);
     ret.indices = new GLushort[ret.numIndices];
     memcpy(ret.indices, stackIndices, sizeof(stackIndices));
     return ret;
 }

主要作用是提供了一个静态方法 makeCube，返回一个立方体的数据。

修改MyGlWindow类

 #include <gl\glew.h>
 #include "MyGlWindow.h"
 #include <iostream>
 #include <fstream>
 #include <glm\gtc\matrix_transform.hpp>
 #include <ShapeGenerator.h>

 GLuint programID;
 GLuint numIndices;

 void MyGlWindow::sendDataToOpenGL()
 {

     ShapeData shape = ShapeGenerator::makeCube();

     GLuint vertexBufferID;
     glGenBuffers(, &vertexBufferID);
     glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
     glBufferData(GL_ARRAY_BUFFER, shape.vertexBufferSize(), shape.vertices, GL_STATIC_DRAW);

     GLuint indexBufferID;
     glGenBuffers(, &indexBufferID);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, shape.indexBufferSize(), shape.indices, GL_STATIC_DRAW);

     glEnableVertexAttribArray();
     glVertexAttribPointer(, , GL_FLOAT, GL_FALSE, sizeof(GLfloat) * , );

     glEnableVertexAttribArray();
     glVertexAttribPointer(, , GL_FLOAT, GL_FALSE, sizeof(GLfloat) * , (char*)(sizeof(GLfloat) * ));

     numIndices = shape.numIndices;
     shape.cleanUp();

 }

 void MyGlWindow::installShaders()
 {
     GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
     GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

     std::string tmp = ReadShaderCode("VertexShaderCode2.glsl");
     const char* vertexShaderCode = tmp.c_str();
     glShaderSource(vertexShaderID, , &vertexShaderCode, );

     tmp = ReadShaderCode("FragmentShaderCode2.glsl");
     const char* fragmentShaderCode = tmp.c_str();
     glShaderSource(fragmentShaderID, , &fragmentShaderCode, );

     glCompileShader(vertexShaderID);
     glCompileShader(fragmentShaderID);

     programID = glCreateProgram();
     glAttachShader(programID, vertexShaderID);
     glAttachShader(programID, fragmentShaderID);

     glLinkProgram(programID);

     glUseProgram(programID);
 }

 void MyGlWindow::initializeGL()
 {
     glewInit();
     glEnable(GL_DEPTH_TEST);
     sendDataToOpenGL();
     installShaders();
 }

 void MyGlWindow::paintGL()
 {
     glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
     glViewport(, , width(), height());

     //更新：最新版本的glm中，glm::mat4()生成的是不是单位矩阵，而是零矩阵，这里要使用glm::mat4(1.0f)才可以
     glm::mat4 modelTransformMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f,-3.0f));
     glm::mat4 projectionMatrix = glm::perspective(30.0f, ((float)width()) / height(), 0.1f, 10.0f);

     GLint modelTransformUniformLocation = glGetUniformLocation(programID, "modelMatrix");
     GLint projectionMatrixUniformLocation = glGetUniformLocation(programID, "projectionMatrix");

     glUniformMatrix4fv(modelTransformUniformLocation, , GL_FALSE, &modelTransformMatrix[][]);
     glUniformMatrix4fv(projectionMatrixUniformLocation, , GL_FALSE, &projectionMatrix[][]);

     glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, );

 }

 std::string MyGlWindow::ReadShaderCode(const char* fileName)
 {
     std::ifstream myInput(fileName);
     if (!myInput.good())
     {
         std::cout << "File failed to load..." << fileName;
         exit();
     }
     return std::string(
         std::istreambuf_iterator<char>(myInput),
         std::istreambuf_iterator<char>());
 }

Vertex Shader :

 #version                            

 in layout(location=) vec3 position;
 in layout(location=) vec3 vertexColor;                                       

 uniform mat4 modelMatrix;
 uniform mat4 projectionMatrix; 

 out vec3 passingColor;

 void main()
 {
   vec4 v =  vec4(position,1.0);
   vec4 newPosition = modelMatrix * v;
   gl_Position = projectionMatrix * newPosition;
   passingColor= vertexColor;
 }

Fragment Shader:

 #version                                          

 in vec3 passingColor;
 out vec4 finalColor;                  

 void main()
 {
   finalColor = vec4(passingColor,1.0);
 }                            

注意MyGlWindow的78-85行，是使用Uniform 变量的通用方法，使用的是Vertex Shader中第6-7行的两个uniform。

使用Uniform变量的步骤总结:

1. 使用glGetUniformLocation获取Uniform变量的ID，并储存在一个GLint 变量中
2. 使用glUnifomxxxx()类的函数和刚才得到的ID给Uniform赋值。

另外要注意85-86行，函数的最后一参数需要一个const GLfloat * 类型的变量，所以我们使用[0][0]获取矩阵的第一个元素，它是个GLfloat类型的，再对他使用取地址符&得到它的地址。

编译运行以后得到一个平面（实际上是立方体的一个面）：

我们在最开始提到了3个矩阵，但是这里只用到了两个，实际上少了第二个矩阵，World to View矩阵，这也正是为什么我们现在无法移动观察视角的原因，我们的相机被假设在世界原点，朝向-z的方向看去，这是默认的设置。后面我们会学习world to view的转换矩阵。