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

Add static helper methods to D3D12RootSignature and D3D12PipelineState

Browse Source
This commit is contained in:
ssdfasd
2026-03-17 00:57:35 +08:00
parent 7874033379
commit 988f94eb29
9 changed files with 180 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
engine/CMakeLists.txt
View File

@@ -95,8 +95,6 @@ add_library(XCEngine STATIC
include/XCEngine/RHI/D3D12/D3D12Shader.h include/XCEngine/RHI/D3D12/D3D12Shader.h
include/XCEngine/RHI/D3D12/D3D12Texture.h include/XCEngine/RHI/D3D12/D3D12Texture.h
include/XCEngine/RHI/D3D12/D3D12RootSignature.h include/XCEngine/RHI/D3D12/D3D12RootSignature.h
include/XCEngine/RHI/D3D12/RootSignatureBuilder.h
include/XCEngine/RHI/D3D12/PipelineStateBuilder.h
include/XCEngine/RHI/D3D12/D3D12SwapChain.h include/XCEngine/RHI/D3D12/D3D12SwapChain.h
include/XCEngine/RHI/D3D12/D3D12Fence.h include/XCEngine/RHI/D3D12/D3D12Fence.h
include/XCEngine/RHI/D3D12/D3D12Screenshot.h include/XCEngine/RHI/D3D12/D3D12Screenshot.h
@@ -117,8 +115,6 @@ add_library(XCEngine STATIC
src/RHI/D3D12/D3D12Shader.cpp src/RHI/D3D12/D3D12Shader.cpp
src/RHI/D3D12/D3D12Texture.cpp src/RHI/D3D12/D3D12Texture.cpp
src/RHI/D3D12/D3D12RootSignature.cpp src/RHI/D3D12/D3D12RootSignature.cpp
src/RHI/D3D12/RootSignatureBuilder.cpp
src/RHI/D3D12/PipelineStateBuilder.cpp
src/RHI/D3D12/D3D12SwapChain.cpp src/RHI/D3D12/D3D12SwapChain.cpp
src/RHI/D3D12/D3D12Fence.cpp src/RHI/D3D12/D3D12Fence.cpp
src/RHI/D3D12/D3D12Screenshot.cpp src/RHI/D3D12/D3D12Screenshot.cpp

23
engine/include/XCEngine/RHI/D3D12/D3D12PipelineState.h
View File

@@ -1,8 +1,10 @@
#pragma once #pragma once
#include <d3d12.h> #include <d3d12.h>
#include <dxgi1_4.h>
#include <wrl/client.h> #include <wrl/client.h>
#include "../Enums.h"
#include "D3D12Enum.h" #include "D3D12Enum.h"
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
@@ -23,6 +25,27 @@ public:
void* GetNativeHandle() const { return m_pipelineState.Get(); } void* GetNativeHandle() const { return m_pipelineState.Get(); }
PipelineType GetType() const { return PipelineType::Graphics; } PipelineType GetType() const { return PipelineType::Graphics; }
static D3D12_GRAPHICS_PIPELINE_STATE_DESC CreateDesc(
ID3D12RootSignature* rootSignature,
const D3D12_SHADER_BYTECODE& vs,
const D3D12_SHADER_BYTECODE& ps,
const D3D12_SHADER_BYTECODE& gs,
uint32_t inputElementCount,
const D3D12_INPUT_ELEMENT_DESC* inputElements);
static D3D12_INPUT_ELEMENT_DESC CreateInputElement(
const char* semanticName,
uint32_t semanticIndex,
Format format,
uint32_t inputSlot,
uint32_t alignedByteOffset);
static D3D12_INPUT_ELEMENT_DESC CreateInputElement(
const char* semanticName,
uint32_t semanticIndex,
Format format,
uint32_t inputSlot);
private: private:
ComPtr<ID3D12PipelineState> m_pipelineState; ComPtr<ID3D12PipelineState> m_pipelineState;
}; };

17
engine/include/XCEngine/RHI/D3D12/D3D12RootSignature.h
View File

