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

feat: 实现D3D12Device类，整合D3D12Enum.h转换函数

Browse Source 
- 简化D3D12Device，仅封装ID3D12Device和IDXGIFactory
- 将D3D12Common.h中的转换函数合并到D3D12Enum.h
- 添加ResourceStates枚举到Enums.h
- 更新测试项目使用新的D3D12Device类
- 更新CMake配置
This commit is contained in:
ssdfasd
2026-03-15 03:02:15 +08:00
parent b2c7627a1b
commit cba4f9c838
8 changed files with 429 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -5,6 +5,4 @@ set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_subdirectory(engine)
add_subdirectory(mvs/XCEngineDemo)
add_subdirectory(mvs/HelloEarth)
add_subdirectory(test)
add_subdirectory(tests/D3D12)

5
engine/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.15)
project(XCEngine)
project(XCEngineLib)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -83,6 +83,9 @@ add_library(XCEngine STATIC
# RHI
include/XCEngine/RHI/Enums.h
include/XCEngine/RHI/D3D12/D3D12Enum.h
include/XCEngine/RHI/D3D12/D3D12Device.h
src/RHI/D3D12Device.cpp
)
target_include_directories(XCEngine PUBLIC

74
engine/include/XCEngine/RHI/D3D12/D3D12Device.h Normal file
View File

@@ -0,0 +1,74 @@
#pragma once
#include <d3d12.h>
#include <dxgi1_4.h>
#include <wrl/client.h>
#include <string>
#include <vector>
#include "../Enums.h"
#include "D3D12Enum.h"
using Microsoft::WRL::ComPtr;
namespace XCEngine {
namespace RHI {
struct AdapterInfo {
std::wstring description;
uint64_t dedicatedVideoMemory;
uint64_t dedicatedSystemMemory;
uint64_t sharedSystemMemory;
uint32_t vendorId;
uint32_t deviceId;
bool isSoftware;
};
struct DeviceInfo {
std::wstring deviceName;
std::wstring driverVersion;
uint64_t dedicatedVideoMemory;
uint64_t dedicatedSystemMemory;
uint64_t sharedSystemMemory;
uint32_t vendorId;
uint32_t deviceId;
bool supportsRaytracing;
bool supportsMeshShaders;
bool supportsSamplerFeedback;
};
class D3D12Device {
public:
D3D12Device();
~D3D12Device();
bool Initialize(bool enableDebugLayer = false);
void Shutdown();
ID3D12Device* GetDevice() const { return m_device.Get(); }
IDXGIFactory4* GetFactory() const { return m_factory.Get(); }
const DeviceInfo& GetDeviceInfo() const { return m_deviceInfo; }
std::vector<AdapterInfo> EnumerateAdapters();
bool CheckFeatureSupport(D3D12_FEATURE feature, void* featureSupportData, uint32_t featureSupportDataSize);
void SetDeviceRemoved() { m_isDeviceRemoved = true; }
bool IsDeviceRemoved() const { return m_isDeviceRemoved; }
private:
bool CreateDXGIFactory(bool enableDebugLayer);
bool CreateDevice(IDXGIAdapter1* adapter);
void QueryDeviceInfo();
ComPtr<ID3D12Device> m_device;
ComPtr<IDXGIFactory4> m_factory;
ComPtr<IDXGIAdapter1> m_adapter;
DeviceInfo m_deviceInfo;
bool m_isDeviceRemoved;
bool m_initialized;
};
} // namespace RHI
} // namespace XCEngine

142
engine/include/XCEngine/RHI/D3D12/D3D12Enum.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <d3d12.h>
#include <dxgi1_4.h>
#include "../Enums.h"
namespace XCEngine {
@@ -131,5 +132,146 @@ inline D3D12_SHADER_VISIBILITY ToD3D12(ShaderVisibility visibility) {
return D3D12_SHADER_VISIBILITY_ALL;
}
inline DXGI_FORMAT ToD3D12(Format format) {
switch (format) {
case Format::Unknown: return DXGI_FORMAT_UNKNOWN;
case Format::R8_UNorm: return DXGI_FORMAT_R8_UNORM;
case Format::R8G8_UNorm: return DXGI_FORMAT_R8G8_UNORM;
case Format::R8G8B8A8_UNorm: return DXGI_FORMAT_R8G8B8A8_UNORM;
case Format::R16G16B16A16_Float: return DXGI_FORMAT_R16G16B16A16_FLOAT;
case Format::R32G32B32A32_Float: return DXGI_FORMAT_R32G32B32A32_FLOAT;
case Format::R16_Float: return DXGI_FORMAT_R16_FLOAT;
case Format::R32_Float: return DXGI_FORMAT_R32_FLOAT;
case Format::D16_UNorm: return DXGI_FORMAT_D16_UNORM;
case Format::D24_UNorm_S8_UInt: return DXGI_FORMAT_D24_UNORM_S8_UINT;
case Format::D32_Float: return DXGI_FORMAT_D32_FLOAT;
case Format::BC1_UNorm: return DXGI_FORMAT_BC1_UNORM;
case Format::BC2_UNorm: return DXGI_FORMAT_BC2_UNORM;
case Format::BC3_UNorm: return DXGI_FORMAT_BC3_UNORM;
case Format::BC4_UNorm: return DXGI_FORMAT_BC4_UNORM;
case Format::BC5_UNorm: return DXGI_FORMAT_BC5_UNORM;
case Format::BC6H_UF16: return DXGI_FORMAT_BC6H_UF16;
case Format::BC7_UNorm: return DXGI_FORMAT_BC7_UNORM;
case Format::R32G32B32A32_UInt: return DXGI_FORMAT_R32G32B32A32_UINT;
case Format::R32_UInt: return DXGI_FORMAT_R32_UINT;
}
return DXGI_FORMAT_UNKNOWN;
}
inline D3D12_RESOURCE_STATES ToD3D12(ResourceStates state) {
switch (state) {
case ResourceStates::Common: return D3D12_RESOURCE_STATE_COMMON;
case ResourceStates::VertexAndConstantBuffer: return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
case ResourceStates::IndexBuffer: return D3D12_RESOURCE_STATE_INDEX_BUFFER;
case ResourceStates::RenderTarget: return D3D12_RESOURCE_STATE_RENDER_TARGET;
case ResourceStates::UnorderedAccess: return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
case ResourceStates::DepthWrite: return D3D12_RESOURCE_STATE_DEPTH_WRITE;
case ResourceStates::DepthRead: return D3D12_RESOURCE_STATE_DEPTH_READ;
case ResourceStates::NonPixelShaderResource: return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
case ResourceStates::PixelShaderResource: return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
case ResourceStates::CopySrc: return D3D12_RESOURCE_STATE_COPY_SOURCE;
case ResourceStates::CopyDst: return D3D12_RESOURCE_STATE_COPY_DEST;
case ResourceStates::Present: return D3D12_RESOURCE_STATE_PRESENT;
}
return D3D12_RESOURCE_STATE_COMMON;
}
inline D3D12_PRIMITIVE_TOPOLOGY_TYPE ToD3D12(PrimitiveTopology topology) {
switch (topology) {
case PrimitiveTopology::PointList: return D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
case PrimitiveTopology::LineList:
case PrimitiveTopology::LineStrip:
case PrimitiveTopology::LineListAdj:
case PrimitiveTopology::LineStripAdj:
return D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
case PrimitiveTopology::TriangleList:
case PrimitiveTopology::TriangleStrip:
case PrimitiveTopology::TriangleListAdj:
case PrimitiveTopology::TriangleStripAdj:
return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
case PrimitiveTopology::PatchList:
return D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH;
}
return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
}
inline D3D12_PRIMITIVE_TOPOLOGY ToD3D12Topology(PrimitiveTopology topology) {
switch (topology) {
case PrimitiveTopology::Undefined: return D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
case PrimitiveTopology::PointList: return D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
case PrimitiveTopology::LineList: return D3D_PRIMITIVE_TOPOLOGY_LINELIST;
case PrimitiveTopology::LineStrip: return D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;
case PrimitiveTopology::TriangleList: return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
case PrimitiveTopology::TriangleStrip: return D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
case PrimitiveTopology::LineListAdj: return D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ;
case PrimitiveTopology::LineStripAdj: return D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ;
case PrimitiveTopology::TriangleListAdj: return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ;
case PrimitiveTopology::TriangleStripAdj: return D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ;
case PrimitiveTopology::PatchList: return D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST;
}
return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
}
inline D3D12_DESCRIPTOR_HEAP_TYPE ToD3D12(DescriptorHeapType type) {
switch (type) {
case DescriptorHeapType::CBV_SRV_UAV: return D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
case DescriptorHeapType::Sampler: return D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
case DescriptorHeapType::RTV: return D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
case DescriptorHeapType::DSV: return D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
}
return D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
}
inline D3D12_QUERY_TYPE ToD3D12(QueryType type) {
switch (type) {
case QueryType::Occlusion: return D3D12_QUERY_TYPE_OCCLUSION;
case QueryType::Timestamp: return D3D12_QUERY_TYPE_TIMESTAMP;
case QueryType::PipelineStatistics: return D3D12_QUERY_TYPE_PIPELINE_STATISTICS;
}
return D3D12_QUERY_TYPE_OCCLUSION;
}
inline D3D12_ROOT_PARAMETER_TYPE ToD3D12(RootParameterType type) {
switch (type) {
case RootParameterType::DescriptorTable: return D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
case RootParameterType::Constants: return D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
case RootParameterType::CBV: return D3D12_ROOT_PARAMETER_TYPE_CBV;
case RootParameterType::SRV: return D3D12_ROOT_PARAMETER_TYPE_SRV;
case RootParameterType::UAV: return D3D12_ROOT_PARAMETER_TYPE_UAV;
}
return D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
}
inline DXGI_FORMAT ToDXGI(Format format) {
return ToD3D12(format);
}
inline D3D12_RESOURCE_DIMENSION ToD3D12(TextureType type) {
switch (type) {
case TextureType::Texture1D: return D3D12_RESOURCE_DIMENSION_TEXTURE1D;
case TextureType::Texture2D:
case TextureType::Texture2DArray:
case TextureType::TextureCube:
case TextureType::TextureCubeArray:
return D3D12_RESOURCE_DIMENSION_TEXTURE2D;
case TextureType::Texture3D: return D3D12_RESOURCE_DIMENSION_TEXTURE3D;
}
return D3D12_RESOURCE_DIMENSION_TEXTURE2D;
}
inline D3D12_STENCIL_OP ToD3D12(StencilOp op) {
switch (op) {
case StencilOp::Keep: return D3D12_STENCIL_OP_KEEP;
case StencilOp::Zero: return D3D12_STENCIL_OP_ZERO;
case StencilOp::Replace: return D3D12_STENCIL_OP_REPLACE;
case StencilOp::IncrSat: return D3D12_STENCIL_OP_INCR_SAT;
case StencilOp::DecrSat: return D3D12_STENCIL_OP_DECR_SAT;
case StencilOp::Invert: return D3D12_STENCIL_OP_INVERT;
case StencilOp::Incr: return D3D12_STENCIL_OP_INCR;
case StencilOp::Decr: return D3D12_STENCIL_OP_DECR;
}
return D3D12_STENCIL_OP_KEEP;
}
} // namespace RHI
} // namespace XCEngine

