From 8c096fa8d99b47a313e81c48c9fa868bd3eb917e Mon Sep 17 00:00:00 2001 From: Egor Yusov Date: Sat, 23 Nov 2019 18:28:06 -0800 Subject: clang-formatted GraphicsEngineD3DBase project --- Graphics/GraphicsEngineD3DBase/include/D3DErrors.h | 80 +- .../include/D3DShaderResourceLoader.h | 447 +++++----- .../include/D3DTypeConversionImpl.h | 931 +++++++++++---------- .../include/D3DViewDescConversionImpl.h | 484 +++++------ .../include/DXGITypeConversions.h | 9 +- .../include/EngineFactoryD3DBase.h | 98 ++- .../include/RenderDeviceD3DBase.h | 14 +- .../GraphicsEngineD3DBase/include/ShaderD3DBase.h | 22 +- .../include/ShaderResources.h | 293 ++++--- .../include/ShaderVariableD3DBase.h | 80 +- .../include/SwapChainD3DBase.h | 324 +++---- .../GraphicsEngineD3DBase/interface/ShaderD3D.h | 6 +- .../src/DXGITypeConversions.cpp | 398 ++++----- .../GraphicsEngineD3DBase/src/ShaderD3DBase.cpp | 131 +-- .../GraphicsEngineD3DBase/src/ShaderResources.cpp | 147 ++-- 15 files changed, 1766 insertions(+), 1698 deletions(-) (limited to 'Graphics/GraphicsEngineD3DBase') diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h b/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h index 81c478a3..fdc3689f 100644 --- a/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h +++ b/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h @@ -35,64 +35,66 @@ namespace Diligent class ComErrorDesc { public: - ComErrorDesc( HRESULT hr ) + ComErrorDesc(HRESULT hr) { - FormatMessageA( - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, + FormatMessageA( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr, - MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), m_Msg, _countof(m_Msg), - NULL ); - auto nLen = strlen( m_Msg ); - if( nLen > 1 && m_Msg[nLen - 1] == '\n' ) + NULL); + auto nLen = strlen(m_Msg); + if (nLen > 1 && m_Msg[nLen - 1] == '\n') { m_Msg[nLen - 1] = 0; - if( m_Msg[nLen - 2] == '\r' ) + if (m_Msg[nLen - 2] == '\r') { m_Msg[nLen - 2] = 0; } } } - const char* Get(){ return m_Msg; } + const char* Get() { return m_Msg; } private: char m_Msg[4096]; }; -} +} // namespace Diligent -#define CHECK_D3D_RESULT_THROW(Expr, Message)\ -do{ \ - HRESULT _hr_ = Expr; \ - if(FAILED(_hr_)) \ - { \ - ComErrorDesc ErrDesc( _hr_ ); \ - LOG_ERROR_AND_THROW( Message, "\nHRESULT Desc: ", ErrDesc.Get());\ - } \ -}while(false) +#define CHECK_D3D_RESULT_THROW(Expr, Message) \ + do \ + { \ + HRESULT _hr_ = Expr; \ + if (FAILED(_hr_)) \ + { \ + ComErrorDesc ErrDesc(_hr_); \ + LOG_ERROR_AND_THROW(Message, "\nHRESULT Desc: ", ErrDesc.Get()); \ + } \ + } while (false) -#define CHECK_D3D_RESULT_THROW_EX(Expr, ...)\ -do{ \ - HRESULT _hr_ = Expr; \ - if(FAILED(_hr_)) \ - { \ - auto msg = Diligent::FormatString(__VA_ARGS__); \ - ComErrorDesc ErrDesc( _hr_ ); \ - LOG_ERROR_AND_THROW( msg, "\nHRESULT Desc: ", ErrDesc.Get());\ - } \ -}while(false) +#define CHECK_D3D_RESULT_THROW_EX(Expr, ...) \ + do \ + { \ + HRESULT _hr_ = Expr; \ + if (FAILED(_hr_)) \ + { \ + auto msg = Diligent::FormatString(__VA_ARGS__); \ + ComErrorDesc ErrDesc(_hr_); \ + LOG_ERROR_AND_THROW(msg, "\nHRESULT Desc: ", ErrDesc.Get()); \ + } \ + } while (false) -#define LOG_D3D_ERROR(Expr, Message)\ -do{ \ - HRESULT _hr_ = Expr; \ - if(FAILED(_hr_)) \ - { \ - ComErrorDesc ErrDesc( _hr_ ); \ - LOG_ERROR_MESSAGE( Message, "\nHRESULT Desc: ", ErrDesc.Get());\ - } \ -}while(false) +#define LOG_D3D_ERROR(Expr, Message) \ + do \ + { \ + HRESULT _hr_ = Expr; \ + if (FAILED(_hr_)) \ + { \ + ComErrorDesc ErrDesc(_hr_); \ + LOG_ERROR_MESSAGE(Message, "\nHRESULT Desc: ", ErrDesc.Get()); \ + } \ + } while (false) diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h index 008b41af..35562249 100644 --- a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h +++ b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h @@ -35,261 +35,268 @@ namespace Diligent { - struct D3DShaderResourceCounters - { - Uint32 NumCBs = 0; - Uint32 NumTexSRVs = 0; - Uint32 NumTexUAVs = 0; - Uint32 NumBufSRVs = 0; - Uint32 NumBufUAVs = 0; - Uint32 NumSamplers = 0; - }; - - template - void LoadD3DShaderResources(ID3DBlob* pShaderByteCode, - THandleShaderDesc HandleShaderDesc, - TOnResourcesCounted OnResourcesCounted, - TOnNewCB OnNewCB, - TOnNewTexUAV OnNewTexUAV, - TOnNewBuffUAV OnNewBuffUAV, - TOnNewBuffSRV OnNewBuffSRV, - TOnNewSampler OnNewSampler, - TOnNewTexSRV OnNewTexSRV) + +struct D3DShaderResourceCounters +{ + Uint32 NumCBs = 0; + Uint32 NumTexSRVs = 0; + Uint32 NumTexUAVs = 0; + Uint32 NumBufSRVs = 0; + Uint32 NumBufUAVs = 0; + Uint32 NumSamplers = 0; +}; + +template +void LoadD3DShaderResources(ID3DBlob* pShaderByteCode, + THandleShaderDesc HandleShaderDesc, + TOnResourcesCounted OnResourcesCounted, + TOnNewCB OnNewCB, + TOnNewTexUAV OnNewTexUAV, + TOnNewBuffUAV OnNewBuffUAV, + TOnNewBuffSRV OnNewBuffSRV, + TOnNewSampler OnNewSampler, + TOnNewTexSRV OnNewTexSRV) +{ + CComPtr pShaderReflection; + + auto hr = D3DReflect(pShaderByteCode->GetBufferPointer(), pShaderByteCode->GetBufferSize(), __uuidof(pShaderReflection), reinterpret_cast(static_cast(&pShaderReflection))); + CHECK_D3D_RESULT_THROW(hr, "Failed to get the shader reflection"); + + D3D_SHADER_DESC shaderDesc = {}; + pShaderReflection->GetDesc(&shaderDesc); + + HandleShaderDesc(shaderDesc); + + std::vector> Resources(STD_ALLOCATOR_RAW_MEM(D3DShaderResourceAttribs, GetRawAllocator(), "Allocator for vector")); + Resources.reserve(shaderDesc.BoundResources); + std::unordered_set ResourceNamesTmpPool; + + D3DShaderResourceCounters RC; + + size_t ResourceNamesPoolSize = 0; + // Number of resources to skip (used for array resources) + UINT SkipCount = 1; + for (UINT Res = 0; Res < shaderDesc.BoundResources; Res += SkipCount) { - CComPtr pShaderReflection; - auto hr = D3DReflect( pShaderByteCode->GetBufferPointer(), pShaderByteCode->GetBufferSize(), __uuidof(pShaderReflection), reinterpret_cast(static_cast(&pShaderReflection))); - CHECK_D3D_RESULT_THROW(hr, "Failed to get the shader reflection" ); - - D3D_SHADER_DESC shaderDesc = {}; - pShaderReflection->GetDesc( &shaderDesc ); - - HandleShaderDesc(shaderDesc); - - std::vector > Resources( STD_ALLOCATOR_RAW_MEM(D3DShaderResourceAttribs, GetRawAllocator(), "Allocator for vector") ); - Resources.reserve(shaderDesc.BoundResources); - std::unordered_set ResourceNamesTmpPool; - - D3DShaderResourceCounters RC; - size_t ResourceNamesPoolSize = 0; - // Number of resources to skip (used for array resources) - UINT SkipCount = 1; - for (UINT Res = 0; Res < shaderDesc.BoundResources; Res += SkipCount) + D3D_SHADER_INPUT_BIND_DESC BindingDesc = {}; + pShaderReflection->GetResourceBindingDesc(Res, &BindingDesc); + + std::string Name(BindingDesc.Name); + + SkipCount = 1; + + UINT BindCount = BindingDesc.BindCount; + + // Handle arrays + // For shader models 5_0 and before, every resource array element is enumerated individually. + // For instance, if the following texture array is defined in the shader: + // + // Texture2D g_tex2DDiffuse[4]; + // + // The reflection system will enumerate 4 resources with the following names: + // "g_tex2DDiffuse[0]" + // "g_tex2DDiffuse[1]" + // "g_tex2DDiffuse[2]" + // "g_tex2DDiffuse[3]" + // + // Notice that if some array element is not used by the shader, it will not be enumerated + + auto OpenBracketPos = Name.find('['); + if (String::npos != OpenBracketPos) { - D3D_SHADER_INPUT_BIND_DESC BindingDesc = {}; - pShaderReflection->GetResourceBindingDesc( Res, &BindingDesc ); - - std::string Name(BindingDesc.Name); - - SkipCount = 1; - - UINT BindCount = BindingDesc.BindCount; - - // Handle arrays - // For shader models 5_0 and before, every resource array element is enumerated individually. - // For instance, if the following texture array is defined in the shader: - // - // Texture2D g_tex2DDiffuse[4]; - // - // The reflection system will enumerate 4 resources with the following names: - // "g_tex2DDiffuse[0]" - // "g_tex2DDiffuse[1]" - // "g_tex2DDiffuse[2]" - // "g_tex2DDiffuse[3]" - // - // Notice that if some array element is not used by the shader, it will not be enumerated - - auto OpenBracketPos = Name.find('['); - if (String::npos != OpenBracketPos) - { - VERIFY(BindCount == 1, "When array elements are enumerated individually, BindCount is expected to always be 1"); - - // Name == "g_tex2DDiffuse[0]" - // ^ - // OpenBracketPos - Name.erase(OpenBracketPos, Name.length() - OpenBracketPos); - // Name == "g_tex2DDiffuse" - VERIFY_EXPR(Name.length() == OpenBracketPos); + VERIFY(BindCount == 1, "When array elements are enumerated individually, BindCount is expected to always be 1"); + + // Name == "g_tex2DDiffuse[0]" + // ^ + // OpenBracketPos + Name.erase(OpenBracketPos, Name.length() - OpenBracketPos); + // Name == "g_tex2DDiffuse" + VERIFY_EXPR(Name.length() == OpenBracketPos); #ifdef _DEBUG - for (const auto& ExistingRes : Resources) + for (const auto& ExistingRes : Resources) + { + VERIFY(Name.compare(ExistingRes.Name) != 0, "Resource with the same name has already been enumerated. All array elements are expected to be enumerated one after another"); + } +#endif + for (UINT ArrElem = Res + 1; ArrElem < shaderDesc.BoundResources; ++ArrElem) + { + D3D_SHADER_INPUT_BIND_DESC ArrElemBindingDesc = {}; + pShaderReflection->GetResourceBindingDesc(ArrElem, &ArrElemBindingDesc); + + // Make sure this case is handled correctly: + // "g_tex2DDiffuse[.]" != "g_tex2DDiffuse2[.]" + if (strncmp(Name.c_str(), ArrElemBindingDesc.Name, OpenBracketPos) == 0 && ArrElemBindingDesc.Name[OpenBracketPos] == '[') { - VERIFY(Name.compare(ExistingRes.Name) != 0, "Resource with the same name has already been enumerated. All array elements are expected to be enumerated one after another"); + //g_tex2DDiffuse[2] + // ^ + UINT Ind = atoi(ArrElemBindingDesc.Name + OpenBracketPos + 1); + BindCount = std::max(BindCount, Ind + 1); + VERIFY(ArrElemBindingDesc.BindPoint == BindingDesc.BindPoint + Ind, + "Array elements are expected to use contigous bind points.\n", + BindingDesc.Name, " uses slot ", BindingDesc.BindPoint, ", so ", ArrElemBindingDesc.Name, + " is expected to use slot ", BindingDesc.BindPoint + Ind, " while ", ArrElemBindingDesc.BindPoint, + " is actually used"); + + // Note that skip count may not necessarily be the same as BindCount. + // If some array elements are not used by the shader, the reflection system skips them + ++SkipCount; } -#endif - for (UINT ArrElem = Res+1; ArrElem < shaderDesc.BoundResources; ++ArrElem) + else { - D3D_SHADER_INPUT_BIND_DESC ArrElemBindingDesc = {}; - pShaderReflection->GetResourceBindingDesc( ArrElem, &ArrElemBindingDesc ); - - // Make sure this case is handled correctly: - // "g_tex2DDiffuse[.]" != "g_tex2DDiffuse2[.]" - if ( strncmp(Name.c_str(), ArrElemBindingDesc.Name, OpenBracketPos) == 0 && ArrElemBindingDesc.Name[OpenBracketPos] == '[') - { - //g_tex2DDiffuse[2] - // ^ - UINT Ind = atoi(ArrElemBindingDesc.Name+OpenBracketPos+1); - BindCount = std::max(BindCount, Ind+1); - VERIFY(ArrElemBindingDesc.BindPoint == BindingDesc.BindPoint + Ind, - "Array elements are expected to use contigous bind points.\n", - BindingDesc.Name, " uses slot ", BindingDesc.BindPoint, ", so ", ArrElemBindingDesc.Name, " is expected to use slot ", BindingDesc.BindPoint + Ind, " while ", ArrElemBindingDesc.BindPoint, " is actually used" ); - - // Note that skip count may not necessarily be the same as BindCount. - // If some array elements are not used by the shader, the reflection system skips them - ++SkipCount; - } - else - { - break; - } + break; } } + } - switch( BindingDesc.Type ) - { - case D3D_SIT_CBUFFER: ++RC.NumCBs; break; - case D3D_SIT_TBUFFER: UNSUPPORTED( "TBuffers are not supported" ); break; - case D3D_SIT_TEXTURE: ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufSRVs : RC.NumTexSRVs); break; - case D3D_SIT_SAMPLER: ++RC.NumSamplers; break; - case D3D_SIT_UAV_RWTYPED: ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufUAVs : RC.NumTexUAVs); break; - case D3D_SIT_STRUCTURED: ++RC.NumBufSRVs; break; - case D3D_SIT_UAV_RWSTRUCTURED: ++RC.NumBufUAVs; break; - case D3D_SIT_BYTEADDRESS: ++RC.NumBufSRVs; break; - case D3D_SIT_UAV_RWBYTEADDRESS: ++RC.NumBufUAVs; break; - case D3D_SIT_UAV_APPEND_STRUCTURED: UNSUPPORTED( "Append structured buffers are not supported" ); break; - case D3D_SIT_UAV_CONSUME_STRUCTURED: UNSUPPORTED( "Consume structured buffers are not supported" ); break; - case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" ); break; - default: UNEXPECTED("Unexpected resource type"); - } - ResourceNamesPoolSize += Name.length() + 1; - auto it = ResourceNamesTmpPool.emplace(std::move(Name)); - Resources.emplace_back( - it.first->c_str(), - BindingDesc.BindPoint, - BindCount, - BindingDesc.Type, - BindingDesc.Dimension, - D3DShaderResourceAttribs::InvalidSamplerId - ); + switch (BindingDesc.Type) + { + // clang-format off + case D3D_SIT_CBUFFER: ++RC.NumCBs; break; + case D3D_SIT_TBUFFER: UNSUPPORTED( "TBuffers are not supported" ); break; + case D3D_SIT_TEXTURE: ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufSRVs : RC.NumTexSRVs); break; + case D3D_SIT_SAMPLER: ++RC.NumSamplers; break; + case D3D_SIT_UAV_RWTYPED: ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufUAVs : RC.NumTexUAVs); break; + case D3D_SIT_STRUCTURED: ++RC.NumBufSRVs; break; + case D3D_SIT_UAV_RWSTRUCTURED: ++RC.NumBufUAVs; break; + case D3D_SIT_BYTEADDRESS: ++RC.NumBufSRVs; break; + case D3D_SIT_UAV_RWBYTEADDRESS: ++RC.NumBufUAVs; break; + case D3D_SIT_UAV_APPEND_STRUCTURED: UNSUPPORTED( "Append structured buffers are not supported" ); break; + case D3D_SIT_UAV_CONSUME_STRUCTURED: UNSUPPORTED( "Consume structured buffers are not supported" ); break; + case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" ); break; + // clang-format on + default: UNEXPECTED("Unexpected resource type"); } + ResourceNamesPoolSize += Name.length() + 1; + auto it = ResourceNamesTmpPool.emplace(std::move(Name)); + Resources.emplace_back( + it.first->c_str(), + BindingDesc.BindPoint, + BindCount, + BindingDesc.Type, + BindingDesc.Dimension, + D3DShaderResourceAttribs::InvalidSamplerId); + } - OnResourcesCounted(RC, ResourceNamesPoolSize); + OnResourcesCounted(RC, ResourceNamesPoolSize); - std::vector > TexSRVInds( STD_ALLOCATOR_RAW_MEM(size_t, GetRawAllocator(), "Allocator for vector") ); - TexSRVInds.reserve(RC.NumTexSRVs); + std::vector> TexSRVInds(STD_ALLOCATOR_RAW_MEM(size_t, GetRawAllocator(), "Allocator for vector")); + TexSRVInds.reserve(RC.NumTexSRVs); - for (size_t ResInd = 0; ResInd < Resources.size(); ++ResInd) + for (size_t ResInd = 0; ResInd < Resources.size(); ++ResInd) + { + const auto& Res = Resources[ResInd]; + switch (Res.GetInputType()) { - const auto& Res = Resources[ResInd]; - switch (Res.GetInputType()) + case D3D_SIT_CBUFFER: + { + OnNewCB(Res); + break; + } + + case D3D_SIT_TBUFFER: { - case D3D_SIT_CBUFFER: + UNSUPPORTED("TBuffers are not supported"); + break; + } + + case D3D_SIT_TEXTURE: + { + if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER) { - OnNewCB( Res ); - break; + OnNewBuffSRV(Res); } - - case D3D_SIT_TBUFFER: + else { - UNSUPPORTED( "TBuffers are not supported" ); - break; + // Texture SRVs must be processed all samplers are initialized + TexSRVInds.push_back(ResInd); } + break; + } - case D3D_SIT_TEXTURE: - { - if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER) - { - OnNewBuffSRV( Res ); - } - else - { - // Texture SRVs must be processed all samplers are initialized - TexSRVInds.push_back(ResInd); - } - break; - } + case D3D_SIT_SAMPLER: + { + OnNewSampler(Res); + break; + } - case D3D_SIT_SAMPLER: + case D3D_SIT_UAV_RWTYPED: + { + if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER) { - OnNewSampler( Res ); - break; + OnNewBuffUAV(Res); } - - case D3D_SIT_UAV_RWTYPED: + else { - if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER) - { - OnNewBuffUAV( Res ); - } - else - { - OnNewTexUAV( Res ); - } - break; + OnNewTexUAV(Res); } + break; + } - case D3D_SIT_STRUCTURED: - { - OnNewBuffSRV( Res ); - break; - } + case D3D_SIT_STRUCTURED: + { + OnNewBuffSRV(Res); + break; + } - case D3D_SIT_UAV_RWSTRUCTURED: - { - OnNewBuffUAV( Res ); - break; - } + case D3D_SIT_UAV_RWSTRUCTURED: + { + OnNewBuffUAV(Res); + break; + } - case D3D_SIT_BYTEADDRESS: - { - OnNewBuffSRV( Res ); - break; - } + case D3D_SIT_BYTEADDRESS: + { + OnNewBuffSRV(Res); + break; + } - case D3D_SIT_UAV_RWBYTEADDRESS: - { - OnNewBuffUAV( Res ); - break; - } + case D3D_SIT_UAV_RWBYTEADDRESS: + { + OnNewBuffUAV(Res); + break; + } - case D3D_SIT_UAV_APPEND_STRUCTURED: - { - UNSUPPORTED( "Append structured buffers are not supported" ); - break; - } + case D3D_SIT_UAV_APPEND_STRUCTURED: + { + UNSUPPORTED("Append structured buffers are not supported"); + break; + } - case D3D_SIT_UAV_CONSUME_STRUCTURED: - { - UNSUPPORTED( "Consume structured buffers are not supported" ); - break; - } + case D3D_SIT_UAV_CONSUME_STRUCTURED: + { + UNSUPPORTED("Consume structured buffers are not supported"); + break; + } - case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: - { - UNSUPPORTED( "RW structured buffers with counter are not supported" ); - break; - } + case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: + { + UNSUPPORTED("RW structured buffers with counter are not supported"); + break; + } - default: - { - UNEXPECTED("Unexpected resource input type"); - } + default: + { + UNEXPECTED("Unexpected resource input type"); } } + } - // Process texture SRVs. We need to do this after all samplers are initialized - for (auto TexSRVInd : TexSRVInds) - { - OnNewTexSRV(Resources[TexSRVInd]); - } + // Process texture SRVs. We need to do this after all samplers are initialized + for (auto TexSRVInd : TexSRVInds) + { + OnNewTexSRV(Resources[TexSRVInd]); } } + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h b/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h index d474ecf0..25c562bd 100644 --- a/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h +++ b/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h @@ -33,540 +33,553 @@ namespace Diligent { - template - inline D3D_COMPARISON_FUNC ComparisonFuncToD3DComparisonFunc(COMPARISON_FUNCTION Func) +template +inline D3D_COMPARISON_FUNC ComparisonFuncToD3DComparisonFunc(COMPARISON_FUNCTION Func) +{ + // D3D12_COMPARISON_FUNC is equal to D3D11_COMPARISON_FUNC + switch (Func) { - // D3D12_COMPARISON_FUNC is equal to D3D11_COMPARISON_FUNC - switch(Func) - { - case COMPARISON_FUNC_UNKNOWN: UNEXPECTED("Comparison function is not specified" ); return D3D_COMPARISON_FUNC_ALWAYS; - case COMPARISON_FUNC_NEVER: return D3D_COMPARISON_FUNC_NEVER; - case COMPARISON_FUNC_LESS: return D3D_COMPARISON_FUNC_LESS; - case COMPARISON_FUNC_EQUAL: return D3D_COMPARISON_FUNC_EQUAL; - case COMPARISON_FUNC_LESS_EQUAL: return D3D_COMPARISON_FUNC_LESS_EQUAL; - case COMPARISON_FUNC_GREATER: return D3D_COMPARISON_FUNC_GREATER; - case COMPARISON_FUNC_NOT_EQUAL: return D3D_COMPARISON_FUNC_NOT_EQUAL; - case COMPARISON_FUNC_GREATER_EQUAL: return D3D_COMPARISON_FUNC_GREATER_EQUAL; - case COMPARISON_FUNC_ALWAYS: return D3D_COMPARISON_FUNC_ALWAYS; - default: UNEXPECTED("Unknown comparison function" ); return D3D_COMPARISON_FUNC_ALWAYS; - } + // clang-format off + case COMPARISON_FUNC_UNKNOWN: UNEXPECTED("Comparison function is not specified" ); return D3D_COMPARISON_FUNC_ALWAYS; + case COMPARISON_FUNC_NEVER: return D3D_COMPARISON_FUNC_NEVER; + case COMPARISON_FUNC_LESS: return D3D_COMPARISON_FUNC_LESS; + case COMPARISON_FUNC_EQUAL: return D3D_COMPARISON_FUNC_EQUAL; + case COMPARISON_FUNC_LESS_EQUAL: return D3D_COMPARISON_FUNC_LESS_EQUAL; + case COMPARISON_FUNC_GREATER: return D3D_COMPARISON_FUNC_GREATER; + case COMPARISON_FUNC_NOT_EQUAL: return D3D_COMPARISON_FUNC_NOT_EQUAL; + case COMPARISON_FUNC_GREATER_EQUAL: return D3D_COMPARISON_FUNC_GREATER_EQUAL; + case COMPARISON_FUNC_ALWAYS: return D3D_COMPARISON_FUNC_ALWAYS; + default: UNEXPECTED("Unknown comparison function" ); return D3D_COMPARISON_FUNC_ALWAYS; + // clang-format on } +} - template - D3D_TEXTURE_ADDRESS_MODE TexAddressModeToD3DAddressMode(TEXTURE_ADDRESS_MODE Mode) +template +D3D_TEXTURE_ADDRESS_MODE TexAddressModeToD3DAddressMode(TEXTURE_ADDRESS_MODE Mode) +{ + switch (Mode) { - switch(Mode) - { - case TEXTURE_ADDRESS_UNKNOWN: UNEXPECTED("Texture address mode is not specified" ); return D3D_TEXTURE_ADDRESS_CLAMP; - case TEXTURE_ADDRESS_WRAP: return D3D_TEXTURE_ADDRESS_WRAP; - case TEXTURE_ADDRESS_MIRROR: return D3D_TEXTURE_ADDRESS_MIRROR; - case TEXTURE_ADDRESS_CLAMP: return D3D_TEXTURE_ADDRESS_CLAMP; - case TEXTURE_ADDRESS_BORDER: return D3D_TEXTURE_ADDRESS_BORDER; - case TEXTURE_ADDRESS_MIRROR_ONCE: return D3D_TEXTURE_ADDRESS_MIRROR_ONCE; - default: UNEXPECTED("Unknown texture address mode" ); return D3D_TEXTURE_ADDRESS_CLAMP; - } - } - - template - D3D_PRIM_TOPOLOGY TopologyToD3DTopology(PRIMITIVE_TOPOLOGY Topology) + // clang-format off + case TEXTURE_ADDRESS_UNKNOWN: UNEXPECTED("Texture address mode is not specified" ); return D3D_TEXTURE_ADDRESS_CLAMP; + case TEXTURE_ADDRESS_WRAP: return D3D_TEXTURE_ADDRESS_WRAP; + case TEXTURE_ADDRESS_MIRROR: return D3D_TEXTURE_ADDRESS_MIRROR; + case TEXTURE_ADDRESS_CLAMP: return D3D_TEXTURE_ADDRESS_CLAMP; + case TEXTURE_ADDRESS_BORDER: return D3D_TEXTURE_ADDRESS_BORDER; + case TEXTURE_ADDRESS_MIRROR_ONCE: return D3D_TEXTURE_ADDRESS_MIRROR_ONCE; + default: UNEXPECTED("Unknown texture address mode" ); return D3D_TEXTURE_ADDRESS_CLAMP; + // clang-format on + } +} + +template +D3D_PRIM_TOPOLOGY TopologyToD3DTopology(PRIMITIVE_TOPOLOGY Topology) +{ + static bool bIsInit = false; + static std::array d3dPrimTopology = {}; + if (!bIsInit) { - static bool bIsInit = false; - static std::array d3dPrimTopology = {}; - if( !bIsInit ) - { - d3dPrimTopology[PRIMITIVE_TOPOLOGY_UNDEFINED] = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_LIST] = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP] = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_POINT_LIST] = D3D_PRIMITIVE_TOPOLOGY_POINTLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_LINE_LIST] = D3D_PRIMITIVE_TOPOLOGY_LINELIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST; - d3dPrimTopology[PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST; - - bIsInit = true; - } - - VERIFY_EXPR(Topology >= PRIMITIVE_TOPOLOGY_UNDEFINED && Topology= PRIMITIVE_TOPOLOGY_UNDEFINED && Topology < PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES); + return d3dPrimTopology[Topology]; +} - // ================= Rasterizer state attributes conversion functions ================= - template - D3D_FILL_MODE FillModeToD3DFillMode(FILL_MODE FillMode) +// ================= Rasterizer state attributes conversion functions ================= + +template +D3D_FILL_MODE FillModeToD3DFillMode(FILL_MODE FillMode) +{ + // D3D12_FILL_MODE is identical tp D3D11_FILL_MODE + static bool bIsInit = false; + static std::array d3dFillModes = {}; + if (!bIsInit) + { + d3dFillModes[FILL_MODE_WIREFRAME] = D3D_FILL_MODE_WIREFRAME; + d3dFillModes[FILL_MODE_SOLID] = D3D_FILL_MODE_SOLID; + + bIsInit = true; + } + if (FILL_MODE_UNDEFINED < FillMode && FillMode < FILL_MODE_NUM_MODES) + { + auto d3dFillMode = d3dFillModes[FillMode]; + VERIFY(d3dFillMode != 0, "Incorrect fill mode"); + return d3dFillMode; + } + else { - // D3D12_FILL_MODE is identical tp D3D11_FILL_MODE - static bool bIsInit = false; - static std::array d3dFillModes = {}; - if( !bIsInit ) - { - d3dFillModes[ FILL_MODE_WIREFRAME ] = D3D_FILL_MODE_WIREFRAME; - d3dFillModes[ FILL_MODE_SOLID ] = D3D_FILL_MODE_SOLID; - - bIsInit = true; - } - if( FILL_MODE_UNDEFINED < FillMode && FillMode < FILL_MODE_NUM_MODES ) - { - auto d3dFillMode = d3dFillModes[FillMode]; - VERIFY( d3dFillMode != 0, "Incorrect fill mode" ); - return d3dFillMode; - } - else - { - UNEXPECTED( "Incorrect fill mode (", FillMode, ")" ); - return static_cast(0); - } + UNEXPECTED("Incorrect fill mode (", FillMode, ")"); + return static_cast(0); } +} - template - D3D_CULL_MODE CullModeToD3DCullMode( CULL_MODE CullMode ) +template +D3D_CULL_MODE CullModeToD3DCullMode(CULL_MODE CullMode) +{ + // D3D_CULL_MODE is identical to D3D11_CULL_MODE + static bool bIsInit = false; + static std::array d3dCullModes = {}; + if (!bIsInit) { - // D3D_CULL_MODE is identical to D3D11_CULL_MODE - static bool bIsInit = false; - static std::array d3dCullModes = {}; - if( !bIsInit ) - { - d3dCullModes[ CULL_MODE_NONE ] = D3D_CULL_MODE_NONE; - d3dCullModes[ CULL_MODE_FRONT ] = D3D_CULL_MODE_FRONT; - d3dCullModes[ CULL_MODE_BACK ] = D3D_CULL_MODE_BACK; - - bIsInit = true; - } - - if( CULL_MODE_UNDEFINED < CullMode && CullMode < CULL_MODE_NUM_MODES ) - { - auto d3dCullMode = d3dCullModes[CullMode]; - VERIFY( d3dCullMode != 0, "Incorrect cull mode" ); - return d3dCullMode; - } - else - { - UNEXPECTED( "Incorrect cull mode (", CullMode, ")" ); - return static_cast(0); - } + d3dCullModes[CULL_MODE_NONE] = D3D_CULL_MODE_NONE; + d3dCullModes[CULL_MODE_FRONT] = D3D_CULL_MODE_FRONT; + d3dCullModes[CULL_MODE_BACK] = D3D_CULL_MODE_BACK; + + bIsInit = true; } - template - void RasterizerStateDesc_To_D3D_RASTERIZER_DESC(const RasterizerStateDesc &RasterizerDesc, D3D_RASTERIZER_DESC &d3dRSDesc) + if (CULL_MODE_UNDEFINED < CullMode && CullMode < CULL_MODE_NUM_MODES) { - d3dRSDesc.FillMode = FillModeToD3DFillMode(RasterizerDesc.FillMode); - d3dRSDesc.CullMode = CullModeToD3DCullMode(RasterizerDesc.CullMode); - d3dRSDesc.FrontCounterClockwise = RasterizerDesc.FrontCounterClockwise ? TRUE : FALSE; - d3dRSDesc.DepthBias = RasterizerDesc.DepthBias; - d3dRSDesc.DepthBiasClamp = RasterizerDesc.DepthBiasClamp; - d3dRSDesc.SlopeScaledDepthBias = RasterizerDesc.SlopeScaledDepthBias; - d3dRSDesc.DepthClipEnable = RasterizerDesc.DepthClipEnable ? TRUE : FALSE; - - //d3d12RSDesc.ScissorEnable = RSDesc.ScissorEnable ? TRUE : FALSE; - - d3dRSDesc.AntialiasedLineEnable = RasterizerDesc.AntialiasedLineEnable ? TRUE : FALSE; - d3dRSDesc.MultisampleEnable = d3dRSDesc.AntialiasedLineEnable; + auto d3dCullMode = d3dCullModes[CullMode]; + VERIFY(d3dCullMode != 0, "Incorrect cull mode"); + return d3dCullMode; } + else + { + UNEXPECTED("Incorrect cull mode (", CullMode, ")"); + return static_cast(0); + } +} + +template +void RasterizerStateDesc_To_D3D_RASTERIZER_DESC(const RasterizerStateDesc& RasterizerDesc, D3D_RASTERIZER_DESC& d3dRSDesc) +{ + d3dRSDesc.FillMode = FillModeToD3DFillMode(RasterizerDesc.FillMode); + d3dRSDesc.CullMode = CullModeToD3DCullMode(RasterizerDesc.CullMode); + d3dRSDesc.FrontCounterClockwise = RasterizerDesc.FrontCounterClockwise ? TRUE : FALSE; + d3dRSDesc.DepthBias = RasterizerDesc.DepthBias; + d3dRSDesc.DepthBiasClamp = RasterizerDesc.DepthBiasClamp; + d3dRSDesc.SlopeScaledDepthBias = RasterizerDesc.SlopeScaledDepthBias; + d3dRSDesc.DepthClipEnable = RasterizerDesc.DepthClipEnable ? TRUE : FALSE; + + //d3d12RSDesc.ScissorEnable = RSDesc.ScissorEnable ? TRUE : FALSE; + + d3dRSDesc.AntialiasedLineEnable = RasterizerDesc.AntialiasedLineEnable ? TRUE : FALSE; + d3dRSDesc.MultisampleEnable = d3dRSDesc.AntialiasedLineEnable; +} - // ================= Blend state attributes conversion functions ================= +// ================= Blend state attributes conversion functions ================= + +template +D3D_BLEND BlendFactorToD3DBlend(BLEND_FACTOR bf) +{ + // D3D11_BLEND and D3D12_BLEND are identical - template - D3D_BLEND BlendFactorToD3DBlend( BLEND_FACTOR bf ) + // Note that this code is safe for multithreaded environments since + // bIsInit is set to true only AFTER the entire map is initialized. + static bool bIsInit = false; + static std::array D3DBlend = {}; + if (!bIsInit) { - // D3D11_BLEND and D3D12_BLEND are identical - - // Note that this code is safe for multithreaded environments since - // bIsInit is set to true only AFTER the entire map is initialized. - static bool bIsInit = false; - static std::array D3DBlend = {}; - if( !bIsInit ) - { - // In a multithreaded environment, several threads can potentially enter - // this block. This is not a problem since they will just initialize the - // memory with the same values more than once - D3DBlend[ BLEND_FACTOR_ZERO ] = D3D_BLEND_ZERO; - D3DBlend[ BLEND_FACTOR_ONE ] = D3D_BLEND_ONE; - D3DBlend[ BLEND_FACTOR_SRC_COLOR ] = D3D_BLEND_SRC_COLOR; - D3DBlend[ BLEND_FACTOR_INV_SRC_COLOR ] = D3D_BLEND_INV_SRC_COLOR; - D3DBlend[ BLEND_FACTOR_SRC_ALPHA ] = D3D_BLEND_SRC_ALPHA; - D3DBlend[ BLEND_FACTOR_INV_SRC_ALPHA ] = D3D_BLEND_INV_SRC_ALPHA; - D3DBlend[ BLEND_FACTOR_DEST_ALPHA ] = D3D_BLEND_DEST_ALPHA; - D3DBlend[ BLEND_FACTOR_INV_DEST_ALPHA ] = D3D_BLEND_INV_DEST_ALPHA; - D3DBlend[ BLEND_FACTOR_DEST_COLOR ] = D3D_BLEND_DEST_COLOR; - D3DBlend[ BLEND_FACTOR_INV_DEST_COLOR ] = D3D_BLEND_INV_DEST_COLOR; - D3DBlend[ BLEND_FACTOR_SRC_ALPHA_SAT ] = D3D_BLEND_SRC_ALPHA_SAT; - D3DBlend[ BLEND_FACTOR_BLEND_FACTOR ] = D3D_BLEND_BLEND_FACTOR; - D3DBlend[ BLEND_FACTOR_INV_BLEND_FACTOR ] = D3D_BLEND_INV_BLEND_FACTOR; - D3DBlend[ BLEND_FACTOR_SRC1_COLOR ] = D3D_BLEND_SRC1_COLOR; - D3DBlend[ BLEND_FACTOR_INV_SRC1_COLOR ] = D3D_BLEND_INV_SRC1_COLOR; - D3DBlend[ BLEND_FACTOR_SRC1_ALPHA ] = D3D_BLEND_SRC1_ALPHA; - D3DBlend[ BLEND_FACTOR_INV_SRC1_ALPHA ] = D3D_BLEND_INV_SRC1_ALPHA; - - bIsInit = true; - } - if( bf > BLEND_FACTOR_UNDEFINED && bf < BLEND_FACTOR_NUM_FACTORS ) - { - auto d3dbf = D3DBlend[bf]; - VERIFY( d3dbf != 0, "Incorrect blend factor" ); - return d3dbf; - } - else - { - UNEXPECTED("Incorrect blend factor (", bf, ")" ); - return static_cast( 0 ); - } + // In a multithreaded environment, several threads can potentially enter + // this block. This is not a problem since they will just initialize the + // memory with the same values more than once + + // clang-format off + D3DBlend[BLEND_FACTOR_ZERO ] = D3D_BLEND_ZERO; + D3DBlend[BLEND_FACTOR_ONE ] = D3D_BLEND_ONE; + D3DBlend[BLEND_FACTOR_SRC_COLOR ] = D3D_BLEND_SRC_COLOR; + D3DBlend[BLEND_FACTOR_INV_SRC_COLOR ] = D3D_BLEND_INV_SRC_COLOR; + D3DBlend[BLEND_FACTOR_SRC_ALPHA ] = D3D_BLEND_SRC_ALPHA; + D3DBlend[BLEND_FACTOR_INV_SRC_ALPHA ] = D3D_BLEND_INV_SRC_ALPHA; + D3DBlend[BLEND_FACTOR_DEST_ALPHA ] = D3D_BLEND_DEST_ALPHA; + D3DBlend[BLEND_FACTOR_INV_DEST_ALPHA ] = D3D_BLEND_INV_DEST_ALPHA; + D3DBlend[BLEND_FACTOR_DEST_COLOR ] = D3D_BLEND_DEST_COLOR; + D3DBlend[BLEND_FACTOR_INV_DEST_COLOR ] = D3D_BLEND_INV_DEST_COLOR; + D3DBlend[BLEND_FACTOR_SRC_ALPHA_SAT ] = D3D_BLEND_SRC_ALPHA_SAT; + D3DBlend[BLEND_FACTOR_BLEND_FACTOR ] = D3D_BLEND_BLEND_FACTOR; + D3DBlend[BLEND_FACTOR_INV_BLEND_FACTOR] = D3D_BLEND_INV_BLEND_FACTOR; + D3DBlend[BLEND_FACTOR_SRC1_COLOR ] = D3D_BLEND_SRC1_COLOR; + D3DBlend[BLEND_FACTOR_INV_SRC1_COLOR ] = D3D_BLEND_INV_SRC1_COLOR; + D3DBlend[BLEND_FACTOR_SRC1_ALPHA ] = D3D_BLEND_SRC1_ALPHA; + D3DBlend[BLEND_FACTOR_INV_SRC1_ALPHA ] = D3D_BLEND_INV_SRC1_ALPHA; + // clang-format on + + bIsInit = true; } - - template - D3D_BLEND_OP BlendOperationToD3DBlendOp( BLEND_OPERATION BlendOp ) + if (bf > BLEND_FACTOR_UNDEFINED && bf < BLEND_FACTOR_NUM_FACTORS) { - // D3D12_BLEND_OP and D3D11_BLEND_OP are identical - - static bool bIsInit = false; - static std::array D3DBlendOp = {}; - if( !bIsInit ) - { - D3DBlendOp[ BLEND_OPERATION_ADD ] = D3D_BLEND_OP_ADD; - D3DBlendOp[ BLEND_OPERATION_SUBTRACT ] = D3D_BLEND_OP_SUBTRACT; - D3DBlendOp[ BLEND_OPERATION_REV_SUBTRACT ] = D3D_BLEND_OP_REV_SUBTRACT; - D3DBlendOp[ BLEND_OPERATION_MIN ] = D3D_BLEND_OP_MIN; - D3DBlendOp[ BLEND_OPERATION_MAX ] = D3D_BLEND_OP_MAX; - - bIsInit = true; - } - - if( BlendOp > BLEND_OPERATION_UNDEFINED && BlendOp < BLEND_OPERATION_NUM_OPERATIONS ) - { - auto d3dbop = D3DBlendOp[BlendOp]; - VERIFY( d3dbop != 0, "Incorrect blend operation" ); - return d3dbop; - } - else - { - UNEXPECTED( "Incorrect blend operation (", BlendOp, ")" ); - return static_cast(0); - } + auto d3dbf = D3DBlend[bf]; + VERIFY(d3dbf != 0, "Incorrect blend factor"); + return d3dbf; } - - template - void BlendStateDescToD3DBlendDesc(const BlendStateDesc &BSDesc, D3D_BLEND_DESC &d3d12BlendDesc) + else { - // D3D_BLEND_DESC and D3D11_BLEND_DESC structures are identical - d3d12BlendDesc.AlphaToCoverageEnable = BSDesc.AlphaToCoverageEnable ? TRUE : FALSE; - d3d12BlendDesc.IndependentBlendEnable = BSDesc.IndependentBlendEnable ? TRUE : FALSE; - VERIFY( BSDesc.MaxRenderTargets >= 8, "Number of render targets is expected to be at least 8" ); - for( int i = 0; i < 8; ++i ) - { - const auto& SrcRTDesc = BSDesc.RenderTargets[i]; - auto &DstRTDesc = d3d12BlendDesc.RenderTarget[i]; - DstRTDesc.BlendEnable = SrcRTDesc.BlendEnable ? TRUE : FALSE; - - DstRTDesc.SrcBlend = BlendFactorToD3DBlend(SrcRTDesc.SrcBlend); - DstRTDesc.DestBlend = BlendFactorToD3DBlend(SrcRTDesc.DestBlend); - DstRTDesc.BlendOp = BlendOperationToD3DBlendOp(SrcRTDesc.BlendOp); - - DstRTDesc.SrcBlendAlpha = BlendFactorToD3DBlend(SrcRTDesc.SrcBlendAlpha); - DstRTDesc.DestBlendAlpha = BlendFactorToD3DBlend(SrcRTDesc.DestBlendAlpha); - DstRTDesc.BlendOpAlpha = BlendOperationToD3DBlendOp(SrcRTDesc.BlendOpAlpha); - - DstRTDesc.RenderTargetWriteMask = - ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_RED) ? D3D_COLOR_WRITE_ENABLE_RED : 0) | - ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_GREEN) ? D3D_COLOR_WRITE_ENABLE_GREEN : 0) | - ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_BLUE) ? D3D_COLOR_WRITE_ENABLE_BLUE : 0) | - ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_ALPHA) ? D3D_COLOR_WRITE_ENABLE_ALPHA : 0); - } + UNEXPECTED("Incorrect blend factor (", bf, ")"); + return static_cast(0); } +} +template +D3D_BLEND_OP BlendOperationToD3DBlendOp(BLEND_OPERATION BlendOp) +{ + // D3D12_BLEND_OP and D3D11_BLEND_OP are identical + static bool bIsInit = false; + static std::array D3DBlendOp = {}; + if (!bIsInit) + { + // clang-format off + D3DBlendOp[BLEND_OPERATION_ADD ] = D3D_BLEND_OP_ADD; + D3DBlendOp[BLEND_OPERATION_SUBTRACT ] = D3D_BLEND_OP_SUBTRACT; + D3DBlendOp[BLEND_OPERATION_REV_SUBTRACT] = D3D_BLEND_OP_REV_SUBTRACT; + D3DBlendOp[BLEND_OPERATION_MIN ] = D3D_BLEND_OP_MIN; + D3DBlendOp[BLEND_OPERATION_MAX ] = D3D_BLEND_OP_MAX; + // clang-format on + + bIsInit = true; + } - // ====================== Depth-stencil state attributes conversion functions ====================== + if (BlendOp > BLEND_OPERATION_UNDEFINED && BlendOp < BLEND_OPERATION_NUM_OPERATIONS) + { + auto d3dbop = D3DBlendOp[BlendOp]; + VERIFY(d3dbop != 0, "Incorrect blend operation"); + return d3dbop; + } + else + { + UNEXPECTED("Incorrect blend operation (", BlendOp, ")"); + return static_cast(0); + } +} - template - D3D_STENCIL_OP StencilOpToD3DStencilOp( STENCIL_OP StencilOp ) +template +void BlendStateDescToD3DBlendDesc(const BlendStateDesc& BSDesc, D3D_BLEND_DESC& d3d12BlendDesc) +{ + // D3D_BLEND_DESC and D3D11_BLEND_DESC structures are identical + d3d12BlendDesc.AlphaToCoverageEnable = BSDesc.AlphaToCoverageEnable ? TRUE : FALSE; + d3d12BlendDesc.IndependentBlendEnable = BSDesc.IndependentBlendEnable ? TRUE : FALSE; + VERIFY(BSDesc.MaxRenderTargets >= 8, "Number of render targets is expected to be at least 8"); + for (int i = 0; i < 8; ++i) { - static bool bIsInit = false; - static std::array StOpToD3DStOpMap = {}; - if( !bIsInit ) - { - StOpToD3DStOpMap[ STENCIL_OP_KEEP ] = D3D_STENCIL_OP_KEEP; - StOpToD3DStOpMap[ STENCIL_OP_ZERO ] = D3D_STENCIL_OP_ZERO; - StOpToD3DStOpMap[ STENCIL_OP_REPLACE ] = D3D_STENCIL_OP_REPLACE; - StOpToD3DStOpMap[ STENCIL_OP_INCR_SAT ] = D3D_STENCIL_OP_INCR_SAT; - StOpToD3DStOpMap[ STENCIL_OP_DECR_SAT ] = D3D_STENCIL_OP_DECR_SAT; - StOpToD3DStOpMap[ STENCIL_OP_INVERT ] = D3D_STENCIL_OP_INVERT; - StOpToD3DStOpMap[ STENCIL_OP_INCR_WRAP] = D3D_STENCIL_OP_INCR; - StOpToD3DStOpMap[ STENCIL_OP_DECR_WRAP] = D3D_STENCIL_OP_DECR; - - bIsInit = true; - } - - if( StencilOp > STENCIL_OP_UNDEFINED && StencilOp < STENCIL_OP_NUM_OPS ) - { - auto d3dStencilOp = StOpToD3DStOpMap[StencilOp]; - VERIFY( d3dStencilOp != 0, "Unexpected stencil op" ); - return d3dStencilOp; - } - else - { - UNEXPECTED( "Stencil operation (", StencilOp, ") is out of allowed range [1, ", STENCIL_OP_NUM_OPS - 1, "]" ); - return static_cast(0); - } + const auto& SrcRTDesc = BSDesc.RenderTargets[i]; + auto& DstRTDesc = d3d12BlendDesc.RenderTarget[i]; + DstRTDesc.BlendEnable = SrcRTDesc.BlendEnable ? TRUE : FALSE; + + DstRTDesc.SrcBlend = BlendFactorToD3DBlend(SrcRTDesc.SrcBlend); + DstRTDesc.DestBlend = BlendFactorToD3DBlend(SrcRTDesc.DestBlend); + DstRTDesc.BlendOp = BlendOperationToD3DBlendOp(SrcRTDesc.BlendOp); + + DstRTDesc.SrcBlendAlpha = BlendFactorToD3DBlend(SrcRTDesc.SrcBlendAlpha); + DstRTDesc.DestBlendAlpha = BlendFactorToD3DBlend(SrcRTDesc.DestBlendAlpha); + DstRTDesc.BlendOpAlpha = BlendOperationToD3DBlendOp(SrcRTDesc.BlendOpAlpha); + + DstRTDesc.RenderTargetWriteMask = + ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_RED) ? D3D_COLOR_WRITE_ENABLE_RED : 0) | + ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_GREEN) ? D3D_COLOR_WRITE_ENABLE_GREEN : 0) | + ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_BLUE) ? D3D_COLOR_WRITE_ENABLE_BLUE : 0) | + ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_ALPHA) ? D3D_COLOR_WRITE_ENABLE_ALPHA : 0); } +} + + + +// ====================== Depth-stencil state attributes conversion functions ====================== - template - D3D_DEPTH_STENCILOP_DESC StencilOpDescToD3DStencilOpDesc(const StencilOpDesc &StOpDesc) +template +D3D_STENCIL_OP StencilOpToD3DStencilOp(STENCIL_OP StencilOp) +{ + static bool bIsInit = false; + static std::array StOpToD3DStOpMap = {}; + if (!bIsInit) { - // D3D12_DEPTH_STENCILOP_DESC is identical to D3D11_DEPTH_STENCILOP_DESC - D3D_DEPTH_STENCILOP_DESC D3DStOpDesc; - D3DStOpDesc.StencilFailOp = StencilOpToD3DStencilOp( StOpDesc.StencilFailOp ); - D3DStOpDesc.StencilDepthFailOp = StencilOpToD3DStencilOp( StOpDesc.StencilDepthFailOp ); - D3DStOpDesc.StencilPassOp = StencilOpToD3DStencilOp( StOpDesc.StencilPassOp ); - D3DStOpDesc.StencilFunc = ComparisonFuncToD3DComparisonFunc( StOpDesc.StencilFunc ); - return D3DStOpDesc; + // clang-format off + StOpToD3DStOpMap[STENCIL_OP_KEEP ] = D3D_STENCIL_OP_KEEP; + StOpToD3DStOpMap[STENCIL_OP_ZERO ] = D3D_STENCIL_OP_ZERO; + StOpToD3DStOpMap[STENCIL_OP_REPLACE ] = D3D_STENCIL_OP_REPLACE; + StOpToD3DStOpMap[STENCIL_OP_INCR_SAT ] = D3D_STENCIL_OP_INCR_SAT; + StOpToD3DStOpMap[STENCIL_OP_DECR_SAT ] = D3D_STENCIL_OP_DECR_SAT; + StOpToD3DStOpMap[STENCIL_OP_INVERT ] = D3D_STENCIL_OP_INVERT; + StOpToD3DStOpMap[STENCIL_OP_INCR_WRAP] = D3D_STENCIL_OP_INCR; + StOpToD3DStOpMap[STENCIL_OP_DECR_WRAP] = D3D_STENCIL_OP_DECR; + // clang-format on + + bIsInit = true; } - template - void DepthStencilStateDesc_To_D3D_DEPTH_STENCIL_DESC(const DepthStencilStateDesc &DepthStencilDesc, D3D_DEPTH_STENCIL_DESC &d3dDSSDesc) + if (StencilOp > STENCIL_OP_UNDEFINED && StencilOp < STENCIL_OP_NUM_OPS) + { + auto d3dStencilOp = StOpToD3DStOpMap[StencilOp]; + VERIFY(d3dStencilOp != 0, "Unexpected stencil op"); + return d3dStencilOp; + } + else { - // D3D_DEPTH_STENCIL_DESC is identical to D3D11_DEPTH_STENCIL_DESC - d3dDSSDesc.DepthEnable = DepthStencilDesc.DepthEnable ? TRUE : FALSE; - d3dDSSDesc.DepthWriteMask = DepthStencilDesc.DepthWriteEnable ? D3D_DEPTH_WRITE_MASK_ALL : D3D_DEPTH_WRITE_MASK_ZERO; - d3dDSSDesc.DepthFunc = ComparisonFuncToD3DComparisonFunc( DepthStencilDesc.DepthFunc ); - d3dDSSDesc.StencilEnable = DepthStencilDesc.StencilEnable ? TRUE : FALSE; - d3dDSSDesc.StencilReadMask = DepthStencilDesc.StencilReadMask; - d3dDSSDesc.StencilWriteMask = DepthStencilDesc.StencilWriteMask; - d3dDSSDesc.FrontFace = StencilOpDescToD3DStencilOpDesc( DepthStencilDesc.FrontFace ); - d3dDSSDesc.BackFace = StencilOpDescToD3DStencilOpDesc( DepthStencilDesc.BackFace ); + UNEXPECTED("Stencil operation (", StencilOp, ") is out of allowed range [1, ", STENCIL_OP_NUM_OPS - 1, "]"); + return static_cast(0); } +} + +template +D3D_DEPTH_STENCILOP_DESC StencilOpDescToD3DStencilOpDesc(const StencilOpDesc& StOpDesc) +{ + // D3D12_DEPTH_STENCILOP_DESC is identical to D3D11_DEPTH_STENCILOP_DESC + D3D_DEPTH_STENCILOP_DESC D3DStOpDesc; + D3DStOpDesc.StencilFailOp = StencilOpToD3DStencilOp(StOpDesc.StencilFailOp); + D3DStOpDesc.StencilDepthFailOp = StencilOpToD3DStencilOp(StOpDesc.StencilDepthFailOp); + D3DStOpDesc.StencilPassOp = StencilOpToD3DStencilOp(StOpDesc.StencilPassOp); + D3DStOpDesc.StencilFunc = ComparisonFuncToD3DComparisonFunc(StOpDesc.StencilFunc); + return D3DStOpDesc; +} + +template +void DepthStencilStateDesc_To_D3D_DEPTH_STENCIL_DESC(const DepthStencilStateDesc& DepthStencilDesc, D3D_DEPTH_STENCIL_DESC& d3dDSSDesc) +{ + // D3D_DEPTH_STENCIL_DESC is identical to D3D11_DEPTH_STENCIL_DESC + d3dDSSDesc.DepthEnable = DepthStencilDesc.DepthEnable ? TRUE : FALSE; + d3dDSSDesc.DepthWriteMask = DepthStencilDesc.DepthWriteEnable ? D3D_DEPTH_WRITE_MASK_ALL : D3D_DEPTH_WRITE_MASK_ZERO; + d3dDSSDesc.DepthFunc = ComparisonFuncToD3DComparisonFunc(DepthStencilDesc.DepthFunc); + d3dDSSDesc.StencilEnable = DepthStencilDesc.StencilEnable ? TRUE : FALSE; + d3dDSSDesc.StencilReadMask = DepthStencilDesc.StencilReadMask; + d3dDSSDesc.StencilWriteMask = DepthStencilDesc.StencilWriteMask; + d3dDSSDesc.FrontFace = StencilOpDescToD3DStencilOpDesc(DepthStencilDesc.FrontFace); + d3dDSSDesc.BackFace = StencilOpDescToD3DStencilOpDesc(DepthStencilDesc.BackFace); +} - template - void LayoutElements_To_D3D_INPUT_ELEMENT_DESCs(const InputLayoutDesc& InputLayout, - std::vector> &D3DInputElements) +template +void LayoutElements_To_D3D_INPUT_ELEMENT_DESCs(const InputLayoutDesc& InputLayout, + std::vector>& D3DInputElements) +{ + // D3D12_INPUT_ELEMENT_DESC and D3D11_INPUT_ELEMENT_DESC are identical + D3DInputElements.resize(InputLayout.NumElements); + for (Uint32 iElem = 0; iElem < InputLayout.NumElements; ++iElem) { - // D3D12_INPUT_ELEMENT_DESC and D3D11_INPUT_ELEMENT_DESC are identical - D3DInputElements.resize(InputLayout.NumElements); - for(Uint32 iElem=0; iElem < InputLayout.NumElements; ++iElem) - { - const auto &CurrElem = InputLayout.LayoutElements[iElem]; - auto &D3DElem = D3DInputElements[iElem]; - D3DElem.SemanticName = CurrElem.HLSLSemantic; - D3DElem.SemanticIndex = CurrElem.InputIndex; - D3DElem.AlignedByteOffset = CurrElem.RelativeOffset; - D3DElem.InputSlot = CurrElem.BufferSlot; - D3DElem.Format = TypeToDXGI_Format(CurrElem.ValueType, CurrElem.NumComponents, CurrElem.IsNormalized); - D3DElem.InputSlotClass = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? D3D_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D_INPUT_CLASSIFICATION_PER_INSTANCE_DATA; - D3DElem.InstanceDataStepRate = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? 0 : CurrElem.InstanceDataStepRate; - } + const auto& CurrElem = InputLayout.LayoutElements[iElem]; + auto& D3DElem = D3DInputElements[iElem]; + D3DElem.SemanticName = CurrElem.HLSLSemantic; + D3DElem.SemanticIndex = CurrElem.InputIndex; + D3DElem.AlignedByteOffset = CurrElem.RelativeOffset; + D3DElem.InputSlot = CurrElem.BufferSlot; + D3DElem.Format = TypeToDXGI_Format(CurrElem.ValueType, CurrElem.NumComponents, CurrElem.IsNormalized); + D3DElem.InputSlotClass = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? D3D_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D_INPUT_CLASSIFICATION_PER_INSTANCE_DATA; + D3DElem.InstanceDataStepRate = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? 0 : CurrElem.InstanceDataStepRate; } +} - template - D3D_FILTER FilterTypeToD3DFilter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter) +template +D3D_FILTER FilterTypeToD3DFilter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter) +{ + switch (MinFilter) { - switch( MinFilter ) - { - // Regular filters - case FILTER_TYPE_POINT: - if( MagFilter == FILTER_TYPE_POINT ) - { - if( MipFilter == FILTER_TYPE_POINT ) - return D3D_FILTER_MIN_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_LINEAR ) - return D3D_FILTER_MIN_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_LINEAR ) - { - if( MipFilter == FILTER_TYPE_POINT ) - return D3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_LINEAR ) - return D3D_FILTER_MIN_POINT_MAG_MIP_LINEAR; - } + // Regular filters + case FILTER_TYPE_POINT: + if (MagFilter == FILTER_TYPE_POINT) + { + if (MipFilter == FILTER_TYPE_POINT) + return D3D_FILTER_MIN_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_LINEAR) + return D3D_FILTER_MIN_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_LINEAR) + { + if (MipFilter == FILTER_TYPE_POINT) + return D3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_LINEAR) + return D3D_FILTER_MIN_POINT_MAG_MIP_LINEAR; + } break; - - case FILTER_TYPE_LINEAR: - if( MagFilter == FILTER_TYPE_POINT ) - { - if( MipFilter == FILTER_TYPE_POINT ) - return D3D_FILTER_MIN_LINEAR_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_LINEAR ) - return D3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_LINEAR ) - { - if( MipFilter == FILTER_TYPE_POINT ) - return D3D_FILTER_MIN_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_LINEAR ) - return D3D_FILTER_MIN_MAG_MIP_LINEAR; - } + + case FILTER_TYPE_LINEAR: + if (MagFilter == FILTER_TYPE_POINT) + { + if (MipFilter == FILTER_TYPE_POINT) + return D3D_FILTER_MIN_LINEAR_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_LINEAR) + return D3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_LINEAR) + { + if (MipFilter == FILTER_TYPE_POINT) + return D3D_FILTER_MIN_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_LINEAR) + return D3D_FILTER_MIN_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_ANISOTROPIC: - VERIFY( MagFilter == FILTER_TYPE_ANISOTROPIC && MipFilter == FILTER_TYPE_ANISOTROPIC, - "For anistropic filtering, all filters must be anisotropic" ); - return D3D_FILTER_ANISOTROPIC; + case FILTER_TYPE_ANISOTROPIC: + VERIFY(MagFilter == FILTER_TYPE_ANISOTROPIC && MipFilter == FILTER_TYPE_ANISOTROPIC, + "For anistropic filtering, all filters must be anisotropic"); + return D3D_FILTER_ANISOTROPIC; break; - // Comparison filters - case FILTER_TYPE_COMPARISON_POINT: - if( MagFilter == FILTER_TYPE_COMPARISON_POINT ) - { - if( MipFilter == FILTER_TYPE_COMPARISON_POINT ) - return D3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR ) - return D3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_COMPARISON_LINEAR ) - { - if( MipFilter == FILTER_TYPE_COMPARISON_POINT ) - return D3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR ) - return D3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR; - } + // Comparison filters + case FILTER_TYPE_COMPARISON_POINT: + if (MagFilter == FILTER_TYPE_COMPARISON_POINT) + { + if (MipFilter == FILTER_TYPE_COMPARISON_POINT) + return D3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR) + return D3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_COMPARISON_LINEAR) + { + if (MipFilter == FILTER_TYPE_COMPARISON_POINT) + return D3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR) + return D3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_COMPARISON_LINEAR: - if( MagFilter == FILTER_TYPE_COMPARISON_POINT ) - { - if( MipFilter == FILTER_TYPE_COMPARISON_POINT ) - return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR ) - return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_COMPARISON_LINEAR ) - { - if( MipFilter == FILTER_TYPE_COMPARISON_POINT ) - return D3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR ) - return D3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; - } + case FILTER_TYPE_COMPARISON_LINEAR: + if (MagFilter == FILTER_TYPE_COMPARISON_POINT) + { + if (MipFilter == FILTER_TYPE_COMPARISON_POINT) + return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR) + return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_COMPARISON_LINEAR) + { + if (MipFilter == FILTER_TYPE_COMPARISON_POINT) + return D3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR) + return D3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_COMPARISON_ANISOTROPIC: - VERIFY( MagFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC && MipFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC, - "For comparison anistropic filtering, all filters must be anisotropic" ); - return D3D_FILTER_COMPARISON_ANISOTROPIC; + case FILTER_TYPE_COMPARISON_ANISOTROPIC: + VERIFY(MagFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC && MipFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC, + "For comparison anistropic filtering, all filters must be anisotropic"); + return D3D_FILTER_COMPARISON_ANISOTROPIC; break; - // Minimum filters - case FILTER_TYPE_MINIMUM_POINT: - if( MagFilter == FILTER_TYPE_MINIMUM_POINT ) - { - if( MipFilter == FILTER_TYPE_MINIMUM_POINT ) - return D3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR ) - return D3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_MINIMUM_LINEAR ) - { - if( MipFilter == FILTER_TYPE_MINIMUM_POINT ) - return D3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR ) - return D3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR; - } + // Minimum filters + case FILTER_TYPE_MINIMUM_POINT: + if (MagFilter == FILTER_TYPE_MINIMUM_POINT) + { + if (MipFilter == FILTER_TYPE_MINIMUM_POINT) + return D3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR) + return D3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_MINIMUM_LINEAR) + { + if (MipFilter == FILTER_TYPE_MINIMUM_POINT) + return D3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR) + return D3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_MINIMUM_LINEAR: - if( MagFilter == FILTER_TYPE_MINIMUM_POINT ) - { - if( MipFilter == FILTER_TYPE_MINIMUM_POINT ) - return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR ) - return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_MINIMUM_LINEAR ) - { - if( MipFilter == FILTER_TYPE_MINIMUM_POINT ) - return D3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR ) - return D3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR; - } + case FILTER_TYPE_MINIMUM_LINEAR: + if (MagFilter == FILTER_TYPE_MINIMUM_POINT) + { + if (MipFilter == FILTER_TYPE_MINIMUM_POINT) + return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR) + return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_MINIMUM_LINEAR) + { + if (MipFilter == FILTER_TYPE_MINIMUM_POINT) + return D3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR) + return D3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_MINIMUM_ANISOTROPIC: - VERIFY( MagFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC, - "For minimum anistropic filtering, all filters must be anisotropic" ); - return D3D_FILTER_MINIMUM_ANISOTROPIC; + case FILTER_TYPE_MINIMUM_ANISOTROPIC: + VERIFY(MagFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC, + "For minimum anistropic filtering, all filters must be anisotropic"); + return D3D_FILTER_MINIMUM_ANISOTROPIC; break; - // Maximum filters - case FILTER_TYPE_MAXIMUM_POINT: - if( MagFilter == FILTER_TYPE_MAXIMUM_POINT ) - { - if( MipFilter == FILTER_TYPE_MAXIMUM_POINT ) - return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - return D3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - { - if( MipFilter == FILTER_TYPE_MAXIMUM_POINT ) - return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR; - } + // Maximum filters + case FILTER_TYPE_MAXIMUM_POINT: + if (MagFilter == FILTER_TYPE_MAXIMUM_POINT) + { + if (MipFilter == FILTER_TYPE_MAXIMUM_POINT) + return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR) + return D3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_MAXIMUM_LINEAR) + { + if (MipFilter == FILTER_TYPE_MAXIMUM_POINT) + return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR) + return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_MAXIMUM_LINEAR: - if( MagFilter == FILTER_TYPE_MAXIMUM_POINT ) - { - if( MipFilter == FILTER_TYPE_MAXIMUM_POINT ) - return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - } - else if( MagFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - { - if( MipFilter == FILTER_TYPE_MAXIMUM_POINT ) - return D3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT; - else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR ) - return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR; - } + case FILTER_TYPE_MAXIMUM_LINEAR: + if (MagFilter == FILTER_TYPE_MAXIMUM_POINT) + { + if (MipFilter == FILTER_TYPE_MAXIMUM_POINT) + return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR) + return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + } + else if (MagFilter == FILTER_TYPE_MAXIMUM_LINEAR) + { + if (MipFilter == FILTER_TYPE_MAXIMUM_POINT) + return D3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT; + else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR) + return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR; + } break; - case FILTER_TYPE_MAXIMUM_ANISOTROPIC: - VERIFY( MagFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC, - "For maximum anistropic filtering, all filters must be anisotropic" ); - return D3D_FILTER_MAXIMUM_ANISOTROPIC; + case FILTER_TYPE_MAXIMUM_ANISOTROPIC: + VERIFY(MagFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC, + "For maximum anistropic filtering, all filters must be anisotropic"); + return D3D_FILTER_MAXIMUM_ANISOTROPIC; break; - } - - UNEXPECTED( "Unsupported filter combination" ); - return D3D_FILTER_MIN_MAG_MIP_POINT; } + + UNEXPECTED("Unsupported filter combination"); + return D3D_FILTER_MIN_MAG_MIP_POINT; } + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h b/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h index eafa500c..13b4fcfb 100644 --- a/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h +++ b/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h @@ -32,307 +32,309 @@ namespace Diligent { - template - void TextureViewDesc_to_D3D_SRV_DESC(const TextureViewDesc& SRVDesc, D3D_SHADER_RESOURCE_VIEW_DESC &d3dSRVDesc, Uint32 SampleCount) + +template +void TextureViewDesc_to_D3D_SRV_DESC(const TextureViewDesc& SRVDesc, D3D_SHADER_RESOURCE_VIEW_DESC& d3dSRVDesc, Uint32 SampleCount) +{ + memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc)); + d3dSRVDesc.Format = TexFormatToDXGI_Format(SRVDesc.Format, BIND_SHADER_RESOURCE); + + switch (SRVDesc.TextureDim) { - memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc)); - d3dSRVDesc.Format = TexFormatToDXGI_Format(SRVDesc.Format, BIND_SHADER_RESOURCE); - - switch (SRVDesc.TextureDim) - { - case RESOURCE_DIM_TEX_1D: - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1D; - d3dSRVDesc.Texture1D.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.Texture1D.MostDetailedMip = SRVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D: + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1D; + d3dSRVDesc.Texture1D.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.Texture1D.MostDetailedMip = SRVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_1D_ARRAY: - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1DARRAY; - d3dSRVDesc.Texture1DArray.ArraySize = SRVDesc.NumArraySlices; - d3dSRVDesc.Texture1DArray.FirstArraySlice = SRVDesc.FirstArraySlice; - d3dSRVDesc.Texture1DArray.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.Texture1DArray.MostDetailedMip = SRVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D_ARRAY: + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1DARRAY; + d3dSRVDesc.Texture1DArray.ArraySize = SRVDesc.NumArraySlices; + d3dSRVDesc.Texture1DArray.FirstArraySlice = SRVDesc.FirstArraySlice; + d3dSRVDesc.Texture1DArray.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.Texture1DArray.MostDetailedMip = SRVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_2D: - if( SampleCount > 1 ) - { - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DMS; - d3dSRVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; - } - else - { - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2D; - d3dSRVDesc.Texture2D.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.Texture2D.MostDetailedMip = SRVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D: + if (SampleCount > 1) + { + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DMS; + d3dSRVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; + } + else + { + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2D; + d3dSRVDesc.Texture2D.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.Texture2D.MostDetailedMip = SRVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_2D_ARRAY: - if( SampleCount > 1 ) - { - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY; - d3dSRVDesc.Texture2DMSArray.ArraySize = SRVDesc.NumArraySlices; - d3dSRVDesc.Texture2DMSArray.FirstArraySlice = SRVDesc.FirstArraySlice; - } - else - { - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DARRAY; - d3dSRVDesc.Texture2DArray.ArraySize = SRVDesc.NumArraySlices; - d3dSRVDesc.Texture2DArray.FirstArraySlice = SRVDesc.FirstArraySlice; - d3dSRVDesc.Texture2DArray.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.Texture2DArray.MostDetailedMip = SRVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D_ARRAY: + if (SampleCount > 1) + { + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY; + d3dSRVDesc.Texture2DMSArray.ArraySize = SRVDesc.NumArraySlices; + d3dSRVDesc.Texture2DMSArray.FirstArraySlice = SRVDesc.FirstArraySlice; + } + else + { + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DARRAY; + d3dSRVDesc.Texture2DArray.ArraySize = SRVDesc.NumArraySlices; + d3dSRVDesc.Texture2DArray.FirstArraySlice = SRVDesc.FirstArraySlice; + d3dSRVDesc.Texture2DArray.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.Texture2DArray.MostDetailedMip = SRVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_3D: - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE3D; - d3dSRVDesc.Texture3D.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.Texture3D.MostDetailedMip = SRVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_3D: + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE3D; + d3dSRVDesc.Texture3D.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.Texture3D.MostDetailedMip = SRVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_CUBE: - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBE; - d3dSRVDesc.TextureCube.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.TextureCube.MostDetailedMip = SRVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_CUBE: + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBE; + d3dSRVDesc.TextureCube.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.TextureCube.MostDetailedMip = SRVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_CUBE_ARRAY: - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBEARRAY; - d3dSRVDesc.TextureCubeArray.MipLevels = SRVDesc.NumMipLevels; - d3dSRVDesc.TextureCubeArray.MostDetailedMip = SRVDesc.MostDetailedMip; - d3dSRVDesc.TextureCubeArray.First2DArrayFace = SRVDesc.FirstArraySlice; - d3dSRVDesc.TextureCubeArray.NumCubes = SRVDesc.NumArraySlices / 6; + case RESOURCE_DIM_TEX_CUBE_ARRAY: + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBEARRAY; + d3dSRVDesc.TextureCubeArray.MipLevels = SRVDesc.NumMipLevels; + d3dSRVDesc.TextureCubeArray.MostDetailedMip = SRVDesc.MostDetailedMip; + d3dSRVDesc.TextureCubeArray.First2DArrayFace = SRVDesc.FirstArraySlice; + d3dSRVDesc.TextureCubeArray.NumCubes = SRVDesc.NumArraySlices / 6; break; - default: - UNEXPECTED( "Unexpected view type" ); - } + default: + UNEXPECTED("Unexpected view type"); } +} - template - void TextureViewDesc_to_D3D_RTV_DESC(const TextureViewDesc& RTVDesc, D3D_RENDER_TARGET_VIEW_DESC &d3dRTVDesc, Uint32 SampleCount) +template +void TextureViewDesc_to_D3D_RTV_DESC(const TextureViewDesc& RTVDesc, D3D_RENDER_TARGET_VIEW_DESC& d3dRTVDesc, Uint32 SampleCount) +{ + memset(&d3dRTVDesc, 0, sizeof(d3dRTVDesc)); + d3dRTVDesc.Format = TexFormatToDXGI_Format(RTVDesc.Format, BIND_RENDER_TARGET); + + switch (RTVDesc.TextureDim) { - memset(&d3dRTVDesc, 0, sizeof(d3dRTVDesc)); - d3dRTVDesc.Format = TexFormatToDXGI_Format(RTVDesc.Format, BIND_RENDER_TARGET); - - switch(RTVDesc.TextureDim) - { - case RESOURCE_DIM_TEX_1D: - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE1D; - d3dRTVDesc.Texture1D.MipSlice = RTVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D: + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE1D; + d3dRTVDesc.Texture1D.MipSlice = RTVDesc.MostDetailedMip; break; - - case RESOURCE_DIM_TEX_1D_ARRAY: - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE1DARRAY; - d3dRTVDesc.Texture1DArray.ArraySize = RTVDesc.NumArraySlices; - d3dRTVDesc.Texture1DArray.FirstArraySlice = RTVDesc.FirstArraySlice; - d3dRTVDesc.Texture1DArray.MipSlice = RTVDesc.MostDetailedMip; + + case RESOURCE_DIM_TEX_1D_ARRAY: + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE1DARRAY; + d3dRTVDesc.Texture1DArray.ArraySize = RTVDesc.NumArraySlices; + d3dRTVDesc.Texture1DArray.FirstArraySlice = RTVDesc.FirstArraySlice; + d3dRTVDesc.Texture1DArray.MipSlice = RTVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_2D: - if( SampleCount > 1 ) - { - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DMS; - d3dRTVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; - } - else - { - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2D; - d3dRTVDesc.Texture2D.MipSlice = RTVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D: + if (SampleCount > 1) + { + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DMS; + d3dRTVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; + } + else + { + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2D; + d3dRTVDesc.Texture2D.MipSlice = RTVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_2D_ARRAY: - if( SampleCount > 1 ) - { - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DMSARRAY; - d3dRTVDesc.Texture2DMSArray.ArraySize = RTVDesc.NumArraySlices; - d3dRTVDesc.Texture2DMSArray.FirstArraySlice = RTVDesc.FirstArraySlice; - } - else - { - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DARRAY; - d3dRTVDesc.Texture2DArray.ArraySize = RTVDesc.NumArraySlices; - d3dRTVDesc.Texture2DArray.FirstArraySlice = RTVDesc.FirstArraySlice; - d3dRTVDesc.Texture2DArray.MipSlice = RTVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D_ARRAY: + if (SampleCount > 1) + { + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DMSARRAY; + d3dRTVDesc.Texture2DMSArray.ArraySize = RTVDesc.NumArraySlices; + d3dRTVDesc.Texture2DMSArray.FirstArraySlice = RTVDesc.FirstArraySlice; + } + else + { + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DARRAY; + d3dRTVDesc.Texture2DArray.ArraySize = RTVDesc.NumArraySlices; + d3dRTVDesc.Texture2DArray.FirstArraySlice = RTVDesc.FirstArraySlice; + d3dRTVDesc.Texture2DArray.MipSlice = RTVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_3D: - d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE3D; - d3dRTVDesc.Texture3D.FirstWSlice = RTVDesc.FirstDepthSlice; - d3dRTVDesc.Texture3D.WSize = RTVDesc.NumDepthSlices; - d3dRTVDesc.Texture3D.MipSlice = RTVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_3D: + d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE3D; + d3dRTVDesc.Texture3D.FirstWSlice = RTVDesc.FirstDepthSlice; + d3dRTVDesc.Texture3D.WSize = RTVDesc.NumDepthSlices; + d3dRTVDesc.Texture3D.MipSlice = RTVDesc.MostDetailedMip; break; - default: - UNEXPECTED( "Unexpected view type" ); - } + default: + UNEXPECTED("Unexpected view type"); } +} + +template +void TextureViewDesc_to_D3D_DSV_DESC(const TextureViewDesc& DSVDesc, D3D_DEPTH_STENCIL_VIEW_DESC& d3dDSVDesc, Uint32 SampleCount) +{ + memset(&d3dDSVDesc, 0, sizeof(d3dDSVDesc)); + d3dDSVDesc.Format = TexFormatToDXGI_Format(DSVDesc.Format, BIND_DEPTH_STENCIL); - template - void TextureViewDesc_to_D3D_DSV_DESC(const TextureViewDesc& DSVDesc, D3D_DEPTH_STENCIL_VIEW_DESC &d3dDSVDesc, Uint32 SampleCount) + switch (DSVDesc.TextureDim) { - memset(&d3dDSVDesc, 0, sizeof(d3dDSVDesc)); - d3dDSVDesc.Format = TexFormatToDXGI_Format(DSVDesc.Format, BIND_DEPTH_STENCIL); - - switch(DSVDesc.TextureDim) - { - case RESOURCE_DIM_TEX_1D: - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE1D; - d3dDSVDesc.Texture1D.MipSlice = DSVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D: + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE1D; + d3dDSVDesc.Texture1D.MipSlice = DSVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_1D_ARRAY: - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE1DARRAY; - d3dDSVDesc.Texture1DArray.ArraySize = DSVDesc.NumArraySlices; - d3dDSVDesc.Texture1DArray.FirstArraySlice = DSVDesc.FirstArraySlice; - d3dDSVDesc.Texture1DArray.MipSlice = DSVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D_ARRAY: + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE1DARRAY; + d3dDSVDesc.Texture1DArray.ArraySize = DSVDesc.NumArraySlices; + d3dDSVDesc.Texture1DArray.FirstArraySlice = DSVDesc.FirstArraySlice; + d3dDSVDesc.Texture1DArray.MipSlice = DSVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_2D: - if( SampleCount > 1 ) - { - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DMS; - d3dDSVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; - } - else - { - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2D; - d3dDSVDesc.Texture2D.MipSlice = DSVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D: + if (SampleCount > 1) + { + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DMS; + d3dDSVDesc.Texture2DMS.UnusedField_NothingToDefine = 0; + } + else + { + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2D; + d3dDSVDesc.Texture2D.MipSlice = DSVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_2D_ARRAY: - if( SampleCount > 1 ) - { - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DMSARRAY; - d3dDSVDesc.Texture2DMSArray.ArraySize = DSVDesc.NumArraySlices; - d3dDSVDesc.Texture2DMSArray.FirstArraySlice = DSVDesc.FirstArraySlice; - } - else - { - d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DARRAY; - d3dDSVDesc.Texture2DArray.ArraySize = DSVDesc.NumArraySlices; - d3dDSVDesc.Texture2DArray.FirstArraySlice = DSVDesc.FirstArraySlice; - d3dDSVDesc.Texture2DArray.MipSlice = DSVDesc.MostDetailedMip; - } + case RESOURCE_DIM_TEX_2D_ARRAY: + if (SampleCount > 1) + { + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DMSARRAY; + d3dDSVDesc.Texture2DMSArray.ArraySize = DSVDesc.NumArraySlices; + d3dDSVDesc.Texture2DMSArray.FirstArraySlice = DSVDesc.FirstArraySlice; + } + else + { + d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DARRAY; + d3dDSVDesc.Texture2DArray.ArraySize = DSVDesc.NumArraySlices; + d3dDSVDesc.Texture2DArray.FirstArraySlice = DSVDesc.FirstArraySlice; + d3dDSVDesc.Texture2DArray.MipSlice = DSVDesc.MostDetailedMip; + } break; - case RESOURCE_DIM_TEX_3D: - LOG_ERROR_AND_THROW("Depth stencil views are not supported for 3D textures"); + case RESOURCE_DIM_TEX_3D: + LOG_ERROR_AND_THROW("Depth stencil views are not supported for 3D textures"); break; - default: - UNEXPECTED( "Unexpected view type" ); - } + default: + UNEXPECTED("Unexpected view type"); } +} - template - void TextureViewDesc_to_D3D_UAV_DESC(const TextureViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC &d3dUAVDesc) +template +void TextureViewDesc_to_D3D_UAV_DESC(const TextureViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc) +{ + memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc)); + d3dUAVDesc.Format = TexFormatToDXGI_Format(UAVDesc.Format, BIND_UNORDERED_ACCESS); + + switch (UAVDesc.TextureDim) { - memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc)); - d3dUAVDesc.Format = TexFormatToDXGI_Format(UAVDesc.Format, BIND_UNORDERED_ACCESS); - - switch(UAVDesc.TextureDim) - { - case RESOURCE_DIM_TEX_1D: - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE1D; - d3dUAVDesc.Texture1D.MipSlice = UAVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D: + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE1D; + d3dUAVDesc.Texture1D.MipSlice = UAVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_1D_ARRAY: - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE1DARRAY; - d3dUAVDesc.Texture1DArray.ArraySize = UAVDesc.NumArraySlices; - d3dUAVDesc.Texture1DArray.FirstArraySlice = UAVDesc.FirstArraySlice; - d3dUAVDesc.Texture1DArray.MipSlice = UAVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_1D_ARRAY: + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE1DARRAY; + d3dUAVDesc.Texture1DArray.ArraySize = UAVDesc.NumArraySlices; + d3dUAVDesc.Texture1DArray.FirstArraySlice = UAVDesc.FirstArraySlice; + d3dUAVDesc.Texture1DArray.MipSlice = UAVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_2D: - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE2D; - d3dUAVDesc.Texture2D.MipSlice = UAVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_2D: + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE2D; + d3dUAVDesc.Texture2D.MipSlice = UAVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_2D_ARRAY: - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE2DARRAY; - d3dUAVDesc.Texture2DArray.ArraySize = UAVDesc.NumArraySlices; - d3dUAVDesc.Texture2DArray.FirstArraySlice = UAVDesc.FirstArraySlice; - d3dUAVDesc.Texture2DArray.MipSlice = UAVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_2D_ARRAY: + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE2DARRAY; + d3dUAVDesc.Texture2DArray.ArraySize = UAVDesc.NumArraySlices; + d3dUAVDesc.Texture2DArray.FirstArraySlice = UAVDesc.FirstArraySlice; + d3dUAVDesc.Texture2DArray.MipSlice = UAVDesc.MostDetailedMip; break; - case RESOURCE_DIM_TEX_3D: - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE3D; - d3dUAVDesc.Texture3D.FirstWSlice = UAVDesc.FirstDepthSlice; - d3dUAVDesc.Texture3D.WSize = UAVDesc.NumDepthSlices; - d3dUAVDesc.Texture3D.MipSlice = UAVDesc.MostDetailedMip; + case RESOURCE_DIM_TEX_3D: + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_TEXTURE3D; + d3dUAVDesc.Texture3D.FirstWSlice = UAVDesc.FirstDepthSlice; + d3dUAVDesc.Texture3D.WSize = UAVDesc.NumDepthSlices; + d3dUAVDesc.Texture3D.MipSlice = UAVDesc.MostDetailedMip; break; - default: - UNEXPECTED( "Unexpected view type" ); - } + default: + UNEXPECTED("Unexpected view type"); + } +} + +template +void BufferViewDesc_to_D3D_SRV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& SRVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dSRVDesc) +{ + VERIFY(SRVDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE, "Incorrect view type: shader resource is expected"); + + memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc)); + const auto& BuffFmt = SRVDesc.Format; + if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) + d3dSRVDesc.Format = TypeToDXGI_Format(BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized); + + Uint32 ElementByteStride = 0; + if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) + ElementByteStride = BuffDesc.ElementByteStride; + else if (BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED) + ElementByteStride = 4; + + if (ElementByteStride != 0) + { + DEV_CHECK_ERR((SRVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", SRVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")"); + DEV_CHECK_ERR((SRVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", SRVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")"); + d3dSRVDesc.Buffer.FirstElement = SRVDesc.ByteOffset / ElementByteStride; + d3dSRVDesc.Buffer.NumElements = SRVDesc.ByteWidth / ElementByteStride; } + d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_BUFFER; +} + +template +void BufferViewDesc_to_D3D_UAV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc) +{ + VERIFY(UAVDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS, "Incorrect view type: unordered access is expected"); + + memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc)); + const auto& BuffFmt = UAVDesc.Format; + if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) + d3dUAVDesc.Format = TypeToDXGI_Format(BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized); - template - void BufferViewDesc_to_D3D_SRV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& SRVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dSRVDesc) + Uint32 ElementByteStride = 0; + if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) + ElementByteStride = BuffDesc.ElementByteStride; + else if (BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED) + ElementByteStride = 4; + + if (ElementByteStride != 0) { - VERIFY(SRVDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE, "Incorrect view type: shader resource is expected" ); - - memset( &d3dSRVDesc, 0, sizeof( d3dSRVDesc ) ); - const auto& BuffFmt = SRVDesc.Format; - if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) - d3dSRVDesc.Format = TypeToDXGI_Format( BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized ); - - Uint32 ElementByteStride = 0; - if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) - ElementByteStride = BuffDesc.ElementByteStride; - else if(BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED) - ElementByteStride = 4; - - if (ElementByteStride != 0) - { - DEV_CHECK_ERR( (SRVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", SRVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")" ); - DEV_CHECK_ERR( (SRVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", SRVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")" ); - d3dSRVDesc.Buffer.FirstElement = SRVDesc.ByteOffset / ElementByteStride; - d3dSRVDesc.Buffer.NumElements = SRVDesc.ByteWidth / ElementByteStride; - } - d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_BUFFER; + DEV_CHECK_ERR((UAVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", UAVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")"); + DEV_CHECK_ERR((UAVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", UAVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")"); + d3dUAVDesc.Buffer.FirstElement = UAVDesc.ByteOffset / ElementByteStride; + d3dUAVDesc.Buffer.NumElements = UAVDesc.ByteWidth / ElementByteStride; } - template - void BufferViewDesc_to_D3D_UAV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc) + if (BuffDesc.Mode == BUFFER_MODE_RAW && UAVDesc.Format.ValueType == VT_UNDEFINED) { - VERIFY(UAVDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS, "Incorrect view type: unordered access is expected"); - - memset( &d3dUAVDesc, 0, sizeof(d3dUAVDesc) ); - const auto& BuffFmt = UAVDesc.Format; - if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) - d3dUAVDesc.Format = TypeToDXGI_Format( BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized ); - - Uint32 ElementByteStride = 0; - if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED) - ElementByteStride = BuffDesc.ElementByteStride; - else if(BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED) - ElementByteStride = 4; - - if (ElementByteStride != 0) - { - DEV_CHECK_ERR( (UAVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", UAVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")" ); - DEV_CHECK_ERR( (UAVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", UAVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")" ); - d3dUAVDesc.Buffer.FirstElement = UAVDesc.ByteOffset / ElementByteStride; - d3dUAVDesc.Buffer.NumElements = UAVDesc.ByteWidth / ElementByteStride; - } - - if (BuffDesc.Mode == BUFFER_MODE_RAW && UAVDesc.Format.ValueType == VT_UNDEFINED) - { - d3dUAVDesc.Format = DXGI_FORMAT_R32_TYPELESS; - d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_RAW; - } - else - d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_NONE; - - d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_BUFFER; + d3dUAVDesc.Format = DXGI_FORMAT_R32_TYPELESS; + d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_RAW; } + else + d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_NONE; + + d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_BUFFER; } + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h b/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h index 8d71f9c0..c1a972be 100644 --- a/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h +++ b/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h @@ -31,8 +31,7 @@ namespace Diligent { - DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags = 0); - TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat); - DXGI_FORMAT TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized); -} - +DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags = 0); +TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat); +DXGI_FORMAT TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized); +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h index fac7683c..a13379a7 100644 --- a/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h +++ b/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h @@ -32,20 +32,20 @@ namespace Diligent { -template +template class EngineFactoryD3DBase : public EngineFactoryBase { public: using TEngineFactoryBase = EngineFactoryBase; - EngineFactoryD3DBase(const INTERFACE_ID& FactoryIID) : - TEngineFactoryBase(FactoryIID) + EngineFactoryD3DBase(const INTERFACE_ID& FactoryIID) : + TEngineFactoryBase{FactoryIID} {} - virtual void EnumerateHardwareAdapters(DIRECT3D_FEATURE_LEVEL MinFeatureLevel, - Uint32& NumAdapters, - HardwareAdapterAttribs* Adapters)override final + virtual void EnumerateHardwareAdapters(DIRECT3D_FEATURE_LEVEL MinFeatureLevel, + Uint32& NumAdapters, + HardwareAdapterAttribs* Adapters) override final { auto DXGIAdapters = FindCompatibleAdapters(MinFeatureLevel); @@ -56,17 +56,17 @@ public: NumAdapters = std::min(NumAdapters, static_cast(DXGIAdapters.size())); for (Uint32 adapter = 0; adapter < NumAdapters; ++adapter) { - IDXGIAdapter1 *pDXIAdapter = DXGIAdapters[adapter]; + IDXGIAdapter1* pDXIAdapter = DXGIAdapters[adapter]; DXGI_ADAPTER_DESC1 AdapterDesc; pDXIAdapter->GetDesc1(&AdapterDesc); - auto &Attribs = Adapters[adapter]; + auto& Attribs = Adapters[adapter]; WideCharToMultiByte(CP_ACP, 0, AdapterDesc.Description, -1, Attribs.Description, _countof(Attribs.Description), NULL, FALSE); - Attribs.DedicatedVideoMemory = AdapterDesc.DedicatedVideoMemory; + Attribs.DedicatedVideoMemory = AdapterDesc.DedicatedVideoMemory; Attribs.DedicatedSystemMemory = AdapterDesc.DedicatedSystemMemory; - Attribs.SharedSystemMemory = AdapterDesc.SharedSystemMemory; - Attribs.VendorId = AdapterDesc.VendorId; - Attribs.DeviceId = AdapterDesc.DeviceId; + Attribs.SharedSystemMemory = AdapterDesc.SharedSystemMemory; + Attribs.VendorId = AdapterDesc.VendorId; + Attribs.DeviceId = AdapterDesc.DeviceId; Attribs.NumOutputs = 0; CComPtr pOutput; @@ -81,22 +81,22 @@ public: virtual void EnumerateDisplayModes(DIRECT3D_FEATURE_LEVEL MinFeatureLevel, - Uint32 AdapterId, + Uint32 AdapterId, Uint32 OutputId, - TEXTURE_FORMAT Format, - Uint32& NumDisplayModes, - DisplayModeAttribs* DisplayModes)override final + TEXTURE_FORMAT Format, + Uint32& NumDisplayModes, + DisplayModeAttribs* DisplayModes) override final { auto DXGIAdapters = FindCompatibleAdapters(MinFeatureLevel); - if(AdapterId >= DXGIAdapters.size()) + if (AdapterId >= DXGIAdapters.size()) { LOG_ERROR("Incorrect adapter id ", AdapterId); return; } - IDXGIAdapter1 *pDXIAdapter = DXGIAdapters[AdapterId]; + IDXGIAdapter1* pDXIAdapter = DXGIAdapters[AdapterId]; - DXGI_FORMAT DXIGFormat = TexFormatToDXGI_Format(Format); + DXGI_FORMAT DXIGFormat = TexFormatToDXGI_Format(Format); CComPtr pOutput; if (pDXIAdapter->EnumOutputs(OutputId, &pOutput) == DXGI_ERROR_NOT_FOUND) { @@ -118,15 +118,15 @@ public: hr = pOutput->GetDisplayModeList(DXIGFormat, 0, &numModes, DXIDisplayModes.data()); for (Uint32 m = 0; m < std::min(NumDisplayModes, numModes); ++m) { - const auto &SrcMode = DXIDisplayModes[m]; - auto &DstMode = DisplayModes[m]; - DstMode.Width = SrcMode.Width; - DstMode.Height = SrcMode.Height; - DstMode.Format = DXGI_FormatToTexFormat(SrcMode.Format); - DstMode.RefreshRateNumerator = SrcMode.RefreshRate.Numerator; + const auto& SrcMode = DXIDisplayModes[m]; + auto& DstMode = DisplayModes[m]; + DstMode.Width = SrcMode.Width; + DstMode.Height = SrcMode.Height; + DstMode.Format = DXGI_FormatToTexFormat(SrcMode.Format); + DstMode.RefreshRateNumerator = SrcMode.RefreshRate.Numerator; DstMode.RefreshRateDenominator = SrcMode.RefreshRate.Denominator; - DstMode.Scaling = static_cast(SrcMode.Scaling); - DstMode.ScanlineOrder = static_cast(SrcMode.ScanlineOrdering); + DstMode.Scaling = static_cast(SrcMode.Scaling); + DstMode.ScanlineOrder = static_cast(SrcMode.ScanlineOrdering); } NumDisplayModes = std::min(NumDisplayModes, numModes); } @@ -148,9 +148,9 @@ public: return std::move(DXGIAdapters); } - auto d3dFeatureLevel = GetD3DFeatureLevel(MinFeatureLevel); + auto d3dFeatureLevel = GetD3DFeatureLevel(MinFeatureLevel); CComPtr pDXIAdapter; - UINT adapter = 0; + UINT adapter = 0; for (; pFactory->EnumAdapters1(adapter, &pDXIAdapter) != DXGI_ERROR_NOT_FOUND; ++adapter, pDXIAdapter.Release()) { DXGI_ADAPTER_DESC1 AdapterDesc; @@ -173,16 +173,15 @@ public: protected: - static D3D_FEATURE_LEVEL GetD3DFeatureLevel(DIRECT3D_FEATURE_LEVEL FeatureLevel) { - switch(FeatureLevel) + switch (FeatureLevel) { case DIRECT3D_FEATURE_LEVEL_10_0: return D3D_FEATURE_LEVEL_10_0; case DIRECT3D_FEATURE_LEVEL_10_1: return D3D_FEATURE_LEVEL_10_1; case DIRECT3D_FEATURE_LEVEL_11_0: return D3D_FEATURE_LEVEL_11_0; case DIRECT3D_FEATURE_LEVEL_11_1: return D3D_FEATURE_LEVEL_11_1; -#if defined(_WIN32_WINNT_WIN10) && (_WIN32_WINNT >=_WIN32_WINNT_WIN10) +#if defined(_WIN32_WINNT_WIN10) && (_WIN32_WINNT >= _WIN32_WINNT_WIN10) case DIRECT3D_FEATURE_LEVEL_12_0: return D3D_FEATURE_LEVEL_12_0; case DIRECT3D_FEATURE_LEVEL_12_1: return D3D_FEATURE_LEVEL_12_1; #endif @@ -194,31 +193,30 @@ protected: } private: - - template + template bool CheckAdapterCompatibility(IDXGIAdapter1* pDXGIAdapter, D3D_FEATURE_LEVEL FeatureLevels); - template<> + template <> bool CheckAdapterCompatibility(IDXGIAdapter1* pDXGIAdapter, D3D_FEATURE_LEVEL FeatureLevel) { - auto hr = D3D11CreateDevice( - nullptr, - D3D_DRIVER_TYPE_NULL, // There is no need to create a real hardware device. - 0, - 0, // Flags. - &FeatureLevel, // Feature levels. - 1, // Number of feature levels - D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION for Windows Store apps. - nullptr, // No need to keep the D3D device reference. - nullptr, // Feature level of the created adapter. - nullptr // No need to keep the D3D device context reference. - ); - return SUCCEEDED(hr); + auto hr = D3D11CreateDevice( + nullptr, + D3D_DRIVER_TYPE_NULL, // There is no need to create a real hardware device. + 0, + 0, // Flags. + &FeatureLevel, // Feature levels. + 1, // Number of feature levels + D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION for Windows Store apps. + nullptr, // No need to keep the D3D device reference. + nullptr, // Feature level of the created adapter. + nullptr // No need to keep the D3D device context reference. + ); + return SUCCEEDED(hr); } - template<> + template <> bool CheckAdapterCompatibility(IDXGIAdapter1* pDXGIAdapter, D3D_FEATURE_LEVEL FeatureLevel) { @@ -227,4 +225,4 @@ private: } }; -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h index af82ccac..b0ae8dcb 100644 --- a/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h +++ b/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h @@ -33,19 +33,20 @@ namespace Diligent /// Base implementation of a D3D render device -template +template class RenderDeviceD3DBase : public RenderDeviceBase { public: - RenderDeviceD3DBase(IReferenceCounters* pRefCounters, - IMemoryAllocator& RawMemAllocator, + RenderDeviceD3DBase(IReferenceCounters* pRefCounters, + IMemoryAllocator& RawMemAllocator, IEngineFactory* pEngineFactory, Uint32 NumDeferredContexts, - const DeviceObjectSizes& ObjectSizes) : - RenderDeviceBase(pRefCounters, RawMemAllocator, pEngineFactory, NumDeferredContexts, ObjectSizes) + const DeviceObjectSizes& ObjectSizes) : + RenderDeviceBase{pRefCounters, RawMemAllocator, pEngineFactory, NumDeferredContexts, ObjectSizes} { // Flag texture formats always supported in D3D11 and D3D12 + // clang-format off #define FLAG_FORMAT(Fmt, IsSupported) m_TextureFormatsInfo[Fmt].Supported=IsSupported FLAG_FORMAT(TEX_FORMAT_RGBA32_TYPELESS, true); @@ -148,7 +149,8 @@ public: FLAG_FORMAT(TEX_FORMAT_BC7_UNORM, true); FLAG_FORMAT(TEX_FORMAT_BC7_UNORM_SRGB, true); #undef FLAG_FORMAT + // clang-format on } }; -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h index c8c4de8f..17c86b6f 100644 --- a/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h +++ b/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h @@ -32,13 +32,15 @@ namespace Diligent { - /// Base implementation of a D3D shader - class ShaderD3DBase - { - public: - ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel); - - protected: - CComPtr m_pShaderByteCode; - }; -} + +/// Base implementation of a D3D shader +class ShaderD3DBase +{ +public: + ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel); + +protected: + CComPtr m_pShaderByteCode; +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h index d15484a0..0e08c547 100644 --- a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h +++ b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h @@ -40,10 +40,10 @@ // Nbsrv - number of buffer SRVs // Nbuav - number of buffer UAVs // Nsam - number of samplers -// +// // // If texture SRV is assigned a sampler, it is cross-referenced through SamplerOrTexSRVId: -// +// // _____________________SamplerOrTexSRVId___________________ // | | // | V @@ -68,8 +68,10 @@ namespace Diligent { // sizeof(D3DShaderResourceAttribs) == 16 (x64) -struct D3DShaderResourceAttribs +struct D3DShaderResourceAttribs { + // clang-format off + /* 0 */ const char* const Name; /* 8 */ const Uint16 BindPoint; @@ -97,6 +99,8 @@ private: /*13.0*/ Uint32 SamplerOrTexSRVId : SamplerOrTexSRVIdBits; // Max value: 2^24-1 /*16 */ // End of structure + // clang-format on + public: static constexpr const Uint32 InvalidSamplerId = (1 << SamplerOrTexSRVIdBits) - 1; static constexpr const Uint32 InvalidTexSRVId = (1 << SamplerOrTexSRVIdBits) - 1; @@ -105,25 +109,29 @@ public: static constexpr const Uint16 MaxBindCount = std::numeric_limits::max(); - D3DShaderResourceAttribs(const char* _Name, - UINT _BindPoint, - UINT _BindCount, - D3D_SHADER_INPUT_TYPE _InputType, - D3D_SRV_DIMENSION _SRVDimension, - Uint32 _SamplerId)noexcept : - Name (_Name), - BindPoint (static_cast (_BindPoint)), - BindCount (static_cast (_BindCount)), - InputType (static_cast (_InputType)), - SRVDimension (static_cast(_SRVDimension)), - SamplerOrTexSRVId (_SamplerId) + D3DShaderResourceAttribs(const char* _Name, + UINT _BindPoint, + UINT _BindCount, + D3D_SHADER_INPUT_TYPE _InputType, + D3D_SRV_DIMENSION _SRVDimension, + Uint32 _SamplerId) noexcept : + // clang-format off + Name {_Name}, + BindPoint {static_cast (_BindPoint) }, + BindCount {static_cast (_BindCount) }, + InputType {static_cast (_InputType) }, + SRVDimension {static_cast(_SRVDimension)}, + SamplerOrTexSRVId {_SamplerId} + // clang-format on { #ifdef _DEBUG + // clang-format off VERIFY(_BindPoint <= MaxBindPoint || _BindPoint == InvalidBindPoint, "Bind Point is out of allowed range"); VERIFY(_BindCount <= MaxBindCount, "Bind Count is out of allowed range"); VERIFY(_InputType < (1 << ShaderInputTypeBits), "Shader input type is out of expected range"); VERIFY(_SRVDimension < (1 << SRVDimBits), "SRV dimensions is out of expected range"); VERIFY(_SamplerId < (1 << SamplerOrTexSRVIdBits), "SamplerOrTexSRVId is out of representable range"); + // clang-format on if (_InputType == D3D_SIT_TEXTURE && _SRVDimension != D3D_SRV_DIMENSION_BUFFER) VERIFY_EXPR(GetCombinedSamplerId() == _SamplerId); @@ -132,7 +140,8 @@ public: #endif } - D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs, Uint32 SamplerId)noexcept : + D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs, Uint32 SamplerId) noexcept : + // clang-format off D3DShaderResourceAttribs { NamesPool.CopyString(rhs.Name), @@ -142,11 +151,13 @@ public: rhs.GetSRVDimension(), SamplerId } + // clang-format on { VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Only texture SRV can be assigned a texture sampler"); } - D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs)noexcept : + D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs) noexcept : + // clang-format off D3DShaderResourceAttribs { NamesPool.CopyString(rhs.Name), @@ -156,105 +167,111 @@ public: rhs.GetSRVDimension(), rhs.SamplerOrTexSRVId } + // clang-format on { } + // clang-format off D3DShaderResourceAttribs (const D3DShaderResourceAttribs& rhs) = delete; D3DShaderResourceAttribs ( D3DShaderResourceAttribs&& rhs) = default; // Required for vector D3DShaderResourceAttribs& operator = (const D3DShaderResourceAttribs& rhs) = delete; D3DShaderResourceAttribs& operator = ( D3DShaderResourceAttribs&& rhs) = delete; - - D3D_SHADER_INPUT_TYPE GetInputType()const + // clang-format on + + D3D_SHADER_INPUT_TYPE GetInputType() const { return static_cast(InputType); } - D3D_SRV_DIMENSION GetSRVDimension()const + D3D_SRV_DIMENSION GetSRVDimension() const { return static_cast(SRVDimension); } - bool IsCombinedWithSampler()const + bool IsCombinedWithSampler() const { return GetCombinedSamplerId() != InvalidSamplerId; } - bool IsCombinedWithTexSRV()const + bool IsCombinedWithTexSRV() const { return GetCombinedTexSRVId() != InvalidTexSRVId; } - bool IsValidBindPoint()const + bool IsValidBindPoint() const { return BindPoint != InvalidBindPoint; } - String GetPrintName(Uint32 ArrayInd)const + String GetPrintName(Uint32 ArrayInd) const { VERIFY_EXPR(ArrayInd < BindCount); - if(BindCount > 1) + if (BindCount > 1) return String(Name) + '[' + std::to_string(ArrayInd) + ']'; else return Name; } - bool IsCompatibleWith(const D3DShaderResourceAttribs& Attribs)const + bool IsCompatibleWith(const D3DShaderResourceAttribs& Attribs) const { - return BindPoint == Attribs.BindPoint && - BindCount == Attribs.BindCount && - InputType == Attribs.InputType && - SRVDimension == Attribs.SRVDimension && - SamplerOrTexSRVId == Attribs.SamplerOrTexSRVId; + return BindPoint == Attribs.BindPoint && + BindCount == Attribs.BindCount && + InputType == Attribs.InputType && + SRVDimension == Attribs.SRVDimension && + SamplerOrTexSRVId == Attribs.SamplerOrTexSRVId; } - size_t GetHash()const + size_t GetHash() const { return ComputeHash(BindPoint, BindCount, InputType, SRVDimension, SamplerOrTexSRVId); } - HLSLShaderResourceDesc GetHLSLResourceDesc()const; + HLSLShaderResourceDesc GetHLSLResourceDesc() const; private: friend class ShaderResources; - Uint32 GetCombinedSamplerId()const + Uint32 GetCombinedSamplerId() const { - VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Invalid input type: D3D_SIT_TEXTURE is expected" ); + VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Invalid input type: D3D_SIT_TEXTURE is expected"); return SamplerOrTexSRVId; } void SetTexSRVId(Uint32 TexSRVId) { - VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected" ); + VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected"); VERIFY(TexSRVId < (1 << SamplerOrTexSRVIdBits), "TexSRVId (", TexSRVId, ") is out of representable range"); SamplerOrTexSRVId = TexSRVId; } - Uint32 GetCombinedTexSRVId()const + Uint32 GetCombinedTexSRVId() const { - VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected" ); + VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected"); return SamplerOrTexSRVId; } }; -static_assert(sizeof(D3DShaderResourceAttribs) == sizeof(void*) + sizeof(Uint32)*2, "Unexpected sizeof(D3DShaderResourceAttribs)"); +static_assert(sizeof(D3DShaderResourceAttribs) == sizeof(void*) + sizeof(Uint32) * 2, "Unexpected sizeof(D3DShaderResourceAttribs)"); /// Diligent::ShaderResources class class ShaderResources { public: - ShaderResources(SHADER_TYPE ShaderType)noexcept : - m_ShaderType(ShaderType) + ShaderResources(SHADER_TYPE ShaderType) noexcept : + m_ShaderType{ShaderType} { } + // clang-format off ShaderResources (const ShaderResources&) = delete; ShaderResources ( ShaderResources&&) = delete; ShaderResources& operator = (const ShaderResources&) = delete; ShaderResources& operator = ( ShaderResources&&) = delete; - + // clang-format on + ~ShaderResources(); - + + // clang-format off Uint32 GetNumCBs() const noexcept { return (m_TexSRVOffset - 0); } Uint32 GetNumTexSRV() const noexcept { return (m_TexUAVOffset - m_TexSRVOffset); } Uint32 GetNumTexUAV() const noexcept { return (m_BufSRVOffset - m_TexUAVOffset); } @@ -269,67 +286,68 @@ public: const D3DShaderResourceAttribs& GetBufSRV (Uint32 n)const noexcept { return GetResAttribs(n, GetNumBufSRV(), m_BufSRVOffset); } const D3DShaderResourceAttribs& GetBufUAV (Uint32 n)const noexcept { return GetResAttribs(n, GetNumBufUAV(), m_BufUAVOffset); } const D3DShaderResourceAttribs& GetSampler(Uint32 n)const noexcept { return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); } + // clang-format on - const D3DShaderResourceAttribs& GetCombinedSampler(const D3DShaderResourceAttribs& TexSRV)const noexcept + const D3DShaderResourceAttribs& GetCombinedSampler(const D3DShaderResourceAttribs& TexSRV) const noexcept { VERIFY(TexSRV.IsCombinedWithSampler(), "This texture SRV is not combined with any sampler"); return GetSampler(TexSRV.GetCombinedSamplerId()); } - const D3DShaderResourceAttribs& GetCombinedTextureSRV(const D3DShaderResourceAttribs& Sampler)const noexcept + const D3DShaderResourceAttribs& GetCombinedTextureSRV(const D3DShaderResourceAttribs& Sampler) const noexcept { VERIFY(Sampler.IsCombinedWithTexSRV(), "This sampler is not combined with any texture SRV"); return GetTexSRV(Sampler.GetCombinedTexSRVId()); } - SHADER_TYPE GetShaderType()const noexcept{return m_ShaderType;} - - HLSLShaderResourceDesc GetHLSLShaderResourceDesc(Uint32 Index)const; - - template - void ProcessResources(THandleCB HandleCB, - THandleSampler HandleSampler, - THandleTexSRV HandleTexSRV, - THandleTexUAV HandleTexUAV, - THandleBufSRV HandleBufSRV, - THandleBufUAV HandleBufUAV)const + SHADER_TYPE GetShaderType() const noexcept { return m_ShaderType; } + + HLSLShaderResourceDesc GetHLSLShaderResourceDesc(Uint32 Index) const; + + template + void ProcessResources(THandleCB HandleCB, + THandleSampler HandleSampler, + THandleTexSRV HandleTexSRV, + THandleTexUAV HandleTexUAV, + THandleBufSRV HandleBufSRV, + THandleBufUAV HandleBufUAV) const { - for (Uint32 n=0; n < GetNumCBs(); ++n) + for (Uint32 n = 0; n < GetNumCBs(); ++n) { const auto& CB = GetCB(n); HandleCB(CB, n); } - for (Uint32 n=0; n < GetNumSamplers(); ++n) + for (Uint32 n = 0; n < GetNumSamplers(); ++n) { const auto& Sampler = GetSampler(n); HandleSampler(Sampler, n); } - for (Uint32 n=0; n < GetNumTexSRV(); ++n) + for (Uint32 n = 0; n < GetNumTexSRV(); ++n) { const auto& TexSRV = GetTexSRV(n); HandleTexSRV(TexSRV, n); } - - for (Uint32 n=0; n < GetNumTexUAV(); ++n) + + for (Uint32 n = 0; n < GetNumTexUAV(); ++n) { const auto& TexUAV = GetTexUAV(n); HandleTexUAV(TexUAV, n); } - for (Uint32 n=0; n < GetNumBufSRV(); ++n) + for (Uint32 n = 0; n < GetNumBufSRV(); ++n) { const auto& BufSRV = GetBufSRV(n); HandleBufSRV(BufSRV, n); } - for (Uint32 n=0; n < GetNumBufUAV(); ++n) + for (Uint32 n = 0; n < GetNumBufUAV(); ++n) { const auto& BufUAV = GetBufUAV(n); HandleBufUAV(BufUAV, n); @@ -338,91 +356,93 @@ public: bool IsCompatibleWith(const ShaderResources& Resources) const; bool IsUsingCombinedTextureSamplers() const { return m_SamplerSuffix != nullptr; } - const char* GetCombinedSamplerSuffix() const { return m_SamplerSuffix; } - const Char* GetShaderName() const { return m_ShaderName; } + const char* GetCombinedSamplerSuffix() const { return m_SamplerSuffix; } + const Char* GetShaderName() const { return m_ShaderName; } - size_t GetHash()const; + size_t GetHash() const; SHADER_RESOURCE_VARIABLE_TYPE FindVariableType(const D3DShaderResourceAttribs& ResourceAttribs, - const PipelineResourceLayoutDesc& ResourceLayout)const; + const PipelineResourceLayoutDesc& ResourceLayout) const; Int32 FindStaticSampler(const D3DShaderResourceAttribs& ResourceAttribs, const PipelineResourceLayoutDesc& ResourceLayoutDesc, - bool LogStaticSamplerArrayError)const; + bool LogStaticSamplerArrayError) const; D3DShaderResourceCounters CountResources(const PipelineResourceLayoutDesc& ResourceLayout, const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes, Uint32 NumAllowedTypes, - bool CountStaticSamplers)const noexcept; + bool CountStaticSamplers) const noexcept; #ifdef DEVELOPMENT static void DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& ResourceLayout, const ShaderResources* const pShaderResources[], Uint32 NumShaders); #endif - void GetShaderModel(Uint32& Major, Uint32& Minor)const + void GetShaderModel(Uint32& Major, Uint32& Minor) const { Major = (m_ShaderVersion & 0x000000F0) >> 4; Minor = (m_ShaderVersion & 0x0000000F); } protected: - template - void Initialize(ID3DBlob* pShaderByteCode, - TNewResourceHandler NewResHandler, + template + void Initialize(ID3DBlob* pShaderByteCode, + TNewResourceHandler NewResHandler, const Char* ShaderName, const Char* SamplerSuffix); - __forceinline D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset)noexcept + __forceinline D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset) noexcept { VERIFY(n < NumResources, "Resource index (", n, ") is out of range. Resource array size: ", NumResources); VERIFY_EXPR(Offset + n < m_TotalResources); return reinterpret_cast(m_MemoryBuffer.get())[Offset + n]; } - __forceinline const D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset)const noexcept + __forceinline const D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset) const noexcept { VERIFY(n < NumResources, "Resource index (", n, ") is out of range. Resource array size: ", NumResources); VERIFY_EXPR(Offset + n < m_TotalResources); return reinterpret_cast(m_MemoryBuffer.get())[Offset + n]; } - D3DShaderResourceAttribs& GetCB (Uint32 n)noexcept{ return GetResAttribs(n, GetNumCBs(), 0); } - D3DShaderResourceAttribs& GetTexSRV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumTexSRV(), m_TexSRVOffset); } - D3DShaderResourceAttribs& GetTexUAV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumTexUAV(), m_TexUAVOffset); } - D3DShaderResourceAttribs& GetBufSRV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumBufSRV(), m_BufSRVOffset); } - D3DShaderResourceAttribs& GetBufUAV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumBufUAV(), m_BufUAVOffset); } - D3DShaderResourceAttribs& GetSampler(Uint32 n)noexcept{ return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); } + // clang-format off + D3DShaderResourceAttribs& GetCB(Uint32 n) noexcept { return GetResAttribs(n, GetNumCBs(), 0); } + D3DShaderResourceAttribs& GetTexSRV(Uint32 n) noexcept { return GetResAttribs(n, GetNumTexSRV(), m_TexSRVOffset); } + D3DShaderResourceAttribs& GetTexUAV(Uint32 n) noexcept { return GetResAttribs(n, GetNumTexUAV(), m_TexUAVOffset); } + D3DShaderResourceAttribs& GetBufSRV(Uint32 n) noexcept { return GetResAttribs(n, GetNumBufSRV(), m_BufSRVOffset); } + D3DShaderResourceAttribs& GetBufUAV(Uint32 n) noexcept { return GetResAttribs(n, GetNumBufUAV(), m_BufUAVOffset); } + D3DShaderResourceAttribs& GetSampler(Uint32 n) noexcept { return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); } + // clang-format on private: - void AllocateMemory(IMemoryAllocator& Allocator, + void AllocateMemory(IMemoryAllocator& Allocator, const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize); - Uint32 FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix)const; + Uint32 FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix) const; // Memory buffer that holds all resources as continuous chunk of memory: // | CBs | TexSRVs | TexUAVs | BufSRVs | BufUAVs | Samplers | Resource Names | // - std::unique_ptr< void, STDDeleterRawMem > m_MemoryBuffer; + std::unique_ptr> m_MemoryBuffer; StringPool m_ResourceNames; - const char* m_SamplerSuffix = nullptr; // The suffix and the shader name + const char* m_SamplerSuffix = nullptr; // The suffix and the shader name const char* m_ShaderName = nullptr; // are put into the m_ResourceNames // Offsets in elements of D3DShaderResourceAttribs typedef Uint16 OffsetType; - OffsetType m_TexSRVOffset = 0; - OffsetType m_TexUAVOffset = 0; - OffsetType m_BufSRVOffset = 0; - OffsetType m_BufUAVOffset = 0; - OffsetType m_SamplersOffset = 0; - OffsetType m_TotalResources = 0; + OffsetType m_TexSRVOffset = 0; + OffsetType m_TexUAVOffset = 0; + OffsetType m_BufSRVOffset = 0; + OffsetType m_BufUAVOffset = 0; + OffsetType m_SamplersOffset = 0; + OffsetType m_TotalResources = 0; const SHADER_TYPE m_ShaderType; @@ -430,11 +450,11 @@ private: }; -template -void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, +template +void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, TNewResourceHandler NewResHandler, const Char* ShaderName, const Char* CombinedSamplerSuffix) @@ -443,63 +463,63 @@ void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, LoadD3DShaderResources( pShaderByteCode, - [&](const D3D_SHADER_DESC& d3dShaderDesc) + [&](const D3D_SHADER_DESC& d3dShaderDesc) // { m_ShaderVersion = d3dShaderDesc.Version; }, - [&](const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize) + [&](const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize) // { VERIFY_EXPR(ShaderName != nullptr); - ResourceNamesPoolSize += strlen(ShaderName)+1; + ResourceNamesPoolSize += strlen(ShaderName) + 1; if (CombinedSamplerSuffix != nullptr) - ResourceNamesPoolSize += strlen(CombinedSamplerSuffix)+1; + ResourceNamesPoolSize += strlen(CombinedSamplerSuffix) + 1; AllocateMemory(GetRawAllocator(), ResCounters, ResourceNamesPoolSize); }, - [&](const D3DShaderResourceAttribs& CBAttribs) + [&](const D3DShaderResourceAttribs& CBAttribs) // { VERIFY_EXPR(CBAttribs.GetInputType() == D3D_SIT_CBUFFER); auto* pNewCB = new (&GetCB(CurrCB++)) D3DShaderResourceAttribs(m_ResourceNames, CBAttribs); NewResHandler.OnNewCB(*pNewCB); }, - [&](const D3DShaderResourceAttribs& TexUAV) + [&](const D3DShaderResourceAttribs& TexUAV) // { VERIFY_EXPR(TexUAV.GetInputType() == D3D_SIT_UAV_RWTYPED && TexUAV.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER); auto* pNewTexUAV = new (&GetTexUAV(CurrTexUAV++)) D3DShaderResourceAttribs(m_ResourceNames, TexUAV); NewResHandler.OnNewTexUAV(*pNewTexUAV); }, - [&](const D3DShaderResourceAttribs& BuffUAV) + [&](const D3DShaderResourceAttribs& BuffUAV) // { VERIFY_EXPR(BuffUAV.GetInputType() == D3D_SIT_UAV_RWTYPED && BuffUAV.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER || BuffUAV.GetInputType() == D3D_SIT_UAV_RWSTRUCTURED || BuffUAV.GetInputType() == D3D_SIT_UAV_RWBYTEADDRESS); auto* pNewBufUAV = new (&GetBufUAV(CurrBufUAV++)) D3DShaderResourceAttribs(m_ResourceNames, BuffUAV); NewResHandler.OnNewBuffUAV(*pNewBufUAV); }, - [&](const D3DShaderResourceAttribs& BuffSRV) + [&](const D3DShaderResourceAttribs& BuffSRV) // { VERIFY_EXPR(BuffSRV.GetInputType() == D3D_SIT_TEXTURE && BuffSRV.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER || BuffSRV.GetInputType() == D3D_SIT_STRUCTURED || BuffSRV.GetInputType() == D3D_SIT_BYTEADDRESS); auto* pNewBuffSRV = new (&GetBufSRV(CurrBufSRV++)) D3DShaderResourceAttribs(m_ResourceNames, BuffSRV); NewResHandler.OnNewBuffSRV(*pNewBuffSRV); }, - [&](const D3DShaderResourceAttribs& SamplerAttribs) + [&](const D3DShaderResourceAttribs& SamplerAttribs) // { VERIFY_EXPR(SamplerAttribs.GetInputType() == D3D_SIT_SAMPLER); auto* pNewSampler = new (&GetSampler(CurrSampler++)) D3DShaderResourceAttribs(m_ResourceNames, SamplerAttribs); NewResHandler.OnNewSampler(*pNewSampler); }, - [&](const D3DShaderResourceAttribs& TexAttribs) + [&](const D3DShaderResourceAttribs& TexAttribs) // { VERIFY_EXPR(TexAttribs.GetInputType() == D3D_SIT_TEXTURE && TexAttribs.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER); - VERIFY(CurrSampler == GetNumSamplers(), "All samplers must be initialized before texture SRVs" ); + VERIFY(CurrSampler == GetNumSamplers(), "All samplers must be initialized before texture SRVs"); - auto SamplerId = CombinedSamplerSuffix != nullptr ? FindAssignedSamplerId(TexAttribs, CombinedSamplerSuffix) : D3DShaderResourceAttribs::InvalidSamplerId; + auto SamplerId = CombinedSamplerSuffix != nullptr ? FindAssignedSamplerId(TexAttribs, CombinedSamplerSuffix) : D3DShaderResourceAttribs::InvalidSamplerId; auto* pNewTexSRV = new (&GetTexSRV(CurrTexSRV)) D3DShaderResourceAttribs(m_ResourceNames, TexAttribs, SamplerId); if (SamplerId != D3DShaderResourceAttribs::InvalidSamplerId) { @@ -507,7 +527,8 @@ void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, } ++CurrTexSRV; NewResHandler.OnNewTexSRV(*pNewTexSRV); - }); + } // + ); m_ShaderName = m_ResourceNames.CopyString(ShaderName); @@ -516,7 +537,7 @@ void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, m_SamplerSuffix = m_ResourceNames.CopyString(CombinedSamplerSuffix); #ifdef DEVELOPMENT - for (Uint32 n=0; n < GetNumSamplers(); ++n) + for (Uint32 n = 0; n < GetNumSamplers(); ++n) { const auto& Sampler = GetSampler(n); if (!Sampler.IsCombinedWithTexSRV()) @@ -526,33 +547,37 @@ void ShaderResources::Initialize(ID3DBlob* pShaderByteCode, } VERIFY_EXPR(m_ResourceNames.GetRemainingSize() == 0); + // clang-format off VERIFY(CurrCB == GetNumCBs(), "Not all CBs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called"); VERIFY(CurrTexSRV == GetNumTexSRV(), "Not all Tex SRVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" ); VERIFY(CurrTexUAV == GetNumTexUAV(), "Not all Tex UAVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" ); VERIFY(CurrBufSRV == GetNumBufSRV(), "Not all Buf SRVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" ); VERIFY(CurrBufUAV == GetNumBufUAV(), "Not all Buf UAVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" ); VERIFY(CurrSampler == GetNumSamplers(), "Not all Samplers are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" ); + // clang-format on } -} +} // namespace Diligent namespace std { - template<> - struct hash + +template <> +struct hash +{ + size_t operator()(const Diligent::D3DShaderResourceAttribs& Attribs) const { - size_t operator()(const Diligent::D3DShaderResourceAttribs &Attribs) const - { - return Attribs.GetHash(); - } - }; + return Attribs.GetHash(); + } +}; - template<> - struct hash +template <> +struct hash +{ + size_t operator()(const Diligent::ShaderResources& Res) const { - size_t operator()(const Diligent::ShaderResources &Res) const - { - return Res.GetHash(); - } - }; -} + return Res.GetHash(); + } +}; + +} // namespace std diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h index a8716edb..f69d66e4 100644 --- a/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h +++ b/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h @@ -31,51 +31,55 @@ namespace Diligent { - struct D3DVariableIDComparator + +struct D3DVariableIDComparator +{ + bool operator()(const INTERFACE_ID& IID) const { - bool operator() (const INTERFACE_ID& IID)const - { - return IID == IID_ShaderResourceVariableD3D || IID == IID_ShaderResourceVariable || IID == IID_Unknown; - } - }; + return IID == IID_ShaderResourceVariableD3D || IID == IID_ShaderResourceVariable || IID == IID_Unknown; + } +}; + +template +struct ShaderVariableD3DBase : public ShaderVariableBase +{ + using TBase = ShaderVariableBase; - template - struct ShaderVariableD3DBase : public ShaderVariableBase + ShaderVariableD3DBase(TShaderResourceLayout& ParentResLayout, + const D3DShaderResourceAttribs& Attribs, + SHADER_RESOURCE_VARIABLE_TYPE VariableType) : + // clang-format off + TBase {ParentResLayout}, + m_Attribs {Attribs }, + m_VariableType {VariableType } + // clang-format on { - using TBase = ShaderVariableBase; + } - ShaderVariableD3DBase(TShaderResourceLayout& ParentResLayout, - const D3DShaderResourceAttribs& Attribs, - SHADER_RESOURCE_VARIABLE_TYPE VariableType) : - TBase {ParentResLayout}, - m_Attribs {Attribs }, - m_VariableType {VariableType } - { - } + virtual SHADER_RESOURCE_VARIABLE_TYPE GetType() const override final + { + return m_VariableType; + } - virtual SHADER_RESOURCE_VARIABLE_TYPE GetType()const override final - { - return m_VariableType; - } + virtual ShaderResourceDesc GetResourceDesc() const override final + { + return GetHLSLResourceDesc(); + } - virtual ShaderResourceDesc GetResourceDesc()const override final - { - return GetHLSLResourceDesc(); - } + virtual HLSLShaderResourceDesc GetHLSLResourceDesc() const override final + { + return m_Attribs.GetHLSLResourceDesc(); + } - virtual HLSLShaderResourceDesc GetHLSLResourceDesc()const override final - { - return m_Attribs.GetHLSLResourceDesc(); - } + virtual Uint32 GetIndex() const override final + { + return m_ParentResLayout.GetVariableIndex(*this); + } - virtual Uint32 GetIndex()const override final - { - return m_ParentResLayout.GetVariableIndex(*this); - } + const D3DShaderResourceAttribs& m_Attribs; - const D3DShaderResourceAttribs& m_Attribs; +protected: + const SHADER_RESOURCE_VARIABLE_TYPE m_VariableType; +}; - protected: - const SHADER_RESOURCE_VARIABLE_TYPE m_VariableType; - }; -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h index 6ad6e0a9..58b97309 100644 --- a/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h +++ b/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h @@ -31,208 +31,212 @@ namespace Diligent { - /// Base implementation of a D3D swap chain - template - class SwapChainD3DBase : public SwapChainBase + +/// Base implementation of a D3D swap chain +template +class SwapChainD3DBase : public SwapChainBase +{ +public: + using TBase = SwapChainBase; + SwapChainD3DBase(IReferenceCounters* pRefCounters, + IRenderDevice* pDevice, + IDeviceContext* pDeviceContext, + const SwapChainDesc& SCDesc, + const FullScreenModeDesc& FSDesc, + void* pNativeWndHandle) : + // clang-format off + TBase{pRefCounters, pDevice, pDeviceContext, SCDesc}, + m_FSDesc {FSDesc}, + m_pNativeWndHandle {pNativeWndHandle} + // clang-format on + {} + + ~SwapChainD3DBase() { - public: - using TBase = SwapChainBase; - SwapChainD3DBase(IReferenceCounters* pRefCounters, - IRenderDevice* pDevice, - IDeviceContext* pDeviceContext, - const SwapChainDesc& SCDesc, - const FullScreenModeDesc& FSDesc, - void* pNativeWndHandle) : - TBase{pRefCounters, pDevice, pDeviceContext, SCDesc}, - m_FSDesc {FSDesc}, - m_pNativeWndHandle {pNativeWndHandle} - {} - - ~SwapChainD3DBase() + if (m_pSwapChain) { - if (m_pSwapChain) - { - // Swap chain must be in windowed mode when it is destroyed - // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying - BOOL IsFullScreen = FALSE; - m_pSwapChain->GetFullscreenState(&IsFullScreen, nullptr); - if (IsFullScreen) - m_pSwapChain->SetFullscreenState(FALSE, nullptr); - } + // Swap chain must be in windowed mode when it is destroyed + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying + BOOL IsFullScreen = FALSE; + m_pSwapChain->GetFullscreenState(&IsFullScreen, nullptr); + if (IsFullScreen) + m_pSwapChain->SetFullscreenState(FALSE, nullptr); } + } - protected: - virtual void UpdateSwapChain(bool CreateNew) = 0; +protected: + virtual void UpdateSwapChain(bool CreateNew) = 0; - void CreateDXGISwapChain(IUnknown *pD3D11DeviceOrD3D12CmdQueue) - { + void CreateDXGISwapChain(IUnknown *pD3D11DeviceOrD3D12CmdQueue) + { #if PLATFORM_WIN32 - auto hWnd = reinterpret_cast(m_pNativeWndHandle); - if (m_SwapChainDesc.Width == 0 || m_SwapChainDesc.Height == 0) + auto hWnd = reinterpret_cast(m_pNativeWndHandle); + if (m_SwapChainDesc.Width == 0 || m_SwapChainDesc.Height == 0) + { + RECT rc; + if (m_FSDesc.Fullscreen) + { + const HWND hDesktop = GetDesktopWindow(); + GetWindowRect(hDesktop, &rc); + } + else { - RECT rc; - if (m_FSDesc.Fullscreen) - { - const HWND hDesktop = GetDesktopWindow(); - GetWindowRect(hDesktop, &rc); - } - else - { - GetClientRect(hWnd, &rc); - } - m_SwapChainDesc.Width = rc.right - rc.left; - m_SwapChainDesc.Height = rc.bottom - rc.top; + GetClientRect(hWnd, &rc); } + m_SwapChainDesc.Width = rc.right - rc.left; + m_SwapChainDesc.Height = rc.bottom - rc.top; + } #endif - auto DXGIColorBuffFmt = TexFormatToDXGI_Format(m_SwapChainDesc.ColorBufferFormat); - - DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {}; - swapChainDesc.Width = m_SwapChainDesc.Width; - swapChainDesc.Height = m_SwapChainDesc.Height; - // Flip model swapchains (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD) only support the following Formats: - // - DXGI_FORMAT_R16G16B16A16_FLOAT - // - DXGI_FORMAT_B8G8R8A8_UNORM - // - DXGI_FORMAT_R8G8B8A8_UNORM - // - DXGI_FORMAT_R10G10B10A2_UNORM - // If RGBA8_UNORM_SRGB swap chain is required, we will create RGBA8_UNORM swap chain, but - // create RGBA8_UNORM_SRGB render target view - switch (DXGIColorBuffFmt) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - break; + auto DXGIColorBuffFmt = TexFormatToDXGI_Format(m_SwapChainDesc.ColorBufferFormat); + + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {}; + swapChainDesc.Width = m_SwapChainDesc.Width; + swapChainDesc.Height = m_SwapChainDesc.Height; + // Flip model swapchains (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD) only support the following Formats: + // - DXGI_FORMAT_R16G16B16A16_FLOAT + // - DXGI_FORMAT_B8G8R8A8_UNORM + // - DXGI_FORMAT_R8G8B8A8_UNORM + // - DXGI_FORMAT_R10G10B10A2_UNORM + // If RGBA8_UNORM_SRGB swap chain is required, we will create RGBA8_UNORM swap chain, but + // create RGBA8_UNORM_SRGB render target view + switch (DXGIColorBuffFmt) + { + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + break; - case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: - swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; - break; + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + break; - default: - swapChainDesc.Format = DXGIColorBuffFmt; - } + default: + swapChainDesc.Format = DXGIColorBuffFmt; + } - swapChainDesc.Stereo = FALSE; + swapChainDesc.Stereo = FALSE; - // Multi-sampled swap chains are not supported anymore. CreateSwapChainForHwnd() fails when sample count is not 1 - // for any swap effect. - swapChainDesc.SampleDesc.Count = 1; - swapChainDesc.SampleDesc.Quality = 0; + // Multi-sampled swap chains are not supported anymore. CreateSwapChainForHwnd() fails when sample count is not 1 + // for any swap effect. + swapChainDesc.SampleDesc.Count = 1; + swapChainDesc.SampleDesc.Quality = 0; - DEV_CHECK_ERR(m_SwapChainDesc.Usage != 0, "No swap chain usage flags defined"); - swapChainDesc.BufferUsage = 0; - if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_RENDER_TARGET) - swapChainDesc.BufferUsage |= DXGI_USAGE_RENDER_TARGET_OUTPUT; - if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_SHADER_INPUT) - swapChainDesc.BufferUsage |= DXGI_USAGE_SHADER_INPUT; - //if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_COPY_SOURCE) - // ; - - swapChainDesc.BufferCount = m_SwapChainDesc.BufferCount; - swapChainDesc.Scaling = DXGI_SCALING_NONE; + DEV_CHECK_ERR(m_SwapChainDesc.Usage != 0, "No swap chain usage flags defined"); + swapChainDesc.BufferUsage = 0; + if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_RENDER_TARGET) + swapChainDesc.BufferUsage |= DXGI_USAGE_RENDER_TARGET_OUTPUT; + if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_SHADER_INPUT) + swapChainDesc.BufferUsage |= DXGI_USAGE_SHADER_INPUT; + //if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_COPY_SOURCE) + // ; + + swapChainDesc.BufferCount = m_SwapChainDesc.BufferCount; + swapChainDesc.Scaling = DXGI_SCALING_NONE; #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) - // DXGI_SCALING_NONE is supported starting with Windows 8 - if (!IsWindows8OrGreater()) - swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + // DXGI_SCALING_NONE is supported starting with Windows 8 + if (!IsWindows8OrGreater()) + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; #endif - // DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is the flip presentation model, where the contents of the back - // buffer is preserved after the call to Present. This flag cannot be used with multisampling. - // The only swap effect that supports multisampling is DXGI_SWAP_EFFECT_DISCARD. - // Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD. - swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + // DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is the flip presentation model, where the contents of the back + // buffer is preserved after the call to Present. This flag cannot be used with multisampling. + // The only swap effect that supports multisampling is DXGI_SWAP_EFFECT_DISCARD. + // Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD. + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; - swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; // Transparency behavior is not specified + swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; // Transparency behavior is not specified - // DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH enables an application to switch modes by calling - // IDXGISwapChain::ResizeTarget(). When switching from windowed to fullscreen mode, the display - // mode (or monitor resolution) will be changed to match the dimensions of the application window. - swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + // DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH enables an application to switch modes by calling + // IDXGISwapChain::ResizeTarget(). When switching from windowed to fullscreen mode, the display + // mode (or monitor resolution) will be changed to match the dimensions of the application window. + swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; - CComPtr pSwapChain1; - CComPtr factory; - HRESULT hr = CreateDXGIFactory1(__uuidof(factory), reinterpret_cast(static_cast(&factory))); - CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI factory"); + CComPtr pSwapChain1; + CComPtr factory; + HRESULT hr = CreateDXGIFactory1(__uuidof(factory), reinterpret_cast(static_cast(&factory))); + CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI factory"); #if PLATFORM_WIN32 - DXGI_SWAP_CHAIN_FULLSCREEN_DESC FullScreenDesc = {}; - FullScreenDesc.Windowed = m_FSDesc.Fullscreen ? FALSE : TRUE; - FullScreenDesc.RefreshRate.Numerator = m_FSDesc.RefreshRateNumerator; - FullScreenDesc.RefreshRate.Denominator = m_FSDesc.RefreshRateDenominator; - FullScreenDesc.Scaling = static_cast(m_FSDesc.Scaling); - FullScreenDesc.ScanlineOrdering = static_cast(m_FSDesc.ScanlineOrder); - hr = factory->CreateSwapChainForHwnd(pD3D11DeviceOrD3D12CmdQueue, hWnd, &swapChainDesc, &FullScreenDesc, nullptr, &pSwapChain1); - CHECK_D3D_RESULT_THROW(hr, "Failed to create Swap Chain"); + DXGI_SWAP_CHAIN_FULLSCREEN_DESC FullScreenDesc = {}; + FullScreenDesc.Windowed = m_FSDesc.Fullscreen ? FALSE : TRUE; + FullScreenDesc.RefreshRate.Numerator = m_FSDesc.RefreshRateNumerator; + FullScreenDesc.RefreshRate.Denominator = m_FSDesc.RefreshRateDenominator; + FullScreenDesc.Scaling = static_cast(m_FSDesc.Scaling); + FullScreenDesc.ScanlineOrdering = static_cast(m_FSDesc.ScanlineOrder); + hr = factory->CreateSwapChainForHwnd(pD3D11DeviceOrD3D12CmdQueue, hWnd, &swapChainDesc, &FullScreenDesc, nullptr, &pSwapChain1); + CHECK_D3D_RESULT_THROW(hr, "Failed to create Swap Chain"); + { + // This is silly, but IDXGIFactory used for MakeWindowAssociation must be retrieved via + // calling IDXGISwapchain::GetParent first, otherwise it won't work + // https://www.gamedev.net/forums/topic/634235-dxgidisabling-altenter/?do=findComment&comment=4999990 + CComPtr pFactoryFromSC; + if (SUCCEEDED(pSwapChain1->GetParent(__uuidof(pFactoryFromSC), (void **)&pFactoryFromSC))) { - // This is silly, but IDXGIFactory used for MakeWindowAssociation must be retrieved via - // calling IDXGISwapchain::GetParent first, otherwise it won't work - // https://www.gamedev.net/forums/topic/634235-dxgidisabling-altenter/?do=findComment&comment=4999990 - CComPtr pFactoryFromSC; - if (SUCCEEDED(pSwapChain1->GetParent(__uuidof(pFactoryFromSC), (void **)&pFactoryFromSC))) - { - // Do not allow the swap chain to handle Alt+Enter - pFactoryFromSC->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER); - } + // Do not allow the swap chain to handle Alt+Enter + pFactoryFromSC->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER); } + } #elif PLATFORM_UNIVERSAL_WINDOWS - if (m_FSDesc.Fullscreen) - LOG_WARNING_MESSAGE("UWP applications do not support fullscreen mode"); + if (m_FSDesc.Fullscreen) + LOG_WARNING_MESSAGE("UWP applications do not support fullscreen mode"); - hr = factory->CreateSwapChainForCoreWindow( - pD3D11DeviceOrD3D12CmdQueue, - reinterpret_cast(m_pNativeWndHandle), - &swapChainDesc, - nullptr, - &pSwapChain1); - CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI swap chain"); + hr = factory->CreateSwapChainForCoreWindow( + pD3D11DeviceOrD3D12CmdQueue, + reinterpret_cast(m_pNativeWndHandle), + &swapChainDesc, + nullptr, + &pSwapChain1); + CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI swap chain"); - // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and - // ensures that the application will only render after each VSync, minimizing power consumption. - //pDXGIDevice->SetMaximumFrameLatency( 1 ); + // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and + // ensures that the application will only render after each VSync, minimizing power consumption. + //pDXGIDevice->SetMaximumFrameLatency( 1 ); #endif - pSwapChain1->QueryInterface(__uuidof(m_pSwapChain), reinterpret_cast(static_cast(&m_pSwapChain))); + pSwapChain1->QueryInterface(__uuidof(m_pSwapChain), reinterpret_cast(static_cast(&m_pSwapChain))); - } + } - virtual void SetFullscreenMode(const DisplayModeAttribs &DisplayMode)override final + virtual void SetFullscreenMode(const DisplayModeAttribs &DisplayMode)override final + { + if (m_pSwapChain) { - if (m_pSwapChain) - { - // If we are already in fullscreen mode, we need to switch to windowed mode first, - // because a swap chain must be in windowed mode when it is released. - // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying - if (m_FSDesc.Fullscreen) - m_pSwapChain->SetFullscreenState(FALSE, nullptr); - m_FSDesc.Fullscreen = True; - m_FSDesc.RefreshRateNumerator = DisplayMode.RefreshRateNumerator; - m_FSDesc.RefreshRateDenominator = DisplayMode.RefreshRateDenominator; - m_FSDesc.Scaling = DisplayMode.Scaling; - m_FSDesc.ScanlineOrder = DisplayMode.ScanlineOrder; - m_SwapChainDesc.Width = DisplayMode.Width; - m_SwapChainDesc.Height = DisplayMode.Height; - if (DisplayMode.Format != TEX_FORMAT_UNKNOWN) - m_SwapChainDesc.ColorBufferFormat = DisplayMode.Format; - UpdateSwapChain(true); - } + // If we are already in fullscreen mode, we need to switch to windowed mode first, + // because a swap chain must be in windowed mode when it is released. + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying + if (m_FSDesc.Fullscreen) + m_pSwapChain->SetFullscreenState(FALSE, nullptr); + m_FSDesc.Fullscreen = True; + m_FSDesc.RefreshRateNumerator = DisplayMode.RefreshRateNumerator; + m_FSDesc.RefreshRateDenominator = DisplayMode.RefreshRateDenominator; + m_FSDesc.Scaling = DisplayMode.Scaling; + m_FSDesc.ScanlineOrder = DisplayMode.ScanlineOrder; + m_SwapChainDesc.Width = DisplayMode.Width; + m_SwapChainDesc.Height = DisplayMode.Height; + if (DisplayMode.Format != TEX_FORMAT_UNKNOWN) + m_SwapChainDesc.ColorBufferFormat = DisplayMode.Format; + UpdateSwapChain(true); } + } - virtual void SetWindowedMode()override final + virtual void SetWindowedMode()override final + { + if (m_FSDesc.Fullscreen) { - if (m_FSDesc.Fullscreen) - { - m_FSDesc.Fullscreen = False; - m_pSwapChain->SetFullscreenState(FALSE, nullptr); - } + m_FSDesc.Fullscreen = False; + m_pSwapChain->SetFullscreenState(FALSE, nullptr); } + } + + FullScreenModeDesc m_FSDesc; + CComPtr m_pSwapChain; + void* m_pNativeWndHandle; +}; - FullScreenModeDesc m_FSDesc; - CComPtr m_pSwapChain; - void* m_pNativeWndHandle; - }; } diff --git a/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h b/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h index 12ba8272..c52e195e 100644 --- a/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h +++ b/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h @@ -33,7 +33,7 @@ namespace Diligent // {1EA0898C-1612-457F-B74E-808843D2CBE3} static constexpr INTERFACE_ID IID_ShaderD3D = -{ 0x1ea0898c, 0x1612, 0x457f, { 0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3 } }; + {0x1ea0898c, 0x1612, 0x457f, {0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3}}; /// HLSL resource description @@ -47,7 +47,7 @@ class IShaderD3D : public IShader { public: /// Returns HLSL shader resource description - virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index)const = 0; + virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index) const = 0; }; -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp b/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp index 1c366d90..037c87f3 100644 --- a/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp +++ b/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp @@ -30,237 +30,237 @@ namespace Diligent DXGI_FORMAT TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized) { - switch(ValType) + switch (ValType) { case VT_FLOAT16: { - VERIFY( !bIsNormalized, "Floating point formats cannot be normalized" ); - switch(NumComponents) + VERIFY(!bIsNormalized, "Floating point formats cannot be normalized"); + switch (NumComponents) { case 1: return DXGI_FORMAT_R16_FLOAT; case 2: return DXGI_FORMAT_R16G16_FLOAT; case 4: return DXGI_FORMAT_R16G16B16A16_FLOAT; - default: UNEXPECTED("Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } case VT_FLOAT32: { - VERIFY( !bIsNormalized, "Floating point formats cannot be normalized" ); - switch(NumComponents) + VERIFY(!bIsNormalized, "Floating point formats cannot be normalized"); + switch (NumComponents) { case 1: return DXGI_FORMAT_R32_FLOAT; case 2: return DXGI_FORMAT_R32G32_FLOAT; case 3: return DXGI_FORMAT_R32G32B32_FLOAT; case 4: return DXGI_FORMAT_R32G32B32A32_FLOAT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } case VT_INT32: { - VERIFY( !bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead" ); - switch(NumComponents) + VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead"); + switch (NumComponents) { case 1: return DXGI_FORMAT_R32_SINT; case 2: return DXGI_FORMAT_R32G32_SINT; case 3: return DXGI_FORMAT_R32G32B32_SINT; case 4: return DXGI_FORMAT_R32G32B32A32_SINT; - default: UNEXPECTED("Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } case VT_UINT32: { - VERIFY( !bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead" ); - switch(NumComponents) + VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead"); + switch (NumComponents) { case 1: return DXGI_FORMAT_R32_UINT; case 2: return DXGI_FORMAT_R32G32_UINT; case 3: return DXGI_FORMAT_R32G32B32_UINT; case 4: return DXGI_FORMAT_R32G32B32A32_UINT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } case VT_INT16: { - if( bIsNormalized ) + if (bIsNormalized) { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R16_SNORM; case 2: return DXGI_FORMAT_R16G16_SNORM; case 4: return DXGI_FORMAT_R16G16B16A16_SNORM; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } else { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R16_SINT; case 2: return DXGI_FORMAT_R16G16_SINT; case 4: return DXGI_FORMAT_R16G16B16A16_SINT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } } case VT_UINT16: { - if( bIsNormalized ) + if (bIsNormalized) { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R16_UNORM; case 2: return DXGI_FORMAT_R16G16_UNORM; case 4: return DXGI_FORMAT_R16G16B16A16_UNORM; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } else { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R16_UINT; case 2: return DXGI_FORMAT_R16G16_UINT; case 4: return DXGI_FORMAT_R16G16B16A16_UINT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } } case VT_INT8: { - if( bIsNormalized ) + if (bIsNormalized) { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R8_SNORM; case 2: return DXGI_FORMAT_R8G8_SNORM; case 4: return DXGI_FORMAT_R8G8B8A8_SNORM; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } else { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R8_SINT; case 2: return DXGI_FORMAT_R8G8_SINT; case 4: return DXGI_FORMAT_R8G8B8A8_SINT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } } case VT_UINT8: { - if( bIsNormalized ) + if (bIsNormalized) { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R8_UNORM; case 2: return DXGI_FORMAT_R8G8_UNORM; case 4: return DXGI_FORMAT_R8G8B8A8_UNORM; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } else { - switch(NumComponents) + switch (NumComponents) { case 1: return DXGI_FORMAT_R8_UINT; case 2: return DXGI_FORMAT_R8G8_UINT; case 4: return DXGI_FORMAT_R8G8B8A8_UINT; - default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN; } } } - default: UNEXPECTED( "Unusupported format" ); return DXGI_FORMAT_UNKNOWN; + default: UNEXPECTED("Unusupported format"); return DXGI_FORMAT_UNKNOWN; } } -DXGI_FORMAT CorrectDXGIFormat( DXGI_FORMAT DXGIFormat, Uint32 BindFlags ) +DXGI_FORMAT CorrectDXGIFormat(DXGI_FORMAT DXGIFormat, Uint32 BindFlags) { - if( (BindFlags & BIND_DEPTH_STENCIL) && (BindFlags != BIND_DEPTH_STENCIL) ) + if ((BindFlags & BIND_DEPTH_STENCIL) && (BindFlags != BIND_DEPTH_STENCIL)) { - switch( DXGIFormat ) + switch (DXGIFormat) { case DXGI_FORMAT_R32_TYPELESS: case DXGI_FORMAT_R32_FLOAT: - case DXGI_FORMAT_D32_FLOAT: - DXGIFormat = DXGI_FORMAT_R32_TYPELESS; + case DXGI_FORMAT_D32_FLOAT: + DXGIFormat = DXGI_FORMAT_R32_TYPELESS; break; case DXGI_FORMAT_R24G8_TYPELESS: - case DXGI_FORMAT_D24_UNORM_S8_UINT: - case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: - case DXGI_FORMAT_X24_TYPELESS_G8_UINT: - DXGIFormat = DXGI_FORMAT_R24G8_TYPELESS; + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + DXGIFormat = DXGI_FORMAT_R24G8_TYPELESS; break; case DXGI_FORMAT_R16_TYPELESS: case DXGI_FORMAT_R16_UNORM: - case DXGI_FORMAT_D16_UNORM: - DXGIFormat = DXGI_FORMAT_R16_TYPELESS; + case DXGI_FORMAT_D16_UNORM: + DXGIFormat = DXGI_FORMAT_R16_TYPELESS; break; case DXGI_FORMAT_R32G8X24_TYPELESS: case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: - DXGIFormat = DXGI_FORMAT_R32G8X24_TYPELESS; + DXGIFormat = DXGI_FORMAT_R32G8X24_TYPELESS; break; - default: - UNEXPECTED( "Unsupported depth-stencil format" ); + default: + UNEXPECTED("Unsupported depth-stencil format"); break; } } - if( BindFlags == BIND_DEPTH_STENCIL ) + if (BindFlags == BIND_DEPTH_STENCIL) { - switch( DXGIFormat ) + switch (DXGIFormat) { case DXGI_FORMAT_R32_TYPELESS: case DXGI_FORMAT_R32_FLOAT: - DXGIFormat = DXGI_FORMAT_D32_FLOAT; + DXGIFormat = DXGI_FORMAT_D32_FLOAT; break; - case DXGI_FORMAT_R24G8_TYPELESS: - case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: - case DXGI_FORMAT_X24_TYPELESS_G8_UINT: - DXGIFormat = DXGI_FORMAT_D24_UNORM_S8_UINT; + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + DXGIFormat = DXGI_FORMAT_D24_UNORM_S8_UINT; break; case DXGI_FORMAT_R16_TYPELESS: case DXGI_FORMAT_R16_UNORM: - DXGIFormat = DXGI_FORMAT_D16_UNORM; + DXGIFormat = DXGI_FORMAT_D16_UNORM; break; } } - if( BindFlags == BIND_SHADER_RESOURCE || BindFlags == BIND_UNORDERED_ACCESS ) + if (BindFlags == BIND_SHADER_RESOURCE || BindFlags == BIND_UNORDERED_ACCESS) { - switch( DXGIFormat ) + switch (DXGIFormat) { case DXGI_FORMAT_R32_TYPELESS: case DXGI_FORMAT_D32_FLOAT: - DXGIFormat = DXGI_FORMAT_R32_FLOAT; + DXGIFormat = DXGI_FORMAT_R32_FLOAT; break; - case DXGI_FORMAT_R24G8_TYPELESS: - case DXGI_FORMAT_D24_UNORM_S8_UINT: - case DXGI_FORMAT_X24_TYPELESS_G8_UINT: - DXGIFormat = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + DXGIFormat = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; break; case DXGI_FORMAT_R16_TYPELESS: case DXGI_FORMAT_D16_UNORM: - DXGIFormat = DXGI_FORMAT_R16_UNORM; + DXGIFormat = DXGI_FORMAT_R16_UNORM; break; } } @@ -270,145 +270,147 @@ DXGI_FORMAT CorrectDXGIFormat( DXGI_FORMAT DXGIFormat, Uint32 BindFlags ) DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags) { - static Bool bFormatMapIntialized = false; + static Bool bFormatMapIntialized = false; static DXGI_FORMAT FmtToDXGIFmtMap[TEX_FORMAT_NUM_FORMATS] = {DXGI_FORMAT_UNKNOWN}; - if( !bFormatMapIntialized ) + if (!bFormatMapIntialized) { - FmtToDXGIFmtMap[ TEX_FORMAT_UNKNOWN ] = DXGI_FORMAT_UNKNOWN; - - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_TYPELESS ] = DXGI_FORMAT_R32G32B32A32_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_FLOAT ] = DXGI_FORMAT_R32G32B32A32_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_UINT ] = DXGI_FORMAT_R32G32B32A32_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_SINT ] = DXGI_FORMAT_R32G32B32A32_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_TYPELESS ] = DXGI_FORMAT_R32G32B32_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_FLOAT ] = DXGI_FORMAT_R32G32B32_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_UINT ] = DXGI_FORMAT_R32G32B32_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_SINT ] = DXGI_FORMAT_R32G32B32_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_TYPELESS ] = DXGI_FORMAT_R16G16B16A16_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_FLOAT ] = DXGI_FORMAT_R16G16B16A16_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_UNORM ] = DXGI_FORMAT_R16G16B16A16_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_UINT ] = DXGI_FORMAT_R16G16B16A16_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_SNORM ] = DXGI_FORMAT_R16G16B16A16_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_SINT ] = DXGI_FORMAT_R16G16B16A16_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RG32_TYPELESS ] = DXGI_FORMAT_R32G32_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RG32_FLOAT ] = DXGI_FORMAT_R32G32_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_RG32_UINT ] = DXGI_FORMAT_R32G32_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RG32_SINT ] = DXGI_FORMAT_R32G32_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R32G8X24_TYPELESS ] = DXGI_FORMAT_R32G8X24_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_D32_FLOAT_S8X24_UINT ] = DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_R32_FLOAT_X8X24_TYPELESS ]= DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_X32_TYPELESS_G8X24_UINT ]= DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_TYPELESS ] = DXGI_FORMAT_R10G10B10A2_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_UNORM ] = DXGI_FORMAT_R10G10B10A2_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_UINT ] = DXGI_FORMAT_R10G10B10A2_UINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R11G11B10_FLOAT ] = DXGI_FORMAT_R11G11B10_FLOAT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_TYPELESS ] = DXGI_FORMAT_R8G8B8A8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UNORM ] = DXGI_FORMAT_R8G8B8A8_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UNORM_SRGB ] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UINT ] = DXGI_FORMAT_R8G8B8A8_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_SNORM ] = DXGI_FORMAT_R8G8B8A8_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_SINT ] = DXGI_FORMAT_R8G8B8A8_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_TYPELESS ] = DXGI_FORMAT_R16G16_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_FLOAT ] = DXGI_FORMAT_R16G16_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_UNORM ] = DXGI_FORMAT_R16G16_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_UINT ] = DXGI_FORMAT_R16G16_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_SNORM ] = DXGI_FORMAT_R16G16_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RG16_SINT ] = DXGI_FORMAT_R16G16_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R32_TYPELESS ] = DXGI_FORMAT_R32_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_D32_FLOAT ] = DXGI_FORMAT_D32_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_R32_FLOAT ] = DXGI_FORMAT_R32_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_R32_UINT ] = DXGI_FORMAT_R32_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_R32_SINT ] = DXGI_FORMAT_R32_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R24G8_TYPELESS ] = DXGI_FORMAT_R24G8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_D24_UNORM_S8_UINT ] = DXGI_FORMAT_D24_UNORM_S8_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_R24_UNORM_X8_TYPELESS ] = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_X24_TYPELESS_G8_UINT ] = DXGI_FORMAT_X24_TYPELESS_G8_UINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_TYPELESS ] = DXGI_FORMAT_R8G8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_UNORM ] = DXGI_FORMAT_R8G8_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_UINT ] = DXGI_FORMAT_R8G8_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_SNORM ] = DXGI_FORMAT_R8G8_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_SINT ] = DXGI_FORMAT_R8G8_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R16_TYPELESS ] = DXGI_FORMAT_R16_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_R16_FLOAT ] = DXGI_FORMAT_R16_FLOAT; - FmtToDXGIFmtMap[ TEX_FORMAT_D16_UNORM ] = DXGI_FORMAT_D16_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_R16_UNORM ] = DXGI_FORMAT_R16_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_R16_UINT ] = DXGI_FORMAT_R16_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_R16_SNORM ] = DXGI_FORMAT_R16_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_R16_SINT ] = DXGI_FORMAT_R16_SINT; - - FmtToDXGIFmtMap[ TEX_FORMAT_R8_TYPELESS ] = DXGI_FORMAT_R8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_R8_UNORM ] = DXGI_FORMAT_R8_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_R8_UINT ] = DXGI_FORMAT_R8_UINT; - FmtToDXGIFmtMap[ TEX_FORMAT_R8_SNORM ] = DXGI_FORMAT_R8_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_R8_SINT ] = DXGI_FORMAT_R8_SINT; - FmtToDXGIFmtMap[ TEX_FORMAT_A8_UNORM ] = DXGI_FORMAT_A8_UNORM; - - FmtToDXGIFmtMap[ TEX_FORMAT_R1_UNORM ] = DXGI_FORMAT_R1_UNORM ; - FmtToDXGIFmtMap[ TEX_FORMAT_RGB9E5_SHAREDEXP ] = DXGI_FORMAT_R9G9B9E5_SHAREDEXP; - FmtToDXGIFmtMap[ TEX_FORMAT_RG8_B8G8_UNORM ] = DXGI_FORMAT_R8G8_B8G8_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_G8R8_G8B8_UNORM ] = DXGI_FORMAT_G8R8_G8B8_UNORM; - - FmtToDXGIFmtMap[ TEX_FORMAT_BC1_TYPELESS ] = DXGI_FORMAT_BC1_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC1_UNORM ] = DXGI_FORMAT_BC1_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC1_UNORM_SRGB ] = DXGI_FORMAT_BC1_UNORM_SRGB; - FmtToDXGIFmtMap[ TEX_FORMAT_BC2_TYPELESS ] = DXGI_FORMAT_BC2_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC2_UNORM ] = DXGI_FORMAT_BC2_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC2_UNORM_SRGB ] = DXGI_FORMAT_BC2_UNORM_SRGB; - FmtToDXGIFmtMap[ TEX_FORMAT_BC3_TYPELESS ] = DXGI_FORMAT_BC3_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC3_UNORM ] = DXGI_FORMAT_BC3_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC3_UNORM_SRGB ] = DXGI_FORMAT_BC3_UNORM_SRGB; - FmtToDXGIFmtMap[ TEX_FORMAT_BC4_TYPELESS ] = DXGI_FORMAT_BC4_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC4_UNORM ] = DXGI_FORMAT_BC4_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC4_SNORM ] = DXGI_FORMAT_BC4_SNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC5_TYPELESS ] = DXGI_FORMAT_BC5_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC5_UNORM ] = DXGI_FORMAT_BC5_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC5_SNORM ] = DXGI_FORMAT_BC5_SNORM; - - FmtToDXGIFmtMap[ TEX_FORMAT_B5G6R5_UNORM ] = DXGI_FORMAT_B5G6R5_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_B5G5R5A1_UNORM ] = DXGI_FORMAT_B5G5R5A1_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_UNORM ] = DXGI_FORMAT_B8G8R8A8_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_UNORM ] = DXGI_FORMAT_B8G8R8X8_UNORM; - - FmtToDXGIFmtMap[ TEX_FORMAT_R10G10B10_XR_BIAS_A2_UNORM ]= DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM; - - FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_TYPELESS ] = DXGI_FORMAT_B8G8R8A8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_UNORM_SRGB ] = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; - FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_TYPELESS ] = DXGI_FORMAT_B8G8R8X8_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_UNORM_SRGB ] = DXGI_FORMAT_B8G8R8X8_UNORM_SRGB; - - FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_TYPELESS ] = DXGI_FORMAT_BC6H_TYPELESS; - FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_UF16 ] = DXGI_FORMAT_BC6H_UF16; - FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_SF16 ] = DXGI_FORMAT_BC6H_SF16; - FmtToDXGIFmtMap[ TEX_FORMAT_BC7_TYPELESS ] = DXGI_FORMAT_BC7_TYPELESS ; - FmtToDXGIFmtMap[ TEX_FORMAT_BC7_UNORM ] = DXGI_FORMAT_BC7_UNORM; - FmtToDXGIFmtMap[ TEX_FORMAT_BC7_UNORM_SRGB ] = DXGI_FORMAT_BC7_UNORM_SRGB; - + // clang-format off + FmtToDXGIFmtMap[TEX_FORMAT_UNKNOWN] = DXGI_FORMAT_UNKNOWN; + + FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_TYPELESS] = DXGI_FORMAT_R32G32B32A32_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_FLOAT] = DXGI_FORMAT_R32G32B32A32_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_UINT] = DXGI_FORMAT_R32G32B32A32_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_SINT] = DXGI_FORMAT_R32G32B32A32_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RGB32_TYPELESS] = DXGI_FORMAT_R32G32B32_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RGB32_FLOAT] = DXGI_FORMAT_R32G32B32_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_RGB32_UINT] = DXGI_FORMAT_R32G32B32_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RGB32_SINT] = DXGI_FORMAT_R32G32B32_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_TYPELESS] = DXGI_FORMAT_R16G16B16A16_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_FLOAT] = DXGI_FORMAT_R16G16B16A16_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_UNORM] = DXGI_FORMAT_R16G16B16A16_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_UINT] = DXGI_FORMAT_R16G16B16A16_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_SNORM] = DXGI_FORMAT_R16G16B16A16_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_SINT] = DXGI_FORMAT_R16G16B16A16_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RG32_TYPELESS] = DXGI_FORMAT_R32G32_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RG32_FLOAT] = DXGI_FORMAT_R32G32_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_RG32_UINT] = DXGI_FORMAT_R32G32_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RG32_SINT] = DXGI_FORMAT_R32G32_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R32G8X24_TYPELESS] = DXGI_FORMAT_R32G8X24_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_D32_FLOAT_S8X24_UINT] = DXGI_FORMAT_D32_FLOAT_S8X24_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_R32_FLOAT_X8X24_TYPELESS]= DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_X32_TYPELESS_G8X24_UINT]= DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_TYPELESS] = DXGI_FORMAT_R10G10B10A2_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_UNORM] = DXGI_FORMAT_R10G10B10A2_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_UINT] = DXGI_FORMAT_R10G10B10A2_UINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R11G11B10_FLOAT] = DXGI_FORMAT_R11G11B10_FLOAT; + + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_TYPELESS] = DXGI_FORMAT_R8G8B8A8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UINT] = DXGI_FORMAT_R8G8B8A8_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_SNORM] = DXGI_FORMAT_R8G8B8A8_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_SINT] = DXGI_FORMAT_R8G8B8A8_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RG16_TYPELESS] = DXGI_FORMAT_R16G16_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RG16_FLOAT] = DXGI_FORMAT_R16G16_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_RG16_UNORM] = DXGI_FORMAT_R16G16_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RG16_UINT] = DXGI_FORMAT_R16G16_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RG16_SNORM] = DXGI_FORMAT_R16G16_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RG16_SINT] = DXGI_FORMAT_R16G16_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R32_TYPELESS] = DXGI_FORMAT_R32_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_D32_FLOAT] = DXGI_FORMAT_D32_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_R32_FLOAT] = DXGI_FORMAT_R32_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_R32_UINT] = DXGI_FORMAT_R32_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_R32_SINT] = DXGI_FORMAT_R32_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R24G8_TYPELESS] = DXGI_FORMAT_R24G8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_D24_UNORM_S8_UINT] = DXGI_FORMAT_D24_UNORM_S8_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_R24_UNORM_X8_TYPELESS] = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_X24_TYPELESS_G8_UINT] = DXGI_FORMAT_X24_TYPELESS_G8_UINT; + + FmtToDXGIFmtMap[TEX_FORMAT_RG8_TYPELESS] = DXGI_FORMAT_R8G8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_RG8_UNORM] = DXGI_FORMAT_R8G8_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RG8_UINT] = DXGI_FORMAT_R8G8_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_RG8_SNORM] = DXGI_FORMAT_R8G8_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_RG8_SINT] = DXGI_FORMAT_R8G8_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R16_TYPELESS] = DXGI_FORMAT_R16_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_R16_FLOAT] = DXGI_FORMAT_R16_FLOAT; + FmtToDXGIFmtMap[TEX_FORMAT_D16_UNORM] = DXGI_FORMAT_D16_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_R16_UNORM] = DXGI_FORMAT_R16_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_R16_UINT] = DXGI_FORMAT_R16_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_R16_SNORM] = DXGI_FORMAT_R16_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_R16_SINT] = DXGI_FORMAT_R16_SINT; + + FmtToDXGIFmtMap[TEX_FORMAT_R8_TYPELESS] = DXGI_FORMAT_R8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_R8_UNORM] = DXGI_FORMAT_R8_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_R8_UINT] = DXGI_FORMAT_R8_UINT; + FmtToDXGIFmtMap[TEX_FORMAT_R8_SNORM] = DXGI_FORMAT_R8_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_R8_SINT] = DXGI_FORMAT_R8_SINT; + FmtToDXGIFmtMap[TEX_FORMAT_A8_UNORM] = DXGI_FORMAT_A8_UNORM; + + FmtToDXGIFmtMap[TEX_FORMAT_R1_UNORM] = DXGI_FORMAT_R1_UNORM ; + FmtToDXGIFmtMap[TEX_FORMAT_RGB9E5_SHAREDEXP] = DXGI_FORMAT_R9G9B9E5_SHAREDEXP; + FmtToDXGIFmtMap[TEX_FORMAT_RG8_B8G8_UNORM] = DXGI_FORMAT_R8G8_B8G8_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_G8R8_G8B8_UNORM] = DXGI_FORMAT_G8R8_G8B8_UNORM; + + FmtToDXGIFmtMap[TEX_FORMAT_BC1_TYPELESS] = DXGI_FORMAT_BC1_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC1_UNORM] = DXGI_FORMAT_BC1_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC1_UNORM_SRGB] = DXGI_FORMAT_BC1_UNORM_SRGB; + FmtToDXGIFmtMap[TEX_FORMAT_BC2_TYPELESS] = DXGI_FORMAT_BC2_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC2_UNORM] = DXGI_FORMAT_BC2_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC2_UNORM_SRGB] = DXGI_FORMAT_BC2_UNORM_SRGB; + FmtToDXGIFmtMap[TEX_FORMAT_BC3_TYPELESS] = DXGI_FORMAT_BC3_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC3_UNORM] = DXGI_FORMAT_BC3_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC3_UNORM_SRGB] = DXGI_FORMAT_BC3_UNORM_SRGB; + FmtToDXGIFmtMap[TEX_FORMAT_BC4_TYPELESS] = DXGI_FORMAT_BC4_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC4_UNORM] = DXGI_FORMAT_BC4_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC4_SNORM] = DXGI_FORMAT_BC4_SNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC5_TYPELESS] = DXGI_FORMAT_BC5_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC5_UNORM] = DXGI_FORMAT_BC5_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC5_SNORM] = DXGI_FORMAT_BC5_SNORM; + + FmtToDXGIFmtMap[TEX_FORMAT_B5G6R5_UNORM] = DXGI_FORMAT_B5G6R5_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_B5G5R5A1_UNORM] = DXGI_FORMAT_B5G5R5A1_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_UNORM] = DXGI_FORMAT_B8G8R8A8_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_UNORM] = DXGI_FORMAT_B8G8R8X8_UNORM; + + FmtToDXGIFmtMap[TEX_FORMAT_R10G10B10_XR_BIAS_A2_UNORM]= DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM; + + FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_TYPELESS] = DXGI_FORMAT_B8G8R8A8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_UNORM_SRGB] = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_TYPELESS] = DXGI_FORMAT_B8G8R8X8_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_UNORM_SRGB] = DXGI_FORMAT_B8G8R8X8_UNORM_SRGB; + + FmtToDXGIFmtMap[TEX_FORMAT_BC6H_TYPELESS] = DXGI_FORMAT_BC6H_TYPELESS; + FmtToDXGIFmtMap[TEX_FORMAT_BC6H_UF16] = DXGI_FORMAT_BC6H_UF16; + FmtToDXGIFmtMap[TEX_FORMAT_BC6H_SF16] = DXGI_FORMAT_BC6H_SF16; + FmtToDXGIFmtMap[TEX_FORMAT_BC7_TYPELESS] = DXGI_FORMAT_BC7_TYPELESS ; + FmtToDXGIFmtMap[TEX_FORMAT_BC7_UNORM] = DXGI_FORMAT_BC7_UNORM; + FmtToDXGIFmtMap[TEX_FORMAT_BC7_UNORM_SRGB] = DXGI_FORMAT_BC7_UNORM_SRGB; + // clang-format on + bFormatMapIntialized = true; } - if( TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS ) + if (TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS) { auto DXGIFormat = FmtToDXGIFmtMap[TexFormat]; - VERIFY( TexFormat == TEX_FORMAT_UNKNOWN || DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format" ); - if( BindFlags != 0 ) - DXGIFormat = CorrectDXGIFormat( DXGIFormat, BindFlags ); + VERIFY(TexFormat == TEX_FORMAT_UNKNOWN || DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format"); + if (BindFlags != 0) + DXGIFormat = CorrectDXGIFormat(DXGIFormat, BindFlags); return DXGIFormat; } else { - UNEXPECTED( "Texture format (", TexFormat, ") is out of allowed range [0, ", TEX_FORMAT_NUM_FORMATS-1, "]" ); + UNEXPECTED("Texture format (", TexFormat, ") is out of allowed range [0, ", TEX_FORMAT_NUM_FORMATS - 1, "]"); return DXGI_FORMAT_UNKNOWN; } } @@ -418,7 +420,7 @@ class DXGIFmtToFmtMapInitializer public: DXGIFmtToFmtMapInitializer(TEXTURE_FORMAT DXGIFmtToFmtMap[]) { - for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast(fmt +1)) + for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast(fmt + 1)) { auto DXGIFmt = TexFormatToDXGI_Format(fmt); VERIFY_EXPR(DXGIFmt <= DXGI_FORMAT_B4G4R4A4_UNORM); @@ -430,21 +432,21 @@ public: TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat) { static_assert(DXGI_FORMAT_B4G4R4A4_UNORM == 115, "Unexpected DXGI format value"); - static TEXTURE_FORMAT DXGIFmtToFmtMap[DXGI_FORMAT_B4G4R4A4_UNORM+1]; + static TEXTURE_FORMAT DXGIFmtToFmtMap[DXGI_FORMAT_B4G4R4A4_UNORM + 1]; static DXGIFmtToFmtMapInitializer Initializer(DXGIFmtToFmtMap); - if( DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB ) + if (DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB) { auto Format = DXGIFmtToFmtMap[DXGIFormat]; - VERIFY( DXGIFormat == DXGI_FORMAT_UNKNOWN || Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format" ); + VERIFY(DXGIFormat == DXGI_FORMAT_UNKNOWN || Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format"); VERIFY_EXPR(DXGIFormat == TexFormatToDXGI_Format(Format)); return Format; } else { - UNEXPECTED( "DXGI texture format (", DXGIFormat, ") is out of allowed range [0, ", DXGI_FORMAT_BC7_UNORM_SRGB, "]" ); + UNEXPECTED("DXGI texture format (", DXGIFormat, ") is out of allowed range [0, ", DXGI_FORMAT_BC7_UNORM_SRGB, "]"); return TEX_FORMAT_UNKNOWN; } } -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp index 02281be7..12bd69c0 100644 --- a/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp +++ b/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp @@ -33,92 +33,93 @@ namespace Diligent { -static const Char* g_HLSLDefinitions = -{ - #include "HLSLDefinitions_inc.fxh" +static const Char* g_HLSLDefinitions = + { +#include "HLSLDefinitions_inc.fxh" }; class D3DIncludeImpl : public ID3DInclude { public: - D3DIncludeImpl(IShaderSourceInputStreamFactory* pStreamFactory) : - m_pStreamFactory(pStreamFactory) + D3DIncludeImpl(IShaderSourceInputStreamFactory* pStreamFactory) : + m_pStreamFactory{pStreamFactory} { - } - STDMETHOD( Open )(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID* ppData, UINT* pBytes) + STDMETHOD(Open) + (THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID* ppData, UINT* pBytes) { RefCntAutoPtr pSourceStream; - m_pStreamFactory->CreateInputStream( pFileName, &pSourceStream ); - if( pSourceStream == nullptr ) + m_pStreamFactory->CreateInputStream(pFileName, &pSourceStream); + if (pSourceStream == nullptr) { - LOG_ERROR( "Failed to open shader include file ", pFileName, ". Check that the file exists" ); + LOG_ERROR("Failed to open shader include file ", pFileName, ". Check that the file exists"); return E_FAIL; } - RefCntAutoPtr pFileData( MakeNewRCObj()(0) ); - pSourceStream->Read( pFileData ); + RefCntAutoPtr pFileData(MakeNewRCObj()(0)); + pSourceStream->Read(pFileData); *ppData = pFileData->GetDataPtr(); - *pBytes = static_cast( pFileData->GetSize() ); + *pBytes = static_cast(pFileData->GetSize()); - m_DataBlobs.insert( std::make_pair(*ppData, pFileData) ); + m_DataBlobs.insert(std::make_pair(*ppData, pFileData)); return S_OK; } - STDMETHOD( Close )(THIS_ LPCVOID pData) + STDMETHOD(Close) + (THIS_ LPCVOID pData) { - m_DataBlobs.erase( pData ); + m_DataBlobs.erase(pData); return S_OK; } private: - IShaderSourceInputStreamFactory *m_pStreamFactory; - std::unordered_map< LPCVOID, RefCntAutoPtr > m_DataBlobs; + IShaderSourceInputStreamFactory* m_pStreamFactory; + std::unordered_map> m_DataBlobs; }; -static HRESULT CompileShader(const char* Source, - LPCSTR strFunctionName, - const D3D_SHADER_MACRO* pDefines, - IShaderSourceInputStreamFactory* pIncludeStreamFactory, - LPCSTR profile, - ID3DBlob** ppBlobOut, - ID3DBlob** ppCompilerOutput) +static HRESULT CompileShader(const char* Source, + LPCSTR strFunctionName, + const D3D_SHADER_MACRO* pDefines, + IShaderSourceInputStreamFactory* pIncludeStreamFactory, + LPCSTR profile, + ID3DBlob** ppBlobOut, + ID3DBlob** ppCompilerOutput) { DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS; -#if defined( DEBUG ) || defined( _DEBUG ) +#if defined(DEBUG) || defined(_DEBUG) // Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders. - // Setting this flag improves the shader debugging experience, but still allows - // the shaders to be optimized and to run exactly the way they will run in + // Setting this flag improves the shader debugging experience, but still allows + // the shaders to be optimized and to run exactly the way they will run in // the release configuration of this program. dwShaderFlags |= D3DCOMPILE_DEBUG; #else - // Warning: do not use this flag as it causes shader compiler to fail the compilation and + // Warning: do not use this flag as it causes shader compiler to fail the compilation and // report strange errors: // dwShaderFlags |= D3D10_SHADER_OPTIMIZATION_LEVEL3; #endif - HRESULT hr; -// do -// { - auto SourceLen = strlen(Source); - - D3DIncludeImpl IncludeImpl(pIncludeStreamFactory); - hr = D3DCompile( Source, SourceLen, NULL, pDefines, &IncludeImpl, strFunctionName, profile, dwShaderFlags, 0, ppBlobOut, ppCompilerOutput); - -// if( FAILED(hr) || errors ) -// { -// if( FAILED(hr) -//#if PLATFORM_WIN32 -// && IDRETRY != MessageBoxW( NULL, L"Failed to compile shader", L"FX Error", MB_ICONERROR | (Source == nullptr ? MB_ABORTRETRYIGNORE : 0) ) -//#endif -// ) -// { -// break; -// } -// } -// } while( FAILED(hr) ); - return hr; + HRESULT hr; + // do + // { + auto SourceLen = strlen(Source); + + D3DIncludeImpl IncludeImpl(pIncludeStreamFactory); + hr = D3DCompile(Source, SourceLen, NULL, pDefines, &IncludeImpl, strFunctionName, profile, dwShaderFlags, 0, ppBlobOut, ppCompilerOutput); + + // if( FAILED(hr) || errors ) + // { + // if( FAILED(hr) + //#if PLATFORM_WIN32 + // && IDRETRY != MessageBoxW( NULL, L"Failed to compile shader", L"FX Error", MB_ICONERROR | (Source == nullptr ? MB_ABORTRETRYIGNORE : 0) ) + //#endif + // ) + // { + // break; + // } + // } + // } while( FAILED(hr) ); + return hr; } ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel) @@ -131,14 +132,16 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade std::string strShaderProfile; switch (ShaderCI.Desc.ShaderType) { + // clang-format off case SHADER_TYPE_VERTEX: strShaderProfile="vs"; break; case SHADER_TYPE_PIXEL: strShaderProfile="ps"; break; case SHADER_TYPE_GEOMETRY:strShaderProfile="gs"; break; case SHADER_TYPE_HULL: strShaderProfile="hs"; break; case SHADER_TYPE_DOMAIN: strShaderProfile="ds"; break; case SHADER_TYPE_COMPUTE: strShaderProfile="cs"; break; + // clang-format on - default: UNEXPECTED( "Unknown shader type" ); + default: UNEXPECTED("Unknown shader type"); } strShaderProfile += "_"; strShaderProfile += ShaderModel; @@ -160,33 +163,33 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade pSourceStream->Read(pFileData); // Null terminator is not read from the stream! auto* FileDataPtr = reinterpret_cast(pFileData->GetDataPtr()); - auto Size = pFileData->GetSize(); + auto Size = pFileData->GetSize(); ShaderSource.append(FileDataPtr, FileDataPtr + Size / sizeof(*FileDataPtr)); } - const D3D_SHADER_MACRO *pDefines = nullptr; + const D3D_SHADER_MACRO* pDefines = nullptr; std::vector D3DMacros; if (ShaderCI.Macros) { for (auto* pCurrMacro = ShaderCI.Macros; pCurrMacro->Name && pCurrMacro->Definition; ++pCurrMacro) { - D3DMacros.push_back({ pCurrMacro->Name, pCurrMacro->Definition }); + D3DMacros.push_back({pCurrMacro->Name, pCurrMacro->Definition}); } - D3DMacros.push_back({ nullptr, nullptr }); + D3DMacros.push_back({nullptr, nullptr}); pDefines = D3DMacros.data(); } DEV_CHECK_ERR(ShaderCI.EntryPoint != nullptr, "Entry point must not be null"); CComPtr errors; - auto hr = CompileShader(ShaderSource.c_str(), ShaderCI.EntryPoint, pDefines, ShaderCI.pShaderSourceStreamFactory, strShaderProfile.c_str(), &m_pShaderByteCode, &errors); + auto hr = CompileShader(ShaderSource.c_str(), ShaderCI.EntryPoint, pDefines, ShaderCI.pShaderSourceStreamFactory, strShaderProfile.c_str(), &m_pShaderByteCode, &errors); const char* CompilerMsg = errors ? reinterpret_cast(errors->GetBufferPointer()) : nullptr; if (CompilerMsg != nullptr && ShaderCI.ppCompilerOutput != nullptr) { - auto ErrorMsgLen = strlen(CompilerMsg); - auto *pOutputDataBlob = MakeNewRCObj()(ErrorMsgLen + 1 + ShaderSource.length() + 1); - char* DataPtr = reinterpret_cast(pOutputDataBlob->GetDataPtr()); - memcpy(DataPtr, CompilerMsg, ErrorMsgLen+1); + auto ErrorMsgLen = strlen(CompilerMsg); + auto* pOutputDataBlob = MakeNewRCObj()(ErrorMsgLen + 1 + ShaderSource.length() + 1); + char* DataPtr = reinterpret_cast(pOutputDataBlob->GetDataPtr()); + memcpy(DataPtr, CompilerMsg, ErrorMsgLen + 1); memcpy(DataPtr + ErrorMsgLen + 1, ShaderSource.data(), ShaderSource.length() + 1); pOutputDataBlob->QueryInterface(IID_DataBlob, reinterpret_cast(ShaderCI.ppCompilerOutput)); } @@ -194,13 +197,13 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade if (FAILED(hr)) { ComErrorDesc ErrDesc(hr); - if(ShaderCI.ppCompilerOutput != nullptr) + if (ShaderCI.ppCompilerOutput != nullptr) { - LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), ")."); + LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), ")."); } else { - LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), "):\n", (CompilerMsg != nullptr ? CompilerMsg : "") ); + LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), "):\n", (CompilerMsg != nullptr ? CompilerMsg : "")); } } } @@ -216,4 +219,4 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade } } -} +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp index 224ed75a..ef144b63 100644 --- a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp +++ b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp @@ -34,31 +34,32 @@ namespace Diligent ShaderResources::~ShaderResources() { - for(Uint32 n=0; n < GetNumCBs(); ++n) + for (Uint32 n = 0; n < GetNumCBs(); ++n) GetCB(n).~D3DShaderResourceAttribs(); - for(Uint32 n=0; n < GetNumTexSRV(); ++n) + for (Uint32 n = 0; n < GetNumTexSRV(); ++n) GetTexSRV(n).~D3DShaderResourceAttribs(); - for(Uint32 n=0; n < GetNumTexUAV(); ++n) + for (Uint32 n = 0; n < GetNumTexUAV(); ++n) GetTexUAV(n).~D3DShaderResourceAttribs(); - for(Uint32 n=0; n < GetNumBufSRV(); ++n) + for (Uint32 n = 0; n < GetNumBufSRV(); ++n) GetBufSRV(n).~D3DShaderResourceAttribs(); - for(Uint32 n=0; n < GetNumBufUAV(); ++n) + for (Uint32 n = 0; n < GetNumBufUAV(); ++n) GetBufUAV(n).~D3DShaderResourceAttribs(); - for(Uint32 n=0; n < GetNumSamplers(); ++n) + for (Uint32 n = 0; n < GetNumSamplers(); ++n) GetSampler(n).~D3DShaderResourceAttribs(); } -void ShaderResources::AllocateMemory(IMemoryAllocator& Allocator, +void ShaderResources::AllocateMemory(IMemoryAllocator& Allocator, const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize) { Uint32 CurrentOffset = 0; - auto AdvanceOffset = [&CurrentOffset](Uint32 NumResources) + + auto AdvanceOffset = [&CurrentOffset](Uint32 NumResources) // { constexpr Uint32 MaxOffset = std::numeric_limits::max(); VERIFY(CurrentOffset <= MaxOffset, "Current offser (", CurrentOffset, ") exceeds max allowed value (", MaxOffset, ")"); @@ -67,6 +68,7 @@ void ShaderResources::AllocateMemory(IMemoryAllocator& Allocator, return Offset; }; + // clang-format off auto CBOffset = AdvanceOffset(ResCounters.NumCBs); (void)CBOffset; // To suppress warning m_TexSRVOffset = AdvanceOffset(ResCounters.NumTexSRVs); m_TexUAVOffset = AdvanceOffset(ResCounters.NumTexUAVs); @@ -84,27 +86,30 @@ void ShaderResources::AllocateMemory(IMemoryAllocator& Allocator, VERIFY_EXPR(GetNumBufSRV() == ResCounters.NumBufSRVs); VERIFY_EXPR(GetNumBufUAV() == ResCounters.NumBufUAVs); VERIFY_EXPR(GetNumSamplers()== ResCounters.NumSamplers); + // clang-format on - if( MemorySize ) + if (MemorySize) { - auto* pRawMem = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize ); - m_MemoryBuffer = std::unique_ptr< void, STDDeleterRawMem >(pRawMem, Allocator); + auto* pRawMem = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize); + m_MemoryBuffer = std::unique_ptr>(pRawMem, Allocator); char* NamesPool = reinterpret_cast(reinterpret_cast(pRawMem) + m_TotalResources); m_ResourceNames.AssignMemory(NamesPool, ResourceNamesPoolSize); - } + } } SHADER_RESOURCE_VARIABLE_TYPE ShaderResources::FindVariableType(const D3DShaderResourceAttribs& ResourceAttribs, - const PipelineResourceLayoutDesc& ResourceLayout)const + const PipelineResourceLayoutDesc& ResourceLayout) const { if (ResourceAttribs.GetInputType() == D3D_SIT_SAMPLER) { // Only use CombinedSamplerSuffix when looking for the sampler variable type - return GetShaderVariableType(m_ShaderType, ResourceLayout.DefaultVariableType, ResourceLayout.Variables, ResourceLayout.NumVariables, - [&](const char* VarName) - { - return StreqSuff(ResourceAttribs.Name, VarName, m_SamplerSuffix); - }); + return GetShaderVariableType( + m_ShaderType, ResourceLayout.DefaultVariableType, ResourceLayout.Variables, ResourceLayout.NumVariables, + [&](const char* VarName) // + { + return StreqSuff(ResourceAttribs.Name, VarName, m_SamplerSuffix); + } // + ); } else { @@ -114,11 +119,11 @@ SHADER_RESOURCE_VARIABLE_TYPE ShaderResources::FindVariableType(const D3DShaderR Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs& ResourceAttribs, const PipelineResourceLayoutDesc& ResourceLayoutDesc, - bool LogStaticSamplerArrayError)const + bool LogStaticSamplerArrayError) const { VERIFY(ResourceAttribs.GetInputType() == D3D_SIT_SAMPLER, "Sampler is expected"); - auto StaticSamplerInd = + auto StaticSamplerInd = Diligent::FindStaticSampler(ResourceLayoutDesc.StaticSamplers, ResourceLayoutDesc.NumStaticSamplers, m_ShaderType, @@ -134,9 +139,9 @@ Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs& Resou { if (LogStaticSamplerArrayError) { - LOG_ERROR_MESSAGE("Static sampler '", ResourceAttribs.Name, '[', ResourceAttribs.BindCount, "]' will be ignored because static " - "sampler arrays are not allowed in shader model 5.1 and above. Compile the shader using shader " - "model 5.0 or use non-array sampler variable."); + LOG_ERROR_MESSAGE("Static sampler '", ResourceAttribs.Name, '[', ResourceAttribs.BindCount, + "]' will be ignored because static sampler arrays are not allowed in shader model 5.1 and above. " + "Compile the shader using shader model 5.0 or use non-array sampler variable."); } StaticSamplerInd = -1; } @@ -149,19 +154,19 @@ Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs& Resou D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResourceLayoutDesc& ResourceLayout, const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes, Uint32 NumAllowedTypes, - bool CountStaticSamplers)const noexcept + bool CountStaticSamplers) const noexcept { auto AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes); D3DShaderResourceCounters Counters; ProcessResources( - [&](const D3DShaderResourceAttribs& CB, Uint32) + [&](const D3DShaderResourceAttribs& CB, Uint32) // { auto VarType = FindVariableType(CB, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) ++Counters.NumCBs; }, - [&](const D3DShaderResourceAttribs& Sam, Uint32) + [&](const D3DShaderResourceAttribs& Sam, Uint32) // { auto VarType = FindVariableType(Sam, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) @@ -175,30 +180,30 @@ D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResource ++Counters.NumSamplers; } }, - [&](const D3DShaderResourceAttribs& TexSRV, Uint32) + [&](const D3DShaderResourceAttribs& TexSRV, Uint32) // { auto VarType = FindVariableType(TexSRV, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) ++Counters.NumTexSRVs; }, - [&](const D3DShaderResourceAttribs& TexUAV, Uint32) + [&](const D3DShaderResourceAttribs& TexUAV, Uint32) // { auto VarType = FindVariableType(TexUAV, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) ++Counters.NumTexUAVs; }, - [&](const D3DShaderResourceAttribs& BufSRV, Uint32) + [&](const D3DShaderResourceAttribs& BufSRV, Uint32) // { auto VarType = FindVariableType(BufSRV, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) ++Counters.NumBufSRVs; }, - [&](const D3DShaderResourceAttribs& BufUAV, Uint32) + [&](const D3DShaderResourceAttribs& BufUAV, Uint32) // { auto VarType = FindVariableType(BufUAV, ResourceLayout); if (IsAllowedType(VarType, AllowedTypeBits)) ++Counters.NumBufUAVs; - } + } // ); return Counters; @@ -209,10 +214,10 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& const ShaderResources* const pShaderResources[], Uint32 NumShaders) { - auto GetAllowedShadersString = [&](SHADER_TYPE ShaderStages) + auto GetAllowedShadersString = [&](SHADER_TYPE ShaderStages) // { std::string ShadersStr; - for (Uint32 s=0; s < NumShaders; ++s) + for (Uint32 s = 0; s < NumShaders; ++s) { const auto& Resources = *pShaderResources[s]; if ((ShaderStages & Resources.GetShaderType()) != 0) @@ -240,15 +245,15 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& for (Uint32 s = 0; s < NumShaders && !VariableFound; ++s) { const auto& Resources = *pShaderResources[s]; - if( (VarDesc.ShaderStages & Resources.GetShaderType()) == 0) + if ((VarDesc.ShaderStages & Resources.GetShaderType()) == 0) continue; - + const auto UseCombinedTextureSamplers = Resources.IsUsingCombinedTextureSamplers(); - for (Uint32 n=0; n < Resources.m_TotalResources && !VariableFound; ++n) + for (Uint32 n = 0; n < Resources.m_TotalResources && !VariableFound; ++n) { const auto& Res = Resources.GetResAttribs(n, Resources.m_TotalResources, 0); - // Skip samplers if combined texture samplers are used as + // Skip samplers if combined texture samplers are used as // in this case they are not treated as independent variables if (UseCombinedTextureSamplers && Res.GetInputType() == D3D_SIT_SAMPLER) continue; @@ -275,22 +280,22 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& } const auto* TexOrSamName = StSamDesc.SamplerOrTextureName; - + bool StaticSamplerFound = false; for (Uint32 s = 0; s < NumShaders && !StaticSamplerFound; ++s) { const auto& Resources = *pShaderResources[s]; - if ( (StSamDesc.ShaderStages & Resources.GetShaderType()) == 0) + if ((StSamDesc.ShaderStages & Resources.GetShaderType()) == 0) continue; // Look for static sampler. // In case HLSL-style combined image samplers are used, the condition is Sampler.Name == "g_Texture" + "_sampler". // Otherwise the condition is Sampler.Name == "g_Texture_sampler" + "". const auto* CombinedSamplerSuffix = Resources.GetCombinedSamplerSuffix(); - for (Uint32 n=0; n < Resources.GetNumSamplers() && !StaticSamplerFound; ++n) + for (Uint32 n = 0; n < Resources.GetNumSamplers() && !StaticSamplerFound; ++n) { const auto& Sampler = Resources.GetSampler(n); - StaticSamplerFound = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix); + StaticSamplerFound = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix); } } @@ -304,7 +309,7 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& #endif -Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix)const +Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix) const { VERIFY_EXPR(SamplerSuffix != nullptr && *SamplerSuffix != 0); VERIFY_EXPR(TexSRV.GetInputType() == D3D_SIT_TEXTURE && TexSRV.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER); @@ -312,94 +317,94 @@ Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& Te for (Uint32 s = 0; s < NumSamplers; ++s) { const auto& Sampler = GetSampler(s); - if ( StreqSuff(Sampler.Name, TexSRV.Name, SamplerSuffix) ) + if (StreqSuff(Sampler.Name, TexSRV.Name, SamplerSuffix)) { - DEV_CHECK_ERR(Sampler.BindCount == TexSRV.BindCount || Sampler.BindCount == 1, "Sampler '", Sampler.Name, "' assigned to texture '", TexSRV.Name, "' must be scalar or have the same array dimension (", TexSRV.BindCount, "). Actual sampler array dimension : ", Sampler.BindCount); + DEV_CHECK_ERR(Sampler.BindCount == TexSRV.BindCount || Sampler.BindCount == 1, "Sampler '", Sampler.Name, "' assigned to texture '", TexSRV.Name, "' must be scalar or have the same array dimension (", TexSRV.BindCount, "). Actual sampler array dimension : ", Sampler.BindCount); return s; } } return D3DShaderResourceAttribs::InvalidSamplerId; } -bool ShaderResources::IsCompatibleWith(const ShaderResources &Res)const +bool ShaderResources::IsCompatibleWith(const ShaderResources& Res) const { - if (GetNumCBs() != Res.GetNumCBs() || - GetNumTexSRV() != Res.GetNumTexSRV() || - GetNumTexUAV() != Res.GetNumTexUAV() || - GetNumBufSRV() != Res.GetNumBufSRV() || - GetNumBufUAV() != Res.GetNumBufUAV() || + if (GetNumCBs() != Res.GetNumCBs() || + GetNumTexSRV() != Res.GetNumTexSRV() || + GetNumTexUAV() != Res.GetNumTexUAV() || + GetNumBufSRV() != Res.GetNumBufSRV() || + GetNumBufUAV() != Res.GetNumBufUAV() || GetNumSamplers() != Res.GetNumSamplers()) return false; bool IsCompatible = true; ProcessResources( - [&](const D3DShaderResourceAttribs& CB, Uint32 n) + [&](const D3DShaderResourceAttribs& CB, Uint32 n) // { if (!CB.IsCompatibleWith(Res.GetCB(n))) IsCompatible = false; }, - [&](const D3DShaderResourceAttribs& Sam, Uint32 n) + [&](const D3DShaderResourceAttribs& Sam, Uint32 n) // { if (!Sam.IsCompatibleWith(Res.GetSampler(n))) IsCompatible = false; }, - [&](const D3DShaderResourceAttribs& TexSRV, Uint32 n) + [&](const D3DShaderResourceAttribs& TexSRV, Uint32 n) // { if (!TexSRV.IsCompatibleWith(Res.GetTexSRV(n))) IsCompatible = false; }, - [&](const D3DShaderResourceAttribs& TexUAV, Uint32 n) + [&](const D3DShaderResourceAttribs& TexUAV, Uint32 n) // { if (!TexUAV.IsCompatibleWith(Res.GetTexUAV(n))) IsCompatible = false; }, - [&](const D3DShaderResourceAttribs& BufSRV, Uint32 n) + [&](const D3DShaderResourceAttribs& BufSRV, Uint32 n) // { if (!BufSRV.IsCompatibleWith(Res.GetBufSRV(n))) IsCompatible = false; }, - [&](const D3DShaderResourceAttribs& BufUAV, Uint32 n) + [&](const D3DShaderResourceAttribs& BufUAV, Uint32 n) // { if (!BufUAV.IsCompatibleWith(Res.GetBufUAV(n))) IsCompatible = false; - } + } // ); return IsCompatible; } -HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const +HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc() const { HLSLShaderResourceDesc ResourceDesc; ResourceDesc.Name = Name; ResourceDesc.ArraySize = BindCount; ResourceDesc.ShaderRegister = BindPoint; - switch(GetInputType()) + switch (GetInputType()) { case D3D_SIT_CBUFFER: ResourceDesc.Type = SHADER_RESOURCE_TYPE_CONSTANT_BUFFER; - break; + break; case D3D_SIT_TBUFFER: - UNSUPPORTED( "TBuffers are not supported" ); + UNSUPPORTED("TBuffers are not supported"); ResourceDesc.Type = SHADER_RESOURCE_TYPE_UNKNOWN; - break; + break; case D3D_SIT_TEXTURE: ResourceDesc.Type = (GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER ? SHADER_RESOURCE_TYPE_BUFFER_SRV : SHADER_RESOURCE_TYPE_TEXTURE_SRV); - break; + break; case D3D_SIT_SAMPLER: ResourceDesc.Type = SHADER_RESOURCE_TYPE_SAMPLER; - break; + break; case D3D_SIT_UAV_RWTYPED: ResourceDesc.Type = (GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER ? SHADER_RESOURCE_TYPE_BUFFER_UAV : SHADER_RESOURCE_TYPE_TEXTURE_UAV); - break; + break; case D3D_SIT_STRUCTURED: case D3D_SIT_BYTEADDRESS: ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_SRV; - break; + break; case D3D_SIT_UAV_RWSTRUCTURED: case D3D_SIT_UAV_RWBYTEADDRESS: @@ -407,7 +412,7 @@ HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const case D3D_SIT_UAV_CONSUME_STRUCTURED: case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_UAV; - break; + break; default: UNEXPECTED("Unknown input type"); @@ -416,7 +421,7 @@ HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const return ResourceDesc; } -HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index)const +HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index) const { DEV_CHECK_ERR(Index < m_TotalResources, "Resource index (", Index, ") is out of range"); HLSLShaderResourceDesc HLSLResourceDesc = {}; @@ -428,10 +433,10 @@ HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index)c return HLSLResourceDesc; } -size_t ShaderResources::GetHash()const +size_t ShaderResources::GetHash() const { size_t hash = ComputeHash(GetNumCBs(), GetNumTexSRV(), GetNumTexUAV(), GetNumBufSRV(), GetNumBufUAV(), GetNumSamplers()); - for (Uint32 n=0; n < m_TotalResources; ++n) + for (Uint32 n = 0; n < m_TotalResources; ++n) { const auto& Res = GetResAttribs(n, m_TotalResources, 0); HashCombine(hash, Res); @@ -440,4 +445,4 @@ size_t ShaderResources::GetHash()const return hash; } -} +} // namespace Diligent -- cgit v1.2.3