OpenGL学习之路（三）

1 引子

这些天公司一次次的软件发布节点忙的博主不可开交，另外还有其它的一些事也占用了很多时间。现在坐在电脑前，在很安静的环境下，与大家分享自己的OpenGL学习笔记和理解心得，感到格外舒服。这让我回忆起了童年时期的一些情景，在群山环绕的农村，方圆不足一两公里，当时感觉自己面对的世界好小，很想到去看看外面世界的精彩；上大学后就来到大城市了，至今算来也近十年了。现在看来外面的世界不见得比家乡好：地铁站、大街上，人们步履匆匆，争分按秒；食品安全问题、生活买房压力……让我再次思考——大城市一定适合我吗？现在越来越觉得安静的小城市小乡村的生活是多么的惬意。呵呵，发发感慨！也许这世界本不存在完美，大城市有大城市的好处和缺点，小城镇有小城镇的特色和不足；也许人生之路就是每走一步都要尝试着去用心发现生活中的美好。

读书笔记（二）中我们整理了坐标系的定义，然后着重推导了一下平移、旋转、缩放三种基本的变换矩阵，所讲内容比较抽象，但确实非常重要。这一次读书笔记我们就应用这些矩阵来做几个简单的例子。整装待发，让我们再次踏上OpenGL的学习之旅吧！

2 着色器的编译链接

着色器语言是一门高级语言，语法上和C系列语言很类似。既然是高级语言，那么用它写的程序代码就不能被机器直接执行，需要编译、连接，最后生成可执行文件才能被CPU/GPU调度执行。着色器语言的编译、连接过程与C语言十分类似，所以在介绍GLSL程序的链接接之前来看看C语言程序是怎么链接成一个可执行程序的。C语言的编译与链接过程如下图所示：

类似的，GLSL编译过程如下：

咋看之下，似乎两者相差很大，GLSL的编译链接过程更为复杂。但其实两者本质是一样的，只不过C语言的编译器如gcc为我们默默地做了很多幕后工作了——如读入源程序、编译、链接——一气呵成。而GLSL语言的编译则需要我们自己将这些步骤拼起来，而且这其中还要创建着色器对象和着色器程序对象，以便于OpenGL的管理。下面，我们就GLSL的编译过程具体展开看看——一个着色器程序是怎么变成可以让GPU调度执行的程序。

C语言中，会先把各个源文件编译为目标文件，然后将各个目标文件链接为可执行文件。GLSL中则通过两种对象——着色器对象和着色器程序对象——来分别处理编译过程和连接过程。这里，我使用了一个类GPUProgram来对GLSL着色器程序的编译、链接过程进行了封装：类的使用者只需要创建对象，通过AddShader添加着色器类型和着色器源代码文件名，然后执行CreateGPUProgram函数即可得到编译链接之后的可执行程序。我们先看看这个对象的代码，然后再深入分析涉及到的API。

GPUProgram.h文件声明了类：

 

 1 #pragma once
 2
 3 #include <map>
 4 #include <string>
 5
 6 #ifndef GLEW_STATIC
 7 #define GLEW_STATIC
 8 #endif
 9
10 #include "GL/glew.h"
11 #include "ResourceCommon.h"
12
13 #ifdef __cplusplus
14 extern "C" {
15 #endif // __cplusplus
16
17 /// \brief
18 class GPUProgram
19 {
20 public:
21     /// \brief    constructor & destructor
22     RESOURCE_EXPORT GPUProgram();
23     RESOURCE_EXPORT ~GPUProgram();
24
25     void RESOURCE_EXPORT AddShader(GLenum SHADER_TYPE, const std::string& sFileName);
26
27     GLuint RESOURCE_EXPORT CreateGPUProgram();
28
29 private:
30     std::string _ReadShaderSourceCode(const std::string& sFileName) const;
31
32     void _RecordShaderLog(GLuint shader) const;
33
34     void _CompileShader(GLuint shader) const;
35
36     void _LineGPUProgram() const;
37
38     void _RecordProgramLog() const;
39
40 private:
41     std::map<GLenum, std::string> m_mapShaderFileName;
42
43     GLuint m_uiProgramID;
44 };
45
46 #ifdef __cplusplus
47 }
48 #endif // __cplusplus

 

