GLSL 内建变量#

内建变量为着色器无需手动定义、可直接使用的系统变量，自带固定语义，可理解为系统自动填充或等待管线填充的内置常量/变量。 *示例：*顶点着色器中裁剪空间输出位置向量 gl_Position。

着色器接口块#

接口块用于规范化组织着色器的输入与输出数据，实现顶点着色器与片元着色器的数据传递。

使用规则#

顶点着色器：使用 out 关键字定义输出接口块
片元着色器：使用 in 关键字定义输入接口块
核心要求：两端块名必须完全一致，块实例对象名无需一致
访问块内成员变量时，必须添加块名作为前缀

普通 Uniform 变量共享规则#

跨着色器程序#

多个独立的着色器程序（各自包含一套顶点+片元着色器），即使定义了同名 uniform 变量，必须分别单独设置，相互不共享。

同着色器程序内部#

对于同一个着色器程序，若顶点着色器、片元着色器使用了同一个 uniform 变量，只需 CPU 设置一次即可全局共用。

Uniform 缓冲对象#

UBO（Uniform Buffer Object）：类似于 VBO，VBO 用于存储顶点数据，UBO 专门用于存储多个着色器程序可共享的批量 Uniform 变量。

核心工作原理#

GPU 预设有若干 UBO 绑定点，通过绑定点编号对齐实现数据互通：

CPU 侧：将创建好的 UBO 绑定到指定编号的绑定点
着色器侧：Uniform 块声明绑定到同一编号的绑定点
编号匹配后，所有关联该绑定点的着色器均可读取同一份 UBO 数据

着色器端 UBO 声明（OpenGL4.2+）#

1
// std140：固定内存对齐规则
2
// binding=0：绑定至0号UBO绑定点
3
layout (std140,binding=0) uniform GlobalMatrices{
4
    mat4 view;
5
    mat4 project;
6
};
7

8
// 普通独有Uniform，仅属于当前着色器
9
uniform mat4 model;

C++ 端创建 UBO#

1
unsigned int ubo;
2
glGenBuffers(1,&ubo);
3
glBindBuffer(GL_UNIFORM_BUFFER,ubo);
4
// 开辟对应大小显存，暂不填充数据
5
glBufferData(GL_UNIFORM_BUFFER,2*sizeof(glm::mat4),NULL,GL_STATIC_DRAW);
6
glBindBuffer(GL_UNIFORM_BUFFER,0);

C++ 端绑定 UBO 到绑定点#

1
一个 UBO 只需绑定一次，全局生效：
2
// 方式1：指定偏移与大小，支持一个缓冲区绑定多段UBO
3
glBindBufferRange(GL_UNIFORM_BUFFER,0,ubo,0,2*sizeof(glm::mat4));
4

5
// 方式2：整体绑定整个UBO缓冲区
6
glBindBufferBase(GL_UNIFORM_BUFFER,0,ubo);

低版本 OpenGL 绑定方式（4.2 以下）#

1
不支持着色器内 binding 布局，需要代码手动关联块与绑定点：
2
// 获取Uniform块索引
3
unsigned int index=glGetUniformBlockIndex(shader.ID,"GlobalMatrices");
4
// 将该块关联到0号绑定点
5
glUniformBlockBinding(shader.ID,index,0);

需要使用该 Uniform 块的所有着色器，均需执行一次该绑定。

Uniform 三种内存布局规则#

CPU 与 GPU 内存对齐策略不同，必须指定布局规则，才能精准匹配数据偏移。常用三种：std140、shared、packed。

std140#

强制固定对齐规则，偏移可提前预判计算，适合UBO多着色器共享。 基础对齐规范

float / int / bool / uint：基准对齐 4 字节，占用 4 字节
vec2：基准对齐 8 字节，占用 8 字节
vec3：基准对齐 16 字节，占用 12 字节
vec4：基准对齐 16 字节，占用 16 字节
matN 矩阵：按列拆分为多个 vec4，每列基准对齐 16 字节、占用 16 字节
数组：每个元素基准对齐强制 16 字节，元素自身占用按类型计算
结构体：整体基准对齐 = 内部最大成员的基准对齐，内部成员按规则排布填充

1
layout (std140) uniform ExampleBlock
2
{
3
                     // 基准对齐      // 字节偏移
4
    float value;     // 4            // 0
5
    vec3 vector;     // 16           // 16
6
    mat4 matrix;     // 16           // 32、48、64、80（四列）
7
    float values[3]; // 16           // 96、112、128
8
    bool boolean;    // 4            // 144
9
    int integer;     // 4            // 148
10
};

整体块占用 152 字节，开辟显存时至少分配该大小。

shared#

无强制固定对齐规则，编译器自动优化内存排布，变量偏移无法预计算。使用时需要运行时查询偏移量再写入数据：

1
// 1. 获取块索引
2
GLuint blockIndex=glGetUniformBlockIndex(shader.ID,"TestBlock");
3
// 2. 定义成员名数组
4
const char* names[]={"f","v3","arr[0]"};
5
GLuint indices[3];
6
// 3. 获取成员索引
7
glGetUniformIndices(shader.ID,3,names,indices);
8
// 4. 查询各成员偏移
9
GLuint offsets[3];
10
glGetActiveUniformsiv(shader.ID,3,indices,GL_UNIFORM_OFFSET,offsets);

packed#

编译器会自动优化剔除未使用的 Uniform 变量，内存布局不固定。 禁止用于 UBO 共享场景：不同着色器的变量使用情况不同，布局不一致，无法跨程序共享数据。

UBO 数据填充方式#

使用glBufferSubData局部更新 UBO 数据：

1
glBufferSubData(GL_UNIFORM_BUFFER, 内存偏移, 数据真实大小, 数据指针);

参数说明：偏移量为 std140 规则计算出的精准字节偏移，大小为变量真实数据大小，不包含内存填充空字节。

