# 第二阶段计划：RHI 渲染硬件抽象层

> **目标**：构建跨平台的渲染硬件抽象层，支持多后端（D3D12、Vulkan等）
> **阶段**：第二阶段
> **前置依赖**：第一阶段核心基础层（数学库、内存管理、线程系统）

---

## 2.1 阶段目标

实现完整的RHI抽象层，提供：
- 统一的图形API抽象接口
- D3D12后端完整实现
- 资源管理（纹理、缓冲区）
- 命令流提交机制
- 同步与同步原语

---

## 2.2 目录结构

```
engine/include/XCEngine/RHI/              # 渲染硬件抽象层（公开API）
├── Enums.h                               # 枚举定义（独立编号，跨平台）
├── Types.h                               # 通用类型定义
├── RHISystem.h                           # RHI 系统入口
├── RHIDevice.h                           # 抽象设备接口
├── Resource.h                             # 资源基类接口
├── ResourceView.h                        # 资源视图基类接口
├── RenderTargetView.h                    # 渲染目标视图接口
├── DepthStencilView.h                    # 深度模板视图接口
├── ShaderResourceView.h                  # 着色器资源视图接口
├── UnorderedAccessView.h                # 无序访问视图接口
├── ConstantBufferView.h                  # 常量缓冲区视图接口
├── CommandQueue.h                        # 命令队列
├── CommandList.h                         # 命令列表
├── CommandAllocator.h                    # 命令分配器
├── Fence.h                              # 同步围栏
├── DescriptorHeap.h                      # 描述符堆
├── QueryHeap.h                           # 查询堆
├── RootSignature.h                       # 根签名
├── PipelineState.h                      # 管线状态
├── Sampler.h                            # 采样器
├── SwapChain.h                          # 交换链
├── Texture.h                            # 纹理资源
├── Buffer.h                             # 缓冲区资源
├── Shader.h                             # 着色器
└── D3D12/                              # D3D12 后端实现
    ├── D3D12Enum.h                     # 枚举转换层（RHI→D3D12）
    ├── D3D12Device.h
    ├── D3D12Device.cpp
    ├── D3D12CommandList.h
    ├── D3D12CommandList.cpp
    ├── D3D12CommandQueue.h
    ├── D3D12CommandQueue.cpp
    ├── D3D12CommandAllocator.h
    ├── D3D12CommandAllocator.cpp
    ├── D3D12Fence.h
    ├── D3D12Fence.cpp
    ├── D3D12DescriptorHeap.h
    ├── D3D12DescriptorHeap.cpp
    ├── D3D12QueryHeap.h
    ├── D3D12QueryHeap.cpp
    ├── D3D12RootSignature.h
    ├── D3D12RootSignature.cpp
    ├── D3D12PipelineState.h
    ├── D3D12PipelineState.cpp
    ├── D3D12Sampler.h
    ├── D3D12Sampler.cpp
    ├── D3D12SwapChain.h
    ├── D3D12SwapChain.cpp
    ├── D3D12Texture.h
    ├── D3D12Texture.cpp
    ├── D3D12Buffer.h
    ├── D3D12Buffer.cpp
    ├── D3D12Shader.h
    ├── D3D12Shader.cpp
    ├── D3D12RenderTargetView.h
    ├── D3D12RenderTargetView.cpp
    ├── D3D12DepthStencilView.h
    ├── D3D12DepthStencilView.cpp
    ├── D3D12ShaderResourceView.h
    ├── D3D12ShaderResourceView.cpp
    ├── D3D12UnorderedAccessView.h
    ├── D3D12UnorderedAccessView.cpp
    ├── D3D12ConstantBufferView.h
    ├── D3D12ConstantBufferView.cpp
    └── D3D12Common.h                   # 公共定义
```

---

## 2.3 任务拆分

### 2.3.1 基础枚举与类型定义

**任务 2.1：Enums.h - 枚举定义**