15
engine/include/XCEngine/RHI/Enums.h
View File

@@ -268,5 +268,20 @@ enum class Format : uint32_t {
R32_UInt
};
enum class ResourceStates : uint32_t {
Common,
VertexAndConstantBuffer,
IndexBuffer,
RenderTarget,
UnorderedAccess,
DepthWrite,
DepthRead,
NonPixelShaderResource,
PixelShaderResource,
CopySrc,
CopyDst,
Present
};
} // namespace RHI
} // namespace XCEngine

164
engine/src/RHI/D3D12Device.cpp Normal file
View File

@@ -0,0 +1,164 @@
#include "XCEngine/RHI/D3D12/D3D12Device.h"
#ifdef _DEBUG
#include <dxgidebug.h>
#endif
namespace XCEngine {
namespace RHI {
D3D12Device::D3D12Device()
: m_isDeviceRemoved(false)
, m_initialized(false)
{
}
D3D12Device::~D3D12Device() {
Shutdown();
}
bool D3D12Device::Initialize(bool enableDebugLayer) {
if (m_initialized) {
return true;
}
if (!CreateDXGIFactory(enableDebugLayer)) {
return false;
}
ComPtr<IDXGIAdapter1> adapter;
int adapterIndex = 0;
bool adapterFound = false;
while (m_factory->EnumAdapters1(adapterIndex, &adapter) != DXGI_ERROR_NOT_FOUND) {
DXGI_ADAPTER_DESC1 desc;
adapter->GetDesc1(&desc);
if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
adapterIndex++;
continue;
}
HRESULT hr = D3D12CreateDevice(adapter.Get(), D3D_FEATURE_LEVEL_11_0, __uuidof(ID3D12Device), nullptr);
if (SUCCEEDED(hr)) {
adapterFound = true;
m_adapter = adapter;
break;
}
adapterIndex++;
}
if (!adapterFound) {
return false;
}
if (!CreateDevice(m_adapter.Get())) {
return false;
}
QueryDeviceInfo();
m_initialized = true;
return true;
}
void D3D12Device::Shutdown() {
if (m_device) {
m_device.Reset();
}
if (m_factory) {
m_factory.Reset();
}
m_adapter.Reset();
m_initialized = false;
}
bool D3D12Device::CreateDXGIFactory(bool enableDebugLayer) {
UINT dxgiFactoryFlags = 0;
#ifdef _DEBUG
if (enableDebugLayer) {
ID3D12Debug* debugController = nullptr;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) {
debugController->EnableDebugLayer();
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
debugController->Release();
}
}
#endif
HRESULT hr = CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&m_factory));
return SUCCEEDED(hr);
}
bool D3D12Device::CreateDevice(IDXGIAdapter1* adapter) {
HRESULT hr = D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device));
return SUCCEEDED(hr);
}
void D3D12Device::QueryDeviceInfo() {
if (!m_adapter) {
return;
}
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;
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);
}
}
bool D3D12Device::CheckFeatureSupport(D3D12_FEATURE feature, void* featureSupportData, uint32_t featureSupportDataSize) {
return SUCCEEDED(m_device->CheckFeatureSupport(feature, featureSupportData, featureSupportDataSize));
}
std::vector<AdapterInfo> D3D12Device::EnumerateAdapters() {
std::vector<AdapterInfo> adapters;
if (!m_factory) {
return adapters;
}
ComPtr<IDXGIAdapter1> adapter;
int adapterIndex = 0;
while (m_factory->EnumAdapters1(adapterIndex, &adapter) != DXGI_ERROR_NOT_FOUND) {
DXGI_ADAPTER_DESC1 desc;
adapter->GetDesc1(&desc);
AdapterInfo info;
info.description = desc.Description;
info.dedicatedVideoMemory = desc.DedicatedVideoMemory;
info.dedicatedSystemMemory = desc.DedicatedSystemMemory;
info.sharedSystemMemory = desc.SharedSystemMemory;
info.vendorId = desc.VendorId;
info.deviceId = desc.DeviceId;
info.isSoftware = (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) != 0;
adapters.push_back(info);
adapterIndex++;
}
return adapters;
}
} // namespace RHI
} // namespace XCEngine

