现代渲染引擎渲染管线管理系统

于 2024-09-13 15:31:03 发布
阅读量542 收藏 8
点赞数 3
分类专栏： 渲染管线 文章标签： 渲染管线
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/142212112
版权

现代渲染引擎中的渲染管线管理系统通常负责管理和调度渲染过程中的各个阶段，以确保渲染过程高效且有序地进行。这个系统的逻辑调用通常包括以下几个主要步骤：

  1. 初始化阶段：设置渲染管线所需的资源和状态。
  2. 渲染阶段：执行场景渲染，包括几何处理、光照计算等。
  3. 后期处理阶段：对初步渲染结果进行后期处理，如色调映射、抗锯齿等。
  4. 输出阶段：将最终处理后的图像输出到屏幕或其他目标。

以下是一个简化的渲染管线管理系统的逻辑调用示例：

1. 初始化阶段

在初始化阶段，渲染管线管理系统会设置渲染所需的资源和状态，包括创建帧缓冲对象、加载着色器、设置渲染目标等。

void initializeRenderPipeline() {
    // 创建帧缓冲对象
    createFramebuffers();

    // 加载和编译着色器
    loadShaders();

    // 设置渲染目标
    setRenderTargets();
}

2. 渲染阶段

在渲染阶段，系统会执行场景渲染，包括几何处理、光照计算等。这通常涉及多个渲染通道（Pass），如几何通道、光照通道等。

void renderScene() {
    // 几何通道：渲染场景的几何信息
    renderGeometryPass();

    // 光照通道：计算光照
    renderLightingPass();

    // 其他通道：如阴影、反射等
    renderShadowPass();
    renderReflectionPass();
}

3. 后期处理阶段

在后期处理阶段，系统会对初步渲染结果进行后期处理，以增强图像质量和添加视觉效果。

void postProcess() {
    // 色调映射
    applyToneMapping();

    // 抗锯齿
    applyAntiAliasing();

    // 光晕效果
    applyBloom();

    // 其他后期处理效果
    applyDepthOfField();
    applyMotionBlur();
}

4. 输出阶段

在输出阶段，系统会将最终处理后的图像输出到屏幕或其他目标。

void display() {
    // 将最终图像渲染到屏幕
    renderToScreen();
}

渲染管线管理系统的整体逻辑

将上述各个阶段整合到一个渲染管线管理系统中，整体逻辑调用可能如下所示：

class RenderPipeline {
public:
    void initialize() {
        initializeRenderPipeline();
    }

    void execute() {
        // 清除帧缓冲
        clearFramebuffers();

        // 渲染场景
        renderScene();

        // 执行后期处理
        postProcess();

        // 显示最终图像
        display();
    }

private:
    void initializeRenderPipeline() {
        createFramebuffers();
        loadShaders();
        setRenderTargets();
    }

    void clearFramebuffers() {
        // 清除颜色缓冲和深度缓冲
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    void renderScene() {
        renderGeometryPass();
        renderLightingPass();
        renderShadowPass();
        renderReflectionPass();
    }

    void postProcess() {
        applyToneMapping();
        applyAntiAliasing();
        applyBloom();
        applyDepthOfField();
        applyMotionBlur();
    }

    void display() {
        renderToScreen();
    }

    // 具体的渲染和后期处理方法
    void createFramebuffers() { /* ... */ }
    void loadShaders() { /* ... */ }
    void setRenderTargets() { /* ... */ }
    void renderGeometryPass() { /* ... */ }
    void renderLightingPass() { /* ... */ }
    void renderShadowPass() { /* ... */ }
    void renderReflectionPass() { /* ... */ }
    void applyToneMapping() { /* ... */ }
    void applyAntiAliasing() { /* ... */ }
    void applyBloom() { /* ... */ }
    void applyDepthOfField() { /* ... */ }
    void applyMotionBlur() { /* ... */ }
    void renderToScreen() { /* ... */ }
};

在更复杂的渲染管线管理系统中，可能会使用事件驱动和依赖管理来更灵活地控制渲染过程。这种方法可以确保各个渲染阶段和后期处理步骤按照正确的顺序执行，并且可以根据需要动态调整渲染管线。

事件驱动和依赖管理

事件驱动

事件驱动的渲染管线管理系统通过事件和回调机制来触发各个渲染阶段和后期处理步骤。这种方法可以提高系统的灵活性和可扩展性。

class RenderPipeline {
public:
    void initialize() {
        // 注册事件和回调
        registerEvents();
    }

    void execute() {
        // 触发渲染事件
        triggerEvent("RenderScene");

        // 触发后期处理事件
        triggerEvent("PostProcess");

        // 触发显示事件
        triggerEvent("Display");
    }

private:
    void registerEvents() {
        // 注册渲染事件和回调
        registerEvent("RenderScene", [this]() { renderScene(); });
        registerEvent("PostProcess", [this]() { postProcess(); });
        registerEvent("Display", [this]() { display(); });
    }

    void renderScene() {
        triggerEvent("RenderGeometryPass");
        triggerEvent("RenderLightingPass");
        triggerEvent("RenderShadowPass");
        triggerEvent("RenderReflectionPass");
    }

    void postProcess() {
        triggerEvent("ApplyToneMapping");
        triggerEvent("ApplyAntiAliasing");
        triggerEvent("ApplyBloom");
        triggerEvent("ApplyDepthOfField");
        triggerEvent("ApplyMotionBlur");
    }

    void display() {
        triggerEvent("RenderToScreen");
    }

    // 事件注册和触发机制
    void registerEvent(const std::string& eventName, std::function<void()> callback) {
        eventCallbacks[eventName] = callback;
    }

    void triggerEvent(const std::string& eventName) {
        if (eventCallbacks.find(eventName) != eventCallbacks.end()) {
            eventCallbacks[eventName]();
        }
    }

    std::unordered_map<std::string, std::function<void()>> eventCallbacks;
};

依赖管理（续）

在依赖管理系统中，渲染管线的各个阶段和步骤通过定义明确的依赖关系来确保按正确的顺序执行。以下是一个更详细的示例，展示如何使用依赖管理来组织渲染管线。

依赖管理系统的实现
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <functional>

class RenderPipeline {
public:
    void initialize() {
        // 定义渲染阶段和后期处理步骤
        addStage("RenderScene", [this]() { renderScene(); });
        addStage("PostProcess", [this]() { postProcess(); });
        addStage("Display", [this]() { display(); });

        // 定义依赖关系
        addDependency("RenderScene", "PostProcess");
        addDependency("PostProcess", "Display");
    }

    void execute() {
        // 执行渲染管线
        executeStages();
    }

private:
    void addStage(const std::string& stageName, std::function<void()> callback) {
        stages[stageName] = callback;
    }

    void addDependency(const std::string& before, const std::string& after) {
        dependencies[after].push_back(before);
    }

    void executeStages() {
        std::unordered_set<std::string> executedStages;
        for (const auto& stage : stages) {
            executeStage(stage.first, executedStages);
        }
    }

    void executeStage(const std::string& stageName, std::unordered_set<std::string>& executedStages) {
        if (executedStages.find(stageName) != executedStages.end()) {
            return;
        }

        for (const auto& dependency : dependencies[stageName]) {
            executeStage(dependency, executedStages);
        }

        stages[stageName]();
        executedStages.insert(stageName);
    }

    void renderScene() {
        std::cout << "Rendering Scene..." << std::endl;
        // 渲染场景的各个通道
        triggerEvent("RenderGeometryPass");
        triggerEvent("RenderLightingPass");
        triggerEvent("RenderShadowPass");
        triggerEvent("RenderReflectionPass");
    }

