xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: update RHI API docs

Browse Source
This commit is contained in:
ssdfasd
2026-03-20 02:35:45 +08:00
parent ea756c0177
commit 070b444f8f
501 changed files with 13493 additions and 2022 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
docs/api/rhi/d3d12/buffer/buffer.md
View File

@@ -2,36 +2,79 @@
**命名空间**: `XCEngine::RHI`
**类型**: `class` (继承自 `RHIBuffer`)
**描述**: DirectX 12 缓冲区的 D3D12 实现，继承自 `RHIBuffer`。
## 概述
`D3D12Buffer` 是 RHI 缓冲区接口的 DirectX 12 后端实现。该类封装了 `ID3D12Resource` 对象，提供缓冲区的创建、初始化、数据更新和状态管理功能。支持顶点缓冲区、索引缓冲区、常量缓冲区等多种缓冲区类型。
## 公共方法
### D3D12 特有方法
| 方法 | 描述 |
|------|------|
| [`Initialize`](initialize.md) | 初始化缓冲区 |
| [`InitializeFromExisting`](initialize-from-existing.md) | 从现有资源初始化 |
| [`InitializeWithData`](initialize-with-data.md) | 初始化并写入数据 |
| [`Shutdown`](shutdown.md) | 关闭缓冲区 |
| [`UpdateData`](update-data.md) | 更新数据 |
| [`Map`](map.md) | 映射缓冲区 |
| [`Unmap`](unmap.md) | 取消映射 |
| [`SetData`](set-data.md) | 设置数据 |
| [`GetResource`](get-resource.md) | 获取 D3D12 资源 |
| [`GetDesc`](get-desc.md) | 获取描述符 |
| [`GetGPUVirtualAddress`](get-gpu-virtual-address.md) | 获取 GPU 虚拟地址 |
| [`GetGPUAddress`](get-gpu-address.md) | 获取 GPU 地址 |
| [`GetSize`](get-size.md) | 获取缓冲区大小 |
| [`GetState`](get-state.md) | 获取资源状态 |
### 继承自 RHIBuffer 的方法
| 方法 | 描述 |
|------|------|
| [`Shutdown`](../../buffer/shutdown.md) | 关闭缓冲区 |
| [`Map`](../../buffer/map.md) | 映射缓冲区 |
| [`Unmap`](../../buffer/unmap.md) | 取消映射 |
| [`SetData`](../../buffer/set-data.md) | 设置数据 |
| [`GetSize`](../../buffer/get-size.md) | 获取缓冲区大小 |
| [`GetState`](../../buffer/get-state.md) | 获取资源状态 |
| [`SetState`](../../buffer/set-state.md) | 设置资源状态 |
| [`GetName`](get-name.md) | 获取资源名称 |
| [`GetName`](../../buffer/get-name.md) | 获取资源名称 |
| [`SetName`](../../buffer/set-name.md) | 设置资源名称 |
| [`GetStride`](get-stride.md) | 获取步长 |
| [`GetStride`](../../buffer/get-stride.md) | 获取步长 |
| [`SetStride`](../../buffer/set-stride.md) | 设置步长 |
| [`GetBufferType`](get-buffer-type.md) | 获取缓冲区类型 |
| [`GetBufferType`](../../buffer/get-buffer-type.md) | 获取缓冲区类型 |
| [`SetBufferType`](../../buffer/set-buffer-type.md) | 设置缓冲区类型 |
| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 |
| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
## 使用示例
```cpp
// 创建顶点缓冲区
D3D12Buffer vertexBuffer;
vertexBuffer.Initialize(
device,
sizeof(Vertex) * vertexCount,
D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
D3D12_HEAP_TYPE_DEFAULT);
vertexBuffer.SetName(L"VertexBuffer");
vertexBuffer.SetBufferType(BufferType::Vertex);
vertexBuffer.SetStride(sizeof(Vertex));
// 创建索引缓冲区（带初始数据）
D3D12Buffer indexBuffer;
uint16_t indices[] = { 0, 1, 2, 1, 3, 2 };
indexBuffer.InitializeWithData(
device,
commandList,
indices,
sizeof(indices),
D3D12_RESOURCE_STATE_INDEX_BUFFER);
// 使用 UPLOAD 堆更新数据
D3D12Buffer uploadBuffer;
uploadBuffer.Initialize(device, uploadSize, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_HEAP_TYPE_UPLOAD);
uploadBuffer.UpdateData(newData, dataSize);
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../../d3d12/d3d12.md)
- [RHIBuffer](../../buffer/buffer.md) - 抽象缓冲区接口

16
docs/api/rhi/d3d12/buffer/get-buffer-type.md
View File

@@ -1,16 +0,0 @@
# D3D12Buffer::GetBufferType / SetBufferType
## 函数签名
```cpp
BufferType GetBufferType() const override
void SetBufferType(BufferType type) override
```
## 中文描述
获取和设置缓冲区类型（Vertex / Index / Constant 等）。
## 复杂度
O(1)

16
docs/api/rhi/d3d12/buffer/get-name.md
View File

@@ -1,16 +0,0 @@
# D3D12Buffer::GetName / SetName
## 函数签名
```cpp
const std::string& GetName() const override
void SetName(const std::string& name) override
```
## 中文描述
获取和设置对象名称（用于调试）。
## 复杂度
O(1)

19
docs/api/rhi/d3d12/buffer/get-native-handle.md
View File

@@ -1,19 +0,0 @@
# D3D12Buffer::GetNativeHandle
## 函数签名
```cpp
void* GetNativeHandle() override
```
## 中文描述
返回原生句柄，即 `ID3D12Resource*`。
## 返回值
`void*` - 原生句柄
## 复杂度
O(1)

19
docs/api/rhi/d3d12/buffer/get-size.md
View File

@@ -1,19 +0,0 @@
# D3D12Buffer::GetSize
## 函数签名
```cpp
uint64_t GetSize() const override
```
## 中文描述
获取缓冲区大小（字节）。
## 返回值
`uint64_t` - 缓冲区大小
## 复杂度
O(1)

16
docs/api/rhi/d3d12/buffer/get-state.md
View File

@@ -1,16 +0,0 @@
# D3D12Buffer::GetState / SetState
## 函数签名
```cpp
ResourceStates GetState() const
void SetState(ResourceStates state)
```
## 中文描述
获取和设置当前资源状态。用于状态跟踪和屏障生成。
## 复杂度
O(1)

16
docs/api/rhi/d3d12/buffer/get-stride.md
View File

@@ -1,16 +0,0 @@
# D3D12Buffer::GetStride / SetStride
## 函数签名
```cpp
uint32_t GetStride() const override
void SetStride(uint32_t stride) override
```
## 中文描述
获取和设置顶点缓冲区步长（字节）。
## 复杂度
O(1)

6
docs/api/rhi/d3d12/buffer/initialize-with-data.md
View File

@@ -33,9 +33,9 @@ O(n) - 取决于数据大小，内部创建临时上传堆
```cpp
uint16_t indices[] = { 0, 1, 2, 1, 3, 2 };
D3D12Buffer indexBuffer;
D3D12Buffer::InitializeWithData(
device->GetDevice(),
cmdList->GetCommandList(),
indexBuffer.InitializeWithData(
device,
commandList,
indices,
sizeof(indices),
D3D12_RESOURCE_STATE_INDEX_BUFFER);

27
docs/api/rhi/d3d12/buffer/map.md
View File

@@ -1,27 +0,0 @@
# D3D12Buffer::Map
## 函数签名
```cpp
void* Map() override
```
## 中文描述
将缓冲区内存映射到 CPU 可访问地址。仅对 UPLOAD 或 READBACK 堆有效。
## 返回值
`void*` - 映射的内存指针
## 复杂度
O(1)
## 示例
```cpp
void* mapped = uploadBuffer.Map();
memcpy(mapped, vertexData, sizeof(vertexData));
buffer.Unmap();
```

23
docs/api/rhi/d3d12/buffer/set-data.md
View File

@@ -1,23 +0,0 @@
# D3D12Buffer::SetData
## 函数签名
```cpp
void SetData(const void* data, size_t size, size_t offset = 0) override
```
## 中文描述
设置缓冲区数据。通过 Map/Unmap 实现。
## 参数
| 参数 | 类型 | 描述 |
|------|------|------|
| `data` | `const void*` | 数据指针 |
| `size` | `size_t` | 数据大小 |
| `offset` | `size_t` | 缓冲区内的偏移量 |
## 复杂度
O(n)

15
docs/api/rhi/d3d12/buffer/shutdown.md
View File

@@ -1,15 +0,0 @@
# D3D12Buffer::Shutdown
## 函数签名
```cpp
void Shutdown() override
```
## 中文描述
释放 D3D12 缓冲区资源，将成员变量置为空。
## 复杂度
O(1)

15
docs/api/rhi/d3d12/buffer/unmap.md
View File

@@ -1,15 +0,0 @@
# D3D12Buffer::Unmap
## 函数签名
```cpp
void Unmap() override
```
## 中文描述
解除缓冲区内存映射。
## 复杂度
O(1)

4
docs/api/rhi/d3d12/buffer/update-data.md
View File

@@ -17,6 +17,10 @@ void UpdateData(const void* data, uint64_t size)
| `data` | `const void*` | 新数据指针 |
| `size` | `uint64_t` | 数据大小 |
## 返回值
无
## 复杂度
O(n)

41
docs/api/rhi/d3d12/command-allocator/command-allocator.md
View File

@@ -2,18 +2,49 @@
**命名空间**: `XCEngine::RHI`
**描述**: DirectX 12 命令分配器的 D3D12 实现。
**类型**: `class` (standalone, does not inherit from base)
**描述**: DirectX 12 命令分配器的 D3D12 实现，用于管理 GPU 命令分配内存。
## 构造函数
| 方法 | 描述 |
|------|------|
| [`D3D12CommandAllocator`](constructor.md) | 默认构造函数 |
## 公共方法
| 方法 | 描述 |
|------|------|
| [`Initialize`](../../../threading/task-system/initialize.md) | 初始化命令分配器 |
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭命令分配器 |
| [`Reset`](../../command-list/reset.md) | 重置命令分配器 |
| [`Initialize`](initialize.md) | 初始化命令分配器 |
| [`Shutdown`](shutdown.md) | 关闭命令分配器 |
| [`Reset`](reset.md) | 重置命令分配器 |
| [`IsReady`](is-ready.md) | 检查是否就绪 |
| [`GetCommandAllocator`](get-command-allocator.md) | 获取 D3D12 命令分配器 |
## 析构函数
| 方法 | 描述 |
|------|------|
| [`~D3D12CommandAllocator`](destructor.md) | 析构函数，自动调用 Shutdown |
## 使用示例
```cpp
#include <XCEngine/RHI/D3D12/D3D12CommandAllocator.h>
using namespace XCEngine::RHI;
D3D12CommandAllocator allocator;
if (allocator.Initialize(device, CommandQueueType::Direct)) {
allocator.Reset();
if (allocator.IsReady()) {
ID3D12CommandAllocator* native = allocator.GetCommandAllocator();
}
allocator.Shutdown();
}
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../../d3d12/d3d12.md)

20
docs/api/rhi/d3d12/command-allocator/constructor.md Normal file
View File

@@ -0,0 +1,20 @@
# D3D12CommandAllocator::D3D12CommandAllocator
```cpp
D3D12CommandAllocator();
```
默认构造函数，创建一个未初始化的命令分配器实例。创建后需要调用 [`Initialize`](initialize.md) 进行初始化。
## 示例
```cpp
D3D12CommandAllocator allocator;
// 此时 allocator 未初始化，需要调用 Initialize
allocator.Initialize(device);
```
## 相关文档
- [D3D12CommandAllocator 总览](command-allocator.md) - 返回类总览
- [D3D12CommandAllocator::Initialize](initialize.md) - 初始化分配器

22
docs/api/rhi/d3d12/command-allocator/destructor.md Normal file
View File

@@ -0,0 +1,22 @@
# D3D12CommandAllocator::~D3D12CommandAllocator
```cpp
~D3D12CommandAllocator();
```
析构函数，自动调用 [`Shutdown`](shutdown.md) 释放底层 D3D12 资源。
## 示例
```cpp
{
D3D12CommandAllocator allocator;
allocator.Initialize(device);
// 使用分配器
} // 离开作用域时析构函数自动调用 Shutdown
```
## 相关文档
- [D3D12CommandAllocator 总览](command-allocator.md) - 返回类总览
- [D3D12CommandAllocator::Shutdown](shutdown.md) - 关闭分配器

10
docs/api/rhi/d3d12/command-allocator/get-command-allocator.md
View File

@@ -6,6 +6,16 @@ ID3D12CommandAllocator* GetCommandAllocator() const { return m_commandAllocator.
获取底层的 D3D12 命令分配器接口。
## 示例
```cpp
D3D12CommandAllocator allocator;
if (allocator.Initialize(device)) {
ID3D12CommandAllocator* native = allocator.GetCommandAllocator();
// 使用原生 D3D12 接口
}
```
**返回：** `ID3D12CommandAllocator*`
**复杂度：** O(1)

37
docs/api/rhi/d3d12/command-allocator/initialize.md Normal file
View File

@@ -0,0 +1,37 @@
# D3D12CommandAllocator::Initialize
```cpp
bool Initialize(ID3D12Device* device, CommandQueueType type = CommandQueueType::Direct);
```
初始化 D3D12 命令分配器，创建指定类型的命令分配器。
## 参数
| 参数 | 类型 | 描述 |
|------|------|------|
| `device` | `ID3D12Device*` | D3D12 设备指针 |
| `type` | `CommandQueueType` | 命令队列类型，默认值为 `Direct` |
## 返回值
`bool` - 初始化是否成功
## 示例
```cpp
D3D12CommandAllocator allocator;
if (allocator.Initialize(device, CommandQueueType::Direct)) {
// 分配器初始化成功
}
```
## 复杂度
O(1)
## 相关文档
- [D3D12CommandAllocator 总览](command-allocator.md) - 返回类总览
- [D3D12CommandAllocator::Reset](reset.md) - 重置分配器
- [D3D12CommandAllocator::Shutdown](shutdown.md) - 关闭分配器

11
docs/api/rhi/d3d12/command-allocator/is-ready.md
View File

@@ -6,6 +6,17 @@ bool IsReady() const;
检查命令分配器是否准备就绪。
## 示例
```cpp
D3D12CommandAllocator allocator;
if (allocator.Initialize(device)) {
if (allocator.IsReady()) {
// 分配器就绪可以使用
}
}
```
**返回：** 分配器是否准备就绪
**复杂度：** O(1)

25
docs/api/rhi/d3d12/command-allocator/reset.md Normal file
View File

@@ -0,0 +1,25 @@
# D3D12CommandAllocator::Reset
```cpp
void Reset();
```
重置命令分配器，将分配器重置为初始状态，使其可以重新使用。此方法必须在 GPU 完成所有使用该分配器的命令后才能调用。
## 示例
```cpp
D3D12CommandAllocator allocator;
if (allocator.Initialize(device)) {
allocator.Reset(); // 重置以重新使用
}
```
## 复杂度
O(1)
## 相关文档
- [D3D12CommandAllocator 总览](command-allocator.md) - 返回类总览
- [D3D12CommandAllocator::Initialize](initialize.md) - 初始化分配器

27
docs/api/rhi/d3d12/command-allocator/shutdown.md Normal file
View File

@@ -0,0 +1,27 @@
# D3D12CommandAllocator::Shutdown
```cpp
void Shutdown();
```
关闭 D3D12 命令分配器，释放底层 D3D12 资源。此方法通常不需要显式调用，析构函数会自动执行。
## 示例
```cpp
D3D12CommandAllocator allocator;
if (allocator.Initialize(device)) {
// 使用分配器
allocator.Shutdown(); // 显式关闭
}
// 或者依靠析构函数自动关闭
```
## 复杂度
O(1)
## 相关文档
- [D3D12CommandAllocator 总览](command-allocator.md) - 返回类总览
- [D3D12CommandAllocator::Initialize](initialize.md) - 初始化分配器

9
docs/api/rhi/d3d12/command-list/begin-query.md
View File

@@ -13,6 +13,15 @@ void BeginQuery(ID3D12QueryHeap* queryHeap, QueryType type, uint32_t index);
**复杂度：** O(1)
**示例：**
```cpp
ID3D12QueryHeap* queryHeap = /* 获取查询堆 */;
cmdList.BeginQuery(queryHeap, QueryType::Timestamp, 0);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [EndQuery](end-query.md) - 结束查询
- [ResolveQueryData](resolve-query-data.md) - 解析查询数据

21
docs/api/rhi/d3d12/command-list/clear.md Normal file
View File

@@ -0,0 +1,21 @@
# D3D12CommandList::Clear
```cpp
void Clear(float r, float g, float b, float a, uint32_t buffers) override;
```
清除渲染目标和/或深度模板缓冲区。
**参数：**
- `r` - 清除颜色（红色通道）
- `g` - 清除颜色（绿色通道）
- `b` - 清除颜色（蓝色通道）
- `a` - 清除颜色（Alpha通道）
- `buffers` - 要清除的缓冲区标志
**复杂度：** O(1)
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [RHICommandList::Clear](../../command-list/command-list.md) - 基类方法

14
docs/api/rhi/d3d12/command-list/close.md Normal file
View File

@@ -0,0 +1,14 @@
# D3D12CommandList::Close
```cpp
void Close() override;
```
关闭命令列表，停止录制。
**复杂度：** O(1)
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [RHICommandList::Close](../../command-list/command-list.md) - 基类方法

69
docs/api/rhi/d3d12/command-list/command-list.md
View File

@@ -2,18 +2,33 @@
**命名空间**: `XCEngine::RHI`
**描述**: DirectX 12 命令列表的 D3D12 实现，继承自 `RHICommandList`。
**继承自**: [`RHICommandList`](../../command-list/command-list.md)
**头文件**: `XCEngine/RHI/D3D12/D3D12CommandList.h`
## 概述
`D3D12CommandList` 是 DirectX 12 命令列表的 RHI 实现，封装了 `ID3D12GraphicsCommandList` 接口。该类负责记录 GPU 命令，包括绘制调用、资源状态转换、渲染目标设置等。
### 主要功能
- **命令录制**: 支持图形和计算命令的录制
- **资源状态管理**: 维护资源状态映射表，跟踪资源转换
- **描述符管理**: 管理 GPU 描述符堆和描述符表
- **状态设置**: 设置管线状态、根签名、视口、裁剪矩形等
## 公共方法
| 方法 | 描述 |
|------|------|
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭命令列表 |
| [`Reset`](../../command-list/reset.md) | 重置命令列表 |
| [`Close`](../../command-list/close.md) | 关闭命令列表 |
| [`D3D12CommandList`](../../../threading/lambdatask/constructor.md) | 构造函数 |
| [`~D3D12CommandList`](../../../threading/readwritelock/destructor.md) | 析构函数 |
| [`Initialize`](initialize.md) | 初始化命令列表 |
| [`Shutdown`](shutdown.md) | 关闭命令列表 |
| [`Reset`](reset.md) | 重置命令列表 |
| [`Close`](close.md) | 关闭命令列表 |
| [`GetCommandList`](get-command-list.md) | 获取 D3D12 命令列表 |
| [`TransitionBarrier`](transition-barrier.md) | 资源状态转换 |
| [`TransitionBarrierInternal`](transition-barrier-internal.md) | 内部资源状态转换 |
| [`UAVBarrier`](uav-barrier.md) | UAV 屏障 |
| [`AliasBarrier`](alias-barrier.md) | 别名屏障 |
| [`SetPipelineState`](set-pipeline-state.md) | 设置管线状态 |
@@ -24,8 +39,6 @@
| [`SetScissorRect`](set-scissor-rect.md) | 设置裁剪矩形 |
| [`SetScissorRects`](set-scissor-rects.md) | 设置多个裁剪矩形 |
| [`SetRenderTargets`](set-render-targets.md) | 设置渲染目标 |
| [`SetRenderTargetsInternal`](set-render-targets-internal.md) | 内部渲染目标设置 |
| [`SetRenderTargetsHandle`](set-render-targets-handle.md) | 句柄渲染目标设置 |
| [`SetVertexBuffer`](set-vertex-buffer.md) | 设置顶点缓冲 |
| [`SetVertexBuffers`](set-vertex-buffers.md) | 设置多个顶点缓冲 |
| [`SetIndexBuffer`](set-index-buffer.md) | 设置索引缓冲 |
@@ -44,7 +57,7 @@
| [`DrawIndexed`](draw-indexed.md) | 索引绘制 |
| [`DrawInstancedIndirect`](draw-instanced-indirect.md) | 实例化间接绘制 |
| [`DrawIndexedInstancedIndirect`](draw-indexed-instanced-indirect.md) | 索引实例化间接绘制 |
| [`Clear`](../../command-list/clear.md) | 清除 |
| [`Clear`](clear.md) | 清除 |
| [`ClearRenderTarget`](clear-render-target.md) | 清除渲染目标 |
| [`ClearDepthStencil`](clear-depth-stencil.md) | 清除深度模板 |
| [`CopyResource`](copy-resource.md) | 复制资源 |
@@ -59,7 +72,45 @@
| [`GetResourceState`](get-resource-state.md) | 获取资源状态 |
| [`TrackResource`](track-resource.md) | 跟踪资源 |
## 使用示例
```cpp
#include "XCEngine/RHI/D3D12/D3D12CommandList.h"
#include "XCEngine/RHI/D3D12/D3D12Device.h"
using namespace XCEngine::RHI;
// 创建命令列表
D3D12CommandList cmdList;
ID3D12Device* device = /* 获取设备 */;
// 初始化
if (!cmdList.Initialize(device, CommandQueueType::Direct)) {
return false;
}
// 重置并开始录制
cmdList.Reset();
// 设置渲染状态
cmdList.SetPipelineState(pipelineState);
cmdList.SetRootSignature(rootSignature);
cmdList.SetPrimitiveTopology(PrimitiveTopology::TriangleList);
cmdList.SetViewport(viewport);
cmdList.SetRenderTargets(1, renderTargets, depthStencil);
// 绑定资源
cmdList.SetVertexBuffer(0, vertexBuffer, 0, sizeof(Vertex));
cmdList.SetIndexBuffer(indexBuffer, 0, Format::R32_UINT);
// 绘制
cmdList.DrawIndexed(indexCount, 1, 0, 0, 0);
// 关闭命令列表
cmdList.Close();
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../d3d12.md)
- [RHICommandList](../../command-list/command-list.md) - 抽象命令列表接口

12
docs/api/rhi/d3d12/command-list/copy-buffer.md
View File

@@ -13,8 +13,18 @@ void CopyBuffer(ID3D12Resource* dst, uint64_t dstOffset, ID3D12Resource* src, ui
- `srcOffset` - 源偏移
- `size` - 复制大小
**复杂度：** O(n)
**复杂度：** O(n)，n 为复制数据量
**示例：**
```cpp
ID3D12Resource* srcBuffer = /* 源缓冲区 */;
ID3D12Resource* dstBuffer = /* 目标缓冲区 */;
cmdList.CopyBuffer(dstBuffer, 0, srcBuffer, 0, 1024);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [CopyResource](copy-resource.md) - 复制整个资源
- [CopyTexture](copy-texture.md) - 复制纹理数据

12
docs/api/rhi/d3d12/command-list/copy-resource.md
View File

@@ -10,8 +10,18 @@ void CopyResource(void* dst, void* src) override;
- `dst` - 目标资源指针
- `src` - 源资源指针
**复杂度：** O(n)
**复杂度：** O(n)，n 为资源大小
**示例：**
```cpp
ID3D12Resource* dst = /* 目标资源 */;
ID3D12Resource* src = /* 源资源 */;
cmdList.CopyResource(dst, src);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [CopyBuffer](copy-buffer.md) - 复制缓冲区数据
- [CopyTexture](copy-texture.md) - 复制纹理数据

20
docs/api/rhi/d3d12/command-list/copy-texture.md
View File

@@ -12,8 +12,26 @@ void CopyTexture(ID3D12Resource* dst, const D3D12_TEXTURE_COPY_LOCATION& dstLoca
- `src` - 源纹理
- `srcLocation` - 源位置
**复杂度：** O(n)
**复杂度：** O(n)，n 为复制数据量
**示例：**
```cpp
D3D12_TEXTURE_COPY_LOCATION dstLoc = {};
dstLoc.pResource = dstTexture;
dstLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dstLoc.SubresourceIndex = 0;
D3D12_TEXTURE_COPY_LOCATION srcLoc = {};
srcLoc.pResource = srcTexture;
srcLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
srcLoc.SubresourceIndex = 0;
cmdList.CopyTexture(dst, dstLoc, src, srcLoc);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [CopyResource](copy-resource.md) - 复制整个资源
- [CopyBuffer](copy-buffer.md) - 复制缓冲区数据

10
docs/api/rhi/d3d12/command-list/dispatch-indirect.md
View File

@@ -4,7 +4,7 @@
void DispatchIndirect(void* argBuffer, uint64_t alignedByteOffset);
```
间接分发计算命令。
间接分发计算命令，使用存储在缓冲区中的参数执行 `Dispatch` 操作。
**参数：**
- `argBuffer` - 参数缓冲区
@@ -12,6 +12,14 @@ void DispatchIndirect(void* argBuffer, uint64_t alignedByteOffset);
**复杂度：** O(1)
**示例：**
```cpp
ID3D12Resource* argBuffer = /* 包含 DispatchIndirect 参数的缓冲区 */;
cmdList.DispatchIndirect(argBuffer, 0);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [Dispatch](dispatch.md) - 直接分发计算任务

9
docs/api/rhi/d3d12/command-list/end-query.md
View File

@@ -13,6 +13,15 @@ void EndQuery(ID3D12QueryHeap* queryHeap, QueryType type, uint32_t index);
**复杂度：** O(1)
**示例：**
```cpp
ID3D12QueryHeap* queryHeap = /* 获取查询堆 */;
cmdList.EndQuery(queryHeap, QueryType::Timestamp, 0);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [BeginQuery](begin-query.md) - 开始查询
- [ResolveQueryData](resolve-query-data.md) - 解析查询数据

7
docs/api/rhi/d3d12/command-list/execute-bundle.md
View File

@@ -11,6 +11,13 @@ void ExecuteBundle(ID3D12GraphicsCommandList* bundle);
**复杂度：** O(1)
**示例：**
```cpp
ID3D12GraphicsCommandList* bundle = /* 获取 Bundle */;
cmdList.ExecuteBundle(bundle);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览

14
docs/api/rhi/d3d12/command-list/get-resource-state.md
View File

@@ -9,10 +9,22 @@ ResourceStates GetResourceState(ID3D12Resource* resource) const;
**参数：**
- `resource` - D3D12 资源指针
**返回：** 资源当前状态
**返回值：** 资源当前状态，如果资源未被跟踪则返回 `ResourceStates::Common`
**复杂度：** O(1)
**示例：**
```cpp
ID3D12Resource* resource = /* 获取资源 */;
ResourceStates state = cmdList.GetResourceState(resource);
if (state == ResourceStates::RenderTarget) {
// 资源当前为渲染目标状态
}
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [TrackResource](track-resource.md) - 跟踪资源
- [TransitionBarrier](transition-barrier.md) - 资源状态转换

40
docs/api/rhi/d3d12/command-list/initialize.md Normal file
View File

@@ -0,0 +1,40 @@
# D3D12CommandList::Initialize
```cpp
bool Initialize(ID3D12Device* device, CommandQueueType type = CommandQueueType::Direct, ID3D12CommandAllocator* allocator = nullptr);
```
初始化 D3D12 命令列表，创建 `ID3D12GraphicsCommandList` 实例。
**参数：**
- `device` - D3D12 设备指针
- `type` - 命令队列类型，默认为 `CommandQueueType::Direct`
- `allocator` - 命令分配器指针，如果为 `nullptr`，则由方法内部创建
**返回值：**
- `bool` - 初始化成功返回 `true`，失败返回 `false`
**复杂度：** O(1)
**示例：**
```cpp
D3D12CommandList cmdList;
ID3D12Device* device = /* 获取设备 */;
if (!cmdList.Initialize(device)) {
// 处理初始化失败
return;
}
// 使用命令列表...
cmdList.Reset();
// ... 录制命令
cmdList.Close();
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [Shutdown](shutdown.md) - 关闭命令列表
- [Close](close.md) - 关闭命令列表

14
docs/api/rhi/d3d12/command-list/reset.md Normal file
View File

@@ -0,0 +1,14 @@
# D3D12CommandList::Reset
```cpp
void Reset() override;
```
重置命令列表，准备录制新命令。
**复杂度：** O(1)
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [RHICommandList::Reset](../../command-list/command-list.md) - 基类方法

12
docs/api/rhi/d3d12/command-list/resolve-query-data.md
View File

@@ -14,8 +14,18 @@ void ResolveQueryData(ID3D12QueryHeap* queryHeap, QueryType type, uint32_t start
- `resultBuffer` - 结果缓冲区
- `resultOffset` - 结果偏移
**复杂度：** O(n)
**复杂度：** O(n)，n 为查询数量
**示例：**
```cpp
ID3D12QueryHeap* queryHeap = /* 获取查询堆 */;
ID3D12Resource* resultBuffer = /* 结果缓冲区 */;
cmdList.ResolveQueryData(queryHeap, QueryType::Timestamp, 0, 1, resultBuffer, 0);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [BeginQuery](begin-query.md) - 开始查询
- [EndQuery](end-query.md) - 结束查询

10
docs/api/rhi/d3d12/command-list/set-depth-bias.md
View File

@@ -13,6 +13,16 @@ void SetDepthBias(float depthBias, float slopeScaledDepthBias, float depthBiasCl
**复杂度：** O(1)
**注意：** 当前实现为空，深度偏移通过管线状态对象设置。
**示例：**
```cpp
// 深度偏移参数通常在 PSO 中设置
// 此方法当前为空实现
cmdList.SetDepthBias(0.0f, 0.0f, 0.0f);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览

14
docs/api/rhi/d3d12/command-list/shutdown.md Normal file
View File

@@ -0,0 +1,14 @@
# D3D12CommandList::Shutdown
```cpp
void Shutdown() override;
```
关闭命令列表并释放相关资源。
**复杂度：** O(n) - 遍历释放所有跟踪的资源
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [RHICommandList::Shutdown](../../command-list/command-list.md) - 基类方法

9
docs/api/rhi/d3d12/command-list/track-resource.md
View File

@@ -11,6 +11,15 @@ void TrackResource(ID3D12Resource* resource);
**复杂度：** O(1)
**示例：**
```cpp
ID3D12Resource* resource = /* 获取资源 */;
cmdList.TrackResource(resource);
```
## 相关文档
- [D3D12CommandList 总览](command-list.md) - 返回类总览
- [GetResourceState](get-resource-state.md) - 获取资源状态
- [TransitionBarrier](transition-barrier.md) - 资源状态转换

51
docs/api/rhi/d3d12/command-queue/command-queue.md
View File

@@ -2,25 +2,48 @@
**命名空间**: `XCEngine::RHI`
**类型**: `class`
**继承**: `RHICommandQueue`
**描述**: DirectX 12 命令队列的 D3D12 实现，继承自 `RHICommandQueue`。
## 公共方法
| 方法 | 描述 |
|------|------|
| [`Initialize`](../../../threading/task-system/initialize.md) | 初始化命令队列 |
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭命令队列 |
| [`ExecuteCommandLists`](execute-command-lists.md) | 执行命令列表 |
| [`Signal`](signal.md) | 信号栅栏 |
| [`Wait`](../../../threading/task-group/wait.md) | 等待栅栏 |
| [`GetCompletedValue`](get-completed-value.md) | 获取完成值 |
| [`WaitForIdle`](wait-for-idle.md) | 等待空闲 |
| [`GetType`](../../command-queue/get-type.md) | 获取队列类型 |
| [`GetTimestampFrequency`](get-timestamp-frequency.md) | 获取时间戳频率 |
| [`GetCommandQueue`](get-command-queue.md) | 获取 D3D12 命令队列 |
| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
| 方法 | 描述 | 类型 |
|------|------|------|
| [`Initialize`](initialize.md) | 初始化命令队列 | D3D12 特有 |
| [`Shutdown`](shutdown.md) | 关闭命令队列 | Override |
| [`ExecuteCommandLists`](execute-command-lists.md) | 执行命令列表 | Override |
| [`Signal`](signal.md) | 信号栅栏（RHIFence 重载） | Override |
| [`Signal(ID3D12Fence*)`](signal-native.md) | 信号栅栏（Native D3D12Fence） | D3D12 特有 |
| [`Wait`](wait.md) | 等待栅栏达到指定值 | Override |
| [`Wait(ID3D12Fence*)`](wait-native.md) | 等待栅栏（Native D3D12Fence） | D3D12 特有 |
| [`GetCompletedValue`](get-completed-value.md) | 获取完成值 | Override |
| [`WaitForIdle`](wait-for-idle.md) | 等待空闲 | Override |
| [`GetType`](get-type.md) | 获取队列类型 | Override |
| [`GetTimestampFrequency`](get-timestamp-frequency.md) | 获取时间戳频率 | Override |
| [`GetCommandQueue`](get-command-queue.md) | 获取 D3D12 命令队列 | D3D12 特有 |
| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 | Override |
## 使用示例
```cpp
ID3D12Device* device; // 初始化好的 D3D12 设备
D3D12CommandQueue commandQueue;
if (commandQueue.Initialize(device, CommandQueueType::Direct)) {
// 使用命令队列
commandQueue.ExecuteCommandLists(count, lists);
// 等待完成
commandQueue.WaitForIdle();
}
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../d3d12.md)
- [RHICommandQueue](../../command-queue/command-queue.md) - 抽象命令队列接口
- [D3D12CommandList](../command-list/command-list.md)
- [D3D12Fence](../fence/fence.md)

25
docs/api/rhi/d3d12/command-queue/execute-command-lists.md
View File

@@ -4,14 +4,31 @@
void ExecuteCommandLists(uint32_t count, void** lists) override;
```
执行命令列表。
将指定数量的命令列表提交到命令队列执行。所有命令列表将在 GPU 上按提交顺序串行执行。
**参数：**
- `count` - 命令列表数量
- `lists` - 命令列表指针数组
- `count` - 命令列表数量，为正整数
- `lists` - 命令列表指针数组，每个元素类型为 `ID3D12CommandList*`
**复杂度：** O(n)
**返回：** 无
**线程安全：** 可从任意线程调用，建议从单线程提交以保证顺序
**复杂度：** O(1) 提交，O(n) GPU 执行（n 为命令数量）
**注意：** 此方法会阻塞调用线程直到命令列表提交完成，GPU 实际执行是异步的。
## 示例
```cpp
ID3D12CommandList* lists[2];
lists[0] = commandList1->GetCommandList();
lists[1] = commandList2->GetCommandList();
commandQueue.ExecuteCommandLists(2, reinterpret_cast<void**>(lists));
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [D3D12CommandList](../command-list/command-list.md)

8
docs/api/rhi/d3d12/command-queue/get-completed-value.md
View File

@@ -4,12 +4,16 @@
uint64_t GetCompletedValue() override;
```
获取已完成值。
获取命令队列关联的栅栏的当前完成值。
**返回：** 栅栏已完成的值
**返回：** 栅栏的已完成值
**复杂度：** O(1)
**注意：** 当前实现始终返回 0，表示此方法为未完成功能。使用前请确认功能状态。
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Signal](signal.md) - 向栅栏发送信号
- [D3D12Fence](../fence/fence.md)

18
docs/api/rhi/d3d12/command-queue/get-native-handle.md Normal file
View File

@@ -0,0 +1,18 @@
# D3D12CommandQueue::GetNativeHandle
```cpp
void* GetNativeHandle() override { return m_commandQueue.Get(); }
```
获取命令队列的原生句柄，用于与底层 D3D12 API 交互。
**返回：** `void*` 类型的原生指针，实际类型为 `ID3D12CommandQueue*`
**复杂度：** O(1)
**注意：** 返回的指针在命令队列销毁后将变为无效。请勿在命令队列销毁后继续使用。
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [GetCommandQueue](get-command-queue.md) - 获取类型安全的 D3D12 命令队列指针

21
docs/api/rhi/d3d12/command-queue/get-type.md Normal file
View File

@@ -0,0 +1,21 @@
# D3D12CommandQueue::GetType
```cpp
CommandQueueType GetType() const override { return m_type; }
```
获取命令队列的类型。
**返回：** `CommandQueueType` 枚举值，表示命令队列类型
- `Direct` - 直接命令队列，用于图形和计算操作
- `Compute` - 计算命令队列，用于纯计算操作
- `Copy` - 复制命令队列，用于数据传输操作
**复杂度：** O(1)
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Initialize](initialize.md) - 初始化命令队列
- [CommandQueueType](../../common/enums.md#commandqueuetype) - 队列类型枚举说明

31
docs/api/rhi/d3d12/command-queue/initialize.md Normal file
View File

@@ -0,0 +1,31 @@
# D3D12CommandQueue::Initialize
```cpp
bool Initialize(ID3D12Device* device, CommandQueueType type = CommandQueueType::Direct);
```
初始化 D3D12 命令队列，创建底层 `ID3D12CommandQueue` 对象。
**参数：**
- `device` - D3D12 设备指针
- `type` - 命令队列类型，默认为 `Direct`
**返回：** 初始化成功返回 `true`，失败返回 `false`
**复杂度：** O(1)
## 示例
```cpp
ID3D12Device* device; // 已初始化的 D3D12 设备
D3D12CommandQueue commandQueue;
if (commandQueue.Initialize(device, CommandQueueType::Direct)) {
// 命令队列初始化成功
}
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Shutdown](../../command-queue/shutdown.md) - 关闭命令队列

31
docs/api/rhi/d3d12/command-queue/shutdown.md Normal file
View File

@@ -0,0 +1,31 @@
# D3D12CommandQueue::Shutdown
```cpp
void Shutdown() override;
```
关闭命令队列并释放底层 D3D12 资源。调用此方法后，命令队列将变为无效状态。
**返回：** 无
**注意：**
- 此方法由析构函数自动调用
- 调用前应确保没有正在执行命令
- 释放底层的 `ID3D12CommandQueue` 接口
## 示例
```cpp
D3D12CommandQueue commandQueue;
commandQueue.Initialize(device, CommandQueueType::Direct);
// 使用命令队列...
// 关闭并释放资源
commandQueue.Shutdown();
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Initialize](initialize.md) - 初始化命令队列

