【OpenGL学习笔记】--图像管线

图像管线（Image Pipeline）是计算机图形学中一个核心概念，尤其是在图形处理和渲染的上下文中。它是一个用于处理和渲染图像的流程，其中包括从场景数据的输入到最终图像输出的各个阶段。

图像管线的组成

顶点处理（Vertex Processing）：
顶点着色器（Vertex Shader）：在这一阶段，顶点着色器处理每个顶点的位置、颜色和其他属性。它负责将顶点从模型空间转换到屏幕空间。
图元组装（Primitive Assembly）：
图元组装：将顶点组合成图元（如点、线、三角形）。这些图元构成了渲染的基本单元。
光栅化（Rasterization）：
光栅化阶段：将图元转换为片段（fragments），即即将成为最终像素的数据。光栅化确定哪些像素被图元覆盖，并生成对应的片段。
片段处理（Fragment Processing）：
片段着色器（Fragment Shader）：每个片段经过片段着色器处理，确定最终的颜色和其他属性（如透明度）。这一步是渲染图像的最后阶段。
输出合成（Output Merging）：
混合（Blending）：将片段的颜色值与现有帧缓冲中的像素值进行混合，决定最终的像素值。
深度测试（Depth Testing）：处理像素的深度值，确定哪些像素应该被绘制或遮挡。

图像管线的工作流程

输入数据：接收场景的顶点数据、纹理和其他属性。
顶点处理：顶点着色器将顶点数据转换到裁剪空间。
图元组装：将顶点数据组合成图元（如三角形）。
光栅化：将图元转换为片段。
片段处理：片段着色器计算每个片段的最终颜色。
输出合成：将片段的颜色值合成到帧缓冲中，并进行深度测试和混合。
在这里插入图片描述

着色器（Shader）是计算机图形学中的一种程序，用于在图形渲染过程中处理图形数据。它们在图形管线的不同阶段执行，控制图像的渲染效果。

顶点着色器

顶点着色器（Vertex Shader）

功能

处理顶点数据：顶点着色器的主要任务是处理每个顶点的属性（如位置、颜色、法线、纹理坐标等）。
变换和光照：通常，顶点着色器会对顶点进行变换（例如，将顶点从模型空间转换到视图空间），并计算光照效果。
输出数据：顶点着色器将处理后的顶点数据传递到下一阶段（如图元装配阶段）。输出通常包括屏幕坐标（即裁剪空间坐标）以及传递给片段着色器的数据（如插值的纹理坐标）。

示例代码

#version 330 core

layout(location = 0) in vec3 aPos;      // 输入顶点位置
layout(location = 1) in vec3 aColor;    // 输入顶点颜色

out vec3 vertexColor;                   // 输出给片段着色器的颜色

uniform mat4 model;                     // 模型矩阵
uniform mat4 view;                      // 视图矩阵
uniform mat4 projection;                // 投影矩阵

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0); // 顶点位置变换
    vertexColor = aColor; // 传递颜色数据到片段着色器
}

渲染管线中的位置

顶点着色器：处理顶点数据（如位置、颜色等），执行变换，将数据传递给后续的阶段。
片段着色器：计算每个片段的颜色，负责图像的最终显示效果。

关键区别

处理对象：顶点着色器处理的是单个顶点的数据，而片段着色器处理的是渲染图像中的每个像素（片段）的颜色。
位置：顶点着色器在渲染管线的早期阶段执行，片段着色器在管线的后期阶段执行。

通过这两种着色器，开发者可以实现复杂的渲染效果，如自定义光照模型、纹理映射、阴影等，使得图形渲染具有很大的灵活性和表现力。

曲面细分着色器

曲面细分的目的是将较低细节的几何模型细分成更高细节的模型
这个过程可以分为几个主要阶段：

细分控制点（Tessellation Control Points）：定义细分曲面的基本形状。细分控制点通常是一个粗糙的模型，定义了细分曲面的轮廓。
细分控制着色器（Tessellation Control Shader）：
- 功能：确定细分的级别（即细分的数量）。它接收控制点的输入并生成一个细分的参数，指定如何将曲面分解成更小的部分（如三角形）。
- 输入：控制点的顶点数据和细分因子。
- 输出：细分因子（也称为 tessellation factor），用于确定细分的程度。
细分评估着色器（Tessellation Evaluation Shader）：
- 功能：计算细分后的每个顶点的位置。它接收细分后的参数，利用这些参数计算出细分曲面的实际位置。

