片元丢弃 discard#

在片元着色器中，可使用 discard 指令进行条件片元剔除：满足自定义条件时，直接丢弃当前正在处理的片元，该片元不会进入后续测试、混合与写入流程，常用于镂空贴图、不规则透明裁剪效果。

颜色混合（Blend）执行时机#

颜色混合是渲染管线最后阶段之一，执行顺序严格为： 片元着色器执行 → 模板测试、深度测试全部完成 → 颜色混合 只有通过所有测试的片元，才会参与颜色混合运算，最终写入颜色缓冲。

混合原理#

源颜色（Source Color）：当前片元着色器输出、纹理采样得到的新颜色
目标颜色（Destination Color）：当前像素在颜色缓冲中已经存在的旧颜色混合方程用于定义：源颜色与目标颜色如何加权叠加。其中源、目标颜色由 OpenGL 自动赋值，开发者可手动配置混合因子控制混合权重。

混合因子配置函数#

glBlendFunc#

统一设置 RGB 通道与 Alpha 通道混合规则：RGB、Alpha 通道共用同一套源因子、目标因子。参数：glBlendFunc(源因子, 目标因子)

glBlendFuncSeparate#

分离通道设置，RGB 通道与 Alpha 通道可以使用不同混合因子，灵活度更高。参数顺序：

源颜色 RGB 混合因子
目标颜色 RGB 混合因子
源颜色 Alpha 混合因子
目标颜色 Alpha 混合因子

混合运算方程设置#

glBlendEquation() 用于设置源颜色与目标颜色的运算方式，默认模式为相加，也可配置相减、取最值等运算规则。

次序无关透明度（OIT）#

传统透明渲染的问题#

传统透明渲染需要 CPU 将透明物体由远至近排序，存在诸多无法解决的问题：

模型、面片数量庞大时，CPU 排序开销极高、帧率下降
物体交叉、互相穿透时，不存在全局正确的渲染顺序
动态场景每帧物体位置变化，需要每帧重新排序，开销巨大

OIT 核心思想#

将透明排序逻辑从 CPU 转移至 GPU：GPU 每帧收集单个像素上所有覆盖的透明片元，自动排序、混合，彻底摆脱手动排序依赖。

精确 OIT 方案#

深度剥离：根据片元距相机距离分层，每次仅渲染当前最近一层透明片元，从前往后逐层混合，结果精准，但需要多 Pass 渲染。
逐像素链表：单次渲染遍历，为每个像素开辟链表存储所有透明片元数据，渲染结束后统一遍历链表排序、混合，精度最高。

近似 OIT 方案#

不存储全部透明片元数据，仅累积带权重的颜色与透明度。权重规则：近处物体、不透明区域权重更大，对最终颜色贡献更强。仅需单次 Pass 即可完成透明渲染，性能极高，属于近似拟合方案。

example1: 透明度测试#

实现简易版草丛：将带有透明度通道的草纹理贴在四边形面片上；在着色器中判断当前片元的透明度，如果透明度低于某个值就将其丢弃。 在实现上：我们首先定义了一个四边形面片的六个顶点位置坐标以及纹理坐标，然后定义了面片的位置。设定VAO与VBO，传递数据，然后在渲染循环中绘制。在片元着色器中，读取当前纹理颜色的alpha值，如果小于0.1（不是-==0，浮点数比较有精度问题），则使用discard命令丢弃这个片元。

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

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

10
#include <myShader.h>
11
#include <myCamera.h>
12
#include <Model.h>
13

14
#include <iostream>
15

16
const unsigned int SCR_WIDTH = 800;
17
const unsigned int SCR_HEIGHT = 400;
18

19
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
20
float lastX = (float)SCR_WIDTH / 2.0;
21
float lastY = (float)SCR_HEIGHT / 2.0;
22
bool firstCamera = true;
23

24
float deltaTime = 0.0f;
25
float lastFrame = 0.0f;
26

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

66
    int width, height, nrChannels;
67
    unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