25
docs/api/rhi/d3d12/command-queue/signal-native.md Normal file
View File

@@ -0,0 +1,25 @@
# D3D12CommandQueue::Signal (Native)
```cpp
void Signal(ID3D12Fence* fence, uint64_t value);
```
向 D3D12 原生栅栏发送信号。
**参数：**
- `fence` - D3D12 原生栅栏指针
- `value` - 信号值
**复杂度：** O(1)
## 示例
```cpp
ID3D12Fence* nativeFence; // D3D12 原生栅栏
commandQueue.Signal(nativeFence, 1);
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Signal(RHIFence*)](../../command-queue/signal.md) - RHIFence 重载版本

23
docs/api/rhi/d3d12/command-queue/signal.md
View File

@@ -4,14 +4,31 @@
void Signal(RHIFence* fence, uint64_t value) override;
```
发送信号。
向指定栅栏发送信号，将栅栏的完成值设置为给定值。该方法用于同步 GPU 和 CPU 操作。
**参数：**
- `fence` - 栅栏指针
- `value` - 信号值
- `fence` - 目标栅栏指针，不能为 `nullptr`
- `value` - 信号值，一个正整数
**返回：** 无
**复杂度：** O(1)
**使用场景：**
- 标记命令队列中所有已提交命令完成的时间点
- 用于 GPU-CPU 同步
- 与 `Wait` 方法配合实现 GPU 流水线同步
## 示例
```cpp
D3D12Fence* fence; // 已初始化的栅栏
commandQueue.Signal(fence, 1);
// CPU 可以继续其他工作，GPU 执行完成后 fence 的值变为 1
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Wait](wait-for-idle.md) - 等待命令队列完成
- [D3D12Fence](../fence/fence.md)

27
docs/api/rhi/d3d12/command-queue/wait-for-idle.md
View File

@@ -4,10 +4,33 @@
void WaitForIdle() override;
```
等待空闲。
阻塞当前线程，直到命令队列中所有已提交的命令全部执行完成。该方法会强制 GPU 等待所有待处理命令完成后才返回。
**复杂度：** O(n)
**返回：** 无
**复杂度：** O(n)，其中 n 为待处理命令的数量
**使用场景：**
- 帧同步：确保一帧的所有渲染命令完成后再进行下一步操作
- 资源管理：确保 GPU 不再使用某个资源后再释放
- 调试：等待特定命令完成以便进行 GPU 调试
**注意：** 这是一个阻塞调用，会暂停 CPU 线程直到 GPU 完成所有命令。频繁调用可能影响性能。
## 示例
```cpp
// 提交渲染命令
commandQueue.ExecuteCommandLists(count, lists);
// 等待所有命令完成
commandQueue.WaitForIdle();
// 此时可以安全地释放命令列表使用的资源
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Signal](signal.md) - 向栅栏发送信号
- [Wait](signal.md) - 等待栅栏达到指定值

25
docs/api/rhi/d3d12/command-queue/wait-native.md Normal file
View File

@@ -0,0 +1,25 @@
# D3D12CommandQueue::Wait (Native)
```cpp
void Wait(ID3D12Fence* fence, uint64_t value);
```
等待 D3D12 原生栅栏达到指定值。
**参数：**
- `fence` - D3D12 原生栅栏指针
- `value` - 等待的信号值
**复杂度：** O(1)
## 示例
```cpp
ID3D12Fence* nativeFence; // D3D12 原生栅栏
commandQueue.Wait(nativeFence, 1);
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Wait(RHIFence*)](../../command-queue/wait.md) - RHIFence 重载版本

