Add SHADER_VARIABLE_FLAG_INLINE_CONSTANTS flag with implementation in D3D12 (#672)

Author: TheMostDiligent

Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp

@@ -1843,7 +1843,7 @@ PIPELINE_RESOURCE_FLAGS GetValidPipelineResourceFlags(SHADER_RESOURCE_TYPE Resou
 
 PIPELINE_RESOURCE_FLAGS ShaderVariableFlagsToPipelineResourceFlags(SHADER_VARIABLE_FLAGS Flags)
 {
-    static_assert(SHADER_VARIABLE_FLAG_LAST == (1 << 3), "Please update the switch below to handle the new shader variable flags");
+    static_assert(SHADER_VARIABLE_FLAG_LAST == (1 << 4), "Please update the switch below to handle the new shader variable flags");
     switch (Flags)
     {
         case SHADER_VARIABLE_FLAG_NONE:
@@ -1859,6 +1859,9 @@ PIPELINE_RESOURCE_FLAGS ShaderVariableFlagsToPipelineResourceFlags(SHADER_VARIAB
         case SHADER_VARIABLE_FLAG_NON_FILTERING_SAMPLER_WEBGPU:
             return PIPELINE_RESOURCE_FLAG_NONE;
 
+        case SHADER_VARIABLE_FLAG_INLINE_CONSTANTS:
+            return PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS;
+
         default:
             UNEXPECTED("Unexpected shader variable flag");
             return PIPELINE_RESOURCE_FLAG_NONE;

Graphics/GraphicsEngine/interface/PipelineState.h

@@ -103,22 +103,30 @@ DILIGENT_TYPED_ENUM(SHADER_VARIABLE_FLAGS, Uint8)
     ///             flag in the internal pipeline resource signature.
     SHADER_VARIABLE_FLAG_NO_DYNAMIC_BUFFERS = 1u << 0,
 
+    /// Indicates that the resource consists of inline constants
+    /// (also known as push constants in Vulkan or root constants in Direct3D12).
+    /// Applies to Diligent::SHADER_RESOURCE_TYPE_CONSTANT_BUFFER only.
+    /// 
+    /// \remarks    This flag directly translates to the Diligent::PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS
+    ///             flag in the internal pipeline resource signature.
+    SHADER_VARIABLE_FLAG_INLINE_CONSTANTS = 1u << 1,
+
     /// Indicates that the resource is an input attachment in general layout, which allows simultaneously
     /// reading from the resource through the input attachment and writing to it via color or depth-stencil
     /// attachment.
     ///
     /// \note This flag is only valid in Vulkan.
-    SHADER_VARIABLE_FLAG_GENERAL_INPUT_ATTACHMENT_VK = 1u << 1,
+    SHADER_VARIABLE_FLAG_GENERAL_INPUT_ATTACHMENT_VK = 1u << 2,
 
     /// Indicates that the resource is an unfilterable-float texture.
     ///
     /// \note This flag is only valid in WebGPU and ignored in other backends.
-    SHADER_VARIABLE_FLAG_UNFILTERABLE_FLOAT_TEXTURE_WEBGPU = 1u << 2,
+    SHADER_VARIABLE_FLAG_UNFILTERABLE_FLOAT_TEXTURE_WEBGPU = 1u << 3,
 
     /// Indicates that the resource is a non-filtering sampler.
     ///
     /// \note This flag is only valid in WebGPU and ignored in other backends.
-    SHADER_VARIABLE_FLAG_NON_FILTERING_SAMPLER_WEBGPU = 1u << 3,
+    SHADER_VARIABLE_FLAG_NON_FILTERING_SAMPLER_WEBGPU = 1u << 4,
 
     /// Special value that indicates the last flag in the enumeration.
     SHADER_VARIABLE_FLAG_LAST = SHADER_VARIABLE_FLAG_NON_FILTERING_SAMPLER_WEBGPU

Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -380,7 +380,26 @@ PipelineResourceSignatureDescWrapper PipelineStateD3D12Impl::GetDefaultResourceS
 
                         const SHADER_RESOURCE_TYPE    ResType  = Attribs.GetShaderResourceType();
                         const PIPELINE_RESOURCE_FLAGS ResFlags = Attribs.GetPipelineResourceFlags() | ShaderVariableFlagsToPipelineResourceFlags(VarDesc.Flags);
-                        SignDesc.AddResource(VarDesc.ShaderStages, Attribs.Name, Attribs.BindCount, ResType, VarDesc.Type, ResFlags);
+
+                        Uint32 ArraySize = Attribs.BindCount;
+                        if (ResFlags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS)
+                        {
+                            VERIFY_EXPR(ResType == SHADER_RESOURCE_TYPE_CONSTANT_BUFFER);
+                            VERIFY(ResFlags == PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS, "INLINE_CONSTANTS flag cannot be combined with other flags.");
+                            if (Attribs.BindCount != 1)
+                            {
+                                LOG_ERROR_AND_THROW("Inline constants resource '", Attribs.Name, "' in shader '", pShader->GetDesc().Name,
+                                                    "' can not be an array.");
+                            }
+                            const Uint32 NumConstants = Attribs.GetConstantBufferSize() / sizeof(Uint32);
+                            if (NumConstants > 64)
+                            {
+                                LOG_ERROR_AND_THROW("Inline constants resource '", Attribs.Name, "' in shader '", pShader->GetDesc().Name,
+                                                    "' has ", NumConstants, " constants. The maximum supported number of inline constants is 64.");
+                            }
+                            ArraySize = NumConstants;
+                        }
+                        SignDesc.AddResource(VarDesc.ShaderStages, Attribs.Name, ArraySize, ResType, VarDesc.Type, ResFlags);
                     }
                     else
                     {

Tests/DiligentCoreAPITest/src/InlineConstantsTest.cpp

@@ -165,6 +165,125 @@ InlineConstants::Resources InlineConstants::sm_Res;
 FastRandFloat              InlineConstants::sm_Rnd{0, 0.f, 1.f};
 
 
+TEST_F(InlineConstants, ResourceLayout)
+{
+    GPUTestingEnvironment* pEnv       = GPUTestingEnvironment::GetInstance();
+    IRenderDevice*         pDevice    = pEnv->GetDevice();
+    IDeviceContext*        pContext   = pEnv->GetDeviceContext();
+    ISwapChain*            pSwapChain = pEnv->GetSwapChain();
+    if (pDevice->GetDeviceInfo().Type != RENDER_DEVICE_TYPE_D3D12)
+    {
+        GTEST_SKIP();
+    }
+
+    for (Uint32 pos_type = 0; pos_type < SHADER_RESOURCE_VARIABLE_TYPE_NUM_TYPES; ++pos_type)
+    {
+        for (Uint32 col_type = 0; col_type < SHADER_RESOURCE_VARIABLE_TYPE_NUM_TYPES; ++col_type)
+        {
+            const float ClearColor[] = {sm_Rnd(), sm_Rnd(), sm_Rnd(), sm_Rnd()};
+            RenderDrawCommandReference(pSwapChain, ClearColor);
+
+            SHADER_RESOURCE_VARIABLE_TYPE PosType = static_cast<SHADER_RESOURCE_VARIABLE_TYPE>(pos_type);
+            SHADER_RESOURCE_VARIABLE_TYPE ColType = static_cast<SHADER_RESOURCE_VARIABLE_TYPE>(col_type);
+
+            GraphicsPipelineStateCreateInfoX PsoCI{"Inline constants test"};
+
+            PipelineResourceLayoutDescX ResLayoutDesc;
+            ResLayoutDesc
+                .AddVariable(SHADER_TYPE_VERTEX, "cbInlinePositions", PosType, SHADER_VARIABLE_FLAG_INLINE_CONSTANTS)
+                .AddVariable(SHADER_TYPE_VERTEX, "cbInlineColors", ColType, SHADER_VARIABLE_FLAG_INLINE_CONSTANTS);
+
+            PsoCI
+                .AddRenderTarget(pSwapChain->GetDesc().ColorBufferFormat)
+                .SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
+                .AddShader(sm_Res.pVS)
+                .AddShader(sm_Res.pPS)
+                .SetResourceLayout(ResLayoutDesc);
+            PsoCI.GraphicsPipeline.DepthStencilDesc.DepthEnable = False;
+
+            RefCntAutoPtr<IPipelineState> pPSO;
+            pDevice->CreateGraphicsPipelineState(PsoCI, &pPSO);
+            ASSERT_TRUE(pPSO);
+
+            if (PosType == SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+            {
+                IShaderResourceVariable* pVar = pPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "cbInlinePositions");
+                ASSERT_TRUE(pVar);
+                pVar->SetInlineConstants(g_Positions, 0, kNumPosConstants);
+            }
+
+            if (ColType == SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+            {
+                IShaderResourceVariable* pVar = pPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "cbInlineColors");
+                ASSERT_TRUE(pVar);
+                pVar->SetInlineConstants(g_Colors, 0, kNumColConstants);
+            }
+
+            RefCntAutoPtr<IShaderResourceBinding> pSRB;
+            pPSO->CreateShaderResourceBinding(&pSRB, true);
+            ASSERT_TRUE(pSRB);
+
+            IShaderResourceVariable* pPosVar = nullptr;
+            if (PosType != SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+            {
+                pPosVar = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "cbInlinePositions");
+                ASSERT_TRUE(pPosVar);
+            }
+
+            IShaderResourceVariable* pColVar = nullptr;
+            if (ColType != SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+            {
+                pColVar = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "cbInlineColors");
+                ASSERT_TRUE(pColVar);
+            }
+
+            ITextureView* pRTVs[] = {pSwapChain->GetCurrentBackBufferRTV()};
+            pContext->SetRenderTargets(1, pRTVs, nullptr, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+            pContext->ClearRenderTarget(pRTVs[0], ClearColor, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+
+
+            if (pColVar != nullptr)
+            {
+                // Set first half of color constants before committing SRB
+                pColVar->SetInlineConstants(g_Colors, 0, kNumColConstants / 2);
+            }
+
+            pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+
+            if (pColVar != nullptr)
+            {
+                // Set second half of color constants after committing SRB
+                pColVar->SetInlineConstants(g_Colors[0].Data() + kNumColConstants / 2, kNumColConstants / 2, kNumColConstants / 2);
+            }
+
+            pContext->SetPipelineState(pPSO);
+
+            if (pPosVar == nullptr)
+            {
+                // Draw both triangles as positions are static
+                pContext->Draw({6, DRAW_FLAG_VERIFY_ALL});
+            }
+            else
+            {
+                // Draw first triangle
+                pPosVar->SetInlineConstants(g_Positions, 0, kNumPosConstants / 2);
+                pContext->Draw({3, DRAW_FLAG_VERIFY_ALL});
+
+                // Draw second triangle
+                pPosVar->SetInlineConstants(g_Positions[0].Data() + kNumPosConstants / 2, 0, kNumPosConstants / 2);
+                pContext->Draw({3, DRAW_FLAG_VERIFY_ALL});
+            }
+
+            Present();
+
+            std::cout << TestingEnvironment::GetCurrentTestStatusString() << ' '
+                      << " Pos " << GetShaderVariableTypeLiteralName(PosType) << ','
+                      << " Col " << GetShaderVariableTypeLiteralName(ColType) << std::endl;
+        }
+    }
+}
+
+
 void InlineConstants::TestSignatures(Uint32 NumSignatures)
 {
     GPUTestingEnvironment* pEnv       = GPUTestingEnvironment::GetInstance();