68
    if (data) {
69
        GLenum format;
70
        if (nrChannels == 1) {
71
            format = GL_RED;
72
        }
73
        else if (nrChannels == 3) {
74
            format = GL_RGB;
75
        }
76
        else if (nrChannels == 4) {
77
            format = GL_RGBA;
78
        }
79
        glBindTexture(GL_TEXTURE_2D, texture);
80

81
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
82
        glGenerateMipmap(GL_TEXTURE_2D);
83

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 tetxure" << endl;
91
    }
92
    stbi_image_free(data);
93

94
    return texture;
95
}
96
int main() {
97
    glfwInit();
98
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
99
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
100
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
101

102
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "learnOpenGL", NULL, NULL);
103

104
    if (window == NULL) {
105
        cout << "failed to create GLFW window" << endl;
106
        glfwTerminate();
107
        return -1;
108
    }
109

110
    glfwMakeContextCurrent(window);
111
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
112
    glfwSetCursorPosCallback(window, processMovement);
113
    glfwSetScrollCallback(window, processScroll);
114

115
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
116

117
    if (!gladLoadGLLoader(GLADloadproc(glfwGetProcAddress))) {
118
        cout << "failed to initialize glad" << endl;
119
        glfwTerminate();
120
        return -1;
121
    }
122

123
    stbi_set_flip_vertically_on_load(true);
124

125
    glEnable(GL_DEPTH_TEST);
126
    glDepthFunc(GL_LESS);
127

128
    Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
129

130
    float cubeVertices[] = {
131
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
132
             0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
133
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
134
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
135
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
136
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
137

138
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
139
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
140
             0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
141
             0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
142
            -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
143
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
144

145
            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
146
            -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
147
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
148
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
149
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
150
            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
151

152
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
153
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
154
             0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
155
             0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
156
             0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
157
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
158

159
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
160
             0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
161
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
162
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
163
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
164
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
165

166
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
167
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
168
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
169
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
170
            -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
171
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
172
    };
173

174
    float planeVertices[] = {
175
            5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
176
            -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
177
            -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
178

179
             5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
180
            -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
181
             5.0f, -0.5f, -5.0f,  2.0f, 2.0f
182
    };
183

184
    float transparentVertices[] = {
185
        0.0f,  0.5f,  0.0f,  0.0f,  1.0f,//左上
186
        0.0f, -0.5f,  0.0f,  0.0f,  0.0f,//左下
187
        1.0f, -0.5f,  0.0f,  1.0f,  0.0f,//右下
188

189
        0.0f,  0.5f,  0.0f,  0.0f,  1.0f,//左上
190
        1.0f, -0.5f,  0.0f,  1.0f,  0.0f,//右下
191
        1.0f,  0.5f,  0.0f,  1.0f,  1.0f//右上
192
    };
193

194
    vector<glm::vec3> vegetation{
195
        glm::vec3(-1.5f, 0.0f, -0.48f),
196
        glm::vec3(1.5f, 0.0f, 0.51f),
197
        glm::vec3(0.0f, 0.0f, 0.7f),
198
        glm::vec3(-0.3f, 0.0f, -2.3f),
199
        glm::vec3(0.5f, 0.0f, -0.6f)
200
    };
201

202
    unsigned int cubeVAO, cubeVBO;
203
    glGenVertexArrays(1, &cubeVAO);
204
    glGenBuffers(1, &cubeVBO);
205

206
    glBindVertexArray(cubeVAO);
207
    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
208
    glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
209

210
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
211
    glEnableVertexAttribArray(0);
212

213
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
214
    glEnableVertexAttribArray(1);
215

216
    glBindVertexArray(0);
217

218
    unsigned int planeVAO, planeVBO;
219
    glGenVertexArrays(1, &planeVAO);
220
    glGenBuffers(1, &planeVBO);
221

222
    glBindVertexArray(planeVAO);
223
    glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
224
    glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
225

226
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
227
    glEnableVertexAttribArray(0);
228

229
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
230
    glEnableVertexAttribArray(1);
