OpenGL异步渲染架构

在OpenGL异步渲染的架构中，逻辑线程和渲染线程的分离可以有效提高渲染性能和响应速度。

1. 线程架构

• 逻辑线程：负责游戏逻辑、输入处理、场景更新等。所有与渲染相关的API调用都在这个线程中进行。
• 渲染线程：专门处理渲染命令的执行和DrawCall的解析。它从逻辑线程接收渲染命令并进行实际的OpenGL绘制。

2. 渲染命令和CommandBuffer

为了实现渲染命令的抽象，可以定义一个RenderCommand类或结构体，包含必要的渲染信息，例如：

struct RenderCommand {
    GLenum primitiveType; // 绘制的基本图元类型
    GLuint vertexArray;   // 顶点数组对象
    GLsizei vertexCount;  // 顶点数量
    // 其他渲染参数...
};

然后，创建一个CommandBuffer类来管理这些渲染命令：

class CommandBuffer {
public:
    void AddCommand(const RenderCommand& command) {
        std::lock_guard<std::mutex> lock(mutex_);
        commands_.push_back(command);
    }

    void Clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        commands_.clear();
    }

    const std::vector<RenderCommand>& GetCommands() {
        return commands_;
    }

private:
    std::vector<RenderCommand> commands_;
    std::mutex mutex_; // 保护命令列表的互斥锁
};

3. 信号量的使用

使用信号量来同步逻辑线程和渲染线程的执行。可以使用C++11的std::semaphore（如果可用）或其他信号量实现。初始化时，渲染信号量的初始值为1，逻辑信号量的初始值为0。

std::semaphore renderSemaphore(1); // 渲染信号量
std::semaphore logicSemaphore(0);   // 逻辑信号量

4. 渲染流程

在逻辑线程中，渲染命令的提交和数据交换可以如下进行：

void LogicThread() {
    while (running) {
        // 更新游戏逻辑...

        // 提交渲染命令
        RenderCommand command;
        // 填充command...
        commandBuffer.AddCommand(command);

        // 通知渲染线程
        logicSemaphore.release();
        renderSemaphore.acquire(); // 等待渲染线程完成
    }
}

在渲染线程中，执行渲染命令的流程如下：

void RenderThread() {
    while (running) {
        logicSemaphore.acquire(); // 等待逻辑线程提交命令

        // 获取并执行渲染命令
        const auto& commands = commandBuffer.GetCommands();
        for (const auto& command : commands) {
            // 执行OpenGL绘制命令
            glBindVertexArray(command.vertexArray);
            glDrawArrays(command.primitiveType, 0, command.vertexCount);
        }

        commandBuffer.Clear(); // 清空命令缓冲区

        // 通知逻辑线程可以继续
        renderSemaphore.release();
    }
}

6. 渲染资源管理

在异步渲染架构中，渲染资源（如纹理、着色器、缓冲区等）的管理也需要考虑线程安全。可以使用一个资源管理器来集中管理这些资源，并确保在逻辑线程和渲染线程之间的安全访问。

6.1 资源管理器示例

class ResourceManager {
public:
    GLuint LoadTexture(const std::string& filePath) {
        std::lock_guard<std::mutex> lock(mutex_);
        // 加载纹理并生成OpenGL纹理ID
        GLuint textureID;
        // ... 加载纹理的代码
        return textureID;
    }

    void ReleaseTexture(GLuint textureID) {
        std::lock_guard<std::mutex> lock(mutex_);
        // 释放OpenGL纹理
        glDeleteTextures(1, &textureID);
    }

private:
    std::mutex mutex_; // 保护资源访问的互斥锁
};

7. 性能优化

在异步渲染中，有几个方面可以进行性能优化：

7.1 批处理渲染

尽量将相同类型的渲染命令合并成一个批次进行渲染，以减少状态切换和DrawCall的数量。例如，可以在逻辑线程中收集相同材质的物体，并在渲染线程中一次性绘制它们。

7.2 减少数据传输

在逻辑线程和渲染线程之间传输数据时，尽量减少数据的复制和传输量。可以使用指针或引用来传递数据，或者使用共享内存的方式。

7.3 使用双缓冲

可以考虑使用双缓冲的方式来存储渲染命令。一个缓冲区用于逻辑线程提交命令，另一个缓冲区用于渲染线程执行命令。这样可以减少线程之间的竞争。

8. 错误处理

在多线程环境中，错误处理变得更加复杂。需要确保在逻辑线程和渲染线程中都能正确捕获和处理错误。

8.1 OpenGL错误检查

在渲染线程中，执行OpenGL命令后，应该检查OpenGL的错误状态：

void CheckOpenGLError() {
    GLenum error = glGetError();
    if (error != GL_NO_ERROR) {
        // 处理错误
        std::cerr << "OpenGL Error: " << error << std::endl;
    }
}

8.2 逻辑线程中的异常处理

在逻辑线程中，确保在提交渲染命令时捕获异常，并适当处理：

try {
    // 提交渲染命令
    commandBuffer.AddCommand(command);
} catch (const std::exception& e) {
    std::cerr << "Error in Logic Thread: " << e.what() << std::endl;
}

9. 可能遇到的问题

