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

Refactor D3D12: remove ICommandQueue, IFence dependencies

Browse Source
This commit is contained in:
ssdfasd
2026-03-16 21:50:54 +08:00
parent 4a0f6d65d1
commit 472f106a12
7 changed files with 37 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
engine/include/XCEngine/RHI/D3D12/D3D12CommandAllocator.h
View File

@@ -4,7 +4,6 @@
#include <wrl/client.h>
#include "../Enums.h"
#include "../CommandAllocator.h"
using Microsoft::WRL::ComPtr;

6
engine/include/XCEngine/RHI/D3D12/D3D12CommandQueue.h
View File

@@ -4,7 +4,6 @@
#include <wrl/client.h>
#include "../Enums.h"
#include "../CommandQueue.h"
#include "D3D12Enum.h"
using Microsoft::WRL::ComPtr;
@@ -22,11 +21,10 @@ public:
bool Initialize(ID3D12Device* device, CommandQueueType type = CommandQueueType::Direct);
void Shutdown();
void ExecuteCommandLists(uint32_t count, ICommandList** lists);
void ExecuteCommandLists(uint32_t count, ID3D12CommandList** lists);
void Signal(IFence* fence, uint64_t value);
void Signal(D3D12Fence* fence, uint64_t value);
void Signal(ID3D12Fence* fence, uint64_t value);
void Wait(IFence* fence, uint64_t value);
void Wait(D3D12Fence* fence, uint64_t value);
void Wait(ID3D12Fence* fence, uint64_t value);
uint64_t GetCompletedValue();
void WaitForIdle();

1
engine/include/XCEngine/RHI/D3D12/D3D12DescriptorHeap.h
View File

@@ -5,7 +5,6 @@
#include "../Enums.h"
#include "../Types.h"
#include "../DescriptorHeap.h"
#include "D3D12Enum.h"
using Microsoft::WRL::ComPtr;

45
engine/include/XCEngine/RHI/D3D12/D3D12Device.h
View File