Uniform 块变量访问规则#

在着色器代码中，Uniform 块内部成员变量无需加任何前缀，可直接访问使用。

UBO 优势#

**提升渲染效率：**批量合并内存传输，大幅减少 CPU-GPU API 调用次数
**多着色器共享、易维护：**全局一份统一数据，切换着色器无需重复赋值
**突破原生 Uniform 数量限制：**原生 Uniform 组件数量上限极低（mat4、vec 数量受限），无法满足骨骼动画等大量矩阵需求；UBO 限制宽松，可承载大批量矩阵数据

example1: GLSL内建变量#

顶点着色器的输出变量gl_PointSize。要实现的是离得越远，点越大。那么首先在main.cpp我们需要构建一些点，点没有顶点数据，所以无需准备（位置、法线或纹理等顶点属性信息），但是点有位置数据，所以可以定义一个点位置数组（如果要绘制多个点的话）。把这个位置数据直接放入顶点缓冲区，配置顶点指针，然后在渲染循环内使用glDrawArrays(GL_POINT,0,8)，第一个参数指明了绘制图元类型为点，第二个参数指明了从顶点缓冲区的第一个顶点开始取数据，第三个参数指明了要取多少个数据（即要画多少个点）。如果需要配置点大小，则需要开启GL_PROGRAM_POINT_SIZE，然后在顶点着色器中配置gl_PointSize。这里为了实现离得越远，点越大，那么gl_PointSize=abs(gl_Position.z)，因为gl_Position正是裁剪空间坐标，其z坐标的绝对值代表了物体到相机的非线性深度（相机朝-z看，如果物体在相机前方，其z坐标必定为负数，且离得越远，z坐标的绝对值越大）（教程中这里没有加abs，但也没有出错，我也不知道为什么，按道理说gl_Position.z是负数，赋值给pointSize肯定是不合适的。但是我可视化了一下gl_Position.z发现它并不是负数，这就更奇怪了）

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4

5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21

22
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
23
float lastX = (float)SCR_WIDTH / 2.0f;
24
float lastY = (float)SCR_HEIGHT / 2.0f;
25
float deltaTime = 0.0f;
26
float lastFrame = 0.0f;
27
bool firstCamera = true;
28

29
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
30
        glViewport(0, 0, width, height);
31
}
32
void processInput(GLFWwindow* window) {
33
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
34
                glfwSetWindowShouldClose(window, true);
35
        }
36
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
37
                camera.ProcessKeyboard(FORWARD, deltaTime);
38
        }
39
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
40
                camera.ProcessKeyboard(BACKWARD, deltaTime);
41
        }
42
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
43
                camera.ProcessKeyboard(LEFT, deltaTime);
44
        }
45
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
46
                camera.ProcessKeyboard(RIGHT, deltaTime);
47
        }
48
}
49
void processMovement(GLFWwindow* window, double xpos, double ypos) {
50
        if (firstCamera) {
51
                lastX = xpos;
52
                lastY = ypos;
53
                firstCamera = false;
54
        }
55
        float xoffset = xpos - lastX;
56
        float yoffset = lastY - ypos;
57
        lastX = xpos;
58
        lastY = ypos;
59
        camera.ProcessMouseMovement(xoffset, yoffset);
60
}
61
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
62
        camera.ProcessScroll(yoffset);
63
}
64
unsigned int loadTexture(const char* path) {
65
        unsigned int texture;
66
        glGenTextures(1, &texture);
67
        glBindTexture(GL_TEXTURE_2D, texture);
68

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "Failed to load texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        //stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147
        glEnable(GL_PROGRAM_POINT_SIZE);
148

149
        float vertices[] = {
150
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
156

157
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
158
                 0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
159
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
160
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
161
                -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
162
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
163

164
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
165
                -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
166
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
167
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
168
                -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
169
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
170

171
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
172
                 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
173
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
174
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
175
                 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
176
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
177

178
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
179
                 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
180
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
181
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
182
                -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
183
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
184

185
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
186
                 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
187
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
188
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
189
                -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
190
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
191
        };
192

193
        float pointPositions[] = {
194
                0.0f, 0.0f, 0.0f,
195

196
                1.0f, 0.0f, 0.0f,
197

198
                -1.0f,0.0f,0.0f,
199

200
                0.0f, 1.0f, 0.0f,
201

202
                0.0f,-1.0f,0.0f,
203

204
                0.0f, 0.0f, 1.0f,
205

206
                0.0f, 0.0f,-1.0f,
207

208
                2.0f, 0.0f, 0.0f
209
        };
210

211
        unsigned int pointVAO, pointVBO;
212
        glGenVertexArrays(1, &pointVAO);
213
        glGenBuffers(1, & pointVBO);
214
        glBindVertexArray(pointVAO);
215
        glBindBuffer(GL_ARRAY_BUFFER, pointVBO);
216
        glBufferData(GL_ARRAY_BUFFER, sizeof(pointPositions), pointPositions, GL_STATIC_DRAW);
217
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
218
        glEnableVertexAttribArray(0);
219

220
        glBindVertexArray(0);
221

222
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
223

224
        while (!glfwWindowShouldClose(window)) {
225
                float currentFrame = (float)glfwGetTime();
226
                deltaTime = currentFrame - lastFrame;
227
                lastFrame = currentFrame;
228

229
                processInput(window);
230

231
                glClearColor(0.1, 0.1, 0.1, 1.0);
232
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
233

234
                shader.use();
235
                glm::mat4 view = camera.GetCameraView();
236
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom),(float)SCR_WIDTH / SCR_HEIGHT, 0.1f, 100.0f);
237
                glm::mat4 model = glm::mat4(1.0f);
238
                shader.setMatrix("model", model);
239
                shader.setMatrix("view", view);
240
                shader.setMatrix("project", project);
241

242
                glBindVertexArray(pointVAO);