在实现异步渲染时，可能会遇到以下问题：

9.1 资源竞争

确保在访问共享资源时使用互斥锁，避免数据竞争和不一致性。

9.2 死锁

在使用多个互斥锁时，注意锁的顺序，避免死锁的发生。

9.3 性能瓶颈

监测逻辑线程和渲染线程的性能，确保没有某一线程成为瓶颈。可以使用性能分析工具来识别问题。

10. 总结

通过将渲染逻辑与渲染执行分离，利用多线程的优势，可以显著提高渲染性能。合理管理渲染资源、优化渲染流程、处理错误和潜在问题是实现高效异步渲染的关键。

渲染参数分类

1. 渲染参数分类

1.1 独占参数

这些参数是每个DrawCall独有的，通常在每个DrawCall中进行设置。这些参数包括：

• VertexBuffer：每个DrawCall使用的顶点缓冲区，包含顶点数据。
• IndexBuffer：每个DrawCall使用的索引缓冲区，定义了如何从顶点缓冲区中提取顶点。
• Model矩阵：用于将模型空间的顶点转换到世界空间的矩阵。
• 材质参数：如纹理、颜色等特定于该DrawCall的材质属性。

1.2 共享参数

这些参数在多个DrawCall之间共享，通常在渲染过程中只需设置一次，或者在每帧更新时设置一次。这些参数包括：

• Viewport参数：定义渲染区域的大小和位置。
• 相机参数：如视图矩阵和投影矩阵，通常在每帧更新时设置。
• 光源参数：如光源位置、颜色等，可能在多个DrawCall中使用。

1.3 全局参数

这些参数是所有DrawCall共享的，通常在程序启动时设置一次，或者在全局状态变化时更新。这些参数包括：

• 全局Uniform：如全局光照、环境光、全局材质属性等。
• 时间参数：如时间步长、动画时间等。

2. 渲染参数管理

为了有效管理这些渲染参数，可以设计一个渲染状态管理器。这个管理器可以负责存储和更新不同类型的渲染参数。

2.1 渲染状态管理器示例

class RenderState {
public:
    void SetViewport(int x, int y, int width, int height) {
        viewport_ = {x, y, width, height};
        glViewport(x, y, width, height);
    }

    void SetCamera(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
        viewMatrix_ = viewMatrix;
        projectionMatrix_ = projectionMatrix;
        // 更新相机Uniform
        glUniformMatrix4fv(viewMatrixLocation_, 1, GL_FALSE, glm::value_ptr(viewMatrix_));
        glUniformMatrix4fv(projectionMatrixLocation_, 1, GL_FALSE, glm::value_ptr(projectionMatrix_));
    }

    void SetGlobalUniform(const std::string& name, const glm::vec3& value) {
        glUniform3fv(GetUniformLocation(name), 1, glm::value_ptr(value));
    }

    // 其他设置函数...

private:
    struct Viewport {
        int x, y, width, height;
    } viewport_;

    glm::mat4 viewMatrix_;
    glm::mat4 projectionMatrix_;

    GLint GetUniformLocation(const std::string& name) {
        // 获取Uniform位置的逻辑
    }
};

3. DrawCall的实现

在执行DrawCall时，可以根据参数的类型来设置相应的状态。以下是一个简单的DrawCall实现示例：

void RenderMesh(const Mesh& mesh, const RenderState& renderState) {
    // 设置独占参数
    glBindBuffer(GL_ARRAY_BUFFER, mesh.vertexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.indexBuffer);
    
    // 设置顶点属性指针
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
    glEnableVertexAttribArray(0);
    
    // 设置模型矩阵
    glUniformMatrix4fv(modelMatrixLocation_, 1, GL_FALSE, glm::value_ptr(mesh.modelMatrix));
    
    // 执行DrawCall
    glDrawElements(GL_TRIANGLES, mesh.indexCount, GL_UNSIGNED_INT, 0);
}

4. 渲染流程

在渲染流程中，可以按照以下步骤进行：

1. 更新全局参数：在每帧开始时更新全局Uniform和共享参数。
2. 设置共享参数：设置视口、相机等共享参数。
3. 遍历DrawCall：遍历所有的DrawCall，设置独占参数并执行渲染。

void RenderFrame(const std::vector<Mesh>& meshes, RenderState& renderState) {
    // 更新全局参数
    renderState.SetGlobalUniform("globalLight", glm::vec3(1.0f, 1.0f, 1.0f));
    
    // 设置共享参数
    renderState.SetViewport(0, 0, windowWidth, windowHeight);
    renderState.SetCamera(viewMatrix, projectionMatrix);
    
    // 渲染每个Mesh
    for (const auto& mesh : meshes) {
        RenderMesh(mesh, renderState);
    }
}

全局共享参数比较少，也比较好理解，这里着重讨论前两种分类。

第一种分类很自然的抽象出一个DrawCall数据结构，基本定义如下：

typedef struct {
Handle vertexBuffer;
} Stream;