    void postProcess() {
        std::cout << "Post Processing..." << std::endl;
        // 执行后期处理的各个步骤
        triggerEvent("ApplyToneMapping");
        triggerEvent("ApplyAntiAliasing");
        triggerEvent("ApplyBloom");
        triggerEvent("ApplyDepthOfField");
        triggerEvent("ApplyMotionBlur");
    }

    void display() {
        std::cout << "Displaying Final Image..." << std::endl;
        // 将最终图像渲染到屏幕
        triggerEvent("RenderToScreen");
    }

    void triggerEvent(const std::string& eventName) {
        if (eventCallbacks.find(eventName) != eventCallbacks.end()) {
            eventCallbacks[eventName]();
        }
    }

    std::unordered_map<std::string, std::function<void()>> stages;
    std::unordered_map<std::string, std::vector<std::string>> dependencies;
    std::unordered_map<std::string, std::function<void()>> eventCallbacks;
};

int main() {
    RenderPipeline pipeline;
    pipeline.initialize();
    pipeline.execute();
    return 0;
}

事件和回调的注册

在这个示例中，我们还可以进一步扩展，允许注册更多的事件和回调，以便在渲染管线的不同阶段执行特定的操作。

void registerEvents() {
    // 注册渲染事件和回调
    registerEvent("RenderGeometryPass", []() { std::cout << "Rendering Geometry Pass..." << std::endl; });
    registerEvent("RenderLightingPass", []() { std::cout << "Rendering Lighting Pass..." << std::endl; });
    registerEvent("RenderShadowPass", []() { std::cout << "Rendering Shadow Pass..." << std::endl; });
    registerEvent("RenderReflectionPass", []() { std::cout << "Rendering Reflection Pass..." << std::endl; });

    // 注册后期处理事件和回调
    registerEvent("ApplyToneMapping", []() { std::cout << "Applying Tone Mapping..." << std::endl; });
    registerEvent("ApplyAntiAliasing", []() { std::cout << "Applying Anti-Aliasing..." << std::endl; });
    registerEvent("ApplyBloom", []() { std::cout << "Applying Bloom..." << std::endl; });
    registerEvent("ApplyDepthOfField", []() { std::cout << "Applying Depth of Field..." << std::endl
    ```cpp
    registerEvent("ApplyMotionBlur", []() { std::cout << "Applying Motion Blur..." << std::endl; });

    // 注册显示事件和回调
    registerEvent("RenderToScreen", []() { std::cout << "Rendering to Screen..." << std::endl; });
}

事件和回调的触发

在渲染管线的各个阶段和步骤中，通过触发相应的事件来执行注册的回调函数。

void renderScene() {
    std::cout << "Rendering Scene..." << std::endl;
    // 渲染场景的各个通道
    triggerEvent("RenderGeometryPass");
    triggerEvent("RenderLightingPass");
    triggerEvent("RenderShadowPass");
    triggerEvent("RenderReflectionPass");
}

void postProcess() {
    std::cout << "Post Processing..." << std::endl;
    // 执行后期处理的各个步骤
    triggerEvent("ApplyToneMapping");
    triggerEvent("ApplyAntiAliasing");
    triggerEvent("ApplyBloom");
    triggerEvent("ApplyDepthOfField");
    triggerEvent("ApplyMotionBlur");
}

void display() {
    std::cout << "Displaying Final Image..." << std::endl;
    // 将最终图像渲染到屏幕
    triggerEvent("RenderToScreen");
}

完整示例

以下是一个完整的示例，展示了如何使用事件驱动和依赖管理来组织渲染管线。

#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <functional>

class RenderPipeline {
public:
    void initialize() {
        // 注册事件和回调
        registerEvents();

        // 定义渲染阶段和后期处理步骤
        addStage("RenderScene", [this]() { renderScene(); });
        addStage("PostProcess", [this]() { postProcess(); });
        addStage("Display", [this]() { display(); });

        // 定义依赖关系
        addDependency("RenderScene", "PostProcess");
        addDependency("PostProcess", "Display");
    }

    void execute() {
        // 执行渲染管线
        executeStages();
    }

private:
    void registerEvents() {
        // 注册渲染事件和回调
        registerEvent("RenderGeometryPass", []() { std::cout << "Rendering Geometry Pass..." << std::endl; });
        registerEvent("RenderLightingPass", []() { std::cout << "Rendering Lighting Pass..." << std::endl; });
        registerEvent("RenderShadowPass", []() { std::cout << "Rendering Shadow Pass..." << std::endl; });
        registerEvent("RenderReflectionPass", []() { std::cout << "Rendering Reflection Pass..." << std::endl; });

        // 注册后期处理事件和回调
        registerEvent("ApplyToneMapping", []() { std::cout << "Applying Tone Mapping..." << std::endl; });
        registerEvent("ApplyAntiAliasing", []() { std::cout << "Applying Anti-Aliasing..." << std::endl; });
        registerEvent("ApplyBloom", []() { std::cout << "Applying Bloom..." << std::endl; });
        registerEvent("ApplyDepthOfField", []() { std::cout << "Applying Depth of Field..." << std::endl; });
        registerEvent("ApplyMotionBlur", []() { std::cout << "Applying Motion Blur..." << std::endl; });

        // 注册显示事件和回调
        registerEvent("RenderToScreen", []() { std::cout << "Rendering to Screen..." << std::endl; });
    }

    void addStage(const std::string& stageName, std::function<void()> callback) {
        stages[stageName] = callback;
    }

    void addDependency(const std::string& before, const std::string& after) {
        dependencies[after].push_back(before);
    }

    void executeStages() {
        std::unordered_set<std::string> executedStages;
        for (const auto& stage : stages) {
            executeStage(stage.first, executedStages);
        }
    }

    void executeStage(const std::string& stageName, std::unordered_set<std::string>& executedStages) {
        if (executedStages.find(stageName) != executedStages.end()) {
            return;
        }

        for (const auto& dependency : dependencies[stageName]) {
            executeStage(dependency, executedStages);
        }

        stages[stageName]();
        executedStages.insert(stageName);
    }

    void renderScene() {
        std::cout << "Rendering Scene..." << std::endl;
        // 渲染场
        ```cpp
        // 渲染场景的各个通道
        triggerEvent("RenderGeometryPass");
        triggerEvent("RenderLightingPass");
        triggerEvent("RenderShadowPass");
        triggerEvent("RenderReflectionPass");
    }

    void postProcess() {
        std::cout << "Post Processing..." << std::endl;
        // 执行后期处理的各个步骤
        triggerEvent("ApplyToneMapping");
        triggerEvent("ApplyAntiAliasing");
        triggerEvent("ApplyBloom");
        triggerEvent("ApplyDepthOfField");
        triggerEvent("ApplyMotionBlur");
    }

    void display() {
        std::cout << "Displaying Final Image..." << std::endl;
        // 将最终图像渲染到屏幕
        triggerEvent("RenderToScreen");
    }

    void registerEvent(const std::string& eventName, std::function<void()> callback) {
        eventCallbacks[eventName] = callback;
    }

    void triggerEvent(const std::string& eventName) {
        if (eventCallbacks.find(eventName) != eventCallbacks.end()) {
            eventCallbacks[eventName]();
        }
    }

    std::unordered_map<std::string, std::function<void()>> stages;
    std::unordered_map<std::string, std::vector<std::string>> dependencies;
    std::unordered_map<std::string, std::function<void()>> eventCallbacks;
};

int main() {
    RenderPipeline pipeline;
    pipeline.initialize();
    pipeline.execute();
    return 0;
}

解释

  1. 事件注册和回调：

    • registerEvent 方法用于注册事件和对应的回调函数。
    • triggerEvent 方法用于触发事件，执行注册的回调函数。

  2. 渲染阶段和依赖关系：

    • addStage 方法用于添加渲染阶段，并指定对应的回调函数。
    • addDependency 方法用于定义渲染阶段之间的依赖关系。

  3. 执行渲染管线：

    • executeStages 方法遍历所有渲染阶段，并根据依赖关系执行每个阶段。
    • executeStage 方法递归地执行每个渲染阶段，确保依赖关系得到满足。

  4. 渲染和后期处理：

    • renderScene 方法触发场景渲染的各个通道。
    • postProcess 方法触发后期处理的各个步骤。
    • display 方法触发最终图像的显示。

总结

通过使用事件驱动和依赖管理，可以构建一个灵活且可扩展的渲染管线管理系统。事件驱动机制允许在渲染管线的不同阶段执行特定的操作，而依赖管理系统确保各个阶段按照正确的顺序执行。这种方法不仅提高了系统的灵活性和可维护性，还使得渲染管线的管理更加直观和高效。

扩展和优化

在实际应用中，渲染管线可能会变得非常复杂，包含更多的渲染阶段和后期处理步骤。为了进一步扩展和优化渲染管线管理系统，可以考虑以下几个方面：

1. 并行执行

现代图形硬件和多核处理器允许并行执行多个渲染任务。可以通过分析依赖关系图，找出可以并行执行的任务，从而提高渲染效率。

#include <thread>
#include <future>

void executeStageParallel(const std::string& stageName, std::unordered_set<std::string>& executedStages) {
    if (executedStages.find(stageName) != executedStages.end()) {
        return;
    }

    std::vector<std::future<void>> futures;
    for (const auto& dependency : dependencies[stageName]) {
        futures.push_back(std::async(std::launch::async, &RenderPipeline::executeStageParallel, this, dependency, std::ref(executedStages)));
    }

    for (auto& future : futures) {
        future.get();
    }

    stages[stageName]();
    executedStages.insert(stageName);
}
2. 动态调整渲染管线

根据不同的场景和需求，动态调整渲染管线。例如，在性能优先的场景中，可以禁用一些高开销的后期处理效果；在画质优先的场景中，可以启用更多的后期处理效果。

void adjustPipelineForPerformance() {
    // 禁用一些高开销的后期处理效果
    stages.erase("ApplyBloom");
    stages.erase("ApplyDepthOfField");
}

void adjustPipelineForQuality() {
    // 启用更多的后期处理效果
    addStage("ApplyBloom", []() { std::cout << "Applying Bloom..." << std::endl; });
    addStage("ApplyDepthOfField", []() { std::cout << "Applying Depth of Field..." << std::endl; });
}
3. 配置文件和脚本

使用配置文件或脚本来定义渲染管线的结构和依赖关系，使得渲染管线的配置更加灵活和易于修改。

void loadPipelineConfig(const std::string& configFilePath) {
    // 从配置文件加载渲染管线的结构和依赖关系
    // 例如，使用 JSON 或 XML 格式的配置文件
}

void savePipelineConfig(const std::string& configFilePath) {
    // 将当前渲染管线的结构和依赖关系保存到配置文件
}
4. 性能监控和调试

添加性能监控和调试工具，帮助开发者分析和优化渲染管线。例如，记录每个渲染阶段的执行时间，检测性能瓶颈。

#include <chrono>

void executeStageWithTiming(const std::string& stageName, std::unordered_set<std::string>& executedStages) {
    if (executedStages.find(stageName) != executedStages.end()) {
        return;
    }

    for (const auto& dependency : dependencies[stageName]) {
        executeStageWithTiming(dependency, executedStages);
    }

    auto start = std::chrono::high_resolution_clock::now();
    stages[stageName]();
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;

    std::cout << "Stage " << stageName << " executed in " << duration.count() << " seconds." << std::endl;
    executedStages.insert(stageName);
}

完整示例

以下是一个包含并行执行、动态调整、配置文件和性能监控的完整示例：

#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <functional>
#include <thread>
#include <future>
#include <chrono>

class RenderPipeline {
public:
    void initialize() {
        // 注册事件和回调
        registerEvents();

        // 定义渲染阶段和后期处理步骤
        addStage("RenderScene", [this]() { renderScene(); });
        addStage("PostProcess", [this]() { postProcess(); });
        addStage("Display", [this]() { display(); });

        // 定义依赖关系
        addDependency("RenderScene", "PostProcess");
        addDependency("PostProcess", "Display");
    }

    void execute() {
        // 执行渲染管线
        executeStages();
    }

    void adjustPipelineForPerformance() {
        // 禁用一些高开销的后期处理效果
        stages.erase("ApplyBloom");
        stages.erase("ApplyDepthOfField");
    }

    void adjustPipelineForQuality() {
        // 启用更多的后期处理效果
        addStage("ApplyBloom", []() { std::cout << "Applying Bloom..." << std::endl; });
        addStage("ApplyDepthOfField", []() { std::cout << "Applying Depth of Field..." << std::endl; });
    }

private:
    void registerEvents() {
        // 注册渲染事件和回调
        registerEvent("RenderGeometryPass", []() { std::cout << "Rendering Geometry Pass..." << std::endl; });
        registerEvent("RenderLightingPass", []() { std::cout << "Rendering Lighting Pass..." << std::endl; });
        registerEvent("RenderShadowPass", []() { std::cout << "Rendering Shadow Pass..." << std::endl; });
        registerEvent("RenderReflectionPass", []() { std::cout << "Rendering Reflection Pass..." << std::endl; });

        // 注册后期处理事件和回调
        registerEvent("ApplyToneMapping", []() { std::cout << "Applying Tone Mapping..." << std::endl; });
        registerEvent("ApplyAntiAliasing", []() { std::cout << "Applying Anti-Aliasing..." << std::endl; });
        registerEvent("ApplyBloom", []() { std::cout << "Applying Bloom..." << std::endl; });
        registerEvent("ApplyDepthOfField", []() { std::cout << "Applying Depth of Field..." << std::endl; });
        registerEvent("ApplyMotionBlur", []() { std::cout << "Applying Motion Blur..." << std::endl; });

        // 注册显示事件和回调
        registerEvent("RenderToScreen", []() { std::cout << "Rendering to Screen..." << std::endl; });
    }

    void addStage(const std::string& stageName, std::function<void()> callback) {
        stages[stageName] = callback;
    }

    void addDependency(const std::string& before, const std::string& after) {
        dependencies[after].push_back(before);
    }

    void executeStages() {
        std::unordered_set<std::string> executedStages;
        for (const auto& stage : stages) {
            executeStageWithTiming(stage.first, executedStages);
        }
    }

    void executeStageWithTiming(const std::string& stageName, std::unordered_set<std::string>& executedStages) {
        if (executedStages.find(stageName) != executedStages.end()) {
            return;
        }

        std::vector<std::future<void>> futures;
        for (const auto& dependency : dependencies[stageName]) {
            futures.push_back(std::async(std::launch::async, &RenderPipeline::executeStageWithTiming, this, dependency, std::ref(executedStages)));
        }

        for (auto& future : futures) {
            future.get();
        }

        auto start = std::chrono::high_resolution_clock::now();
        stages[stageName]();
        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;

        std::cout << "Stage " << stageName << " executed in " << duration.count() << " seconds." << std::endl;
        executedStages.insert(stageName);
    }

    void renderScene() {
        std::cout << "Rendering Scene..." << std::endl;
        // 渲染场景的各个通道
        triggerEvent("RenderGeometryPass");
        triggerEvent("RenderLightingPass");
        triggerEvent("RenderShadowPass");
        triggerEvent("RenderReflectionPass");
    }

    void postProcess() {
        std::cout << "Post Processing..." << std::endl;
        // 执行后期处理的各个步骤
        triggerEvent("ApplyToneMapping");
        triggerEvent("ApplyAntiAliasing");
        triggerEvent("ApplyBloom");
        triggerEvent("ApplyDepthOfField");
        triggerEvent("ApplyMotionBlur");
    }

    void display() {
        std::cout << "Displaying Final Image..." << std::endl;
        // 将最终图像渲染到屏幕
        triggerEvent("RenderToScreen");
    }

    void registerEvent(const std::string& eventName, std::function<void()> callback) {
        eventCallbacks[eventName] = callback;
    }

    void triggerEvent(const std::string& eventName) {
        if (eventCallbacks.find(eventName) != eventCallbacks.end()) {
            eventCallbacks[eventName]();
        }
    }

    std::unordered_map<std::string, std::function<void()>> stages;
    std::unordered_map<std::string, std::vector<std::string>> dependencies;
    std::unordered_map<std::string, std::function<void()>> eventCallbacks;
};

int main() {
    RenderPipeline pipeline;
    pipeline.initialize();
    pipeline.adjustPipelineForPerformance(); // 或者 pipeline.adjustPipelineForQuality();
    pipeline.execute();
    return 0;
}

解释

  1. 并行执行：

    • 使用 std::async 和 std::future 实现并行执行依赖关系中的任务。
    • executeStageWithTiming 方法在执行每个阶段时记录执行时间，并输出到控制台。

  2. 动态调整渲染管线：

    • adjustPipelineForPerformance 方法禁用一些高开销的后期处理效果。
    • adjustPipelineForQuality 方法启用更多的后期处理效果。

  3. 性能监控和调试：

    • 在 executeStageWithTiming 方法中，使用 std::chrono 记录每个渲染阶段的执行时间，并输出到控制台。

通过这些扩展和优化，可以构建一个更加灵活、高效和可维护的渲染管线管理系统。

设置渲染目标（Render Target）

在渲染管线的初始化阶段，设置渲染目标（Render Target）是一个关键步骤。渲染目标通常是一个帧缓冲对象（Framebuffer Object, FBO），它包含一个或多个纹理或渲染缓冲区，用于存储渲染输出。设置渲染目标的主要目的是为后续的渲染操作提供一个存储位置，并允许在渲染过程中对渲染结果进行多次处理和操作。

渲染目标的主要用途

  1. 多重渲染目标（MRT）：

    • 允许在一次渲染过程中输出到多个纹理或缓冲区。这对于延迟渲染（Deferred Rendering）等技术非常有用。

  2. 后期处理：

    • 渲染目标可以用于存储中间渲染结果，然后在后期处理阶段应用各种效果（如模糊、色调映射、抗锯齿等）。

  3. 离屏渲染：

    • 渲染目标可以用于离屏渲染（Off-Screen Rendering），即渲染结果不直接显示在屏幕上，而是存储在纹理中，以便后续使用。

  4. 阴影映射：

    • 渲染目标可以用于存储深度信息，用于生成阴影映射。

设置渲染目标的步骤

以下是一个典型的设置渲染目标的步骤，使用 OpenGL 作为示例：

  1. 创建帧缓冲对象：

    • 创建一个新的帧缓冲对象，并绑定它。

  2. 创建纹理或渲染缓冲区：

    • 创建一个或多个纹理或渲染缓冲区，用于存储颜色、深度或模板信息。

  3. 附加纹理或渲染缓冲区到帧缓冲对象：

    • 将创建的纹理或渲染缓冲区附加到帧缓冲对象的不同附件点（Attachment Point）。

  4. 检查帧缓冲对象的完整性：

    • 检查帧缓冲对象是否完整，确保所有附件点都正确配置。

示例代码

以下是一个使用 OpenGL 设置渲染目标的示例代码：

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

GLuint createFramebuffer() {
    GLuint framebuffer;
    glGenFramebuffers(1, &framebuffer);
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

    // 创建颜色附件纹理
    GLuint colorTexture;
    glGenTextures(1, &colorTexture);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0);

    // 创建深度附件渲染缓冲区
    GLuint depthBuffer;
    glGenRenderbuffers(1, &depthBuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 800, 600);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);

