From 34afc690521ec86a151eb9c410d536474910bbd4 Mon Sep 17 00:00:00 2001 From: MikhailGorobets Date: Fri, 17 Dec 2021 21:31:38 +0500 Subject: [PATCH] Add unit tests for #75 (close #76, #71) --- .../interface/RenderStateNotationParser.h | 112 ++++++++- .../src/RenderStateNotationParserImpl.cpp | 34 ++- Tests/DiligentToolsTest/CMakeLists.txt | 1 + .../PipelineResourceSignatureDesc.json | 1 + .../ComputePipelineNotation.json | 14 ++ .../GraphicsPipelineNotation.json | 26 ++ .../PipelineStates.json | 64 +++++ .../RayTracingPipelineNotation.json | 56 +++++ .../RenderPasses.json | 16 ++ .../RenderStatesLibrary.json | 8 + .../ResourceSignatures.json | 11 + .../RenderStateNotationParser/Shaders.json | 34 +++ .../TilePipelineNotation.json | 11 + .../PipelineResourceSignatureParserTest.cpp | 1 + .../RenderStateNotationParserTest.cpp | 230 ++++++++++++++++++ 15 files changed, 608 insertions(+), 11 deletions(-) create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ComputePipelineNotation.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/GraphicsPipelineNotation.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/PipelineStates.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RayTracingPipelineNotation.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderPasses.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderStatesLibrary.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ResourceSignatures.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/Shaders.json create mode 100644 Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/TilePipelineNotation.json create mode 100644 Tests/DiligentToolsTest/src/RenderStateNotationParser/RenderStateNotationParserTest.cpp diff --git a/RenderStateNotationParser/interface/RenderStateNotationParser.h b/RenderStateNotationParser/interface/RenderStateNotationParser.h index 9aaa41762..1ae9e98ce 100644 --- a/RenderStateNotationParser/interface/RenderStateNotationParser.h +++ b/RenderStateNotationParser/interface/RenderStateNotationParser.h @@ -43,6 +43,20 @@ struct PipelineStateNotation const Char** ppResourceSignatureNames DEFAULT_INITIALIZER(nullptr); Uint32 ResourceSignaturesNameCount DEFAULT_INITIALIZER(0); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const PipelineStateNotation& RHS) const + { + if (!(PSODesc == RHS.PSODesc) || !(Flags == RHS.Flags) || !(ResourceSignaturesNameCount == RHS.ResourceSignaturesNameCount)) + return false; + + for (Uint32 SignatureID = 0; SignatureID < ResourceSignaturesNameCount; SignatureID++) + if (!SafeStrEqual(ppResourceSignatureNames[SignatureID], RHS.ppResourceSignatureNames[SignatureID])) + return false; + + return true; + } +#endif }; typedef struct PipelineStateNotation PipelineStateNotation; @@ -66,6 +80,24 @@ struct GraphicsPipelineNotation DILIGENT_DERIVE(PipelineStateNotation) const Char* pASName DEFAULT_INITIALIZER(nullptr); const Char* pMSName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const GraphicsPipelineNotation& RHS) const + { + if (!(static_cast(*this) == static_cast(RHS))) + return false; + + return Desc == RHS.Desc && + SafeStrEqual(pRenderPassName, RHS.pRenderPassName) && + SafeStrEqual(pVSName, RHS.pVSName) && + SafeStrEqual(pPSName, RHS.pPSName) && + SafeStrEqual(pDSName, RHS.pDSName) && + SafeStrEqual(pHSName, RHS.pHSName) && + SafeStrEqual(pGSName, RHS.pGSName) && + SafeStrEqual(pASName, RHS.pASName) && + SafeStrEqual(pMSName, RHS.pMSName); + } +#endif }; typedef struct GraphicsPipelineNotation GraphicsPipelineNotation; @@ -73,6 +105,16 @@ typedef struct GraphicsPipelineNotation GraphicsPipelineNotation; struct ComputePipelineNotation DILIGENT_DERIVE(PipelineStateNotation) const Char* pCSName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const ComputePipelineNotation& RHS) const + { + if (!(static_cast(*this) == static_cast(RHS))) + return false; + + return SafeStrEqual(pCSName, RHS.pCSName); + } +#endif }; typedef struct ComputePipelineNotation ComputePipelineNotation; @@ -80,6 +122,16 @@ typedef struct ComputePipelineNotation ComputePipelineNotation; struct TilePipelineNotation DILIGENT_DERIVE(PipelineStateNotation) const Char* pTSName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const TilePipelineNotation& RHS) const + { + if (!(static_cast(*this) == static_cast(RHS))) + return false; + + return SafeStrEqual(pTSName, RHS.pTSName); + } +#endif }; typedef struct TilePipelineNotation TilePipelineNotation; @@ -89,6 +141,14 @@ struct RTGeneralShaderGroupNotation const Char* Name DEFAULT_INITIALIZER(nullptr); const Char* pShaderName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const RTGeneralShaderGroupNotation& RHS) const + { + return SafeStrEqual(Name, RHS.Name) && + SafeStrEqual(pShaderName, RHS.pShaderName); + } +#endif }; typedef struct RTGeneralShaderGroupNotation RTGeneralShaderGroupNotation; @@ -100,6 +160,15 @@ struct RTTriangleHitShaderGroupNotation const Char* pClosestHitShaderName DEFAULT_INITIALIZER(nullptr); const Char* pAnyHitShaderName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const RTTriangleHitShaderGroupNotation& RHS) const + { + return SafeStrEqual(Name, RHS.Name) && + SafeStrEqual(pClosestHitShaderName, RHS.pClosestHitShaderName) && + SafeStrEqual(pAnyHitShaderName, RHS.pAnyHitShaderName); + } +#endif }; typedef struct RTTriangleHitShaderGroupNotation RTTriangleHitShaderGroupNotation; @@ -113,13 +182,23 @@ struct RTProceduralHitShaderGroupNotation const Char* pClosestHitShaderName DEFAULT_INITIALIZER(nullptr); const Char* pAnyHitShaderName DEFAULT_INITIALIZER(nullptr); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const RTProceduralHitShaderGroupNotation& RHS) const + { + return SafeStrEqual(Name, RHS.Name) && + SafeStrEqual(pIntersectionShaderName, RHS.pIntersectionShaderName) && + SafeStrEqual(pClosestHitShaderName, RHS.pClosestHitShaderName) && + SafeStrEqual(pAnyHitShaderName, RHS.pAnyHitShaderName); + } +#endif }; typedef struct RTProceduralHitShaderGroupNotation RTProceduralHitShaderGroupNotation; struct RayTracingPipelineNotation DILIGENT_DERIVE(PipelineStateNotation) - RayTracingPipelineDesc Desc; + RayTracingPipelineDesc RayTracingPipeline; const RTGeneralShaderGroupNotation* pGeneralShaders DEFAULT_INITIALIZER(nullptr); @@ -138,6 +217,37 @@ struct RayTracingPipelineNotation DILIGENT_DERIVE(PipelineStateNotation) Uint32 MaxAttributeSize DEFAULT_INITIALIZER(0); Uint32 MaxPayloadSize DEFAULT_INITIALIZER(0); + +#if DILIGENT_CPP_INTERFACE + bool operator == (const RayTracingPipelineNotation& RHS) const + { + if (!(static_cast(*this) == static_cast(RHS))) + return false; + + if (!(RayTracingPipeline == RHS.RayTracingPipeline) || + !(GeneralShaderCount == RHS.GeneralShaderCount) || + !(TriangleHitShaderCount == RHS.TriangleHitShaderCount) || + !(ProceduralHitShaderCount == RHS.ProceduralHitShaderCount) || + !(MaxAttributeSize == RHS.MaxAttributeSize) || + !(MaxPayloadSize == RHS.MaxPayloadSize) || + !SafeStrEqual(pShaderRecordName, RHS.pShaderRecordName)) + return false; + + for (Uint32 GroupID = 0; GroupID < GeneralShaderCount; GroupID++) + if (!(pGeneralShaders[GroupID] == RHS.pGeneralShaders[GroupID])) + return false; + + for (Uint32 GroupID = 0; GroupID < TriangleHitShaderCount; GroupID++) + if (!(pTriangleHitShaders[GroupID] == RHS.pTriangleHitShaders[GroupID])) + return false; + + for (Uint32 GroupID = 0; GroupID < ProceduralHitShaderCount; GroupID++) + if (!(pProceduralHitShaders[GroupID] == RHS.pProceduralHitShaders[GroupID])) + return false; + + return true; + } +#endif }; typedef struct RayTracingPipelineNotation RayTracingPipelineNotation; diff --git a/RenderStateNotationParser/src/RenderStateNotationParserImpl.cpp b/RenderStateNotationParser/src/RenderStateNotationParserImpl.cpp index 55bbf23ec..54f73598d 100644 --- a/RenderStateNotationParser/src/RenderStateNotationParserImpl.cpp +++ b/RenderStateNotationParser/src/RenderStateNotationParserImpl.cpp @@ -141,7 +141,7 @@ static void Deserialize(const nlohmann::json& Json, RayTracingPipelineNotation& Deserialize(Json, static_cast(Type), Allocator); if (Json.contains("RayTracingPipeline")) - Deserialize(Json["RayTracingPipeline"], Type.Desc, Allocator); + Deserialize(Json["RayTracingPipeline"], Type.RayTracingPipeline, Allocator); if (Json.contains("pGeneralShaders")) Deserialize(Json["pGeneralShaders"], Type.pGeneralShaders, Type.GeneralShaderCount, Allocator); @@ -153,13 +153,13 @@ static void Deserialize(const nlohmann::json& Json, RayTracingPipelineNotation& Deserialize(Json["pProceduralHitShaders"], Type.pProceduralHitShaders, Type.ProceduralHitShaderCount, Allocator); if (Json.contains("pShaderRecordName")) - Deserialize(Json["MaxAttributeSize"], Type.pShaderRecordName, Allocator); + Deserialize(Json["pShaderRecordName"], Type.pShaderRecordName, Allocator); if (Json.contains("MaxAttributeSize")) Deserialize(Json["MaxAttributeSize"], Type.MaxAttributeSize, Allocator); if (Json.contains("MaxPayloadSize")) - Deserialize(Json["MaxAttributeSize"], Type.MaxPayloadSize, Allocator); + Deserialize(Json["MaxPayloadSize"], Type.MaxPayloadSize, Allocator); } } // namespace Diligent @@ -199,7 +199,20 @@ RenderStateNotationParserImpl::RenderStateNotationParserImpl(IReferenceCounters* Source.assign(ParserCI.StrData); } - nlohmann::json Json = nlohmann::json::parse(Source); + nlohmann::json Json; + + try + { + Json = nlohmann::json::parse(Source); + } + catch (std::exception& e) + { + LOG_ERROR(e.what()); + if (ParserCI.FilePath != nullptr) + LOG_ERROR_AND_THROW("Failed to parse file: '", ParserCI.FilePath, "'."); + else + LOG_ERROR_AND_THROW("Failed to parse string: '", ParserCI.StrData, "'."); + } for (auto const& Import : Json["Imports"]) { @@ -240,7 +253,7 @@ RenderStateNotationParserImpl::RenderStateNotationParserImpl(IReferenceCounters* m_ResourceSignatures.push_back(ResourceDesc); } - for (auto const& Pipeline : Json["Pipeleines"]) + for (auto const& Pipeline : Json["Pipelines"]) { auto& PipelineType = Pipeline["PSODesc"]["PipelineType"]; @@ -298,7 +311,7 @@ RenderStateNotationParserImpl::RenderStateNotationParserImpl(IReferenceCounters* ParseJSON(CreateInfo); m_ParseInfo.ResourceSignatureCount = StaticCast(m_ResourceSignatures.size()); - m_ParseInfo.ShaderCount = StaticCast(m_ShaderNames.size()); + m_ParseInfo.ShaderCount = StaticCast(m_Shaders.size()); m_ParseInfo.RenderPassCount = StaticCast(m_RenderPasses.size()); m_ParseInfo.GraphicsPipelineStateCount = StaticCast(m_GraphicsPipelineStates.size()); m_ParseInfo.ComputePipelineStateCount = StaticCast(m_ComputePipelineStates.size()); @@ -356,8 +369,8 @@ const ShaderCreateInfo* RenderStateNotationParserImpl::GetShaderByName(const Cha const RenderPassDesc* RenderStateNotationParserImpl::GetRenderPassByName(const Char* Name) const { - auto Iter = m_RayTracingPipelineNames.find(Name); - if (Iter != m_RayTracingPipelineNames.end()) + auto Iter = m_RenderPassNames.find(Name); + if (Iter != m_RenderPassNames.end()) return &m_RenderPasses[Iter->second]; return nullptr; } @@ -426,9 +439,10 @@ void CreateRenderStateNotationParser(const RenderStateNotationParserCreateInfo& if (pParser) pParser->QueryInterface(IID_RenderStateNotationParser, reinterpret_cast(ppParser)); } - catch (std::exception& err) + catch (std::exception& e) { - LOG_ERROR("Failed to create descriptor parser: ", err.what()); + LOG_ERROR(e.what()); + LOG_ERROR("Failed to create descriptor parser"); } } diff --git a/Tests/DiligentToolsTest/CMakeLists.txt b/Tests/DiligentToolsTest/CMakeLists.txt index f28607650..fad6f91a9 100644 --- a/Tests/DiligentToolsTest/CMakeLists.txt +++ b/Tests/DiligentToolsTest/CMakeLists.txt @@ -19,6 +19,7 @@ PRIVATE Diligent-TextureLoader Diligent-Common Diligent-GraphicsEngine + Diligent-RenderStateNotationParser LibPng ) diff --git a/Tests/DiligentToolsTest/assets/RenderStates/PipelineResourceSignature/PipelineResourceSignatureDesc.json b/Tests/DiligentToolsTest/assets/RenderStates/PipelineResourceSignature/PipelineResourceSignatureDesc.json index 700ed1105..2b33bfb20 100644 --- a/Tests/DiligentToolsTest/assets/RenderStates/PipelineResourceSignature/PipelineResourceSignatureDesc.json +++ b/Tests/DiligentToolsTest/assets/RenderStates/PipelineResourceSignature/PipelineResourceSignatureDesc.json @@ -1,4 +1,5 @@ { + "Name": "TestName0", "Resources": [ { "Name": "TestName0", diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ComputePipelineNotation.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ComputePipelineNotation.json new file mode 100644 index 000000000..86e7ac425 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ComputePipelineNotation.json @@ -0,0 +1,14 @@ +{ + "Pipelines": [ + { + "PSODesc": { + "Name": "TestName", + "PipelineType": "COMPUTE" + }, + "ppResourceSignatures": [ + "TestName0" + ], + "pCS": "Shader-CS" + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/GraphicsPipelineNotation.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/GraphicsPipelineNotation.json new file mode 100644 index 000000000..3a98e33b0 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/GraphicsPipelineNotation.json @@ -0,0 +1,26 @@ +{ + "Pipelines": [ + { + "GraphicsPipeline": { + "PrimitiveTopology": "TRIANGLE_LIST", + "pRenderPass": "RenderPassTest" + }, + "PSODesc": { + "Name": "TestName", + "PipelineType": "GRAPHICS" + }, + "Flags": "IGNORE_MISSING_VARIABLES", + "ppResourceSignatures": [ + "TestName0", + "TestName1" + ], + "pVS": "Shader-VS", + "pPS": "Shader-PS", + "pDS": "Shader-DS", + "pHS": "Shader-HS", + "pGS": "Shader-GS", + "pAS": "Shader-AS", + "pMS": "Shader-MS" + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/PipelineStates.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/PipelineStates.json new file mode 100644 index 000000000..16421950d --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/PipelineStates.json @@ -0,0 +1,64 @@ +{ + "Pipelines": [ + { + "GraphicsPipeline": { + "DepthStencilDesc": { + "DepthEnable": false + }, + "RasterizerDesc": { + "FillMode": "SOLID", + "CullMode": "NONE" + }, + "NumRenderTargets": 1, + "RTVFormats": { + "0": "RGBA8_UNORM_SRGB" + }, + "PrimitiveTopology": "TRIANGLE_LIST" + }, + "PSODesc": { + "Name": "Graphics-Pipeline0", + "PipelineType": "GRAPHICS" + }, + "ppResourceSignatureNames": [ + "TestName0" + ], + "pVS": "Shader0-VS", + "pPS": "Shader0-PS" + }, + { + "PSODesc": { + "Name": "Compute-Pipeline0", + "PipelineType": "COMPUTE" + }, + "ppResourceSignatureNames": [ + "TestName0" + ], + "pCS": "Shader0-CS" + }, + { + "PSODesc": { + "Name": "Tile-Pipeline0", + "PipelineType": "TILE" + }, + "ppResourceSignatureNames": [ + "TestName0" + ], + "pTS": "Shader0-TS" + }, + { + "PSODesc": { + "Name": "RayTracing-Pipeline0", + "PipelineType": "RAY_TRACING" + }, + "ppResourceSignatureNames": [ + "TestName0" + ], + "pGeneralShaders": [ + { + "Name": "TestName", + "pShaderName": "Shader0-RT" + } + ] + } + ] +} \ No newline at end of file diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RayTracingPipelineNotation.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RayTracingPipelineNotation.json new file mode 100644 index 000000000..4eaef22bf --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RayTracingPipelineNotation.json @@ -0,0 +1,56 @@ +{ + "Pipelines": [ + { + "RayTracingPipeline": { + "ShaderRecordSize": 256, + "MaxRecursionDepth": 8 + }, + "PSODesc": { + "Name": "TestName", + "PipelineType": "RAY_TRACING" + }, + "MaxAttributeSize": 2, + "MaxPayloadSize": 4, + "pShaderRecordName": "TestNameRecord", + "pGeneralShaders": [ + { + "Name": "Name0", + "pShader": "Shader0" + } + ], + "pTriangleHitShaders": [ + { + "Name": "Name0", + "pClosestHitShader": "ClosestHitShader0", + "pAnyHitShader": "AnyHitShader0" + }, + { + "Name": "Name1", + "pClosestHitShader": "ClosestHitShader1", + "pAnyHitShader": "AnyHitShader1" + } + ], + "pProceduralHitShaders": [ + { + "Name": "Name0", + "pIntersectionShader": "IntersectionShader0", + "pClosestHitShader": "ClosestHitShader0", + "pAnyHitShader": "AnyHitShader0" + }, + { + "Name": "Name1", + "pIntersectionShader": "IntersectionShader1", + "pClosestHitShader": "ClosestHitShader1", + "pAnyHitShader": "AnyHitShader1" + }, + { + "Name": "Name2", + "pIntersectionShader": "IntersectionShader2", + "pClosestHitShader": "ClosestHitShader2", + "pAnyHitShader": "AnyHitShader2" + } + ] + + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderPasses.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderPasses.json new file mode 100644 index 000000000..96afe1987 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderPasses.json @@ -0,0 +1,16 @@ +{ + "RenderPasses": [ + { + "Name": "TestName0" + }, + { + "Name": "TestName1" + }, + { + "Name": "TestName2" + }, + { + "Name": "TestName3" + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderStatesLibrary.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderStatesLibrary.json new file mode 100644 index 000000000..45f521dba --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/RenderStatesLibrary.json @@ -0,0 +1,8 @@ +{ + "Imports": [ + "Shaders.json", + "ResourceSignatures.json", + "RenderPasses.json", + "PipelineStates.json" + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ResourceSignatures.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ResourceSignatures.json new file mode 100644 index 000000000..f7ac1e4a8 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/ResourceSignatures.json @@ -0,0 +1,11 @@ +{ + + "ResourceSignatures": [ + { + "Name": "TestName0" + }, + { + "Name": "TestName1" + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/Shaders.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/Shaders.json new file mode 100644 index 000000000..21f699838 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/Shaders.json @@ -0,0 +1,34 @@ +{ + "Shaders": [ + { + "Desc": { + "Name": "Shader0-VS", + "ShaderType": "VERTEX" + }, + "SourceLanguage": "HLSL", + "FilePath": "TestPath0.hlsl", + "EntryPoint": "VSMain", + "UseCombinedTextureSamplers": true + }, + { + "Desc": { + "Name": "Shader0-PS", + "ShaderType": "PIXEL" + }, + "SourceLanguage": "HLSL", + "FilePath": "TestPath0.hlsl", + "EntryPoint": "PSMain", + "UseCombinedTextureSamplers": true + }, + { + "Desc": { + "Name": "Shader1-CS", + "ShaderType": "COMPUTE" + }, + "SourceLanguage": "HLSL", + "FilePath": "TestPath01.hlsl", + "EntryPoint": "CSMain", + "UseCombinedTextureSamplers": true + } + ] +} diff --git a/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/TilePipelineNotation.json b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/TilePipelineNotation.json new file mode 100644 index 000000000..d649b7f80 --- /dev/null +++ b/Tests/DiligentToolsTest/assets/RenderStates/RenderStateNotationParser/TilePipelineNotation.json @@ -0,0 +1,11 @@ +{ + "Pipelines": [ + { + "PSODesc": { + "Name": "TestName", + "PipelineType": "TILE" + }, + "pTS": "Shader-TS" + } + ] +} diff --git a/Tests/DiligentToolsTest/src/RenderStateNotationParser/PipelineResourceSignatureParserTest.cpp b/Tests/DiligentToolsTest/src/RenderStateNotationParser/PipelineResourceSignatureParserTest.cpp index ead87eb98..04aaa9483 100644 --- a/Tests/DiligentToolsTest/src/RenderStateNotationParser/PipelineResourceSignatureParserTest.cpp +++ b/Tests/DiligentToolsTest/src/RenderStateNotationParser/PipelineResourceSignatureParserTest.cpp @@ -96,6 +96,7 @@ TEST(Tools_RenderStateNotationParser, ParsePipelineResourceSignatureDesc) ImmutableSamplerDesc{SHADER_TYPE_PIXEL, "TestName1", {}}}; PipelineResourceSignatureDesc DescReference{}; + DescReference.Name = "TestName0"; DescReference.Resources = Resources; DescReference.NumResources = _countof(Resources); DescReference.ImmutableSamplers = Samplers; diff --git a/Tests/DiligentToolsTest/src/RenderStateNotationParser/RenderStateNotationParserTest.cpp b/Tests/DiligentToolsTest/src/RenderStateNotationParser/RenderStateNotationParserTest.cpp new file mode 100644 index 000000000..1feb50ded --- /dev/null +++ b/Tests/DiligentToolsTest/src/RenderStateNotationParser/RenderStateNotationParserTest.cpp @@ -0,0 +1,230 @@ +/* + * Copyright 2019-2021 Diligent Graphics LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * In no event and under no legal theory, whether in tort (including negligence), + * contract, or otherwise, unless required by applicable law (such as deliberate + * and grossly negligent acts) or agreed to in writing, shall any Contributor be + * liable for any damages, including any direct, indirect, special, incidental, + * or consequential damages of any character arising as a result of this License or + * out of the use or inability to use the software (including but not limited to damages + * for loss of goodwill, work stoppage, computer failure or malfunction, or any and + * all other commercial damages or losses), even if such Contributor has been advised + * of the possibility of such damages. + */ + +#include "gtest/gtest.h" +#include "DRSNLoader.hpp" +#include "RenderStateNotationParser.h" +#include "DefaultShaderSourceStreamFactory.h" + +using namespace Diligent; + +namespace +{ + +RefCntAutoPtr LoadFromFile(const Char* Path) +{ + RefCntAutoPtr pStreamFactory; + CreateDefaultShaderSourceStreamFactory("RenderStates/RenderStateNotationParser", &pStreamFactory); + + RefCntAutoPtr pParser; + RenderStateNotationParserCreateInfo ParserCI{}; + ParserCI.FilePath = Path; + ParserCI.pStreamFactory = pStreamFactory; + + CreateRenderStateNotationParser(ParserCI, &pParser); + return pParser; +} + +TEST(Tools_RenderStateNotationParser, GraphicsPipelineNotationTest) +{ + RefCntAutoPtr pParser = LoadFromFile("GraphicsPipelineNotation.json"); + ASSERT_NE(pParser, nullptr); + + const Char* ResourceSignatures[] = { + "TestName0", + "TestName1"}; + + GraphicsPipelineNotation DescReference{}; + DescReference.Desc.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + DescReference.PSODesc.Name = "TestName"; + DescReference.PSODesc.PipelineType = PIPELINE_TYPE_GRAPHICS; + DescReference.Flags = PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES; + DescReference.ppResourceSignatureNames = ResourceSignatures; + DescReference.ResourceSignaturesNameCount = 2; + DescReference.pRenderPassName = "RenderPassTest"; + DescReference.pVSName = "Shader-VS"; + DescReference.pPSName = "Shader-PS"; + DescReference.pDSName = "Shader-DS"; + DescReference.pHSName = "Shader-HS"; + DescReference.pGSName = "Shader-GS"; + DescReference.pASName = "Shader-AS"; + DescReference.pMSName = "Shader-MS"; + + auto pDesc = pParser->GetGraphicsPipelineStateByName("TestName"); + ASSERT_NE(pDesc, nullptr); + ASSERT_EQ(*pDesc, DescReference); +} + +TEST(Tools_RenderStateNotationParser, ComputePipelineNotationTest) +{ + RefCntAutoPtr pParser = LoadFromFile("ComputePipelineNotation.json"); + ASSERT_NE(pParser, nullptr); + + const Char* ResourceSignatures[] = { + "TestName0"}; + + ComputePipelineNotation DescReference{}; + DescReference.PSODesc.Name = "TestName"; + DescReference.PSODesc.PipelineType = PIPELINE_TYPE_COMPUTE; + DescReference.ppResourceSignatureNames = ResourceSignatures; + DescReference.ResourceSignaturesNameCount = 1; + DescReference.pCSName = "Shader-CS"; + + auto pDesc = pParser->GetComputePipelineStateByName("TestName"); + ASSERT_NE(pDesc, nullptr); + ASSERT_EQ(*pDesc, DescReference); +} + +TEST(Tools_RenderStateNotationParser, RayTracingPipelineNotationTest) +{ + RefCntAutoPtr pParser = LoadFromFile("RayTracingPipelineNotation.json"); + ASSERT_NE(pParser, nullptr); + + RTGeneralShaderGroupNotation GeneralShaders[] = { + RTGeneralShaderGroupNotation{"Name0", "Shader0"}}; + + RTTriangleHitShaderGroupNotation TriangleHitShaders[] = { + RTTriangleHitShaderGroupNotation{"Name0", "ClosestHitShader0", "AnyHitShader0"}, + RTTriangleHitShaderGroupNotation{"Name1", "ClosestHitShader1", "AnyHitShader1"}}; + + RTProceduralHitShaderGroupNotation ProceduralHitShaders[] = { + RTProceduralHitShaderGroupNotation{"Name0", "IntersectionShader0", "ClosestHitShader0", "AnyHitShader0"}, + RTProceduralHitShaderGroupNotation{"Name1", "IntersectionShader1", "ClosestHitShader1", "AnyHitShader1"}, + RTProceduralHitShaderGroupNotation{"Name2", "IntersectionShader2", "ClosestHitShader2", "AnyHitShader2"}}; + + RayTracingPipelineNotation DescReference{}; + DescReference.RayTracingPipeline.ShaderRecordSize = 256; + DescReference.RayTracingPipeline.MaxRecursionDepth = 8; + + DescReference.PSODesc.Name = "TestName"; + DescReference.PSODesc.PipelineType = PIPELINE_TYPE_RAY_TRACING; + DescReference.MaxAttributeSize = 2; + DescReference.MaxPayloadSize = 4; + DescReference.pShaderRecordName = "TestNameRecord"; + DescReference.pGeneralShaders = GeneralShaders; + DescReference.GeneralShaderCount = _countof(GeneralShaders); + DescReference.pTriangleHitShaders = TriangleHitShaders; + DescReference.TriangleHitShaderCount = _countof(TriangleHitShaders); + DescReference.pProceduralHitShaders = ProceduralHitShaders; + DescReference.ProceduralHitShaderCount = _countof(ProceduralHitShaders); + + auto pDesc = pParser->GetRayTracingPipelineStateByName("TestName"); + ASSERT_NE(pDesc, nullptr); + ASSERT_EQ(*pDesc, DescReference); +} + +TEST(Tools_RenderStateNotationParser, TilePipelineNotationTest) +{ + RefCntAutoPtr pParser = LoadFromFile("TilePipelineNotation.json"); + ASSERT_NE(pParser, nullptr); + + TilePipelineNotation DescReference{}; + DescReference.PSODesc.Name = "TestName"; + DescReference.PSODesc.PipelineType = PIPELINE_TYPE_TILE; + DescReference.pTSName = "Shader-TS"; + + auto pDesc = pParser->GetTilePipelineStateByName("TestName"); + ASSERT_NE(pDesc, nullptr); + ASSERT_EQ(*pDesc, DescReference); +} + +TEST(Tools_RenderStateNotationParser, RenderStateNotationParserTest) +{ + RefCntAutoPtr pParser = LoadFromFile("RenderStatesLibrary.json"); + ASSERT_NE(pParser, nullptr); + + auto const& ParserInfo = pParser->GetInfo(); + ASSERT_EQ(ParserInfo.ShaderCount, 3u); + ASSERT_EQ(ParserInfo.RenderPassCount, 4u); + ASSERT_EQ(ParserInfo.ResourceSignatureCount, 2u); + ASSERT_EQ(ParserInfo.GraphicsPipelineStateCount, 1u); + ASSERT_EQ(ParserInfo.ComputePipelineStateCount, 1u); + ASSERT_EQ(ParserInfo.RayTracingPipelineStateCount, 1u); + ASSERT_EQ(ParserInfo.TilePipelineStateCount, 1u); + + auto Iterate = [](Uint32 ResourceCount, std::function const& Callback) { + for (Uint32 ResourceID = 0; ResourceID < ResourceCount; ResourceID++) + Callback(ResourceID); + }; + + Iterate(ParserInfo.ShaderCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetShaderByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetShaderByName(pResourceSrc->Desc.Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.ResourceSignatureCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetResourceSignatureByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetResourceSignatureByName(pResourceSrc->Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.RenderPassCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetRenderPassByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetRenderPassByName(pResourceSrc->Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.GraphicsPipelineStateCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetGraphicsPipelineStateByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetGraphicsPipelineStateByName(pResourceSrc->PSODesc.Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.ComputePipelineStateCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetComputePipelineStateByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetComputePipelineStateByName(pResourceSrc->PSODesc.Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.RayTracingPipelineStateCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetRayTracingPipelineStateByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetRayTracingPipelineStateByName(pResourceSrc->PSODesc.Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); + + Iterate(ParserInfo.TilePipelineStateCount, [&](Uint32 Index) { + auto pResourceSrc = pParser->GetTilePipelineStateByIndex(Index); + ASSERT_NE(pResourceSrc, nullptr); + + auto pResourceDst = pParser->GetTilePipelineStateByName(pResourceSrc->PSODesc.Name); + ASSERT_EQ(pResourceSrc, pResourceDst); + }); +} + +} // namespace