docs: update RHI API docs

docs/api/rhi/opengl/buffer/bind-base.md

@@ -1,7 +1,7 @@
 # OpenGLBuffer::BindBase
 
 ```cpp
-void BindBase(unsigned int target, unsigned int index) const
+void BindBase(unsigned int target, unsigned int index) const;
 ```
 
 将缓冲区绑定到固定的 binding point。

docs/api/rhi/opengl/buffer/buffer.md

@@ -11,13 +11,13 @@
 | [`Initialize`](initialize.md) | 初始化缓冲区 |
 | [`InitializeVertexBuffer`](initialize-vertex-buffer.md) | 初始化顶点缓冲 |
 | [`InitializeIndexBuffer`](initialize-index-buffer.md) | 初始化索引缓冲 |
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭缓冲区 |
+| [`Shutdown`](../../buffer/shutdown.md) | 关闭缓冲区 |
 | [`Bind`](bind.md) | 绑定缓冲区 |
 | [`Unbind`](unbind.md) | 解绑缓冲区 |
 | [`BindBase`](bind-base.md) | 绑定到基准点 |
-| [`Map`](../../buffer/map.md) | 映射缓冲区 |
-| [`Unmap`](../../buffer/unmap.md) | 取消映射 |
-| [`SetData`](../../buffer/set-data.md) | 设置数据 |
+| [`Map`](map.md) | 映射缓冲区 |
+| [`Unmap`](unmap.md) | 取消映射 |
+| [`SetData`](set-data.md) | 设置数据 |
 | [`GetID`](get-id.md) | 获取 OpenGL 缓冲 ID |
 | [`GetSize`](../../buffer/get-size.md) | 获取缓冲区大小 |
 | [`GetType`](get-type.md) | 获取缓冲区类型 |

docs/api/rhi/opengl/buffer/get-id.md

@@ -1,7 +1,7 @@
 # OpenGLBuffer::GetID
 
 ```cpp
-unsigned int GetID() const
+unsigned int GetID() const;
 ```
 
 获取 OpenGL buffer 的 GLuint ID。

docs/api/rhi/opengl/buffer/is-dynamic.md

@@ -1,7 +1,7 @@
 # OpenGLBuffer::IsDynamic
 
 ```cpp
-bool IsDynamic() const
+bool IsDynamic() const;
 ```
 
 判断缓冲区是否为动态缓冲区。

docs/api/rhi/opengl/buffer/map.md

@@ -0,0 +1,27 @@
+# OpenGLBuffer::Map
+
+```cpp
+void* Map() override;
+```
+
+映射缓冲区到客户端地址空间，使用 `GL_WRITE_ONLY` 访问模式。
+
+**返回：** 指向缓冲区数据的指针
+
+**示例：**
+
+```cpp
+void* data = buffer.Map();
+if (data) {
+    memcpy(data, vertices, size);
+    buffer.Unmap();
+}
+```
+
+**注意：** 此方法以 `GL_WRITE_ONLY` 模式映射缓冲区，适用于写入操作。
+
+## 相关文档
+
+- [OpenGLBuffer 总览](buffer.md) - 返回类总览
+- [Unmap](unmap.md) - 取消映射缓冲区
+- [SetData](set-data.md) - 设置缓冲区数据

docs/api/rhi/opengl/buffer/set-data.md

@@ -0,0 +1,30 @@
+# OpenGLBuffer::SetData
+
+```cpp
+void SetData(const void* data, size_t size, size_t offset = 0) override;
+```
+
+设置缓冲区数据。支持部分更新：当 `offset == 0` 且 `size` 等于缓冲区大小时，使用 `glBufferData` 替换整个缓冲区；否则使用 `glBufferSubData` 进行部分更新。
+
+**参数：**
+- `data` - 要写入的数据指针
+- `size` - 数据大小（字节）
+- `offset` - 缓冲区内的偏移量（默认 0）
+
+**示例：**
+
+```cpp
+// 更新整个缓冲区
+buffer.SetData(vertices, sizeof(vertices));
+
+// 部分更新
+buffer.SetData(newVertices, sizeof(newVertices), sizeof(vertices));
+```
+
+**注意：** 动态缓冲区使用 `GL_DYNAMIC_DRAW`，静态缓冲区使用 `GL_STATIC_DRAW`。
+
+## 相关文档
+
+- [OpenGLBuffer 总览](buffer.md) - 返回类总览
+- [Map](map.md) - 映射缓冲区方式写入
+- [Initialize](initialize.md) - 初始化缓冲区

docs/api/rhi/opengl/buffer/unmap.md

@@ -0,0 +1,22 @@
+# OpenGLBuffer::Unmap
+
+```cpp
+void Unmap() override;
+```
+
+取消映射缓冲区，使数据对 GPU 可见。
+
+**示例：**
+
+```cpp
+void* data = buffer.Map();
+if (data) {
+    memcpy(data, vertices, size);
+    buffer.Unmap();
+}
+```
+
+## 相关文档
+
+- [OpenGLBuffer 总览](buffer.md) - 返回类总览
+- [Map](map.md) - 映射缓冲区到客户端地址空间

docs/api/rhi/opengl/command-list/clear.md

@@ -1,24 +1,46 @@
 # OpenGLCommandList::Clear
 
 ```cpp
-void Clear(float r, float g, float b, float a, unsigned int buffers);
+void Clear(float r, float g, float b, float a, unsigned int buffers)
 ```
 
-清除缓冲区。
+清除指定的缓冲区。
 
 **参数：**
-- `r` - 红色分量
-- `g` - 绿色分量
-- `b` - 蓝色分量
-- `a` - Alpha 分量
-- `buffers` - 要清除的缓冲区标志
+- `r` - 清除颜色红色分量（范围 0.0f - 1.0f）
+- `g` - 清除颜色绿色分量（范围 0.0f - 1.0f）
+- `b` - 清除颜色蓝色分量（范围 0.0f - 1.0f）
+- `a` - 清除颜色 Alpha 分量（范围 0.0f - 1.0f）
+- `buffers` - 要清除的缓冲区标志，使用 `ClearFlag` 枚举值的位或组合：
+  - `ClearFlag::Color` (1) - 清除颜色缓冲区
+  - `ClearFlag::Depth` (2) - 清除深度缓冲区
+  - `ClearFlag::Stencil` (4) - 清除模板缓冲区
+
+**返回值**：无
 
 **示例：**
 
 ```cpp
-commandList->Clear(0.0f, 0.0f, 0.0f, 1.0f, Color | Depth);
+// 清除颜色缓冲区
+commandList->Clear(0.0f, 0.0f, 0.0f, 1.0f, static_cast<unsigned int>(ClearFlag::Color));
+
+// 清除颜色和深度缓冲区
+commandList->Clear(0.0f, 0.0f, 0.0f, 1.0f, 
+    static_cast<unsigned int>(ClearFlag::Color) | 
+    static_cast<unsigned int>(ClearFlag::Depth));
+
+// 清除所有缓冲区
+commandList->Clear(0.0f, 0.0f, 0.0f, 1.0f, 
+    static_cast<unsigned int>(ClearFlag::Color) | 
+    static_cast<unsigned int>(ClearFlag::Depth) | 
+    static_cast<unsigned int>(ClearFlag::Stencil));
 ```
 
 ## 相关文档
 
 - [OpenGLCommandList 总览](command-list.md) - 返回类总览
+- [ClearColor](clear-color.md) - 仅清除颜色缓冲区
+- [ClearDepth](clear-depth.md) - 仅清除深度缓冲区
+- [ClearStencil](clear-stencil.md) - 仅清除模板缓冲区
+- [ClearDepthStencil](clear-depth-stencil.md) - 清除深度和模板缓冲区
+- [ClearFlag 枚举](../../enums/clear-flag.md) - 清除缓冲区标志

docs/api/rhi/opengl/command-list/command-list.md

@@ -2,41 +2,112 @@
 
 **命名空间**: `XCEngine::RHI`
 
-**描述**: OpenGL 命令列表实现，继承自 `RHICommandList`。
+**描述**: OpenGL 命令列表实现，继承自 `RHICommandList`。提供 OpenGL 图形 API 的命令录制与执行接口，支持底层 OpenGL 状态操作以及跨平台 RHI 抽象接口。
+
+## 概述
+
+`OpenGLCommandList` 是 XCEngine RHI（渲染硬件接口）层在 OpenGL 后端的实现类。它封装了 OpenGL 图形命令的调用，提供了两类接口：
+
+1. **RHI 抽象接口**：继承自 `RHICommandList`，提供跨后端一致性接口
+2. **OpenGL 特有方法**：底层逃逸接口，用于需要直接操作 OpenGL 状态的场景
 
 ## 公共方法
 