GPUProgram.cpp是上述的实现：

 

  1 #include "GPUProgram.h"
  2
  3 #include <fstream>
  4 #include <iostream>
  5 #include <sstream>
  6 #include <memory>
  7 #include "GameFramework/StdAfx.h"
  8
  9 #ifdef __cplusplus
 10 extern "C" {
 11 #endif // __cplusplus
 12
 13 GPUProgram::GPUProgram()
 14 {
 15
 16 }
 17
 18 GPUProgram::~GPUProgram()
 19 {
 20     // -----------------删除着色器程序对象-----------------
 21     glDeleteProgram(m_uiProgramID);
 22 }
 23
 24 void GPUProgram::AddShader(
 25     GLenum SHADER_TYPE, const std::string& sFileName )
 26 {
 27     m_mapShaderFileName.insert(std::make_pair(SHADER_TYPE, sFileName));
 28 }
 29
 30 GLuint GPUProgram::CreateGPUProgram()
 31 {
 32     if (GLEW_OK != glewInit())
 33     {
 34         std::cerr << "Unable to initialize GLEW... Exiting..." << std::endl;
 35         std::exit(EXIT_FAILURE);
 36     }
 37
 38     // -----------------创建着色器程序对象-----------------
 39     m_uiProgramID = glCreateProgram();
 40
 41     for (auto aPair : m_mapShaderFileName)
 42     {
 43         // -----------------创建着色器对象-----------------
 44         GLuint shader = glCreateShader(aPair.first);
 45
 46         // -----------------读取着色器程序文件内容-----------------
 47         std::string sShaderSrc = _ReadShaderSourceCode(aPair.second);
 48
 49         // -----------------关联着色器对象和着色器源代码-----------------
 50         const GLchar *src = const_cast<GLchar *>(sShaderSrc.c_str());
 51         glShaderSource(shader, 1, &src, NULL);
 52
 53         // -----------------编译着色器源代码-----------------
 54         _CompileShader(shader);
 55
 56         // -----------------关联着色器对象到着色器程序对象-----------------
 57         glAttachShader(m_uiProgramID, shader);
 58     }
 59
 60     // ----------------连接着色器程序对象-----------------
 61     _LineGPUProgram();
 62
 63     return m_uiProgramID;
 64 }
 65
 66 std::string GPUProgram::_ReadShaderSourceCode( const std::string& sFileName ) const
 67 {
 68     std::ifstream is;
 69     is.open(sFileName);
 70
 71     std::stringstream ss;
 72     ss << is.rdbuf();
 73
 74     return ss.str();
 75 }
 76
 77 void GPUProgram::_RecordShaderLog(GLuint shader) const
 78 {
 79     // -----------------获取Log长度----------------
 80     GLsizei len;
 81     glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
 82
 83     // -----------------获取Log并打印----------------
 84     GLchar* LOG = new GLchar[len+1];
 85     glGetShaderInfoLog(shader, len, &len, LOG);
 86     std::cerr << "Program link failed: " << LOG << std::endl;
 87     delete [] LOG;
 88 }
 89
 90 void GPUProgram::_CompileShader( GLuint shader ) const
 91 {
 92     glCompileShader(shader);
 93
 94     GLint compileSucceed;
 95     glGetShaderiv(shader, GL_COMPILE_STATUS, &compileSucceed);
 96     if (!compileSucceed)
 97     {
 98         _RecordShaderLog(shader);
 99         throw std::exception("Failed to compile the shader!");
100     }
101 }
102
103 void GPUProgram::_LineGPUProgram() const
104 {
105     glLinkProgram(m_uiProgramID);
106
107     GLint linkSucceed;
108     glGetProgramiv(m_uiProgramID, GL_LINK_STATUS, &linkSucceed);
109     if (!linkSucceed)
110     {
111         _RecordProgramLog();
112         throw std::exception("Failed to link the GPUProgram!");
113     }
114 }
115
116 void GPUProgram::_RecordProgramLog() const
117 {
118     // -----------------获取Log长度----------------
119     GLsizei len;
120     glGetProgramiv(m_uiProgramID, GL_INFO_LOG_LENGTH, &len);
121
122     // -----------------获取Log并打印----------------
123     std::shared_ptr<GLchar> LOG(
124         new GLchar[len + 1], std::default_delete<GLchar>());
125     glGetProgramInfoLog(m_uiProgramID, len, &len, LOG.get());
126     std::cerr << "Program link failed: " << *LOG << std::endl;
127 }
128
129 #ifdef __cplusplus
130 }
131 #endif // __cplusplus

 

