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]

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 ?

[jkwak-work]

I think I misread what you said as "I need to read this parameter to generate".
I thought that you were trying to read the value set to the shader parameter before compiling the shader.

But if you are injecting the values like how you showed us, I must have misunderstood it.

generated_module += std::format("export static const bool {} = {};", sw.first, sw.second ? "true" : "false");

Going back to the initial question with your CPP side code, I am not sure what the problem is for you.
Is the problem that you cannot populate the variable, static_switches?
Are you trying to populate an array of static_switches with the Slang Reflection API?

[PierreEVEN]

Yup that's exactly the problem. I don't want to know the value, but only the name (with eventually, if possible the default value).
On the cpp side, I have no information about what are the "static const bool" parameter names my shader uses. (which will populate my static_switches parameter map)

The goal of using reflection in this case is to get the list of available parameters, and - if possible - their default value, so that I can override the default value by the one desired by the user. (the injection process works as expected. All that's missing is a way of knowing what parameters are available (name + default value), and - consequently - what should be injected)

More precisely, for better context : a shader is wrapped in a material asset that will hold multiple permutations. Theses permutations (one permutation per combination of static switches values) will be generated on demand. (The user can configure a different set of features in each "MaterialInstance" asset, for example)
For example if I need to draw a mesh with :

• only normal
• no normal but mrao map
• only roughness map,

and so one...; instead of writing one different shader each time, I just have to perform the completion step again, but with different default values for those switches.
Ideally, it would be nice if all I had to do from the user perspective, was declare a static const property in the shader.

The main problem is that I haven't figured out how to find reflection information about these parameters. (it doesn't appears at all in reflection data) => A simple example in Slang Playground

Hope it's clearer :)

[jkwak-work]

I think you came up with a nice trick to generate the shader permutation.
Unfortunately I don't think you can get the names of those variables because they are not "shader parameters" that can be bound at runtime.

I like to suggest you to file an issue with a smallest repro code as examples; probably you can just copy and paste from this discussion.
Then, we will be able to schedule for the work with respect to the priorities for other milestone goals.

I also like to encourage you to implement it for us and push to the repo. It will be highly appreciated by the team.

[PierreEVEN]

I don't know how other people would have implemented "automatic" shaders permutations, but yeah I think it's a pretty clean approach 🤔
I think I'll try to implement that in slang soon👍 I've never dug into this kind of project but it could be interesting :)

Thanks for the answer !

[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.