    // 检查帧缓冲对象的完整性
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        std::cerr << "Framebuffer is not complete!" << std::endl;
        return 0;
    }

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    return framebuffer;
}

int main() {
    // 初始化 OpenGL 上下文（省略）

    GLuint framebuffer = createFramebuffer();
    if (framebuffer == 0) {
        std::cerr << "Failed to create framebuffer!" << std::endl;
        return -1;
    }

    // 渲染循环（省略）

    return 0;
}

解释

  1. 创建帧缓冲对象：

    • 使用 glGenFramebuffers 创建一个新的帧缓冲对象，并使用 glBindFramebuffer 绑定它。

  2. 创建颜色附件纹理：

    • 使用 glBindTexture 绑定纹理对象。
    • 使用 glTexImage2D 分配纹理存储空间，这里指定了纹理的格式（GL_RGB）和尺寸（800x600）。
    • 使用 glTexParameteri 设置纹理参数，如缩小和放大过滤方式（GL_LINEAR）。
    • 使用 glFramebufferTexture2D 将纹理附加到帧缓冲对象的颜色附件点（GL_COLOR_ATTACHMENT0）。

  3. 创建深度附件渲染缓冲区：

    • 使用 glGenRenderbuffers 创建一个新的渲染缓冲区对象，并使用 glBindRenderbuffer 绑定它。
    • 使用 glRenderbufferStorage 分配渲染缓冲区存储空间，这里指定了缓冲区的格式（GL_DEPTH_COMPONENT）和尺寸（800x600）。
    • 使用 glFramebufferRenderbuffer 将渲染缓冲区附加到帧缓冲对象的深度附件点（GL_DEPTH_ATTACHMENT）。

  4. 检查帧缓冲对象的完整性：

    • 使用 glCheckFramebufferStatus 检查帧缓冲对象的完整性，确保所有附件点都正确配置。如果帧缓冲对象不完整，输出错误信息。

  5. 解绑帧缓冲对象：

    • 使用 glBindFramebuffer 绑定默认帧缓冲对象（0），以解除当前帧缓冲对象的绑定。

