第十六章 opengl之高级OpenGL（混合）

最新推荐文章于 2025-07-30 17:26:38 发布
原创 最新推荐文章于 2025-07-30 17:26:38 发布 · 709 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#计算机视觉 #opencv #人工智能

文章介绍了如何使用OpenGL进行混合操作以实现物体的透明和半透明效果。通过调整片段着色器，可以丢弃特定透明度的片段，或者启用混合功能来处理不同透明级别的图像。混合涉及到源颜色、目标颜色、源因子和目标因子，以及如何设置它们来达到预期的混合效果。同时，为了正确渲染半透明纹理，需要先绘制远处的物体，并确保混合顺序正确，避免深度测试导致的问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

OpenGL

混合

混合通常是实现物体透明度的一种技术。
透明就是指一个物体，或者其中的一部分，不是纯色的。它的颜色是物体本身的颜色和它背后其他物体的颜色的不同强度结合。

透明的物体可以是完全透明的，或者是半透明的。一个物体的透明度是通过它颜色的alpha值来决定的。
alpha颜色值是颜色向量的第四分量。之前都是将第四分量设置为1，让物体透明度为0，而当alpha值为0，代表物体将完全透明。当alpha值为0.5，物体的颜色50%来自物体自身的颜色，50%来自背后物体的颜色。

一直使用的纹理颜色是RGB，但是一些材质会有一个内嵌的alpha通道，对每个纹素都包含了一个alpha值。这个值精确地告诉我们纹理各个部分的透明度。

综上，第四分量为1，完全不透明；第四分量为0，完全透明。

丢弃片段

当前需要实现只有完全透明和完全不透明的纹理的透明度。
有些图片并不需要半透明，只需要根据纹理颜色值，显示一部分，或者不显示一部分，没有中间情况。

举例：如果想不太费劲地创建草这种东西，你需要将一个草的纹理贴在一个2D四边形(Quad)上，然后将这个四边形放到场景中。然而，草的形状和2D四边形的形状并不完全相同，所以你只想显示草纹理的某些部分，而忽略剩下的部分。

所以想要丢弃显示纹理中的部分片段，不将这些片段存储到颜色缓冲里。首先需要学习如何加载一个透明的纹理。
要想加载有alpha值的纹理，我们并不需要改很多东西，stb_image在纹理有alpha通道的时候会自动加载，但我们仍要在纹理生成过程中告诉OpenGL，我们的纹理现在使用alpha通道了：（这个在之前的loadTexture函数中已经使用了，可以回顾关注下）

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

保证在片段着色器中获取了纹理的全部四个颜色分量，而不仅仅是RGB分量：

void main()
{
    // FragColor = vec4(vec3(texture(texture1, TexCoords)), 1.0);
    FragColor = texture(texture1, TexCoords);
}

下面在上章节中的深度测试的基础上，增加几个小草。
创建一个vector，向里面添加glm::vec3变量来代表草的位置：

vector<glm::vec3> vegetation;
vegetation.push_back(glm::vec3(-1.5f,  0.0f, -0.48f));
vegetation.push_back(glm::vec3( 1.5f,  0.0f,  0.51f));
vegetation.push_back(glm::vec3( 0.0f,  0.0f,  0.7f));
vegetation.push_back(glm::vec3(-0.3f,  0.0f, -2.3f));
vegetation.push_back(glm::vec3( 0.5f,  0.0f, -0.6f));

每个草都被渲染到了一个四边形上，贴上草的纹理。这并不能完美地表示3D的草，但这比加载复杂的模型要快多了。
因为草的纹理是添加到四边形对象上的，我们还需要创建另外一个VAO，填充VBO，设置正确的顶点属性指针。接下来，在绘制完地板和两个立方体后，我们将会绘制草：

glBindVertexArray(vegetationVAO);
glBindTexture(GL_TEXTURE_2D, grassTexture);  
for(unsigned int i = 0; i < vegetation.size(); i++) 
{
    model = glm::mat4(1.0f);
    model = glm::translate(model, vegetation[i]);               
    shader.setMat4("model", model);
    glDrawArrays(GL_TRIANGLES, 0, 6);
}

但是会出现正方形的白色没有被丢弃的现象。是因为OpenGL默认不知道如何处理alpha值，更不清楚什么时候需要丢弃片段。
GLSL有discard命令，一旦被调用，会保证片段不会被进一步处理，所以不会进入到颜色缓冲。可以通过这个指令，在片段着色器中检测一个片段的alpha值是否低于某个阈值，如果是，则丢弃这个片段