+### 生命周期
+
+| 方法 | 描述 |
+|------|------|
+| [`Shutdown`](opengl-methods.md#shutdown) | 关闭命令列表（占位实现） |
+| [`Reset`](opengl-methods.md#reset) | 重置命令列表（占位实现） |
+| [`Close`](opengl-methods.md#close) | 关闭命令列表（占位实现） |
+
+### 清除操作
+
+| 方法 | 描述 |
+|------|------|
+| [`Clear`](clear.md) | 清除指定缓冲区 |
+| [`ClearColor`](clear-color.md) | 清除颜色缓冲区 |
+| [`ClearDepth`](clear-depth.md) | 清除深度缓冲区 |
+| [`ClearStencil`](clear-stencil.md) | 清除模板缓冲区 |
+| [`ClearDepthStencil`](clear-depth-stencil.md) | 清除深度和模板缓冲区 |
+| [`ClearRenderTarget`](clear-render-target.md) | 清除渲染目标 |
+
+### 状态设置
+
 | 方法 | 描述 |
 |------|------|
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭命令列表 |
-| [`Reset`](../../command-list/reset.md) | 重置命令列表 |
-| [`Close`](../../command-list/close.md) | 关闭命令列表 |
-| [`Clear`](clear.md) | 清除 |
-| [`ClearColor`](clear-color.md) | 清除颜色 |
-| [`ClearDepth`](clear-depth.md) | 清除深度 |
-| [`ClearStencil`](clear-stencil.md) | 清除模板 |
-| [`ClearDepthStencil`](clear-depth-stencil.md) | 清除深度模板 |
 | [`SetPipelineState`](set-pipeline-state.md) | 设置管线状态 |
-| [`SetVertexBuffer`](set-vertex-buffer.md) | 设置顶点缓冲 |
-| [`SetVertexBuffers`](set-vertex-buffers.md) | 设置多个顶点缓冲 |
-| [`SetIndexBuffer`](set-index-buffer.md) | 设置索引缓冲 |
-| [`TransitionBarrier`](transition-barrier.md) | 资源状态转换 |
-| [`SetPrimitiveTopology`](set-primitive-topology.md) | 设置图元拓扑 |
-| [`SetViewport`](set-viewport.md) | 设置视口 |
-| [`SetViewports`](set-viewports.md) | 设置多个视口 |
-| [`SetScissorRect`](set-scissor-rect.md) | 设置裁剪矩形 |
-| [`SetScissorRects`](set-scissor-rects.md) | 设置多个裁剪矩形 |
+| [`SetVertexBuffer`](set-vertex-buffer.md) | 设置顶点缓冲区 |
+| [`SetVertexBuffers`](set-vertex-buffers.md) | 批量设置顶点缓冲区 |
+| [`SetIndexBuffer`](set-index-buffer.md) | 设置索引缓冲区 |
 | [`SetRenderTargets`](set-render-targets.md) | 设置渲染目标 |
 | [`SetDepthStencilState`](set-depth-stencil-state.md) | 设置深度模板状态 |
 | [`SetStencilRef`](set-stencil-ref.md) | 设置模板引用值 |
 | [`SetBlendState`](set-blend-state.md) | 设置混合状态 |
-| [`SetBlendFactor`](set-blend-factor.md) | 设置混合因子 |
-| [`ClearRenderTarget`](clear-render-target.md) | 清除渲染目标 |
-| [`Draw`](draw.md) | 绘制 |
-| [`DrawIndexed`](draw-indexed.md) | 索引绘制 |
+| [`SetBlendFactor`](set-blend-factor.md) | 设置混合因子颜色 |
+| [`SetPrimitiveTopology`](set-primitive-topology.md) | 设置图元拓扑 |
+
+### 视口与裁剪
+
+| 方法 | 描述 |
+|------|------|
+| [`SetViewport`](set-viewport.md) | 设置视口 |
+| [`SetViewports`](set-viewports.md) | 批量设置视口 |
+| [`SetScissorRect`](set-scissor-rect.md) | 设置裁剪矩形 |
+| [`SetScissorRects`](set-scissor-rects.md) | 批量设置裁剪矩形 |
+
+### 绘制
+
+| 方法 | 描述 |
+|------|------|
+| [`Draw`](draw.md) | 绘制非索引图元 |
+| [`DrawIndexed`](draw-indexed.md) | 绘制索引图元 |
+
+### 计算
+
+| 方法 | 描述 |
+|------|------|
 | [`Dispatch`](dispatch.md) | 分发计算任务 |
-| [`CopyResource`](copy-resource.md) | 复制资源 |
-| [`OpenGLMethods`](opengl-methods.md) | OpenGL 特有方法 |
+| [`CopyResource`](copy-resource.md) | 复制资源（占位实现） |
+| [`TransitionBarrier`](transition-barrier.md) | 资源状态转换（占位实现） |
+
+### OpenGL 特有方法
+
+| 方法 | 描述 |
+|------|------|
+| [`OpenGLMethods`](opengl-methods.md) | 底层 OpenGL 逃逸接口 |
+
+## 使用示例
+
+```cpp
+#include "XCEngine/RHI/OpenGL/OpenGLCommandList.h"
+
+using namespace XCEngine::RHI;
+
+// 创建命令列表
+OpenGLCommandList* cmdList = new OpenGLCommandList();
+
+// 清除颜色缓冲区
+cmdList->ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+// 设置视口
+Viewport viewport;
+viewport.topLeftX = 0.0f;
+viewport.topLeftY = 0.0f;
+viewport.width = 800.0f;
+viewport.height = 600.0f;
+viewport.minDepth = 0.0f;
+viewport.maxDepth = 1.0f;
+cmdList->SetViewport(viewport);
+
+// 绑定 shader program
+cmdList->UseShader(shaderProgram);
+
+// 绘制
+cmdList->Draw(3, 1, 0, 0);
+
+delete cmdList;
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/command-list/draw.md

@@ -4,20 +4,34 @@
 void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t startVertex, uint32_t startInstance)
 ```
 
-绘制非索引图元。
+绘制非索引图元（实例化绘制）。
 
 **参数：**
-- `vertexCount` - 顶点数量
-- `instanceCount` - 实例数量
-- `startVertex` - 起始顶点
-- `startInstance` - 起始实例
+- `vertexCount` - 每个实例的顶点数量
+- `instanceCount` - 要绘制的实例数量
+- `startVertex` - 第一个顶点的索引
+- `startInstance` - 第一个实例的 ID
+
+**返回值**：无
+
+**详细描述**：
+此方法使用 `glDrawArraysInstanced` 执行实例化绘制。当 `instanceCount` 为 1 时，等同于普通的非实例化绘制。
 
 **示例：**
 
 ```cpp
+// 绘制单个实例（相当于 glDrawArrays）
 commandList->Draw(3, 1, 0, 0);
+
+// 绘制 100 个实例
+commandList->Draw(3, 100, 0, 0);
+
+// 绘制多个实例，从实例 ID 10 开始
+commandList->Draw(3, 50, 0, 10);
 ```
 
 ## 相关文档
 
-- [OpenGLCommandList](command-list.md) - 返回类总览
+- [OpenGLCommandList 总览](command-list.md) - 返回类总览
+- [DrawIndexed](draw-indexed.md) - 索引绘制
+- [OpenGL 特有 Draw 方法](opengl-methods.md#draw-primitivetype) - 使用 PrimitiveType 的版本

docs/api/rhi/opengl/command-list/set-blend-state.md

@@ -4,21 +4,40 @@
 void SetBlendState(const BlendState& state)
 ```
 
-设置混合状态。
+设置颜色混合状态。
 
 **参数：**
-- `state` - 混合状态结构
+- `state` - 混合状态结构，包含以下成员：
+  - `alphaToCoverageEnable` - Alpha to coverage 使能标志
+  - `renderTargets[0]` - 渲染目标混合配置（以第一个为例）：
+    - `blendEnable` - 混合使能标志
+    - `srcBlend` - RGB 源混合因子（参见 `BlendFactor` 枚举）
+    - `dstBlend` - RGB 目标混合因子
+    - `srcBlendAlpha` - Alpha 源混合因子
+    - `dstBlendAlpha` - Alpha 目标混合因子
+    - `blendOp` - RGB 混合操作（参见 `BlendOp` 枚举）
+    - `blendOpAlpha` - Alpha 混合操作
+
+**返回值**：无
 
 **示例：**
 
 ```cpp
 BlendState state;
-state.enable = true;
-state.srcBlend = BlendFunc::SrcAlpha;
-state.dstBlend = BlendFunc::InvSrcAlpha;
+state.alphaToCoverageEnable = false;
+state.renderTargets[0].blendEnable = true;
+state.renderTargets[0].srcBlend = BlendFactor::SrcAlpha;
+state.renderTargets[0].dstBlend = BlendFactor::InvSrcAlpha;
+state.renderTargets[0].srcBlendAlpha = BlendFactor::One;
+state.renderTargets[0].dstBlendAlpha = BlendFactor::InvSrcAlpha;
+state.renderTargets[0].blendOp = BlendOp::Add;
+state.renderTargets[0].blendOpAlpha = BlendOp::Add;
 commandList->SetBlendState(state);
 ```
 
 ## 相关文档
 
-- [OpenGLCommandList](command-list.md) - 返回类总览
+- [OpenGLCommandList 总览](command-list.md) - 返回类总览
+- [SetBlendFactor](set-blend-factor.md) - 设置混合常量颜色
+- [BlendFactor](../../enums/blend-factor.md) - 混合因子枚举
+- [BlendOp](../../enums/blend-op.md) - 混合操作枚举

docs/api/rhi/opengl/command-list/set-viewport.md

@@ -4,21 +4,33 @@
 void SetViewport(const Viewport& viewport)
 ```
 
-设置视口。
+设置渲染视口区域。
 
 **参数：**
-- `viewport` - 视口结构
+- `viewport` - 视口结构，包含以下成员：
+  - `topLeftX` - 视口左下角 X 坐标
+  - `topLeftY` - 视口左下角 Y 坐标
+  - `width` - 视口宽度
+  - `height` - 视口高度
+  - `minDepth` - 最小深度值（通常为 0.0f）
+  - `maxDepth` - 最大深度值（通常为 1.0f）
+
+**返回值**：无
 
 **示例：**
 
 ```cpp
 Viewport viewport;
-viewport.x = 0; viewport.y = 0;
-viewport.width = 800; viewport.height = 600;
-viewport.minDepth = 0.0f; viewport.maxDepth = 1.0f;
+viewport.topLeftX = 0.0f;
+viewport.topLeftY = 0.0f;
+viewport.width = 800.0f;
+viewport.height = 600.0f;
+viewport.minDepth = 0.0f;
+viewport.maxDepth = 1.0f;
 commandList->SetViewport(viewport);
 ```
 
 ## 相关文档
 
-- [OpenGLCommandList](command-list.md) - 返回类总览
+- [OpenGLCommandList 总览](command-list.md) - 返回类总览
+- [SetViewports](set-viewports.md) - 批量设置视口

docs/api/rhi/opengl/command-queue/command-queue.md

@@ -2,23 +2,29 @@
 
 **命名空间**: `XCEngine::RHI`
 
+**类型**: `class`
+
 **描述**: OpenGL 命令队列实现，继承自 `RHICommandQueue`。
 
+## 概述
+
+OpenGL 采用立即模式（Immediate Mode）渲染，与 D3D12 的命令列表模式不同。OpenGLCommandQueue 作为 RHI 抽象层接口实现，当前大多数方法为存根（stub）实现，实际渲染操作通过 OpenGL 命令直接执行。
+
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭命令队列 |
+| [`Shutdown`](shutdown.md) | 关闭命令队列 |
 | [`ExecuteCommandLists`](execute-command-lists.md) | 执行命令列表 |
-| [`Signal`](signal.md) | 信号栅栏 |
-| [`Wait`](../../../threading/task-group/wait.md) | 等待栅栏 |
+| [`Signal`](signal.md) | 信号围栏 |
+| [`Wait`](wait.md) | 等待围栏 |
 | [`GetCompletedValue`](get-completed-value.md) | 获取完成值 |
 | [`WaitForIdle`](wait-for-idle.md) | 等待空闲 |
-| [`GetType`](../../command-queue/get-type.md) | 获取队列类型 |
+| [`GetType`](get-type.md) | 获取队列类型 |
 | [`GetTimestampFrequency`](get-timestamp-frequency.md) | 获取时间戳频率 |
-| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
+| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 |
 
 ## 相关文档
 
 - [OpenGL 后端总览](../overview.md)
-- [RHICommandQueue](../../command-queue/command-queue.md) - 抽象命令队列接口
+- [RHICommandQueue](../../command-queue/command-queue.md) - 抽象命令队列接口

docs/api/rhi/opengl/command-queue/execute-command-lists.md

@@ -4,12 +4,14 @@
 void ExecuteCommandLists(uint32_t count, void** lists)
 ```
 
-执行命令列表。
+**详细描述**: 执行命令列表。OpenGL 采用立即模式，此方法当前为存根实现，实际渲染通过 OpenGL 命令直接执行。
 
 **参数：**
 - `count` - 命令列表数量
 - `lists` - 命令列表指针数组
 
+**返回值：** 无
+
 **示例：**
 
 ```cpp
@@ -19,4 +21,4 @@ commandQueue->ExecuteCommandLists(1, lists);
 
 ## 相关文档
 
-- [OpenGLCommandQueue](command-queue.md) - 返回类总览
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/get-completed-value.md

@@ -4,9 +4,9 @@
 uint64_t GetCompletedValue()
 ```
 
-获取已完成的值。
+**详细描述**: 获取围栏已完成的值。由于 OpenGLCommandQueue 为存根实现，此方法始终返回 0。
 
-**返回：** 已完成的围栏值
+**返回值：** `uint64_t` - 已完成的围栏值，当前固定返回 0
 
 **示例：**
 
@@ -16,4 +16,4 @@ uint64_t value = commandQueue->GetCompletedValue();
 
 ## 相关文档
 
-- [OpenGLCommandQueue](command-queue.md) - 返回类总览
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/get-native-handle.md

@@ -0,0 +1,19 @@
+# OpenGLCommandQueue::GetNativeHandle
+
+```cpp
+void* GetNativeHandle()
+```
+
+**详细描述**: 获取原生句柄。OpenGLCommandQueue 当前为存根实现，因此始终返回 `nullptr`。
+
+**返回值：** `void*` - 原生句柄指针，OpenGL 实现当前返回 `nullptr`
+
+**示例：**
+
+```cpp
+void* handle = commandQueue->GetNativeHandle();
+```
+
+## 相关文档
+
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/get-timestamp-frequency.md

@@ -4,9 +4,9 @@
 uint64_t GetTimestampFrequency() const
 ```
 
-获取时间戳频率。
+**详细描述**: 获取时间戳频率。OpenGLCommandQueue 为存根实现，此方法始终返回 0，表示不支持时间戳查询。
 
-**返回：** 时间戳频率（Hz）
+**返回值：** `uint64_t` - 时间戳频率（Hz），当前固定返回 0
 
 **示例：**
 
@@ -16,4 +16,4 @@ uint64_t frequency = commandQueue->GetTimestampFrequency();
 
 ## 相关文档
 
-- [OpenGLCommandQueue](command-queue.md) - 返回类总览
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/get-type.md

@@ -0,0 +1,19 @@
+# OpenGLCommandQueue::GetType
+
+```cpp
+CommandQueueType GetType() const
+```
+
+**详细描述**: 获取命令队列类型。OpenGLCommandQueue 固定返回 `CommandQueueType::Direct`，表示直接命令队列。
+
+**返回值：** `CommandQueueType` - 命令队列类型，当前固定返回 `CommandQueueType::Direct`
+
+**示例：**
+
+```cpp
+CommandQueueType type = commandQueue->GetType();
+```
+
+## 相关文档
+
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/shutdown.md

@@ -0,0 +1,13 @@
+# OpenGLCommandQueue::Shutdown
+
+```cpp
+void Shutdown()
+```
+
+**详细描述**: 关闭命令队列并释放相关资源。OpenGLCommandQueue 当前为存根实现，此方法为空实现。
+
+**返回值：** 无
+
+## 相关文档
+
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/signal.md

@@ -4,12 +4,14 @@
 void Signal(RHIFence* fence, uint64_t value)
 ```
 
-发送信号。
+**详细描述**: 向围栏发送信号。OpenGLCommandQueue 当前为存根实现，此方法为空实现。
 
 **参数：**
 - `fence` - 围栏指针
 - `value` - 信号值
 
+**返回值：** 无
+
 **示例：**
 
 ```cpp
@@ -18,4 +20,4 @@ commandQueue->Signal(fence, 1);
 
 ## 相关文档
 
-- [OpenGLCommandQueue](command-queue.md) - 返回类总览
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/wait-for-idle.md

@@ -4,7 +4,9 @@
 void WaitForIdle()
 ```
 
-等待命令队列空闲。
+**详细描述**: 等待命令队列空闲。OpenGLCommandQueue 当前为存根实现，此方法为空实现。
+
+**返回值：** 无
 
 **示例：**
 
@@ -14,4 +16,4 @@ commandQueue->WaitForIdle();
 
 ## 相关文档
 
-- [OpenGLCommandQueue](command-queue.md) - 返回类总览
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/command-queue/wait.md

@@ -0,0 +1,23 @@
+# OpenGLCommandQueue::Wait
+
+```cpp
+void Wait(RHIFence* fence, uint64_t value)
+```
+
+**详细描述**: 等待围栏达到指定值。OpenGLCommandQueue 当前为存根实现，此方法为空实现。
+
+**参数：**
+- `fence` - 围栏指针
+- `value` - 等待的围栏值
+
+**返回值：** 无
+
+**示例：**
+
+```cpp
+commandQueue->Wait(fence, 1);
+```
+
+## 相关文档
+
+- [OpenGLCommandQueue](command-queue.md) - 返回至类概览

docs/api/rhi/opengl/depth-stencil-view/bind-framebuffer.md

@@ -9,6 +9,8 @@ static void BindFramebuffer(unsigned int framebuffer)
 **参数：**
 - `framebuffer` - 帧缓冲区 ID（0 表示解除绑定）
 
+**返回值：** `void`
+
 **示例：**
 
 ```cpp

docs/api/rhi/opengl/depth-stencil-view/bind.md

@@ -1,10 +1,16 @@
 # OpenGLDepthStencilView::Bind
 
 ```cpp
-void Bind() const;
+void Bind();
 ```
 
-绑定深度模板视图。
+将深度模板视图的帧缓冲对象绑定到当前 OpenGL 上下文。绑定后，后续的深度测试和模板测试将使用此视图。
+
+**返回值：** `void`
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览
 
 ## 相关文档
 

docs/api/rhi/opengl/depth-stencil-view/clear-depth-stencil.md

@@ -4,12 +4,14 @@
 void ClearDepthStencil(float depth, uint8_t stencil)
 ```
 
-同时清除深度和模板缓冲区。
+同时清除深度和模板缓冲区。此操作会先绑定帧缓冲，然后执行清除。
 
 **参数：**
 - `depth` - 深度值（通常为 0.0 到 1.0）
 - `stencil` - 模板值（0-255）
 
+**返回值：** `void`
+
 **示例：**
 
 ```cpp

docs/api/rhi/opengl/depth-stencil-view/clear-depth.md

@@ -4,11 +4,13 @@
 void ClearDepth(float depth)
 ```
 
-清除深度缓冲区的深度值。
+清除深度缓冲区的深度值为指定值。此操作会先绑定帧缓冲，然后执行清除。
 
 **参数：**
 - `depth` - 深度值（通常为 0.0 到 1.0）
 
+**返回值：** `void`
+
 **示例：**
 
 ```cpp

docs/api/rhi/opengl/depth-stencil-view/clear-stencil.md

@@ -4,11 +4,13 @@
 void ClearStencil(uint8_t stencil)
 ```
 
-清除模板缓冲区的模板值。
+清除模板缓冲区的模板值为指定值。此操作会先绑定帧缓冲，然后执行清除。
 
 **参数：**
 - `stencil` - 模板值（0-255）
 
+**返回值：** `void`
+
 **示例：**
 
 ```cpp

docs/api/rhi/opengl/depth-stencil-view/constructor.md

@@ -0,0 +1,11 @@
+# OpenGLDepthStencilView::OpenGLDepthStencilView
+
+```cpp
+OpenGLDepthStencilView();
+```
+
+默认构造函数，创建一个空的深度模板视图对象。
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览

docs/api/rhi/opengl/depth-stencil-view/depth-stencil-format.md

@@ -0,0 +1,19 @@
+# DepthStencilFormat
+
+**命名空间**: `XCEngine::RHI`
+
+**描述**: 深度模板格式枚举。
+
+## 枚举值
+
+| 枚举值 | 描述 |
+|--------|------|
+| `D16_UNORM` | 16 位无符号归一化深度格式 |
+| `D24_UNORM_S8_UINT` | 24 位无符号归一化深度格式，8 位模板 |
+| `D32_FLOAT` | 32 位浮点深度格式 |
+| `D32_FLOAT_S8X24_UINT` | 32 位浮点深度格式，8 位模板，24 位未使用 |
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览
+- [OpenGLDepthStencilViewDesc](openGLDepthStencilViewDesc.md) - 深度模板视图描述结构体

docs/api/rhi/opengl/depth-stencil-view/depth-stencil-type.md

@@ -0,0 +1,18 @@
+# DepthStencilType
+
+**命名空间**: `XCEngine::RHI`
+
+**描述**: 深度模板类型枚举。
+
+## 枚举值
+
+| 枚举值 | 描述 |
+|--------|------|
+| `Texture2D` | 2D 纹理 |
+| `Texture2DArray` | 2D 纹理数组 |
+| `TextureCube` | 立方体贴图 |
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览
+- [OpenGLDepthStencilViewDesc](openGLDepthStencilViewDesc.md) - 深度模板视图描述结构体

docs/api/rhi/opengl/depth-stencil-view/depth-stencil-view.md

@@ -2,12 +2,24 @@
 
 **命名空间**: `XCEngine::RHI`
 
-**描述**: OpenGL 深度模板视图实现。
+**描述**: OpenGL 深度模板视图实现，用于管理深度缓冲区和模板缓冲区的帧缓冲对象。
+
+## 概述
+
+`OpenGLDepthStencilView` 类封装了 OpenGL 深度模板视图（Depth-Stencil View）的功能，通过帧缓冲对象（Framebuffer Object）管理深度缓冲区和模板缓冲区。该类支持多种纹理类型，包括 2D 纹理、2D 纹理数组和立方体贴图。
+
+主要功能：
+- 创建和管理深度模板帧缓冲对象
+- 绑定/解绑深度模板视图到渲染管线
+- 清除深度缓冲区和/或模板缓冲区的值
+- 查询视图相关的纹理和帧缓冲信息
 
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
+| [`OpenGLDepthStencilView`](constructor.md) | 构造函数 |
+| [`~OpenGLDepthStencilView`](destructor.md) | 析构函数 |
 | [`Initialize`](initialize.md) | 初始化深度模板视图 |
 | [`InitializeCubemap`](initialize-cubemap.md) | 初始化立方体贴图深度模板视图 |
 | [`Shutdown`](shutdown.md) | 关闭深度模板视图 |
@@ -24,6 +36,12 @@
 | [`BindFramebuffer`](bind-framebuffer.md) | 绑定帧缓冲 |
 | [`UnbindFramebuffer`](unbind-framebuffer.md) | 解绑帧缓冲 |
 
+## 相关结构体与枚举
+
+- [`OpenGLDepthStencilViewDesc`](openGLDepthStencilViewDesc.md) - 深度模板视图描述结构体
+- [`DepthStencilFormat`](depth-stencil-format.md) - 深度模板格式枚举
+- [`DepthStencilType`](depth-stencil-type.md) - 深度模板类型枚举
+
 ## 相关文档
 
 - [OpenGL 后端总览](../overview.md)

docs/api/rhi/opengl/depth-stencil-view/destructor.md

@@ -0,0 +1,11 @@
+# OpenGLDepthStencilView::~OpenGLDepthStencilView
+
+```cpp
+~OpenGLDepthStencilView();
+```
+
+析构函数，自动调用 `Shutdown()` 释放资源。
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览

docs/api/rhi/opengl/depth-stencil-view/get-framebuffer.md

@@ -4,9 +4,9 @@
 unsigned int GetFramebuffer() const
 ```
 
-获取帧缓冲区对象 ID。
+获取与此深度模板视图关联的帧缓冲对象 ID。
 
-**返回：** `unsigned int` - 帧缓冲区 ID
+**返回：** `unsigned int` - 帧缓冲区 OpenGL 对象 ID
 
 **示例：**
 

docs/api/rhi/opengl/depth-stencil-view/get-mip-level.md

@@ -4,9 +4,9 @@
 int GetMipLevel() const
 ```
 
-获取 mipmap 级别。
+获取此深度模板视图所绑定的 mipmap 级别。
 
-**返回：** `int` - mip 级别
+**返回：** `int` - mip 级别索引
 
 **示例：**
 

docs/api/rhi/opengl/depth-stencil-view/get-size.md

@@ -5,9 +5,9 @@ int GetWidth() const;
 int GetHeight() const;
 ```
 
-获取深度模板视图的宽度和高度。
+获取深度模板视图的宽度和高度（以像素为单位）。
 
-**返回：** 宽度/高度
+**返回：** `int` - 视图的宽度/高度值
 
 ## 相关文档
 

docs/api/rhi/opengl/depth-stencil-view/get-texture.md

@@ -4,9 +4,9 @@
 unsigned int GetTexture() const
 ```
 
-获取关联的纹理对象 ID。
+获取创建此深度模板视图时使用的原始纹理对象 ID。
 
-**返回：** `unsigned int` - 纹理 ID
+**返回：** `unsigned int` - 纹理 OpenGL 对象 ID
 
 **示例：**
 

docs/api/rhi/opengl/depth-stencil-view/initialize.md

@@ -1,17 +1,61 @@
 # OpenGLDepthStencilView::Initialize
 
-```cpp
-bool Initialize(unsigned int texture, int width, int height);
-```
-
 初始化深度模板视图。
 
+## 重载 1
+
+```cpp
+bool Initialize(unsigned int texture, const OpenGLDepthStencilViewDesc& desc);
+```
+
+使用描述结构体初始化深度模板视图，将指定的 OpenGL 纹理创建为深度模板帧缓冲对象。
+
 **参数：**
 - `texture` - OpenGL 纹理 ID
-- `width` - 宽度
-- `height` - 高度
+- `desc` - 深度模板视图描述结构体
 
-**返回：** 成功返回 true
+**返回：** 成功返回 `true`，失败返回 `false`。失败时帧缓冲不会被创建。
+
+**示例：**
+
+```cpp
+OpenGLDepthStencilView dsv;
+OpenGLDepthStencilViewDesc desc;
+desc.type = DepthStencilType::Texture2D;
+desc.mipLevel = 0;
+desc.baseArraySlice = 0;
+desc.arraySize = 1;
+dsv.Initialize(textureID, desc);
+```
+
+## 重载 2
+
+```cpp
+bool Initialize(unsigned int texture, int mipLevel = 0);
+```
+
+使用简单参数初始化深度模板视图。
+
+**参数：**
+- `texture` - OpenGL 纹理 ID
+- `mipLevel` - mipmap 级别（默认为 0）
+
+**返回：** 成功返回 true，失败返回 false
+
+**示例：**
+
+```cpp
+// 使用描述结构体初始化
+OpenGLDepthStencilViewDesc desc;
+desc.type = DepthStencilType::Texture2D;
+desc.mipLevel = 0;
+desc.baseArraySlice = 0;
+desc.arraySize = 1;
+dsv.Initialize(textureID, desc);
+
+// 使用简单参数初始化
+dsv.Initialize(textureID, 0);
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/depth-stencil-view/openGLDepthStencilViewDesc.md

@@ -0,0 +1,30 @@
+# OpenGLDepthStencilViewDesc
+
+**命名空间**: `XCEngine::RHI`
+
+**描述**: 深度模板视图描述结构体。
+
+## 成员变量
+
+| 成员 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `type` | `DepthStencilType` | `Texture2D` | 深度模板视图类型 |
+| `mipLevel` | `int` | `0` | mipmap 级别 |
+| `baseArraySlice` | `int` | `0` | 数组起始索引 |
+| `arraySize` | `int` | `1` | 数组大小 |
+| `layer` | `int` | `0` | 层索引 |
+
+## 示例
+
+```cpp
+OpenGLDepthStencilViewDesc desc;
+desc.type = DepthStencilType::Texture2D;
+desc.mipLevel = 0;
+desc.baseArraySlice = 0;
+desc.arraySize = 1;
+desc.layer = 0;
+```
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览

docs/api/rhi/opengl/depth-stencil-view/shutdown.md

@@ -4,7 +4,13 @@
 void Shutdown();
 ```
 
-关闭深度模板视图。
+关闭深度模板视图，释放关联的帧缓冲对象资源。调用此方法后会删除帧缓冲并将内部状态重置为初始值。
+
+**返回值：** `void`
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览
 
 ## 相关文档
 

docs/api/rhi/opengl/depth-stencil-view/unbind-framebuffer.md

@@ -4,7 +4,9 @@
 static void UnbindFramebuffer()
 ```
 
-静态方法，解除当前深度模板帧缓冲区的绑定。
+静态方法，将默认帧缓冲（framebuffer 0）绑定为当前深度模板帧缓冲区，用于解除任何自定义深度模板帧缓冲的绑定。
+
+**返回值：** `void`
 
 **示例：**
 

docs/api/rhi/opengl/depth-stencil-view/unbind.md

@@ -1,10 +1,16 @@
 # OpenGLDepthStencilView::Unbind
 
 ```cpp
-void Unbind() const;
+void Unbind();
 ```
 
-解除绑定深度模板视图。
+解除深度模板视图的帧缓冲绑定，将主帧缓冲（默认帧缓冲）重新绑定到当前 OpenGL 上下文。
+
+**返回值：** `void`
+
+## 相关文档
+
+- [OpenGLDepthStencilView 总览](depth-stencil-view.md) - 返回类总览
 
 ## 相关文档
 

docs/api/rhi/opengl/device/compile-shader.md

@@ -0,0 +1,73 @@
+# OpenGLDevice::CompileShader
+
+```cpp
+RHIShader* CompileShader(const ShaderCompileDesc& desc) override
+```
+
+编译着色器程序。
+
+## 详细描述
+
+从文件加载并编译着色器代码。
+
+### 支持的着色器类型
+
+通过 `profile` 参数指定：
+- `"vs"` / `"vert"` - 顶点着色器
+- `"fs"` / `"frag"` - 片段着色器
+- `"gs"` - 几何着色器
+- `"cs"` / `"compute"` - 计算着色器
+- `"ts"` / `"tess"` - 曲面细分着色器
+
+### 着色器编译流程
+
+1. 从文件读取着色器源码
+2. 根据 `profile` 选择着色器类型
+3. 编译着色器源码
+4. 链接程序（如果需要）
+
+## 参数
+
+- `desc` - 着色器编译描述符
+
+### ShaderCompileDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `fileName` | 着色器文件路径（宽字符） |
+| `entryPoint` | 入口点名称（默认 "main"） |
+| `profile` | 着色器配置文件（如 "vs", "fs"） |
+
+## 返回值
+
+`RHIShader*` - 创建的着色器指针，编译失败返回包含错误的着色器对象
+
+## 注意事项
+
+- `fileName` 使用宽字符 (`std::wstring`)
+- `entryPoint` 和 `profile` 从宽字符转换为窄字符
+- 如果 `fileName` 为空，不执行编译但仍返回着色器对象
+- 返回的着色器对象归调用者所有，需自行管理生命周期
+
+## 示例
+
+```cpp
+ShaderCompileDesc vsDesc;
+vsDesc.fileName = L"shaders/triangle.vert";
+vsDesc.entryPoint = L"main";
+vsDesc.profile = L"vs";
+
+RHIShader* vertexShader = device.CompileShader(vsDesc);
+
+ShaderCompileDesc fsDesc;
+fsDesc.fileName = L"shaders/triangle.frag";
+fsDesc.entryPoint = L"main";
+fsDesc.profile = L"fs";
+
+RHIShader* fragmentShader = device.CompileShader(fsDesc);
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLShader](../opengl-shader.md) - OpenGL 着色器实现

docs/api/rhi/opengl/device/constructor.md

@@ -0,0 +1,29 @@
+# OpenGLDevice::OpenGLDevice
+
+```cpp
+OpenGLDevice()
+```
+
+默认构造函数，创建一个未初始化的 `OpenGLDevice` 实例。
+
+## 详细描述
+
+构造函数创建 `OpenGLDevice` 对象并初始化内部状态：
+- `m_window` 设为 `nullptr`
+- `m_initialized` 设为 `false`
+- `m_ownsWindow` 设为 `false`
+
+设备在使用前必须调用 `Initialize()` 或 `InitializeWithExistingWindow()` 进行初始化。
+
+## 示例
+
+```cpp
+OpenGLDevice* device = new OpenGLDevice();
+// 后续需要调用 Initialize() 进行初始化
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [Initialize](initialize.md) - 初始化设备
+- [InitializeWithExistingWindow](initialize-with-existing-window.md) - 使用现有窗口初始化

docs/api/rhi/opengl/device/create-buffer.md

@@ -0,0 +1,67 @@
+# OpenGLDevice::CreateBuffer
+
+```cpp
+RHIBuffer* CreateBuffer(const BufferDesc& desc) override
+```
+
+创建 OpenGL 缓冲区对象。
+
+## 详细描述
+
+根据 `BufferDesc` 创建一个 OpenGL 缓冲区对象。缓冲区类型映射：
+
+| BufferDesc.bufferType | OpenGLBufferType |
+|----------------------|------------------|
+| 0 (默认) | Vertex (顶点缓冲区) |
+| 1 | Index (索引缓冲区) |
+| 2 | Uniform (常量缓冲区/Uniform Buffer) |
+
+### 缓冲区类型
+
+- **Vertex Buffer**: 存储顶点属性数据（位置、法线、UV 等）
+- **Index Buffer**: 存储顶点索引，用于索引绘制
+- **Uniform Buffer**: 存储着色器 uniforms 数据
+
+## 参数
+
+- `desc` - 缓冲区描述符
+
+### BufferDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `bufferType` | 缓冲区类型 (0=顶点, 1=索引, 2=Uniform) |
+| `size` | 缓冲区大小（字节） |
+
+## 返回值
+
+`RHIBuffer*` - 创建的缓冲区指针，失败返回 `nullptr`
+
+## 注意事项
+
+- 当前实现创建的缓冲区初始数据为 `nullptr`（空缓冲区）
+- 缓冲区创建后可使用 `OpenGLBuffer` 的接口进行数据更新
+- 返回的缓冲区对象归调用者所有，需自行管理生命周期
+
+## 示例
+
+```cpp
+// 创建顶点缓冲区
+BufferDesc vertexDesc;
+vertexDesc.bufferType = 0; // Vertex
+vertexDesc.size = sizeof(Vertex) * vertexCount;
+
+RHIBuffer* vertexBuffer = device.CreateBuffer(vertexDesc);
+
+// 创建索引缓冲区
+BufferDesc indexDesc;
+indexDesc.bufferType = 1; // Index
+indexDesc.size = sizeof(uint32_t) * indexCount;
+
+RHIBuffer* indexBuffer = device.CreateBuffer(indexDesc);
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLBuffer](../opengl-buffer.md) - OpenGL 缓冲区实现

docs/api/rhi/opengl/device/create-command-list.md

@@ -0,0 +1,49 @@
+# OpenGLDevice::CreateCommandList
+
+```cpp
+RHICommandList* CreateCommandList(const CommandListDesc& desc) override
+```
+
+创建 OpenGL 命令列表对象。
+
+## 详细描述
+
+创建用于记录 GPU 命令的命令列表对象。
+
+### OpenGL 实现
+
+当前实现创建基本的 `OpenGLCommandList`，支持：
+- 命令录制
+- 命令重放
+
+## 参数
+
+- `desc` - 命令列表描述符
+
+## 返回值
+
+`RHICommandList*` - 创建的命令列表指针
+
+## 注意事项
+
+- 返回的命令列表对象归调用者所有，需自行管理生命周期
+- 命令列表使用前可能需要额外初始化步骤
+
+## 示例
+
+```cpp
+CommandListDesc cmdDesc;
+RHICommandList* cmdList = device.CreateCommandList(cmdDesc);
+
+// 录制命令
+cmdList->Begin();
+cmdList->Draw(...);
+cmdList->End();
+
+// 提交命令
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLCommandList](../opengl-command-list.md) - OpenGL 命令列表实现

docs/api/rhi/opengl/device/create-command-queue.md

@@ -0,0 +1,45 @@
+# OpenGLDevice::CreateCommandQueue
+
+```cpp
+RHICommandQueue* CreateCommandQueue(const CommandQueueDesc& desc) override
+```
+
+创建 OpenGL 命令队列对象。
+
+## 详细描述
+
+创建用于管理命令列表提交的命令队列。
+
+### OpenGL 实现
+
+当前实现创建 `OpenGLCommandQueue`，用于：
+- 命令列表提交
+- 命令同步
+
+## 参数
+
+- `desc` - 命令队列描述符
+
+## 返回值
+
+`RHICommandQueue*` - 创建的命令队列指针
+
+## 注意事项
+
+- 返回的命令队列对象归调用者所有，需自行管理生命周期
+- OpenGL 本身没有显式的命令队列概念，此为抽象接口实现
+
+## 示例
+
+```cpp
+CommandQueueDesc queueDesc;
+RHICommandQueue* queue = device.CreateCommandQueue(queueDesc);
+
+// 提交命令列表到队列
+queue->ExecuteCommandList(cmdList);
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLCommandQueue](../opengl-command-queue.md) - OpenGL 命令队列实现

docs/api/rhi/opengl/device/create-fence.md

@@ -0,0 +1,56 @@
+# OpenGLDevice::CreateFence
+
+```cpp
+RHIFence* CreateFence(const FenceDesc& desc) override
+```
+
+创建同步栅栏对象。
+
+## 详细描述
+
+创建用于 GPU/CPU 同步的栅栏对象。
+
+### FenceDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `initialValue` | 初始值（0=未 signaled, >0=signaled） |
+
+### 行为
+
+- `initialValue > 0`: 创建时栅栏处于 signaled 状态
+- `initialValue == 0`: 创建时栅栏处于未 signaled 状态
+
+## 参数
+
+- `desc` - 栅栏描述符
+
+## 返回值
+
+`RHIFence*` - 创建的栅栏指针
+
+## 注意事项
+
+- 返回的栅栏对象归调用者所有，需自行管理生命周期
+- 栅栏用于同步 GPU 命令执行和 CPU 代码执行
+
+## 示例
+
+```cpp
+FenceDesc fenceDesc;
+fenceDesc.initialValue = 0;
+
+RHIFence* fence = device.CreateFence(fenceDesc);
+
+// 等待栅栏
+while (!fence->IsSignaled()) {
+    // 等待或做其他工作
+}
+
+// GPU 命令完成，栅栏 signaled
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLFence](../opengl-fence.md) - OpenGL 栅栏实现

docs/api/rhi/opengl/device/create-pipeline-state.md

@@ -0,0 +1,53 @@
+# OpenGLDevice::CreatePipelineState
+
+```cpp
+RHIPipelineState* CreatePipelineState(const PipelineStateDesc& desc) override
+```
+
+创建图形管线状态对象。
+
+## 详细描述
+
+创建封装完整渲染管线状态的 `RHIPipelineState` 对象。
+
+### 管线组件
+
+- 顶点/片段着色器
+- 顶点格式
+- 光栅化状态
+- 混合状态
+- 深度/模板状态
+- 渲染目标格式
+
+## 参数
+
+- `desc` - 管线状态描述符
+
+## 返回值
+
+`RHIPipelineState*` - 创建的管线状态指针
+
+## 注意事项
+
+- 返回的管线状态对象归调用者所有，需自行管理生命周期
+- 管线状态创建后可通过 `RHIPipelineState` 接口配置
+
+## 示例
+
+```cpp
+PipelineStateDesc psoDesc;
+psoDesc.vertexShader = vertexShader;
+psoDesc.fragmentShader = fragmentShader;
+psoDesc.vertexFormat = vertexFormat;
+// ... 设置其他管线状态
+
+RHIPipelineState* pso = device.CreatePipelineState(psoDesc);
+
+// 绑定管线状态
+pso->Bind();
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLPipelineState](../opengl-pipeline-state.md) - OpenGL 管线状态实现