使用渲染目标

在渲染循环中，可以使用设置好的帧缓冲对象作为渲染目标。以下是一个简单的渲染循环示例：

int main() {
    // 初始化 OpenGL 上下文（省略）

    GLuint framebuffer = createFramebuffer();
    if (framebuffer == 0) {
        std::cerr << "Failed to create framebuffer!" << std::endl;
        return -1;
    }

    // 渲染循环
    while (!shouldCloseWindow()) {
        // 绑定帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

        // 清除颜色和深度缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染场景
        renderScene();

        // 解绑帧缓冲对象，绑定默认帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, 0);

        // 清除默认帧缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染帧缓冲对象的纹理到屏幕
        renderFramebufferTexture();

        // 交换缓冲区
        swapBuffers();
    }

    return 0;
}

解释

  1. 绑定帧缓冲对象：

    • 使用 glBindFramebuffer 绑定之前创建的帧缓冲对象，将其设置为当前渲染目标。

  2. 清除颜色和深度缓冲区：

    • 使用 glClear 清除帧缓冲对象的颜色和深度缓冲区。

  3. 渲染场景：

    • 调用 renderScene 函数渲染场景内容到帧缓冲对象。

  4. 解绑帧缓冲对象：

    • 使用 glBindFramebuffer 绑定默认帧缓冲对象（0），将渲染目标切换回默认帧缓冲对象。

  5. 清除默认帧缓冲区：

    • 使用 glClear 清除默认帧缓冲对象的颜色和深度缓冲区。

  6. 渲染帧缓冲对象的纹理到屏幕：

    • 调用 renderFramebufferTexture 函数将帧缓冲对象的纹理渲染到屏幕。这通常涉及将纹理绘制到一个全屏四边形上。

  7. 交换缓冲区：

    • 调用 swapBuffers 函数交换前后缓冲区，显示渲染结果。