243
                glDrawArrays(GL_POINTS, 0, 8);
244
                glBindVertexArray(0);
245

246
                glfwSwapBuffers(window);
247
                glfwPollEvents();
248
        }
249
        glDeleteVertexArrays(1, &pointVAO);
250
        glDeleteBuffers(1, &pointVBO);
251

252
        glfwTerminate();
253
        return 0;
254
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4

5
uniform mat4 model;
6
uniform mat4 view;
7
uniform mat4 project;
8

9
void main(){
10
        gl_Position=project*view*model*vec4(aPos,1.0);
11
        gl_PointSize=gl_Position.z;
12
}

1
//fragmentShader
2
#version 330 core
3

4
out vec4 FragColor;
5

6
void main(){
7
        FragColor=vec4(vec3(0.5),1.0);
8
}

BQACAgUAAyEGAASHRsPbAAEWLONqP4IAARW5_f3btZQv__VDgav7e0AAAmkmAAJNOQFW9DMzFkcyPxM8BA.png 顶点着色器的输入变量gl_VertexID。表示当前正在处理的顶点在本次绘制调用中的索引。从0开始递增，每处理一个顶点，值+1.对使用glDrawArrays绘制而言，gl_VertexID是顶点的全局序号，从start开始，每画一个顶点，gl_VertexID+1。对使用glDrawELements绘制而言，gl_VertexID是绘制顶点本身的索引。它的用途可以是：不需要在C++里准备完整顶点数据，靠gl_VertexID在着色器中区分顶点，减少CPU-GPU的数据传输。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4

5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21

22
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
23
float lastX = (float)SCR_WIDTH / 2.0f;
24
float lastY = (float)SCR_HEIGHT / 2.0f;
25
float deltaTime = 0.0f;
26
float lastFrame = 0.0f;
27
bool firstCamera = true;
28

29
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
30
        glViewport(0, 0, width, height);
31
}
32
void processInput(GLFWwindow* window) {
33
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
34
                glfwSetWindowShouldClose(window, true);
35
        }
36
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
37
                camera.ProcessKeyboard(FORWARD, deltaTime);
38
        }
39
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
40
                camera.ProcessKeyboard(BACKWARD, deltaTime);
41
        }
42
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
43
                camera.ProcessKeyboard(LEFT, deltaTime);
44
        }
45
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
46
                camera.ProcessKeyboard(RIGHT, deltaTime);
47
        }
48
}
49
void processMovement(GLFWwindow* window, double xpos, double ypos) {
50
        if (firstCamera) {
51
                lastX = xpos;
52
                lastY = ypos;
53
                firstCamera = false;
54
        }
55
        float xoffset = xpos - lastX;
56
        float yoffset = lastY - ypos;
57
        lastX = xpos;
58
        lastY = ypos;
59
        camera.ProcessMouseMovement(xoffset, yoffset);
60
}
61
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
62
        camera.ProcessScroll(yoffset);
63
}
64
unsigned int loadTexture(const char* path) {
65
        unsigned int texture;
66
        glGenTextures(1, &texture);
67
        glBindTexture(GL_TEXTURE_2D, texture);
68

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "Failed to load texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        //stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147
        glEnable(GL_PROGRAM_POINT_SIZE);
148

149
        float vertices[] = {
150
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
156

157
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
158
                 0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
159
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
160
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
161
                -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
162
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
163

164
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
165
                -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
166
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
167
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
168
                -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
169
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
170

171
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
172
                 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
173
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
174
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
175
                 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
176
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
177

178
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
179
                 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
180
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
181
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
182
                -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
183
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
184

185
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
186
                 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
187
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
188
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
189
                -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
190
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
191
        };
192

193
        //只存了一个顶点的数据
194
        float pointPositions[] = {
195
                0.0f, 0.0f, 0.0f
196
        };
197

198
        unsigned int pointVAO, pointVBO;
199
        glGenVertexArrays(1, &pointVAO);
200
        glGenBuffers(1, & pointVBO);
201
        glBindVertexArray(pointVAO);
202
        glBindBuffer(GL_ARRAY_BUFFER, pointVBO);
203
        glBufferData(GL_ARRAY_BUFFER, sizeof(pointPositions), pointPositions, GL_STATIC_DRAW);
204
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
205
        glEnableVertexAttribArray(0);
206

207
        glBindVertexArray(0);
208

209
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
210

211
        while (!glfwWindowShouldClose(window)) {
212
                float currentFrame = (float)glfwGetTime();
213
                deltaTime = currentFrame - lastFrame;
214
                lastFrame = currentFrame;
215

216
                processInput(window);
217

218
                glClearColor(0.1, 0.1, 0.1, 1.0);
219
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
220

221
                shader.use();
222
                glm::mat4 view = camera.GetCameraView();
223
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom),(float)SCR_WIDTH / SCR_HEIGHT, 0.1f, 100.0f);
224
                glm::mat4 model = glm::mat4(1.0f);
225
                shader.setMatrix("model", model);
226
                shader.setMatrix("view", view);
227
                shader.setMatrix("project", project);
228

229
                glBindVertexArray(pointVAO);
230
                glDrawArrays(GL_POINTS, 0, 15);//要求GPU连续处理15个顶点，而缓冲区只有1组数据，那么就循环复用缓冲区里的顶点数据
231
                glBindVertexArray(0);
232

233
                glfwSwapBuffers(window);
234
                glfwPollEvents();
235
        }
236
        glDeleteVertexArrays(1, &pointVAO);
237
        glDeleteBuffers(1, &pointVBO);
238

239
        glfwTerminate();
240
        return 0;
241
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4

5
uniform mat4 model;
6
uniform mat4 view;
7
uniform mat4 project;
8

9
out vec3 ourColor;
10