2.1 着色器对象的管理

OpenGL管理着一系列的对象，如之前我们接触到的缓存对象、顶点数组对象，以及以后要接触的纹理对象、采样器对象、帧缓存对象等等，使用这些对象来管理我们的数据。我们在客户端通过OpenGL的API创建这些对象，并设置其中的数据，然后在GPU端的着色器程序中实现对这些对象的访问。对于每一个对象，都有与之对于的一套API，如创建glCreateXXX，销毁glDeleteXXX，有一些对象还有绑定glBindXXX，以及其他一些和具体对象相关的API。着色器对象和这些对象一样，不过它管理的数据是用GLSL语言写的着色器源代码。

首先看CreateGPUProgram函数，这个函数主要封装了GLSL编译链接的过程。第一个调用的OpenGL API便是glCreateProgram，顾名思义，这个借口就是创建一个着色器程序对象。创建完着色器程序对象后，遍历一个map容器，在这个map容器中存放着着色器类型到着色器文件名的映射。

• 对每一个着色器类型，通过glCreateShader创建一个管理着色器源代码的着色器对象，该函数的函数签名为：

GLuint glCreateShader(GLenum type);

type    ——待创建的着色器对象类型
返回值   ——着色器对象的ID

• 对每一个着色器文件名，通过调用_ReadShaderSourceCode读入文件中的着色器程序源代码。

创建完对应类型的着色器对象并从文件读取着色器的源代码（注：着色器代码也可以通过定义字符串的方式给出，见红宝书<中文版>p50-51），接下来就是建立着色器对象和着色器源代码之间的关系，通过glShaderSource实现，其函数签名为：

 

void glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLchar* length);

shader    ——标识着色器对象的ID（可理解为Handler）
count     ——着色器源代码的数量
string    ——着色器源代码（可能由多个，根据count而定）
length    ——每个着色器源代码的长度

 

一切准备工作都已经完毕——着色器对象已经有了，着色器源代码也已经有了，并和着色器对象做了关联，接下来就是把编译着色器源代码了，这就是glCompileShader的功能，其函数签名为：

void glCompileShader(GLuint shader)

shader    ——标识着色器对象的ID

最后一步，就是将编译好的着色器对象关联到着色器程序对象，所使用 的OpenGL API函数签名如下：

void glAttachShader(GLuint program, GLuint shader)

program    ——标识着色器程序对象的ID
shader     ——标识着色器对象的ID

2.2 着色器程序对象的管理

着色器程序对象相当于着色器对象的容器，和任何OpenGL管理的对象一样，在使用着色器程序对象之前，需要通过glCreateProgram接口来创建出一个着色器程序对象。一般，在一次OpenGL绘制中，只能使用一个着色器程序对象。创建着色器程序对象的函数签名为：

GLuint glCreateProgram()

返回值    ——标识着色器程序对象的ID

创建完着色器程序对象之后，可以通过刚才介绍的glAttachShader将编译完的着色器对象与着色器程序对象关联起来。关联完成后，就可以将这些着色器对象链接成为一个可被GPU调度执行的二进制程序了。链接命令的函数全面如下：

void glLinkProgram(GLuint program)

program    ——标识着色器程序对象的ID

执行完上述命令后，我们得到了一个可执行的着色器程序，但一个OpenGL程序中可能有多个很多个可执行的着色器程序，那么这时我们就要告诉OpenGL，使用哪一个可执行的着色器程序，这就引出了下面的API：

void GLUseProgram(GLuint program)

program    ——标识着色器程序对象的ID

至此，OpenGL在执行渲染管线时就会调用相应的着色器程序了。写到这里，我们可以知道，编译好的着色器程序就像dll一样，不能单独运行，只能嵌入到OpenGL的渲染管线中管线中才能被执行。上面介绍的是在编译链接过程中最重要的一些API，还有其它API都是比较简单的，在此就不作详细介绍了。

