【LearnOpenGL学习笔记】——16.混合测试

已于 2022-04-30 00:18:26 修改
阅读量509 收藏 1
点赞数
文章标签： 学习
于 2022-04-29 23:49:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45974407/article/details/124506596
版权

文章目录

1.丢弃片段

丢弃纹理中透明部分的片段，保留不透明部分的片段
如何加载透明纹理？
stb_image会自动加载，但我们需要告诉OpenGL
因此使用
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

2.半透明图形渲染——使用混合（blend）

（1）混合开启：glEnable(GL_BLEND);
（2）混合公式：
在这里插入图片描述
（3）因子值设置：

glBlendFunc(GLenum sfactor, GLenum dfactor)
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
在这里插入图片描述

（4）渲染顺序：

先绘制所有不透明的物体（从前往后）
对所有透明的物体排序。
按顺序绘制所有透明的物体（从后往前）

3.练习

（1）代码

#include <glad/glad.h>
#include <GLFW/glfw3.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);

// 窗口设置
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

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

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


int main()
{

    // glfw: 初始化与配置
    // ------------------------------
    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 窗口创建
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL17", 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);

    // 捕获鼠标
    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;
    }

    // tell stb_image.h to flip loaded texture's on the y-axis (before loading model).
    stbi_set_flip_vertically_on_load(true);

    // 深度测试
    // -----------------------------
    //glEnable(GL_DEPTH_TEST);
    //glDepthFunc(GL_ALWAYS);

     // configure global opengl state
    // -----------------------------
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    // shaders创建、链接
    // -------------------------
    Shader ourShader("1.vs", "1.fs");


    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 (note we set these higher than 1 (together with GL_REPEAT as texture wrapping mode). this will cause the floor texture to repeat)
         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)));
    glBindVertexArray(0);
    // 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)));
    glBindVertexArray(0);
    // 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);


    // draw in wireframe
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

        // load textures
    // -------------
    string path1 = "F:/DeskTop/texture/marble.jpg";
    string path2 = "F:/DeskTop/texture/metal.png";
    string path3 = "F:/DeskTop/texture/blending_transparent_window.png";
    
    //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 cubeTexture = loadTexture(path1.c_str());
    unsigned int floorTexture = loadTexture(path2.c_str());
    unsigned int transparentTexture = loadTexture(path3.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)
    };



    ourShader.use();
    ourShader.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
        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.05f, 0.05f, 0.05f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // don't forget to clear the stencil buffer!

        // view/projection transformations

        //singleShader.use();
        //glm::mat4 model = glm::mat4(1.0f);
        //glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        //glm::mat4 view = camera.GetViewMatrix();
        //singleShader.setMat4("projection", projection);
        //singleShader.setMat4("view", view);

        //ourShader.use();
        //ourShader.setMat4("projection", projection);
        //ourShader.setMat4("view", view);


        ourShader.use();

        glm::mat4 model = glm::mat4(1.0f);
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        glm::mat4 view = camera.GetViewMatrix();
        ourShader.setMat4("projection", projection);
        ourShader.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));
        ourShader.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));
        ourShader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // floor
        glBindVertexArray(planeVAO);
        glBindTexture(GL_TEXTURE_2D, floorTexture);
        ourShader.setMat4("model", glm::mat4(1.0f));
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);
        

        // 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);
            ourShader.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);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    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, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 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;
}

（2）运行结果
在这里插入图片描述

4.面剔除

（1）一个面有两侧，其中一侧背向用户，只绘制其中一侧。
（2）OpenGL做法：分析顶点环绕顺序，检查正向面，丢弃背向面
（3）环绕顺序：环绕一组三角形顶点，从两侧看顺序方向相反

5.面剔除相关函数

（1）面剔除开启：glEnable(GL_CULL_FACE);
（2）改变剔除面：glCullFace(GL_FRONT);

GL_BACK：只剔除背向面。(默认)
GL_FRONT：只剔除正向面。
GL_FRONT_AND_BACK：剔除正向面和背向面。

（3）设置正面的顺序：glFrontFace(GL_CCW);

GL_CCW：逆时针
GL_CW：顺时针

6.练习

重新定义顶点数据，将每个三角形设置为顺时针顺序，并将顺时针的三角形设置为正向面

glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);

正面：
在这里插入图片描述
背面：
在这里插入图片描述
cube内部：
在这里插入图片描述