typedef struct {
Stream streams[BCFX_CONFIG_MAX_VERTEX_STREAMS]; // 支持多个顶点缓冲
uint8_t streamMask;

Handle indexBuffer;

Mat4x4 model; // 模型矩阵（ModelToWorld）

/* 其他渲染参数、渲染状态 */
} RenderDraw;
对于第二种分类，参数需要给多个DrawCall共享，那我们抽象出一个概念，称为View。一个View附带一系列参数，每个DrawCall都隶属于某个View。如此以来，渲染过程该DrawCall就使用对应View的参数来进行渲染。View结构基本定义如下：

typedef struct {
/* … */

Clear clear; // 该View的Clear参数
Rect rect; // Viewport范围
Rect scissor; // 2D裁剪范围
Mat4x4 viewMat; // 相机空间矩阵（WorldToCamera）
Mat4x4 projMat; // 投影矩阵（CameraToClip）

/* 其他参数 */
} View;
DrawCall和View两个抽象层次是bcfx渲染库设计的基础，后续逻辑线程提交DrawCall都需要指定一个View。为了逻辑简单，我们直接定下来仅支持256个View，相关数据结构可设计为固定大小的数组，无需动态扩容。

在渲染系统中，合理地组织和管理渲染参数是至关重要的。以下是对这两个结构的详细分析，以及如何在渲染流程中使用它们的建议。

1. RenderDraw 结构

RenderDraw 结构用于表示一个具体的 DrawCall，包含了该 DrawCall 所需的所有独占参数。以下是对 RenderDraw 结构的详细定义和说明：

typedef struct {
    Handle vertexBuffer; // 顶点缓冲区句柄
} Stream;

typedef struct {
    Stream streams[BCFX_CONFIG_MAX_VERTEX_STREAMS]; // 支持多个顶点缓冲
    uint8_t streamMask; // 有效的流掩码

    Handle indexBuffer; // 索引缓冲区句柄

    Mat4x4 model; // 模型矩阵（ModelToWorld）

    // 其他渲染参数、渲染状态
    // 例如：材质、着色器句柄、混合状态等
} RenderDraw;

1.1 说明

• Stream：表示一个顶点流，允许支持多个顶点缓冲区。streamMask 用于指示哪些流是有效的。
• vertexBuffer 和 indexBuffer：分别用于存储顶点和索引数据的缓冲区句柄。
• model：用于存储模型的变换矩阵，将模型空间的顶点转换到世界空间。

2. View 结构

View 结构用于表示一组共享的渲染参数，多个 DrawCall 可以共享同一个 View。以下是对 View 结构的详细定义和说明：

typedef struct {
    Clear clear; // 该 View 的清除参数
    Rect rect; // Viewport 范围
    Rect scissor; // 2D 裁剪范围
    Mat4x4 viewMat; // 相机空间矩阵（WorldToCamera）
    Mat4x4 projMat; // 投影矩阵（CameraToClip）

    // 其他参数
    // 例如：光源信息、全局 Uniform 等
} View;

2.1 说明

• clear：定义了在渲染之前需要清除的缓冲区（如颜色、深度等）。
• rect：定义了视口的范围，决定了渲染输出的区域。
• scissor：定义了2D裁剪范围，限制了渲染的区域。
• viewMat 和 projMat：分别表示相机的视图矩阵和投影矩阵，用于将世界空间的坐标转换到裁剪空间。

3. 渲染流程

在渲染过程中，逻辑线程需要提交 DrawCall，并指定一个 View。以下是一个简单的渲染流程示例：

void SubmitDrawCall(RenderDraw drawCall, uint8_t viewIndex) {
    // 将 DrawCall 添加到指定的 View 中
    if (viewIndex < MAX_VIEWS) {
        views[viewIndex].drawCalls.push_back(drawCall);
    }
}

void RenderFrame() {
    for (uint8_t i = 0; i < MAX_VIEWS; ++i) {
        View& view = views[i];

        // 设置视口和裁剪范围
        glViewport(view.rect.x, view.rect.y, view.rect.width, view.rect.height);
        glScissor(view.scissor.x, view.scissor.y, view.scissor.width, view.scissor.height);

        // 清除缓冲区
        glClear(view.clear.color | view.clear.depth);

        // 设置相机矩阵
        glUniformMatrix4fv(viewMatrixLocation, 1, GL_FALSE, glm::value_ptr(view.viewMat));
        glUniformMatrix4fv(projectionMatrixLocation, 1, GL_FALSE, glm::value_ptr(view.projMat));

        // 渲染该 View 中的所有 DrawCall
        for (const RenderDraw& drawCall : view.drawCalls) {
            // 绑定顶点和索引缓冲区
            glBindBuffer(GL_ARRAY_BUFFER, drawCall.streams[0].vertexBuffer);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, drawCall.indexBuffer);

            // 设置模型矩阵
            glUniformMatrix4fv(modelMatrixLocation, 1, GL_FALSE, glm::value_ptr(drawCall.model));

            // 执行 DrawCall
            glDrawElements(GL_TRIANGLES, drawCall.indexCount, GL_UNSIGNED_INT, 0);
        }

        // 清空该 View 的 DrawCall 列表
        view.drawCalls.clear();
    }
}

4. 总结

通过将渲染参数分为独占参数和共享参数，并使用 RenderDraw 和 View 结构进行管理，可以有效地组织渲染过程。这种设计不仅提高了渲染的灵活性和可扩展性，还能减少状态切换和提高性能。