231

232
    glBindVertexArray(0);
233

234
    unsigned int transparentVAO, transparentVBO;
235
    glGenVertexArrays(1, &transparentVAO);
236
    glGenBuffers(1, &transparentVBO);
237

238
    glBindVertexArray(transparentVAO);
239
    glBindBuffer(GL_ARRAY_BUFFER, transparentVBO);
240

241
    glBufferData(GL_ARRAY_BUFFER, sizeof(transparentVertices), transparentVertices, GL_STATIC_DRAW);
242

243
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
244
    glEnableVertexAttribArray(0);
245
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
246
    glEnableVertexAttribArray(1);
247

248
    glBindVertexArray(0);
249

250
    unsigned int cubeTexture = loadTexture("resources/textures/marble.jpg");
251
    unsigned int floorTexture = loadTexture("resources/textures/metal.jpg");
252
    unsigned int grassTexture = loadTexture("resources/textures/grass.png");
253

254
    shader.use();
255
    shader.setInt("texture1", 0);
256
    shader.setInt("texture2", 1);
257
    shader.setInt("texture3", 2);
258

259
    while (!glfwWindowShouldClose(window)) {
260
        float currentFrame = (float)glfwGetTime();
261
        deltaTime = currentFrame - lastFrame;
262
        lastFrame = currentFrame;
263

264
        processInput(window);
265

266
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
267
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
268

269
        shader.use();
270
        glm::mat4 model = glm::mat4(1.0f);
271
        glm::mat4 view = camera.GetCameraView();
272
        glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
273
        shader.setMatrix("view", view);
274
        shader.setMatrix("project", project);
275

276
        glBindVertexArray(cubeVAO);
277
        glActiveTexture(GL_TEXTURE0);
278
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
279
        shader.setInt("useTex", 1);
280
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
281
        shader.setMatrix("model", model);
282
        glDrawArrays(GL_TRIANGLES, 0, 36);
283

284
        model = glm::mat4(1.0f);
285
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
286
        shader.setMatrix("model", model);
287
        glDrawArrays(GL_TRIANGLES, 0, 36);
288

289
        glBindVertexArray(0);
290

291
        glBindVertexArray(planeVAO);
292
        glActiveTexture(GL_TEXTURE1);
293
        glBindTexture(GL_TEXTURE_2D, floorTexture);
294
        shader.setInt("useTex", 2);
295
        shader.setMatrix("model", glm::mat4(1.0f));
296
        glDrawArrays(GL_TRIANGLES, 0, 6);
297
        glBindVertexArray(0);
298

299
        glBindVertexArray(transparentVAO);
300
        glActiveTexture(GL_TEXTURE2);
301
        glBindTexture(GL_TEXTURE_2D, grassTexture);
302
        shader.setInt("useTex", 3);
303
        for (int i = 0; i < vegetation.size(); i++) {
304
            model = glm::mat4(1.0f);
305
            model = glm::translate(model, vegetation[i]);
306
            shader.setMatrix("model", model);
307
            shader.setMatrix("view", view);
308
            shader.setMatrix("project", project);
309
            glDrawArrays(GL_TRIANGLES, 0, 6);
310
        }
311
        glBindVertexArray(0);
312

313
        glfwSwapBuffers(window);
314
        glfwPollEvents();
315
    }
316
    glDeleteVertexArrays(1, &cubeVAO);
317
    glDeleteVertexArrays(1, &planeVAO);
318
    glDeleteBuffers(1, &cubeVBO);
319
    glDeleteBuffers(1, &planeVBO);
320

321
    glfwTerminate();
322
    return 0;
323
}

1
//fragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D texture1;
6
uniform sampler2D texture2;
7
uniform sampler2D texture3;
8

9
uniform int useTex;
10
void main(){
11
    vec4 texColor;
12
        if(useTex==1){
13
        texColor=texture(texture1,TexCoords);
14
    }else if(useTex==2){
15
        texColor=texture(texture2,TexCoords);
16
    }else if(useTex==3){
17
        texColor=texture(texture3,TexCoords);
18
    }
19
    if(texColor.a<0.1){
20
        discard;
21
    }
22
    FragColor=texColor;
23
}