定义所有渲染相关的枚举类型：
- `Format` - 像素格式
- `ResourceStates` - 资源状态
- `ShaderType` - 着色器类型
- `PrimitiveTopology` - 图元拓扑
- `CullMode` / `FillMode` - 剔除/填充模式
- `BlendOp` / `BlendFactor` - 混合操作/因子
- `ComparisonFunc` - 比较函数
- `StencilOp` - 模板操作
- `TextureType` - 纹理类型
- `BufferType` - 缓冲区类型
- `QueryType` - 查询类型
- `DescriptorType` - 描述符类型
- `PipelineType` - 管线类型
- `CommandQueueType` - 命令队列类型
- `LoadAction` / `StoreAction` - 渲染目标加载/存储操作
- `PresentFlags` - 呈现标志
- `IndirectDrawArguments` - 间接绘制参数
- `IndirectDispatchArguments` - 间接调度参数

**任务 2.1.2：类型定义 - Types.h**

定义通用结构体（不依赖特定图形API）：
- `Viewport` - 视口
- `Rect` - 矩形区域
- `Color` - 颜色
- `ClearValue` - 清空值
- `ShaderCompileDesc` - 着色器编译描述
- `ShaderCompileResult` - 着色器编译结果
- `ShaderCompileMacro` - 着色器宏定义
- `InputElementDesc` - 输入元素描述
- `InputLayoutDesc` - 输入布局描述
- `VertexBufferBinding` - 顶点缓冲区绑定
- `TextureCopyLocation` - 纹理复制位置
- `DescriptorHandle` - 描述符句柄（通用类型）
- `GPUDescriptorHandle` - GPU描述符句柄
- `CPUDescriptorHandle` - CPU描述符句柄
- `ResourceBarrierDesc` - 资源屏障描述
- `SubresourceRange` - 子资源范围
- `TextureDesc` - 纹理描述
- `BufferDesc` - 缓冲区描述
- `RenderTargetDesc` - 渲染目标描述
- `DepthStencilDesc` - 深度模板描述
- `DescriptorHeapDesc` - 描述符堆描述
- `CommandQueueDesc` - 命令队列描述
- `CommandListDesc` - 命令列表描述
- `CommandAllocatorDesc` - 命令分配器描述
- `FenceDesc` - 围栏描述
- `QueryHeapDesc` - 查询堆描述
- `RootSignatureDesc` - 根签名描述
- `SamplerDesc` - 采样器描述
- `PipelineStateDesc` - 管线状态描述
- `SwapChainDesc` - 交换链描述
- `BlendStateDesc` - 混合状态描述
- `DepthStencilStateDesc` - 深度模板状态描述
- `RasterizerStateDesc` - 光栅化状态描述
- `ShaderBytecode` - 着色器字节码
- `ShaderBindingInfo` - 着色器绑定信息
- `RenderTargetViewDesc` - 渲染目标视图描述
- `DepthStencilViewDesc` - 深度模板视图描述
- `ShaderResourceViewDesc` - 着色器资源视图描述
- `UnorderedAccessViewDesc` - 无序访问视图描述
- `ConstantBufferViewDesc` - 常量缓冲区视图描述
- `FormatSupport` - 格式支持信息

### 2.3.2 核心接口定义

**任务 2.2：RHISystem.h - RHI系统入口**

```cpp
struct RHISystemConfig {
    void* nativeWindowHandle = nullptr;  // HWND on Windows
    uint32_t width = 1280;
    uint32_t height = 720;
    bool fullscreen = false;
    uint32_t backBufferCount = 2;
    bool enableDebugLayer = false;
    bool enableGBV = false;
};

class RHISystem {
public:
    static RHISystem& Get();
    
    bool Initialize(const RHISystemConfig& config);
    void Shutdown();
    
    IRHIDevice* GetDevice();
    ISwapChain* GetSwapChain();
    
    void BeginFrame();
    void EndFrame();
    
    // 窗口管理
    void Resize(uint32_t width, uint32_t height);
    void SetFullscreen(bool fullscreen);
    bool IsFullscreen() const;
    
private:
    std::unique_ptr<IRHIDevice> m_device;
    std::unique_ptr<ISwapChain> m_swapChain;
};
```

