diff --git a/engine/include/XCEngine/RHI/D3D12/D3D12Enum.h b/engine/include/XCEngine/RHI/D3D12/D3D12Enum.h new file mode 100644 index 00000000..92288e51 --- /dev/null +++ b/engine/include/XCEngine/RHI/D3D12/D3D12Enum.h @@ -0,0 +1,135 @@ +#pragma once + +#include +#include "../Enums.h" + +namespace XCEngine { +namespace RHI { + +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; + } + return D3D12_FILL_MODE_SOLID; +} + +inline D3D12_CULL_MODE ToD3D12(CullMode mode) { + switch (mode) { + case CullMode::None: return D3D12_CULL_MODE_NONE; + case CullMode::Front: return D3D12_CULL_MODE_FRONT; + case CullMode::Back: return D3D12_CULL_MODE_BACK; + } + return D3D12_CULL_MODE_NONE; +} + +inline D3D12_COMPARISON_FUNC ToD3D12(ComparisonFunc func) { + switch (func) { + case ComparisonFunc::Never: return D3D12_COMPARISON_FUNC_NEVER; + case ComparisonFunc::Less: return D3D12_COMPARISON_FUNC_LESS; + case ComparisonFunc::Equal: return D3D12_COMPARISON_FUNC_EQUAL; + case ComparisonFunc::LessEqual: return D3D12_COMPARISON_FUNC_LESS_EQUAL; + case ComparisonFunc::Greater: return D3D12_COMPARISON_FUNC_GREATER; + case ComparisonFunc::NotEqual: return D3D12_COMPARISON_FUNC_NOT_EQUAL; + case ComparisonFunc::GreaterEqual: return D3D12_COMPARISON_FUNC_GREATER_EQUAL; + case ComparisonFunc::Always: return D3D12_COMPARISON_FUNC_ALWAYS; + } + return D3D12_COMPARISON_FUNC_ALWAYS; +} + +inline D3D12_BLEND_OP ToD3D12(BlendOp op) { + switch (op) { + case BlendOp::Add: return D3D12_BLEND_OP_ADD; + case BlendOp::Subtract: return D3D12_BLEND_OP_SUBTRACT; + case BlendOp::ReverseSubtract: return D3D12_BLEND_OP_REV_SUBTRACT; + case BlendOp::Min: return D3D12_BLEND_OP_MIN; + case BlendOp::Max: return D3D12_BLEND_OP_MAX; + } + return D3D12_BLEND_OP_ADD; +} + +inline D3D12_BLEND ToD3D12(BlendFactor factor) { + switch (factor) { + case BlendFactor::Zero: return D3D12_BLEND_ZERO; + case BlendFactor::One: return D3D12_BLEND_ONE; + case BlendFactor::SrcColor: return D3D12_BLEND_SRC_COLOR; + case BlendFactor::InvSrcColor: return D3D12_BLEND_INV_SRC_COLOR; + case BlendFactor::SrcAlpha: return D3D12_BLEND_SRC_ALPHA; + case BlendFactor::InvSrcAlpha: return D3D12_BLEND_INV_SRC_ALPHA; + case BlendFactor::SrcAlphaSat: return D3D12_BLEND_SRC_ALPHA_SAT; + case BlendFactor::BlendFactor: return D3D12_BLEND_BLEND_FACTOR; + case BlendFactor::InvBlendFactor: return D3D12_BLEND_INV_BLEND_FACTOR; + } + return D3D12_BLEND_ONE; +} + +inline D3D12_LOGIC_OP ToD3D12(LogicOp op) { + switch (op) { + case LogicOp::Clear: return D3D12_LOGIC_OP_CLEAR; + case LogicOp::Set: return D3D12_LOGIC_OP_SET; + case LogicOp::Copy: return D3D12_LOGIC_OP_COPY; + case LogicOp::CopyInverted: return D3D12_LOGIC_OP_COPY_INVERTED; + case LogicOp::Noop: return D3D12_LOGIC_OP_NOOP; + case LogicOp::Invert: return D3D12_LOGIC_OP_INVERT; + case LogicOp::And: return D3D12_LOGIC_OP_AND; + case LogicOp::Nand: return D3D12_LOGIC_OP_NAND; + case LogicOp::Or: return D3D12_LOGIC_OP_OR; + case LogicOp::Nor: return D3D12_LOGIC_OP_NOR; + case LogicOp::Xor: return D3D12_LOGIC_OP_XOR; + case LogicOp::Equiv: return D3D12_LOGIC_OP_EQUIV; + case LogicOp::AndReverse: return D3D12_LOGIC_OP_AND_REVERSE; + case LogicOp::AndInverted: return D3D12_LOGIC_OP_AND_INVERTED; + case LogicOp::OrReverse: return D3D12_LOGIC_OP_OR_REVERSE; + case LogicOp::OrInverted: return D3D12_LOGIC_OP_OR_INVERTED; + } + return D3D12_LOGIC_OP_NOOP; +} + +inline D3D12_FILTER ToD3D12(FilterMode mode) { + switch (mode) { + case FilterMode::Point: return D3D12_FILTER_MIN_MAG_MIP_POINT; + case FilterMode::Linear: return D3D12_FILTER_MIN_MAG_MIP_LINEAR; + case FilterMode::Anisotropic: return D3D12_FILTER_ANISOTROPIC; + case FilterMode::ComparisonPoint: return D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT; + case FilterMode::ComparisonLinear: return D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; + case FilterMode::ComparisonAnisotropic: return D3D12_FILTER_COMPARISON_ANISOTROPIC; + } + return D3D12_FILTER_MIN_MAG_MIP_LINEAR; +} + +inline D3D12_TEXTURE_ADDRESS_MODE ToD3D12(TextureAddressMode mode) { + switch (mode) { + case TextureAddressMode::Wrap: return D3D12_TEXTURE_ADDRESS_MODE_WRAP; + case TextureAddressMode::Mirror: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR; + case TextureAddressMode::Clamp: return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + case TextureAddressMode::Border: return D3D12_TEXTURE_ADDRESS_MODE_BORDER; + case TextureAddressMode::MirrorOnce: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; + } + return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; +} + +inline D3D12_STATIC_BORDER_COLOR ToD3D12(BorderColor color) { + switch (color) { + case BorderColor::TransparentBlack: return D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK; + case BorderColor::OpaqueBlack: return D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK; + case BorderColor::OpaqueWhite: return D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE; + } + return D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK; +} + +inline D3D12_SHADER_VISIBILITY ToD3D12(ShaderVisibility visibility) { + switch (visibility) { + case ShaderVisibility::All: return D3D12_SHADER_VISIBILITY_ALL; + case ShaderVisibility::Vertex: return D3D12_SHADER_VISIBILITY_VERTEX; + case ShaderVisibility::Hull: return D3D12_SHADER_VISIBILITY_HULL; + case ShaderVisibility::Domain: return D3D12_SHADER_VISIBILITY_DOMAIN; + case ShaderVisibility::Geometry: return D3D12_SHADER_VISIBILITY_GEOMETRY; + case ShaderVisibility::Pixel: return D3D12_SHADER_VISIBILITY_PIXEL; + case ShaderVisibility::Amplification: return D3D12_SHADER_VISIBILITY_AMPLIFICATION; + case ShaderVisibility::Mesh: return D3D12_SHADER_VISIBILITY_MESH; + } + return D3D12_SHADER_VISIBILITY_ALL; +} + +} // namespace RHI +} // namespace XCEngine diff --git a/engine/include/XCEngine/RHI/Enums.h b/engine/include/XCEngine/RHI/Enums.h index b38c9c78..5705b163 100644 --- a/engine/include/XCEngine/RHI/Enums.h +++ b/engine/include/XCEngine/RHI/Enums.h @@ -18,64 +18,64 @@ enum class ShaderType : uint8_t { }; enum class CullMode : uint8_t { - None = 1, - Front = 2, - Back = 3 + None, + Front, + Back }; enum class FillMode : uint8_t { - Wireframe = 2, - Solid = 3 + Wireframe, + Solid }; enum class BlendOp : uint8_t { - Add = 1, - Subtract = 2, - ReverseSubtract = 3, - Min = 4, - Max = 5 + Add, + Subtract, + ReverseSubtract, + Min, + Max }; enum class BlendFactor : uint8_t { - Zero = 0, - One = 1, - SrcColor = 2, - InvSrcColor = 3, - SrcAlpha = 4, - InvSrcAlpha = 5, - DstAlpha = 6, - InvDstAlpha = 7, - DstColor = 8, - InvDstColor = 9, - SrcAlphaSat = 10, - BlendFactor = 11, - InvBlendFactor = 12, - Src1Color = 13, - InvSrc1Color = 14, - Src1Alpha = 15, - InvSrc1Alpha = 16 + Zero, + One, + SrcColor, + InvSrcColor, + SrcAlpha, + InvSrcAlpha, + DstAlpha, + InvDstAlpha, + DstColor, + InvDstColor, + SrcAlphaSat, + BlendFactor, + InvBlendFactor, + Src1Color, + InvSrc1Color, + Src1Alpha, + InvSrc1Alpha }; enum class ComparisonFunc : uint8_t { - Never = 1, - Less = 2, - Equal = 3, - LessEqual = 4, - Greater = 5, - NotEqual = 6, - GreaterEqual = 7, - Always = 8 + Never, + Less, + Equal, + LessEqual, + Greater, + NotEqual, + GreaterEqual, + Always }; enum class StencilOp : uint8_t { - Keep = 1, - Zero = 2, - Replace = 3, - IncrSat = 4, - DecrSat = 5, - Invert = 6, - Incr = 7, - Decr = 8 + Keep, + Zero, + Replace, + IncrSat, + DecrSat, + Invert, + Incr, + Decr }; enum class TextureType : uint8_t { @@ -119,86 +119,86 @@ enum class CommandQueueType : uint8_t { }; enum class LoadAction : uint8_t { - Undefined = 0, - Load = 1, - Clear = 2 + Undefined, + Load, + Clear }; enum class StoreAction : uint8_t { - Undefined = 0, - Store = 1, - Resolve = 2, - StoreAndResolve = 3, - Discard = 4 + Undefined, + Store, + Resolve, + StoreAndResolve, + Discard }; enum class PresentFlags : uint8_t { - None = 0, - AllowTearing = 1, - StrictlyTimedFrame = 2, - AllowDisplayLatencyWaitableObject = 4 + None, + AllowTearing, + StrictlyTimedFrame, + AllowDisplayLatencyWaitableObject }; enum class PrimitiveTopology : uint8_t { - Undefined = 0, - PointList = 1, - LineList = 2, - LineStrip = 3, - TriangleList = 4, - TriangleStrip = 5, - LineListAdj = 10, - LineStripAdj = 11, - TriangleListAdj = 12, - TriangleStripAdj = 13, - PatchList = 33 + Undefined, + PointList, + LineList, + LineStrip, + TriangleList, + TriangleStrip, + LineListAdj, + LineStripAdj, + TriangleListAdj, + TriangleStripAdj, + PatchList }; enum class FilterMode : uint8_t { - Point = 0, - Linear = 1, - Anisotropic = 2, - ComparisonPoint = 3, - ComparisonLinear = 4, - ComparisonAnisotropic = 5, - MinimumPoint = 7, - MinimumLinear = 8, - MinimumAnisotropic = 9, - MaximumPoint = 11, - MaximumLinear = 12, - MaximumAnisotropic = 13 + Point, + Linear, + Anisotropic, + ComparisonPoint, + ComparisonLinear, + ComparisonAnisotropic, + MinimumPoint, + MinimumLinear, + MinimumAnisotropic, + MaximumPoint, + MaximumLinear, + MaximumAnisotropic }; enum class TextureAddressMode : uint8_t { - Wrap = 1, - Mirror = 2, - Clamp = 3, - Border = 4, - MirrorOnce = 5 + Wrap, + Mirror, + Clamp, + Border, + MirrorOnce }; enum class BorderColor : uint8_t { - TransparentBlack = 0, - OpaqueBlack = 1, - OpaqueWhite = 2 + TransparentBlack, + OpaqueBlack, + OpaqueWhite }; enum class LogicOp : uint8_t { - Clear = 0, - Set = 1, - Copy = 2, - CopyInverted = 3, - Noop = 4, - Invert = 5, - And = 6, - Nand = 7, - Or = 8, - Nor = 9, - Xor = 10, - Equiv = 11, - AndReverse = 12, - AndInverted = 13, - OrReverse = 14, - OrInverted = 15 + Clear, + Set, + Copy, + CopyInverted, + Noop, + Invert, + And, + Nand, + Or, + Nor, + Xor, + Equiv, + AndReverse, + AndInverted, + OrReverse, + OrInverted }; enum class ColorWriteMask : uint8_t { @@ -214,14 +214,14 @@ inline ColorWriteMask operator|(ColorWriteMask a, ColorWriteMask b) { } enum class ShaderVisibility : uint8_t { - All = 0, - Vertex = 1, - Hull = 2, - Domain = 3, - Geometry = 4, - Pixel = 5, - Amplification = 6, - Mesh = 7 + All, + Vertex, + Hull, + Domain, + Geometry, + Pixel, + Amplification, + Mesh }; enum class RootParameterType : uint8_t { @@ -246,26 +246,26 @@ enum class QueryType : uint8_t { }; enum class Format : uint32_t { - Unknown = 0, - R8_UNorm = 61, - R8G8_UNorm = 49, - R8G8B8A8_UNorm = 28, - R16G16B16A16_Float = 10, - R32G32B32A32_Float = 2, - R16_Float = 54, - R32_Float = 41, - D16_UNorm = 55, - D24_UNorm_S8_UInt = 45, - D32_Float = 40, - BC1_UNorm = 71, - BC2_UNorm = 74, - BC3_UNorm = 77, - BC4_UNorm = 80, - BC5_UNorm = 83, - BC6H_UF16 = 95, - BC7_UNorm = 98, - R32G32B32A32_UInt = 23, - R32_UInt = 39 + Unknown, + R8_UNorm, + R8G8_UNorm, + R8G8B8A8_UNorm, + R16G16B16A16_Float, + R32G32B32A32_Float, + R16_Float, + R32_Float, + D16_UNorm, + D24_UNorm_S8_UInt, + D32_Float, + BC1_UNorm, + BC2_UNorm, + BC3_UNorm, + BC4_UNorm, + BC5_UNorm, + BC6H_UF16, + BC7_UNorm, + R32G32B32A32_UInt, + R32_UInt }; } // namespace RHI diff --git a/tests/D3D12/CMakeLists.txt b/tests/D3D12/CMakeLists.txt index 4c1805aa..c89e173b 100644 --- a/tests/D3D12/CMakeLists.txt +++ b/tests/D3D12/CMakeLists.txt @@ -14,8 +14,9 @@ target_compile_definitions(D3D12 PRIVATE ) target_include_directories(D3D12 PRIVATE - ${CMAKE_SOURCE_DIR}/tests/D3D12 - ${CMAKE_SOURCE_DIR}/tests/D3D12/stbi + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/stbi + D:/Xuanchi/高斯泼溅/XCEngine/engine/include ) target_link_libraries(D3D12 PRIVATE diff --git a/tests/D3D12/RHI/Enums.h b/tests/D3D12/RHI/Enums.h deleted file mode 100644 index b38c9c78..00000000 --- a/tests/D3D12/RHI/Enums.h +++ /dev/null @@ -1,272 +0,0 @@ -#pragma once - -#include - -namespace XCEngine { -namespace RHI { - -enum class ShaderType : uint8_t { - Vertex, - Hull, - Domain, - Geometry, - Pixel, - Compute, - Amplification, - Mesh, - Library -}; - -enum class CullMode : uint8_t { - None = 1, - Front = 2, - Back = 3 -}; - -enum class FillMode : uint8_t { - Wireframe = 2, - Solid = 3 -}; - -enum class BlendOp : uint8_t { - Add = 1, - Subtract = 2, - ReverseSubtract = 3, - Min = 4, - Max = 5 -}; - -enum class BlendFactor : uint8_t { - Zero = 0, - One = 1, - SrcColor = 2, - InvSrcColor = 3, - SrcAlpha = 4, - InvSrcAlpha = 5, - DstAlpha = 6, - InvDstAlpha = 7, - DstColor = 8, - InvDstColor = 9, - SrcAlphaSat = 10, - BlendFactor = 11, - InvBlendFactor = 12, - Src1Color = 13, - InvSrc1Color = 14, - Src1Alpha = 15, - InvSrc1Alpha = 16 -}; - -enum class ComparisonFunc : uint8_t { - Never = 1, - Less = 2, - Equal = 3, - LessEqual = 4, - Greater = 5, - NotEqual = 6, - GreaterEqual = 7, - Always = 8 -}; - -enum class StencilOp : uint8_t { - Keep = 1, - Zero = 2, - Replace = 3, - IncrSat = 4, - DecrSat = 5, - Invert = 6, - Incr = 7, - Decr = 8 -}; - -enum class TextureType : uint8_t { - Texture1D, - Texture2D, - Texture2DArray, - Texture3D, - TextureCube, - TextureCubeArray -}; - -enum class BufferType : uint8_t { - Vertex, - Index, - Constant, - ReadBack, - Indirect, - RaytracingAccelerationStructure, - ShaderBindingTable -}; - -enum class DescriptorType : uint8_t { - CBV, - SRV, - UAV, - Sampler, - RTV, - DSV -}; - -enum class PipelineType : uint8_t { - Graphics, - Compute, - Raytracing -}; - -enum class CommandQueueType : uint8_t { - Direct, - Compute, - Copy -}; - -enum class LoadAction : uint8_t { - Undefined = 0, - Load = 1, - Clear = 2 -}; - -enum class StoreAction : uint8_t { - Undefined = 0, - Store = 1, - Resolve = 2, - StoreAndResolve = 3, - Discard = 4 -}; - -enum class PresentFlags : uint8_t { - None = 0, - AllowTearing = 1, - StrictlyTimedFrame = 2, - AllowDisplayLatencyWaitableObject = 4 -}; - -enum class PrimitiveTopology : uint8_t { - Undefined = 0, - PointList = 1, - LineList = 2, - LineStrip = 3, - TriangleList = 4, - TriangleStrip = 5, - LineListAdj = 10, - LineStripAdj = 11, - TriangleListAdj = 12, - TriangleStripAdj = 13, - PatchList = 33 -}; - -enum class FilterMode : uint8_t { - Point = 0, - Linear = 1, - Anisotropic = 2, - ComparisonPoint = 3, - ComparisonLinear = 4, - ComparisonAnisotropic = 5, - MinimumPoint = 7, - MinimumLinear = 8, - MinimumAnisotropic = 9, - MaximumPoint = 11, - MaximumLinear = 12, - MaximumAnisotropic = 13 -}; - -enum class TextureAddressMode : uint8_t { - Wrap = 1, - Mirror = 2, - Clamp = 3, - Border = 4, - MirrorOnce = 5 -}; - -enum class BorderColor : uint8_t { - TransparentBlack = 0, - OpaqueBlack = 1, - OpaqueWhite = 2 -}; - -enum class LogicOp : uint8_t { - Clear = 0, - Set = 1, - Copy = 2, - CopyInverted = 3, - Noop = 4, - Invert = 5, - And = 6, - Nand = 7, - Or = 8, - Nor = 9, - Xor = 10, - Equiv = 11, - AndReverse = 12, - AndInverted = 13, - OrReverse = 14, - OrInverted = 15 -}; - -enum class ColorWriteMask : uint8_t { - Red = 1, - Green = 2, - Blue = 4, - Alpha = 8, - All = 15 -}; - -inline ColorWriteMask operator|(ColorWriteMask a, ColorWriteMask b) { - return static_cast(static_cast(a) | static_cast(b)); -} - -enum class ShaderVisibility : uint8_t { - All = 0, - Vertex = 1, - Hull = 2, - Domain = 3, - Geometry = 4, - Pixel = 5, - Amplification = 6, - Mesh = 7 -}; - -enum class RootParameterType : uint8_t { - DescriptorTable, - Constants, - CBV, - SRV, - UAV -}; - -enum class DescriptorHeapType : uint8_t { - CBV_SRV_UAV, - Sampler, - RTV, - DSV -}; - -enum class QueryType : uint8_t { - Occlusion, - Timestamp, - PipelineStatistics -}; - -enum class Format : uint32_t { - Unknown = 0, - R8_UNorm = 61, - R8G8_UNorm = 49, - R8G8B8A8_UNorm = 28, - R16G16B16A16_Float = 10, - R32G32B32A32_Float = 2, - R16_Float = 54, - R32_Float = 41, - D16_UNorm = 55, - D24_UNorm_S8_UInt = 45, - D32_Float = 40, - BC1_UNorm = 71, - BC2_UNorm = 74, - BC3_UNorm = 77, - BC4_UNorm = 80, - BC5_UNorm = 83, - BC6H_UF16 = 95, - BC7_UNorm = 98, - R32G32B32A32_UInt = 23, - R32_UInt = 39 -}; - -} // namespace RHI -} // namespace XCEngine diff --git a/tests/D3D12/main.cpp b/tests/D3D12/main.cpp index c9e0faf7..9b90049c 100644 --- a/tests/D3D12/main.cpp +++ b/tests/D3D12/main.cpp @@ -11,7 +11,8 @@ #include #include #include "stbi/stb_image.h" -#include "RHI/Enums.h" +#include "XCEngine/RHI/Enums.h" +#include "XCEngine/RHI/D3D12/D3D12Enum.h" using namespace XCEngine::RHI; @@ -208,13 +209,13 @@ D3D12_RESOURCE_BARRIER InitResourceBarrier( ID3D12RootSignature* InitRootSignature() { D3D12_ROOT_PARAMETER rootParameters[4]; rootParameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; - rootParameters[1].ShaderVisibility = static_cast(ShaderVisibility::Vertex); + rootParameters[1].ShaderVisibility = ToD3D12(ShaderVisibility::Vertex); rootParameters[1].Constants.RegisterSpace = 0; rootParameters[1].Constants.ShaderRegister = 0; rootParameters[1].Constants.Num32BitValues = 4; rootParameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; - rootParameters[0].ShaderVisibility = static_cast(ShaderVisibility::All); + rootParameters[0].ShaderVisibility = ToD3D12(ShaderVisibility::All); rootParameters[0].Descriptor.RegisterSpace = 0; rootParameters[0].Descriptor.ShaderRegister = 1; @@ -226,26 +227,26 @@ ID3D12RootSignature* InitRootSignature() { descriptorRange[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND; rootParameters[2].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; - rootParameters[2].ShaderVisibility = static_cast(ShaderVisibility::Pixel); + rootParameters[2].ShaderVisibility = ToD3D12(ShaderVisibility::Pixel); rootParameters[2].DescriptorTable.pDescriptorRanges = descriptorRange; rootParameters[2].DescriptorTable.NumDescriptorRanges = _countof(descriptorRange); rootParameters[3].ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV; - rootParameters[3].ShaderVisibility = static_cast(ShaderVisibility::All); + rootParameters[3].ShaderVisibility = ToD3D12(ShaderVisibility::All); rootParameters[3].Descriptor.RegisterSpace = 1; rootParameters[3].Descriptor.ShaderRegister = 0; D3D12_STATIC_SAMPLER_DESC samplerDesc[1]; memset(samplerDesc, 0, sizeof(D3D12_STATIC_SAMPLER_DESC) * _countof(samplerDesc)); - samplerDesc[0].Filter = static_cast(FilterMode::Linear); - samplerDesc[0].AddressU = static_cast(TextureAddressMode::Clamp); - samplerDesc[0].AddressV = static_cast(TextureAddressMode::Clamp); - samplerDesc[0].AddressW = static_cast(TextureAddressMode::Clamp); - samplerDesc[0].BorderColor = static_cast(BorderColor::OpaqueBlack); + samplerDesc[0].Filter = ToD3D12(FilterMode::Linear); + samplerDesc[0].AddressU = ToD3D12(TextureAddressMode::Clamp); + samplerDesc[0].AddressV = ToD3D12(TextureAddressMode::Clamp); + samplerDesc[0].AddressW = ToD3D12(TextureAddressMode::Clamp); + samplerDesc[0].BorderColor = ToD3D12(BorderColor::OpaqueBlack); samplerDesc[0].MaxLOD = D3D12_FLOAT32_MAX; samplerDesc[0].RegisterSpace = 0; samplerDesc[0].ShaderRegister = 0; - samplerDesc[0].ShaderVisibility = static_cast(ShaderVisibility::Pixel); + samplerDesc[0].ShaderVisibility = ToD3D12(ShaderVisibility::Pixel); D3D12_ROOT_SIGNATURE_DESC rootSignatureDesc = {}; rootSignatureDesc.NumParameters = _countof(rootParameters); @@ -515,20 +516,20 @@ ID3D12PipelineState* CreatePSO(ID3D12RootSignature* inID3D12RootSignature, psoDesc.InputLayout = vertexDataLayoutDesc; psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; - psoDesc.RasterizerState.FillMode = static_cast(FillMode::Solid); - psoDesc.RasterizerState.CullMode = static_cast(CullMode::Back); + psoDesc.RasterizerState.FillMode = ToD3D12(FillMode::Solid); + psoDesc.RasterizerState.CullMode = ToD3D12(CullMode::Back); psoDesc.RasterizerState.DepthClipEnable = TRUE; psoDesc.DepthStencilState.DepthEnable = true; psoDesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; - psoDesc.DepthStencilState.DepthFunc = static_cast(ComparisonFunc::LessEqual); + psoDesc.DepthStencilState.DepthFunc = ToD3D12(ComparisonFunc::LessEqual); psoDesc.BlendState = { 0 }; D3D12_RENDER_TARGET_BLEND_DESC rtBlendDesc = { FALSE,FALSE, - static_cast(BlendFactor::SrcAlpha),static_cast(BlendFactor::InvSrcAlpha),static_cast(BlendOp::Add), - static_cast(BlendFactor::SrcAlpha),static_cast(BlendFactor::InvSrcAlpha),static_cast(BlendOp::Add), - static_cast(LogicOp::Noop), + ToD3D12(BlendFactor::SrcAlpha),ToD3D12(BlendFactor::InvSrcAlpha),ToD3D12(BlendOp::Add), + ToD3D12(BlendFactor::SrcAlpha),ToD3D12(BlendFactor::InvSrcAlpha),ToD3D12(BlendOp::Add), + ToD3D12(LogicOp::Noop), static_cast(ColorWriteMask::All), }; for (int i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)