总结

设置渲染目标是渲染管线初始化阶段的重要步骤。通过创建和配置帧缓冲对象，可以灵活地控制渲染输出的位置和格式，为后续的渲染和后期处理提供基础。

初始化阶段的设置渲染目标可以看成是为渲染结果的输出选择一个位置吗

是的，初始化阶段的设置渲染目标可以看作是为渲染结果的输出选择一个位置。具体来说，这个位置通常是一个帧缓冲对象（Framebuffer Object, FBO），它包含一个或多个附件（Attachments），如颜色附件、深度附件和模板附件。这些附件可以是纹理或渲染缓冲区，用于存储渲染结果。

渲染目标的作用

  1. 存储渲染结果：

    • 渲染目标提供了一个存储渲染结果的位置。通过将渲染结果存储在纹理或渲染缓冲区中，可以在后续的渲染阶段或后期处理阶段对这些结果进行进一步处理。

  2. 灵活的渲染控制：

    • 使用帧缓冲对象可以灵活地控制渲染输出的位置和格式。例如，可以将渲染结果输出到多个颜色附件（多重渲染目标，MRT），或者将深度信息存储在深度附件中。

  3. 离屏渲染：

    • 渲染目标允许进行离屏渲染（Off-Screen Rendering），即渲染结果不直接显示在屏幕上，而是存储在纹理中。这对于后期处理、阴影映射、环境映射等技术非常有用。

示例代码回顾

以下是一个设置渲染目标的示例代码，使用 OpenGL 作为示例：

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

GLuint createFramebuffer() {
    GLuint framebuffer;
    glGenFramebuffers(1, &framebuffer);
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

    // 创建颜色附件纹理
    GLuint colorTexture;
    glGenTextures(1, &colorTexture);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0);

    // 创建深度附件渲染缓冲区
    GLuint depthBuffer;
    glGenRenderbuffers(1, &depthBuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 800, 600);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);

    // 检查帧缓冲对象的完整性
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        std::cerr << "Framebuffer is not complete!" << std::endl;
        return 0;
    }

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    return framebuffer;
}

int main() {
    // 初始化 OpenGL 上下文（省略）

    GLuint framebuffer = createFramebuffer();
    if (framebuffer == 0) {
        std::cerr << "Failed to create framebuffer!" << std::endl;
        return -1;
    }

    // 渲染循环
    while (!shouldCloseWindow()) {
        // 绑定帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

        // 清除颜色和深度缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染场景
        renderScene();

        // 解绑帧缓冲对象，绑定默认帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, 0);

        // 清除默认帧缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染帧缓冲对象的纹理到屏幕
        renderFramebufferTexture();

        // 交换缓冲区
        swapBuffers();
    }

    return 0;
}

解释

  1. 创建帧缓冲对象：

    • 使用 glGenFramebuffers 创建一个新的帧缓冲对象，并使用 glBindFramebuffer 绑定它。

  2. 创建颜色附件纹理：

    • 使用 glTexImage2D 分配纹理存储空间，这里指定了纹理的格式（GL_RGB）和尺寸（800x600）。
    • 使用 glTexParameteri 设置纹理参数，如缩小和放大过滤方式（GL_LINEAR）。
    • 使用 glFramebufferTexture2D 将纹理附加到帧缓冲对象的颜色附件点（GL_COLOR_ATTACHMENT0）。

  3. 创建深度附件渲染缓冲区：

    • 使用 glGenRenderbuffers 创建一个新的渲染缓冲区对象，并使用 glBindRenderbuffer 绑定它。
    • 使用 glRenderbufferStorage 分配渲染缓冲区存储空间，这里指定了缓冲区的格式（GL_DEPTH_COMPONENT）和尺寸（800x600）。
    • 使用 glFramebufferRenderbuffer 将渲染缓冲区附加到帧缓冲对象的深度附件点（GL_DEPTH_ATTACHMENT）。

  4. 检查帧缓冲对象的完整性：

    • 使用 glCheckFramebufferStatus 检查帧缓冲对象的完整性，确保所有附件点都正确配置。如果帧缓冲对象不完整，输出错误信息。

  5. 解绑帧缓冲对象：

    • 使用 glBindFramebuffer 绑定默认帧缓冲对象（0），以解除当前帧缓冲对象的绑定。

使用渲染目标

在渲染循环中，可以使用设置好的帧缓冲对象作为渲染目标。以下是一个简单的渲染循环示例：

int main() {
    // 初始化 OpenGL 上下文（省略）

    GLuint framebuffer = createFramebuffer();
    if (framebuffer == 0) {
        std::cerr << "Failed to create framebuffer!" << std::endl;
        return -1;
    }

    // 渲染循环
    while (!shouldCloseWindow()) {
        // 绑定帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

        // 清除颜色和深度缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染场景
        renderScene();

        // 解绑帧缓冲对象，绑定默认帧缓冲对象
        glBindFramebuffer(GL_FRAMEBUFFER, 0);

        // 清除默认帧缓冲区
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 渲染帧缓冲对象的纹理到屏幕
        renderFramebufferTexture();

        // 交换缓冲区
        swapBuffers();
    }

    return 0;
}

解释

  1. 绑定帧缓冲对象：

    • 使用 glBindFramebuffer 绑定之前创建的帧缓冲对象，将其设置为当前渲染目标。

  2. 清除颜色和深度缓冲区：

    • 使用 glClear 清除帧缓冲对象的颜色和深度缓冲区。

  3. 渲染场景：

    • 调用 renderScene 函数渲染场景内容到帧缓冲对象。

  4. 解绑帧缓冲对象：

    • 使用 glBindFramebuffer 绑定默认帧缓冲对象（0），将渲染目标切换回默认帧缓冲对象。

  5. 清除默认帧缓冲区：

    • 使用 glClear 清除默认帧缓冲对象的颜色和深度缓冲区。

  6. 渲染帧缓冲对象的纹理到屏幕：

    • 调用 renderFramebufferTexture 函数将帧缓冲对象的纹理渲染到屏幕。这通常涉及将纹理绘制到一个全屏四边形上。

  7. 交换缓冲区：

    • 调用 swapBuffers 函数交换前后缓冲区，显示渲染结果。

总结

设置渲染目标是渲染管线初始化阶段的重要步骤。通过创建和配置帧缓冲对象，可以灵活地控制渲染输出的位置和格式，为后续的渲染和后期处理提供基础。了解和掌握渲染目标的设置和使用方法，对于实现复杂的渲染效果和优化渲染性能至关重要。

渲染阶段主要的职责是什么，都会进行哪些操作

渲染阶段是计算机图形学中将场景数据转换为图像的过程。这个阶段的主要职责是将几何数据、材质、光照等信息通过一系列的计算和处理，最终生成可以显示在屏幕上的图像。渲染阶段通常包括以下几个主要操作：

1. 清除缓冲区

在每一帧的开始，通常需要清除颜色缓冲区、深度缓冲区和模板缓冲区，以确保新一帧的渲染不会受到上一帧残留数据的影响。

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

2. 设置视口和投影矩阵

视口定义了渲染结果在窗口中的显示区域，而投影矩阵则定义了从3D空间到2D屏幕的投影方式。

glViewport(0, 0, windowWidth, windowHeight);
glm::mat4 projection = glm::perspective(glm::radians(fov), aspectRatio, nearPlane, farPlane);

3. 设置视图矩阵

视图矩阵定义了摄像机的位置和方向，用于将世界坐标转换为摄像机坐标。

