Specialization Constants support?

[hzqst]

Would be useful when we have something like a uber shader with more than 1000 variants.

Vulkan: Specialization Constants

• https://docs.vulkan.org/samples/latest/samples/performance/specialization_constants/README.html

WebGPU: pipeline-overridable constants

• https://webgpufundamentals.org/webgpu/lessons/webgpu-constants.html

D3D12: No such thing, maybe ShaderModel 7

• [Feature Request] DXIL Specialization Constant Support microsoft/hlsl-specs#71

D3D11: No such thing

OpenGL: No such thing

[TheMostDiligent]

It looks like this is not too difficult to add. Only this will essentially be a Vulkan-exclusive feature (which may not be too bad).
The main question is if specialization constants can be defined in HLSL. If it is GLSL-only, then on top of being Vulkan-exclusive, this will also be GLSL-only feature.
For WebGPU, also the main question whether shader translation can handle initialization constants and convert them to WGSL

[hzqst]

Slang:

SPIRV :

GLSL for Vulkan Counterpart:

WGSL Counterpart:

HLSL Counterpart:
[[vk::constant_id(0)]] . however this does nothing when emitting DXBC/DXIL.

Vulkan example:

https://github.com/SaschaWillems/Vulkan/blob/master/examples/specializationconstants/specializationconstants.cpp

[hzqst]

Tested with https://shader-playground.timjones.io/

; SPIR-V
; Version: 1.0
; Generator: Khronos Glslang Reference Front End; 11
; Bound: 25
; Schema: 0
               OpCapability Shader
          %1 = OpExtInstImport "GLSL.std.450"
               OpMemoryModel Logical GLSL450
               OpEntryPoint Fragment %main "main" %fragColor
               OpExecutionMode %main OriginUpperLeft
               OpSource GLSL 460
               OpName %main "main"
               OpName %GammaCorrectionEnabled "GammaCorrectionEnabled"
               OpName %fragColor "fragColor"
               OpDecorate %GammaCorrectionEnabled SpecId 0
               OpDecorate %fragColor Location 0
       %void = OpTypeVoid
          %3 = OpTypeFunction %void
        %int = OpTypeInt 32 1
%GammaCorrectionEnabled = OpSpecConstant %int 1
      %int_1 = OpConstant %int 1
       %bool = OpTypeBool
         %10 = OpSpecConstantOp %bool IEqual %GammaCorrectionEnabled %int_1
      %float = OpTypeFloat 32
    %v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
  %fragColor = OpVariable %_ptr_Output_v4float Output
%float_0_899999976 = OpConstant %float 0.899999976
%float_0_300000012 = OpConstant %float 0.300000012
    %float_1 = OpConstant %float 1
         %20 = OpConstantComposite %v4float %float_0_899999976 %float_0_899999976 %float_0_300000012 %float_1
%float_0_400000006 = OpConstant %float 0.400000006
%float_0_800000012 = OpConstant %float 0.800000012
         %24 = OpConstantComposite %v4float %float_0_400000006 %float_0_400000006 %float_0_800000012 %float_1
       %main = OpFunction %void None %3
          %5 = OpLabel
               OpSelectionMerge %12 None
               OpBranchConditional %10 %11 %21
         %11 = OpLabel
               OpStore %fragColor %20
               OpBranch %12
         %21 = OpLabel
               OpStore %fragColor %24
               OpBranch %12
         %12 = OpLabel
               OpReturn
               OpFunctionEnd

Compiler: tint, updated from trunk on 2024-03-02
Output format: WGSL

error: unhandled expression for ID 10
%10 = OpSpecConstantOp %13 IEqual %6 %9

Probably gonna try newer version of tint.

[TheMostDiligent]

Looks like glslang supports vk::constant_id:

[TheMostDiligent]

My current thinking about the API:

/// Specialization constant description
struct SpecializationConstant
{
    /// Name of the constant in the shader
    const char* Name = nullptr;

    /// Shader stages where the constant is used
    SHADER_TYPE ShaderStages = SHADER_TYPE_ALL;

    /// Data size in bytes
    Uint32 Size = 0;

    /// Pointer to the constant data
    const void* pData = nullptr;
};

struct PipelineStateCreateInfo
{
    /// ...
    
    /// Pointer to an array of `NumSpecializationConstants` specialization constants
    const SpecializationConstant* pSpecializationConstants = nullptr;

    /// Number of specialization constants in the `pSpecializationConstants` array
    Uint32 NumSpecializationConstants = 0;
};

Specialization constant information will be added to SPIRVShaderResources, then during the PSO creation the constant data will be matched to constants in the shader stages.

[TheMostDiligent]

Also, add SpecializationConstants feature to DeviceFeatures