docs/api/rhi/opengl/device/create-sampler.md

@@ -0,0 +1,65 @@
+# OpenGLDevice::CreateSampler
+
+```cpp
+RHISampler* CreateSampler(const SamplerDesc& desc) override
+```
+
+创建纹理采样器对象。
+
+## 详细描述
+
+创建配置纹理采样参数的状态对象。
+
+### 默认采样参数
+
+当前实现使用默认采样参数（`OpenGLSamplerDesc` 零初始化）：
+
+| 参数 | 默认值 |
+|------|--------|
+| 过滤模式 | 线性 |
+| 地址模式 | Clamp |
+| 各向异性 | 关闭 |
+
+## 参数
+
+- `desc` - 采样器描述符
+
+### SamplerDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `minFilter` | 缩小过滤模式 |
+| `magFilter` | 放大过滤模式 |
+| `addressU/V/W` | UVW 坐标寻址模式 |
+| `maxAnisotropy` | 最大各向异性级别 |
+
+## 返回值
+
+`RHISampler*` - 创建的采样器指针
+
+## 注意事项
+
+- 返回的采样器对象归调用者所有，需自行管理生命周期
+- 当前实现忽略输入的 `desc`，使用默认参数
+- 采样器需要绑定到纹理单元才能使用
+
+## 示例
+
+```cpp
+SamplerDesc samplerDesc;
+samplerDesc.minFilter = FilterMode::Linear;
+samplerDesc.magFilter = FilterMode::Linear;
+samplerDesc.addressU = AddressMode::Clamp;
+samplerDesc.addressV = AddressMode::Clamp;
+samplerDesc.maxAnisotropy = 16;
+
+RHISampler* sampler = device.CreateSampler(samplerDesc);
+
+// 绑定到纹理单元
+sampler->Bind(0);
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLSampler](../opengl-sampler.md) - OpenGL 采样器实现

docs/api/rhi/opengl/device/create-swap-chain.md

@@ -0,0 +1,61 @@
+# OpenGLDevice::CreateSwapChain
+
+```cpp
+RHISwapChain* CreateSwapChain(const SwapChainDesc& desc) override
+```
+
+创建 OpenGL 交换链对象。
+
+## 详细描述
+
+创建与设备窗口关联的交换链，用于管理前后缓冲区的交换。
+
+### 交换链行为
+
+- 使用窗口的当前尺寸初始化交换链
+- 通过 `SwapBuffers()` 执行缓冲区交换
+- 交换链与 GLFW 窗口 (`m_window`) 关联
+
+## 参数
+
+- `desc` - 交换链描述符
+
+### SwapChainDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `width` | 缓冲区宽度 |
+| `height` | 缓冲区高度 |
+
+## 返回值
+
+`RHISwapChain*` - 创建的交换链指针
+
+## 注意事项
+
+- 如果 `m_window` 为 `nullptr`，交换链创建失败
+- 返回的交换链对象归调用者所有，需自行管理生命周期
+- 交换链尺寸应与窗口尺寸匹配
+
+## 示例
+
+```cpp
+SwapChainDesc swapDesc;
+swapDesc.width = 1280;
+swapDesc.height = 720;
+
+RHISwapChain* swapChain = device.CreateSwapChain(swapDesc);
+
+// 在渲染循环中使用
+while (!device.ShouldClose()) {
+    device.PollEvents();
+    renderScene();
+    device.SwapBuffers();
+}
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLSwapChain](../opengl-swap-chain.md) - OpenGL 交换链实现
+- [SwapBuffers](swap-buffers.md) - 交换缓冲区