@@ -7,7 +7,7 @@
#include <vector>
#include "../Enums.h"
#include "../RHIDevice.h"
#include "../Types.h"
#include "D3D12Enum.h"
using Microsoft::WRL::ComPtr;
@@ -54,7 +54,7 @@ public:
ID3D12Device* GetDevice() const { return m_device.Get(); }
IDXGIFactory4* GetFactory() const { return m_factory.Get(); }
const ::XCEngine::RHI::DeviceInfo& GetDeviceInfo() const { return m_deviceInfo; }
const AdapterInfo& GetAdapterInfo() const { return m_adapterInfo; }
std::vector<AdapterInfo> EnumerateAdapters();
@@ -66,39 +66,38 @@ public:
bool IsDeviceRemoved() const { return m_isDeviceRemoved; }
// Factory methods
ICommandQueue* CreateCommandQueue(const CommandQueueDesc& desc);
ICommandList* CreateCommandList(const CommandListDesc& desc);
ICommandAllocator* CreateCommandAllocator(const CommandAllocatorDesc& desc);
IFence* CreateFence(const FenceDesc& desc);
IDescriptorHeap* CreateDescriptorHeap(const DescriptorHeapDesc& desc);
IQueryHeap* CreateQueryHeap(const QueryHeapDesc& desc);
IRootSignature* CreateRootSignature(const RootSignatureDesc& desc);
IPipelineState* CreatePipelineState(const PipelineStateDesc& desc);
ISampler* CreateSampler(const SamplerDesc& desc);
ITexture* CreateTexture(const TextureDesc& desc);
IBuffer* CreateBuffer(const BufferDesc& desc);
ISwapChain* CreateSwapChain(const SwapChainDesc& desc);
IShader* CompileShader(const ShaderCompileDesc& desc);
D3D12CommandQueue* CreateCommandQueue(const CommandQueueDesc& desc);
D3D12CommandList* CreateCommandList(const CommandListDesc& desc);
D3D12CommandAllocator* CreateCommandAllocator(const CommandAllocatorDesc& desc);
D3D12Fence* CreateFence(const FenceDesc& desc);
D3D12DescriptorHeap* CreateDescriptorHeap(const DescriptorHeapDesc& desc);
D3D12QueryHeap* CreateQueryHeap(const QueryHeapDesc& desc);
D3D12RootSignature* CreateRootSignature(const RootSignatureDesc& desc);
D3D12PipelineState* CreatePipelineState(const PipelineStateDesc& desc);
D3D12Sampler* CreateSampler(const SamplerDesc& desc);
D3D12Texture* CreateTexture(const TextureDesc& desc);
D3D12Buffer* CreateBuffer(const BufferDesc& desc);
D3D12SwapChain* CreateSwapChain(const SwapChainDesc& desc);
D3D12Shader* CompileShader(const ShaderCompileDesc& desc);
IRenderTargetView* CreateRenderTargetView(IBuffer* resource, const RenderTargetViewDesc& desc);
IDepthStencilView* CreateDepthStencilView(IBuffer* resource, const DepthStencilViewDesc& desc);
IShaderResourceView* CreateShaderResourceView(IBuffer* resource, const ShaderResourceViewDesc& desc);
IUnorderedAccessView* CreateUnorderedAccessView(IBuffer* resource, const UnorderedAccessViewDesc& desc);
IConstantBufferView* CreateConstantBufferView(IBuffer* resource, const ConstantBufferViewDesc& desc);
D3D12RenderTargetView* CreateRenderTargetView(D3D12Buffer* resource, const RenderTargetViewDesc& desc);
D3D12DepthStencilView* CreateDepthStencilView(D3D12Buffer* resource, const DepthStencilViewDesc& desc);
D3D12ShaderResourceView* CreateShaderResourceView(D3D12Buffer* resource, const ShaderResourceViewDesc& desc);
D3D12UnorderedAccessView* CreateUnorderedAccessView(D3D12Buffer* resource, const UnorderedAccessViewDesc& desc);
D3D12ConstantBufferView* CreateConstantBufferView(D3D12Buffer* resource, const ConstantBufferViewDesc& desc);
void GetDeviceInfo(DeviceInfo& info) const;
void* GetNativeHandle() const;
private:
bool CreateDXGIFactory(bool enableDebugLayer);
bool CreateDevice(IDXGIAdapter1* adapter);
void QueryDeviceInfo();
void QueryAdapterInfo();
ComPtr<ID3D12Device> m_device;
ComPtr<IDXGIFactory4> m_factory;
ComPtr<IDXGIAdapter1> m_adapter;
::XCEngine::RHI::DeviceInfo m_deviceInfo;
AdapterInfo m_adapterInfo;
bool m_isDeviceRemoved;
bool m_initialized;
};

1
engine/include/XCEngine/RHI/D3D12/D3D12Fence.h
View File

@@ -4,7 +4,6 @@
#include <wrl/client.h>
#include <cstdint>
#include "../Fence.h"
using Microsoft::WRL::ComPtr;

18
engine/src/RHI/D3D12/D3D12CommandQueue.cpp
View File