11
void main(){
12
        //根据变化的gl_VertexID计算顶点的差异化位置、大小、颜色
13
        float offsetX=gl_VertexID*0.6;
14
        vec3 newPos=aPos+vec3(offsetX,0.0,0.0);
15
        gl_Position=project*view*model*vec4(newPos,1.0);
16
        gl_PointSize=8.0+gl_VertexID*1.2;
17
        ourColor=vec3(gl_VertexID/15.0,0.3,0.8);
18
}

1
//fragmentShader
2
#version 330 core
3
in vec3 ourColor;
4
out vec4 FragColor;
5

6
void main(){
7
        FragColor=vec4(ourColor,1.0);
8
}

BQACAgUAAyEGAASHRsPbAAEWLPNqP4JvYkC4FbxZIrEJyfvIOmDxBAACfyYAAk05AVZcWWFl6jlLpDwE.png 还可以是构建程序化网格：根据gl_VertexID计算点的行数和列数，分别赋予不同的颜色

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4

5
uniform mat4 model;
6
uniform mat4 view;
7
uniform mat4 project;
8

9
out vec3 ourColor;
10

11
void main(){
12
        //根据变化的gl_VertexID计算顶点的差异化位置、颜色
13
        float row=floor(gl_VertexID/10.0);
14
        float col=mod(gl_VertexID,10.0);
15
        vec3 gridPos=vec3(col*0.6,row*0.6,0.0);
16
        gl_Position=project*view*model*vec4(gridPos,1.0);
17
        gl_PointSize=8.0;
18
        ourColor=vec3(gl_VertexID/20.0,0.3,0.8);
19
}

BQACAgUAAyEGAASHRsPbAAEWLPtqP4Kt8U-UStmLds75fqYGbSQf2AACjSYAAk05AVa-y-wdEBHsrDwE.png 还可以是CPU传入顶点颜色/纹理数组，然后使用gl_VertexID作为下标取值。片元着色器的输入gl_FragCoord。是屏幕空间的坐标，其x和y分量分别的范围是[0,screen_width]和[0,screenHeight]，其z分量是片元的真实非线性深度值，范围是[0,1]，可用于深度测试。此外，gl_FragCoord还可以用于技术演示，划分屏幕范围，特定的区域显示特定的颜色。如下例中屏幕左半部分显示红色，右半部分显示绿色。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4

5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21

22
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
23
float lastX = (float)SCR_WIDTH / 2.0f;
24
float lastY = (float)SCR_HEIGHT / 2.0f;
25
float deltaTime = 0.0f;
26
float lastFrame = 0.0f;
27
bool firstCamera = true;
28

29
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
30
        glViewport(0, 0, width, height);
31
}
32
void processInput(GLFWwindow* window) {
33
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
34
                glfwSetWindowShouldClose(window, true);
35
        }
36
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
37
                camera.ProcessKeyboard(FORWARD, deltaTime);
38
        }
39
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
40
                camera.ProcessKeyboard(BACKWARD, deltaTime);
41
        }
42
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
43
                camera.ProcessKeyboard(LEFT, deltaTime);
44
        }
45
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
46
                camera.ProcessKeyboard(RIGHT, deltaTime);
47
        }
48
}
49
void processMovement(GLFWwindow* window, double xpos, double ypos) {
50
        if (firstCamera) {
51
                lastX = xpos;
52
                lastY = ypos;
53
                firstCamera = false;
54
        }
55
        float xoffset = xpos - lastX;
56
        float yoffset = lastY - ypos;
57
        lastX = xpos;
58
        lastY = ypos;
59
        camera.ProcessMouseMovement(xoffset, yoffset);
60
}
61
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
62
        camera.ProcessScroll(yoffset);
63
}
64
unsigned int loadTexture(const char* path) {
65
        unsigned int texture;
66
        glGenTextures(1, &texture);
67
        glBindTexture(GL_TEXTURE_2D, texture);
68

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "Failed to load texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        //stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147
        glEnable(GL_PROGRAM_POINT_SIZE);
148

149
        float vertices[] = {
150
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
156

157
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
158
                 0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
159
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
160
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
161
                -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
162
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
163

164
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
165
                -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
166
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
167
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
168
                -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
169
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
170

171
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
172
                 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
173
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
174
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
175
                 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
176
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
177

178
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
179
                 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
180
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
181
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
182
                -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
183
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
184

185
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
186
                 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
187
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
188
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
189
                -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
190
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
191
        };
192

193

194
        unsigned int cubeVAO, cubeVBO;
195
        glGenVertexArrays(1, &cubeVAO);
196
        glGenBuffers(1, &cubeVBO);
197

198
        glBindVertexArray(cubeVAO);
199
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
200
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
201
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
202
        glEnableVertexAttribArray(0);
203
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
204
        glEnableVertexAttribArray(1);
205

206
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
207

208
        while (!glfwWindowShouldClose(window)) {
209
                float currentFrame = (float)glfwGetTime();
210
                deltaTime = currentFrame - lastFrame;
211
                lastFrame = currentFrame;
212

213
                processInput(window);
214

215
                glClearColor(0.1, 0.1, 0.1, 1.0);
216
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
217

218
                shader.use();
219
                glm::mat4 view = camera.GetCameraView();
220
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom),(float)SCR_WIDTH / SCR_HEIGHT, 0.1f, 100.0f);
221
                glm::mat4 model = glm::mat4(1.0f);
222
                shader.setMatrix("model", model);
223
                shader.setMatrix("view", view);
224
                shader.setMatrix("project", project);
225

226
                glBindVertexArray(cubeVAO);
227
                glDrawArrays(GL_TRIANGLES, 0, 36);
228
                glBindVertexArray(0);
229

230
                glfwSwapBuffers(window);
231
                glfwPollEvents();
232
        }
233
        glDeleteVertexArrays(1, &cubeVAO);
234
        glDeleteBuffers(1, &cubeVBO);
235

236
        glfwTerminate();
237
        return 0;
238
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 1) in vec3 aNormal;
5