**任务 2.3：RHIDevice.h - 抽象设备接口**

```cpp
struct DeviceInfo {
    String deviceName;
    String driverVersion;
    uint64_t dedicatedVideoMemory;
    uint64_t dedicatedSystemMemory;
    uint64_t sharedSystemMemory;
    uint32_t vendorId;
    uint32_t deviceId;
    bool supportsRaytracing;
    bool supportsMeshShaders;
    bool supportsSamplerFeedback;
};

class IRHIDevice {
public:
    virtual ~IRHIDevice() = default;
    
    // 资源创建
    virtual ICommandQueue* CreateCommandQueue(const CommandQueueDesc& desc) = 0;
    virtual ICommandList* CreateCommandList(const CommandListDesc& desc) = 0;
    virtual ICommandAllocator* CreateCommandAllocator(const CommandAllocatorDesc& desc) = 0;
    virtual IFence* CreateFence(const FenceDesc& desc) = 0;
    virtual IDescriptorHeap* CreateDescriptorHeap(const DescriptorHeapDesc& desc) = 0;
    virtual IQueryHeap* CreateQueryHeap(const QueryHeapDesc& desc) = 0;
    virtual IRootSignature* CreateRootSignature(const RootSignatureDesc& desc) = 0;
    virtual IPipelineState* CreatePipelineState(const PipelineStateDesc& desc) = 0;
    virtual ISampler* CreateSampler(const SamplerDesc& desc) = 0;
    virtual ITexture* CreateTexture(const TextureDesc& desc) = 0;
    virtual IBuffer* CreateBuffer(const BufferDesc& desc) = 0;
    virtual ISwapChain* CreateSwapChain(const SwapChainDesc& desc) = 0;
    
    // 视图创建
    virtual IRenderTargetView* CreateRenderTargetView(IResource* resource, const RenderTargetViewDesc& desc) = 0;
    virtual IDepthStencilView* CreateDepthStencilView(IResource* resource, const DepthStencilViewDesc& desc) = 0;
    virtual IShaderResourceView* CreateShaderResourceView(IResource* resource, const ShaderResourceViewDesc& desc) = 0;
    virtual IUnorderedAccessView* CreateUnorderedAccessView(IResource* resource, const UnorderedAccessViewDesc& desc) = 0;
    virtual IConstantBufferView* CreateConstantBufferView(IResource* resource, const ConstantBufferViewDesc& desc) = 0;
    
    // 着色器编译
    virtual IShader* CompileShader(const ShaderCompileDesc& desc) = 0;
    
    // 查询
    virtual void GetDeviceInfo(DeviceInfo& info) const = 0;
    virtual FormatSupport GetFormatSupport(Format format) const = 0;
};
```

**任务 2.4：CommandQueue.h - 命令队列接口**

```cpp
class ICommandQueue {
public:
    virtual ~ICommandQueue() = default;
    
    virtual void ExecuteCommandLists(uint32_t count, ICommandList** lists) = 0;
    virtual void Signal(IFence* fence, uint64_t value) = 0;
    virtual void Wait(IFence* fence, uint64_t value) = 0;
    virtual uint64_t GetCompletedValue() = 0;
    virtual void WaitForIdle() = 0;
    
    virtual CommandQueueType GetType() const = 0;
    virtual uint64_t GetTimestampFrequency() const = 0;
};
```

**任务 2.5：CommandList.h - 命令列表接口**