@@ -36,23 +36,13 @@ void D3D12CommandQueue::Shutdown() {
m_commandQueue.Reset();
}
void D3D12CommandQueue::ExecuteCommandLists(uint32_t count, ICommandList** lists) {
std::vector<ID3D12CommandList*> d3d12Lists(count);
for (uint32_t i = 0; i < count; ++i) {
if (lists[i]) {
d3d12Lists[i] = reinterpret_cast<D3D12CommandList*>(lists[i])->GetCommandList();
}
}
m_commandQueue->ExecuteCommandLists(count, d3d12Lists.data());
}
void D3D12CommandQueue::ExecuteCommandLists(uint32_t count, ID3D12CommandList** lists) {
m_commandQueue->ExecuteCommandLists(count, lists);
}
void D3D12CommandQueue::Signal(IFence* fence, uint64_t value) {
void D3D12CommandQueue::Signal(D3D12Fence* fence, uint64_t value) {
if (fence) {
m_commandQueue->Signal(reinterpret_cast<D3D12Fence*>(fence)->GetFence(), value);
m_commandQueue->Signal(fence->GetFence(), value);
}
}
@@ -62,9 +52,9 @@ void D3D12CommandQueue::Signal(ID3D12Fence* fence, uint64_t value) {
}
}
void D3D12CommandQueue::Wait(IFence* fence, uint64_t value) {
void D3D12CommandQueue::Wait(D3D12Fence* fence, uint64_t value) {
if (fence) {
m_commandQueue->Wait(reinterpret_cast<D3D12Fence*>(fence)->GetFence(), value);
m_commandQueue->Wait(fence->GetFence(), value);
}
}

28
engine/src/RHI/D3D12/D3D12Device.cpp
View File

@@ -75,7 +75,7 @@ bool D3D12Device::Initialize(bool enableDebugLayer) {
return false;
}
QueryDeviceInfo();
QueryAdapterInfo();
m_initialized = true;
return true;
}
@@ -118,7 +118,7 @@ bool D3D12Device::CreateDevice(IDXGIAdapter1* adapter) {
return SUCCEEDED(hr);
}
void D3D12Device::QueryDeviceInfo() {
void D3D12Device::QueryAdapterInfo() {
if (!m_adapter) {
return;
}
@@ -126,26 +126,20 @@ void D3D12Device::QueryDeviceInfo() {
DXGI_ADAPTER_DESC1 desc;
m_adapter->GetDesc1(&desc);
m_deviceInfo.vendorId = desc.VendorId;
m_deviceInfo.deviceId = desc.DeviceId;
m_deviceInfo.dedicatedVideoMemory = desc.DedicatedVideoMemory;
m_deviceInfo.dedicatedSystemMemory = desc.DedicatedSystemMemory;
m_deviceInfo.sharedSystemMemory = desc.SharedSystemMemory;
m_deviceInfo.deviceName = desc.Description;
m_deviceInfo.supportsRaytracing = false;
m_deviceInfo.supportsMeshShaders = false;
m_deviceInfo.supportsSamplerFeedback = false;
m_adapterInfo.vendorId = desc.VendorId;
m_adapterInfo.deviceId = desc.DeviceId;
m_adapterInfo.dedicatedVideoMemory = desc.DedicatedVideoMemory;
m_adapterInfo.dedicatedSystemMemory = desc.DedicatedSystemMemory;
m_adapterInfo.sharedSystemMemory = desc.SharedSystemMemory;
m_adapterInfo.description = desc.Description;
m_adapterInfo.isSoftware = (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) != 0;
D3D12_FEATURE_DATA_D3D12_OPTIONS5 options5 = {};
if (SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &options5, sizeof(options5)))) {
m_deviceInfo.supportsRaytracing = (options5.RaytracingTier != D3D12_RAYTRACING_TIER_NOT_SUPPORTED);
}
D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7 = {};
if (SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options7, sizeof(options7)))) {
m_deviceInfo.supportsSamplerFeedback = (options7.SamplerFeedbackTier != D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED);
m_deviceInfo.supportsMeshShaders = (options7.MeshShaderTier != D3D12_MESH_SHADER_TIER_NOT_SUPPORTED);
}
}
@@ -187,10 +181,6 @@ UINT D3D12Device::GetDescriptorHandleIncrementSize(DescriptorHeapType type) cons
return m_device->GetDescriptorHandleIncrementSize(ToD3D12(type));
}
void D3D12Device::GetDeviceInfo(DeviceInfo& info) const {
info = m_deviceInfo;
}
void* D3D12Device::GetNativeHandle() const {
return m_device.Get();
}