Add SpecializationConstant declaration to PipelineState.

Author: hzqst

Graphics/GraphicsEngine/interface/PipelineState.h

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -704,6 +704,84 @@ DILIGENT_TYPED_ENUM(PSO_CREATE_FLAGS, Uint32)
 };
 DEFINE_FLAG_ENUM_OPERATORS(PSO_CREATE_FLAGS);
 
+/// Specialization constants allow applications to set constant values
+/// at pipeline creation time, enabling the driver to optimize the compiled
+/// shader code.
+///
+/// \remarks    Specialization constants are supported in Vulkan (via VkSpecializationInfo)
+///             and WebGPU (via pipeline-overridable constants). Other backends
+///             will reject non-empty specialization constants.
+struct SpecializationConstant
+{
+    /// Specialization constant name as defined in the shader source.
+
+    /// In GLSL/SPIR-V, this corresponds to the name decorated with the
+    /// `constant_id` layout qualifier.
+    /// In WGSL, this corresponds to the name of an `override` declaration.
+    ///
+    /// Must not be null.
+    const Char* Name         DEFAULT_INITIALIZER(nullptr);
+
+    /// Shader stages this specialization constant applies to.
+
+    /// Specifies which shader stages use this constant.
+    /// The value must be a valid combination of SHADER_TYPE flags.
+    SHADER_TYPE ShaderStages DEFAULT_INITIALIZER(SHADER_TYPE_UNKNOWN);
+
+    /// Size of the specialization constant data, in bytes.
+
+    /// Must match the size of the constant's type as declared in the shader.
+    Uint32      Size         DEFAULT_INITIALIZER(0);
+
+    /// Pointer to the specialization constant data.
+
+    /// The data is interpreted as raw bytes and must be at least
+    /// `Size` bytes long. Must not be null when Size > 0.
+    const void* pData        DEFAULT_INITIALIZER(nullptr);
+
+#if DILIGENT_CPP_INTERFACE
+    constexpr SpecializationConstant() noexcept {}
+
+    constexpr SpecializationConstant(const Char* _Name,
+                                     SHADER_TYPE _ShaderStages,
+                                     Uint32      _Size,
+                                     const void* _pData) noexcept :
+        Name        {_Name        },
+        ShaderStages{_ShaderStages},
+        Size        {_Size        },
+        pData       {_pData       }
+    {}
+
+    bool operator==(const SpecializationConstant& RHS) const noexcept
+    {
+        if (ShaderStages != RHS.ShaderStages ||
+            Size         != RHS.Size         ||
+            !SafeStrEqual(Name, RHS.Name))
+            return false;
+
+        if (pData != RHS.pData)
+        {
+            if (Size == 0)
+                return true;
+
+            if ((pData == nullptr) != (RHS.pData == nullptr))
+                return false;
+
+            if (pData != nullptr && memcmp(pData, RHS.pData, Size) != 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    bool operator!=(const SpecializationConstant& RHS) const noexcept
+    {
+        return !(*this == RHS);
+    }
+#endif
+};
+typedef struct SpecializationConstant SpecializationConstant;
+
 
 /// Pipeline state creation attributes
 struct PipelineStateCreateInfo
@@ -729,6 +807,22 @@ struct PipelineStateCreateInfo
     /// should be in it default state.
     IPipelineResourceSignature** ppResourceSignatures DEFAULT_INITIALIZER(nullptr);
 
+    /// The number of specialization constants.
+    Uint32 NumSpecializationConstants DEFAULT_INITIALIZER(0);
+
+    /// Pointer to an array of NumSpecializationConstants SpecializationConstant
+    /// elements that define the values of specialization constants for the pipeline.
+
+    /// Specialization constants allow applications to set constant values at pipeline
+    /// creation time, enabling the driver to optimize the compiled shader code.
+    ///
+    /// This feature requires DeviceFeatures.SpecializationConstants to be enabled.
+    /// If the device does not support specialization constants, non-empty arrays
+    /// will be rejected during pipeline creation.
+    ///
+    /// \sa SpecializationConstant
+    const SpecializationConstant* pSpecializationConstants DEFAULT_INITIALIZER(nullptr);
+
     /// Optional pipeline state cache that is used to accelerate
     /// PSO creation. If `PSODesc.Name` is found in the cache, the cache
     /// data is used to create the PSO. Otherwise, the PSO
@@ -751,9 +845,10 @@ struct PipelineStateCreateInfo
 
     bool operator==(const PipelineStateCreateInfo& RHS) const noexcept
     {
-        if (PSODesc                 != RHS.PSODesc ||
-            Flags                   != RHS.Flags   ||
-            ResourceSignaturesCount != RHS.ResourceSignaturesCount)
+        if (PSODesc                      != RHS.PSODesc                      ||
+            Flags                        != RHS.Flags                        ||
+            ResourceSignaturesCount      != RHS.ResourceSignaturesCount      ||
+            NumSpecializationConstants   != RHS.NumSpecializationConstants)
             return false;
 
         if (ppResourceSignatures != RHS.ppResourceSignatures)
@@ -776,6 +871,18 @@ struct PipelineStateCreateInfo
             }
         }
 
+        if (pSpecializationConstants != RHS.pSpecializationConstants)
+        {
+            if ((pSpecializationConstants == nullptr) != (RHS.pSpecializationConstants == nullptr))
+                return false;
+
+            for (Uint32 i = 0; i < NumSpecializationConstants; ++i)
+            {
+                if (pSpecializationConstants[i] != RHS.pSpecializationConstants[i])
+                    return false;
+            }
+        }
+
         // Ignore PSO cache and pInternalData
 
         return true;