资源管理

在渲染系统中，资源管理是一个关键的组成部分，尤其是在多线程环境下，逻辑线程和渲染线程之间的协作显得尤为重要。你提到的流程清晰地描述了如何在逻辑线程中准备和使用渲染资源，并将其传递给渲染线程进行实际渲染。以下是对这个流程的详细分析，以及如何设计一套有效的渲染资源管理结构。

1. 渲染资源管理的基本结构

为了有效管理渲染资源，我们需要设计一个资源管理器，它能够处理资源的创建、引用、使用和销毁。以下是一个可能的资源管理结构的设计：

typedef enum {
    RESOURCE_TYPE_VERTEX_BUFFER,
    RESOURCE_TYPE_INDEX_BUFFER,
    RESOURCE_TYPE_SHADER,
    // 其他资源类型
} ResourceType;

typedef struct {
    ResourceType type; // 资源类型
    Handle handle;     // 资源句柄
    // 其他资源相关信息
} Resource;

typedef struct {
    Resource* resources; // 资源数组
    size_t resourceCount; // 当前资源数量
    size_t resourceCapacity; // 资源容量
} ResourceManager;

2. 资源创建和使用流程

根据你提供的流程，我们可以将其细化为以下步骤：

2.1 逻辑线程准备数据

逻辑线程准备渲染所需的数据，例如顶点数据、着色器源码等。

2.2 调用 API 创建资源

逻辑线程调用 bcfx 的 API，传入数据以创建对应的渲染资源。此时，bcfx 将数据打包成命令，放入 CommandBuffer 中。

Handle CreateVertexBuffer(const VertexData* data, size_t size) {
    // 将数据打包到 CommandBuffer 中
    Command command;
    command.type = COMMAND_CREATE_VERTEX_BUFFER;
    command.data.vertexBuffer.data = data;
    command.data.vertexBuffer.size = size;

    // 将命令添加到 CommandBuffer
    AddCommandToBuffer(command);

    // 返回一个资源句柄（引用）
    return GenerateHandle();
}

2.3 使用资源进行渲染

逻辑线程使用返回的引用（句柄）进行渲染操作，提交 DrawCall 到 View。

void SubmitDrawCall(RenderDraw drawCall, Handle vertexBufferHandle) {
    drawCall.streams[0].vertexBuffer = vertexBufferHandle;
    // 将 DrawCall 添加到指定的 View 中
    views[currentViewIndex].drawCalls.push_back(drawCall);
}

2.4 结束帧逻辑

逻辑线程调用 bcfx 的 apiFrame 结束当前帧的逻辑。此时，bcfx 将等待上一帧的渲染完成，并将 CommandBuffer 和 DrawCall 列表交给渲染线程。

void apiFrame() {
    // 等待渲染线程完成上一帧的渲染
    WaitForRenderThread();

    // 提交 CommandBuffer 和 DrawCall 列表
    SubmitCommandsToRenderThread(commandBuffer, drawCallList);
    
    // 清空当前帧的命令和 DrawCall 列表
    ClearCommandBuffer();
    ClearDrawCallList();
}

3. 渲染线程处理资源

在渲染线程中，实际的资源创建和渲染操作会在 apiFrame 被调用后执行。渲染线程会从 CommandBuffer 中提取命令并执行。

void RenderThread() {
    while (running) {
        // 等待新的命令
        WaitForNewCommands();

        // 处理 CommandBuffer 中的命令
        for (const Command& command : commandBuffer) {
            switch (command.type) {
                case COMMAND_CREATE_VERTEX_BUFFER:
                    CreateVertexBufferInGPU(command.data.vertexBuffer.data, command.data.vertexBuffer.size);
                    break;
                // 处理其他命令
            }
        }

        // 渲染 DrawCall 列表
        for (const RenderDraw& drawCall : drawCallList) {
            RenderDrawCall(drawCall);
        }

        // 清空命令和 DrawCall 列表
        ClearCommandBuffer();
        ClearDrawCallList();
    }
}

4. 资源管理的注意事项

• 资源引用计数：为了避免资源在使用过程中被销毁，可以实现引用计数机制。当资源的引用计数为零时，才可以安全地释放资源。
• 资源重用：在资源管理中，可以考虑实现资源重用机制，以减少内存分配和释放的开销。
• 异步加载：对于较大的资源（如纹理、模型等），可以考虑异步加载，以避免在渲染过程中造成阻塞。

5. 总结

通过设计一个清晰的资源管理结构和流程，可以有效地管理渲染资源，确保逻辑线程和渲染线程之间的高效协作。

渲染线程

在渲染线程的设计中，确保高效的资源管理和渲染流程是至关重要的。你提供的代码和结构清晰地展示了如何通过命令模式来管理渲染资源，并通过渲染器接口与OpenGL进行交互。以下是对你所描述的渲染线程实现的详细分析和补充。

1. 渲染线程的职责

渲染线程的主要职责可以总结为以下几点：

• 管理渲染资源：包括创建、更新和销毁渲染资源。
• 提交DrawCall：使用已创建的渲染资源来渲染物体。
• 与逻辑线程同步：确保渲染线程在逻辑线程准备好数据后再进行渲染。