docs/api/rhi/opengl/device/create-texture.md

@@ -0,0 +1,81 @@
+# OpenGLDevice::CreateTexture
+
+```cpp
+RHITexture* CreateTexture(const TextureDesc& desc) override
+```
+
+创建 OpenGL 纹理对象。
+
+## 详细描述
+
+根据 `TextureDesc` 创建一个 OpenGL 纹理对象。纹理类型映射：
+
+| TextureDesc.textureType | OpenGLTextureType |
+|------------------------|-------------------|
+| 0 | Texture1D |
+| 1 (默认) | Texture2D |
+| 2 | Texture3D |
+| 3 | TextureCube |
+
+### 纹理格式
+
+当前实现固定使用 `RGBA8` (RGBA, 8 bits per channel) 格式。
+
+### 纹理参数
+
+| 参数 | 值 |
+|------|-----|
+| 格式 | RGBA8 |
+| Mipmap | 根据 `desc.mipLevels` |
+| 类型 | GL_UNSIGNED_BYTE |
+
+## 参数
+
+- `desc` - 纹理描述符
+
+### TextureDesc 字段
+
+| 字段 | 描述 |
+|------|------|
+| `textureType` | 纹理类型 (0=1D, 1=2D, 2=3D, 3=Cube) |
+| `width` | 纹理宽度 |
+| `height` | 纹理高度 |
+| `depth` | 纹理深度（用于 3D 纹理） |
+| `mipLevels` | Mipmap 级别数量 |
+
+## 返回值
+
+`RHITexture*` - 创建的纹理指针
+
+## 注意事项
+
+- 当前实现创建的纹理初始数据为 `nullptr`（空纹理）
+- 返回的纹理对象归调用者所有，需自行管理生命周期
+- 1D 纹理使用 `height=1`，3D 纹理使用 `depth` 参数
+
+## 示例
+
+```cpp
+// 创建 2D 纹理
+TextureDesc tex2dDesc;
+tex2dDesc.textureType = 1; // Texture2D
+tex2dDesc.width = 1024;
+tex2dDesc.height = 1024;
+tex2dDesc.mipLevels = 1;
+
+RHITexture* tex2d = device.CreateTexture(tex2dDesc);
+
+// 创建立方体纹理
+TextureDesc texCubeDesc;
+texCubeDesc.textureType = 3; // TextureCube
+texCubeDesc.width = 512;
+texCubeDesc.height = 512;
+texCubeDesc.mipLevels = 1;
+
+RHITexture* texCube = device.CreateTexture(texCubeDesc);
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [OpenGLTexture](../opengl-texture.md) - OpenGL 纹理实现

docs/api/rhi/opengl/device/destructor.md

@@ -0,0 +1,33 @@
+# OpenGLDevice::~OpenGLDevice
+
+```cpp
+~OpenGLDevice() override
+```
+
+析构函数，销毁 `OpenGLDevice` 实例。
+
+## 详细描述
+
+析构函数调用 `Shutdown()` 清理资源：
+- 如果设备拥有窗口 (`m_ownsWindow == true`)，则销毁 GLFW 窗口
+- 重置所有内部状态
+
+## 注意事项
+
+- 建议在销毁前显式调用 `Shutdown()` 以确保资源正确释放
+- 析构函数是虚函数，支持多态删除
+
+## 示例
+
+```cpp
+{
+    OpenGLDevice device;
+    device.Initialize(desc);
+    // ... 使用设备
+} // 析构时自动调用 Shutdown()
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [Shutdown](shutdown.md) - 关闭设备

docs/api/rhi/opengl/device/device.md

@@ -2,34 +2,101 @@
 
 **命名空间**: `XCEngine::RHI`
 
-**描述**: OpenGL 设备的实现，继承自 `RHIDevice`。
+**继承自**: `RHIDevice`
+
+**描述**: OpenGL 设备的实现，基于 GLFW 和 Glad 提供 OpenGL 图形渲染能力。支持创建窗口、管理渲染资源、编译着色器等核心 RHI 功能。
+
+## 概述
+
+`OpenGLDevice` 是 XCEngine RHI 模块的 OpenGL 后端实现，通过 GLFW 管理窗口上下文，使用 Glad 加载 OpenGL 函数。它继承自抽象接口 `RHIDevice`，提供与具体图形 API 无关的统一接口。
+
+### 主要功能
+
+- 基于 GLFW 的窗口管理和事件处理
+- OpenGL 3.3 Core Profile 上下文初始化
+- 使用 Glad 动态加载 OpenGL 函数
+- 设备能力查询和信息收集
+- 渲染资源创建（缓冲区、纹理、着色器等）
+
+### 版本要求
+
+- OpenGL 3.3 Core Profile
+- GLFW 3.0+
+- Glad OpenGL 3.3+
 
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
-| [`Initialize`](../../../threading/task-system/initialize.md) | 初始化设备 |
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭设备 |
+| [`OpenGLDevice`](constructor.md) | 构造函数 |
+| [`~OpenGLDevice`](destructor.md) | 析构函数 |
+| [`Initialize`](initialize.md) | 初始化设备 |
+| [`Shutdown`](shutdown.md) | 关闭设备 |
 | [`CreateRenderWindow`](create-render-window.md) | 创建渲染窗口 |
 | [`InitializeWithExistingWindow`](initialize-with-existing-window.md) | 使用现有窗口初始化 |
-| [`GetWindow`](get-window.md) | 获取窗口 |
-| [`SwapBuffers`](swap-buffers.md) | 交换缓冲 |
+| [`GetWindow`](get-window.md) | 获取 GLFW 窗口指针 |
+| [`GetDeviceInfoImpl`](get-device-info-impl.md) | 获取设备信息实现 |
+| [`SwapBuffers`](swap-buffers.md) | 交换前后缓冲区 |
 | [`PollEvents`](poll-events.md) | 处理窗口事件 |
 | [`SetShouldClose`](set-should-close.md) | 设置关闭标志 |
 | [`ShouldClose`](should-close.md) | 检查是否应关闭 |