BQACAgUAAyEGAASHRsPbAAEWK1FqP2x--a1FzSNttvBXIic8GHvbjQACqCQAAk05AVaXd1k6KExjBjwE.png 可以发现纹理顶部也出现了一些颜色，而这些区域原本应该完全透明。这是因为纹理的环绕模式（wrap mode）设置为GL_REPEAT，这会在纹理边缘，混合另一边的像素颜色，这不是我们想要的。所以需要为透明度纹理设置环绕模式为GL_CLAMP_TO_EDGE。 BQACAgUAAyEGAASHRsPbAAEWK1JqP2yr6GxjfbxtTJ3Wnwv4BFJHSgACqSQAAk05AVbx3R6srDpaKTwE.png

example2: 透明度混合#

使用一张半透明的纹理替换上边的草纹理，并开启透明度混合，设置混合函数（源因子和目标因子）。在片元着色器中，不再需要丢弃片元，直接输出采样到的纹理颜色，之后GPU会自动帮我们混合，然后输出。 BQACAgUAAyEGAASHRsPbAAEWK1NqP2zONOWOwk-UxZIHVaFw87O5FgACqiQAAk05AVazV7_zAVwUczwE.png BQACAgUAAyEGAASHRsPbAAEWK1RqP2zkTaxuhO7U2wVm5bn5jA6SsAACqyQAAk05AVYYzjx5Ox-CgTwE.png 你会发现，前边的窗户部分遮挡了后边的窗户，由于窗户是透明度，所以这不太对。这是因为写入深度缓冲时，透明片元和不透明片元会一同处理，一同写入深度缓冲，那么也会正常进行深度测试，前边的遮挡后边的。所以在渲染透明物体时，深度缓冲并不能起到很好的作用，甚至有些干扰了渲染。所以我们需要手动的、固定按照从后往前的顺序渲染这些透明物体，后面渲染的物体（视角上更靠前）会与前面渲染的物体（视角上更靠后）混合。而对于透明度测试，我们只是简单的丢弃片元，深度测试不会对它造成影响。 从后往前渲染的实现是：首先定义物体的远近关系，判断依据是物体到观察者（即摄像机）的距离，这可以通过计算物体指向摄像机的向量的长度得到；然后是对这些距离进行排序，可以借助map，它能够自动根据key的大小，把容器内的value按key从小到大的顺序排序，那么本案例中，key就是物体到摄像机的距离，value就是物体的位置；接着是从远到近的绘制，在渲染循环中，由于map是从小（近）到大（远）的排序，所以需要逆向遍历map，可以借助map的逆向迭代器reverse_iterator实现。

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

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

10
#include <myShader.h>
11
#include <myCamera.h>
12
#include <Model.h>
13

14
#include <iostream>
15

16
const unsigned int SCR_WIDTH = 800;
17
const unsigned int SCR_HEIGHT = 400;
18

19
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
20
float lastX = (float)SCR_WIDTH / 2.0;
21
float lastY = (float)SCR_HEIGHT / 2.0;
22
bool firstCamera = true;
23

24
float deltaTime = 0.0f;
25
float lastFrame = 0.0f;
26

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

66
    int width, height, nrChannels;
67
    unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
68
    if (data) {
69
        GLenum format;
70
        if (nrChannels == 1) {
71
            format = GL_RED;
72
        }
73
        else if (nrChannels == 3) {
74
            format = GL_RGB;
75
        }
76
        else if (nrChannels == 4) {
77
            format = GL_RGBA;
78
        }
79
        glBindTexture(GL_TEXTURE_2D, texture);
80

81
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
82
        glGenerateMipmap(GL_TEXTURE_2D);
83

84
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
85
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
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 tetxure" << endl;
91
    }
92
    stbi_image_free(data);
93