37
docs/api/rhi/d3d12/command-queue/wait.md Normal file
View File

@@ -0,0 +1,37 @@
# D3D12CommandQueue::Wait
```cpp
void Wait(RHIFence* fence, uint64_t value) override;
```
阻塞命令队列，直到指定栅栏的完成值达到指定值。该方法用于 GPU 内部的同步操作。
**参数：**
- `fence` - 目标栅栏指针，不能为 `nullptr`
- `value` - 等待的信号值
**返回：** 无
**复杂度：** O(1)
**使用场景：**
- 等待另一个命令队列的操作完成
- 实现 GPU 流水线各阶段之间的同步
- 多 GPU 节点间的同步
**注意：** 如果栅栏的当前值已经大于或等于指定值，则此方法立即返回。
## 示例
```cpp
D3D12Fence* fence; // 已发送信号的栅栏
// 等待 fence 的值达到 1
commandQueue.Wait(fence, 1);
```
## 相关文档
- [D3D12CommandQueue 总览](command-queue.md) - 返回类总览
- [Signal](signal.md) - 向栅栏发送信号
- [Wait(ID3D12Fence*)](wait-native.md) - Native D3D12Fence 版本
- [D3D12Fence](../fence/fence.md)

37
docs/api/rhi/d3d12/common/check-format-support.md Normal file
View File