2. 渲染命令的结构

你定义的命令结构体 Command 和命令缓冲区 CommandBuffer 是实现渲染资源管理的基础。通过将渲染操作封装为命令，可以实现逻辑线程与渲染线程之间的解耦。

typedef enum {
    COMMAND_CREATE_VERTEX_BUFFER,
    COMMAND_UPDATE_VERTEX_BUFFER,
    COMMAND_DESTROY_VERTEX_BUFFER,
    // 其他命令类型
    COMMAND_END
} CommandType;

typedef union {
    struct {
        VertexBufferGL buffer;
        const void* data;
        size_t size;
    } createVertexBuffer;
    struct {
        VertexBufferGL buffer;
        const void* data;
        size_t size;
    } updateVertexBuffer;
    struct {
        VertexBufferGL buffer;
    } destroyVertexBuffer;
    // 其他命令参数
} CommandParam;

typedef struct {
    CommandType type;
    CommandParam param;
} Command;

typedef struct {
    uint32_t count;
    uint32_t size;
    Command* buffer;
} CommandBuffer;

3. 渲染线程的执行流程

在 ctx_renderFrame 函数中，渲染线程的执行流程如下：

1. 等待逻辑线程信号：通过信号量机制，确保逻辑线程已经准备好数据。
2. 开始渲染帧：调用 beginFrame 函数，进行必要的状态设置。
3. 执行渲染命令：处理命令缓冲区中的创建和更新命令。
4. 提交DrawCall：调用 submit 函数，将DrawCall提交给OpenGL进行渲染。
5. 处理销毁命令：执行命令缓冲区中的销毁命令。
6. 结束渲染帧：调用 endFrame 函数，进行必要的清理。
7. 发出渲染完毕信号：通知逻辑线程渲染已完成。
8. 交换缓冲区：调用 flip 函数，将渲染结果显示到屏幕上。

4. 渲染器的初始化与关闭

在渲染线程启动时，首先需要初始化渲染器。初始化过程包括设置OpenGL上下文和加载OpenGL函数指针。

static void _renderThreadStart(void* arg) {
    Context* ctx = (Context*)arg;
    RendererContext* renderCtx = ctx->renderCtx;
    CALL_RENDERER(init, ctx->mainWin); // 初始化渲染器

    // 设置OpenGL上下文
    winctx_makeContextCurrent(glCtx->mainWin);
    if (!gladLoadGLLoader((GLADloadproc)winctx_getProcAddress)) {
        printf("Failed to initialize GLAD");
        exit(-1);
    }

    while (ctx->running) {
        ctx_renderFrame(ctx); // 渲染一帧
    }
    CALL_RENDERER(shutdown); // 关闭渲染器
}

在渲染线程结束时，调用 shutdown 函数以销毁所有GPU资源，确保没有内存泄漏。

5. 资源管理的注意事项

• 资源的生命周期管理：确保在资源不再使用时及时销毁，避免内存泄漏。
• 多线程安全：在逻辑线程和渲染线程之间传递命令时，确保对命令缓冲区的访问是线程安全的。
• 性能优化：可以考虑批处理渲染命令，以减少与GPU的交互次数，提高渲染性能。

6. 总结

通过将渲染资源管理和DrawCall提交封装为命令，并通过渲染器接口与OpenGL进行交互，渲染线程能够高效地执行渲染任务。

着色器（Shader）

在OpenGL中，着色器（Shader）是实现图形渲染的核心组件。它们允许开发者自定义如何处理顶点和片段数据，从而实现各种视觉效果。你提供的代码片段展示了如何创建和编译着色器，以及如何将其与程序（Program）关联。以下是对你所描述的着色器实现的详细分析和补充。

1. 着色器类型定义

首先，你定义了一个枚举类型 bcfx_EShaderType，用于区分顶点着色器和片段着色器：

typedef enum {
    ST_Vertex,
    ST_Fragment,
} bcfx_EShaderType;

2. 创建着色器和程序的API

你提供了两个API函数，用于创建着色器和程序：

BCFX_API Handle bcfx_createShader(luaL_MemBuffer* mem, bcfx_EShaderType type);
BCFX_API Handle bcfx_createProgram(Handle vs, Handle fs);

• bcfx_createShader：接受一个内存缓冲区（luaL_MemBuffer）和着色器类型，返回一个句柄（Handle）以标识创建的着色器。
• bcfx_createProgram：接受顶点着色器和片段着色器的句柄，返回一个程序的句柄。

3. 命令缓冲区的使用

在逻辑线程中调用这些API时，实际上是将创建着色器和程序的命令插入到命令缓冲区中。这些命令将在渲染线程中执行，以确保线程安全和资源管理的有效性。

4. 着色器创建的实现

在渲染线程中，着色器的创建逻辑如下：