94
    return texture;
95
}
96
int main() {
97
    glfwInit();
98
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
99
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
100
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
101

102
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "learnOpenGL", NULL, NULL);
103

104
    if (window == NULL) {
105
        cout << "failed to create GLFW window" << endl;
106
        glfwTerminate();
107
        return -1;
108
    }
109

110
    glfwMakeContextCurrent(window);
111
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
112
    glfwSetCursorPosCallback(window, processMovement);
113
    glfwSetScrollCallback(window, processScroll);
114

115
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
116

117
    if (!gladLoadGLLoader(GLADloadproc(glfwGetProcAddress))) {
118
        cout << "failed to initialize glad" << endl;
119
        glfwTerminate();
120
        return -1;
121
    }
122

123
    stbi_set_flip_vertically_on_load(true);
124

125
    glEnable(GL_DEPTH_TEST);
126
    glDepthFunc(GL_LESS);
127
    glEnable(GL_BLEND);
128
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
129

130
    Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
131

132
    float cubeVertices[] = {
133
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
134
             0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
135
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
136
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
137
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
138
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
139

140
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
141
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
142
             0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
143
             0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
144
            -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
145
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
146

147
            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
148
            -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
149
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
150
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
151
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
152
            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
153

154
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
155
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
156
             0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
157
             0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
158
             0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
159
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
160

161
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
162
             0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
163
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
164
             0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
165
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
166
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
167

168
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
169
             0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
170
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
171
             0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
172
            -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
173
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
174
    };
175

176
    float planeVertices[] = {
177
            5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
178
            -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
179
            -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
180

181
             5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
182
            -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
183
             5.0f, -0.5f, -5.0f,  2.0f, 2.0f
184
    };
185

186
    float transparentVertices[] = {
187
        0.0f,  0.5f,  0.0f,  0.0f,  1.0f,//左上
188
        0.0f, -0.5f,  0.0f,  0.0f,  0.0f,//左下
189
        1.0f, -0.5f,  0.0f,  1.0f,  0.0f,//右下
190

191
        0.0f,  0.5f,  0.0f,  0.0f,  1.0f,//左上
192
        1.0f, -0.5f,  0.0f,  1.0f,  0.0f,//右下
193
        1.0f,  0.5f,  0.0f,  1.0f,  1.0f//右上
194
    };
195

196
    vector<glm::vec3> windowQuad{
197
        glm::vec3(-1.5f, 0.0f, -0.48f),
198
        glm::vec3(1.5f, 0.0f, 0.51f),
199
        glm::vec3(0.0f, 0.0f, 0.7f),
200
        glm::vec3(-0.3f, 0.0f, -2.3f),
201
        glm::vec3(0.5f, 0.0f, -0.6f)
202
    };
203

204
    map<float, glm::vec3> sorted;
205
    //map会自动根据键值即这里的float进行从小到大的排序，那么以distance作为key，从后往前取map中的value，就能得到从远到近的quad的位置
206
    for (int i = 0; i < windowQuad.size(); i++) {
207
        float distance = glm::length(camera.Position - windowQuad[i]);
208
        sorted[distance] = windowQuad[i];
209
    }
210

211
    unsigned int cubeVAO, cubeVBO;
212
    glGenVertexArrays(1, &cubeVAO);
213
    glGenBuffers(1, &cubeVBO);
214

215
    glBindVertexArray(cubeVAO);
216
    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
217
    glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
218

219
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
220
    glEnableVertexAttribArray(0);
221

222
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
223
    glEnableVertexAttribArray(1);
224

225
    glBindVertexArray(0);
226

227
    unsigned int planeVAO, planeVBO;
228
    glGenVertexArrays(1, &planeVAO);
229
    glGenBuffers(1, &planeVBO);
230

231
    glBindVertexArray(planeVAO);
232
    glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
233
    glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
234

235
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
236
    glEnableVertexAttribArray(0);
237

238
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
239
    glEnableVertexAttribArray(1);
240

241
    glBindVertexArray(0);