@@ -2,6 +2,7 @@
#include <d3d12.h> #include <d3d12.h>
#include <wrl/client.h> #include <wrl/client.h>
#include <vector>
#include "../Enums.h" #include "../Enums.h"
#include "D3D12Enum.h" #include "D3D12Enum.h"
@@ -20,10 +21,24 @@ public:
void Shutdown(); void Shutdown();
ID3D12RootSignature* GetRootSignature() const { return m_rootSignature.Get(); } ID3D12RootSignature* GetRootSignature() const { return m_rootSignature.Get(); }
void* GetNativeHandle() const { return m_rootSignature.Get(); } void* GetNativeHandle() const { return m_rootSignature.Get(); }
uint32_t GetParameterCount() const { return m_parameterCount; } uint32_t GetParameterCount() const { return m_parameterCount; }
static D3D12_ROOT_SIGNATURE_DESC CreateDesc(
D3D12_ROOT_PARAMETER* parameters,
uint32_t parameterCount,
D3D12_STATIC_SAMPLER_DESC* samplers = nullptr,
uint32_t samplerCount = 0,
D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
static D3D12_ROOT_PARAMETER CreateCBV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
static D3D12_ROOT_PARAMETER CreateSRV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
static D3D12_ROOT_PARAMETER CreateUAV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
static D3D12_ROOT_PARAMETER Create32BitConstants(uint32_t shaderRegister, uint32_t num32BitValues, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
static D3D12_ROOT_PARAMETER CreateDescriptorTable(uint32_t shaderRegister, uint32_t numDescriptors, D3D12_DESCRIPTOR_RANGE_TYPE rangeType, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
static D3D12_STATIC_SAMPLER_DESC CreateStaticSampler(uint32_t shaderRegister, const D3D12_SAMPLER_DESC& desc, ShaderVisibility visibility = ShaderVisibility::Pixel);
private: private:
ComPtr<ID3D12RootSignature> m_rootSignature; ComPtr<ID3D12RootSignature> m_rootSignature;
uint32_t m_parameterCount = 0; uint32_t m_parameterCount = 0;

53
engine/include/XCEngine/RHI/D3D12/PipelineStateBuilder.h
View File

@@ -1,53 +0,0 @@
#pragma once
#include <d3d12.h>
#include <dxgi1_4.h>
#include "../Enums.h"
#include "D3D12Enum.h"
namespace XCEngine {
namespace RHI {
class PipelineStateBuilder {
public:
PipelineStateBuilder();
PipelineStateBuilder& SetRootSignature(ID3D12RootSignature* rootSignature);
PipelineStateBuilder& SetVertexShader(const D3D12_SHADER_BYTECODE& shader);
PipelineStateBuilder& SetPixelShader(const D3D12_SHADER_BYTECODE& shader);
PipelineStateBuilder& SetGeometryShader(const D3D12_SHADER_BYTECODE& shader);
PipelineStateBuilder& SetInputLayout(uint32_t numElements, const D3D12_INPUT_ELEMENT_DESC* elements);
PipelineStateBuilder& SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE topologyType);
PipelineStateBuilder& SetRenderTargetFormat(Format format);
PipelineStateBuilder& SetRenderTargetFormats(uint32_t count, const Format* formats);
PipelineStateBuilder& SetDepthStencilFormat(Format format);
PipelineStateBuilder& SetSampleDesc(uint32_t count, uint32_t quality);
PipelineStateBuilder& SetFillMode(FillMode mode);
PipelineStateBuilder& SetCullMode(CullMode mode);
PipelineStateBuilder& SetDepthClipEnable(bool enable);
PipelineStateBuilder& SetDepthEnable(bool enable);
PipelineStateBuilder& SetDepthWriteMask(D3D12_DEPTH_WRITE_MASK writeMask);
PipelineStateBuilder& SetDepthFunc(ComparisonFunc func);
PipelineStateBuilder& SetStencilEnable(bool enable);
PipelineStateBuilder& SetFrontFaceStencilOp(D3D12_STENCIL_OP failOp, D3D12_STENCIL_OP depthFailOp, D3D12_STENCIL_OP passOp, ComparisonFunc func);
PipelineStateBuilder& SetBackFaceStencilOp(D3D12_STENCIL_OP failOp, D3D12_STENCIL_OP depthFailOp, D3D12_STENCIL_OP passOp, ComparisonFunc func);
PipelineStateBuilder& SetBlendEnable(bool enable);
PipelineStateBuilder& SetBlendFactor(BlendFactor srcBlend, BlendFactor dstBlend, BlendOp blendOp);
PipelineStateBuilder& SetAlphaBlendFactor(BlendFactor srcBlendAlpha, BlendFactor dstBlendAlpha, BlendOp blendOpAlpha);
PipelineStateBuilder& SetColorWriteMask(ColorWriteMask mask);
D3D12_GRAPHICS_PIPELINE_STATE_DESC Build();
private:
D3D12_GRAPHICS_PIPELINE_STATE_DESC m_desc;
};
} // namespace RHI
} // namespace XCEngine

30
engine/include/XCEngine/RHI/D3D12/RootSignatureBuilder.h
View File

@@ -1,30 +0,0 @@
#pragma once
#include <d3d12.h>
#include <vector>
#include "../Enums.h"
#include "D3D12Enum.h"
namespace XCEngine {
namespace RHI {
class RootSignatureBuilder {
public:
RootSignatureBuilder();
RootSignatureBuilder& AddCBV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
RootSignatureBuilder& AddSRV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
RootSignatureBuilder& AddUAV(uint32_t shaderRegister, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
RootSignatureBuilder& Add32BitConstants(uint32_t shaderRegister, uint32_t num32BitValues, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
RootSignatureBuilder& AddDescriptorTable(uint32_t shaderRegister, uint32_t numDescriptors, D3D12_DESCRIPTOR_RANGE_TYPE rangeType, ShaderVisibility visibility = ShaderVisibility::All, uint32_t registerSpace = 0);
D3D12_ROOT_SIGNATURE_DESC Build();
private:
std::vector<D3D12_ROOT_PARAMETER> m_parameters;
std::vector<std::vector<D3D12_DESCRIPTOR_RANGE>> m_descriptorRanges;
};
} // namespace RHI
} // namespace XCEngine

55
engine/src/RHI/D3D12/D3D12PipelineState.cpp
View File

@@ -22,5 +22,60 @@ void D3D12PipelineState::Shutdown() {
m_pipelineState.Reset(); m_pipelineState.Reset();
} }
D3D12_GRAPHICS_PIPELINE_STATE_DESC D3D12PipelineState::CreateDesc(
ID3D12RootSignature* rootSignature,
const D3D12_SHADER_BYTECODE& vs,
const D3D12_SHADER_BYTECODE& ps,
const D3D12_SHADER_BYTECODE& gs,
uint32_t inputElementCount,
const D3D12_INPUT_ELEMENT_DESC* inputElements) {
D3D12_GRAPHICS_PIPELINE_STATE_DESC desc = {};
desc.pRootSignature = rootSignature;
desc.VS = vs;
desc.PS = ps;
desc.GS = gs;
desc.InputLayout.NumElements = inputElementCount;
desc.InputLayout.pInputElementDescs = inputElements;
desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.SampleMask = 0xffffffff;
desc.NumRenderTargets = 1;
desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
desc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
desc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
desc.RasterizerState.DepthClipEnable = TRUE;
desc.DepthStencilState.DepthEnable = TRUE;
desc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL;
return desc;
}
D3D12_INPUT_ELEMENT_DESC D3D12PipelineState::CreateInputElement(
const char* semanticName,
uint32_t semanticIndex,
Format format,
uint32_t inputSlot,
uint32_t alignedByteOffset) {
D3D12_INPUT_ELEMENT_DESC element = {};
element.SemanticName = semanticName;
element.SemanticIndex = semanticIndex;
element.Format = ToD3D12(format);
element.InputSlot = inputSlot;
element.AlignedByteOffset = alignedByteOffset;
element.InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
element.InstanceDataStepRate = 0;
return element;
}
D3D12_INPUT_ELEMENT_DESC D3D12PipelineState::CreateInputElement(
const char* semanticName,
uint32_t semanticIndex,
Format format,
uint32_t inputSlot) {
return CreateInputElement(semanticName, semanticIndex, format, inputSlot, D3D12_APPEND_ALIGNED_ELEMENT);
}
} // namespace RHI } // namespace RHI
} // namespace XCEngine } // namespace XCEngine

86
engine/src/RHI/D3D12/D3D12RootSignature.cpp
View File

@@ -39,5 +39,91 @@ void D3D12RootSignature::Shutdown() {
m_rootSignature.Reset(); m_rootSignature.Reset();
} }
D3D12_ROOT_SIGNATURE_DESC D3D12RootSignature::CreateDesc(
D3D12_ROOT_PARAMETER* parameters,
uint32_t parameterCount,
D3D12_STATIC_SAMPLER_DESC* samplers,
uint32_t samplerCount,
D3D12_ROOT_SIGNATURE_FLAGS flags) {
D3D12_ROOT_SIGNATURE_DESC desc = {};
desc.NumParameters = parameterCount;
desc.pParameters = parameters;
desc.NumStaticSamplers = samplerCount;
desc.pStaticSamplers = samplers;
desc.Flags = flags;
return desc;
}
D3D12_ROOT_PARAMETER D3D12RootSignature::CreateCBV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
return param;
}
D3D12_ROOT_PARAMETER D3D12RootSignature::CreateSRV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
return param;
}
D3D12_ROOT_PARAMETER D3D12RootSignature::CreateUAV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
return param;
}
D3D12_ROOT_PARAMETER D3D12RootSignature::Create32BitConstants(uint32_t shaderRegister, uint32_t num32BitValues, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
param.ShaderVisibility = ToD3D12(visibility);
param.Constants.RegisterSpace = registerSpace;
param.Constants.ShaderRegister = shaderRegister;
param.Constants.Num32BitValues = num32BitValues;
return param;
}
D3D12_ROOT_PARAMETER D3D12RootSignature::CreateDescriptorTable(uint32_t shaderRegister, uint32_t numDescriptors, D3D12_DESCRIPTOR_RANGE_TYPE rangeType, ShaderVisibility visibility, uint32_t registerSpace) {
static D3D12_DESCRIPTOR_RANGE range;
range.RangeType = rangeType;
range.NumDescriptors = numDescriptors;
range.BaseShaderRegister = shaderRegister;
range.RegisterSpace = registerSpace;
range.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
param.ShaderVisibility = ToD3D12(visibility);
param.DescriptorTable.NumDescriptorRanges = 1;
param.DescriptorTable.pDescriptorRanges = &range;
return param;
}
D3D12_STATIC_SAMPLER_DESC D3D12RootSignature::CreateStaticSampler(uint32_t shaderRegister, const D3D12_SAMPLER_DESC& desc, ShaderVisibility visibility) {
D3D12_STATIC_SAMPLER_DESC samplerDesc = {};
samplerDesc.Filter = desc.Filter;
samplerDesc.AddressU = desc.AddressU;
samplerDesc.AddressV = desc.AddressV;
samplerDesc.AddressW = desc.AddressW;
samplerDesc.MipLODBias = desc.MipLODBias;
samplerDesc.MaxAnisotropy = desc.MaxAnisotropy;
samplerDesc.ComparisonFunc = desc.ComparisonFunc;
samplerDesc.BorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK;
samplerDesc.MinLOD = desc.MinLOD;
samplerDesc.MaxLOD = desc.MaxLOD;
samplerDesc.RegisterSpace = 0;
samplerDesc.ShaderRegister = shaderRegister;
samplerDesc.ShaderVisibility = ToD3D12(visibility);
return samplerDesc;
}
} // namespace RHI } // namespace RHI
} // namespace XCEngine } // namespace XCEngine