static void gl_createShader(RendererContext* ctx, Handle handle, luaL_MemBuffer* mem, bcfx_EShaderType type) {
    RendererContextGL* glCtx = (RendererContextGL*)ctx;
    ShaderGL* shader = &glCtx->shaders[handle_index(handle)];
    shader->type = shader_glType[type];
    
    // 创建OpenGL着色器
    GL_CHECK(shader->id = glCreateShader(shader->type));
    
    // 设置着色器源代码
    const GLint length = mem->sz;
    GL_CHECK(glShaderSource(shader->id, 1, (const GLchar* const*)&mem->ptr, &length));
    
    // 编译着色器
    GL_CHECK(glCompileShader(shader->id));

    // 检查编译状态
    GLint success;
    GL_CHECK(glGetShaderiv(shader->id, GL_COMPILE_STATUS, &success));
    if (success == GL_FALSE) {
        GLint logLen = 0;
        GL_CHECK(glGetShaderiv(shader->id, GL_INFO_LOG_LENGTH, &logLen));
        GLchar* infoLog = (GLchar*)alloca(logLen);
        GL_CHECK(glGetShaderInfoLog(shader->id, logLen, NULL, infoLog));
        printf_err("Shader compile error: %s\n", infoLog);
    }
    
    // 释放内存缓冲区
    MEMBUFFER_RELEASE(mem);
}

关键步骤分析

1. 创建着色器：使用 glCreateShader 创建一个OpenGL着色器对象，并将其类型设置为顶点或片段着色器。
2. 设置源代码：通过 glShaderSource 将着色器的源代码传递给OpenGL。
3. 编译着色器：调用 glCompileShader 编译着色器。
4. 检查编译状态：使用 glGetShaderiv 检查编译是否成功。如果失败，获取错误日志并输出。
5. 释放内存：在完成后释放内存缓冲区，避免内存泄漏。

5. 创建程序的实现

创建程序的逻辑可以类似于创建着色器，通常会涉及到链接顶点着色器和片段着色器。以下是一个可能的实现示例：

static void gl_createProgram(RendererContext* ctx, Handle vs, Handle fs) {
    RendererContextGL* glCtx = (RendererContextGL*)ctx;
    ProgramGL* program = &glCtx->programs[handle_index(vs)]; // 假设程序与顶点着色器的句柄相关

    // 创建程序对象
    program->id = glCreateProgram();
    
    // 附加着色器
    glAttachShader(program->id, glCtx->shaders[handle_index(vs)].id);
    glAttachShader(program->id, glCtx->shaders[handle_index(fs)].id);
    
    // 链接程序
    glLinkProgram(program->id);
    
    // 检查链接状态
    GLint success;
    glGetProgramiv(program->id, GL_LINK_STATUS, &success);
    if (success == GL_FALSE) {
        GLint logLen = 0;
        glGetProgramiv(program->id, GL_INFO_LOG_LENGTH, &logLen);
        GLchar* infoLog = (GLchar*)alloca(logLen);
        glGetProgramInfoLog(program->id, logLen, NULL, infoLog);
        printf_err("Program link error: %s\n", infoLog);
    }
}

纹理图片

在纹理图片的加载和渲染过程中，涉及多个步骤和接口的调用。以下是整个流程的详细说明：

1. 加载PNG数据

首先，从磁盘加载PNG格式的图片数据，得到一个内存缓冲区（MemBuffer）。这通常通过文件I/O操作实现。

2. 解码PNG数据

使用stb_image库对加载的PNG数据进行解码，得到解码后的内存缓冲区。解码后的数据通常包含图像的像素信息。

3. 创建纹理

调用bcfx的接口createTexture，将解码后的内存缓冲区传递给它，获得该图片的纹理句柄（Handle）。这个句柄用于后续的纹理操作。

4. 设置DrawCall参数

在设置绘制调用（DrawCall）的参数时，使用bcfx的setTexture接口将创建的纹理与某个Uniform绑定在一起。需要提供采样参数（如过滤和包裹方式）。

5. Shader中采样

在Shader中，通过采样该Uniform来实现纹理的渲染。Shader代码中会使用sampler2D类型的Uniform来获取纹理数据。

6. 顶点UV坐标

为了正确采样纹理，需要为顶点添加合适的UV坐标。顶点数据应以顶点为单位进行组织，并配置相应的顶点布局（VertexLayout）。

7. 创建Uniform

创建Uniform的接口定义如下：

typedef enum {
  UT_Sampler2D,
  UT_Vec4,
  UT_Mat3x3,
  UT_Mat4x4,
} bcfx_UniformType;

BCFX_API Handle bcfx_createUniform(const char* name, bcfx_UniformType type, uint16_t num);

在逻辑线程中创建Uniform时，会新增一个命令，渲染线程在OpenGL渲染器上维护所有Uniform对应的数值。

8. OpenGL纹理绑定

OpenGL中纹理的绑定采用两步走的方式：

1. 使用glUniform1i将Shader中Uniform的location绑定到一个TextureUnit。
2. 使用glActiveTexture和glBindTexture启用该TextureUnit并将纹理绑定到该Unit上，同时配置具体的采样参数。

9. RenderBind结构

为了记录某个DrawCall的所有纹理绑定，设计了一个RenderBind结构：

typedef struct {
  Handle handle;
  bcfx_SamplerFlag samplerFlags;
} Binding;

typedef struct {
  Binding binds[BCFX_CONFIG_MAX_TEXTURE_UNIT];
} RenderBind;

10. 绑定逻辑