看到这里，大家也许有点疲惫了，休息一会，来看看静谧的海滩、蔚蓝的天空和美丽的椰子树~~

3 着色器输入之变换矩阵

3.1 存储限制符与uniform变量的引入

课堂笔记（一）讲述了OpenGL程序的基本结构——和大多数程序一样，OpenGL程序一般由三部分组成（如下图）：输入层、处理层和输出层。其中输入部分主要是将顶点数据、坐标变换矩阵（本节将要讲述）以及以后要讲述的纹理数据、光照数据输入给OpenGL——巧妇难为无米之催，OpenGL也同样需要数据或资源才能绘制图像；处理层则主要是运行OpenGL运行渲染管线——这部分以前是固定的、不可编程的；现在引入了着色器程序之后就可编程了，也就是着色器程序的作用主要是对这些输入进行处理，比如顶点变换、光照明暗处理、纹理读取balabala……，也就是对输入层进行加工；最后从帧缓存中取出的就是OpenGL给我们绘制出来的图像了。这就是计算机绘图，曾经觉得很神秘，现在也慢慢地懂了其中的一些流程，慢慢觉得这些也不过如此！^_^。

从上图中可以看出：笔记（二）得到的变换矩阵是作为输入层的一部分。在笔记（一）中，我们知道OpenGL为顶点数据提供了缓冲区对象（Buffer Object）和顶点数组属性分别用来上传顶点数据和描述顶点的数据（元数据）给GPU。那OpenGL为变换矩阵的输入提供了什么工具呢？——Uniform变量。在讲述uniform变量前，让我们先来回顾一下变量的概念。

从大一接触C语言开始，我们就学习了程序设计中变量的概念。所谓变量，其实是一段内存区域的刻画——变量名、变量类型、变量初始值（数据）。变量在编程中的重要性，不言而喻：变量里保存的是数据，我们编程的目的不就是对这些数据进行处理吗？所以，在任何一门编程语言中，变量（包括声明、赋值、类型等）相关的知识点是学习编程语言的一个重点。

在C语言中变量定义时，碰到第一个单词描述的就是变量的类型，如int a = 1。我们从变量类型开始，GLSL着色语言的变量类型和普通的C系列语言没有太大差别，主要是多了两个在计算机图形学中使用十分广泛的类型——向量vec和矩阵mat，下图给出了GLSL定义的基本数据类型：

 变量名和变量初始值这些和C系列语言是完全相同的，在这里就不再赘述了。

定义变量语句给出的是变量类型、变量名和变量值，这在GLSL中还不够！变量在内存/显存中是存储在哪块区域中的？从物理存储器的角度看，内存只是一系列连续的存储单元，通过地址对其访问；从编程逻辑的角度看，操作系统或编译系统对内存的管理其实是分了不同的逻辑区域的——栈区、堆区、全局数据区、常量区和代码区。例如：全局变量存储在全局数据区；局部变量及函数输入输出变量存储在栈区；常量存储在常量区。在C语言中，可以将全局变量定义在任何函数之外来表示这是一个全局变量；局部变量则定义在函数中；函数的输入变量定义在函数的输入参数列表中等等。那GLSL中，怎么描述一个变量是局部变量还是全局变量，怎么描述着色器的输入变量还是输出变量。这就引入了存储限制符的概念——用来描述变量存储区域和作用，存储限制符主要用下面这些关键字描述:

const 　　  ——这应该是最简单的存储限制符了，它出现在变量声明表达式中，意味着该变量一旦初始化之后，就不能改变了，如：const float PI = 3.1415926；

in　　　　  ——在着色器程序中的主函数（main）中，是没有输入参数的，如何向着色器传入外部数据呢？这时就要用到in存储修饰符来表示那些变量是来自外部程序或其他着色器的输入；

out　 　　  ——和in存储修饰符相反，out存储修饰符用于标识着色器的输出变量，或传给下一阶段的着色器，或传给着色器外部程序；

uniform　  ——总算出来了，红宝书上是这么写的：uniform修饰符可以指定一个在应用中设置好的变量，它不会在图元处理的过程中发生变化，且在所有的着色阶段之间都是共享的——着色器中的全局变量。

buffer　　   ——和uniform变量类似，不过它可以被修改。