6
uniform mat4 model;
7
uniform mat4 view;
8
uniform mat4 project;
9

10
void main(){
11
        gl_Position=project*view*model*vec4(aPos,1.0);
12
}

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4

5
void main(){
6
        if(gl_FragCoord.x<400){
7
                FragColor=vec4(1.0,0.0,0.0,1.0);
8
        }else{
9
                FragColor=vec4(0.0,1.0,0.0,1.0);
10
        }
11
}

BQACAgUAAyEGAASHRsPbAAEWLQtqP4Mw5v3gD5CELTQjiDYifmXBuAACnSYAAk05AVbfrSuC5hL1yzwE.png BQACAgUAAyEGAASHRsPbAAEWLQxqP4NDai-DTuzSnq4pxvMHw3FvlAACoCYAAk05AVY3teIbRqO_DTwE.png BQACAgUAAyEGAASHRsPbAAEWLQ5qP4NS-yJ442_q1rSABODaO1DsLAACoyYAAk05AVaB3CvzNBywijwE.png 还可以用于测试不同的光照模型：下例中左半部分采用phong光照模型（反射向量和视角方向接近度），右半部分采用blinn-phong光照模型（半角向量和法向量接近度），观察高光部分的不同。可以看到blinn-phong光照模型下高光形状更自然。

1
//fragmentShader
2
#version 330 core
3
in vec3 FragPos;
4
in vec3 Normal;
5

6
out vec4 FragColor;
7

8
uniform vec3 lightPos;
9
uniform vec3 viewPos;
10
void main(){
11
        vec2 uv=gl_FragCoord.xy/vec2(800,400);
12
        vec3 worldNormal=normalize(Normal);
13
        vec3 worldLightDir=normalize(lightPos-FragPos);
14
        vec3 worldViewDir=normalize(viewPos-FragPos);
15

16
        float diff=max(dot(worldNormal,worldLightDir),0.0);
17
        vec3 lightDiffuse=vec3(0.8f);
18
        vec3 diffuseColor=vec3(0.1,0.6,0.2);
19
        vec3 diffuse=lightDiffuse*diff*diffuseColor;
20

21
        vec3 lightAmbient=vec3(0.1f);
22
        vec3 ambient=lightAmbient*diffuseColor;
23

24
        float spec=0.0f;
25
        if(gl_FragCoord.x<400){
26
                vec3 reflectDir=reflect(-worldLightDir,worldNormal);
27
                spec=pow(max(dot(worldViewDir,reflectDir),0.0f),32.0f);
28
        }else{
29
                vec3 halfDir=normalize(worldLightDir+worldViewDir);
30
                spec=pow(max(dot(worldNormal,halfDir),0.0f),32.0f);
31
        }
32
        vec3 lightSpecular=vec3(1.0f);
33
        vec3 specular=lightSpecular*spec*vec3(1.0f);
34

35
        FragColor=vec4(ambient+diffuse+specular,1.0);
36
}

BQACAgUAAyEGAASHRsPbAAEWLRFqP4OaW9fJ7As-HAME8N-HqyO1twACqiYAAk05AVZ4Bd1YiQYMxTwE.png BQACAgUAAyEGAASHRsPbAAEWLRNqP4OxG_GZ2ZLay9z6hIq4PLYclgACrSYAAk05AVaAduZzCa5oJTwE.png 片元着色器的输入变量gl_FrontFacing，返回一个bool类型的值，反应当前片元是正面面的一部分，还是背面面的一部分。仅在不开启面剔除时使用，因为开启面剔除之后，有一类面（正向面/背向面）总是会被剔除，那么gl_FrontFacing总是返回true/false，没有使用的意义了。下例中为模型的正向面和背向面分别赋予不同的纹理。编写代码时一定要注意关闭面剔除，以及顶点的定义需要遵循背向面顺时针，正向面逆时针（或者反过来，关键是要全部背面统一，全部正面统一）

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4

5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21

22
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
23
float lastX = (float)SCR_WIDTH / 2.0f;
24
float lastY = (float)SCR_HEIGHT / 2.0f;
25
float deltaTime = 0.0f;
26
float lastFrame = 0.0f;
27
bool firstCamera = true;
28

29
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
30
        glViewport(0, 0, width, height);
31
}
32
void processInput(GLFWwindow* window) {
33
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
34
                glfwSetWindowShouldClose(window, true);
35
        }
36
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
37
                camera.ProcessKeyboard(FORWARD, deltaTime);
38
        }
39
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
40
                camera.ProcessKeyboard(BACKWARD, deltaTime);
41
        }
42
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
43
                camera.ProcessKeyboard(LEFT, deltaTime);
44
        }
45
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
46
                camera.ProcessKeyboard(RIGHT, deltaTime);
47
        }
48
}
49
void processMovement(GLFWwindow* window, double xpos, double ypos) {
50
        if (firstCamera) {
51
                lastX = xpos;
52
                lastY = ypos;
53
                firstCamera = false;
54
        }
55
        float xoffset = xpos - lastX;
56
        float yoffset = lastY - ypos;
57
        lastX = xpos;
58
        lastY = ypos;
59
        camera.ProcessMouseMovement(xoffset, yoffset);
60
}
61
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
62
        camera.ProcessScroll(yoffset);