-| [`CreateBuffer`](../../device/create-buffer.md) | 创建缓冲区 |
-| [`CreateTexture`](../../device/create-texture.md) | 创建纹理 |
-| [`CreateSwapChain`](../../device/create-swap-chain.md) | 创建交换链 |
-| [`CreateCommandList`](../../device/create-command-list.md) | 创建命令列表 |
-| [`CreateCommandQueue`](../../device/create-command-queue.md) | 创建命令队列 |
-| [`CompileShader`](../../device/compile-shader.md) | 编译着色器 |
-| [`CreatePipelineState`](../../device/create-pipeline-state.md) | 创建管线状态 |
-| [`CreateFence`](../../device/create-fence.md) | 创建栅栏 |
-| [`CreateSampler`](../../device/create-sampler.md) | 创建采样器 |
-| [`GetCapabilities`](../../device/get-capabilities.md) | 获取设备能力 |
-| [`GetDeviceInfo`](../../device/get-device-info.md) | 获取设备信息 |
-| [`GetNativeDevice`](../../device/get-native-device.md) | 获取原生设备 |
-| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
+| [`CreateBuffer`](create-buffer.md) | 创建缓冲区 |
+| [`CreateTexture`](create-texture.md) | 创建纹理 |
+| [`CreateSwapChain`](create-swap-chain.md) | 创建交换链 |
+| [`CreateCommandList`](create-command-list.md) | 创建命令列表 |
+| [`CreateCommandQueue`](create-command-queue.md) | 创建命令队列 |
+| [`CompileShader`](compile-shader.md) | 编译着色器 |
+| [`CreatePipelineState`](create-pipeline-state.md) | 创建管线状态 |
+| [`CreateFence`](create-fence.md) | 创建栅栏 |
+| [`CreateSampler`](create-sampler.md) | 创建采样器 |
+| [`GetCapabilities`](get-capabilities.md) | 获取设备能力 |
+| [`GetDeviceInfo`](get-device-info.md) | 获取设备信息 |
+| [`GetNativeDevice`](get-native-device.md) | 获取原生设备 |
+| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 |
+
+## 使用示例
+
+```cpp
+#include "XCEngine/RHI/OpenGL/OpenGLDevice.h"
+
+using namespace XCEngine::RHI;
+
+// 创建并初始化 OpenGL 设备
+OpenGLDevice device;
+RHIDeviceDesc desc;
+desc.width = 1280;
+desc.height = 720;
+desc.appName = L"XCEngine App";
+desc.enableDebugLayer = true;
+
+if (!device.Initialize(desc)) {
+    return false;
+}
+
+// 渲染循环
+while (!device.ShouldClose()) {
+    device.PollEvents();
+    
+    // 渲染逻辑
+    renderScene();
+    
+    device.SwapBuffers();
+}
+
+// 清理
+device.Shutdown();
+```
+
+### 使用已有 GLFW 窗口
+
+```cpp
+GLFWwindow* existingWindow = glfwCreateWindow(1280, 720, "My Window", nullptr, nullptr);
+
+OpenGLDevice device;
+if (device.InitializeWithExistingWindow(existingWindow)) {
+    // 使用已有窗口继续渲染
+}
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/device/get-capabilities.md

@@ -0,0 +1,57 @@
+# OpenGLDevice::GetCapabilities
+
+```cpp
+const RHICapabilities& GetCapabilities() const override
+```
+
+获取 OpenGL 设备能力。
+
+## 详细描述
+
+返回设备的硬件能力和特性支持信息。能力信息在 `InitializeWithExistingWindow()` 期间通过查询 OpenGL 获得。
+
+### 查询的能力项
+
+| 能力字段 | 描述 | OpenGL 查询 |
+|----------|------|-------------|
+| `majorVersion` | OpenGL 主版本 | GL_MAJOR_VERSION |
+| `minorVersion` | OpenGL 次版本 | GL_MINOR_VERSION |
+| `bSupportsGeometryShaders` | 几何着色器支持 | 始终 true |
+| `bSupportsComputeShaders` | 计算着色器支持 | GL_VERSION >= 4.3 |
+| `bSupportsTessellation` | 曲面细分支持 | GL_VERSION >= 4.1 |
+| `bSupportsExplicitMultiThreading` | 多线程支持 | 始终 false |
+| `maxTexture2DSize` | 2D 纹理最大尺寸 | GL_MAX_TEXTURE_SIZE |
+| `maxTextureCubeSize` | 立方体贴图最大尺寸 | GL_MAX_CUBE_MAP_TEXTURE_SIZE |
+| `maxRenderTargets` | 最大渲染目标数 | GL_MAX_DRAW_BUFFERS |
+| `maxColorAttachments` | 最大颜色附件数 | GL_MAX_DRAW_BUFFERS |
+| `maxViewports` | 最大视口数 | GL_MAX_VIEWPORTS |
+| `maxAnisotropy` | 最大各向异性级别 | GL_MAX_TEXTURE_MAX_ANISOTROPY |
+| `maxVertexAttribs` | 最大顶点属性数 | GL_MAX_VERTEX_ATTRIBS |
+
+## 返回值
+
+`const RHICapabilities&` - 设备能力结构的常量引用
+
+## 复杂度
+
+O(1) - 返回内部缓存的能力信息
+
+## 示例
+
+```cpp
+const RHICapabilities& caps = device.GetCapabilities();
+
+std::cout << "OpenGL Version: " << caps.majorVersion << "." << caps.minorVersion << std::endl;
+std::cout << "Max Texture Size: " << caps.maxTexture2DSize << std::endl;
+std::cout << "Max Render Targets: " << caps.maxRenderTargets << std::endl;
+
+if (caps.bSupportsComputeShaders) {
+    std::cout << "Compute shaders supported" << std::endl;
+}
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [RHICapabilities](../../capabilities/capabilities.md) - 能力结构定义
+- [GetDeviceInfo](get-device-info.md) - 获取设备信息

docs/api/rhi/opengl/device/get-device-info-impl.md

@@ -0,0 +1,39 @@
+# OpenGLDevice::GetDeviceInfoImpl
+
+```cpp
+const RHIDeviceInfo& GetDeviceInfoImpl() const
+```
+
+获取设备信息的内部实现。
+
+## 详细描述
+
+返回存储在设备中的 `RHIDeviceInfo` 结构，包含 OpenGL 设备的具体信息：
+- **vendor**: GPU 厂商名称
+- **renderer**: GPU 渲染器名称
+- **version**: OpenGL 驱动版本
+- **majorVersion**: OpenGL 主版本号
+- **minorVersion**: OpenGL 次版本号
+
+此方法直接返回内部缓存的设备信息，无需额外查询。
+
+## 返回值
+
+`const RHIDeviceInfo&` - 设备信息结构的常量引用
+
+## 复杂度
+
+O(1)
+
+## 示例
+
+```cpp
+const RHIDeviceInfo& info = device.GetDeviceInfoImpl();
+std::wcout << L"GPU: " << info.renderer << std::endl;
+std::wcout << L"OpenGL Version: " << info.majorVersion << L"." << info.minorVersion << std::endl;
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [GetDeviceInfo](get-device-info.md) - 获取设备信息（公共接口）

docs/api/rhi/opengl/device/get-device-info.md

@@ -0,0 +1,53 @@
+# OpenGLDevice::GetDeviceInfo
+
+```cpp
+const RHIDeviceInfo& GetDeviceInfo() const override
+```
+
+获取 OpenGL 设备信息。
+
+## 详细描述
+
+返回设备的标识和版本信息。设备信息在 `InitializeWithExistingWindow()` 期间通过 `glGetString()` 和 `glGetIntegerv()` 查询获得。
+
+### 设备信息内容
+
+| 信息字段 | 描述 | OpenGL 来源 |
+|----------|------|-------------|
+| `vendor` | GPU 厂商 | GL_VENDOR |
+| `renderer` | GPU 渲染器名称 | GL_RENDERER |
+| `version` | OpenGL 版本字符串 | GL_VERSION |
+| `majorVersion` | OpenGL 主版本号 | GL_MAJOR_VERSION |
+| `minorVersion` | OpenGL 次版本号 | GL_MINOR_VERSION |
+
+### 厂商示例
+
+- **NVIDIA**: "NVIDIA Corporation"
+- **AMD**: "AMD" 或 "Advanced Micro Devices, Inc."
+- **Intel**: "Intel" 或 "Intel Corporation"
+
+## 返回值
+
+`const RHIDeviceInfo&` - 设备信息结构的常量引用
+
+## 复杂度
+
+O(1) - 返回内部缓存的设备信息
+
+## 示例
+
+```cpp
+const RHIDeviceInfo& info = device.GetDeviceInfo();
+
+std::wcout << L"Vendor: " << info.vendor << std::endl;
+std::wcout << L"Renderer: " << info.renderer << std::endl;
+std::wcout << L"Version: " << info.version << std::endl;
+std::cout << "GL Version: " << info.majorVersion << "." << info.minorVersion << std::endl;
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [RHIDeviceInfo](../../types/device-info.md) - 设备信息结构定义
+- [GetCapabilities](get-capabilities.md) - 获取设备能力
+- [GetDeviceInfoImpl](get-device-info-impl.md) - 获取设备信息实现

docs/api/rhi/opengl/device/get-native-device.md

@@ -0,0 +1,35 @@
+# OpenGLDevice::GetNativeDevice
+
+```cpp
+void* GetNativeDevice() override
+```
+
+获取原生图形设备指针。
+
+## 详细描述
+
+返回原生图形 API 的设备指针。OpenGL 是一种状态机模型，没有传统意义上的"设备"对象，因此此方法返回 `nullptr`。
+
+## 返回值
+
+`void*` - 始终返回 `nullptr`（OpenGL 无原生设备对象）
+
+## 注意事项
+
+- OpenGL 使用隐式状态机模式，不需要显式的设备对象
+- 如需获取 OpenGL 上下文相关信息，使用 `GetCapabilities()` 或 `GetDeviceInfo()`
+- 如需获取窗口句柄，使用 `GetWindow()` 方法
+
+## 示例
+
+```cpp
+void* native = device.GetNativeDevice();
+// 注意：当前实现返回 nullptr
+// OpenGL 为状态机，无需设备对象
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [GetWindow](get-window.md) - 获取 GLFW 窗口
+- [GetCapabilities](get-capabilities.md) - 获取设备能力

docs/api/rhi/opengl/device/get-native-handle.md

@@ -0,0 +1,26 @@
+# OpenGLDevice::GetNativeHandle
+
+```cpp
+void* GetNativeHandle() const
+```
+
+获取原生窗口或渲染上下文句柄。
+
+**返回：** `void*` - 原生句柄（当前实现返回 `nullptr`）
+
+**复杂度：** O(1)
+
+**注意：** 此方法当前实现返回 `nullptr`。使用 `GetWindow()` 获取 GLFW 窗口指针。
+
+**示例：**
+
+```cpp
+void* handle = device.GetNativeHandle();
+// 注意：当前实现返回 nullptr
+GLFWwindow* window = device.GetWindow(); // 使用此方法获取窗口
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 返回类总览
+- [GetWindow](get-window.md) - 获取 GLFW 窗口指针

docs/api/rhi/opengl/device/initialize.md

@@ -0,0 +1,64 @@
+# OpenGLDevice::Initialize
+
+```cpp
+bool Initialize(const RHIDeviceDesc& desc) override
+```
+
+初始化 OpenGL 设备。
+
+## 详细描述
+
+根据 `RHIDeviceDesc` 初始化 OpenGL 设备。初始化过程包括：
+
+1. **检查是否已初始化**: 如果已初始化，直接返回 `true`
+2. **窗口处理**:
+   - 如果 `desc.windowHandle` 提供现有窗口，调用 `InitializeWithExistingWindow()`
+   - 否则调用 `CreateRenderWindow()` 创建新窗口
+3. **GLFW 初始化**: 确保 GLFW 库已初始化
+4. **OpenGL 上下文**: 创建 OpenGL 3.3 Core Profile 上下文
+5. **Glad 加载**: 使用 Glad 动态加载 OpenGL 函数
+6. **设备信息收集**: 获取 GPU 厂商、渲染器、版本等信息
+7. **能力查询**: 查询并存储 OpenGL 设备能力
+
+### RHIDeviceDesc 字段说明
+
+| 字段 | 描述 |
+|------|------|
+| `width` | 窗口宽度（当创建新窗口时） |
+| `height` | 窗口高度（当创建新窗口时） |
+| `appName` | 应用程序名称（用于窗口标题） |
+| `enableDebugLayer` | 是否启用调试上下文 |
+| `windowHandle` | 现有 GLFW 窗口句柄（可选） |
+
+## 参数
+
+- `desc` - 设备描述符，包含初始化参数
+
+## 返回值
+
+`bool` - 初始化成功返回 `true`，失败返回 `false`
+
+## 示例
+
+```cpp
+OpenGLDevice device;
+RHIDeviceDesc desc;
+desc.width = 1920;
+desc.height = 1080;
+desc.appName = L"My OpenGL App";
+desc.enableDebugLayer = true;
+
+if (!device.Initialize(desc)) {
+    // 处理初始化失败
+    return;
+}
+
+// 设备已就绪，可以开始渲染
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [CreateRenderWindow](create-render-window.md) - 创建渲染窗口
+- [InitializeWithExistingWindow](initialize-with-existing-window.md) - 使用现有窗口初始化
+- [Shutdown](shutdown.md) - 关闭设备

docs/api/rhi/opengl/device/shutdown.md

@@ -0,0 +1,49 @@
+# OpenGLDevice::Shutdown
+
+```cpp
+void Shutdown() override
+```
+
+关闭 OpenGL 设备并释放相关资源。
+
+## 详细描述
+
+关闭 OpenGL 设备并执行清理操作：
+
+1. **窗口销毁**: 如果设备拥有窗口 (`m_ownsWindow == true`)，调用 `glfwDestroyWindow()` 销毁 GLFW 窗口
+2. **状态重置**: 
+   - `m_window` 设为 `nullptr`
+   - `m_initialized` 设为 `false`
+   - `m_ownsWindow` 设为 `false`
+
+### 窗口所有权
+
+设备可能通过两种方式获得窗口：
+- **自有窗口**: 通过 `CreateRenderWindow()` 创建，设备负责销毁
+- **外部窗口**: 通过 `InitializeWithExistingWindow()` 传入，设备不负责销毁
+
+## 注意事项
+
+- 多次调用 `Shutdown()` 是安全的
+- 销毁窗口后，与该窗口关联的 OpenGL 上下文将无效
+- 建议在程序结束前显式调用 `Shutdown()`
+
+## 示例
+
+```cpp
+{
+    OpenGLDevice device;
+    device.Initialize(desc);
+    
+    // ... 使用设备进行渲染
+    
+    device.Shutdown(); // 显式关闭
+}
+// 或等待析构函数自动调用
+```
+
+## 相关文档
+
+- [OpenGLDevice](device.md) - 类总览
+- [Initialize](initialize.md) - 初始化设备
+- [CreateRenderWindow](create-render-window.md) - 创建渲染窗口

docs/api/rhi/opengl/fence/fence.md

@@ -2,22 +2,71 @@
 
 **命名空间**: `XCEngine::RHI`
 
-**描述**: OpenGL 栅栏同步实现，继承自 `RHIFence`。
+**描述**: OpenGL 栅栏同步实现，继承自 `RHIFence`。使用 OpenGL `GLsync` 对象实现 CPU-GPU 同步机制。
+
+## 概述
+
+`OpenGLFence` 提供基于 OpenGL 同步对象（`GLsync`）的栅栏实现，用于 CPU-GPU 同步。当 GPU 完成特定操作后，栅栏会被设置为 signaled 状态，CPU 可以通过 `Wait` 方法等待该状态。
+
+### FenceStatus 枚举
+
+```cpp
+enum class FenceStatus {
+    Signaled,    // 栅栏已signaled，操作已完成
+    Unsignaled,  // 栅栏未signaled，操作未完成
+    Error        // 发生错误
+};
+```
+
+### 私有成员
+
+| 成员 | 类型 | 描述 |
+|------|------|------|
+| `m_sync` | `void*` | OpenGL GLsync 句柄 |
+| `m_fenceValue` | `uint64_t` | 当前栅栏值 |
+| `m_completedValue` | `uint64_t` | 已完成的栅栏值 |
+| `m_signaled` | `bool` | 软件层面的signaled状态标志 |
 
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
-| [`Initialize`](initialize.md) | 初始化栅栏 |
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭栅栏 |
-| [`Signal`](signal.md) | 信号栅栏 |
-| [`Wait`](../../../threading/task-group/wait.md) | 等待栅栏 |
-| [`Reset`](reset.md) | 重置栅栏 |
-| [`IsSignaled`](is-signaled.md) | 检查是否已信号 |
-| [`GetStatus`](get-status.md) | 获取状态 |
-| [`GetCompletedValue`](get-completed-value.md) | 获取完成值 |
-| [`GetCurrentValue`](get-current-value.md) | 获取当前值 |
-| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
+| [`Initialize`](initialize.md) | 初始化栅栏，设置初始值和状态 |
+| [`Shutdown`](shutdown.md) | 关闭栅栏，释放 GLsync 资源 |
+| [`Signal`](signal.md) | 信号栅栏，创建/更新同步对象 |
+| [`Wait`](wait.md) | 等待栅栏达到 signaled 状态 |
+| [`Reset`](reset.md) | 重置栅栏，删除同步对象 |
+| [`IsSignaled`](is-signaled.md) | 检查软件层面的signaled状态 |
+| [`GetStatus`](get-status.md) | 获取 OpenGL 层面的同步状态 |
+| [`GetCompletedValue`](get-completed-value.md) | 获取已完成的栅栏值 |
+| [`GetCurrentValue`](get-current-value.md) | 获取当前栅栏值 |
+| [`GetNativeHandle`](get-native-handle.md) | 获取原生 GLsync 句柄 |
+
+## 使用示例
+
+```cpp
+#include "XCEngine/RHI/OpenGL/OpenGLFence.h"
+
+using namespace XCEngine::RHI;
+
+// 创建并初始化栅栏
+OpenGLFence fence;
+fence.Initialize(false);
+
+// 执行 GPU 操作后信号栅栏
+fence.Signal();
+
+// 等待栅栏，最多等待 1 秒
+fence.Wait(1000000000);
+
+// 检查状态
+if (fence.IsSignaled()) {
+    // 操作已完成
+}
+
+// 重置并复用
+fence.Reset();
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/fence/get-completed-value.md

