3D Computer Grapihcs Using OpenGL

本节我们将绘制一个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 <glmglm.hpp>

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

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

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

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

#pragma once
#include <GLglew.h>
#include "Vertex.h"

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

    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 = 0;
    }
};

此外还加入了一个新的类，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), //0
        glm::vec3(+1.0f, 0.0f, 0.0f),   //Color
        glm::vec3(+1.0f, +1.0f, +1.0f), //1
        glm::vec3(0.0f, +1.0f, 0.0f),    //Color
        glm::vec3(+1.0f, +1.0f, -1.0f), //2
        glm::vec3(0.0f, 0.0f, +1.0f), //Color
        glm::vec3(-1.0f, +1.0f, -1.0f), //3
        glm::vec3(+1.0f, +1.0f, +1.0f), //Color

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

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

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

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

        glm::vec3(+1.0f, -1.0f, -1.0f), //20
        glm::vec3(0.7f, 0.8f, 0.2f),   //Color
        glm::vec3(-1.0f, -1.0f, -1.0f), //21
        glm::vec3(0.5f, 0.7f, 0.3f),    //Color
        glm::vec3(-1.0f, -1.0f, +1.0f), //22
        glm::vec3(0.8f, 0.6f, 0.4f), //Color
        glm::vec3(+1.0f, -1.0f, +1.0f), //23
        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[] = 
    {
        0,1,2,0,2,3,
        4,5,6,4,6,7,
        8,9,10,8,10,11,
        12,13,14,12,14,15,
        16,17,18,16,18,19,
        20,22,21,20,23,22,
    };

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

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

修改MyGlWindow类

#include <glglew.h>
#include "MyGlWindow.h"
#include <iostream>
#include <fstream>
#include <glmgtcmatrix_transform.hpp>
#include <ShapeGenerator.h>



GLuint programID;
GLuint numIndices;

void MyGlWindow::sendDataToOpenGL()
{
    
    ShapeData shape = ShapeGenerator::makeCube();

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

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

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, 0);

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

    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, 1, &vertexShaderCode, 0);

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

    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(0, 0, 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, 1, GL_FALSE, &modelTransformMatrix[0][0]);
    glUniformMatrix4fv(projectionMatrixUniformLocation, 1, GL_FALSE, &projectionMatrix[0][0]);

    glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, 0);

}


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

Vertex Shader :

#version 430                           
                                       
in layout(location=0) vec3 position;   
in layout(location=1) 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 430                                         
                                      
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的转换矩阵。