Wascofe
关注
学习笔记——sql.zip
06-08
"学习笔记——sql.zip"这个压缩包文件很可能包含了关于SQL的学习资料，如教程、笔记、示例代码等，旨在帮助用户掌握SQL的基本概念、语法和高级特性。 首先，SQL的基础知识包括数据类型，如整型（INT）、浮点型...
Opengl glBlendFunc,颜色混合公式，FrameBuffer混合颜色不正确，预乘alpha总结
最新发布
m0_58186648的博客
01-20 556
Opengl glBlendFunc,颜色混合公式，FrameBuffer混合颜色不正确，预乘alpha总结
GLES2.0中文API-glBlendFunc
flycatdeng的专栏
11-28 1621
名称 glBlendFunc - 指定像素算术 C规范 void glBlendFunc(    GLenum sfactor,      GLenum dfactor); 参数 sfactor 指定如何计算红色，绿色，蓝色和alpha源混合因子。下列符号常量被接受：GL_ZERO，GL_ONE，GL_SRC_COLOR，GL_ONE_MINUS_SRC_COLOR，GL_DST_CO...
《高效学习OpenGL》 之 混合 glBlendFunc(), glBlendFuncSeparate(),glBlendEquation(), glBlendEquationSeparate()
编辑编辑器
02-21 1万+
1.源因子和目标因子 void glBlendFunc (GLenum sfactor, GLenum dfactor); //控制被处理片段（源片段）的颜色值如何与已经存储在帧缓冲区的像素（目标像素）的颜色值进行组合 //参数sfactor表示如何计算源混合因子，dfactor表示如何计算目标混合因子 glBlendFuncSeparate(GLenum
第十六章 opengl之高级OpenGL（混合）
Re_view的博客
03-14 589
第十六章 opengl之高级OpenGL（混合）
【OpenGL】七、混合
qq_36674053的博客
10-24 259
OpenGl 混合函数
GLES3.0中文API-glBlendFuncSeparate
MSK1111的博客
02-11 546
名称 glBlendFuncSeparate - 分别指定RGB和alpha分量的像素算术 C规范 void glBlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); 参数 srcRGB 指定如何计算红色，绿色和蓝色混合因子。下列符号常量被接受：GL_ZERO，GL_ONE，GL...
读书笔记——AGoodManIsHardToFind.pdf
12-07
读书笔记——AGoodManIsHardToFind.pdf 读书笔记——AGoodManIsHardToFind.pdf 是一篇关于美国南方女作家 Flannery O'Connor 的读书笔记。该笔记主要讨论了 O'Connor 的小说《好人难寻》（A Good Man Is Hard to ...
MySQL笔记——笔记.md
10-02
MySQL笔记
OpenGL关于glStencilFuncSeparate()和glStencilFunc()函数的区别讲解
08-26
今天小编就为大家分享一篇OpenGL关于glStencilFuncSeparate()和glStencilFunc()函数的区别讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
网络运维笔记——T221.docx
07-11
《网络运维笔记——T221》主要涵盖了网络运维中的关键知识点，包括TCP与UDP报文首部的解析、访问控制列表（ACL）的工作原理与配置，以及网络地址转换（NAT）的操作流程和相关概念。以下是这些主题的详细解释： 一、...
blend后颜色异常问题（glBlendFunc & glBlendFuncSeparate）
And乔的博客
04-24 1179
blend后颜色异常问题（glBlendFunc & glBlendFuncSeparate） 1. 问题描述 应用中显示投屏小窗部分的颜色值与预期不一致，预期为纯白色 [0xFF]，而实际显示偏黑 [0xDE] 相同渲染合成逻辑在X86平台测试显示为正常色彩 [0xFF] 各个layer叠加顺序如下（简化层级可以说明问题即可）： 应用使用GPU渲染各个对象后进行blending合成输出到Overlay 01： media bottom 投屏画面输出到Overlay 02； PS：Over
Android OpenGLES2.0（十八）——轻松搞定Blend颜色混合
热门推荐
偶尔记录的一些学习笔记
08-03 1万+
Blend是OpenGL中的一个非常重要的部分，它可以让每个输出的源和目的颜色以多种方式组合在一起，以呈现出不同的效果，满足不同的需求。
OpenGL: 混合
Augusdi的专栏
04-15 7032
OpenGL 红宝书 混合6.1 混合6.1.1 源因子和目标因子假定源和目标混合因子分别为(Sr, Sg, Sb, Sa)和(Dr,Dg,Db,Da), 混合后的RGB值如下:(RsSr + RdDr, GsSg + GdDg, BsSb + BdDb, AsSa + AdDa)最后,将该四元组的各个分量截取到[0,1].将源片元和目标象素合并起来的默认方式是,将它们的值相加. 选择源混合因子和
OpenGL管线（用经典管线代说着色器内部）
爱不释手lc
09-02 1598
转载自：http://www.cnblogs.com/liangliangh/p/4116164.html
OpenGL 颜色混合、图元的反走样（五）
TanJiaXiang的博客
12-18 832
1、颜色混合   使用混合的原因： 我们把OpenGL渲染时会把颜⾊值存在颜⾊缓存区中，每个⽚段的深度值也是放在深度缓冲区。当深度缓冲区被关闭时，新的颜⾊将简单的覆盖原来颜⾊缓存区存在的颜⾊值；当深度缓冲区再次打开时，新的颜⾊⽚段只是当它们⽐原来的值更接近邻近的裁剪平⾯才会替换原来的颜⾊⽚段。 那么如果开启深度测试后，当出现2个重叠的图层情况，有⼀个图层是半透明的，另⼀个图层是⾮半透明的，那么此时就不能进⾏单纯的⽐较深度值，然后进⾏覆盖。⽽是需要将2个图层的颜⾊进⾏计算后得到应该显示颜色，.
[WebGL入门]三十，混合系数
lufy小屋
08-23 3737
混色是将颜色和颜色混合处理的总称，在WebGL中主要是指源颜色和目标颜色这两种颜色的混合。源颜色是即将要绘制的颜色，目标颜色是已经绘制的颜色，源颜色如何处理，目标颜色如何处理，这些都可以单独进行设置。颜色如何处理是由混合系数决定的，混合系数有很多种，不同的组合绘制的结果也会有很大不同。根据自己的创意，可以实现透明处理，加算合成，反转合成等各种各样的合成处理。 这次，来更进一步详细说说混合系数。而这回的demo，也会将这些混合系数做成可调整的形式，大家可以试一下各种混合系数的组合。
Python基础教程学习笔记——模块详解
资源摘要信息: "python基础教程_学习笔记充电时刻_模块共13页.pdf.zip" 在本压缩包中，我们期望找到关于Python基础教程的学习笔记，具体涵盖了模块部分的内容，总计有13页。根据文件的描述和标题，我们可以推断出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值