```cpp
class ICommandList {
public:
    virtual ~ICommandList() = default;
    
    // 状态转换
    virtual void TransitionBarrier(uint32_t count, const ResourceBarrierDesc* barriers) = 0;
    virtual void UAVBarrier(IResource* resource = nullptr) = 0;
    virtual void AliasBarrier(IResource* before, IResource* after) = 0;
    
    // 渲染状态
    virtual void SetPipelineState(IPipelineState* pso) = 0;
    virtual void SetRootSignature(IRootSignature* signature) = 0;
    virtual void SetViewport(const Viewport& viewport) = 0;
    virtual void SetViewports(uint32_t count, const Viewport* viewports) = 0;
    virtual void SetScissorRect(const Rect& rect) = 0;
    virtual void SetScissorRects(uint32_t count, const Rect* rects) = 0;
    virtual void SetPrimitiveTopology(PrimitiveTopology topology) = 0;
    virtual void SetRenderTargets(uint32_t count, IResource** renderTargets, IResource* depthStencil) = 0;
    
    // 绑定
    virtual void SetVertexBuffer(uint32_t slot, IBuffer* buffer, uint32_t offset, uint32_t stride) = 0;
    virtual void SetVertexBuffers(uint32_t startSlot, uint32_t count, const VertexBufferBinding* bindings) = 0;
    virtual void SetIndexBuffer(IBuffer* buffer, uint32_t offset, Format indexFormat) = 0;
    virtual void SetConstantBuffer(uint32_t rootParameterIndex, IBuffer* buffer, uint32_t offset, uint32_t size) = 0;
    virtual void SetShaderResource(uint32_t rootParameterIndex, IResource* resource) = 0;
    virtual void SetUnorderedAccess(uint32_t rootParameterIndex, IResource* resource) = 0;
    virtual void SetDescriptorHeap(IDescriptorHeap* heap) = 0;
    virtual void SetGraphicsDescriptorTable(uint32_t rootParameterIndex, GPUDescriptorHandle baseHandle) = 0;
    virtual void SetComputeDescriptorTable(uint32_t rootParameterIndex, GPUDescriptorHandle baseHandle) = 0;
    
    // 渲染状态设置
    virtual void SetStencilRef(uint8_t stencilRef) = 0;
    virtual void SetBlendFactor(const float blendFactor[4]) = 0;
    virtual void SetDepthBias(float depthBias, float slopeScaledDepthBias, float depthBiasClamp) = 0;
    
    // 绘制
    virtual void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t startVertex, uint32_t startInstance) = 0;
    virtual void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t startIndex, int32_t baseVertex, uint32_t startInstance) = 0;
    virtual void DrawInstancedIndirect(IBuffer* argBuffer, uint32_t alignedByteOffset) = 0;
    virtual void DrawIndexedInstancedIndirect(IBuffer* argBuffer, uint32_t alignedByteOffset) = 0;
    
    // 清空
    virtual void ClearRenderTargetView(IResource* renderTarget, const float color[4]) = 0;
    virtual void ClearDepthStencilView(IResource* depthStencil, uint32_t clearFlags, float depth, uint8_t stencil) = 0;
    virtual void ClearUnorderedAccessView(IResource* unorderedAccess, const float values[4]) = 0;
    
    // 复制
    virtual void CopyResource(IResource* dst, IResource* src) = 0;
    virtual void CopyBuffer(IBuffer* dst, uint64_t dstOffset, IBuffer* src, uint64_t srcOffset, uint64_t size) = 0;
    virtual void CopyTexture(ITexture* dst, const TextureCopyLocation& dstLocation, ITexture* src, const TextureCopyLocation& srcLocation) = 0;
    
    // 查询
    virtual void BeginQuery(IQueryHeap* queryHeap, QueryType type, uint32_t index) = 0;
    virtual void EndQuery(IQueryHeap* queryHeap, QueryType type, uint32_t index) = 0;
    virtual void ResolveQuery(IQueryHeap* queryHeap, QueryType type, uint32_t startIndex, uint32_t count, IBuffer* resultBuffer, uint64_t resultOffset) = 0;
    
    // 提交
    virtual void Close() = 0;
    virtual void Reset(ICommandAllocator* allocator) = 0;
    
    // 计算着色器
    virtual void Dispatch(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ) = 0;
    virtual void DispatchIndirect(IBuffer* argBuffer, uint32_t alignedByteOffset) = 0;
    
    // Bundle (用于命令复用)
    virtual void ExecuteBundle(ICommandList* bundle) = 0;
};
```

**任务 2.6：其他核心接口**