@@ -1,19 +1,41 @@
 # OpenGLFence::GetCompletedValue
 
 ```cpp
-uint64_t GetCompletedValue() const override
+uint64_t GetCompletedValue() const override;
 ```
 
 获取已完成的最大栅栏值。
 
-**返回：** `uint64_t` - 已完成的栅栏值
+## 详细描述
 
-**示例：**
+返回 `m_completedValue`，表示已确认完成的栅栏值。每次 `Wait()` 成功返回且同步对象已信号时更新。
+
+此值用于判断在 `Wait(value)` 中指定的栅栏值是否已完成。
+
+## 参数
+
+无
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `uint64_t` | 已完成的栅栏值 |
+
+## 示例
 
 ```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal(5);
+fence.Wait(1000000000); // 等待完成后
+
 uint64_t completed = fence.GetCompletedValue();
+// completed >= 5
 ```
 
 ## 相关文档
 
-- [OpenGLFence](fence.md) - 返回类总览
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [GetCurrentValue](get-current-value.md) - 获取当前栅栏值
+- [Wait](wait.md) - 等待特定栅栏值

docs/api/rhi/opengl/fence/get-current-value.md

@@ -1,19 +1,41 @@
 # OpenGLFence::GetCurrentValue
 
 ```cpp
-uint64_t GetCurrentValue() const
+uint64_t GetCurrentValue() const;
 ```
 
 获取栅栏的当前值。
 
-**返回：** `uint64_t` - 当前栅栏值
+## 详细描述
 
-**示例：**
+返回 `m_fenceValue`，表示栅栏的最新值。每次调用 `Signal()` 时更新。
+
+## 参数
+
+无
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `uint64_t` | 当前栅栏值 |
+
+## 示例
 
 ```cpp
-uint64_t current = fence.GetCurrentValue();
+OpenGLFence fence;
+fence.Initialize(false);
+
+uint64_t initial = fence.GetCurrentValue(); // 0
+
+fence.Signal();
+uint64_t afterSignal = fence.GetCurrentValue(); // 1
+
+fence.Signal(10);
+uint64_t afterValue = fence.GetCurrentValue(); // 10
 ```
 
 ## 相关文档
 
-- [OpenGLFence](fence.md) - 返回类总览
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [GetCompletedValue](get-completed-value.md) - 获取已完成的栅栏值

docs/api/rhi/opengl/fence/get-native-handle.md

@@ -0,0 +1,43 @@
+# OpenGLFence::GetNativeHandle
+
+```cpp
+void* GetNativeHandle() override;
+```
+
+获取 OpenGL 同步对象句柄。
+
+## 详细描述
+
+返回指向 `GLsync` 对象的指针。返回值为 `m_sync`，类型为 `void*`。
+
+## 参数
+
+无
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `void*` | OpenGL `GLsync` 句柄。如果未调用过 `Signal()`，则返回 `nullptr` |
+
+## 复杂度
+
+O(1) - 常数时间
+
+## 示例
+
+```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal();
+
+void* handle = fence.GetNativeHandle();
+if (handle != nullptr) {
+    // 可以传递给其他 OpenGL 函数
+    GLsync sync = static_cast<GLsync>(handle);
+}
+```
+
+## 相关文档
+
+- [OpenGLFence 总览](fence.md) - 返回类总览

docs/api/rhi/opengl/fence/get-status.md

@@ -1,25 +1,50 @@
 # OpenGLFence::GetStatus
 
 ```cpp
-FenceStatus GetStatus() const
+FenceStatus GetStatus() const;
 ```
 
 获取栅栏的当前状态。
 
-**返回：** `FenceStatus` - 栅栏状态，可能的值：
-- `FenceStatus::Signaled` - 栅栏已signaled
-- `FenceStatus::Unsignaled` - 栅栏未signaled
-- `FenceStatus::Error` - 发生错误
+## 详细描述
 
-**示例：**
+此方法查询 OpenGL 同步对象的实际状态：
+
+1. 如果 `m_sync` 为 `nullptr`，返回软件层面的 `m_signaled` 状态
+2. 如果 `m_sync` 存在，调用 `glGetSynciv(sync, GL_SYNC_STATUS, ...)` 查询 OpenGL 状态
+3. 根据 `GL_SYNC_STATUS` 返回 `FenceStatus::Signaled` 或 `FenceStatus::Unsignaled`
+
+与 `IsSignaled()` 的区别：
+- `GetStatus()`：查询 OpenGL 同步对象状态，更准确但有 GPU 开销
+- `IsSignaled()`：返回软件标志，快速但不反映 GPU 实际状态
+
+## 参数
+
+无
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `FenceStatus` | 栅栏状态，值为以下之一： |
+| | `FenceStatus::Signaled` - 栅栏已signaled，GPU 操作已完成 |
+| | `FenceStatus::Unsignaled` - 栅栏未signaled，GPU 操作未完成 |
+| | `FenceStatus::Error` - 此实现不会返回此值（错误处理在底层） |
+
+## 示例
 
 ```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal();
+
 FenceStatus status = fence.GetStatus();
 if (status == FenceStatus::Signaled) {
-    // 操作已完成
+    // GPU 操作已完成
 }
 ```
 
 ## 相关文档
 
-- [OpenGLFence](fence.md) - 返回类总览
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [IsSignaled](is-signaled.md) - 快速状态检查

docs/api/rhi/opengl/fence/initialize.md

@@ -4,20 +4,38 @@
 bool Initialize(bool signaled = false);
 ```
 
-初始化 OpenGL 栅栏。
+初始化 OpenGLFence 实例，设置栅栏的初始值和状态。
 
-**参数：**
-- `signaled` - 初始是否为 signaled 状态
+## 详细描述
 
-**返回：** 成功返回 true
+此方法不创建 OpenGL 同步对象（`GLsync`），仅初始化内部状态。`GLsync` 对象在首次调用 `Signal()` 时才被创建。
 
-**示例：**
+## 参数
+
+| 参数 | 类型 | 描述 |
+|------|------|------|
+| `signaled` | `bool` | 初始是否为 signaled 状态。默认为 `false`（Unsignaled） |
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `bool` | 始终返回 `true`。初始化成功 |
+
+## 示例
 
 ```cpp
 OpenGLFence fence;
-fence.Initialize(true);
+// 创建为 unsignaled 状态
+fence.Initialize(false);
+
+// 或创建为 already signaled 状态
+OpenGLFence fence2;
+fence2.Initialize(true);
 ```
 
 ## 相关文档
 
 - [OpenGLFence 总览](fence.md) - 返回类总览
+- [Signal](signal.md) - 创建 GLsync 对象
+- [Shutdown](shutdown.md) - 释放资源

docs/api/rhi/opengl/fence/is-signaled.md

@@ -1,21 +1,43 @@
 # OpenGLFence::IsSignaled
 
 ```cpp
-bool IsSignaled() const override
+bool IsSignaled() const override;
 ```
 
 检查栅栏是否处于 signaled 状态。
 
-**返回：** `bool` - 如果栅栏已signaled返回 true，否则返回 false
+## 详细描述
 
-**示例：**
+此方法返回软件层面的 `m_signaled` 标志状态，不查询 OpenGL 同步对象。
+
+与 `GetStatus()` 的区别：
+- `IsSignaled()`：返回软件标志，快速但可能不反映 GPU 实际状态
+- `GetStatus()`：查询 `GLsync` 对象的 OpenGL 状态，结果更准确但有额外开销
+
+## 参数
+
+无
+
+## 返回值
+
+| 类型 | 描述 |
+|------|------|
+| `bool` | `true` 表示栅栏已信号，`false` 表示未信号 |
+
+## 示例
 
 ```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+
 if (fence.IsSignaled()) {
-    // 可以安全地继续执行
+    // 操作已完成
+} else {
+    // 操作未完成
 }
 ```
 
 ## 相关文档
 
-- [OpenGLFence](fence.md) - 返回类总览
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [GetStatus](get-status.md) - 查询 OpenGL 同步状态

docs/api/rhi/opengl/fence/reset.md

@@ -4,14 +4,44 @@
 void Reset();
 ```
 
-重置栅栏。
+重置栅栏为 unsignaled 状态。
 
-**示例：**
+## 详细描述
+
+此方法执行以下操作：
+
+1. 如果存在 `m_sync`，调用 `glDeleteSync()` 删除 OpenGL 同步对象
+2. 将 `m_sync` 置为 `nullptr`
+3. 将 `m_signaled` 设置为 `false`
+
+重置后，栅栏的 `IsSignaled()` 将返回 `false`，可重新用于新的同步操作。
+
+## 参数
+
+无
+
+## 返回值
+
+无
+
+## 示例
 
 ```cpp
-fence->Reset();
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal();
+
+// 使用后重置
+fence.Reset();
+
+// 此时 IsSignaled() 返回 false
+if (!fence.IsSignaled()) {
+    // 可以重新使用
+}
 ```
 
 ## 相关文档
 
 - [OpenGLFence 总览](fence.md) - 返回类总览
+- [Signal](signal.md) - 信号栅栏
+- [IsSignaled](is-signaled.md) - 检查状态

docs/api/rhi/opengl/fence/shutdown.md

@@ -0,0 +1,39 @@
+# OpenGLFence::Shutdown
+
+```cpp
+void Shutdown() override;
+```
+
+释放 OpenGL 栅栏资源。
+
+## 详细描述
+
+如果 `m_sync` 不为 `nullptr`，调用 `glDeleteSync()` 删除 OpenGL 同步对象，然后将 `m_sync` 置为 `nullptr`。
+
+此方法由析构函数自动调用，确保资源正确释放。
+
+## 参数
+
+无
+
+## 返回值
+
+无
+
+## 示例
+
+```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal();
+
+// 显式关闭，释放 GLsync 资源
+fence.Shutdown();
+
+// fence 对象销毁时会再次调用 Shutdown，但已是安全操作
+```
+
+## 相关文档
+
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [Initialize](initialize.md) - 初始化

docs/api/rhi/opengl/fence/signal.md

@@ -1,20 +1,48 @@
 # OpenGLFence::Signal
 
 ```cpp
-void Signal() override
-void Signal(uint64_t value) override
+void Signal() override;
+void Signal(uint64_t value) override;
 ```
 
 将栅栏设置为 signaled 状态，通知等待的线程操作完成。
 
-**示例：**
+## 详细描述
+
+`Signal()` 执行以下操作：
+
+1. 调用 `glFlush()` 确保所有挂起的 OpenGL 命令已发送到 GPU
+2. 增加 `m_fenceValue`（无参版本）或设置为指定值
+3. 设置 `m_signaled = true`
+4. 如果 `m_sync` 已存在，先删除旧对象
+5. 调用 `glFenceSync()` 创建新的 `GLsync` 对象
+
+## 参数
+
+| 重载 | 参数 | 类型 | 描述 |
+|------|------|------|------|
+| `Signal()` | 无 | - | 将栅栏值增加 1 |
+| `Signal(uint64_t value)` | `value` | `uint64_t` | 设置栅栏为指定值 |
+
+## 返回值
+
+无
+
+## 示例
 
 ```cpp
 OpenGLFence fence;
 fence.Initialize(false);
+
+// 无参版本：栅栏值 +1
 fence.Signal();
+
+// 带值版本：设置指定栅栏值
+fence.Signal(5);
 ```
 
 ## 相关文档
 