#version 330 core
out vec4 FragColor;

in vec2 TexCoords;

uniform sampler2D texture1;

void main()
{             
    vec4 texColor = texture(texture1, TexCoords);
    if(texColor.a < 0.1)
        discard;
    FragColor = texColor;
}

注意，当采样纹理的边缘的时候，OpenGL会对边缘的值和纹理下一个重复的值进行插值（因为我们将它的环绕方式设置为了GL_REPEAT。这通常是没问题的，但是由于我们使用了透明值，纹理图像的顶部将会与底部边缘的纯色值进行插值。这样的结果是一个半透明的有色边框，你可能会看见它环绕着你的纹理四边形。要想避免这个，每当你alpha纹理的时候，请将纹理的环绕方式设置为GL_CLAMP_TO_EDGE：

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

混合

上述丢弃片段的方法，不能渲染半透明的图像。要么渲染一个片段，要么完全丢弃它。要渲染有多个透明度级别的图像，需要启用混合：

glEnable(GL_BLEND);

启用后，需要告诉OpenGL如何进行混合：

源颜色向量。这是源自纹理的颜色向量。
目标颜色向量。这是当前储存在颜色缓冲中的颜色向量。
源因子值。指定了alpha值对源颜色的影响。
目标因子值。指定了alpha值对目标颜色的影响。

片段着色器运行完成后，并且所有的测试都通过之后，这个混合方程(Blend Equation)才会应用到片段颜色输出与当前颜色缓冲中的值（当前片段之前储存的之前片段的颜色）上。源颜色和目标颜色将会由OpenGL自动设定，但源因子和目标因子的值可以由我们来决定。
举例如下：
先声明一个完全不透明的红色矩形（1，0，0，1），再声明一个半透明的绿色矩形（0，1，0，0.6）。希望半透明的绿色方块绘制到红色方块上。则：红色方块是目标颜色（所以红色方块应该先在颜色缓冲中）。在红色方块的上面绘制绿色方块。
源颜色向量：0.6。则目标方块需要贡献剩下的alpha值，则目标因子值是0.4
有一个函数可以让OpenGL使用混合的颜色glBlendFunc
glBlendFunc(GLenum sfactor, GLenum dfactor)函数接受两个参数，来设置源和目标因子。OpenGL为我们定义了很多个选项，我们将在下面列出大部分最常用的选项。注意常数颜色向量可以通过glBlendColor函数来另外设置。

选项和值如下：
GL_ZERO： 表示使用0.0作为因子，实际上相当于不使用这种颜色参与混合运算。
GL_ONE： 表示使用1.0作为因子，实际上相当于完全的使用了这种颜色参与混合运算。
GL_SRC_ALPHA：表示使用源颜色的alpha值来作为因子。
GL_DST_ALPHA：表示使用目标颜色的alpha值来作为因子。
GL_ONE_MINUS_SRC_ALPHA：表示用1.0减去源颜色的alpha值来作为因子。
GL_ONE_MINUS_DST_ALPHA：表示用1.0减去目标颜色的alpha值来作为因子。
除 此以外，还有GL_SRC_COLOR（把源颜色的四个分量分别作为因子的四个分量）、GL_ONE_MINUS_SRC_COLOR、 GL_DST_COLOR、GL_ONE_MINUS_DST_COLOR等，前两个在OpenGL旧版本中只能用于设置目标因子，后两个在OpenGL 旧版本中只能用于设置源因子。新版本的OpenGL则没有这个限制，并且支持新的GL_CONST_COLOR（设定一种常数颜色，将其四个分量分别作为 因子的四个分量）、GL_ONE_MINUS_CONST_COLOR、GL_CONST_ALPHA、 GL_ONE_MINUS_CONST_ALPHA。另外还有GL_SRC_ALPHA_SATURATE。新版本的OpenGL还允许颜色的alpha 值和RGB值采用不同的混合因子。但这些都不是我们现在所需要了解的。

为了获得之前两个方形的混合结果，我们需要使用源颜色向量的作为源因子，使用目标颜色向量作为目标因子。这将会产生以下的glBlendFunc：

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

也可以使用glBlendFuncSeparate为RGB和alpha通道分别设置不同的选项：

glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);

这个函数和我们之前设置的那样设置了RGB分量，但这样只能让最终的alpha分量被源颜色向量的alpha值所影响到。

