Vulkan push constant support, based on #728

Graphics/Archiver/src/Archiver_Vk.cpp

@@ -128,9 +128,10 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf
     {
         ShaderStageInfoVk&                    Src{ShaderStages[i]};
         PipelineStateVkImpl::ShaderStageInfo& Dst{ShaderStagesVk[i]};
-        Dst.Type    = Src.Type;
-        Dst.Shaders = std::move(Src.Shaders);
-        Dst.SPIRVs  = std::move(Src.SPIRVs);
+        Dst.Type            = Src.Type;
+        Dst.Shaders         = std::move(Src.Shaders);
+        Dst.SPIRVs          = std::move(Src.SPIRVs);
+        Dst.ShaderResources = std::move(Src.ShaderResources);
     }
 
     IPipelineResourceSignature** ppSignatures    = CreateInfo.ppResourceSignatures;

Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp

@@ -1637,13 +1637,17 @@ String GetPipelineResourceFlagsString(PIPELINE_RESOURCE_FLAGS Flags, bool GetFul
 
         PIPELINE_RESOURCE_FLAGS Flag = ExtractLSB(Flags);
 
-        static_assert(PIPELINE_RESOURCE_FLAG_LAST == (1u << 4), "Please update the switch below to handle the new pipeline resource flag.");
+        static_assert(PIPELINE_RESOURCE_FLAG_LAST == (1u << 5), "Please update the switch below to handle the new pipeline resource flag.");
         switch (Flag)
         {
             case PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS:
                 Str.append(GetFullName ? "PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS" : "NO_DYNAMIC_BUFFERS");
                 break;
 
+            case PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS:
+                Str.append(GetFullName ? "PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS" : "INLINE_CONSTANTS");
+                break;
+
             case PIPELINE_RESOURCE_FLAG_COMBINED_SAMPLER:
                 Str.append(GetFullName ? "PIPELINE_RESOURCE_FLAG_COMBINED_SAMPLER" : "COMBINED_SAMPLER");
                 break;
@@ -1808,7 +1812,7 @@ PIPELINE_RESOURCE_FLAGS GetValidPipelineResourceFlags(SHADER_RESOURCE_TYPE Resou
     switch (ResourceType)
     {
         case SHADER_RESOURCE_TYPE_CONSTANT_BUFFER:
-            return PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS | PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY;
+            return PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS | PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY | PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS;
 
         case SHADER_RESOURCE_TYPE_TEXTURE_SRV:
             return PIPELINE_RESOURCE_FLAG_COMBINED_SAMPLER | PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY;
@@ -1839,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:
@@ -1848,6 +1852,9 @@ PIPELINE_RESOURCE_FLAGS ShaderVariableFlagsToPipelineResourceFlags(SHADER_VARIAB
         case SHADER_VARIABLE_FLAG_NO_DYNAMIC_BUFFERS:
             return PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS;
 
+        case SHADER_VARIABLE_FLAG_INLINE_CONSTANTS:
+            return PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS;
+
         case SHADER_VARIABLE_FLAG_GENERAL_INPUT_ATTACHMENT_VK:
             return PIPELINE_RESOURCE_FLAG_GENERAL_INPUT_ATTACHMENT;
 

Graphics/GraphicsEngine/include/DeviceContextBase.hpp

@@ -381,6 +381,9 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
         // buffers with dynamic offsets in all backends).
         SRBMaskType DynamicSRBMask = 0;
 
+        // Indicates which SRBs contain inline constants
+        SRBMaskType InlineConstantsSRBMask = 0;
+
         void Set(Uint32 Index, ShaderResourceBindingImplType* pSRB)
         {
             VERIFY_EXPR(Index < MAX_RESOURCE_SIGNATURES);
@@ -398,6 +401,11 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
             else
                 DynamicSRBMask &= ~SRBBit;
 
+            if (pResourceCache != nullptr && pResourceCache->HasInlineConstants())
+                InlineConstantsSRBMask |= SRBBit;
+            else
+                InlineConstantsSRBMask &= ~SRBBit;
+
 #ifdef DILIGENT_DEVELOPMENT
             SRBs[Index] = pSRB;
             if (pSRB != nullptr)
@@ -412,18 +420,26 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
         }
 
         // Returns the mask of SRBs whose resources need to be committed
-        SRBMaskType GetCommitMask(bool DynamicResourcesIntact = false) const
+        SRBMaskType GetCommitMask(bool DynamicResourcesIntact = false,
+                                  bool InlineConstantsIntact  = false) const
         {
 #ifdef DILIGENT_DEVELOPMENT
             DvpVerifyCacheRevisions();
 #endif
 
             // Stale SRBs always have to be committed
             SRBMaskType CommitMask = StaleSRBMask;
+
             // If dynamic resources are not intact, SRBs with dynamic resources
             // have to be handled
             if (!DynamicResourcesIntact)
                 CommitMask |= DynamicSRBMask;
+
+            // If inline constants are not intact, SRBs with inline constants
+            // have to be handled
+            if (!InlineConstantsIntact)
+                CommitMask |= InlineConstantsSRBMask;
+
             // Only process SRBs that are used by current PSO
             CommitMask &= ActiveSRBMask;
             return CommitMask;

Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp

@@ -231,6 +231,20 @@ bool VerifyConstantBufferBinding(const PipelineResourceDesc& ResDesc,
                                  Uint64                      CachedRangeSize,
                                  const char*                 SignatureName)
 {
+    if ((ResDesc.Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS) != 0)
+    {
+        std::stringstream ss;
+        ss << "Error binding buffer to variable '" << GetShaderResourcePrintName(ResDesc, BindInfo.ArrayIndex) << '\'';
+        if (SignatureName != nullptr)
+        {
+            ss << " defined by signature '" << SignatureName << '\'';
+        }
+        ss << ". The variable is marked as inline constants and cannot be bound to a buffer. "
+              "Use IShaderResourceVariable::SetInlineConstants() method to set the inline constant values.";
+        RESOURCE_VALIDATION_FAILURE(ss.str());
+        return false;
+    }
+
     bool BindingOK = VerifyResourceBinding("buffer", ResDesc, BindInfo, pBufferImpl, pCachedBuffer, SignatureName);
 
     if (pBufferImpl != nullptr)
@@ -540,6 +554,12 @@ bool VerifyDynamicBufferOffset(const PipelineResourceDesc& ResDesc,
 {
     bool BindingOK = true;
 
+    if ((ResDesc.Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS) != 0)
+    {
+        RESOURCE_VALIDATION_FAILURE("Error setting dynamic buffer offset for variable '", ResDesc.Name, "': inline constants do not support dynamic offsets.");
+        BindingOK = false;
+    }
+
     if ((ResDesc.Flags & PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS) != 0)
     {
         RESOURCE_VALIDATION_FAILURE("Error setting dynamic buffer offset for variable '", ResDesc.Name, "': the variable was created with PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS flag.");
@@ -602,6 +622,34 @@ bool VerifyDynamicBufferOffset(const PipelineResourceDesc& ResDesc,
 }
 
 
+inline bool VerifyInlineConstants(const PipelineResourceDesc& ResDesc,
+                                  const void*                 pConstants,
+                                  Uint32                      FirstConstant,
+                                  Uint32                      NumConstants)
+{
+    bool ParamsOK = true;
+    if (ResDesc.ResourceType != SHADER_RESOURCE_TYPE_CONSTANT_BUFFER)
+    {
+        RESOURCE_VALIDATION_FAILURE("SetInlineConstants() is only allowed for constant buffer resources.");
+        ParamsOK = false;
+    }
+
+    if (pConstants == nullptr)
+    {
+        RESOURCE_VALIDATION_FAILURE("Pointer to inline constants is null.");
+        ParamsOK = false;
+    }
+
+    if (FirstConstant + NumConstants > ResDesc.ArraySize)
+    {
+        RESOURCE_VALIDATION_FAILURE("Inline constant range (", FirstConstant, " .. ", FirstConstant + NumConstants - 1,
+                                    ") is out of bounds for variable '", ResDesc.Name, "' of size ", ResDesc.ArraySize, " constants.");
+        ParamsOK = false;
+    }
+
+    return ParamsOK;
+}
+
 #undef RESOURCE_VALIDATION_FAILURE
 
 template <typename ShaderVectorType>
@@ -713,6 +761,27 @@ struct ShaderVariableBase : public ResourceVariableBaseInterface
     }
 
 
+    virtual void DILIGENT_CALL_TYPE SetInlineConstants(const void* pConstants,
+                                                       Uint32      FirstConstant,
+                                                       Uint32      NumConstants) override final
+    {
+#ifdef DILIGENT_DEVELOPMENT
+        {
+            const PipelineResourceDesc& Desc = GetDesc();
+            DEV_CHECK_ERR(Desc.ResourceType == SHADER_RESOURCE_TYPE_CONSTANT_BUFFER,
+                          "SetInlineConstants() is only allowed for constant buffer resources.");
+            DEV_CHECK_ERR(Desc.Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS,
+                          "SetInlineConstants() is only allowed for inline constant buffers.");
+            DEV_CHECK_ERR(pConstants != nullptr, "Pointer to inline constants is null.");
+            DEV_CHECK_ERR(FirstConstant + NumConstants <= Desc.ArraySize,
+                          "Inline constant range (", FirstConstant, " .. ", FirstConstant + NumConstants - 1,
+                          ") is out of bounds for variable '", Desc.Name, "' of size ", Desc.ArraySize, " constants.");
+        }
+#endif
+
+        static_cast<ThisImplType*>(this)->SetConstants(pConstants, FirstConstant, NumConstants);
+    }
+
     virtual SHADER_RESOURCE_VARIABLE_TYPE DILIGENT_CALL_TYPE GetType() const override final
     {
         return GetDesc().VarType;

Graphics/GraphicsEngine/interface/DeviceContext.h

@@ -213,7 +213,27 @@ DILIGENT_TYPED_ENUM(DRAW_FLAGS, Uint8)
     ///  (see RootSignature::CommitRootViews). When `DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT` is set, root views are only bound
     ///  by the first draw command that uses the PSO + SRB pair. The flag avoids setting the same GPU virtual addresses when
     ///  they stay unchanged.
-    DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT = 1u << 2u
+    ///
+    ///  \see DRAW_FLAG_INLINE_CONSTANTS_INTACT, DRAW_FLAG_DYNAMIC_BUFFERS_AND_INLINE_CONSTANTS_INTACT
+    DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT = 1u << 2u,
+
+    /// Indicates that none of the inline constants used by the draw command
+    /// have been modified by the CPU since the last command.
+    ///
+    /// This flag should be used to improve performance when an application issues a
+    /// series of draw commands that use the same pipeline state and shader resources and
+    /// no inline constants are updated between the commands.
+    ///
+    /// \see DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT, DRAW_FLAG_DYNAMIC_BUFFERS_AND_INLINE_CONSTANTS_INTACT
+    DRAW_FLAG_INLINE_CONSTANTS_INTACT = 1u << 3u,
+
+    /// Indicates that neither the dynamic resource buffers nor the inline constants used by
+    /// the draw command have been modified by the CPU since the previous command.
+    ///
+    /// \see DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT, DRAW_FLAG_INLINE_CONSTANTS_INTACT
+    DRAW_FLAG_DYNAMIC_BUFFERS_AND_INLINE_CONSTANTS_INTACT = 
+        DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT | 
+        DRAW_FLAG_INLINE_CONSTANTS_INTACT
 };
 DEFINE_FLAG_ENUM_OPERATORS(DRAW_FLAGS)
 

Graphics/GraphicsEngine/interface/PipelineResourceSignature.h

@@ -105,9 +105,28 @@ DILIGENT_TYPED_ENUM(PIPELINE_RESOURCE_FLAGS, Uint8)
     /// PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS flag.
     PIPELINE_RESOURCE_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 SHADER_RESOURCE_TYPE_CONSTANT_BUFFER only.
+    ///
+    /// Use this flag if you have a buffer of frequently changing constants
+    /// - that are small in size (typically up to 128 bytes) and
+    /// - change often (e.g. per-draw or per-dispatch).
+    ///
+    /// Inline constants are set directly using IShaderResourceVariable::SetInlineConstants.
+    ///
+    /// This flag cannot be combined with any other flags.
+    ///
+    /// In Vulkan and Direct3D12, inline constants are not bound via descriptor sets or root
+    /// signatures, but are set directly in command buffers or command lists and are very cheap.
+    /// In legacy APIs (Direct3D11 and OpenGL), inline constants are emulated using regular
+    /// constant buffers and thus have higher overhead.
+    PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS = 1u << 1,
+
     /// Indicates that a texture SRV will be combined with a sampler.
     /// Applies to SHADER_RESOURCE_TYPE_TEXTURE_SRV resources.
-    PIPELINE_RESOURCE_FLAG_COMBINED_SAMPLER   = 1u << 1,
+    PIPELINE_RESOURCE_FLAG_COMBINED_SAMPLER   = 1u << 2,
 
     /// Indicates that this variable will be used to bind formatted buffers.
     /// Applies to SHADER_RESOURCE_TYPE_BUFFER_UAV and SHADER_RESOURCE_TYPE_BUFFER_SRV
@@ -117,19 +136,19 @@ DILIGENT_TYPED_ENUM(PIPELINE_RESOURCE_FLAGS, Uint8)
     /// as opposed to structured buffers. If an application will be using
     /// formatted buffers with buffer UAVs and SRVs, it must specify the
     /// PIPELINE_RESOURCE_FLAG_FORMATTED_BUFFER flag.
-    PIPELINE_RESOURCE_FLAG_FORMATTED_BUFFER   = 1u << 2,
+    PIPELINE_RESOURCE_FLAG_FORMATTED_BUFFER   = 1u << 3,
 
     /// Indicates that resource is a run-time sized shader array (e.g. an array without a specific size).
-    PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY      = 1u << 3,
+    PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY      = 1u << 4,
 
     /// 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.
-    PIPELINE_RESOURCE_FLAG_GENERAL_INPUT_ATTACHMENT = 1u << 4,
+    PIPELINE_RESOURCE_FLAG_GENERAL_INPUT_ATTACHMENT = 1u << 5,
 
-    PIPELINE_RESOURCE_FLAG_LAST               = PIPELINE_RESOURCE_FLAG_GENERAL_INPUT_ATTACHMENT
+    PIPELINE_RESOURCE_FLAG_LAST = PIPELINE_RESOURCE_FLAG_GENERAL_INPUT_ATTACHMENT
 };
 DEFINE_FLAG_ENUM_OPERATORS(PIPELINE_RESOURCE_FLAGS);
 
@@ -269,6 +288,9 @@ struct PipelineResourceDesc
     SHADER_TYPE                    ShaderStages  DEFAULT_INITIALIZER(SHADER_TYPE_UNKNOWN);
 
     /// Resource array size (must be 1 for non-array resources).
+    ///
+    /// For inline constants (see PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS),
+    /// this member specifies the number of 4-byte values.
     Uint32                         ArraySize     DEFAULT_INITIALIZER(1);
 
     /// Resource type, see Diligent::SHADER_RESOURCE_TYPE.
@@ -334,6 +356,13 @@ struct PipelineResourceDesc
     {
         return !(*this == Rhs);
     }
+
+    Uint32 GetArraySize() const noexcept
+    {
+        return (Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS) != 0 ?
+                1 : // For inline constants, ArraySize is the number of 4-byte constants.
+                ArraySize;
+    }
 #endif
 };
 typedef struct PipelineResourceDesc PipelineResourceDesc;

Graphics/GraphicsEngine/interface/PipelineState.h

@@ -103,22 +103,32 @@ 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.
+    /// 
+    /// See Diligent::PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS for more details.
+    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