输入：细分后的控制点和细分因子。
输出：细分后的顶点位置，用于后续的图形处理。

图元组装（Primitive Assembly）：将细分后的顶点组装成图元（如三角形）。
光栅化（Rasterization）：将图元转换为片段，进行渲染。
片段处理（Fragment Processing）：通过片段着色器处理每个片段的颜色和其他属性，最终输出到屏幕。

几何着色器

几何着色器位于顶点着色器和片段着色器之间。它允许对图元（如点、线和三角形）进行更高级的操作和处理。
几何着色器可以改变图元的形状，增加或删除顶点，甚至生成新的图元，这些新生成的图元可以传递到片段着色器进行进一步处理。但并不是所有的渲染管线都需要几何着色器，它是一个可选的阶段。

工作流程：

输入：几何着色器的输入是从顶点着色器输出的图元（例如，一个三角形的三个顶点）。
处理：几何着色器对这些图元进行处理，可以修改顶点位置、生成新顶点、创建新的图元（例如从一个三角形生成多个三角形）。
输出：几何着色器将处理后的图元传递给后续的阶段，如片段着色器或进一步的几何着色器（如果存在的话）。

栅格化

栅格化（Rasterization）是计算机图形学中的一个关键步骤，用于将图形中的矢量图形（如几何图形）转换为图像像素（点阵图）。
这个过程是从图形渲染管线的几何处理阶段到最终图像显示阶段的关键环节。以下是栅格化的主要内容和流程：

栅格化是将一个几何图形（例如三角形、线段或点）映射到屏幕上的像素网格的过程。
简而言之，它的目的是确定哪些像素会被图形覆盖，并为这些像素分配适当的颜色和其他属性（如深度）。

栅格化的流程：

几何图形表示：在栅格化之前，图形通常由顶点着色器处理，并通过几何着色器生成最终的图元（如三角形）。
图元拆分：几何图形被拆分为一系列小的片段（fragments）。每个片段代表了屏幕上的一个像素位置，但包含了该像素的颜色、深度等信息。
像素覆盖测试：确定哪些像素被图元覆盖。对于三角形，这个步骤涉及到检查像素是否位于三角形内部。
片段处理：对覆盖像素的颜色、深度进行计算和处理。这个阶段涉及到片段着色器，它确定最终的像素颜色。
合成：将计算出的颜色值和深度值合成到最终的图像缓冲区中，并进行可能的深度测试（z-buffering）和混合（blending）操作。

栅格化的关键点：

像素位置：栅格化确定图形的哪些部分覆盖了具体的像素点。
片段生成：生成片段，片段包含了像素的颜色、深度和其他可能的属性。
光栅化算法：如扫描线算法和Bresenham算法用于高效地确定哪些像素被图元覆盖。

片段着色器（Fragment Shader）

片段着色器用于为栅格化的像素指定颜色

功能

计算像素颜色：片段着色器的任务是计算最终的像素颜色（即片段颜色）。它在图形管线的最终阶段运行，接收从顶点着色器传递来的插值数据，并对每个片段进行颜色计算。
纹理映射和光照：通常在片段着色器中会进行纹理映射、光照计算以及其他图像处理操作。
输出颜色：片段着色器的输出是最终的颜色值，决定了图像中每个像素的颜色。

示例代码

#version 330 core

in vec3 vertexColor;    // 从顶点着色器传来的颜色

out vec4 FragColor;    // 输出到屏幕的颜色

void main()
{
    FragColor = vec4(vertexColor, 1.0); // 设置片段的最终颜色
}

VAO和VBO

VAO（Vertex Array Object）和VBO（Vertex Buffer Object）是OpenGL中的两个重要概念，它们用于高效地管理和传输顶点数据，从而提高图形渲染的性能和灵活性。

VAO

VAO 是一种用于封装顶点数据格式和状态的对象。它记录了顶点属性的配置（如VBO的绑定、属性指针等），使得在渲染时能够方便地重复使用这些设置。
功能：