允许我们改变方程中源和目标部分的运算符。当前源和目标是相加的，但如果愿意的话，我们也可以让它们相减。glBlendEquation(GLenum mode)允许我们设置运算符，它提供了三个选项：
GL_FUNC_ADD：默认选项，将两个分量相加：。
GL_FUNC_SUBTRACT：将两个分量相减： 。
GL_FUNC_REVERSE_SUBTRACT：将两个分量相减，但顺序相反：。
通常我们都可以省略调用glBlendEquation，因为GL_FUNC_ADD对大部分的操作来说都是我们希望的混合方程，但如果你真的想打破主流，其它的方程也可能符合你的要求。

渲染半透明纹理

首先，需要在初始化的时候启用混合，设定相应的混合函数：

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

启用混合，就不要丢弃片段了，需要把片段着色器还原：

#version 330 core
out vec4 FragColor;

in vec2 TexCoords;

uniform sampler2D texture1;

void main()
{             
    FragColor = texture(texture1, TexCoords);
}

则，每当OpenGL渲染一个片段时，就会将当前片段的颜色和当前颜色缓冲中的片段颜色，根据alpha值来进行混合。但是深度测试和混合一起使用会有一点问题：当写入深度缓冲时，深度缓冲不会检查片段是否透明的，所以透明的部分会和其他值一样写入到深度缓冲中。则，应该要半透明的图形和要半透明的图形重叠后，后面的半透明图形会因为深度测试而被丢弃。
解决方法：要保证如果重叠的半透明图形都显示出来，则需要先绘制后面的半透明图形，在绘制的时候，需要手动将窗户按照最远到最近来排序，再按照顺序渲染

不要打乱顺序

要让混合在多个物体上工作，需要先绘制最远的物体，最后绘制最近的物体。普通不需要混合的物体仍然可以使用深度缓冲正常绘制，不需要排序。但需要保证它们在绘制透明物体之前已经绘制完毕了。当绘制一个有不透明和透明物体的场景，原则如下：

  1. 先绘制所有不透明物体
  2. 对所有透明的物体排序
  3. 按顺序绘制所有透明物体
    排序透明物体的一种方法是：从观察者视角获取物体的距离。可以通过计算摄像机位置向量和物体的位置向量之间的距离得到。下面将距离和它对应的位置向量存储到一个STL库的map数据结构中，map会根据键值对它的值进行排序。只要我们添加了所有位置，并以它的距离作为键，就会自动根据距离值排序
std::map<float, glm::vec3> sorted;
for (unsigned int i = 0; i < windows.size(); i++)
{
    float distance = glm::length(camera.Position - windows[i]);
    sorted[distance] = windows[i];
}

可以得到一个排序后的容器对象，是根据distance键值从低到高存储每个窗户的位置。
然后在渲染的时候，将从远到近来从map获取值，就可以正确的顺序绘制半透明图形了：

for(std::map<float,glm::vec3>::reverse_iterator it = sorted.rbegin(); it != sorted.rend(); ++it) 
{
    model = glm::mat4();
    model = glm::translate(model, it->second);              
    shader.setMat4("model", model);
    glDrawArrays(GL_TRIANGLES, 0, 6);
}

上述代码使用了map的反向迭代器，反向遍历其中的条目，并将每个窗户四边形位移到对应的位置。这是一种排序透明物体的简单实现。
综上，代码如下：

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <stb_image.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <learnopengl/shader_m.h>
#include <learnopengl/camera.h>
#include <learnopengl/model.h>

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void processInput(GLFWwindow *window);
unsigned int loadTexture(const char *path);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

// camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
float lastX = (float)SCR_WIDTH / 2.0;
float lastY = (float)SCR_HEIGHT / 2.0;
bool firstMouse = true;

// timing
float deltaTime = 0.0f;
float lastFrame = 0.0f;