glm::mat4 view = glm::lookAt(cameraPosition, cameraTarget, upVector);

4. 设置模型矩阵

模型矩阵定义了物体在世界空间中的位置、旋转和缩放。

glm::mat4 model = glm::translate(glm::mat4(1.0f), objectPosition);
model = glm::rotate(model, glm::radians(angle), rotationAxis);
model = glm::scale(model, scaleVector);

5. 绑定着色器程序

在渲染之前，需要绑定适当的着色器程序，这些程序将定义顶点和片段的处理方式。

glUseProgram(shaderProgram);

6. 设置着色器参数

将必要的参数传递给着色器程序，例如投影矩阵、视图矩阵、模型矩阵、光照参数、材质参数等。

glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(viewLocation, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(modelLocation, 1, GL_FALSE, glm::value_ptr(model));

7. 绑定纹理

如果使用了纹理映射，需要绑定相应的纹理对象。

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
glUniform1i(textureLocation, 0);

8. 绘制几何体

使用顶点数组对象（VAO）或顶点缓冲对象（VBO）来绘制几何体。

glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);

9. 后期处理

在所有几何体绘制完成后，可能需要进行后期处理，例如屏幕空间效果（SSAO、Bloom等）、颜色校正、抗锯齿等。这通常涉及将帧缓冲对象（FBO）中的内容作为输入，应用一系列的片段着色器进行处理。

glBindFramebuffer(GL_FRAMEBUFFER, postProcessingFBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderQuad();

10. 交换缓冲区

在所有渲染操作完成后，交换前后缓冲区以显示渲染结果。

swapBuffers();

总结

渲染阶段的主要职责是将场景数据转换为图像，这包括清除缓冲区、设置视口和矩阵、绑定着色器和纹理、绘制几何体以及进行后期处理等操作。每一步都至关重要，共同确保最终生成的图像符合预期。通过合理的渲染管线设置和优化，可以实现高效且高质量的图形渲染。

纹理映射在什么阶段进行的，纹理映射的实现细节是什么

纹理映射是计算机图形学中将二维图像（纹理）应用到三维几何体表面的技术。纹理映射通常在渲染阶段进行，具体来说，它是在片段着色器（Fragment Shader）阶段实现的。以下是纹理映射的实现细节和步骤。

纹理映射的实现步骤

  1. 加载纹理数据
    • 在渲染之前，需要从文件中加载纹理数据，并将其上传到GPU。常用的纹理格式包括PNG、JPEG等。
GLuint textureID;
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);

// 加载纹理数据（例如使用stb_image库）
int width, height, nrChannels;
unsigned char *data = stbi_load("path/to/texture.jpg", &width, &height, &nrChannels, 0);
if (data) {
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    glGenerateMipmap(GL_TEXTURE_2D);
} else {
    std::cerr << "Failed to load texture" << std::endl;
}
stbi_image_free(data);
  1. 设置纹理参数
    • 设置纹理的过滤方式和环绕方式，以控制纹理在不同情况下的表现。
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);
  1. 绑定纹理
    • 在渲染之前，需要将纹理绑定到指定的纹理单元。
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
glUniform1i(glGetUniformLocation(shaderProgram, "textureSampler"), 0);
  1. 顶点数据中包含纹理坐标
    • 在顶点数据中包含纹理坐标（UV坐标），这些坐标用于在片段着色器中查找纹理颜色。
float vertices[] = {
    // 位置          // 颜色           // 纹理坐标
    0.5f,  0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f, // 右上
    0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f, // 右下
   -0.5f, -0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f, // 左下
   -0.5f,  0.5f, 0.0f,  1.0f, 1.0f, 0.0f,  0.0f, 1.0f  // 左上
};
  1. 顶点着色器
    • 顶点着色器将纹理坐标传递给片段着色器。
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aColor;
layout(location = 2) in vec2 aTexCoord;

out vec3 ourColor;
out vec2 TexCoord;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    ourColor = aColor;
    TexCoord = aTexCoord;
}
``

### 片段着色器

片段着色器的主要职责是根据传入的纹理坐标从纹理中采样颜色，并将其应用到片段上。以下是片段着色器的完整代码示例：