- `Resource.h` - 资源基类接口（所有资源的共同基类）
- `ResourceView.h` - 资源视图基类接口
- `RenderTargetView.h` - 渲染目标视图接口
- `DepthStencilView.h` - 深度模板视图接口
- `ShaderResourceView.h` - 着色器资源视图接口
- `UnorderedAccessView.h` - 无序访问视图接口
- `ConstantBufferView.h` - 常量缓冲区视图接口
- `CommandAllocator.h` - 命令分配器接口
```cpp
class ICommandAllocator {
public:
    virtual ~ICommandAllocator() = default;
    virtual void Reset() = 0;
    virtual bool IsReady() const = 0;
};
```
- `Fence.h` - 同步围栏接口
```cpp
class IFence {
public:
    virtual ~IFence() = default;
    virtual void Signal(uint64_t value) = 0;
    virtual void Wait(uint64_t value) = 0;
    virtual uint64_t GetCompletedValue() = 0;
    virtual void* GetEventHandle() = 0;
};
```
- `DescriptorHeap.h` - 描述符堆接口
```cpp
class IDescriptorHeap {
public:
    virtual ~IDescriptorHeap() = default;
    virtual CPUDescriptorHandle GetCPUDescriptorHandle(uint32_t index) = 0;
    virtual GPUDescriptorHandle GetGPUDescriptorHandle(uint32_t index) = 0;
    virtual uint32_t GetDescriptorCount() const = 0;
    virtual DescriptorType GetType() const = 0;
};
```
- `QueryHeap.h` - 查询堆接口
```cpp
class IQueryHeap {
public:
    virtual ~IQueryHeap() = default;
    virtual void* GetNativeHandle() const = 0;
    virtual QueryType GetType() const = 0;
    virtual uint32_t GetCount() const = 0;
};
```
- `RootSignature.h` - 根签名接口
```cpp
class IRootSignature {
public:
    virtual ~IRootSignature() = default;
    virtual void* GetNativeHandle() const = 0;
    virtual uint32_t GetParameterCount() const = 0;
};
```
- `PipelineState.h` - 管线状态接口
```cpp
class IPipelineState {
public:
    virtual ~IPipelineState() = default;
    virtual void* GetNativeHandle() const = 0;
    virtual PipelineType GetType() const = 0;
};
```
- `Sampler.h` - 采样器接口
```cpp
class ISampler {
public:
    virtual ~ISampler() = default;
    virtual void* GetNativeHandle() const = 0;
};
```
- `SwapChain.h` - 交换链接口
```cpp
class ISwapChain {
public:
    virtual ~ISwapChain() = default;
    
    virtual uint32_t GetCurrentBackBufferIndex() = 0;
    virtual IResource* GetBackBuffer(uint32_t index) = 0;
    virtual void Present(uint32_t syncInterval, PresentFlags flags) = 0;
    virtual void Resize(uint32_t width, uint32_t height) = 0;
    virtual void SetFullscreen(bool fullscreen) = 0;
    virtual bool IsFullscreen() const = 0;
    
    virtual void* GetNativeHandle() const = 0;
};
```
- `Texture.h` - 纹理资源接口
```cpp
class ITexture : public IResource {
public:
    virtual uint32_t GetWidth() const = 0;
    virtual uint32_t GetHeight() const = 0;
    virtual uint32_t GetDepth() const = 0;
    virtual uint32_t GetMipLevels() const = 0;
    virtual uint32_t GetArraySize() const = 0;
    virtual Format GetFormat() const = 0;
    virtual TextureType GetTextureType() const = 0;
    
    virtual IShaderResourceView* GetOrCreateSRV() = 0;
    virtual IRenderTargetView* GetOrCreateRTV(uint32_t mipSlice = 0, uint32_t arraySlice = 0) = 0;
    virtual IDepthStencilView* GetOrCreateDSV(uint32_t mipSlice = 0, uint32_t arraySlice = 0) = 0;
    virtual IUnorderedAccessView* GetOrCreateUAV(uint32_t mipSlice = 0, uint32_t arraySlice = 0) = 0;
};
```
- `Buffer.h` - 缓冲区资源接口
```cpp
class IBuffer : public IResource {
public:
    virtual uint64_t GetSize() const = 0;
    virtual uint32_t GetStride() const = 0;
    virtual BufferType GetBufferType() const = 0;
    
    virtual IConstantBufferView* GetOrCreateCBV() = 0;
    virtual IShaderResourceView* GetOrCreateSRV() = 0;
    virtual IUnorderedAccessView* GetOrCreateUAV() = 0;
};
```
- `Shader.h` - 着色器接口
```cpp
class IShader {
public:
    virtual ~IShader() = default;
    
    virtual const void* GetBytecode() const = 0;
    virtual size_t GetBytecodeSize() const = 0;
    virtual ShaderType GetType() const = 0;
    
    virtual const InputLayoutDesc& GetInputLayout() const = 0;
    virtual const ShaderBindingInfo& GetBindingInfo() const = 0;
};
```
- `RenderTarget.h` - 渲染目标接口
```cpp
class IRenderTarget {
public:
    virtual ~IRenderTarget() = default;
    
    virtual ITexture* GetTexture() = 0;
    virtual IRenderTargetView* GetRTV() = 0;
    virtual uint32_t GetWidth() const = 0;
    virtual uint32_t GetHeight() const = 0;
    virtual Format GetFormat() const = 0;
};
```
- `DepthStencil.h` - 深度模板接口
```cpp
class IDepthStencil {
public:
    virtual ~IDepthStencil() = default;
    
    virtual ITexture* GetTexture() = 0;
    virtual IDepthStencilView* GetDSV() = 0;
    virtual IShaderResourceView* GetSRV() = 0;
    virtual uint32_t GetWidth() const = 0;
    virtual uint32_t GetHeight() const = 0;
    virtual Format GetFormat() const = 0;
};
```