63
}
64
unsigned int loadTexture(const char* path) {
65
        unsigned int texture;
66
        glGenTextures(1, &texture);
67
        glBindTexture(GL_TEXTURE_2D, texture);
68

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "Failed to load texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147
        glDisable(GL_CULL_FACE);
148

149
        float vertices[] = {
150
                // Back face
151
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f, // Bottom-left
152
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f, // top-right
153
                 0.5f, -0.5f, -0.5f,  1.0f, 0.0f, // bottom-right
154
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f, // top-right
155
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f, // bottom-left
156
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, // top-left
157
                // Front face
158
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, // bottom-left
159
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f, // bottom-right
160
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f, // top-right
161
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f, // top-right
162
                -0.5f,  0.5f,  0.5f,  0.0f, 1.0f, // top-left
163
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, // bottom-left
164
                // Left face
165
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // top-right
166
                -0.5f,  0.5f, -0.5f,  1.0f, 1.0f, // top-left
167
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // bottom-left
168
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // bottom-left
169
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, // bottom-right
170
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // top-right
171
                // Right face
172
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // top-left
173
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // bottom-right
174
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f, // top-right
175
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // bottom-right
176
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // top-left
177
                 0.5f, -0.5f,  0.5f,  0.0f, 0.0f, // bottom-left
178
                 // Bottom face
179
                 -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // top-right
180
                  0.5f, -0.5f, -0.5f,  1.0f, 1.0f, // top-left
181
                  0.5f, -0.5f,  0.5f,  1.0f, 0.0f, // bottom-left
182
                  0.5f, -0.5f,  0.5f,  1.0f, 0.0f, // bottom-left
183
                 -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, // bottom-right
184
                 -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, // top-right
185
                 // Top face
186
                 -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, // top-left
187
                  0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // bottom-right
188
                  0.5f,  0.5f, -0.5f,  1.0f, 1.0f, // top-right
189
                  0.5f,  0.5f,  0.5f,  1.0f, 0.0f, // bottom-right
190
                 -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, // top-left
191
                 -0.5f,  0.5f,  0.5f,  0.0f, 0.0f  // bottom-left
192
        };
193

194
        unsigned int cubeVAO, cubeVBO;
195
        glGenVertexArrays(1, &cubeVAO);
196
        glGenBuffers(1, &cubeVBO);
197

198
        glBindVertexArray(cubeVAO);
199
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
200
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
201
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
202
        glEnableVertexAttribArray(0);
203
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
204
        glEnableVertexAttribArray(1);
205

206
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
207

208
        unsigned int frontTexture = loadTexture("resources/textures/container.jpg");
209
        unsigned int backTexture = loadTexture("resources/textures/marble.jpg");
210

211
        shader.use();
212
        shader.setInt("frontTexture", 0);
213
        shader.setInt("backTexture", 1);
214

215
        while (!glfwWindowShouldClose(window)) {
216
                float currentFrame = (float)glfwGetTime();
217
                deltaTime = currentFrame - lastFrame;
218
                lastFrame = currentFrame;
219

220
                processInput(window);
221

222
                glClearColor(0.1, 0.1, 0.1, 1.0);
223
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
224

225
                shader.use();
226
                glm::mat4 view = camera.GetCameraView();
227
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom),(float)SCR_WIDTH / SCR_HEIGHT, 0.1f, 100.0f);
228
                glm::mat4 model = glm::mat4(1.0f);
229
                shader.setMatrix("model", model);
230
                shader.setMatrix("view", view);
231
                shader.setMatrix("project", project);
232

233
                glActiveTexture(GL_TEXTURE0);
234
                glBindTexture(GL_TEXTURE_2D, frontTexture);
235
                glActiveTexture(GL_TEXTURE1);
236
                glBindTexture(GL_TEXTURE_2D, backTexture);
237

238
                glBindVertexArray(cubeVAO);
239
                glDrawArrays(GL_TRIANGLES, 0, 36);
240
                glBindVertexArray(0);
241

242
                glfwSwapBuffers(window);
243
                glfwPollEvents();
244
        }
245
        glDeleteVertexArrays(1, &cubeVAO);
246
        glDeleteBuffers(1, &cubeVBO);
247

248
        glfwTerminate();
249
        return 0;
250
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 1) in vec2 aTexCoords;
5

6
out vec2 TexCoords;
7

8
uniform mat4 model;
9
uniform mat4 view;
10
uniform mat4 project;
11

12
void main(){
13
        gl_Position=project*view*model*vec4(aPos,1.0);
14
        TexCoords=aTexCoords;
15
}

1
//fragmentShader
2
#version 330 core
3

4
in vec2 TexCoords;
5
out vec4 FragColor;
6

7
uniform sampler2D frontTexture;
8
uniform sampler2D backTexture;
9

10
void main(){
11
        if(gl_FrontFacing){
12
                FragColor=texture(frontTexture,TexCoords);
13
        }else{
14
                FragColor=texture(backTexture,TexCoords);
15
        }
16
}

BQACAgUAAyEGAASHRsPbAAEWLR5qP4QDBjPo2okk5LolD1_O5-H5IgACuSYAAk05AVb5jbNk-OmTHzwE.png gl_FragCoord还可以用于实现双面材质的物体、双面光照，以及描边轮廓（检测到背面，输出纯色描边）。此外，默认是剔除背面，也可以通过glCullFace设置要剔除的面。片元着色器的输出变量gl_FragDepth，默认值等于gl_FragCoord.z，但是gl_FragCoord作为一个输入变量，它是只读的，所以如果我们要修改片元深度，就只能使用gl_FragDepth。但之前说过，如果要在片元着色器修改深度，那么early-z就禁用了，因为early-z时并不知道当前片元是否会被剔除，无法预知修改后的片元深度。但是opengl4.2版本以上给我们提供了有条件的修改。

1
//fragmentShader
2
//片元着色器中修改后的深度只能比原始深度（即gl_FragCoord.z大）
3
//这种情况下，如果原始深度>缓冲深度，那么修改后的深度必定也>缓冲深度，一定可以被early-z剔除
4
layout (depth_greater) out float gl_FragDepth;
5
//片元着色器中修改后的深度只能比原始深度小
6
//这种情况下，如果原始深度<缓冲深度，那么修改后的深度必定也<缓冲深度，一定可以被early-z保留
7
layout (depth_less) out float gl_FragDepth;
8
//片元着色器中修改后的深度和原始深度关系未知，可大可小
9
layout (depth_any) out float gl_FragDepth;
10
//片元着色器中未对深度进行修改
11
layout (depth_unchanged) out float gl_FragDepth;