在GL渲染器中，实际进行绑定的逻辑如下：

void gl_setProgramUniforms(RendererContextGL* glCtx, ProgramGL* prog, RenderDraw* draw, View* view, RenderBind* bind) {
    ...
    GL_CHECK(glUniform1i(prop->loc, (GLint)uniform->data.stage));
    gl_bindTextureUnit(glCtx, bind, uniform->data.stage);
    ...
}

static void gl_bindTextureUnit(RendererContextGL* glCtx, RenderBind* bind, uint8_t stage) {
    Binding* b = &bind->binds[stage];
    if (b->handle != kInvalidHandle) {
        TextureGL* texture = &glCtx->textures[handle_index(b->handle)];
        GL_CHECK(glActiveTexture(GL_TEXTURE0 + stage));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, texture->id));

        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureWrap_glType[b->samplerFlags.wrapU]));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureWrap_glType[b->samplerFlags.wrapV]));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureFilter_glType[b->samplerFlags.filterMin]));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureFilter_glType[b->samplerFlags.filterMag]));
    } else {
        printf_err("Bind texture unit %d with invalid handle\n", stage);
    }
}

注意：如果不设置纹理的GL_TEXTURE_MIN_FILTER参数，OpenGL中Shader采样可能会得到全黑的颜色。

11. 提交DrawCall

在提交DrawCall时，将Uniform和纹理绑定起来，接口设计如下：

typedef struct {
  uint8_t wrapU : 1;
  uint8_t wrapV : 1;
  uint8_t filterMin : 1;
  uint8_t filterMag : 1;
  uint8_t reserved1 : 4;
  uint8_t reserved2[3];
} bcfx_SamplerFlag;

BCFX_API void bcfx_setTexture(uint8_t stage, Handle sampler, Handle texture, bcfx_SamplerFlag flags);

其中，stage表示TextureUnit，从0开始，支持最多8个；sampler为对应Uniform的Handle，texture为纹理的Handle，flags为纹理采样参数。

通过以上步骤，可以实现纹理的加载、绑定和渲染。

渲染状态

在这个上下文中，我们讨论的是如何在OpenGL中管理渲染状态，特别是通过bcfx_RenderState结构体来设置和更新渲染状态。以下是对渲染状态的详细分析，以及如何使用这些状态来渲染一个支持深度测试的立方体。

渲染状态结构体

bcfx_RenderState结构体定义了多个渲染状态参数，具体包括：

• 前面剔除（frontFace）：指示是否剔除前面（或背面）面。
• 剔除启用（enableCull）：指示是否启用剔除。
• 剔除面（cullFace）：指定剔除的面（前面或背面）。
• 深度测试启用（enableDepth）：指示是否启用深度测试。
• 深度函数（depthFunc）：指定深度比较函数。
• 颜色混合参数（srcRGB, dstRGB, srcAlpha, dstAlpha）：用于设置颜色混合的源和目标因子。
• 逻辑操作（enableLogicOp, logicOp）：指示是否启用逻辑操作及其类型。

深度测试状态更新逻辑

renderstate_updateDepth函数负责根据bcfx_RenderState中的状态更新OpenGL的深度测试设置。其核心逻辑如下：

1. 深度写入：通过glDepthMask设置是否允许深度写入。
2. 深度测试启用：通过glEnable或glDisable启用或禁用深度测试。
3. 深度函数：通过glDepthFunc设置深度比较函数。

static void renderstate_updateDepth(RenderStateGL* stateGL, bcfx_RenderState state) {
  GLboolean writeZ = !((GLboolean)state.noWriteZ);
  if (IS_STATE_CHANGED(writeZ)) {
    GL_CHECK(glDepthMask(writeZ));
  }
  GLboolean enableDepth = state.enableDepth;
  if (IS_STATE_CHANGED(enableDepth)) {
    if (enableDepth) {
      GL_CHECK(glEnable(GL_DEPTH_TEST));
      GLenum depthFunc = compareFunc_glType[state.depthFunc];
      if (IS_STATE_CHANGED(depthFunc)) {
        GL_CHECK(glDepthFunc(depthFunc));
      }
    } else {
      if (writeZ) {
        GL_CHECK(glEnable(GL_DEPTH_TEST));
        GL_CHECK(glDepthFunc(GL_ALWAYS));
        stateGL->depthFunc = GL_ALWAYS;
      } else {
        GL_CHECK(glDisable(GL_DEPTH_TEST));
      }
    }
  }
}

渲染状态设置接口

bcfx_setState函数用于设置渲染状态。每个DrawCall都可以拥有独立的状态，这使得渲染过程更加灵活和可控。

BCFX_API void bcfx_setState(bcfx_RenderState state, uint32_t blendColor);

渲染立方体的示例

在渲染立方体的示例中，我们使用模型空间的顶点位置作为颜色，并启用深度测试。以下是实现的步骤：

1. 设置视口和清除颜色：在窗口的回调函数中设置视口和清除颜色。
2. 创建顶点和索引缓冲区：定义立方体的顶点和索引数据，并创建相应的缓冲区。
3. 编写着色器：创建顶点着色器和片段着色器，处理顶点位置和颜色输出。
4. 渲染循环：在每一帧中设置顶点和索引缓冲区，应用变换，并提交绘制调用。