**任务 2.7：Resource.h - 资源基类接口**

```cpp
class IResource {
public:
    virtual ~IResource() = default;
    
    virtual void* GetNativeHandle() const = 0;
    virtual ResourceStates GetState() const = 0;
    virtual void SetState(ResourceStates state) = 0;
    
    virtual uint64_t GetGPUAddress() const = 0;
    virtual size_t GetSize() const = 0;
    
    virtual const String& GetName() const = 0;
    virtual void SetName(const String& name) = 0;
};
```

**任务 2.8：ResourceView.h - 资源视图基类接口**

```cpp
class IResourceView {
public:
    virtual ~IResourceView() = default;
    virtual void* GetNativeHandle() const = 0;
    virtual IResource* GetResource() const = 0;
};
```

---

### 2.3.3 D3D12 后端实现

**任务 2.9：D3D12Common.h - 公共定义**

D3D12相关的公共定义和辅助函数：
- 格式转换映射
- 描述符大小计算
- 资源状态转换
- 辅助工具函数

**任务 2.10：D3D12Device - 设备实现**

实现 `D3D12Device` 类：
- ID3D12Device 封装
- IDXGIFactory 创建与管理
- 所有资源创建接口实现
- 适配器信息查询
- 功能级别支持检测
- 内存信息查询
- 设备移除与恢复处理

**任务 2.11：D3D12CommandQueue - 命令队列实现**

实现 `D3D12CommandQueue` 类：
- ID3D12CommandQueue 封装
- 命令列表执行
- 围栏同步
- 时间戳频率查询

**任务 2.12：D3D12CommandList - 命令列表实现**

实现 `D3D12CommandList` 类：
- ID3D12GraphicsCommandList 封装
- 所有渲染命令实现
- 状态追踪与验证
- 资源追踪

**任务 2.13：D3D12CommandAllocator - 命令分配器实现**

实现 `D3D12CommandAllocator` 类：
- ID3D12CommandAllocator 封装
- 重置管理

**任务 2.14：D3D12Fence - 围栏实现**

实现 `D3D12Fence` 类：
- ID3D12Fence 封装
- CPU/GPU同步
- 事件句柄管理

**任务 2.15：D3D12DescriptorHeap - 描述符堆实现**

实现 `D3D12DescriptorHeap` 类：
- ID3D12DescriptorHeap 封装
- CPU/GPU描述符句柄管理
- 描述符分配/释放
- 堆增量大小计算