int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);

    // tell GLFW to capture our mouse
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // configure global opengl state
    // -----------------------------
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // build and compile shaders
    // -------------------------
    Shader shader("3.2.blending.vs", "3.2.blending.fs");

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float cubeVertices[] = {
        // positions          // texture Coords
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };
    float planeVertices[] = {
        // positions          // texture Coords 
         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,

         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
         5.0f, -0.5f, -5.0f,  2.0f, 2.0f
    };
    float transparentVertices[] = {
        // positions         // texture Coords (swapped y coordinates because texture is flipped upside down)
        0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
        0.0f, -0.5f,  0.0f,  0.0f,  1.0f,
        1.0f, -0.5f,  0.0f,  1.0f,  1.0f,

        0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
        1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
        1.0f,  0.5f,  0.0f,  1.0f,  0.0f
    };
    // cube VAO
    unsigned int cubeVAO, cubeVBO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &cubeVBO);
    glBindVertexArray(cubeVAO);
    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    // plane VAO
    unsigned int planeVAO, planeVBO;
    glGenVertexArrays(1, &planeVAO);
    glGenBuffers(1, &planeVBO);
    glBindVertexArray(planeVAO);
    glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    // transparent VAO
    unsigned int transparentVAO, transparentVBO;
    glGenVertexArrays(1, &transparentVAO);
    glGenBuffers(1, &transparentVBO);
    glBindVertexArray(transparentVAO);
    glBindBuffer(GL_ARRAY_BUFFER, transparentVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(transparentVertices), transparentVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glBindVertexArray(0);

    // load textures
    // -------------
    unsigned int cubeTexture = loadTexture(FileSystem::getPath("resources/textures/marble.jpg").c_str());
    unsigned int floorTexture = loadTexture(FileSystem::getPath("resources/textures/metal.png").c_str());
    unsigned int transparentTexture = loadTexture(FileSystem::getPath("resources/textures/window.png").c_str());

    // transparent window locations
    // --------------------------------
    vector<glm::vec3> windows
    {
        glm::vec3(-1.5f, 0.0f, -0.48f),
        glm::vec3( 1.5f, 0.0f, 0.51f),
        glm::vec3( 0.0f, 0.0f, 0.7f),
        glm::vec3(-0.3f, 0.0f, -2.3f),
        glm::vec3( 0.5f, 0.0f, -0.6f)
    };

    // shader configuration
    // --------------------
    shader.use();
    shader.setInt("texture1", 0);

    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // per-frame time logic
        // --------------------
        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // input
        // -----
        processInput(window);

        // sort the transparent windows before rendering
        // ---------------------------------------------
        std::map<float, glm::vec3> sorted;
        for (unsigned int i = 0; i < windows.size(); i++)
        {
            float distance = glm::length(camera.Position - windows[i]);
            sorted[distance] = windows[i];
        }

        // render
        // ------
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // draw objects
        shader.use();
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        glm::mat4 view = camera.GetViewMatrix();
        glm::mat4 model = glm::mat4(1.0f);
        shader.setMat4("projection", projection);
        shader.setMat4("view", view);
        // cubes
        glBindVertexArray(cubeVAO);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        // floor
        glBindVertexArray(planeVAO);
        glBindTexture(GL_TEXTURE_2D, floorTexture);
        model = glm::mat4(1.0f);
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 6);
        // windows (from furthest to nearest)
        glBindVertexArray(transparentVAO);
        glBindTexture(GL_TEXTURE_2D, transparentTexture);
        for (std::map<float, glm::vec3>::reverse_iterator it = sorted.rbegin(); it != sorted.rend(); ++it)
        {
            model = glm::mat4(1.0f);
            model = glm::translate(model, it->second);
            shader.setMat4("model", model);
            glDrawArrays(GL_TRIANGLES, 0, 6);
        }


        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &cubeVAO);
    glDeleteVertexArrays(1, &planeVAO);
    glDeleteBuffers(1, &cubeVBO);
    glDeleteBuffers(1, &planeVBO);

    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

// glfw: whenever the mouse moves, this callback is called
// -------------------------------------------------------
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
    float xpos = static_cast<float>(xposIn);
    float ypos = static_cast<float>(yposIn);
    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

// glfw: whenever the mouse scroll wheel scrolls, this callback is called
// ----------------------------------------------------------------------
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(static_cast<float>(yoffset));
}