所以，如果希望应用程序客户端向GPU的着色器程序传递数据，可以使用uniform变量。关于uniform变量，这涉及到两个知识点：应用程序端调用什么借口上传数据？着色器中应该怎么定义uniform变量？下面通过一段程序来看看uniform变量的使用。

3.2 Uniform变量的使用

下面的程序绘制的是一个正方形轮廓，代码和读书笔记（一）中的程序差不多，主要是增加了一个变换矩阵，并通过Uniform变量上传至GPU中，使着色器程序能访问到该矩阵变量；另外，在读书笔记（一）中我们使用的是红宝书给出的方法来加载着色器，这次读书笔记中使用的是刚才在第二小节中给出的GPUProgram对象对着色器程序的加载、编译与链接。程序代码如下：

 

 1 #include <iostream>
 2
 3 #include "AlgebraicEntity/Matrix.h"
 4
 5 #include "GameFramework/StdAfx.h"
 6 #include "Resource/GPUProgram.h"
 7
 8 GLint location;
 9 GPUProgram gpuProgram;
10
11 void initialize_04()
12 {
13     // ----------------准备顶点数据----------------
14     GLfloat vertices_array[4][4] =
15     {
16         { -0.5,  0.5, 0.0, 1.0 },
17         {  0.5,  0.5, 0.0, 1.0 },
18         {  0.5, -0.5, 0.0, 1.0 },
19         { -0.5, -0.5, 0.0, 1.0 },
20     };
21
22     // ----------------建立缓存对象加载数据----------------
23     GLuint Buffer_ID;
24     glGenBuffers(1, &Buffer_ID);
25     glBindBuffer(GL_ARRAY_BUFFER, Buffer_ID);
26     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_array), vertices_array, GL_STATIC_DRAW);
27
28     // ----------------建立顶点数组对象----------------
29     GLuint VAO_ID;
30     glGenVertexArrays(1, &VAO_ID);
31     glBindVertexArray(VAO_ID);
32     glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, BUFFER_OFFSET(0));
33     glEnableVertexAttribArray(0);
34
35     // ----------------创建着色器程序对象----------------
36     gpuProgram.AddShader(GL_VERTEX_SHADER, "F:/VC++游戏编程/OpenGLGuide/OpenGL04/square.vert");
37     gpuProgram.AddShader(GL_FRAGMENT_SHADER, "F:/VC++游戏编程/OpenGLGuide/OpenGL04/square.frag");
38     GLuint program = gpuProgram.CreateGPUProgram();
39     glUseProgram(program);
40
41     location = glGetUniformLocation(program, "mat_simple_transform");
42 }
43
44 void display_04()
45 {
46     // ----------------创建缩放矩阵----------------
47     Matrix4X4 mat = Matrix4X4::CreateRotateMatrix(PI / 4, Vector3D(0.0, 0.0, 1.0));
48
49     // ----------------通过uniform上传至GPU----------------
50     glUniformMatrix4fv(location, 1, GL_FALSE, mat._m);
51
52     // ----------------清空颜色缓存----------------
53     glClear(GL_COLOR_BUFFER_BIT);
54
55     // ----------------绘制正方形图像----------------
56     glDrawArrays(GL_LINE_LOOP, 0, 4);
57
58     // ----------------同步执行结束----------------
59     glFlush();
60 }
61
62 int main(int argc, char **argv)
63 {
64     try
65     {
66         glutInit(&argc, argv);
67         glutInitDisplayMode(GLUT_RGBA);
68         glutInitWindowSize(512, 512);
69         glutInitContextVersion(3, 3);
70         glutInitContextProfile(GLUT_CORE_PROFILE);
71         glutCreateWindow(argv[0]);
72
73         glewExperimental = GL_TRUE;
74         if (GLEW_OK != glewInit())
75         {
76             std::cerr << "Unable to initialize GLEW... Exiting..." << std::endl;
77             std::exit(EXIT_FAILURE);
78         }
79
80         initialize_04();
81         glutDisplayFunc(display_04);
82         glutMainLoop();
83
84         return 0;
85     }
86     catch (const std::exception& ke)
87     {
88         std::cerr << "Error happened because of " << ke.what();
89         return -1;
90     }
91 }

 

运行效果就是绘制了一个正方形的轮廓，如下图所示：