**任务 2.16：D3D12RootSignature - 根签名实现**

实现 `D3D12RootSignature` 类：
- ID3D12RootSignature 封装
- 根参数配置
- 描述符表布局
- 静态采样器

**任务 2.17：D3D12PipelineState - 管线状态实现**

实现 `D3D12PipelineState` 类：
- ID3D12PipelineState 封装
- 图形管线描述构建
- 计算管线描述构建
- 混合状态
- 深度模板状态
- 输入布局
- 顶点/像素着色器绑定

**任务 2.18：D3D12Sampler - 采样器实现**

实现 `D3D12Sampler` 类：
- D3D12_SAMPLER_DESC 封装
- 静态采样器支持

**任务 2.19：D3D12QueryHeap - 查询堆实现**

实现 `D3D12QueryHeap` 类：
- ID3D12QueryHeap 封装
- 时间戳查询
- 遮挡查询
- 流水线统计

**任务 2.20：D3D12SwapChain - 交换链实现**

实现 `D3D12SwapChain` 类：
- IDXGISwapChain3 封装
- 帧缓冲管理
- 呈现模式配置
- 完整屏幕支持

**任务 2.21：D3D12Texture - 纹理实现**

实现 `D3D12Texture` 类：
- ID3D12Resource 封装
- 纹理描述
- 子资源管理
- 视图创建（SRV, RTV, DSV, UAV）
- 状态管理

**任务 2.22：D3D12Buffer - 缓冲区实现**

实现 `D3D12Buffer` 类：
- ID3D12Resource 封装
- 缓冲区描述
- 视图创建（SRV, CBV, UAV）
- 上传堆管理
- 默认堆管理

**任务 2.23：D3D12Shader - 着色器实现**

实现 `D3D12Shader` 类：
- 着色器字节码管理
- 反射数据提取
- 输入布局构建

**任务 2.24：D3D12RenderTargetView - 渲染目标视图实现**

实现 `D3D12RenderTargetView` 类：
- ID3D12RenderTargetView 封装
- 描述符创建与管理

**任务 2.25：D3D12DepthStencilView - 深度模板视图实现**

实现 `D3D12DepthStencilView` 类：
- ID3D12DepthStencilView 封装
- 描述符创建与管理

**任务 2.26：D3D12ShaderResourceView - 着色器资源视图实现**

实现 `D3D12ShaderResourceView` 类：
- ID3D12ShaderResourceView 封装
- 描述符创建与管理

**任务 2.27：D3D12UnorderedAccessView - 无序访问视图实现**

实现 `D3D12UnorderedAccessView` 类：
- ID3D12UnorderedAccessView 封装
- 描述符创建与管理

**任务 2.28：D3D12ConstantBufferView - 常量缓冲区视图实现**

实现 `D3D12ConstantBufferView` 类：
- ID3D12ConstantBufferView 封装
- 描述符创建与管理

---

## 2.4 实现顺序

```
阶段 2.1: 基础枚举与类型 (1天)
    ├── 2.1.1 Enums.h [已完成]
    │   └── RHI枚举定义（独立编号）
    ├── 2.1.2 Types.h (通用类型定义)
    └── 2.1.3 D3D12Enum.h [已完成]
        └── 枚举转换层（RHI→D3D12）

阶段 2.2: 核心接口定义 (3天)
    ├── 2.2.1 RHISystem.h
    ├── 2.2.2 RHIDevice.h
    ├── 2.2.3 Resource.h (资源基类)
    ├── 2.2.4 ResourceView.h (视图基类)
    ├── 2.2.5 CommandQueue.h
    ├── 2.2.6 CommandList.h
    └── 2.2.7 其他接口文件

阶段 2.3: D3D12 后端实现 (7天)
    ├── 2.3.1 D3D12Common.h
    ├── 2.3.2 D3D12Device
    ├── 2.3.3 D3D12Resource / D3D12Texture / D3D12Buffer
    ├── 2.3.4 D3D12CommandQueue
    ├── 2.3.5 D3D12CommandList
    ├── 2.3.6 D3D12CommandAllocator
    ├── 2.3.7 D3D12Fence
    ├── 2.3.8 D3D12DescriptorHeap
    ├── 2.3.9 D3D12RootSignature
    ├── 2.3.10 D3D12PipelineState
    ├── 2.3.11 D3D12Sampler
    ├── 2.3.12 D3D12QueryHeap
    ├── 2.3.13 D3D12SwapChain
    ├── 2.3.14 D3D12Shader
    ├── 2.3.15 D3D12RenderTargetView
    ├── 2.3.16 D3D12DepthStencilView
    ├── 2.3.17 D3D12ShaderResourceView
    ├── 2.3.18 D3D12UnorderedAccessView
    └── 2.3.19 D3D12ConstantBufferView

阶段 2.4: 集成测试 (1天)
    ├── 窗口创建与交换链关联
    ├── 渲染循环基本框架
    └── 简单的清屏测试
```