// utility function for loading a 2D texture from file
// ---------------------------------------------------
unsigned int loadTexture(char const * path)
{
    unsigned int textureID;
    glGenTextures(1, &textureID);

    int width, height, nrComponents;
    unsigned char *data = stbi_load(path, &width, &height, &nrComponents, 0);
    if (data)
    {
        GLenum format;
        if (nrComponents == 1)
            format = GL_RED;
        else if (nrComponents == 3)
            format = GL_RGB;
        else if (nrComponents == 4)
            format = GL_RGBA;

        glBindTexture(GL_TEXTURE_2D, textureID);
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, format == GL_RGBA ? GL_CLAMP_TO_EDGE : GL_REPEAT); // for this tutorial: use GL_CLAMP_TO_EDGE to prevent semi-transparent borders. Due to interpolation it takes texels from next repeat 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, format == GL_RGBA ? GL_CLAMP_TO_EDGE : GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        stbi_image_free(data);
    }
    else
    {
        std::cout << "Texture failed to load at path: " << path << std::endl;
        stbi_image_free(data);
    }

    return textureID;
}
OpenGL简单镶嵌
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-21 337
OpenGL简单镶嵌先上图，再解答。完整主要的源代码源代码剖析 先上图，再解答。 完整主要的源代码 #include <stdio.h> #include "GL/glus.h" static GLUSprogram g_program; static GLint g_projectionMatrixLocation; static GLint g_modelViewMatrixLocation; static GLint g_vertexLocation; static GLuint g_v
OpenGL学习笔记2：绘制和混合
键盘春秋的博客
06-18 3944
绘制OpenGL几何图元在使用OpenGL在计算机屏幕上进行绘图时不需要从一个点的绘制开始。我们关心的不是物理屏幕坐标和像素，而是视景体中的位置坐标，我们将从7个由定义的几何图元来开始绘制实心几何图形： 图元 描述 GL_POINTS 每个顶点在屏幕上都是一个单独的点 GL_LINES 每一对顶点定义了一个线段 GL_LINE_STRIP 一个从第一个顶点依次经过每个后
OpenGL_alpha混合
12-04
Exercise 5：alpha 混合要求： 1. 绘制若干个透明和非透明茶壶，并体现出它们之间正确的混合效果； 考察目的： 1. OpenGL 中 alpha 混合的使用； 2. 混合绘制透明和不透明物体的正确方法； 3. 运算符的重载和基本 STL 的使用；
OpenGL Alpha混合
痞子龙3D编程
02-26 2800
原 文：Lesson 8: Blending　译 者：CKER　　OpenGL中的绝大多数特效都与某些类型的（色彩）混合有关。混色的定义为，将某个象素的颜色和已绘制在屏幕上与其对应的象素颜色相互结合。至于如何结合这两个颜色则依赖于颜色的alpha通道的分量值，以及/或者所使用的混色函数。Alpha通常是位于颜色值末尾的第4个颜色组成分量。前面这些课我们都是用GL_RGB来指定颜色的三个分量。相
OpenGL:三维模型，模型网格点与面片同时显示，模型网格轮廓线与面片同时显示
HW140701的博客
12-27 5953
1、 OpenGL多边形偏移函数glPolygonOffser(GLfloat factor,GLfloat units)如果我们想显示一个三维模型的边缘，我们可能会采用GL_FILL先绘制一遍三维模型，然后在用GL_LINE用不同的颜色再绘制一遍，但是在这种情况下，我们所绘制的边缘线与面片叠在一起，时有时无，会产生非常不好的视觉效果。 OpenGL采用了glPolygonOffset(GLfloa
OpenGL下实现Alpha混合
架构设计
12-09 459
&lt;style type="text/css"&gt; &lt;!-- @page {margin:2cm} pre.cjk {font-family:"DejaVu Sans Condensed",monospace} p {margin-bottom:0.21cm} --&gt; &lt;/style&gt; OpenGL下实现Alpha混合 有很久都没有使用Op...
OpenGL下的alpha融合
dizuo的专栏
04-14 2769
alpha混合理论见前一篇博客：http://blog.csdn.net/dizuo/archive/2009/12/18/5035371.aspx alpha融合必须对物体设置不同的z值，可以通过glVertex3*绘制指定不同z值；或者通过glVertex2*绘制，调用glTranslate3f/d设置不同的z值。 opengl绘制二维图形，进行alpha融合时候，如果所有二维图形具有相同
OpenGL ES 3.0编程指南第2版[中文][PDF]
04-09
由资深OpenGL技术专家亲笔撰写，全面介绍OpenGL ES 3.0的各种特性及新增功能，通过大量已经编译和测试过的实例，...第16章讨论如何为iOS 7、Android 4.3 NDK、Android 4.3 SDK、Windows和Linux构建OpenGL ES样板代码。
opengl编程教程-opengl Programming Guide.zip
01-30
第16课可能涵盖了高级主题，比如高级着色技术，如GLSL（OpenGL Shading Language）的使用，或者是交互式图形处理。 "G"和"H"可能是文件夹，代表了课程的不同部分或者模块。它们可能包含源代码、图像资源、纹理文件...
OpenGL ES 3.0
11-21
　第16章——OpenGL ES平台 　在最后一章中，我们抛开API的细节，讨论如何为iOS 7、Android 4.3 NDK、Android 4.3 SDK、Windows和Linux构建OpenGL ES样板代码。该章的意图是作为一个指南，帮助你在所选择的OpenGL ES...
OpenGL的Alpha混合（演示程序+源代码）
12-08
操作说明： [w][s][a][d]键：控制最中间的方块移动。 [F1~F5]键：设置背景颜色，其中F2~F5的背景颜色可以掩盖一个方块。 [Esc]键：退出。 Windows下可能出现的错误： 1、无法定位程序输入点-except-handler4-commom于动态链接库msvcrt.dll上。 这种错误是由于新版msvcrt.dll含有异常处理机制，而老的msvcrt.dll没有。你可能需要更换一个msvcrt.dll，试试可以运行程序的计算机，找到Windows/system32/msvcrt.dll，复制粘贴到无法运行程序的计算机的相同位置即可。 2、无法找到glu32.dll、opengl32.dll，同上所述，将响应的动态链接库复制到对应的位置即可。 Linux下可能出现的错误： 1、没有为 可执行文件 文件类型安装应用程序。 权限问题，将可执行属性加上。 2、如果找不到相关的动态库，需要安装。具体问题可以到http://blog.csdn.net/jiangcaiyang123上向我留言。 如果你发现程序中的方块运动过快或者过慢，那么请自行编译程序并且更改相关数据。程序在Windows使用minGW编译。我的开发环境是： Windows：Windows8+QtCreator2.6+QtSDK4.8.4+minGW4.4.1。 Linux：Ubuntu11.10+QtCreator2.4+QtSDK4.8.1+gcc4.4
OpenGL的Alpha混合（演示程序）
12-14
此资源是演示程序，可以免费下载。 ---------------------------------------- 有很久都没有使用OpenGL了。一直都只是看书，一旦实践起来就会发现比想象起来困难得多。不过我还是实现了OpenGL下面一个小小的效果：Alpha混合。 以前在DirectX上做过，所以赶紧回去看了看自己以前写的文章。果然像一些高手说得一样，Direct3D和OpenGL其实是相通的。像Direct3D中要实现此功能要这么写： m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE ); m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); 在OpenGL中则是这么写： glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
OpenGL学习总结-OpenGL功能总结（六）
pplander的专栏
10-17 1414
OpenGL相关功能总结
OpenGL教程之Alpha混合
01-16 4411
Jeff Molofee(NeHe)的OpenGL教程- Alpha混合　原 文：Lesson 8: Blending　译 者：CKER　　OpenGL中的绝大多数特效都与某些类型的（色彩）混合有关。混色的定义为，将某个象素的颜色和已绘制在屏幕上与其对应的象素颜色相互结合。至于如何结合这两个颜色则依赖于颜色的alpha通道的分量值，以及/或者所使用的混色函数。Alpha通常是位于颜色值末尾的第
OPENGL半透明图像产生黑色光环
weixin_34232617的博客
09-21 401
OPENGL提供了多种多样的混合方法，我们很容易就能实现诸如 叠加、变亮等图像混合。 我们知道一般带透明度的图像是RGBA四个通道来存储，最常的glBlendFunc是 　　glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) 大多数的资料会告诉要用这个来处理半透明的图像，因为： 　　ColorResult = SrcColor * SrcAl...
【OpenGL】笔记二十一、Alpha测试、混合测试
ycrsw的博客
06-01 1932
1. 流程
OpenGL 混合
xueangfu的博客
05-18 681
OpenGL 混合（Blending） 在OpenGL中，物体透明技术通常被叫做混合(Blending)。透明的物体的颜色来自于不同浓度的自身颜色和它后面的物体颜色的混合。 可以开启GL_BLEND来启用混合功能： glEnable(GL_BLEND); OpenGL以下面的方程进行混合： Csource：源颜色向量。这是来自纹理的本来的颜色向量。 Cdestination：目标颜色向量。这是储存在颜色缓冲中当前位置的颜色向量。 Fsource：源因子。设置了对源颜色的alpha值影响。 Fdes
Vision Transformer (ViT) 详解：当Transformer“看见”世界，计算机视觉的范式革命
最新发布
AggressiveYu的博客
07-30 971
长久以来，卷积神经网络（CNN）凭借其精心设计的归纳偏置（inductive biases），无可争议地统治着计算机视觉领域。然而，一篇名为《An Image is Worth 16x16 Words》的论文彻底改变了这一格局，它所提出的 Vision Transformer (ViT) 模型，成功地将源于自然语言处理（NLP）领域的 Transformer 架构直接应用于图像识别，并取得了惊人的成果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值