-- [OpenGLFence](fence.md) - 返回类总览
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [Wait](wait.md) - 等待栅栏
+- [Initialize](initialize.md) - 初始化

docs/api/rhi/opengl/fence/wait.md

@@ -0,0 +1,50 @@
+# OpenGLFence::Wait
+
+```cpp
+void Wait(uint64_t timeoutNs) override;
+```
+
+等待栅栏达到 signaled 状态或超时。
+
+## 详细描述
+
+此方法尝试等待 `m_sync`（OpenGL 同步对象）变为 signaled 状态：
+
+- **未信号或无同步对象**：直接调用 `glFinish()` 阻塞 CPU，直到 GPU 完成所有命令，然后将 `m_completedValue` 更新为 `m_fenceValue`
+- **已信号状态**：调用 `glClientWaitSync()` 尝试获取同步状态，支持超时
+- **timeout = 0**：立即返回，不阻塞
+
+内部使用 `GL_SYNC_FLUSH_COMMANDS_BIT` 标志确保客户端命令已刷新。
+
+## 参数
+
+| 参数 | 类型 | 描述 |
+|------|------|------|
+| `timeoutNs` | `uint64_t` | 超时时间，以纳秒为单位。为 `0` 时立即返回 |
+
+## 返回值
+
+无
+
+## 示例
+
+```cpp
+OpenGLFence fence;
+fence.Initialize(false);
+fence.Signal();
+
+// 等待最多 1 秒 (1000000000 ns)
+fence.Wait(1000000000);
+
+// 等待最多 100 毫秒
+fence.Wait(100000000);
+
+// timeout = 0 立即返回
+fence.Wait(0);
+```
+
+## 相关文档
+
+- [OpenGLFence 总览](fence.md) - 返回类总览
+- [Signal](signal.md) - 信号栅栏
+- [IsSignaled](is-signaled.md) - 非阻塞检查状态

docs/api/rhi/opengl/overview.md

@@ -37,5 +37,5 @@
 
 ## 相关文档
 
-- [../rhi/rhi.md](../rhi.md) - RHI 模块总览
+- [RHI 模块总览](../rhi.md) - RHI 模块总览
 - [D3D12 后端](overview.md)

docs/api/rhi/opengl/pipeline-state/bind.md

@@ -0,0 +1,24 @@
+# OpenGLPipelineState::Bind
+
+```cpp
+void Bind() override;
+```
+
+绑定管线状态到当前渲染上下文。
+
+**线程安全：** ❌
+
+**注意：** 如果 shader 已附加（通过 `AttachShader`），则调用 `glUseProgram`。然后调用 `Apply()` 应用所有状态。
+
+**示例：**
+
+```cpp
+pipelineState->AttachShader(program);
+pipelineState->Bind();
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [Unbind](unbind.md) - 解绑管线状态
+- [AttachShader](attach-shader.md) - 附加着色器

docs/api/rhi/opengl/pipeline-state/clear.md

@@ -0,0 +1,31 @@
+# OpenGLPipelineState::Clear
+
+```cpp
+void Clear(unsigned int buffers);
+```
+
+清除指定的缓冲区。
+
+**参数：**
+- `buffers` - 要清除的缓冲区标志位
+  - `1` - 颜色缓冲区 (`GL_COLOR_BUFFER_BIT`)
+  - `2` - 深度缓冲区 (`GL_DEPTH_BUFFER_BIT`)
+  - `4` - 模板缓冲区 (`GL_STENCIL_BUFFER_BIT`)
+
+**线程安全：** ❌
+
+**注意：** 调用此方法前应先通过 `SetClearColor` 设置清除颜色。
+
+**示例：**
+
+```cpp
+pipelineState->SetClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+pipelineState->Clear(0x1); // 清除颜色缓冲
+pipelineState->Clear(0x3); // 清除颜色和深度缓冲
+pipelineState->Clear(0x7); // 清除所有缓冲
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [SetClearColor](set-clear-color.md) - 设置清除颜色

docs/api/rhi/opengl/pipeline-state/constructor.md

@@ -0,0 +1,21 @@
+# OpenGLPipelineState::OpenGLPipelineState
+
+```cpp
+OpenGLPipelineState();
+```
+
+构造一个 `OpenGLPipelineState` 对象。
+
+**线程安全：** ❌
+
+**注意：** 初始化清除颜色为 (0, 0, 0, 0)，program 句柄为 0，附加标志为 false。
+
+**示例：**
+
+```cpp
+auto* pipelineState = new OpenGLPipelineState();
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览

docs/api/rhi/opengl/pipeline-state/destructor.md

@@ -0,0 +1,22 @@
+# OpenGLPipelineState::~OpenGLPipelineState
+
+```cpp
+~OpenGLPipelineState() override;
+```
+
+销毁 `OpenGLPipelineState` 对象。
+
+**线程安全：** ❌
+
+**注意：** 不会调用 `Shutdown()`，如果资源需要释放，应在销毁前手动调用 `Shutdown()`。
+
+**示例：**
+
+```cpp
+delete pipelineState;
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [Shutdown](shutdown.md) - 关闭管线状态

docs/api/rhi/opengl/pipeline-state/get-native-handle.md

@@ -0,0 +1,26 @@
+# OpenGLPipelineState::GetNativeHandle
+
+```cpp
+void* GetNativeHandle() override;
+```
+
+获取 OpenGL shader program 的原生句柄。
+
+**返回：** 
+- OpenGL: `void*` 指向 `GLuint` 类型的 program 值
+
+**线程安全：** ✅
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+void* handle = pipelineState->GetNativeHandle();
+GLuint program = static_cast<GLuint>(reinterpret_cast<uintptr_t>(handle));
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [AttachShader](attach-shader.md) - 附加着色器

docs/api/rhi/opengl/pipeline-state/get-type.md

@@ -0,0 +1,27 @@
+# OpenGLPipelineState::GetType
+
+```cpp
+PipelineType GetType() const override;
+```
+
+获取管线类型。
+
+**返回：** `PipelineType::Graphics` - OpenGL 只支持图形管线
+
+**线程安全：** ✅
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+PipelineType type = pipelineState->GetType();
+if (type == PipelineType::Graphics) {
+    // graphics pipeline
+}
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [RHIPipelineState 总览](../../pipeline-state/pipeline-state.md) - 抽象管线状态接口

docs/api/rhi/opengl/pipeline-state/pipeline-state.md

@@ -8,11 +8,13 @@
 
 | 方法 | 描述 |
 |------|------|
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭管线状态 |
-| [`Bind`](../../shader/bind.md) | 绑定管线状态 |
-| [`Unbind`](../../shader/unbind.md) | 解绑管线状态 |
-| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
-| [`GetType`](../../command-queue/get-type.md) | 获取管线类型 |
+| [`OpenGLPipelineState`](constructor.md) | 构造函数 |
+| [`~OpenGLPipelineState`](destructor.md) | 析构函数 |
+| [`Shutdown`](shutdown.md) | 关闭管线状态 |
+| [`Bind`](bind.md) | 绑定管线状态 |
+| [`Unbind`](unbind.md) | 解绑管线状态 |
+| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 |
+| [`GetType`](get-type.md) | 获取管线类型 |
 | [`SetDepthStencilState`](set-depth-stencil-state.md) | 设置深度模板状态 |
 | [`SetBlendState`](set-blend-state.md) | 设置混合状态 |
 | [`SetRasterizerState`](set-rasterizer-state.md) | 设置光栅化状态 |
@@ -26,7 +28,7 @@
 | [`ApplyViewport`](apply-viewport.md) | 应用视口 |
 | [`ApplyScissor`](apply-scissor.md) | 应用裁剪 |
 | [`SetClearColor`](set-clear-color.md) | 设置清除颜色 |
-| [`Clear`](../../command-list/clear.md) | 清除 |
+| [`Clear`](clear.md) | 清除 |
 | [`AttachShader`](attach-shader.md) | 附加着色器 |
 | [`DetachShader`](detach-shader.md) | 分离着色器 |
 | [`GetDepthStencilState`](get-depth-stencil-state.md) | 获取深度模板状态 |

docs/api/rhi/opengl/pipeline-state/shutdown.md

@@ -0,0 +1,21 @@
+# OpenGLPipelineState::Shutdown
+
+```cpp
+void Shutdown() override;
+```
+
+关闭管线状态并释放资源。
+
+**线程安全：** ❌
+
+**注意：** 此方法将 shader program 置零，但不会调用 glDeleteProgram。
+
+**示例：**
+
+```cpp
+pipelineState->Shutdown();
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览

docs/api/rhi/opengl/pipeline-state/unbind.md

@@ -0,0 +1,20 @@
+# OpenGLPipelineState::Unbind
+
+```cpp
+void Unbind() override;
+```
+
+解绑管线状态，将当前 program 设为 0。
+
+**线程安全：** ❌
+
+**示例：**
+
+```cpp
+pipelineState->Unbind();
+```
+
+## 相关文档
+
+- [OpenGLPipelineState 总览](pipeline-state.md) - 返回类总览
+- [Bind](bind.md) - 绑定管线状态

docs/api/rhi/opengl/render-target-view/bind.md

@@ -1,10 +1,35 @@
 # OpenGLRenderTargetView::Bind
 
 ```cpp