---

## 2.5 验收标准

1. **编译通过**：所有头文件和实现文件能够无错误编译
2. **接口完整**：所有定义的接口都有D3D12实现
3. **功能验证**：
   - 能够创建窗口并初始化D3D12设备
   - 能够创建命令队列和命令列表
   - 能够执行基本的渲染命令（清屏）
   - 能够处理窗口消息和呈现
4. **代码质量**：
   - 遵循编码规范
   - 必要的注释和文档
   - 错误处理完善

---

## 2.6 关键技术点

### 2.6.1 资源状态管理

D3D12要求严格的状态管理：
- 资源必须处于正确的状态才能使用
- 状态转换通过 `TransitionBarrier`
- 常用状态：`D3D12_RESOURCE_STATE_GENERIC_READ`, `D3D12_RESOURCE_STATE_RENDER_TARGET`, `D3D12_RESOURCE_STATE_DEPTH_WRITE` 等

### 2.6.2 描述符管理

- 描述符堆类型：CBV/SRV/UAV, Sampler, RTV, DSV
- GPU可见描述符堆用于渲染
- CPU可见描述符堆用于描述符拷贝
- 描述符递增大小计算

### 2.6.3 根签名设计

- 根参数类型：根常量、根描述符、根描述符表
- 描述符表：描述符数组
- 静态采样器：不可变的采样器配置

### 2.6.4 管线状态对象

- 图形管线：混合、深度、模板、光栅化、输入布局、顶点/像素/几何/ Hull/Domain着色器
- 计算管线：根签名、CS着色器

### 2.6.5 视图接口设计

- 每种视图类型(RTV/DSV/SRV/UAV/CBV)都有独立接口
- 视图持有对底层资源的引用
- 视图描述符确定资源的解释方式

### 2.6.6 着色器编译

- 使用D3DCompiler API或dxc编译HLSL
- 支持着色器反射获取输入布局和资源绑定信息
- 支持着色器宏定义和include处理

### 2.6.7 跨平台抽象设计原则

- 所有接口使用抽象类型，不暴露D3D12特定类型
- GPUDescriptorHandle/CPUDescriptorHandle 作为通用句柄类型
- 资源状态使用统一的ResourceStates枚举
- 创建描述符结构体独立于特定API
- RHI枚举使用独立编号，通过转换层转换为特定API枚举

### 2.6.8 枚举转换层

RHI枚举使用独立编号（与任何图形API无关），通过转换层转换为特定API：
```cpp
// RHI枚举（独立编号）
enum class FillMode { Wireframe, Solid };

// D3D12转换层
inline D3D12_FILL_MODE ToD3D12(FillMode mode) {
    switch (mode) {
        case FillMode::Wireframe: return D3D12_FILL_MODE_WIREFRAME;
        case FillMode::Solid: return D3D12_FILL_MODE_SOLID;
    }
}
```

---

## 2.7 后续阶段依赖

- 第三阶段：渲染管线（RenderPipeline）需要RHI作为基础
- 材质系统需要RHI的Shader和PipelineState
- 场景渲染需要CommandList提交绘制命令