1
tests/D3D12/CMakeLists.txt
View File

@@ -24,4 +24,5 @@ target_link_libraries(D3D12 PRIVATE
dxgi
d3dcompiler
winmm
XCEngine
)

87
tests/D3D12/main.cpp
View File

@@ -13,6 +13,7 @@
#include "stbi/stb_image.h"
#include "XCEngine/RHI/Enums.h"
#include "XCEngine/RHI/D3D12/D3D12Enum.h"
#include "XCEngine/RHI/D3D12/D3D12Device.h"
using namespace XCEngine::RHI;
@@ -24,7 +25,7 @@ using namespace XCEngine::RHI;
//=================================================================================
// D3D12 核心全局对象 (最小渲染所需)
//=================================================================================
ID3D12Device* gD3D12Device = nullptr;
XCEngine::RHI::D3D12Device gDevice;
ID3D12CommandQueue* gCommandQueue = nullptr;
IDXGISwapChain3* gSwapChain = nullptr;
@@ -258,7 +259,7 @@ ID3D12RootSignature* InitRootSignature() {
ID3DBlob* signature;
HRESULT hResult = D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, nullptr);
ID3D12RootSignature* d3d12RootSignature;
gD3D12Device->CreateRootSignature(
gDevice.GetDevice()->CreateRootSignature(
0, signature->GetBufferPointer(), signature->GetBufferSize(),
IID_PPV_ARGS(&d3d12RootSignature));
@@ -311,7 +312,7 @@ ID3D12Resource* CreateConstantBufferObject(int inDataLen) {
d3d12ResourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
ID3D12Resource* bufferObject = nullptr;
gD3D12Device->CreateCommittedResource(
gDevice.GetDevice()->CreateCommittedResource(
&d3dHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12ResourceDesc,
@@ -355,7 +356,7 @@ ID3D12Resource* CreateBufferObject(ID3D12GraphicsCommandList* inCommandList,
d3d12ResourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
ID3D12Resource* bufferObject = nullptr;
gD3D12Device->CreateCommittedResource(
gDevice.GetDevice()->CreateCommittedResource(
&d3dHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12ResourceDesc,
@@ -368,13 +369,13 @@ ID3D12Resource* CreateBufferObject(ID3D12GraphicsCommandList* inCommandList,
UINT64 rowSizeInBytes = 0;
UINT rowUsed = 0;
D3D12_PLACED_SUBRESOURCE_FOOTPRINT subresourceFootprint;
gD3D12Device->GetCopyableFootprints(&d3d12ResourceDesc, 0, 1, 0,
gDevice.GetDevice()->GetCopyableFootprints(&d3d12ResourceDesc, 0, 1, 0,
&subresourceFootprint, &rowUsed, &rowSizeInBytes, &memorySizeUsed);
ID3D12Resource* tempBufferObject = nullptr;
d3dHeapProperties = {};
d3dHeapProperties.Type = D3D12_HEAP_TYPE_UPLOAD;
gD3D12Device->CreateCommittedResource(
gDevice.GetDevice()->CreateCommittedResource(
&d3dHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12ResourceDesc,
@@ -421,7 +422,7 @@ ID3D12Resource* CreateTexture2D(ID3D12GraphicsCommandList* inCommandList,
d3d12ResourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
ID3D12Resource* texture = nullptr;
gD3D12Device->CreateCommittedResource(&d3dHeapProperties,
gDevice.GetDevice()->CreateCommittedResource(&d3dHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12ResourceDesc,
D3D12_RESOURCE_STATE_COPY_DEST,
@@ -433,7 +434,7 @@ ID3D12Resource* CreateTexture2D(ID3D12GraphicsCommandList* inCommandList,
UINT64 rowSizeInBytes = 0;
UINT rowUsed = 0;
D3D12_PLACED_SUBRESOURCE_FOOTPRINT subresourceFootprint;
gD3D12Device->GetCopyableFootprints(&d3d12ResourceDesc, 0, 1, 0,
gDevice.GetDevice()->GetCopyableFootprints(&d3d12ResourceDesc, 0, 1, 0,
&subresourceFootprint, &rowUsed, &rowSizeInBytes, &memorySizeUsed);
ID3D12Resource* tempBufferObject = nullptr;
@@ -453,7 +454,7 @@ ID3D12Resource* CreateTexture2D(ID3D12GraphicsCommandList* inCommandList,
d3d12TempResourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
d3d12TempResourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
gD3D12Device->CreateCommittedResource(
gDevice.GetDevice()->CreateCommittedResource(
&d3dTempHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12TempResourceDesc,
@@ -537,7 +538,7 @@ ID3D12PipelineState* CreatePSO(ID3D12RootSignature* inID3D12RootSignature,
psoDesc.NumRenderTargets = 1;
ID3D12PipelineState* d3d12PSO = nullptr;
HRESULT hResult = gD3D12Device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&d3d12PSO));
HRESULT hResult = gDevice.GetDevice()->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&d3d12PSO));
if (FAILED(hResult)) {
return nullptr;
}
@@ -559,47 +560,15 @@ ID3D12PipelineState* CreatePSO(ID3D12RootSignature* inID3D12RootSignature,
// 10. 创建Fence (同步)
//=================================================================================
bool InitD3D12(HWND inHWND, int inWidth, int inHeight) {
HRESULT hResult;
UINT dxgiFactoryFlags = 0;
#ifdef _DEBUG
{
ID3D12Debug* debugController = nullptr;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) {
debugController->EnableDebugLayer();
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
IDXGIFactory4* dxgiFactory;
hResult = CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&dxgiFactory));
if (FAILED(hResult)) {
return false;
}
IDXGIAdapter1* adapter;
int adapterIndex = 0;
bool adapterFound = false;
while (dxgiFactory->EnumAdapters1(adapterIndex, &adapter) != DXGI_ERROR_NOT_FOUND) {
DXGI_ADAPTER_DESC1 desc;
adapter->GetDesc1(&desc);
if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
continue;
}
hResult = D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, __uuidof(ID3D12Device), nullptr);
if (SUCCEEDED(hResult)) {
adapterFound = true;
break;
}
adapterIndex++;
}
if (false == adapterFound) {
return false;
}
hResult = D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&gD3D12Device));
if (FAILED(hResult)) {
if (!gDevice.Initialize()) {
return false;
}
ID3D12Device* device = gDevice.GetDevice();
IDXGIFactory4* dxgiFactory = gDevice.GetFactory();
D3D12_COMMAND_QUEUE_DESC d3d12CommandQueueDesc = {};
hResult = gD3D12Device->CreateCommandQueue(&d3d12CommandQueueDesc, IID_PPV_ARGS(&gCommandQueue));
HRESULT hResult = device->CreateCommandQueue(&d3d12CommandQueueDesc, IID_PPV_ARGS(&gCommandQueue));
if (FAILED(hResult)) {
return false;
}
@@ -640,7 +609,7 @@ bool InitD3D12(HWND inHWND, int inWidth, int inHeight) {
dsClearValue.DepthStencil.Depth = 1.0f;
dsClearValue.DepthStencil.Stencil = 0;
gD3D12Device->CreateCommittedResource(&d3dHeapProperties,
device->CreateCommittedResource(&d3dHeapProperties,
D3D12_HEAP_FLAG_NONE,
&d3d12ResourceDesc,
D3D12_RESOURCE_STATE_DEPTH_WRITE,
@@ -651,32 +620,32 @@ bool InitD3D12(HWND inHWND, int inWidth, int inHeight) {
D3D12_DESCRIPTOR_HEAP_DESC d3dDescriptorHeapDescRTV = {};
d3dDescriptorHeapDescRTV.NumDescriptors = 2;
d3dDescriptorHeapDescRTV.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
gD3D12Device->CreateDescriptorHeap(&d3dDescriptorHeapDescRTV, IID_PPV_ARGS(&gSwapChainRTVHeap));
gRTVDescriptorSize = gD3D12Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
device->CreateDescriptorHeap(&d3dDescriptorHeapDescRTV, IID_PPV_ARGS(&gSwapChainRTVHeap));
gRTVDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
D3D12_DESCRIPTOR_HEAP_DESC d3dDescriptorHeapDescDSV = {};
d3dDescriptorHeapDescDSV.NumDescriptors = 1;
d3dDescriptorHeapDescDSV.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
gD3D12Device->CreateDescriptorHeap(&d3dDescriptorHeapDescDSV, IID_PPV_ARGS(&gSwapChainDSVHeap));
gDSVDescriptorSize = gD3D12Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
device->CreateDescriptorHeap(&d3dDescriptorHeapDescDSV, IID_PPV_ARGS(&gSwapChainDSVHeap));
gDSVDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
D3D12_CPU_DESCRIPTOR_HANDLE rtvHeapStart = gSwapChainRTVHeap->GetCPUDescriptorHandleForHeapStart();
for (int i = 0; i < 2; i++) {
gSwapChain->GetBuffer(i, IID_PPV_ARGS(&gColorRTs[i]));
D3D12_CPU_DESCRIPTOR_HANDLE rtvPointer;
rtvPointer.ptr = rtvHeapStart.ptr + i * gRTVDescriptorSize;
gD3D12Device->CreateRenderTargetView(gColorRTs[i], nullptr, rtvPointer);
device->CreateRenderTargetView(gColorRTs[i], nullptr, rtvPointer);
}
D3D12_DEPTH_STENCIL_VIEW_DESC d3dDSViewDesc = {};
d3dDSViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
d3dDSViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
gD3D12Device->CreateDepthStencilView(gDSRT, &d3dDSViewDesc, gSwapChainDSVHeap->GetCPUDescriptorHandleForHeapStart());
device->CreateDepthStencilView(gDSRT, &d3dDSViewDesc, gSwapChainDSVHeap->GetCPUDescriptorHandleForHeapStart());
gD3D12Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&gCommandAllocator));
gD3D12Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, gCommandAllocator, nullptr, IID_PPV_ARGS(&gCommandList));
device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&gCommandAllocator));
device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, gCommandAllocator, nullptr, IID_PPV_ARGS(&gCommandList));
gD3D12Device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&gFence));
device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&gFence));
gFenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
return true;
@@ -757,7 +726,7 @@ void SwapD3D12Buffers() {
// 获取D3D12设备
//=================================================================================
ID3D12Device* GetD3DDevice() {
return gD3D12Device;
return gDevice.GetDevice();
}
//=================================================================================