@@ -0,0 +1,37 @@
# D3D12Common::CheckFormatSupport
```cpp
inline bool CheckFormatSupport(
ID3D12Device* device,
DXGI_FORMAT format,
D3D12_FORMAT_SUPPORT1 support1,
D3D12_FORMAT_SUPPORT2 support2 = D3D12_FORMAT_SUPPORT2_NONE
)
```
检查设备是否支持指定格式的特定功能。
**参数：**
- `device` - D3D12 设备指针
- `format` - 要检查的 DXGI 格式
- `support1` - 主格式支持标志（`D3D12_FORMAT_SUPPORT1`）
- `support2` - 扩展格式支持标志（`D3D12_FORMAT_SUPPORT2`），默认为 `D3D12_FORMAT_SUPPORT2_NONE`
**返回：** 如果格式支持指定功能返回 `true`，否则返回 `false`
**线程安全：** ✅（只读查询）
**示例：**
```cpp
ID3D12Device* device = ...;
if (CheckFormatSupport(device, DXGI_FORMAT_BC1_UNORM, D3D12_FORMAT_SUPPORT1_TEXTURE2D)) {
// 支持 BC1 压缩格式
}
```
## 相关文档
- [D3D12Common 总览](common.md)
- [IsRenderTargetFormatSupported](is-render-target-format-supported.md)
- [IsTextureFormatSupported](is-texture-format-supported.md)

90
docs/api/rhi/d3d12/common/common.md
View File