效果确实不怎么样^_^，但是可以阐述知识点和OpenGL API。可以看出，图中的正方形是旋转得到的。旋转矩阵通过下面这个我们自己写的接口CreateRotateMatrix获得（该矩阵的定义已在笔记（二）中做了介绍，在此不再赘述了），该函数的函数签名如下：

static Matrix4X4 CreateRotateMatrix(double dAngle, const Vector3D& rotateAxis);

dAngle         ——旋转的角度
rotateAxis     ——旋转轴向量

紧接着就是通过glUniformMatrix4fv的方式将上述旋转矩阵上传至服务（GPU）端。上传之前，就像我们上传文件到服务器一样，需要知道上传的位置，所以在调用此函数前，会先调用glGetUniformLocation函数获得Uniform变量的索引值（见程序：41行）。事实上，GLSL编译器在链接着色器程序时，会创建一个uniform变量列表，在设置unifrom前所获取的索引便是在该列表中的索引。glGetUniformLocation函数签名如下：

GLint glGetUniformLocation(GLuint program, const char* name);

program     ——链接后的GLSL程序标识ID
name        ——uniform在着色器程序代码中的变量名
返回值       ——uniform变量在uniform变量列表中的索引值

上述函数的返回值和输入参数program都比较简单，但name（变量名）的设置可以比较灵活——可以是单一的变量名称，也可以是结构体中成员变量（域）的名称(通过.操作符访问)，或者是数组中的某一条目（通过[]索引访问），下面是几个较为复杂的实例：

着色器中的声明如下：

 

1 uniform struct
2 {
3     struct
4     {
5         float a;
6         float b[10];
7     }  c[2];
8     vec2 d;
9 } e;

 

应用程序端获取索引值的函数调用为：

1 GLint loc1 = glGetUniformLoaction(program, "e.d");    　　　　// ok
2 GLint loc1 = glGetUniformLoaction(program, "e.c[0]");    　　// error
3 GLint loc1 = glGetUniformLoaction(program, "e.c[0].b");     // ok, 数组第一个元素的索引
4 GLint loc1 = glGetUniformLoaction(program, "e.c[0].b[2]");  // ok

确定好存放位置之后，就可以通过glUniformMatrix4fv接口向GPU端上传数据了，其函数签名为：

 

void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* values)

location    ——上传数据在uniform列表中索引值
count       ——上传的矩阵个数
transpose   ——行主序还是列主序
value       ——指向矩阵数据的指针

 

上传了数据之后，就可以在着色器程序中对unifrom变量进行访问了，例如，顶点着色器中访问旋转矩阵的代码如下：

 

#version 330 core

uniform mat4 mat_simple_transform;

layout(location = 0) in vec4 vPosition;

void main()
{
    gl_Position = mat_simple_transform * vPosition;
}

 

实践提示：① 一定要保证着色器中的uniform变量类型一定要和应用程序上传的数据类型一致。例如在我们的着色器程序中，变换矩阵元素的类型是单精度浮点型，那上传的数据也必须是单精度浮点型的。我在写这段程序的时候，就遇到了一个错误：着色器中使用的是mat4，也就是矩阵元素单精度浮点型，但上传的数据时使用了double类型（双精度浮点型），而且这样的错误还很难发现——编译器并没有提示，只是图都不见了；② 另外GLSL支持的隐式类型转换更少，更要保持类型的一致性。例如：如果矩阵是mat4类型的，vPosition必须是vec4类型的，那么它们之间是不能运算的，会有编译错误。

4 变换矩阵的综合使用

这一节主要对笔记（二）定义的坐标变换矩阵的综合运用，给出几个基于目前所了解的知识点就能实现的绘制实例，也算是对前两篇读书笔记的温习吧！这里的例子，顶点数据就是上述例子中的数据——绘制的都是正方形轮廓，只是通过不同的display函数实现不同的展示效果。

4.1 缩放

将绘制函数修改为如下函数：

 

 1 void display_04_scale()
 2 {
 3     // ----------------清空颜色缓存----------------
 4     glClear(GL_COLOR_BUFFER_BIT);
 5
 6     for (int i = 1; i <= 10; i++)
 7     {
 8         // ----------------创建缩放矩阵----------------
 9         Matrix4X4 mat = Matrix4X4::CreateScaleMatrix(i * 0.1);
10
11         // ----------------通过uniform上传至GPU----------------
12         glUniformMatrix4fv(location, 1, GL_FALSE, mat._m);
13
14         // ----------------绘制正方形图像----------------
15         glDrawArrays(GL_LINE_LOOP, 0, 4);
16     }
17 }

 