封装顶点状态：存储顶点属性指针（如顶点位置、颜色、纹理坐标的格式和位置）和VBO的绑定状态，避免每次渲染时重复设置这些状态。
简化代码：使得绑定和配置顶点数据的代码更加简洁，通过一次绑定VAO即可恢复先前设置的顶点属性状态。
提高效率：减少了每帧需要调用的OpenGL状态设置函数的数量，从而提高渲染性能。

用法：

创建VAO：调用 glGenVertexArrays 生成一个或多个VAO。
绑定VAO：使用 glBindVertexArray 绑定到当前的VAO。
设置顶点属性：在VAO绑定状态下，设置顶点属性指针（如 glVertexAttribPointer）和绑定VBO。
解绑VAO：通过 glBindVertexArray 绑定到0，解除当前VAO的绑定。

VBO

VBO 是一种用于存储顶点数据（如位置、颜色、法线、纹理坐标等）的缓冲区对象。它是一种在显存中存储顶点数据的机制，使得数据可以在GPU上高效地进行处理，而不必在每一帧重新传输数据。

功能：

存储顶点数据：将顶点属性（如位置、颜色等）上传到GPU的内存中，以减少CPU和GPU之间的数据传输。
提高性能：通过减少数据传输的开销，提升渲染性能。因为数据已经在GPU内存中，渲染时只需简单地引用这些数据即可。
数据分离：允许数据和渲染状态分开管理，提高灵活性和性能。

用法：

创建VBO：调用 glGenBuffers 生成一个或多个VBO。
绑定VBO：使用 glBindBuffer 将VBO绑定到目标缓冲区（如GL_ARRAY_BUFFER）。
上传数据：使用 glBufferData 将顶点数据上传到GPU。
解绑VBO：通过 glBindBuffer 绑定到0，解除当前VBO的绑定。

综合使用

通常，VAO 和 VBO 会一起使用以优化渲染过程。典型的使用流程如下：

创建和绑定VAO：设置和绑定VAO，以记录顶点属性的状态。
创建和绑定VBO：设置和绑定VBO，上传顶点数据到GPU。
设置顶点属性：在VAO绑定状态下，配置顶点属性的格式。
渲染：绑定VAO，然后调用渲染命令（如 glDrawArrays 或 glDrawElements）。

代码示例：

使用 VAO 和 VBO 来渲染一个简单的三角形


#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>

// 顶点着色器源代码
const char* vertexShaderSource = R"(
#version 330 core
layout(location = 0) in vec3 aPos;
void main() {
    gl_Position = vec4(aPos, 1.0);
}
)";

// 片段着色器源代码
const char* fragmentShaderSource = R"(
#version 330 core
out vec4 FragColor;
void main() {
    FragColor = vec4(1.0, 0.0, 0.0, 1.0); // 红色
}
)";

// 编译着色器
GLuint compileShader(GLenum shaderType, const char* source) {
    GLuint shader = glCreateShader(shaderType);
    glShaderSource(shader, 1, &source, nullptr);
    glCompileShader(shader);

    // 检查编译状态
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(shader, 512, nullptr, infoLog);
        std::cerr << "Shader Compilation Error: " << infoLog << std::endl;
    }

    return shader;
}

// 链接着色器程序
GLuint createShaderProgram() {
    GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
    GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);

    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    // 检查链接状态
    GLint success;
    GLchar infoLog[512];
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
        std::cerr << "Program Linking Error: " << infoLog << std::endl;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return shaderProgram;
}

int main() {
    // 初始化GLFW
    if (!glfwInit()) {
        std::cerr << "Failed to initialize GLFW" << std::endl;
        return -1;
    }

    // 创建窗口
    GLFWwindow* window = glfwCreateWindow(800, 600, "VAO & VBO Example", nullptr, nullptr);
    if (!window) {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);
    glewInit();

    // 定义顶点数据
    float vertices[] = {
        0.0f,  0.5f, 0.0f,
       -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f
    };

    // 创建VBO和VAO
    GLuint VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, 0); // 解绑VBO
    glBindVertexArray(0); // 解绑VAO

    GLuint shaderProgram = createShaderProgram();

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        // 输入处理
        if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            glfwSetWindowShouldClose(window, true);

        // 渲染命令
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);

        // 交换缓冲区和处理事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 清理
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);

    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}