example2: 接口块#

**使用接口块的原因：使代码模块化，**当传递的变量很少时，零散in/out无所谓，但当渲染管线复杂时，可能有十几二十个变量，接口块可以把所有传递数据收拢到一个结构体，语义清晰。

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 1) in vec2 aTexCoords;
5

6
out VS_OUT{
7
        vec2 TexCoords;
8
}vs_out;
9

10
uniform mat4 model;
11
uniform mat4 view;
12
uniform mat4 project;
13

14
void main(){
15
        gl_Position=project*view*model*vec4(aPos,1.0);
16
        vs_out.TexCoords=aTexCoords;
17
}

1
//fragmentShader
2
#version 330 core
3

4
in VS_OUT{
5
        vec2 TexCoords;
6
}fs_in;
7
out vec4 FragColor;
8

9
uniform sampler2D frontTexture;
10
uniform sampler2D backTexture;
11

12
void main(){
13
        if(gl_FrontFacing){
14
                FragColor=texture(frontTexture,fs_in.TexCoords);
15
        }else{
16
                FragColor=texture(backTexture,fs_in.TexCoords);
17
        }
18
}

example3: uniform缓冲#

使用多个着色器绘制不同的模型，但所有着色器共享一套matrices uniform结构块，对其中的变量view和project矩阵只需赋值一次，体现UBO跨着色器共享uniform的价值。 **首先是创建UBO缓冲，**与创建VBO的步骤类似。在使用glBufferData开辟缓冲占据内存时，开辟的大小由缓冲内所有uniform块的内存决定，而uniform块的内存由它要存储的变量决定，本例中只有一个uniform块，且uniform块内只是两个mat矩阵。 然后是将创建的UBO缓冲绑定到绑定点。 然后使用glBufferSubData写入数据，需要知道数据的起始偏移位置和数据的大小。 然后创建若干个着色器程序，分别将其中的uniform块绑定到与UBO一样的绑定点。最后在渲染循环中分别激活这些着色器程序，设置变化的变量或私有的变量，绘制。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4

5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21

22
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
23
float lastX = (float)SCR_WIDTH / 2.0f;
24
float lastY = (float)SCR_HEIGHT / 2.0f;
25
float deltaTime = 0.0f;
26
float lastFrame = 0.0f;
27
bool firstCamera = true;
28

29
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
30
        glViewport(0, 0, width, height);
31
}
32
void processInput(GLFWwindow* window) {
33
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
34
                glfwSetWindowShouldClose(window, true);
35
        }
36
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
37
                camera.ProcessKeyboard(FORWARD, deltaTime);
38
        }
39
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
40
                camera.ProcessKeyboard(BACKWARD, deltaTime);
41
        }
42
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
43
                camera.ProcessKeyboard(LEFT, deltaTime);
44
        }
45
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
46
                camera.ProcessKeyboard(RIGHT, deltaTime);
47
        }
48
}
49
void processMovement(GLFWwindow* window, double xpos, double ypos) {
50
        if (firstCamera) {
51
                lastX = xpos;
52
                lastY = ypos;
53
                firstCamera = false;
54
        }
55
        float xoffset = xpos - lastX;
56
        float yoffset = lastY - ypos;
57
        lastX = xpos;
58
        lastY = ypos;
59
        camera.ProcessMouseMovement(xoffset, yoffset);
60
}
61
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
62
        camera.ProcessScroll(yoffset);
63
}
64
unsigned int loadTexture(const char* path) {
65
        unsigned int texture;
66
        glGenTextures(1, &texture);
67
        glBindTexture(GL_TEXTURE_2D, texture);
68

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "Failed to load texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        //stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147

148
        float vertices[] = {
149
                // positions
150
                -0.5f, -0.5f, -0.5f,
151
                 0.5f, -0.5f, -0.5f,
152
                 0.5f,  0.5f, -0.5f,
153
                 0.5f,  0.5f, -0.5f,
154
                -0.5f,  0.5f, -0.5f,
155
                -0.5f, -0.5f, -0.5f,
156

157
                -0.5f, -0.5f,  0.5f,
158
                 0.5f, -0.5f,  0.5f,
159
                 0.5f,  0.5f,  0.5f,
160
                 0.5f,  0.5f,  0.5f,
161
                -0.5f,  0.5f,  0.5f,
162
                -0.5f, -0.5f,  0.5f,
163

164
                -0.5f,  0.5f,  0.5f,
165
                -0.5f,  0.5f, -0.5f,
166
                -0.5f, -0.5f, -0.5f,
167
                -0.5f, -0.5f, -0.5f,
168
                -0.5f, -0.5f,  0.5f,
169
                -0.5f,  0.5f,  0.5f,
170

171
                 0.5f,  0.5f,  0.5f,
172
                 0.5f,  0.5f, -0.5f,
173
                 0.5f, -0.5f, -0.5f,
174
                 0.5f, -0.5f, -0.5f,
175
                 0.5f, -0.5f,  0.5f,
176
                 0.5f,  0.5f,  0.5f,
177

178
                -0.5f, -0.5f, -0.5f,
179
                 0.5f, -0.5f, -0.5f,
180
                 0.5f, -0.5f,  0.5f,
181
                 0.5f, -0.5f,  0.5f,
182
                -0.5f, -0.5f,  0.5f,
183
                -0.5f, -0.5f, -0.5f,
184

185
                -0.5f,  0.5f, -0.5f,
186
                 0.5f,  0.5f, -0.5f,
187
                 0.5f,  0.5f,  0.5f,
188
                 0.5f,  0.5f,  0.5f,
189
                -0.5f,  0.5f,  0.5f,
190
                -0.5f,  0.5f, -0.5f,
191
        };
192

193
        unsigned int cubeVAO, cubeVBO;
194
        glGenVertexArrays(1, &cubeVAO);
195
        glGenBuffers(1, &cubeVBO);
196

197
        glBindVertexArray(cubeVAO);
198
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
199
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
200
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
201
        glEnableVertexAttribArray(0);
202
        glBindVertexArray(0);
203
        glBindBuffer(GL_ARRAY_BUFFER, 0);
204

205
        //创建uniform缓冲对象
206
        unsigned int uboMatrices;
207
        glGenBuffers(1, &uboMatrices);
208
        glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
209
        glBufferData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), NULL, GL_STATIC_DRAW);