可以得到下面的显示效果：

4.2 平移

将绘制函数改为如下函数：

 

 1 void display_04_translate()
 2 {
 3     // ----------------清空颜色缓存----------------
 4     glClear(GL_COLOR_BUFFER_BIT);
 5
 6     for (int i =-4; i <= 4; i++)
 7     {
 8         // ----------------创建缩放矩阵----------------
 9         Matrix4X4 mat = Matrix4X4::CreateTranslateMatrix(
10             Vector3D(i * 0.1, i * 0.1, 0.0));
11
12         // ----------------通过uniform上传至GPU----------------
13         glUniformMatrix4fv(location, 1, GL_TRUE, mat._m);
14
15         // ----------------绘制正方形图像----------------
16         glDrawArrays(GL_LINE_LOOP, 0, 4);
17     }
18 }

 

可以得到下述效果：

4.3 综合效果

下面代码演示的是各种不同坐标变换矩阵相乘得到的变换矩阵，对图形进行变换，然后进行绘制：

 

 1 void display_04_combine()
 2 {
 3     // ----------------清空颜色缓存----------------
 4     glClear(GL_COLOR_BUFFER_BIT);
 5
 6     // 上
 7     {
 8         Matrix4X4 mat = Matrix4X4::CreateTranslateMatrix(Vector3D(0.0, 0.5, 0.0));
 9         mat = mat * Matrix4X4::CreateScaleMatrix(0.3);
10         mat = mat * Matrix4X4::CreateRotateMatrix(0, Vector3D(0.0, 0.0, 1.0));
11         glUniformMatrix4fv(location, 1, GL_TRUE, mat._m);
12         glDrawArrays(GL_LINE_LOOP, 0, 4);
13     }
14
15     // 右
16     {
17         Matrix4X4 mat = Matrix4X4::CreateTranslateMatrix(Vector3D(0.5, 0.0, 0.0));
18         mat = mat * Matrix4X4::CreateScaleMatrix(0.4);
19         mat = mat * Matrix4X4::CreateRotateMatrix(PI / 12, Vector3D(0.0, 0.0, 1.0));
20         glUniformMatrix4fv(location, 1, GL_TRUE, mat._m);
21         glDrawArrays(GL_LINE_LOOP, 0, 4);
22     }
23
24     // 下
25     {
26         Matrix4X4 mat = Matrix4X4::CreateTranslateMatrix(Vector3D(0.0, -0.5, 0.0));
27         mat = mat * Matrix4X4::CreateScaleMatrix(0.5);
28         mat = mat * Matrix4X4::CreateRotateMatrix(PI / 6, Vector3D(0.0, 0.0, 1.0));
29         glUniformMatrix4fv(location, 1, GL_TRUE, mat._m);
30         glDrawArrays(GL_LINE_LOOP, 0, 4);
31     }
32
33     // 左
34     {
35         Matrix4X4 mat = Matrix4X4::CreateTranslateMatrix(Vector3D(-0.5, 0, 0.0));
36         mat = mat * Matrix4X4::CreateScaleMatrix(0.6);
37         mat = mat * Matrix4X4::CreateRotateMatrix(PI / 4, Vector3D(0.0, 0.0, 1.0));
38         glUniformMatrix4fv(location, 1, GL_TRUE, mat._m);
39         glDrawArrays(GL_LINE_LOOP, 0, 4);
40     }
41 }

 

效果图：

 5 总结

这一次读书笔记主要是对上次读书笔记的回顾与应用，同时讲述了GLSL着色器程序的编译以及如何通过uniform变量向着色器程序传递数据。这次读书笔记内容虽然较多，但相对前一次读书笔记来说，要简单一些。到目前为止，我们还是在二维领域摸索，但OpenGL主要是用于三维图形的绘制，接下来我们会将这些基础知识应用到三维图形的绘制。哎，明天又要上班了，又不能睡懒觉了，~~~~(>_<)~~~~

标签: OpenGL