Get link-time constants using the reflection API

[PierreEVEN]

Hi,
I'm currently replacing my old shader builder which used custom #pragma directives to declare static switches as shader permutations.

I was wondering if it was possible to get a similar behavior using link-time constants, but currently I haven't found a way to retrieve it using reflection and the documentation doesn't mention it, so maybe this feature doesn't exists yet ?

Also if you see a better way of handling my use case that would be great too.
Thanks ! :)

[jkwak-work]

Can you give us examples with shader code?
And I am not ware of any pragma that generates shader permutations. Can you tell us more about the pragma too?

[PierreEVEN]

Hi
This is not a language feature. I manually parse the shader file to get additional information (like pipeline settings...) :

// declare a static parameter with true as default value. This will add an option in the editor to enable or disable this feature
#pragma option WITH_NORMAL_MAP = true 

// Other use cases
#pragma pass gbuffers = main_frag_1, main_vert, main_fragment_2
#pragma depth_test = true // additional options...

float4 main_fragment_2() {
    #if WITH_NORMAL_MAP // value defined in compiler options
          normal = normal_map.Sample(...);
    #else
          normal = float3(0, 0, 1);
    #endif
} 

I've manager to translate these features using native slang syntax, except for the static switches (#pragma option WITH_NORMAL_MAP = true in my example)

In slang my example would looks like this :

// I need to read this parameter to generate a module before linking that overrides the default value
// everything works fine except I haven't found were this parameter might be available in the module reflection data.
extern static const bool WITH_NORMAL_MAP = false;

[shader("fragment")]
[RenderPass("gbuffers")]
[OptionDepthTest(true)]
float4 main_fragment_2() {
    if (WITH_NORMAL_MAP)
          normal = normal_map.Sample(...);
    else
          normal = float3(0, 0, 1);
} 

[jkwak-work]

I am still not sure about the following line,

#pragma option WITH_NORMAL_MAP = true 

This doesn't seem to be a valid line for DXC or any other shader compilers.
I am gonna assume that this is processed by your custom tool that is mentioned as "editor".

For the Slang shader you gave use, the link-time constant shouldn't have a value when it is declared with extern.
The value should be set in another module or different file with export keyword; note that it is not extern.

You probably have seen the code example on Slang User's Guide.
As you can see in the example, the completion API is supposed to set the value.

It sounds like you are trying to access a link-time constant with the reflection API in order to perform the shader permutation in your tool.
But I don't think Slang supports a workflow like that.
Because it sounds like you are trying to use the reflection API before the compilation begin.

There is a distension between the completion API and the reflection API.
My understanding is that you cannot use the reflection API until the completion is complete.
And the link-time constant value must be decided in order to compile.
I don't think you can access the link-time constant from the reflection API as you asked.

[PierreEVEN]

Yeah you guessed right, sorry for not detailing it.
I created a custom tool that gives me additional reflection information, which removes this line once parsed.
This tool will populate a map<string, bool> static_switches; which can be changed from the editor.

I declared WITH_NORMAL_MAP as 'extern' with a default value on purpose, because I want to be able to override it optionnaly from a generated module :

std::vector<slang::IComponentType*> components;
if (!static_switches.keys().empty())
{
    std::string generated_module;
    for (const auto& sw: static_switches)
        generated_module += std::format("export static const bool {} = {};", sw.first, sw.second ? "true" : "false");

    auto permutation_values_src = UnownedRawBlob::create(generated_module.c_str(), generated_module.size());
    components.emplace_back(session->loadModuleFromSource("permutation-values", "permutation-values.slang", permutation_values_src));
}
components.emplace_back(entry_point);
Slang::ComPtr<slang::IComponentType> program;
session->createCompositeComponentType(components.data(), components.size(), program.writeRef());

// then link + getEntryPointCode

I'm not sure what you call "Completion Api", I assume it's related to createCompositeComponentType() and what I am doing in the previous block ?

As @cheneym2 confirmed, setting a default value for a link-time constant should be valid in my case if the documentation is correct :
https://shader-slang.com/slang/user-guide/link-time-specialization.html#providing-default-settings.

If I read in the documentation of IComponentType::getLayout() :

    If this component type has specialization parameters (that is,
    it is not fully specialized), then the resulting layout may
    be incomplete, and plugging in arguments for generic specialization
    parameters may result in a component type that doesn't have
    a compatible layout. If the component type only uses
    interface-type specialization parameters, then the layout
    for a specialization should be compatible with an unspecialized
    layout (all parameters in the unspecialized layout will have
    the same offset/binding in the specialized layout).

it implies that I could use reflection before completion, except that there might be some change in offset/bindings which should not be a problem in my case.
I can also retrieve other resources before completion so I think the possibility of getting link-time constants at this point should not be absurd I suppose ?

[cheneym2]

@tangent-vector Do you have an answer for the immediate question about discovering "WITH_NORMAL_MAP" in reflection so a module can be generated with an override for that constant defined?

[cheneym2]

For the Slang shader you gave use, the link-time constant shouldn't have a value when it is declared with extern.
The value should be set in another module or different file with export keyword; note that it is not extern.
https://shader-slang.com/slang/user-guide/link-time-specialization.html#link-time-constants mentions that a default value can be assigned to externs, and overridden.