242

243
    unsigned int transparentVAO, transparentVBO;
244
    glGenVertexArrays(1, &transparentVAO);
245
    glGenBuffers(1, &transparentVBO);
246

247
    glBindVertexArray(transparentVAO);
248
    glBindBuffer(GL_ARRAY_BUFFER, transparentVBO);
249

250
    glBufferData(GL_ARRAY_BUFFER, sizeof(transparentVertices), transparentVertices, GL_STATIC_DRAW);
251

252
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
253
    glEnableVertexAttribArray(0);
254
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
255
    glEnableVertexAttribArray(1);
256

257
    glBindVertexArray(0);
258

259
    unsigned int cubeTexture = loadTexture("resources/textures/marble.jpg");
260
    unsigned int floorTexture = loadTexture("resources/textures/metal.jpg");
261
    unsigned int transparentTexture = loadTexture("resources/textures/blending_transparent_window.png");
262

263
    shader.use();
264
    shader.setInt("texture1", 0);
265
    shader.setInt("texture2", 1);
266
    shader.setInt("texture3", 2);
267

268
    while (!glfwWindowShouldClose(window)) {
269
        float currentFrame = (float)glfwGetTime();
270
        deltaTime = currentFrame - lastFrame;
271
        lastFrame = currentFrame;
272

273
        processInput(window);
274

275
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
276
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
277

278
        shader.use();
279
        glm::mat4 model = glm::mat4(1.0f);
280
        glm::mat4 view = camera.GetCameraView();
281
        glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
282
        shader.setMatrix("view", view);
283
        shader.setMatrix("project", project);
284

285
        glBindVertexArray(cubeVAO);
286
        glActiveTexture(GL_TEXTURE0);
287
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
288
        shader.setInt("useTex", 1);
289
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
290
        shader.setMatrix("model", model);
291
        glDrawArrays(GL_TRIANGLES, 0, 36);
292

293
        model = glm::mat4(1.0f);
294
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
295
        shader.setMatrix("model", model);
296
        glDrawArrays(GL_TRIANGLES, 0, 36);
297

298
        glBindVertexArray(0);
299

300
        glBindVertexArray(planeVAO);
301
        glActiveTexture(GL_TEXTURE1);
302
        glBindTexture(GL_TEXTURE_2D, floorTexture);
303
        shader.setInt("useTex", 2);
304
        shader.setMatrix("model", glm::mat4(1.0f));
305
        glDrawArrays(GL_TRIANGLES, 0, 6);
306
        glBindVertexArray(0);
307

308
        glBindVertexArray(transparentVAO);
309
        glActiveTexture(GL_TEXTURE2);
310
        glBindTexture(GL_TEXTURE_2D, transparentTexture);
311
        shader.setInt("useTex", 3);
312
        for (map<float, glm::vec3>::reverse_iterator it = sorted.rbegin(); it != sorted.rend(); it++) {
313
            model = glm::mat4(1.0f);
314
            model = glm::translate(model, it->second);
315
            shader.setMatrix("model", model);
316
            shader.setMatrix("view", view);
317
            shader.setMatrix("project", project);
318
            glDrawArrays(GL_TRIANGLES, 0, 6);
319
        }
320
        glBindVertexArray(0);
321

322
        glfwSwapBuffers(window);
323
        glfwPollEvents();
324
    }
325
    glDeleteVertexArrays(1, &cubeVAO);
326
    glDeleteVertexArrays(1, &planeVAO);
327
    glDeleteBuffers(1, &cubeVBO);
328
    glDeleteBuffers(1, &planeVBO);
329

330
    glfwTerminate();
331
    return 0;
332
}

BQACAgUAAyEGAASHRsPbAAEWK1tqP21I2FsXeK2gHNIRIjHp1AXKEgACsiQAAk05AVZ70fCqPpWMTTwE.png 但是上面这种排序假设物体各个部分都是相同的深度，对于那些不同地方深度不一样的物体来说，这样的深度排序就是不正确的。