示例代码

以下是一个简化的示例代码，展示如何设置和渲染一个立方体：

local viewID = 0
local triangle = {}

local function setup(win)
    -- 设置窗口回调
    glfw.setFramebufferSizeCallback(win, function(window, width, height)
        bcfx.setViewRect(viewID, 0, 0, width, height)
    end)

    -- 设置视口和清除颜色
    bcfx.setViewRect(viewID, 0, 0, glfw.getFramebufferSize(win))
    bcfx.setViewClear(viewID, bcfx.clear_flag.COLOR | bcfx.clear_flag.DEPTH, bcfx.color.cyan, 1.0, 0)

    -- 创建立方体的顶点和索引数据
    local vertexData = bcfx.makeMemBuffer(bcfx.data_type.Float, {
        -- 立方体的顶点坐标
    })
    local indexData = bcfx.makeMemBuffer(bcfx.data_type.Uint8, {
        -- 立方体的索引数据
    })

    -- 创建顶点和索引缓冲区
    triangle.vertexHandle = bcfx.createVertexBuffer(vertexData, layoutHandle)
    triangle.indexHandle = bcfx.createIndexBuffer(indexData, bcfx.index_type.Uint8)

    -- 创建着色器
    local vs = bcfx.createShader([[...]])
    local fs = bcfx.createShader([[...]])
    triangle.programHandle = bcfx.createProgram(vs, fs)

    -- 设置渲染状态
    triangle.renderFlags = bcfx.utils.packRenderState({
        enableDepth = true,
    })
end

local function loop()
    -- 设置顶点和索引缓冲区
    bcfx.setVertexBuffer(0, triangle.vertexHandle)
    bcfx.setIndexBuffer(triangle.indexHandle)

    -- 应用变换
    bcfx.setTransform(bcfx.math.graphics3d.rotate(bcfx.frameId() % 360, bcfx.math.vector.Vec3(1.0, 1.0, 0.0)))

    -- 设置渲染状态并提交绘制调用
    bcfx.setState(triangle.renderFlags, bcfx.color.black)
    bcfx.submit(viewID, triangle.programHandle)
end

总结

通过合理管理渲染状态，特别是深度测试和颜色混合等设置，可以实现复杂的渲染效果。BCFX框架提供了灵活的接口，使得开发者能够轻松地设置和更新这些状态，从而实现高效的3D渲染。

渲染排序

在渲染线程中，处理DrawCall的排序和提交是一个复杂的过程，涉及多个因素的考虑。以下是对整个流程的详细分析和解释。

1. SortKey结构体

SortKey结构体包含了多个字段，用于描述每个DrawCall的属性。字段的含义如下：

• viewId: 视图ID，决定了DrawCall的渲染顺序。
• notTouch: 标记该DrawCall是否为触摸事件。
• isDraw: 标记该DrawCall是否需要绘制。
• sortType: 排序类型，决定了在同一视图内的DrawCall的排序方式。
• blend: 混合模式，影响绘制的方式。
• program: 着色器程序ID，决定使用哪个着色器进行渲染。
• depth: 深度值，用于深度排序。
• sequence: 在DrawCall列表中的序列号，用于索引。

2. SortKey编码逻辑

sortkey_encode函数将SortKey编码为一个uint64_t值，以便于快速排序。编码逻辑的关键点包括：

• ViewID优先级: viewId是最高优先级的字段，所有DrawCall会根据viewId进行分组。
• notTouch处理: 如果notTouch为真，表示该DrawCall是一个触摸事件，优先处理。
• isDraw处理: 如果isDraw为真，进一步根据sortType进行排序。
• 不同的排序类型: 根据sortType的不同，depth、blend、program和sequence的编码顺序会有所不同。

3. SortKey解码逻辑

sortkey_decode函数将编码后的uint64_t值解码回SortKey结构体。解码逻辑与编码逻辑相对应，确保能够正确恢复每个字段的值。

4. 提交渲染的逻辑

在gl_submit函数中，首先对SortKey数组进行排序，然后遍历排序后的数组，进行实际的渲染操作。关键步骤包括：

• 排序: 使用sortUint64Array对frame->sortKeys进行排序。
• 遍历DrawCall: 遍历排序后的SortKey，解码每个SortKey以获取其对应的viewId和RenderDraw。
• 更新视图参数: 当视图ID发生变化时，更新视图参数。
• 提交绘制: 如果该DrawCall不是触摸事件且需要绘制，则调用gl_submitDraw进行实际的绘制。

5. 其他考虑

• 性能优化: 通过将SortKey编码为uint64_t，可以利用快速排序算法提高性能。
• 状态管理: 在遍历过程中，管理当前的视图状态和OpenGL状态，以确保渲染的正确性。
• 混合和深度处理: 根据blend和depth的值，可能需要在渲染过程中进行额外的状态设置。

总结

整个渲染排序和提交的过程是为了确保DrawCall按照正确的顺序进行渲染，以提高渲染效率和视觉效果。通过合理的编码和解码逻辑，结合视图管理和状态更新，能够有效地处理复杂的渲染场景。