@@ -2,7 +2,21 @@
**命名空间**: `XCEngine::RHI`
**描述**: D3D12 通用辅助函数集合，提供描述符大小、屏障创建、格式支持检查等功能。**所有函数均为 inline 函数**。
**类型**: `inline 函数集合` (header-only)
**描述**: D3D12 通用辅助函数集合，提供描述符大小查询、资源屏障创建、格式支持检查、视图创建等功能。所有函数均为 `inline` 函数，封装自 DirectX 12 原生 API。
## 概述
D3D12Common 是 D3D12 后端的工具函数模块，封装了 DirectX 12 常用的辅助功能，包括：
- **描述符大小查询**: 封装 `ID3D12Device::GetDescriptorHandleIncrementSize`，提供各类描述符的增量大小
- **资源屏障创建**: 封装 `D3D12_RESOURCE_BARRIER` 的三种类型（Transition、UAV、Aliasing）
- **格式支持检查**: 封装 `ID3D12Device::CheckFeatureSupport`，检查格式是否支持特定用途
- **视图创建**: 封装 D3D12_VERTEX_BUFFER_VIEW、D3D12_INDEX_BUFFER_VIEW、D3D12_VIEWPORT 等创建
- **描述符句柄运算**: 提供描述符句柄的偏移计算
这些函数均为无状态的纯函数，设计用于简化 D3D12 常见操作的代码编写。
## 函数列表
@@ -10,58 +24,88 @@
| 函数 | 描述 |
|------|------|
| `GetDescriptorHandleIncrementSize` | 获取描述符增量大小 |
| `GetRTVDescriptorSize` | 获取 RTV 描述符大小 |
| `GetDSVDescriptorSize` | 获取 DSV 描述符大小 |
| `GetCBV_SRV_UAVDescriptorSize` | 获取 CBV/SRV/UAV 描述符大小 |
| `GetSamplerDescriptorSize` | 获取 Sampler 描述符大小 |
| [`GetDescriptorHandleIncrementSize`](get-descriptor-handle-increment-size.md) | 获取指定描述符堆类型的增量大小 |
| [`GetRTVDescriptorSize`](get-rtv-descriptor-size.md) | 获取 RTV 描述符大小 |
| [`GetDSVDescriptorSize`](get-dsv-descriptor-size.md) | 获取 DSV 描述符大小 |
| [`GetCBV_SRV_UAVDescriptorSize`](get-cbv-srv-uav-descriptor-size.md) | 获取 CBV/SRV/UAV 描述符大小 |
| [`GetSamplerDescriptorSize`](get-sampler-descriptor-size.md) | 获取 Sampler 描述符大小 |
### 屏障创建
| 函数 | 描述 |
|------|------|
| `CreateTransitionBarrier` | 创建资源状态转换屏障 |
| `CreateUAVBarrier` | 创建 UAV 屏障 |
| `CreateAliasingBarrier` | 创建别名化屏障 |
| [`CreateTransitionBarrier`](create-transition-barrier.md) | 创建资源状态转换屏障 |
| [`CreateUAVBarrier`](create-uav-barrier.md) | 创建 UAV 屏障 |
| [`CreateAliasingBarrier`](create-aliasing-barrier.md) | 创建别名化屏障 |
### 格式支持
| 函数 | 描述 |
|------|------|
| `CheckFormatSupport` | 检查格式支持 |
| `IsRenderTargetFormatSupported` | 检查是否支持作为渲染目标 |
| `IsDepthStencilFormatSupported` | 检查是否支持作为深度模板 |
| `IsShaderResourceFormatSupported` | 检查 shader 是否可读取 |
| `IsTextureFormatSupported` | 检查是否支持作为纹理 |
| [`CheckFormatSupport`](check-format-support.md) | 检查格式是否支持指定功能 |
| [`IsRenderTargetFormatSupported`](is-render-target-format-supported.md) | 检查是否支持作为渲染目标 |
| [`IsDepthStencilFormatSupported`](is-depth-stencil-format-supported.md) | 检查是否支持作为深度模板 |
| [`IsShaderResourceFormatSupported`](is-shader-resource-format-supported.md) | 检查是否支持作为着色器资源 |
| [`IsTextureFormatSupported`](is-texture-format-supported.md) | 检查是否支持作为纹理 |
### 清除值创建
| 函数 | 描述 |
|------|------|
| `CreateRenderTargetClearValue` | 创建渲染目标清除值 |
| `CreateDepthStencilClearValue` | 创建深度模板清除值 |
| [`CreateRenderTargetClearValue`](create-render-target-clear-value.md) | 创建渲染目标清除值 |
| [`CreateDepthStencilClearValue`](create-depth-stencil-clear-value.md) | 创建深度模板清除值 |
### 视口和裁剪矩形
| 函数 | 描述 |
|------|------|
| `CreateViewport` | 创建视口 |
| `CreateScissorRect` | 创建裁剪矩形 |
| [`CreateViewport`](create-viewport.md) | 创建视口结构 |
| [`CreateScissorRect`](create-scissor-rect.md) | 创建裁剪矩形 |
### 缓冲区视图
| 函数 | 描述 |
|------|------|
| `CreateVertexBufferView` | 创建顶点缓冲区视图 |
| `CreateIndexBufferView` | 创建索引缓冲区视图 |
| [`CreateVertexBufferView`](create-vertex-buffer-view.md) | 创建顶点缓冲区视图 |
| [`CreateIndexBufferView`](create-index-buffer-view.md) | 创建索引缓冲区视图 |
### 描述符句柄运算
| 函数 | 描述 |
|------|------|
| `GetCPUDescriptorHandle` | 计算偏移后的 CPU 描述符句柄 |
| `GetGPUDescriptorHandle` | 计算偏移后的 GPU 描述符句柄 |
| [`GetCPUDescriptorHandle`](get-cpu-descriptor-handle.md) | 计算偏移后的 CPU 描述符句柄 |
| [`GetGPUDescriptorHandle`](get-gpu-descriptor-handle.md) | 计算偏移后的 GPU 描述符句柄 |
## 使用示例
```cpp
#include <XCEngine/RHI/D3D12/D3D12Common.h>
using namespace XCEngine::RHI;
// 获取描述符大小
ID3D12Device* device = ...;
UINT rtvSize = GetRTVDescriptorSize(device);
// 创建资源屏障
D3D12_RESOURCE_BARRIER barrier = CreateTransitionBarrier(
resource,
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_COMMON
);
// 检查格式支持
if (IsTextureFormatSupported(device, DXGI_FORMAT_BC1_UNORM)) {
// 使用压缩纹理
}
// 创建视口
D3D12_VIEWPORT viewport = CreateViewport(1280.0f, 720.0f);
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端概览](../d3d12.md) - D3D12 模块总览
- [RHI 模块总览](../../rhi.md) - RHI 抽象层
- [D3D12Device](../device/device.md) - D3D12 设备
- [D3D12DescriptorHeap](../descriptor-heap/descriptor-heap.md) - 描述符堆

32
docs/api/rhi/d3d12/common/create-aliasing-barrier.md Normal file
View File

@@ -0,0 +1,32 @@
# D3D12Common::CreateAliasingBarrier
```cpp
inline D3D12_RESOURCE_BARRIER CreateAliasingBarrier(
ID3D12Resource* beforeResource = nullptr,
ID3D12Resource* afterResource = nullptr
)
```
创建资源别名化屏障，用于不同资源之间的切换。
**参数：**
- `beforeResource` - 别名前的资源，默认为 `nullptr`
- `afterResource` - 别名后的资源，默认为 `nullptr`
**返回：** 配置好的 `D3D12_RESOURCE_BARRIER` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
ID3D12Resource* resourceA = ...;
ID3D12Resource* resourceB = ...;
D3D12_RESOURCE_BARRIER barrier = CreateAliasingBarrier(resourceA, resourceB);
cmdList->ResourceBarrier(1, &barrier);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateTransitionBarrier](create-transition-barrier.md)

35
docs/api/rhi/d3d12/common/create-depth-stencil-clear-value.md Normal file
View File

@@ -0,0 +1,35 @@
# D3D12Common::CreateDepthStencilClearValue
```cpp
inline D3D12_CLEAR_VALUE CreateDepthStencilClearValue(
DXGI_FORMAT format,
float depth = 1.0f,
uint8_t stencil = 0
)
```
创建深度模板缓冲区的清除值。
**参数：**
- `format` - 深度模板格式
- `depth` - 深度值，默认为 1.0f
- `stencil` - 模板值，默认为 0
**返回：** 配置好的 `D3D12_CLEAR_VALUE` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_CLEAR_VALUE clearValue = CreateDepthStencilClearValue(
DXGI_FORMAT_D24_UNORM_S8_UINT,
1.0f,
0
);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateRenderTargetClearValue](create-render-target-clear-value.md)

37
docs/api/rhi/d3d12/common/create-index-buffer-view.md Normal file
View File

@@ -0,0 +1,37 @@
# D3D12Common::CreateIndexBufferView
```cpp
inline D3D12_INDEX_BUFFER_VIEW CreateIndexBufferView(
D3D12_GPU_VIRTUAL_ADDRESS bufferLocation,
UINT sizeInBytes,
DXGI_FORMAT format
)
```
创建索引缓冲区视图。
**参数：**
- `bufferLocation` - 索引缓冲区 GPU 虚拟地址
- `sizeInBytes` - 缓冲区大小（字节）
- `format` - 索引格式（DXGI_FORMAT_R16_UINT 或 DXGI_FORMAT_R32_UINT）
**返回：** 配置好的 `D3D12_INDEX_BUFFER_VIEW` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
ID3D12Resource* indexBuffer = ...;
D3D12_INDEX_BUFFER_VIEW ibView = CreateIndexBufferView(
indexBuffer->GetGPUVirtualAddress(),
indexBufferSize,
DXGI_FORMAT_R16_UINT
);
cmdList->IASetIndexBuffer(&ibView);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateVertexBufferView](create-vertex-buffer-view.md)

38
docs/api/rhi/d3d12/common/create-render-target-clear-value.md Normal file
View File

@@ -0,0 +1,38 @@
# D3D12Common::CreateRenderTargetClearValue
```cpp
inline D3D12_CLEAR_VALUE CreateRenderTargetClearValue(
DXGI_FORMAT format,
float r = 0.0f,
float g = 0.0f,
float b = 0.0f,
float a = 1.0f
)
```
创建渲染目标的清除值（清除颜色）。
**参数：**
- `format` - 渲染目标格式
- `r` - 红色分量，默认为 0.0f
- `g` - 绿色分量，默认为 0.0f
- `b` - 蓝色分量，默认为 0.0f
- `a` - Alpha 分量，默认为 1.0f
**返回：** 配置好的 `D3D12_CLEAR_VALUE` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_CLEAR_VALUE clearValue = CreateRenderTargetClearValue(
DXGI_FORMAT_R8G8B8A8_UNORM,
0.0f, 0.0f, 0.0f, 1.0f
);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateDepthStencilClearValue](create-depth-stencil-clear-value.md)

29
docs/api/rhi/d3d12/common/create-scissor-rect.md Normal file
View File

@@ -0,0 +1,29 @@
# D3D12Common::CreateScissorRect
```cpp
inline D3D12_RECT CreateScissorRect(int left, int top, int right, int bottom)
```
创建裁剪矩形（剪刀矩形）。
**参数：**
- `left` - 矩形左边界
- `top` - 矩形上边界
- `right` - 矩形右边界
- `bottom` - 矩形下边界
**返回：** 配置好的 `D3D12_RECT` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_RECT scissorRect = CreateScissorRect(0, 0, 1280, 720);
cmdList->RSSetScissorRects(1, &scissorRect);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateViewport](create-viewport.md)

39
docs/api/rhi/d3d12/common/create-transition-barrier.md Normal file
View File

@@ -0,0 +1,39 @@
# D3D12Common::CreateTransitionBarrier
```cpp
inline D3D12_RESOURCE_BARRIER CreateTransitionBarrier(
ID3D12Resource* resource,
D3D12_RESOURCE_STATES stateBefore,
D3D12_RESOURCE_STATES stateAfter,
UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES
)
```
创建资源状态转换屏障，用于同步资源状态转换。
**参数：**
- `resource` - 目标资源指针
- `stateBefore` - 转换前的资源状态
- `stateAfter` - 转换后的资源状态
- `subresource` - 子资源索引，默认为所有子资源
**返回：** 配置好的 `D3D12_RESOURCE_BARRIER` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
ID3D12Resource* texture = ...;
D3D12_RESOURCE_BARRIER barrier = CreateTransitionBarrier(
texture,
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_COMMON
);
cmdList->ResourceBarrier(1, &barrier);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [D3D12CommandList](../command-list/command-list.md)

27
docs/api/rhi/d3d12/common/create-uav-barrier.md Normal file
View File

@@ -0,0 +1,27 @@
# D3D12Common::CreateUAVBarrier
```cpp
inline D3D12_RESOURCE_BARRIER CreateUAVBarrier(ID3D12Resource* resource = nullptr)
```
创建无序访问视图（UAV）屏障，用于同步 UAV 访问。
**参数：**
- `resource` - UAV 资源指针，默认为 `nullptr`（全局 UAV 屏障）
**返回：** 配置好的 `D3D12_RESOURCE_BARRIER` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
ID3D12Resource* uavResource = ...;
D3D12_RESOURCE_BARRIER barrier = CreateUAVBarrier(uavResource);
cmdList->ResourceBarrier(1, &barrier);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateTransitionBarrier](create-transition-barrier.md)

37
docs/api/rhi/d3d12/common/create-vertex-buffer-view.md Normal file
View File

@@ -0,0 +1,37 @@
# D3D12Common::CreateVertexBufferView
```cpp
inline D3D12_VERTEX_BUFFER_VIEW CreateVertexBufferView(
D3D12_GPU_VIRTUAL_ADDRESS bufferLocation,
UINT sizeInBytes,
UINT strideInBytes
)
```
创建顶点缓冲区视图。
**参数：**
- `bufferLocation` - 顶点缓冲区 GPU 虚拟地址
- `sizeInBytes` - 缓冲区大小（字节）
- `strideInBytes` - 单个顶点的大小（字节）
**返回：** 配置好的 `D3D12_VERTEX_BUFFER_VIEW` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
ID3D12Resource* vertexBuffer = ...;
D3D12_VERTEX_BUFFER_VIEW vbView = CreateVertexBufferView(
vertexBuffer->GetGPUVirtualAddress(),
vertexBufferSize,
sizeof(Vertex)
);
cmdList->IASetVertexBuffers(0, 1, &vbView);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateIndexBufferView](create-index-buffer-view.md)

38
docs/api/rhi/d3d12/common/create-viewport.md Normal file
View File

@@ -0,0 +1,38 @@
# D3D12Common::CreateViewport
```cpp
inline D3D12_VIEWPORT CreateViewport(
float width,
float height,
float topLeftX = 0.0f,
float topLeftY = 0.0f,
float minDepth = 0.0f,
float maxDepth = 1.0f
)
```
创建 D3D12 视口结构。
**参数：**
- `width` - 视口宽度（像素）
- `height` - 视口高度（像素）
- `topLeftX` - 视口左上角 X 坐标，默认为 0
- `topLeftY` - 视口左上角 Y 坐标，默认为 0
- `minDepth` - 最小深度值，默认为 0
- `maxDepth` - 最大深度值，默认为 1
**返回：** 配置好的 `D3D12_VIEWPORT` 结构
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_VIEWPORT viewport = CreateViewport(1280.0f, 720.0f, 0.0f, 0.0f, 0.0f, 1.0f);
cmdList->RSSetViewports(1, &viewport);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CreateScissorRect](create-scissor-rect.md)

26
docs/api/rhi/d3d12/common/get-cbv-srv-uav-descriptor-size.md Normal file
View File

@@ -0,0 +1,26 @@
# D3D12Common::GetCBV_SRV_UAVDescriptorSize
```cpp
inline UINT GetCBV_SRV_UAVDescriptorSize(ID3D12Device* device)
```
获取常量缓冲区视图（CBV）、着色器资源视图（SRV）和无序访问视图（UAV）的描述符大小。
**参数：**
- `device` - D3D12 设备指针
**返回：** CBV/SRV/UAV 描述符大小（字节）
**线程安全：** ✅（只读操作）
**示例：**
```cpp
ID3D12Device* device = ...;
UINT descriptorSize = GetCBV_SRV_UAVDescriptorSize(device);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [GetSamplerDescriptorSize](get-sampler-descriptor-size.md)

35
docs/api/rhi/d3d12/common/get-cpu-descriptor-handle.md Normal file
View File

@@ -0,0 +1,35 @@
# D3D12Common::GetCPUDescriptorHandle
```cpp
inline D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle(
D3D12_CPU_DESCRIPTOR_HANDLE baseHandle,
UINT offsetInDescriptors,
UINT descriptorSize
)
```
计算偏移后的 CPU 描述符句柄。
**参数：**
- `baseHandle` - 基础描述符句柄
- `offsetInDescriptors` - 描述符偏移数量
- `descriptorSize` - 单个描述符大小（字节）
**返回：** 偏移后的 CPU 描述符句柄
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = GetCPUDescriptorHandle(
heapStartHandle,
2, // 第3个描述符
rtvDescriptorSize
);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [GetGPUDescriptorHandle](get-gpu-descriptor-handle.md)