210
        glBindBuffer(GL_UNIFORM_BUFFER, 0);
211

212
        //关联缓冲对象到绑定点
213
        glBindBufferRange(GL_UNIFORM_BUFFER, 0, uboMatrices, 0, 2 * sizeof(glm::mat4));
214

215
        //填充缓冲对象
216
        //先填充渲染过程中不会变的成员变量
217
        glm::mat4 project = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);//相机没有缩放了，固定fov为45度
218
        glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
219
        glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(project));//为什么需要value_ptr？glm::mat4是C++类/结构体，而glBufferSubData等OpenGL API只接收原生指针，value_ptr会返回矩阵内部底层float数组首地址
220
        glBindBuffer(GL_UNIFORM_BUFFER, 0);
221

222
        Shader shader1("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
223
        Shader shader2("src/Shader/vertexShader.txt", "src/Shader/fragmentShader2.txt");
224
        Shader shader3("src/Shader/vertexShader.txt", "src/Shader/fragmentShader3.txt");
225
        Shader shader4("src/Shader/vertexShader.txt", "src/Shader/fragmentShader4.txt");
226

227
        //为顶点着色器中的uniform块关联绑定点
228
        //获得uniform块的位置值
229
        unsigned int uniformBlockIndexRed = glGetUniformBlockIndex(shader1.ID, "Matrices");
230
        unsigned int uniformBlockIndexGreen = glGetUniformBlockIndex(shader2.ID, "Matrices");
231
        unsigned int uniformBlockIndexBlue = glGetUniformBlockIndex(shader3.ID, "Matrices");
232
        unsigned int uniformBlockIndexYellow = glGetUniformBlockIndex(shader4.ID, "Matrices");
233
        //关联绑定点
234
        glUniformBlockBinding(shader1.ID, uniformBlockIndexRed, 0);
235
        glUniformBlockBinding(shader2.ID, uniformBlockIndexGreen, 0);
236
        glUniformBlockBinding(shader3.ID, uniformBlockIndexBlue, 0);
237
        glUniformBlockBinding(shader4.ID, uniformBlockIndexYellow, 0);
238

239
        while (!glfwWindowShouldClose(window)) {
240
                float currentFrame = (float)glfwGetTime();
241
                deltaTime = currentFrame - lastFrame;
242
                lastFrame = currentFrame;
243

244
                processInput(window);
245

246
                glClearColor(0.1, 0.1, 0.1, 1.0);
247
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
248

249
                glm::mat4 view = camera.GetCameraView();
250
                glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
251
                glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));
252
                glBindBuffer(GL_UNIFORM_BUFFER, 0);
253

254
                glBindVertexArray(cubeVAO);
255
                shader1.use();
256
                glm::mat4 model;
257
                model = glm::translate(model, glm::vec3(-0.75f, 0.75f, 0.0f));
258
                shader1.setMatrix("model", model);
259
                glDrawArrays(GL_TRIANGLES, 0, 36);
260

261
                shader2.use();
262
                model = glm::mat4(1.0f);
263
                model = glm::translate(model, glm::vec3(0.75f, 0.75f, 0.0f));
264
                shader2.setMatrix("model", model);
265
                glDrawArrays(GL_TRIANGLES, 0, 36);
266

267
                shader3.use();
268
                model = glm::mat4(1.0f);
269
                model = glm::translate(model, glm::vec3(-0.75f, -0.75f, 0.0f));
270
                shader3.setMatrix("model", model);
271
                glDrawArrays(GL_TRIANGLES, 0, 36);
272

273
                shader4.use();
274
                model = glm::mat4(1.0f);
275
                model = glm::translate(model, glm::vec3(0.75f, -0.75f, 0.0f));
276
                shader4.setMatrix("model", model);
277
                glDrawArrays(GL_TRIANGLES, 0, 36);
278

279
                glBindVertexArray(0);
280

281
                glfwSwapBuffers(window);
282
                glfwPollEvents();
283
        }
284
        glDeleteVertexArrays(1, &cubeVAO);
285
        glDeleteBuffers(1, &cubeVBO);
286

287
        glfwTerminate();
288
        return 0;
289
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (std140) uniform Matrices{
5
        mat4 project;
6
        mat4 view;
7
};
8

9
uniform mat4 model;
10

11
void main(){
12
        gl_Position=project*view*model*vec4(aPos,1.0);
13
}

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4

5
void main(){
6
        FragColor=vec4(1.0,0.0,0.0,1.0);
7
}

1
//fragmentShader2
2
#version 330 core
3
out vec4 FragColor;
4

5
void main(){
6
        FragColor=vec4(0.0,1.0,0.0,1.0);
7
}

1
//fragmentShader3
2
#version 330 core
3
out vec4 FragColor;
4

5
void main(){
6
        FragColor=vec4(0.0,0.0,1.0,1.0);
7
}

1
//fragmentShader4
2
#version 330 core
3
out vec4 FragColor;
4

5
void main(){
6
        FragColor=vec4(1.0,1.0,0.0,1.0);
7
}

BQACAgUAAyEGAASHRsPbAAEWLTFqP4VIpFRG3XBLxUrb4tKgvbDfAAPPJgACTTkBVueYdq8u36mRPAQ.png