```glsl
#version 330 core
out vec4 FragColor;

in vec3 ourColor;
in vec2 TexCoord;

uniform sampler2D textureSampler;

void main() {
    // 从纹理中采样颜色
    vec4 sampledColor = texture(textureSampler, TexCoord);
    // 将采样的颜色与顶点颜色混合
    FragColor = sampledColor * vec4(ourColor, 1.0);
}

解释

  1. 输入变量：

    • in vec3 ourColor;：从顶点着色器传递过来的顶点颜色。
    • in vec2 TexCoord;：从顶点着色器传递过来的纹理坐标。

  2. 输出变量：

    • out vec4 FragColor;：片段的最终颜色，将输出到帧缓冲区。

  3. 统一变量：

    • uniform sampler2D textureSampler;：纹理采样器，用于在片段着色器中访问绑定的纹理。

  4. 采样纹理颜色：

    • vec4 sampledColor = texture(textureSampler, TexCoord);：使用 texture 函数从纹理中采样颜色，TexCoord 是纹理坐标。

  5. 混合颜色：

    • FragColor = sampledColor * vec4(ourColor, 1.0);：将采样的纹理颜色与顶点颜色混合，得到片段的最终颜色。

纹理映射的完整流程

  1. 加载和创建纹理：

    • 从文件中加载纹理数据，并将其上传到GPU，生成纹理对象。

  2. 设置纹理参数：

    • 设置纹理的过滤方式和环绕方式，以控制纹理在不同情况下的表现。

  3. 绑定纹理：

    • 在渲染之前，将纹理绑定到指定的纹理单元，并将纹理单元传递给片段着色器。

  4. 顶点数据中包含纹理坐标：

    • 在顶点数据中包含纹理坐标（UV坐标），这些坐标用于在片段着色器中查找纹理颜色。

  5. 顶点着色器传递纹理坐标：

    • 顶点着色器将纹理坐标传递给片段着色器。

  6. 片段着色器采样纹理颜色：

    • 片段着色器使用传递过来的纹理坐标从纹理中采样颜色，并将其应用到片段上。

示例代码

以下是一个完整的示例代码，展示了如何在OpenGL中实现纹理映射：

// 顶点着色器代码
const char* vertexShaderSource = R"(
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aColor;
layout(location = 2) in vec2 aTexCoord;

out vec3 ourColor;
out vec2 TexCoord;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    ourColor = aColor;
    TexCoord = aTexCoord;
}
)";

// 片段着色器代码
const char* fragmentShaderSource = R"(
#version 330 core
out vec4 FragColor;

in vec3 ourColor;
in vec2 TexCoord;

uniform sampler2D textureSampler;

void main() {
    vec4 sampledColor = texture(textureSampler, TexCoord);
    FragColor = sampledColor * vec4(ourColor, 1.0);
}
)";

// 加载纹理
GLuint textureID;
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);

// 加载纹理数据（例如使用stb_image库）
int width, height, nrChannels;
unsigned char *data = stbi_load("path/to/texture.jpg", &width, &height, &nrChannels, 0);
if (data) {
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    glGenerateMipmap(GL_TEXTURE_2D);
} else {
    std::cerr << "Failed to load texture" << std::endl;
}
stbi_image_free(data);

// 设置纹理参数
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);

// 创建和编译着色器程序
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);

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

glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

// 设置顶点数据和缓冲区，并配置顶点属性
float vertices[] = {
    // 位置          // 颜色           // 纹理坐标
    0.5f,  0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f, // 右上
    0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f, // 右下
   -0.5f, -0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f, // 左下
   -0.5f,  0.5f, 0.0f,  1.0f, 1.0f, 0.0f,  0.0f, 1.0f  // 左上
};
unsigned int indices[] = {
    0, 1, 3, // 第一个三角形
    1, 2, 3  // 第二个三角形
};

GLuint VBO, VAO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

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

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

// 位置属性
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// 颜色属性
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);
// 纹理坐标属性
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
glEnableVertexAttribArray(2);

// 渲染循环
while (!glfwWindowShouldClose(window)) {
    // 输入处理
    processInput(window);

    // 渲染指令
    glClear(GL_COLOR_BUFFER_BIT);

    // 绑定纹理
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureID);

    // 使用着色器程序
    glUseProgram(shaderProgram);

    // 绘制物体
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

    // 交换缓冲区和轮询IO事件
    glfwSwapBuffers(window);
    glfwPollEvents();
}

// 释放资源
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
glDeleteProgram(shaderProgram);
glDeleteTextures(1, &textureID);

// 终止GLFW
glfwTerminate();

完整示例代码

以下是一个完整的示例代码，展示了如何在OpenGL中实现纹理映射：

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

// 回调函数，用于调整窗口大小
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

// 处理输入
void processInput(GLFWwindow *window) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

int main() {
    // 初始化GLFW
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // 创建窗口
    GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
    if (window == NULL) {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // 初始化GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cerr << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // 顶点着色器代码
    const char* vertexShaderSource = R"(
    #version 330 core
    layout(location = 0) in vec3 aPos;
    layout(location = 1) in vec3 aColor;
    layout(location = 2) in vec2 aTexCoord;

    out vec3 ourColor;
    out vec2 TexCoord;

    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;

    void main() {
        gl_Position = projection * view * model * vec4(aPos, 1.0);
        ourColor = aColor;
        TexCoord = aTexCoord;
    }
    )";

    // 片段着色器代码
    const char* fragmentShaderSource = R"(
    #version 330 core
    out vec4 FragColor;

    in vec3 ourColor;
    in vec2 TexCoord;

    uniform sampler2D textureSampler;

    void main() {
        vec4 sampledColor = texture(textureSampler, TexCoord);
        FragColor = sampledColor * vec4(ourColor, 1.0);
    }
    )";

    // 加载纹理
    GLuint textureID;
    glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);

    // 加载纹理数据（例如使用stb_image库）
    int width, height, nrChannels;
    unsigned char *data = stbi_load("path/to/texture.jpg", &width, &height, &nrChannels, 0);
    if (data) {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    } else {
        std::cerr << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);

    // 设置纹理参数
    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);

    // 创建和编译着色器程序
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glCompileShader(fragmentShader);

    // 检查编译错误
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }

    // 链接着色器程序
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    // 检查链接错误
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }

    // 删除着色器对象
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // 设置顶点数据和缓冲区，并配置顶点属性
    float vertices[] = {
        // 位置          // 颜色           // 纹理坐标
        0.5f,  0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f, // 右上
        0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f, // 右下
       -0.5f, -0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f, // 左下
       -0.5f,  0.5f, 0.0f,  1.0f, 1.0f, 0.0f,  0.0f, 1.0f  // 左上
    };
    unsigned int indices[] = {
        0, 1, 3, // 第一个三角形
        1, 2, 3  // 第二个三角形
    };

    GLuint VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

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

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // 位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // 颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    // 纹理坐标属性
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2);

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        // 输入处理
        processInput(window);

        // 渲染指令
        glClear(GL_COLOR_BUFFER_BIT);

        // 绑定纹理
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textureID);

        // 使用着色器程序
        glUseProgram(shaderProgram);

        // 绘制物体
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        // 交换缓冲区和轮询IO事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 释放资源
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);
    glDeleteProgram(shaderProgram);
    glDeleteTextures(1, &textureID);

    // 终止GLFW
    glfwTerminate();
    return 0;
}

完整示例代码

以下是完整的示例代码，展示了如何在OpenGL中实现纹理映射：

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

// 回调函数，用于调整窗口大小
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

// 处理输入
void processInput(GLFWwindow *window) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

int main() {
    // 初始化GLFW
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // 创建窗口
    GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
    if (window == NULL) {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // 初始化GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cerr << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // 顶点着色器代码
    const char* vertexShaderSource = R"(
    #version 330 core
    layout(location = 0) in vec3 aPos;
    layout(location = 1) in vec3 aColor;
    layout(location = 2) in vec2 aTexCoord;

    out vec3 ourColor;
    out vec2 TexCoord;

    void main() {
        gl_Position = vec4(aPos, 1.0);
        ourColor = aColor;
        TexCoord = aTexCoord;
    }
    )";

    // 片段着色器代码
    const char* fragmentShaderSource = R"(
    #version 330 core
    out vec4 FragColor;

    in vec3 ourColor;
    in vec2 TexCoord;

    uniform sampler2D textureSampler;

    void main() {
        vec4 sampledColor = texture(textureSampler, TexCoord);
        FragColor = sampledColor * vec4(ourColor, 1.0);
    }
    )";

    // 加载纹理
    GLuint textureID;
    glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);

    // 加载纹理数据（例如使用stb_image库）
    int width, height, nrChannels;
    unsigned char *data = stbi_load("path/to/texture.jpg", &width, &height, &nrChannels, 0);
    if (data) {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    } else {
        std::cerr << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);

    // 设置纹理参数
    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);

    // 创建和编译着色器程序
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    GLuint fragmentShader = glCreateShader
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);

    // 检查编译错误
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }

    // 链接着色器程序
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    // 检查链接错误
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }

    // 删除着色器对象
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // 设置顶点数据和缓冲区，并配置顶点属性
    float vertices[] = {
        // 位置          // 颜色           // 纹理坐标
        0.5f,  0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f, // 右上
        0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f, // 右下
       -0.5f, -0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f, // 左下
       -0.5f,  0.5f, 0.0f,  1.0f, 1.0f, 0.0f,  0.0f, 1.0f  // 左上
    };
    unsigned int indices[] = {
        0, 1, 3, // 第一个三角形
        1, 2, 3  // 第二个三角形
    };

    GLuint VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

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

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // 位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // 颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    // 纹理坐标属性
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2);

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        // 输入处理
        processInput(window);

        // 渲染指令
        glClear(GL_COLOR_BUFFER_BIT);

        // 绑定纹理
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textureID);

        // 使用着色器程序
        glUseProgram(shaderProgram）
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        // 交换缓冲区和轮询IO事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 释放资源
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);
    glDeleteProgram(shaderProgram);
    glDeleteTextures(1, &textureID);

    // 终止GLFW
    glfwTerminate();
    return 0;
}
你一身傲骨怎能输
关注
专栏目录
Unity中，渲染管线（Rendering Pipeline）
听老罗娓娓道来
07-15 126
在Unity中，Shader是定义物体表面外观（如颜色、亮度等）的程序。通过编写自定义Shader，你可以控制GPU如何渲染物体的每一个像素。return o;ENDCG这个Shader非常基础，它仅仅将物体渲染为单一颜色。Shader Graph是Unity提供的一个可视化工具，允许你无需编写代码即可创建复杂的Shader。
浅谈 GPU图形固定渲染管线
weixin_34077371的博客
07-13 395
图形渲染管道被认为是实时图形渲染的核心，简称为管道。管道的主要功能是由给定的虚拟摄像机、三维物体、灯源、光照模型、纹理贴图或其他来产生或渲染一个二维图像。由此可见，渲染管线是实时渲染技术的底层工具。图像中物体的位置及形状是通过它们的几何描述、环境特征、以及该环境中虚拟摄像机的摆放位置来决定的。物体的外观受到了材质属性、灯源、贴图以及渲染模式（sharding modles）的影响。 很多计算机图...
【Unity】Unity Shader学习笔记（二）渲染管线
一个普普通通的游戏开发者
08-24 3616
渲染管线是将网格、纹理等信息从加载到展现在屏幕上的整个过程，也叫做渲染流水线。是给定坐标系、镜头、物体、纹理、光源等信息后如何呈现为二维画面的流程。这些流程以流水线的方式工作。...
固定渲染管线Shader
Kiboo的博客
12-03 1350
固定渲染管线是标准的几何&光照（T&L）管线，功能是固定的，它控制着世界、视、投影变换及固定光照控制和纹理混合T&L管线可以被渲染状态控制，矩阵，光照及采制参数固定渲染管线一般用于Shader在老显卡无法显示时的Fallback（在Shader的SubShader都无法使用的时候调用）变量小括号写法是固定写法大括号写法是变量写法，可以传一个自定义变量进去Shader "Custom/FixFunc
（转）固定渲染管线与可编程渲染管线
weixin_34117522的博客
01-18 429
1.固定渲染管线与可编程渲染管线的区别：     1）、固定渲染管线 ——这是标准的几何&amp;光照(T&amp;L)管线，功能是固定的，它控制着世界、视、投影变换及固定光照控制和纹理混合。T&amp;L管线可以被渲染状态控制，矩阵，光照和采制参数。     2）、顶点着色器——图形开发人员可以对渲染管线中的顶点运算和像素运算分别进行编程处理了，而无须象以前那样套用一些固定函数，取代设置参数...
图形渲染基础-常用渲染管线介绍
最新发布
Hanson的博客
07-03 1128
常用渲染管线介绍
Inferno：具有可定制的渲染管线的现代GPU驱动的Vulkan渲染器
02-20
总的来说，Inferno是一个利用Vulkan和Nimble技术的现代渲染引擎，它提供了一个强大的平台，让开发者能够实现复杂的图形效果和高效的渲染流程。对于想要提升图形处理能力或者研究渲染技术的程序员来说，Inferno是一个...
Ogre游戏引擎中的渲染管线与渲染优化
Ogre游戏引擎是一个开源的3D图形渲染引擎，采用C++语言编写，旨在为开发人员提供强大的渲染功能和灵活性。其渲染系统构建在现代图形API（如Direct3D和OpenGL）之上，可以支持复杂的渲染效果和技术。Ogre通过模块化的...
Tiny3D:微型 3D 渲染引擎
06-18
Tiny3D虽小，但具备了3D渲染引擎的基本要素，如场景图管理、图形管线、光照处理、纹理映射等。以下是这些要素的详细介绍： 1. 场景图管理：Tiny3D使用一种结构化的数据结构来组织3D对象，这种结构通常称为场景图。...
剖析虚幻渲染体系（14）- 延展篇：现代渲染引擎演变史Part 1（萌芽期）
www_xuhss_com的博客
04-04 5607
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 目录* 14.1 本篇概述 + 14.1.1 游戏引擎简介 + 14.1.2 游戏引擎模块 + 14.1.3 游戏引擎列表 - 14.1.3.1 Unreal Engine - 14.1.3.2 Unity - 14.1.3.3 CryEngine - 14.1.3.4 Doo
unity Shader Lab（cg hlsl glsl）着色器入门教程 以及 vstudio 支持unity shader语法（更新中）
炼丹炉里有煤灰
08-05 1万+
shaderlab 是unity封装了cg hlsl glsl的专有着色器语言。具有跨平台的优点。在unity2018.3.5f以后版本，可以使用图形化工具shader graph来简化shader编程成本。作为unityer最好具有基本的shaderlab编程能力。 shaderlab语法 基本结构 //定义shander在unity中的路径和名称，该名称最好和shader文件名相同。 Shad...
计算机图形渲染管线
gghhb12的博客
07-31 435
光栅化部分的输入是经过变化和投影后的顶点，颜色以及纹理坐标，他的工作是给每个像素正确配色，一遍绘制整幅图形。由于输入的是三角形顶点，所以需要根据三角形表面的差异，逐个遍历三角形计算各个像素的颜色值。好处是模型的顶点信息放进VBO，这样每次画模型时，数据不在从CPU的势力范围内存里取，而是直接从GPU的显存里取，从而提高效率。VAO（Vertex Array Object）顶点数组对象，是一个保存了所有顶点数据属性的状态组合，它存储了顶点数据的格式以及顶点数据所需要的VBO对象的引用。与OpenGL的通信。
渲染管线概论
jkkk_的博客
09-21 790
渲染管线（渲染流水线）是将三维场景模型转换到屏幕像素空间输出的过程。图形渲染管线主要包括两个功能：一是将物体3D坐标转变为屏幕空间2D坐标，二是为屏幕每个像素点进行着色。
【OpenGL ES】渲染管线
little_fat_sheep
09-09 5518
渲染管线是指：将模型的顶点序列、颜色系列、纹理序列、法线序列等数据输入到 OpenGL ES 中，到输出屏幕，这个阶段数据所经历的流程。裁剪：进行透视分割，并剔除视锥体外面的顶点，根据 x, y, z 的值是否在 [-1, 1] 之间判断是否淘汰顶点； 屏幕映射：根据视口（Viewport）大小，将近平面上的点映射到屏幕上 图元装配：根绝输入顶点序列和和图元类型（mode）组装图元； 光栅化：对图元内部进行插值，使其与屏幕中的像素一一对应； 裁剪测试：指定一个矩形的剪裁区域，当启用剪裁测试后，只有在这个区域
固定渲染管线与可编程渲染管线
ccsu_deer
03-25 459
【前言】 前面从0开始学计算机图形学（参考倪明亮， 吴良芝编著的书）了解了基本的图形变换和公式推导、投影、Gouraud光照模式 参考b站视频学会下用OpenGL写相关代码。基本上对光滑着色（Gouraud）、深度缓存、透明处理、纹理映射有了更深刻的了解，画一些简单的图形还是可以的。 后面看其他博客发现了其他方法的写法。经过大量资料查阅才发现 原来是两种绘图方式：固定渲染管线与可编程渲染管线 我之前的代码都属于固定渲染管线 下面继续学习可编程渲染管线是怎么画图的。 【参考资料】 Op...
固定渲染管线流程
bbing_的博客
12-28 984
渲染管线是指为了在显示器上显示图像而经过的一系列必要操作，具体流程如下： 1、自身坐标系 在自身坐标系中建模不像在世界坐标系中要考虑本物体相对于其他物体的位置、大小、方向关系。 2、世界坐标系 一旦我们构造了各种模型，它们都在自己的自身坐标系中，但是我们需要把它们都放到同一个世界坐标系中。物体从自身坐标系到世界坐标系中的变换叫做世界变换。世界变换通常是用平移、旋转、缩放操作来设置模型...
【GLSL教程】（一）图形流水线
热门推荐
racehorse的专栏
07-08 7万+
这是一些列来自lighthouse3d的GLSL教程，非常适合入门。我将边学习边翻译该教程的内容，同时记录在这里，方便以后查询。流水线概述下图描述了一个简化的图形处理流水线，虽然简略但仍然可以展示着色器编程（shader programming）的一些重要概念。一个固定流水线包括
图形学（1）固定功能管线
nate的专栏
06-06 2514
转自：孤舟博客 首先要知道几个OpenGL的术语 渲染(rendering)：计算机根据模型(model)创建图像的过程。模型(model)：根据几何图元创建的物体(object)。几何图元：包括点、直线和多边形等，它是通过顶点(vertex)指定的。 最终完成了渲染的图像是由在屏幕上绘制的像素组成的。在内存中，和像素有关的信息（如像素的颜色）组织成位平面的形式，位平面是一块内存区域，保存了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值