28
docs/api/rhi/d3d12/common/get-descriptor-handle-increment-size.md Normal file
View File

@@ -0,0 +1,28 @@
# D3D12Common::GetDescriptorHandleIncrementSize
```cpp
inline UINT GetDescriptorHandleIncrementSize(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE heapType)
```
获取指定描述符堆类型的描述符增量大小（增量偏移值）。
**参数：**
- `device` - D3D12 设备指针
- `heapType` - 描述符堆类型（`D3D12_DESCRIPTOR_HEAP_TYPE`）
**返回：** 指定类型的描述符增量大小（字节）
**线程安全：** ✅（只读操作）
**示例：**
```cpp
ID3D12Device* device = ...;
UINT rtvIncSize = GetDescriptorHandleIncrementSize(device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
UINT srvIncSize = GetDescriptorHandleIncrementSize(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [D3D12DescriptorHeap](../descriptor-heap/descriptor-heap.md)

26
docs/api/rhi/d3d12/common/get-dsv-descriptor-size.md Normal file
View File

@@ -0,0 +1,26 @@
# D3D12Common::GetDSVDescriptorSize
```cpp
inline UINT GetDSVDescriptorSize(ID3D12Device* device)
```
获取深度模板视图（DSV）的描述符大小。
**参数：**
- `device` - D3D12 设备指针
**返回：** DSV 描述符大小（字节）
**线程安全：** ✅（只读操作）
**示例：**
```cpp
ID3D12Device* device = ...;
UINT dsvSize = GetDSVDescriptorSize(device);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [GetRTVDescriptorSize](get-rtv-descriptor-size.md)

35
docs/api/rhi/d3d12/common/get-gpu-descriptor-handle.md Normal file
View File

@@ -0,0 +1,35 @@
# D3D12Common::GetGPUDescriptorHandle
```cpp
inline D3D12_GPU_DESCRIPTOR_HANDLE GetGPUDescriptorHandle(
D3D12_GPU_DESCRIPTOR_HANDLE baseHandle,
UINT offsetInDescriptors,
UINT descriptorSize
)
```
计算偏移后的 GPU 描述符句柄。
**参数：**
- `baseHandle` - 基础描述符句柄
- `offsetInDescriptors` - 描述符偏移数量
- `descriptorSize` - 单个描述符大小（字节）
**返回：** 偏移后的 GPU 描述符句柄
**线程安全：** ✅（纯函数）
**示例：**
```cpp
D3D12_GPU_DESCRIPTOR_HANDLE srvHandle = GetGPUDescriptorHandle(
heapStartHandle,
5, // 第6个描述符
srvDescriptorSize
);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [GetCPUDescriptorHandle](get-cpu-descriptor-handle.md)

27
docs/api/rhi/d3d12/common/get-rtv-descriptor-size.md Normal file
View File

@@ -0,0 +1,27 @@
# D3D12Common::GetRTVDescriptorSize
```cpp
inline UINT GetRTVDescriptorSize(ID3D12Device* device)
```
获取渲染目标视图（RTV）的描述符大小。
**参数：**
- `device` - D3D12 设备指针
**返回：** RTV 描述符大小（字节）
**线程安全：** ✅（只读操作）
**示例：**
```cpp
ID3D12Device* device = ...;
UINT rtvSize = GetRTVDescriptorSize(device);
D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = GetCPUDescriptorHandle(baseHandle, 0, rtvSize);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [D3D12RenderTargetView](../render-target-view/render-target-view.md)

26
docs/api/rhi/d3d12/common/get-sampler-descriptor-size.md Normal file
View File

@@ -0,0 +1,26 @@
# D3D12Common::GetSamplerDescriptorSize
```cpp
inline UINT GetSamplerDescriptorSize(ID3D12Device* device)
```
获取采样器（Sampler）的描述符大小。
**参数：**
- `device` - D3D12 设备指针
**返回：** Sampler 描述符大小（字节）
**线程安全：** ✅（只读操作）
**示例：**
```cpp
ID3D12Device* device = ...;
UINT samplerSize = GetSamplerDescriptorSize(device);
```
## 相关文档
- [D3D12Common 总览](common.md)
- [GetCBV_SRV_UAVDescriptorSize](get-cbv-srv-uav-descriptor-size.md)

29
docs/api/rhi/d3d12/common/is-depth-stencil-format-supported.md Normal file
View File

@@ -0,0 +1,29 @@
# D3D12Common::IsDepthStencilFormatSupported
```cpp
inline bool IsDepthStencilFormatSupported(ID3D12Device* device, DXGI_FORMAT format)
```
检查指定格式是否支持作为深度模板缓冲区。
**参数：**
- `device` - D3D12 设备指针
- `format` - 要检查的 DXGI 格式
**返回：** 如果格式支持作为深度模板返回 `true`
**线程安全：** ✅（只读查询）
**示例：**
```cpp
ID3D12Device* device = ...;
if (IsDepthStencilFormatSupported(device, DXGI_FORMAT_D24_UNORM_S8_UINT)) {
// 可以使用该格式作为深度模板
}
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CheckFormatSupport](check-format-support.md)

29
docs/api/rhi/d3d12/common/is-render-target-format-supported.md Normal file
View File

@@ -0,0 +1,29 @@
# D3D12Common::IsRenderTargetFormatSupported
```cpp
inline bool IsRenderTargetFormatSupported(ID3D12Device* device, DXGI_FORMAT format)
```
检查指定格式是否支持作为渲染目标。
**参数：**
- `device` - D3D12 设备指针
- `format` - 要检查的 DXGI 格式
**返回：** 如果格式支持作为渲染目标返回 `true`
**线程安全：** ✅（只读查询）
**示例：**
```cpp
ID3D12Device* device = ...;
if (IsRenderTargetFormatSupported(device, DXGI_FORMAT_R8G8B8A8_UNORM)) {
// 可以使用该格式作为渲染目标
}
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CheckFormatSupport](check-format-support.md)

29
docs/api/rhi/d3d12/common/is-shader-resource-format-supported.md Normal file
View File

@@ -0,0 +1,29 @@
# D3D12Common::IsShaderResourceFormatSupported
```cpp
inline bool IsShaderResourceFormatSupported(ID3D12Device* device, DXGI_FORMAT format)
```
检查指定格式是否支持作为着色器资源。
**参数：**
- `device` - D3D12 设备指针
- `format` - 要检查的 DXGI 格式
**返回：** 如果格式支持作为着色器资源返回 `true`
**线程安全：** ✅（只读查询）
**示例：**
```cpp
ID3D12Device* device = ...;
if (IsShaderResourceFormatSupported(device, DXGI_FORMAT_R32G32B32_FLOAT)) {
// 可以在着色器中读取该格式
}
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CheckFormatSupport](check-format-support.md)

29
docs/api/rhi/d3d12/common/is-texture-format-supported.md Normal file
View File

@@ -0,0 +1,29 @@
# D3D12Common::IsTextureFormatSupported
```cpp
inline bool IsTextureFormatSupported(ID3D12Device* device, DXGI_FORMAT format)
```
检查指定格式是否支持作为纹理。
**参数：**
- `device` - D3D12 设备指针
- `format` - 要检查的 DXGI 格式
**返回：** 如果格式支持作为纹理返回 `true`
**线程安全：** ✅（只读查询）
**示例：**
```cpp
ID3D12Device* device = ...;
if (IsTextureFormatSupported(device, DXGI_FORMAT_BC1_UNORM)) {
// 可以创建该格式的纹理
}
```
## 相关文档
- [D3D12Common 总览](common.md)
- [CheckFormatSupport](check-format-support.md)

28
docs/api/rhi/d3d12/constant-buffer-view/constant-buffer-view.md
View File

@@ -2,16 +2,36 @@
**命名空间**: `XCEngine::RHI`
**描述**: DirectX 12 常量缓冲区视图的 D3D12 实现。
**类型**: 类
**描述**: DirectX 12 常量缓冲区视图的 D3D12 实现，提供与 D3D12 API 的直接交互接口。
**概述**: `D3D12ConstantBufferView` 是对 D3D12 常量缓冲区视图（Constant Buffer View）的封装类。它管理一个 CPU 可见的描述符句柄，用于在渲染命令中绑定常量缓冲区。内部持有对 D3D12 资源的引用，资源生命周期由外部管理。
## 公共方法
| 方法 | 描述 |
|------|------|
| [`Initialize`](../../../threading/task-system/initialize.md) | 初始化常量缓冲区视图 |
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭常量缓冲区视图 |
| [`D3D12ConstantBufferView`](constructor.md) | 构造函数 |
| [`~D3D12ConstantBufferView`](destructor.md) | 析构函数 |
| [`Initialize`](initialize.md) | 初始化常量缓冲区视图 |
| [`Shutdown`](shutdown.md) | 关闭常量缓冲区视图 |
| [`GetCPUDescriptorHandle`](get-cpu-descriptor-handle.md) | 获取 CPU 描述符句柄 |
## 使用示例
```cpp
ID3D12Device* device;
ID3D12Resource* buffer;
XCEngine::RHI::D3D12ConstantBufferView cbv;
cbv.Initialize(device, buffer);
// 使用 cbv.GetCPUDescriptorHandle() 绑定到命令列表
cbv.Shutdown();
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../d3d12.md)

16
docs/api/rhi/d3d12/constant-buffer-view/constructor.md Normal file
View File

@@ -0,0 +1,16 @@
# D3D12ConstantBufferView::D3D12ConstantBufferView
```cpp
D3D12ConstantBufferView();
```
构造一个空的 D3D12ConstantBufferView 实例。
## 复杂度
O(1)
## 相关文档
- [D3D12ConstantBufferView 总览](constant-buffer-view.md)
- [~D3D12ConstantBufferView](destructor.md)

16
docs/api/rhi/d3d12/constant-buffer-view/destructor.md Normal file
View File

@@ -0,0 +1,16 @@
# D3D12ConstantBufferView::~D3D12ConstantBufferView
```cpp
~D3D12ConstantBufferView();
```
析构函数，自动调用 Shutdown 清理资源。
## 复杂度
O(1)
## 相关文档
- [D3D12ConstantBufferView 总览](constant-buffer-view.md)
- [D3D12ConstantBufferView](constructor.md)

16
docs/api/rhi/d3d12/constant-buffer-view/get-cpu-descriptor-handle.md
View File

@@ -1,15 +1,21 @@
# D3D12ConstantBufferView::GetCPUDescriptorHandle
```cpp
D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle() const { return m_handle; }
D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle() const;
```
获取 CPU 描述符句柄。
获取 CPU 描述符句柄，用于绑定到命令列表。
**返回：** CPU 描述符句柄
## 返回值
**复杂度：** O(1)
| 类型 | 描述 |
|------|------|
| `D3D12_CPU_DESCRIPTOR_HANDLE` | CPU 侧描述符句柄，可用于设置命令列表 |
## 复杂度
O(1)
## 相关文档
- [D3D12ConstantBufferView 总览](constant-buffer-view.md) - 返回类总览
- [D3D12ConstantBufferView 总览](constant-buffer-view.md)

26
docs/api/rhi/d3d12/constant-buffer-view/initialize.md Normal file
View File

@@ -0,0 +1,26 @@
# D3D12ConstantBufferView::Initialize
```cpp
void Initialize(ID3D12Device* device, ID3D12Resource* buffer, const D3D12_CONSTANT_BUFFER_VIEW_DESC* desc = nullptr);
```
初始化常量缓冲区视图。
当 `desc` 参数为 `nullptr` 时，方法会自动根据 `buffer` 的属性创建视图描述：设置 `BufferLocation` 为缓冲区的 GPU 虚拟地址，`SizeInBytes` 为缓冲区的宽度。
## 参数
| 参数 | 类型 | 描述 |
|------|------|------|
| `device` | `ID3D12Device*` | D3D12 设备指针 |
| `buffer` | `ID3D12Resource*` | D3D12 资源指针，必须是常量缓冲区 |
| `desc` | `const D3D12_CONSTANT_BUFFER_VIEW_DESC*` | 可选的视图描述，如果为 `nullptr` 则自动创建 |
## 复杂度
O(1)
## 相关文档
- [D3D12ConstantBufferView 总览](constant-buffer-view.md)
- [Shutdown](shutdown.md)