159
engine/src/RHI/D3D12/PipelineStateBuilder.cpp
View File

@@ -1,159 +0,0 @@
#include "XCEngine/RHI/D3D12/PipelineStateBuilder.h"
namespace XCEngine {
namespace RHI {
PipelineStateBuilder::PipelineStateBuilder() {
memset(&m_desc, 0, sizeof(m_desc));
m_desc.SampleDesc.Count = 1;
m_desc.SampleDesc.Quality = 0;
m_desc.SampleMask = 0xffffffff;
m_desc.NumRenderTargets = 1;
m_desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
m_desc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
m_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
m_desc.DepthStencilState.DepthEnable = TRUE;
m_desc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
m_desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL;
m_desc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
m_desc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
m_desc.RasterizerState.DepthClipEnable = TRUE;
}
PipelineStateBuilder& PipelineStateBuilder::SetRootSignature(ID3D12RootSignature* rootSignature) {
m_desc.pRootSignature = rootSignature;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetVertexShader(const D3D12_SHADER_BYTECODE& shader) {
m_desc.VS = shader;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetPixelShader(const D3D12_SHADER_BYTECODE& shader) {
m_desc.PS = shader;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetGeometryShader(const D3D12_SHADER_BYTECODE& shader) {
m_desc.GS = shader;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetInputLayout(uint32_t numElements, const D3D12_INPUT_ELEMENT_DESC* elements) {
m_desc.InputLayout.NumElements = numElements;
m_desc.InputLayout.pInputElementDescs = elements;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE topologyType) {
m_desc.PrimitiveTopologyType = topologyType;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetRenderTargetFormat(Format format) {
m_desc.NumRenderTargets = 1;
m_desc.RTVFormats[0] = ToD3D12(format);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetRenderTargetFormats(uint32_t count, const Format* formats) {
m_desc.NumRenderTargets = count;
for (uint32_t i = 0; i < count && i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i) {
m_desc.RTVFormats[i] = ToD3D12(formats[i]);
}
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetDepthStencilFormat(Format format) {
m_desc.DSVFormat = ToD3D12(format);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetSampleDesc(uint32_t count, uint32_t quality) {
m_desc.SampleDesc.Count = count;
m_desc.SampleDesc.Quality = quality;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetFillMode(FillMode mode) {
m_desc.RasterizerState.FillMode = ToD3D12(mode);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetCullMode(CullMode mode) {
m_desc.RasterizerState.CullMode = ToD3D12(mode);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetDepthClipEnable(bool enable) {
m_desc.RasterizerState.DepthClipEnable = enable ? TRUE : FALSE;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetDepthEnable(bool enable) {
m_desc.DepthStencilState.DepthEnable = enable ? TRUE : FALSE;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetDepthWriteMask(D3D12_DEPTH_WRITE_MASK writeMask) {
m_desc.DepthStencilState.DepthWriteMask = writeMask;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetDepthFunc(ComparisonFunc func) {
m_desc.DepthStencilState.DepthFunc = ToD3D12(func);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetStencilEnable(bool enable) {
m_desc.DepthStencilState.StencilEnable = enable ? TRUE : FALSE;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetFrontFaceStencilOp(D3D12_STENCIL_OP failOp, D3D12_STENCIL_OP depthFailOp, D3D12_STENCIL_OP passOp, ComparisonFunc func) {
m_desc.DepthStencilState.FrontFace.StencilFailOp = failOp;
m_desc.DepthStencilState.FrontFace.StencilDepthFailOp = depthFailOp;
m_desc.DepthStencilState.FrontFace.StencilPassOp = passOp;
m_desc.DepthStencilState.FrontFace.StencilFunc = ToD3D12(func);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetBackFaceStencilOp(D3D12_STENCIL_OP failOp, D3D12_STENCIL_OP depthFailOp, D3D12_STENCIL_OP passOp, ComparisonFunc func) {
m_desc.DepthStencilState.BackFace.StencilFailOp = failOp;
m_desc.DepthStencilState.BackFace.StencilDepthFailOp = depthFailOp;
m_desc.DepthStencilState.BackFace.StencilPassOp = passOp;
m_desc.DepthStencilState.BackFace.StencilFunc = ToD3D12(func);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetBlendEnable(bool enable) {
m_desc.BlendState.RenderTarget[0].BlendEnable = enable ? TRUE : FALSE;
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetBlendFactor(BlendFactor srcBlend, BlendFactor dstBlend, BlendOp blendOp) {
m_desc.BlendState.RenderTarget[0].SrcBlend = ToD3D12(srcBlend);
m_desc.BlendState.RenderTarget[0].DestBlend = ToD3D12(dstBlend);
m_desc.BlendState.RenderTarget[0].BlendOp = ToD3D12(blendOp);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetAlphaBlendFactor(BlendFactor srcBlendAlpha, BlendFactor dstBlendAlpha, BlendOp blendOpAlpha) {
m_desc.BlendState.RenderTarget[0].SrcBlendAlpha = ToD3D12(srcBlendAlpha);
m_desc.BlendState.RenderTarget[0].DestBlendAlpha = ToD3D12(dstBlendAlpha);
m_desc.BlendState.RenderTarget[0].BlendOpAlpha = ToD3D12(blendOpAlpha);
return *this;
}
PipelineStateBuilder& PipelineStateBuilder::SetColorWriteMask(ColorWriteMask mask) {
m_desc.BlendState.RenderTarget[0].RenderTargetWriteMask = static_cast<UINT8>(mask);
return *this;
}
D3D12_GRAPHICS_PIPELINE_STATE_DESC PipelineStateBuilder::Build() {
return m_desc;
}
} // namespace RHI
} // namespace XCEngine

84
engine/src/RHI/D3D12/RootSignatureBuilder.cpp
View File

@@ -1,84 +0,0 @@
#include "XCEngine/RHI/D3D12/RootSignatureBuilder.h"
namespace XCEngine {
namespace RHI {
RootSignatureBuilder::RootSignatureBuilder() {
m_parameters.reserve(8);
m_descriptorRanges.reserve(8);
}
RootSignatureBuilder& RootSignatureBuilder::AddCBV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
m_parameters.push_back(param);
return *this;
}
RootSignatureBuilder& RootSignatureBuilder::AddSRV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
m_parameters.push_back(param);
return *this;
}
RootSignatureBuilder& RootSignatureBuilder::AddUAV(uint32_t shaderRegister, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
param.ShaderVisibility = ToD3D12(visibility);
param.Descriptor.RegisterSpace = registerSpace;
param.Descriptor.ShaderRegister = shaderRegister;
m_parameters.push_back(param);
return *this;
}
RootSignatureBuilder& RootSignatureBuilder::Add32BitConstants(uint32_t shaderRegister, uint32_t num32BitValues, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
param.ShaderVisibility = ToD3D12(visibility);
param.Constants.RegisterSpace = registerSpace;
param.Constants.ShaderRegister = shaderRegister;
param.Constants.Num32BitValues = num32BitValues;
m_parameters.push_back(param);
return *this;
}
RootSignatureBuilder& RootSignatureBuilder::AddDescriptorTable(uint32_t shaderRegister, uint32_t numDescriptors, D3D12_DESCRIPTOR_RANGE_TYPE rangeType, ShaderVisibility visibility, uint32_t registerSpace) {
D3D12_DESCRIPTOR_RANGE range = {};
range.RangeType = rangeType;
range.NumDescriptors = numDescriptors;
range.BaseShaderRegister = shaderRegister;
range.RegisterSpace = registerSpace;
range.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
std::vector<D3D12_DESCRIPTOR_RANGE> ranges;
ranges.push_back(range);
m_descriptorRanges.push_back(ranges);
D3D12_ROOT_PARAMETER param = {};
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
param.ShaderVisibility = ToD3D12(visibility);
param.DescriptorTable.NumDescriptorRanges = static_cast<UINT>(m_descriptorRanges.back().size());
param.DescriptorTable.pDescriptorRanges = m_descriptorRanges.back().data();
m_parameters.push_back(param);
return *this;
}
D3D12_ROOT_SIGNATURE_DESC RootSignatureBuilder::Build() {
D3D12_ROOT_SIGNATURE_DESC desc = {};
desc.NumParameters = static_cast<UINT>(m_parameters.size());
desc.pParameters = m_parameters.data();
desc.NumStaticSamplers = 0;
desc.pStaticSamplers = nullptr;
desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
return desc;
}
} // namespace RHI
} // namespace XCEngine