-void Bind() const;
+void Bind(unsigned int slot = 0);
+void Bind(unsigned int count, const unsigned int* framebuffers, const int* drawBuffers);
 ```
 
-绑定渲染目标视图。
+绑定渲染目标视图作为当前渲染目标。
+
+**重载 1 参数：**
+- `slot` - 绑定槽位（预留参数，当前实现中未使用）
+
+**重载 2 参数：**
+- `count` - 帧缓冲区数量
+- `framebuffers` - 帧缓冲区 ID 数组
+- `drawBuffers` - 对应每个帧缓冲区的绘制缓冲附件
+
+**行为说明：**
+- 当 `count` 为 1 时，直接绑定单个帧缓冲区
+- 当 `count` 大于 1 时，启用多重渲染目标（MRT），依次绑定各帧缓冲区并设置绘制缓冲附件
+
+**示例：**
+
+```cpp
+// 单帧缓冲绑定
+rtv.Bind();
+
+// 多帧缓冲绑定
+unsigned int fbos[] = { fbo1, fbo2 };
+int attachments[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
+rtv.Bind(2, fbos, attachments);
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/render-target-view/clear.md

@@ -2,15 +2,34 @@
 
 ```cpp
 void Clear(float r, float g, float b, float a);
+void Clear(float r, float g, float b, float a, float depth, uint8_t stencil);
 ```
 
-清除渲染目标视图。
+清除渲染目标视图的颜色缓冲区和可选的深度/模板缓冲区。
 
-**参数：**
+**重载 1 参数（仅清除颜色）：**
+- `r` - 红色分量（0.0f - 1.0f）
+- `g` - 绿色分量（0.0f - 1.0f）
+- `b` - 蓝色分量（0.0f - 1.0f）
+- `a` - Alpha 分量（0.0f - 1.0f）
+
+**重载 2 参数（清除颜色、深度和模板）：**
 - `r` - 红色分量
 - `g` - 绿色分量
 - `b` - 蓝色分量
 - `a` - Alpha 分量
+- `depth` - 深度值（通常 0.0f 或 1.0f）
+- `stencil` - 模板值（0-255）
+
+**示例：**
+
+```cpp
+// 仅清除颜色缓冲
+rtv.Clear(0.1f, 0.1f, 0.1f, 1.0f);
+
+// 清除颜色、深度和模板缓冲
+rtv.Clear(0.1f, 0.1f, 0.1f, 1.0f, 1.0f, 0);
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/render-target-view/get-height.md

@@ -0,0 +1,19 @@
+# OpenGLRenderTargetView::GetHeight
+
+```cpp
+int GetHeight() const;
+```
+
+获取渲染目标视图的高度（像素）。
+
+**返回：** `int` - 渲染目标高度
+
+**示例：**
+
+```cpp
+int height = rtv.GetHeight();
+```
+
+## 相关文档
+
+- [OpenGLRenderTargetView 总览](render-target-view.md) - 返回类总览

docs/api/rhi/opengl/render-target-view/get-size.md

@@ -1,13 +1,18 @@
-# OpenGLRenderTargetView::GetWidth / GetHeight
+# OpenGLRenderTargetView::GetWidth
 
 ```cpp
 int GetWidth() const;
-int GetHeight() const;
 ```
 
-获取渲染目标视图的宽度和高度。
+获取渲染目标视图的宽度（像素）。
 
-**返回：** 宽度/高度
+**返回：** `int` - 渲染目标宽度
+
+**示例：**
+
+```cpp
+int width = rtv.GetWidth();
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/render-target-view/initialize.md

@@ -1,17 +1,28 @@
 # OpenGLRenderTargetView::Initialize
 
 ```cpp
-bool Initialize(unsigned int texture, int width, int height);
+bool Initialize(unsigned int texture, const OpenGLRenderTargetViewDesc& desc);
+bool Initialize(unsigned int texture, int mipLevel = 0);
 ```
 
 初始化渲染目标视图。
 
-**参数：**
+**重载 1 参数：**
 - `texture` - OpenGL 纹理 ID
-- `width` - 宽度
-- `height` - 高度
+- `desc` - 渲染目标视图描述
 
-**返回：** 成功返回 true
+**重载 2 参数：**
+- `texture` - OpenGL 纹理 ID
+- `mipLevel` - mipmap 级别（默认为 0）
+
+**返回：** `bool` - 成功返回 true，失败返回 false
+
+**示例：**
+
+```cpp
+OpenGLRenderTargetView rtv;
+rtv.Initialize(texture, 0);
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/render-target-view/render-target-view.md

@@ -2,26 +2,87 @@
 
 **命名空间**: `XCEngine::RHI`
 
-**描述**: OpenGL 渲染目标视图实现。
+**描述**: OpenGL 渲染目标视图实现，用于将纹理绑定为渲染目标进行渲染输出。
+
+## 类型定义
+
+### RenderTargetType
+
+```cpp
+enum class RenderTargetType {
+    Texture2D,           // 2D 纹理
+    Texture2DArray,      // 2D 纹理数组
+    Texture3D,           // 3D 纹理
+    TextureCube,         // 立方体贴图
+    TextureCubeArray     // 立方体贴图数组
+};
+```
+
+### OpenGLRenderTargetViewDesc
+
+```cpp
+struct OpenGLRenderTargetViewDesc {
+    RenderTargetType type = RenderTargetType::Texture2D;  // 渲染目标类型
+    int mipLevel = 0;           // Mip 级别
+    int baseArraySlice = 0;     // 数组起始索引
+    int arraySize = 1;          // 数组大小
+    int layer = 0;              // 层级（用于 3D 纹理）
+    uint32_t format = 0;        // 格式
+};
+```
 
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
-| [`Initialize`](initialize.md) | 初始化渲染目标视图 |
+| [`Initialize`](initialize.md) | 初始化渲染目标视图（2 个重载） |
 | [`InitializeCubemap`](initialize-cubemap.md) | 初始化立方体贴图渲染目标视图 |
 | [`Shutdown`](shutdown.md) | 关闭渲染目标视图 |
-| [`Bind`](bind.md) | 绑定渲染目标视图 |
+| [`Bind`](bind.md) | 绑定渲染目标视图（2 个重载） |
 | [`Unbind`](unbind.md) | 解绑渲染目标视图 |
-| [`Clear`](clear.md) | 清除 |
+| [`Clear`](clear.md) | 清除（2 个重载） |
 | [`GetFramebuffer`](get-framebuffer.md) | 获取帧缓冲 |
 | [`GetTexture`](get-texture.md) | 获取纹理 |
 | [`GetMipLevel`](get-mip-level.md) | 获取 Mip 级别 |
 | [`GetWidth`](get-size.md) | 获取宽度 |
-| [`GetHeight`](get-size.md) | 获取高度 |
+| [`GetHeight`](get-height.md) | 获取高度 |
 | [`BindFramebuffer`](bind-framebuffer.md) | 绑定帧缓冲 |
 | [`UnbindFramebuffer`](unbind-framebuffer.md) | 解绑帧缓冲 |
 
+## 使用示例
+
+```cpp
+#include "XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h"
+
+void RenderToTexture() {
+    OpenGLRenderTargetView rtv;
+    
+    // 初始化为 2D 纹理渲染目标
+    if (rtv.Initialize(textureID, 0)) {
+        rtv.Bind();
+        rtv.Clear(0.0f, 0.0f, 0.0f, 1.0f);
+        // 执行渲染...
+        rtv.Unbind();
+    }
+    
+    rtv.Shutdown();
+}
+
+void RenderToCubemap() {
+    OpenGLRenderTargetView rtv;
+    
+    // 初始化为立方体贴图的第一面
+    if (rtv.InitializeCubemap(cubemapID, 0, 0)) {
+        rtv.Bind();
+        rtv.Clear(0.0f, 0.0f, 0.0f, 1.0f);
+        // 执行渲染...
+        rtv.Unbind();
+    }
+    
+    rtv.Shutdown();
+}
+```
+
 ## 相关文档
 
 - [OpenGL 后端总览](../overview.md)

docs/api/rhi/opengl/render-target-view/shutdown.md

@@ -4,7 +4,20 @@
 void Shutdown();
 ```
 
-关闭渲染目标视图。
+关闭渲染目标视图，释放关联的帧缓冲区资源。此方法会在析构时自动调用，但也可手动调用以提前释放资源。
+
+**注意：** 此方法仅删除帧缓冲区对象，不会删除关联的纹理对象。
+
+**示例：**
+
+```cpp
+OpenGLRenderTargetView rtv;
+rtv.Initialize(texture, 0);
+
+// 使用 rtv...
+
+rtv.Shutdown();  // 释放帧缓冲区资源
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/render-target-view/unbind.md

@@ -1,10 +1,18 @@
 # OpenGLRenderTargetView::Unbind
 
 ```cpp
-void Unbind() const;
+void Unbind();
 ```
 
-解除绑定渲染目标视图。
+解除当前渲染目标视图的绑定，将默认帧缓冲区（framebuffer 0）设为当前渲染目标。
+
+**示例：**
+
+```cpp
+rtv.Bind();
+// 执行渲染...
+rtv.Unbind();  // 解除绑定，恢复默认帧缓冲
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/sampler/bind.md

@@ -4,10 +4,14 @@
 void Bind(unsigned int unit);
 ```
 
-绑定采样器到纹理单元。
+绑定采样器到指定纹理单元。调用 `glBindSampler` 将采样器对象绑定到对应的纹理单元，后续纹理采样操作将使用该采样器。
 
 **参数：**
-- `unit` - 纹理单元编号
+- `unit` - 纹理单元编号，通常为 0-15
+
+**返回：** 无
+
+**线程安全：** ❌
 
 **复杂度：** O(1)
 

docs/api/rhi/opengl/sampler/constructor.md

@@ -0,0 +1,23 @@
+# OpenGLSampler::OpenGLSampler
+
+```cpp
+OpenGLSampler();
+```
+
+构造一个空的 OpenGLSampler 对象。实际采样器 ID 在调用 `Initialize` 之前无效（为 0）。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+OpenGLSampler sampler;
+```
+
+## 相关文档
+
+- [OpenGLSampler 总览](sampler.md) - 返回类总览

docs/api/rhi/opengl/sampler/get-id.md

@@ -1,13 +1,19 @@
 # OpenGLSampler::GetID
 
 ```cpp
-unsigned int GetID() const
-unsigned int GetID() override
+unsigned int GetID() const;
+unsigned int GetID() override;
 ```
 
-获取 OpenGL 采样器对象 ID。
+获取 OpenGL 采样器对象 ID。返回 `glGenSamplers` 生成的采样器对象名称。
 
-**返回：** `unsigned int` - 采样器 ID
+**参数：** 无
+
+**返回：** `unsigned int` - OpenGL 采样器 ID
+
+**线程安全：** ❌
+
+**复杂度：** O(1)
 
 **示例：**
 

docs/api/rhi/opengl/sampler/initialize.md

@@ -4,13 +4,25 @@
 bool Initialize(const OpenGLSamplerDesc& desc);
 ```
 
-初始化采样器。
+初始化采样器。创建 OpenGL 采样器对象并根据描述符设置各项参数，包括过滤模式、环绕模式、各向异性级别和 LOD 范围。
 
 **参数：**
-- `desc` - 采样器描述符
+- `desc` - 采样器描述符，包含以下字段：
+  - `minFilter` - 缩小过滤模式
+  - `magFilter` - 放大过滤模式
+  - `wrapS` - S轴环绕模式
+  - `wrapT` - T轴环绕模式
+  - `wrapR` - R轴环绕模式
+  - `maxAnisotropy` - 各向异性级别
+  - `minLod` - 最小 LOD 值
+  - `maxLod` - 最大 LOD 值
+  - `compareMode` - 比较模式（当前实现未使用）
+  - `compareFunc` - 比较函数（当前实现未使用）
 
 **返回：** 成功返回 `true`，失败返回 `false`
 
+**线程安全：** ❌
+
 **复杂度：** O(1)
 
 **示例：**
@@ -21,7 +33,14 @@ desc.minFilter = SamplerFilter::LinearMipmapLinear;
 desc.magFilter = SamplerFilter::Linear;
 desc.wrapS = SamplerWrapMode::Repeat;
 desc.wrapT = SamplerWrapMode::Repeat;
-sampler.Initialize(desc);
+desc.maxAnisotropy = 16.0f;
+desc.minLod = -1000.0f;
+desc.maxLod = 1000.0f;
+
+OpenGLSampler sampler;
+if (sampler.Initialize(desc)) {
+    // 采样器初始化成功
+}
 ```
 
 ## 相关文档

docs/api/rhi/opengl/sampler/sampler.md

@@ -1,19 +1,70 @@
 # OpenGLSampler
 
-**命名空间**: `XCEngine::RHI`
+## 命名空间
 
-**描述**: OpenGL 采样器实现，继承自 `RHISampler`。
+`XCEngine::RHI`
+
+## 头文件
+
+`XCEngine/RHI/OpenGL/OpenGLSampler.h`
+
+## 类型
+
+| 类型 | 说明 |
+|------|------|
+| `OpenGLSampler` | OpenGL 采样器封装类，继承自 `RHISampler` |
+| `OpenGLSamplerDesc` | 采样器描述结构体 |
+| `SamplerWrapMode` | 采样器环绕模式枚举 |
+| `SamplerFilter` | 采样器滤镜模式枚举 |
+| `SamplerCompareMode` | 采样器比较模式枚举 |
+
+## 描述
+
+OpenGL 采样器实现，继承自 `RHISampler`。
+
+## 概述
+
+`OpenGLSampler` 是 RHI 抽象层对 OpenGL 纹理采样器的封装。通过 `OpenGLSamplerDesc` 配置采样参数（过滤模式、环绕模式、各向异性、LOD 等），`Initialize` 方法创建 OpenGL 采样器对象，`Bind`/`Unbind` 控制采样器与纹理单元的绑定状态。
+
+**关键特性：**
+- 支持点采样、线性采样、各向异性采样
+- 支持 Repeat、Mirror、Clamp、Border 等寻址模式
+- 支持 Mipmap 多级渐远纹理过滤
+- 支持各向异性过滤和 LOD 范围控制
 
 ## 公共方法
 
 | 方法 | 描述 |
 |------|------|
-| [`Initialize`](initialize.md) | 初始化采样器 |
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭采样器 |
-| [`Bind`](bind.md) | 绑定采样器 |
+| [`OpenGLSampler`](constructor.md) | 构造函数 |
+| [`Initialize`](initialize.md) | 初始化采样器（OpenGL 特有） |
+| [`Shutdown`](shutdown.md) | 关闭采样器 |
+| [`Bind`](bind.md) | 绑定采样器到纹理单元 |
 | [`Unbind`](unbind.md) | 解绑采样器 |
 | [`GetID`](get-id.md) | 获取采样器 ID |
-| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
+| [`GetNativeHandle`](../../sampler/get-native-handle.md) | 获取原生句柄（继承自 `RHISampler`） |
+
+## 使用示例
+
+```cpp
+#include "XCEngine/RHI/OpenGL/OpenGLSampler.h"
+
+using namespace XCEngine::RHI;
+
+OpenGLSamplerDesc desc;
+desc.minFilter = SamplerFilter::LinearMipmapLinear;
+desc.magFilter = SamplerFilter::Linear;
+desc.wrapS = SamplerWrapMode::Repeat;
+desc.wrapT = SamplerWrapMode::Repeat;
+desc.maxAnisotropy = 16.0f;
+
+OpenGLSampler sampler;
+if (sampler.Initialize(desc)) {
+    sampler.Bind(0);
+    sampler.Unbind(0);
+    sampler.Shutdown();
+}
+```
 
 ## 相关文档
 

docs/api/rhi/opengl/sampler/shutdown.md

@@ -0,0 +1,29 @@
+# OpenGLSampler::Shutdown
+
+```cpp
+void Shutdown() override;
+```
+
+关闭采样器。释放 OpenGL 采样器对象，调用 `glDeleteSamplers` 删除采样器并重置 ID 为 0。
+
+**参数：** 无
+
+**返回：** 无
+
+**线程安全：** ❌
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+OpenGLSampler sampler;
+if (sampler.Initialize(desc)) {
+    sampler.Bind(0);
+    sampler.Shutdown();
+}
+```
+
+## 相关文档
+
+- [OpenGLSampler 总览](sampler.md) - 返回类总览

docs/api/rhi/opengl/sampler/unbind.md

@@ -4,10 +4,14 @@
 void Unbind(unsigned int unit);
 ```
 
-解绑采样器。
+解绑采样器。将指定纹理单元的采样器绑定解除，实际调用 `glBindSampler(unit, 0)`。
 
 **参数：**
-- `unit` - 纹理单元编号
+- `unit` - 纹理单元编号，通常为 0-15
+
+**返回：** 无
+
+**线程安全：** ❌
 
 **复杂度：** O(1)
 

docs/api/rhi/opengl/shader/compile-type.md

@@ -0,0 +1,31 @@
+# OpenGLShader::Compile (单着色器)
+
+```cpp
+bool Compile(const char* source, ShaderType type);
+```
+
+从源代码编译单个着色器（顶点、片段、几何、计算或细分着色器）。
+
+**参数：**
+- `source` - 着色器源代码
+- `type` - 着色器类型（`ShaderType::Vertex`、`ShaderType::Fragment`、`ShaderType::Geometry`、`ShaderType::Compute`、`ShaderType::TessControl`、`ShaderType::TessEvaluation`）
+
+**返回：** 成功返回 `true`，失败返回 `false`
+
+**线程安全：** ❌
+
+**示例：**
+
+```cpp
+const char* vs = R"(
+    #version 330 core
+    void main() { gl_Position = vec4(0.0); }
+)";
+shader->Compile(vs, ShaderType::Vertex);
+```
+
+## 相关文档
+
+- [OpenGLShader 总览](shader.md) - 返回类总览
+- [Compile (VS+FS)](compile-vs-fs.md) - 顶点+片段着色器版本
+- [CompileCompute](compile-compute.md) - 计算着色器版本

docs/api/rhi/opengl/shader/shader.md

@@ -8,9 +8,11 @@
 
 | 方法 | 描述 |
 |------|------|
-| [`CompileFromFile`](../../shader/compile-from-file.md) | 从文件编译着色器 |
-| [`Compile`](../../shader/compile.md) | 从源码编译着色器 |
-| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭着色器 |
+| [`CompileFromFile`](compile-from-file-vs-fs.md) | 从文件编译顶点+片段着色器 |
+| [`Compile`](compile-vs-fs.md) | 从源码编译顶点+片段着色器 |
+| [`Compile`](compile-type.md) | 从源码编译单着色器 |
+| [`CompileCompute`](compile-compute.md) | 编译计算着色器 |
+| [`Shutdown`](../../shader/shutdown.md) | 关闭着色器 |
 | [`Use`](use.md) | 使用着色器 |
 | [`Bind`](../../shader/bind.md) | 绑定着色器 |
 | [`Unbind`](../../shader/unbind.md) | 解绑着色器 |
@@ -25,7 +27,7 @@
 | [`GetID`](get-id.md) | 获取着色器 ID |
 | [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
 | [`IsValid`](../../shader/is-valid.md) | 检查是否有效 |
-| [`GetType`](../../command-queue/get-type.md) | 获取着色器类型 |
+| [`GetType`](../../shader/get-type.md) | 获取着色器类型 |
 
 ## 相关文档
 

docs/api/rhi/opengl/swap-chain/constructor.md

@@ -0,0 +1,24 @@
+# OpenGLSwapChain::OpenGLSwapChain
+
+```cpp
+OpenGLSwapChain();
+```
+
+构造空的 OpenGL 交换链对象。
+
+**注意：**
+- 构造函数不初始化交换链，需调用 `Initialize` 方法完成初始化
+- 初始化参数由 `Initialize` 方法指定
+
+**示例：**
+
+```cpp
+OpenGLSwapChain swapChain;
+swapChain.Initialize(window, true);
+```
+
+## 相关文档
+
+- [OpenGLSwapChain 总览](swap-chain.md) - 返回类总览
+- [Initialize](initialize.md) - 初始化方法
+- [析构函数](destructor.md) - 析构函数