16
docs/api/rhi/d3d12/constant-buffer-view/shutdown.md Normal file
View File

@@ -0,0 +1,16 @@
# D3D12ConstantBufferView::Shutdown
```cpp
void Shutdown();
```
关闭常量缓冲区视图，重置内部状态。此方法仅重置描述符句柄和资源指针，**不会**释放底层 D3D12 资源，资源生命周期由外部管理。
## 复杂度
O(1)
## 相关文档
- [D3D12ConstantBufferView 总览](constant-buffer-view.md)
- [Initialize](initialize.md)

14
docs/api/rhi/d3d12/depth-stencil-view/create-desc.md
View File

@@ -7,13 +7,21 @@ static D3D12_DEPTH_STENCIL_VIEW_DESC CreateDesc(Format format, D3D12_DSV_DIMENSI
创建深度模板视图描述（静态方法）。
**参数：**
- `format` - 格式
- `dimension` - 视图维度
- `format` - 深度模板格式（如 `Format::D32_FLOAT`）
- `dimension` - 视图维度，默认为 `D3D12_DSV_DIMENSION_TEXTURE2D`
**返回：** D3D12 深度模板视图描述
**复杂度：** O(1)
## 示例
```cpp
auto desc = D3D12DepthStencilView::CreateDesc(Format::D32_FLOAT, D3D12_DSV_DIMENSION_TEXTURE2D);
dsv.Initialize(device, depthBuffer, &desc);
```
## 相关文档
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 返回类总览
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 类总览
- [Initialize](initialize.md) - 初始化方法

37
docs/api/rhi/d3d12/depth-stencil-view/depth-stencil-view.md
View File

@@ -2,18 +2,43 @@
**命名空间**: `XCEngine::RHI`
**描述**: DirectX 12 深度模板视图的 D3D12 实现。
**类型**: `class`
**描述**: DirectX 12 深度模板视图的 D3D12 实现，用于渲染管线中的深度/模板测试。
## 概述
`D3D12DepthStencilView` 是 RHI 深度模板视图接口的 D3D12 特定实现。该类封装了 D3D12 深度模板视图（DSV）的创建和管理，提供两种初始化方式：自动分配描述符句柄或使用预分配的描述符句柄。深度模板视图是渲染管线中用于深度测试和模板测试的关键资源。
## 公共方法
| 方法 | 描述 |
|------|------|
| [`Initialize`](../../../threading/task-system/initialize.md) | 初始化深度模板视图 |
| [`InitializeAt`](initialize-at.md) | 在指定位置初始化 |
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭深度模板视图 |
| [`D3D12DepthStencilView()`](initialize.md) | 构造函数 |
| [`~D3D12DepthStencilView()`](initialize.md) | 析构函数 |
| [`Initialize`](initialize.md) | 初始化深度模板视图 |
| [`InitializeAt`](initialize-at.md) | 在指定位置初始化深度模板视图 |
| [`Shutdown`](shutdown.md) | 关闭深度模板视图 |
| [`GetCPUDescriptorHandle`](get-cpu-descriptor-handle.md) | 获取 CPU 描述符句柄 |
| [`CreateDesc`](create-desc.md) | 创建描述符（静态） |
| [`CreateDesc`](create-desc.md) | 创建描述符（静态方法） |
## 使用示例
```cpp
ID3D12Device* device; // 已初始化的 D3D12 设备
ID3D12Resource* depthBuffer; // 深度缓冲资源
D3D12DepthStencilView dsv;
dsv.Initialize(device, depthBuffer, nullptr);
D3D12_CPU_DESCRIPTOR_HANDLE handle = dsv.GetCPUDescriptorHandle();
// 使用 handle 进行渲染操作
dsv.Shutdown();
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端概览](../d3d12.md) - D3D12 后端模块总览
- [D3D12DescriptorHeap](../descriptor-heap/descriptor-heap.md) - 描述符堆管理
- [D3D12RenderTargetView](../render-target-view/render-target-view.md) - 渲染目标视图

18
docs/api/rhi/d3d12/depth-stencil-view/get-cpu-descriptor-handle.md
View File

@@ -1,15 +1,29 @@
# D3D12DepthStencilView::GetCPUDescriptorHandle
```cpp
D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle() const { return m_handle; }
D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle() const;
```
获取 CPU 描述符句柄。
获取深度模板视图的 CPU 描述符句柄，用于绑定到渲染管线。
**返回：** CPU 描述符句柄
**复杂度：** O(1)
## 说明
返回的描述符句柄用于将深度模板视图绑定到渲染管线的 OM（输出合并）阶段。此方法是 const 的，因为描述符句柄本身不修改对象状态。
## 示例
```cpp
D3D12DepthStencilView dsv;
dsv.Initialize(device, depthBuffer, nullptr);
D3D12_CPU_DESCRIPTOR_HANDLE handle = dsv.GetCPUDescriptorHandle();
// 使用 handle 绑定到 OM 阶段
```
## 相关文档
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 返回类总览

24
docs/api/rhi/d3d12/depth-stencil-view/initialize-at.md
View File

@@ -4,16 +4,30 @@
void InitializeAt(ID3D12Device* device, ID3D12Resource* resource, D3D12_CPU_DESCRIPTOR_HANDLE handle, const D3D12_DEPTH_STENCIL_VIEW_DESC* desc = nullptr);
```
在指定位置初始化深度模板视图。
在指定位置初始化深度模板视图，允许使用预分配的描述符句柄。
**参数：**
- `device` - D3D12 设备
- `resource` - D3D12 资源
- `handle` - CPU 描述符句柄
- `desc` - 深度模板视图描述
- `device` - D3D12 设备指针
- `resource` - D3D12 资源指针（深度缓冲纹理）
- `handle` - 预分配的 CPU 描述符句柄位置
- `desc` - 深度模板视图描述符，可选，默认为 nullptr
**返回：** 无
**复杂度：** O(1)
## 说明
此方法与 `Initialize` 的区别在于使用预分配的描述符句柄位置，适用于描述符堆管理场景。当需要将深度模板视图绑定到特定的描述符位置时使用此方法。
## 示例
```cpp
D3D12DepthStencilView dsv;
D3D12_CPU_DESCRIPTOR_HANDLE handle = GetPreallocatedHandle(); // 预分配的句柄
dsv.InitializeAt(device, depthBuffer, handle, nullptr);
```
## 相关文档
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 返回类总览

36
docs/api/rhi/d3d12/depth-stencil-view/initialize.md Normal file
View File

@@ -0,0 +1,36 @@
# D3D12DepthStencilView::Initialize
```cpp
void Initialize(ID3D12Device* device, ID3D12Resource* resource, const D3D12_DEPTH_STENCIL_VIEW_DESC* desc = nullptr);
```
初始化深度模板视图，使用设备自动分配描述符句柄。
**参数：**
- `device` - D3D12 设备指针
- `resource` - D3D12 资源指针（深度缓冲纹理）
- `desc` - 深度模板视图描述符，可选，默认为 nullptr
**返回：** 无
**复杂度：** O(1)
## 说明
此方法使用 `ID3D12Device::CreateDepthStencilView` 创建深度模板视图，描述符句柄由设备自动分配。适用于创建独立的深度模板视图。
## 示例
```cpp
D3D12DepthStencilView dsv;
dsv.Initialize(device, depthBuffer, nullptr);
// 获取描述符句柄用于渲染
D3D12_CPU_DESCRIPTOR_HANDLE handle = dsv.GetCPUDescriptorHandle();
```
## 相关文档
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 类总览
- [InitializeAt](initialize-at.md) - 在指定位置初始化
- [D3D12Device](../../device/device.md) - D3D12 设备

31
docs/api/rhi/d3d12/depth-stencil-view/shutdown.md Normal file
View File

@@ -0,0 +1,31 @@
# D3D12DepthStencilView::Shutdown
```cpp
void Shutdown();
```
关闭深度模板视图，释放关联的资源引用。
**返回：** 无
**复杂度：** O(1)
## 说明
此方法重置内部描述符句柄和资源指针，但不会释放描述符堆本身。调用后，视图对象处于未初始化状态，可以重新调用 `Initialize` 或 `InitializeAt` 进行初始化。
## 示例
```cpp
D3D12DepthStencilView dsv;
dsv.Initialize(device, depthBuffer, nullptr);
// 使用视图...
dsv.Shutdown();
```
## 相关文档
- [D3D12DepthStencilView 总览](depth-stencil-view.md) - 类总览
- [Initialize](initialize.md) - 初始化视图
- [InitializeAt](initialize-at.md) - 在指定位置初始化

18
docs/api/rhi/d3d12/descriptor-heap/constructor.md Normal file
View File

@@ -0,0 +1,18 @@
# D3D12DescriptorHeap::D3D12DescriptorHeap
```cpp
D3D12DescriptorHeap();
```
默认构造函数。创建空的描述符堆对象，所有成员变量初始化为默认值：
- `m_type` 初始化为 `CBV_SRV_UAV`
- `m_numDescriptors` 初始化为 0
- `m_descriptorSize` 初始化为 0
- `m_shaderVisible` 初始化为 false
构造的对象需要调用 `Initialize` 方法进行实际初始化。
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [Initialize](initialize-from-desc.md) - 初始化方法

45
docs/api/rhi/d3d12/descriptor-heap/descriptor-heap.md
View File

@@ -2,26 +2,61 @@
**命名空间**: `XCEngine::RHI`
**描述**: DirectX 12 描述符堆的 D3D12 实现，继承自 `RHIDescriptorPool`。
**继承自**: [`RHIDescriptorPool`](../../descriptor-pool/descriptor-pool.md)
**描述**: DirectX 12 描述符堆的 D3D12 实现，继承自 `RHIDescriptorPool`。描述符堆是 D3D12 中用于存储描述符（CBV/SRV/UAV/Sampler）的内存块，支持 CPU 可访问和 GPU 可访问两种模式。
**概述**:
`D3D12DescriptorHeap` 封装了 D3D12 的描述符堆资源，提供描述符的分配、句柄计算和资源管理功能。描述符堆类型包括：
- `CBV_SRV_UAV` - 常量缓冲区、Shader资源和无序访问视图
- `SAMPLER` - 采样器
描述符堆可以标记为 `shaderVisible`，使其可被 GPU shader 访问。仅当需要绑定到命令列表时才应使用 shader visible 堆。
## 公共方法
| 方法 | 描述 |
|------|------|
| [`D3D12DescriptorHeap`](constructor.md) | 构造函数 |
| [`Initialize`](initialize-from-desc.md) | 从描述符初始化 |
| [`Shutdown`](../../../threading/task-system/shutdown.md) | 关闭描述符堆 |
| [`Initialize(ID3D12Device*,...)`](initialize-device.md) | 直接初始化 |
| [`Shutdown`](shutdown.md) | 关闭描述符堆 |
| [`GetDescriptorHeap`](get-descriptor-heap.md) | 获取 D3D12 描述符堆 |
| [`GetCPUDescriptorHandle`](get-cpu-descriptor-handle.md) | 获取 CPU 描述符句柄 |
| [`GetGPUDescriptorHandle`](get-gpu-descriptor-handle.md) | 获取 GPU 描述符句柄 |
| [`GetDescriptorCount`](get-descriptor-count.md) | 获取描述符数量 |
| [`GetType`](../../command-queue/get-type.md) | 获取描述符类型 |
| [`GetType`](get-type.md) | 获取描述符类型 |
| [`GetDescriptorSize`](get-descriptor-size.md) | 获取描述符大小 |
| [`GetCPUDescriptorHandleForHeapStart`](get-cpu-descriptor-handle-for-heap-start.md) | 获取堆起始 CPU 句柄 |
| [`GetGPUDescriptorHandleForHeapStart`](get-gpu-descriptor-handle-for-heap-start.md) | 获取堆起始 GPU 句柄 |
| [`GetNativeHandle`](../../buffer/get-native-handle.md) | 获取原生句柄 |
| [`GetNativeHandle`](get-native-handle.md) | 获取原生句柄 |
| [`CreateDesc`](create-desc.md) | 创建描述符（静态） |
## 使用示例
```cpp
#include "XCEngine/RHI/D3D12/D3D12DescriptorHeap.h"
using namespace XCEngine::RHI;
// 创建设备
ID3D12Device* device = ...;
// 创建 CBV/SRV/UAV 描述符堆
D3D12DescriptorHeap heap;
heap.Initialize(device, DescriptorHeapType::CBV_SRV_UAV, 256, true);
// 获取描述符句柄
CPUDescriptorHandle cpuHandle = heap.GetCPUDescriptorHandle(0);
GPUDescriptorHandle gpuHandle = heap.GetGPUDescriptorHandle(0);
// 关闭
heap.Shutdown();
```
## 相关文档
- [D3D12 后端总览](../../opengl/overview.md)
- [D3D12 后端总览](../d3d12.md)
- [RHIDescriptorPool](../../descriptor-pool/descriptor-pool.md) - 抽象描述符池接口
- [D3D12Enum](d3d12-enum.md) - D3D12 类型枚举映射

6
docs/api/rhi/d3d12/descriptor-heap/get-cpu-descriptor-handle-for-heap-start.md
View File

@@ -4,12 +4,14 @@
D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandleForHeapStart() const;
```
获取堆起始处的 CPU 描述符句柄。
获取描述符堆起始位置的 CPU 描述符句柄。此句柄指向堆中第一个描述符，可作为遍历和偏移计算的基准。
**返回：** CPU 描述符句柄
**返回：** `D3D12_CPU_DESCRIPTOR_HANDLE` 结构体，包含堆起始 CPU 指针
**复杂度：** O(1)
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [GetCPUDescriptorHandle](get-cpu-descriptor-handle.md) - 获取指定索引的 CPU 句柄
- [GetGPUDescriptorHandleForHeapStart](get-gpu-descriptor-handle-for-heap-start.md) - GPU 版本

6
docs/api/rhi/d3d12/descriptor-heap/get-gpu-descriptor-handle-for-heap-start.md
View File

@@ -4,12 +4,14 @@
D3D12_GPU_DESCRIPTOR_HANDLE GetGPUDescriptorHandleForHeapStart() const;
```
获取堆起始处的 GPU 描述符句柄。
获取描述符堆起始位置的 GPU 描述符句柄。此句柄指向堆中第一个描述符，可作为遍历和偏移计算的基准。仅当堆创建时 `shaderVisible` 为 `true` 时返回的句柄才有效。
**返回：** GPU 描述符句柄
**返回：** `D3D12_GPU_DESCRIPTOR_HANDLE` 结构体，包含堆起始 GPU 指针
**复杂度：** O(1)
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [GetGPUDescriptorHandle](get-gpu-descriptor-handle.md) - 获取指定索引的 GPU 句柄
- [GetCPUDescriptorHandleForHeapStart](get-cpu-descriptor-handle-for-heap-start.md) - CPU 版本

17
docs/api/rhi/d3d12/descriptor-heap/get-native-handle.md Normal file
View File

@@ -0,0 +1,17 @@
# D3D12DescriptorHeap::GetNativeHandle
```cpp
void* GetNativeHandle() override;
```
获取底层 D3D12 描述符堆原生句柄。返回 `ID3D12DescriptorHeap*` 的 `void*` 形式，用于泛型接口获取原生资源。
**返回：** `void*` 指向 `ID3D12DescriptorHeap` 的指针
**复杂度：** O(1)
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [RHIDescriptorPool::GetNativeHandle](../../descriptor-pool/get-native-handle.md) - 基类方法
- [GetDescriptorHeap](get-descriptor-heap.md) - 类型安全的获取方法

16
docs/api/rhi/d3d12/descriptor-heap/get-type.md Normal file
View File

@@ -0,0 +1,16 @@
# D3D12DescriptorHeap::GetType
```cpp
DescriptorHeapType GetType() const override;
```
获取描述符堆类型。
**返回：** 描述符堆类型枚举值
**复杂度：** O(1)
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [RHIDescriptorPool::GetType](../../descriptor-pool/get-type.md) - 基类方法

40
docs/api/rhi/d3d12/descriptor-heap/initialize-device.md Normal file
View File

@@ -0,0 +1,40 @@
# D3D12DescriptorHeap::Initialize
```cpp
bool Initialize(ID3D12Device* device, DescriptorHeapType type, uint32_t numDescriptors, bool shaderVisible = false);
```
直接使用 D3D12 设备创描述符堆。这是主要初始化方法，会创建底层的 `ID3D12DescriptorHeap` COM 对象。
**参数：**
- `device` - D3D12 设备指针，不得为 `nullptr`
- `type` - 描述符堆类型，决定堆中存储的描述符种类
- `numDescriptors` - 描述符数量，必须大于 0
- `shaderVisible` - 是否创建为 shader visible 模式。shader visible 的堆可绑定到命令列表供 shader 访问，但会增加 GPU 访问开销
**返回：** 是否初始化成功。失败时返回 `false`，可能原因包括：
- 设备指针无效
- 描述符数量为 0
- D3D12 API 创建堆失败
**复杂度：** O(1)
## 示例
```cpp
ID3D12Device* device = ...;
// 创建不可见的 CPU 描述符堆
D3D12DescriptorHeap cpuHeap;
cpuHeap.Initialize(device, DescriptorHeapType::CBV_SRV_UAV, 64, false);
// 创建 GPU 可见的描述符堆
D3D12DescriptorHeap gpuHeap;
gpuHeap.Initialize(device, DescriptorHeapType::CBV_SRV_UAV, 256, true);
```
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [Initialize(const DescriptorPoolDesc&)](initialize-from-desc.md) - 描述符重载
- [CreateDesc](create-desc.md) - 创建描述符结构体

24
docs/api/rhi/d3d12/descriptor-heap/initialize-from-desc.md
View File

@@ -4,15 +4,31 @@
bool Initialize(const DescriptorPoolDesc& desc) override;
```
从描述符初始化。
从描述符池描述结构体初始化描述符堆。该方法是 `RHIDescriptorPool` 基类接口的实现，内部调用 `Initialize(ID3D12Device*, ...)` 重载。
**参数：**
- `desc` - 描述符池描述
- `desc` - 描述符池描述，包含设备指针、堆类型、描述符数量和 shader visible 标志
**返回：** 是否初始化成功
**返回：** 是否初始化成功。失败时返回 `false`，可能由于 D3D12 API 调用失败导致。
**复杂度：** O(n)
**复杂度：** O(1)
## 示例
```cpp
DescriptorPoolDesc desc = {};
desc.device = device;
desc.type = DescriptorHeapType::CBV_SRV_UAV;
desc.descriptorCount = 256;
desc.shaderVisible = true;
D3D12DescriptorHeap heap;
if (!heap.Initialize(desc)) {
// 处理初始化失败
}
```
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [Initialize(ID3D12Device*,...)](initialize-device.md) - 直接初始化重载

14
docs/api/rhi/d3d12/descriptor-heap/shutdown.md Normal file
View File

@@ -0,0 +1,14 @@
# D3D12DescriptorHeap::Shutdown
```cpp
void Shutdown() override;
```
关闭描述符堆，释放底层 D3D12 描述符堆资源。
**复杂度：** O(1)
## 相关文档
- [D3D12DescriptorHeap 总览](descriptor-heap.md) - 返回类总览
- [RHIDescriptorPool::Shutdown](../../descriptor-pool/shutdown.md) - 基类方法

31
docs/api/rhi/d3d12/device/compile-shader.md Normal file
View File

@@ -0,0 +1,31 @@
# D3D12Device::CompileShader
```cpp
RHIShader* CompileShader(const ShaderCompileDesc& desc) override;
```
编译 D3D12 着色器。
**参数：**
- `desc` - 着色器编译描述符，包含文件名、入口点、Profile 等
**返回：** 新创建的着色器指针，失败返回 `nullptr`
**复杂度：** 取决于着色器复杂度
**示例：**
```cpp
ShaderCompileDesc shaderDesc;
shaderDesc.fileName = L"shaders/vertex.hlsl";
shaderDesc.entryPoint = "VSMain";
shaderDesc.profile = "vs_5_0";
RHIShader* shader = device->CompileShader(shaderDesc);
```
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CompileShader](../../device/compile-shader.md) - 基类方法
- [D3D12Shader](../../shader/shader.md) - D3D12 着色器实现

32
docs/api/rhi/d3d12/device/create-buffer.md Normal file
View File

@@ -0,0 +1,32 @@
# D3D12Device::CreateBuffer
```cpp
RHIBuffer* CreateBuffer(const BufferDesc& desc) override;
```
创建 D3D12 缓冲区资源。
**参数：**
- `desc` - 缓冲区描述符，包含大小、类型、标志等
**返回：** 新创建的缓冲区指针，失败返回 `nullptr`
**复杂度：** O(1)
**示例：**
```cpp
BufferDesc bufferDesc;
bufferDesc.size = sizeof(Vertex) * vertexCount;
bufferDesc.stride = sizeof(Vertex);
bufferDesc.bufferType = (uint32_t)BufferType::Vertex;
bufferDesc.flags = 0;
RHIBuffer* vertexBuffer = device->CreateBuffer(bufferDesc);
```
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreateBuffer](../../device/create-buffer.md) - 基类方法
- [D3D12Buffer](../../buffer/buffer.md) - D3D12 缓冲区实现

19
docs/api/rhi/d3d12/device/create-command-list.md Normal file
View File

@@ -0,0 +1,19 @@
# D3D12Device::CreateCommandList
```cpp
RHICommandList* CreateCommandList(const CommandListDesc& desc) override;
```
创建 D3D12 命令列表。
**参数：**
- `desc` - 命令列表描述符
**返回：** 新创建的命令列表指针
**注意：** 当前实现返回 `nullptr`
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreateCommandList](../../device/create-command-list.md) - 基类方法

19
docs/api/rhi/d3d12/device/create-command-queue.md Normal file
View File

@@ -0,0 +1,19 @@
# D3D12Device::CreateCommandQueue
```cpp
RHICommandQueue* CreateCommandQueue(const CommandQueueDesc& desc) override;
```
创建 D3D12 命令队列。
**参数：**
- `desc` - 命令队列描述符
**返回：** 新创建的命令队列指针
**注意：** 当前实现返回 `nullptr`
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreateCommandQueue](../../device/create-command-queue.md) - 基类方法

27
docs/api/rhi/d3d12/device/create-fence.md Normal file
View File

@@ -0,0 +1,27 @@
# D3D12Device::CreateFence
```cpp
RHIFence* CreateFence(const FenceDesc& desc) override;
```
创建 D3D12 栅栏。
**参数：**
- `desc` - 栅栏描述符，包含初始值等
**返回：** 新创建的栅栏指针，失败返回 `nullptr`
**示例：**
```cpp
FenceDesc fenceDesc;
fenceDesc.initialValue = 0;
RHIFence* fence = device->CreateFence(fenceDesc);
```
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreateFence](../../device/create-fence.md) - 基类方法
- [D3D12Fence](../../fence/fence.md) - D3D12 栅栏实现

19
docs/api/rhi/d3d12/device/create-pipeline-state.md Normal file
View File

@@ -0,0 +1,19 @@
# D3D12Device::CreatePipelineState
```cpp
RHIPipelineState* CreatePipelineState(const PipelineStateDesc& desc) override;
```
创建 D3D12 管线状态对象。
**参数：**
- `desc` - 管线状态描述符
**返回：** 新创建的管线状态指针
**注意：** 当前实现返回 `nullptr`
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreatePipelineState](../../device/create-pipeline-state.md) - 基类方法

30
docs/api/rhi/d3d12/device/create-sampler.md Normal file
View File

@@ -0,0 +1,30 @@
# D3D12Device::CreateSampler
```cpp
RHISampler* CreateSampler(const SamplerDesc& desc) override;
```
创建 D3D12 采样器。
**参数：**
- `desc` - 采样器描述符，包含过滤模式、地址模式等
**返回：** 新创建的采样器指针，失败返回 `nullptr`
**示例：**
```cpp
SamplerDesc samplerDesc;
samplerDesc.filter = (uint32_t)D3D12_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.addressU = (uint32_t)D3D12_TEXTURE_ADDRESS_MODE_WRAP;
samplerDesc.addressV = (uint32_t)D3D12_TEXTURE_ADDRESS_MODE_WRAP;
samplerDesc.addressW = (uint32_t)D3D12_TEXTURE_ADDRESS_MODE_WRAP;
RHISampler* sampler = device->CreateSampler(samplerDesc);
```
## 相关文档
- [D3D12Device 总览](device.md) - 返回类总览
- [RHIDevice::CreateSampler](../../device/create-sampler.md) - 基类方法
- [D3D12Sampler](../../sampler/sampler.md) - D3D12 采样器实现

Some files were not shown because too many files have changed in this diff Show More