Advice for setting up slang shaders in a C# program

[Ollhax]

Hi, I’m trying (perhaps foolishly) to write slang shaders for my C# game running OpenGL. I’m a bit out of my depth here, but scrambling to get up to speed on things. I’m looking for advice on how to set this up with as little pain as possible.

I’ve used slangc to generate my glsl files so far, but from what I can see in the docs it’s not recommended because you can’t get reflection info. I don’t really mind specifying registers manually and this worked well for specifying cbuffers and such, but I hit a snag when it came to textures and samplers.

Using a Texture2D and SamplerState doesn’t seem to work, it generates invalid glsl code. I’m not sure if this is a bug or if it’s just not supported. The only way I’ve managed to get things to work is via Sampler2D objects, but they do not seem to support specifying registers.

I guess I could just create samplers and such and have my code assume they’re listed in a linear order, but I don’t really know how slang assigns the binding indices so it seems safer to get them via reflection.

The next problem is I can’t find any readily available C# bindings, so I tried to set up some interop with slang.dll, but I can’t for the life of me figure out how to get the COM interop to work. I’m still working on it, having some marginal success by skipping all of the built-in C# interop features and just working with manual pointers, but it seems like a less than ideal way of doing it. It’s trivial to use the C bindings, but from what I’ve understood they are being deprecated, but there’s talk about generating the C bindings later, so maybe not after all?

So in summary my questions are:

1. Is using Texture2D+SamplerState when generating glsl shaders supported?
2. Can you specify registers for Sampler2D objects?
3. Is it safe to assume that binding indices will be assigned linearly and deterministically, so that I could avoid using reflection to find them?
4. Are there C# bindings available for the compiler, or any plans for it?
5. Can I assume that C bindings will remain in some shape in the future?

[csyonghe]

@Ollhax Thank you for giving slang a try for your use case. Unfortunately, Slang's GLSL backend isn't intended to generate glsl code for OpenGL, instead it emits Vulkan-flavored GLSL which does allow separated texture-samplers.

It seems that we will need to get explicit binding to work on Sampler2D objects to get you unblocked, which we should be able to do.

There should be existing ways to export COM interfaces to .Net as C# interfaces. I haven't digged into it, but https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms404285(v=vs.100) seems relevant.

[Ollhax]

@Ollhax Thank you for giving slang a try for your use case. Unfortunately, Slang's GLSL backend isn't intended to generate glsl code for OpenGL, instead it emits Vulkan-flavored GLSL which does allow separated texture-samplers.

My pleasure, it's been fun to tinker with! But alright, would you consider it ill-advised to use Slang to generate OpenGL's GLSL? I'd rather not make the switch if there's a lot of trouble down the road. I'm hoping to one day have the time to make a proper Vulkan renderer, but I really shouldn't work on that right now.

There should be existing ways to export COM interfaces to .Net as C# interfaces. I haven't digged into it, but https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms404285(v=vs.100) seems relevant.

Yeah, I tried those among other variants, but could not get any of it to work. I'm not sure if I'm doing it wrong or if the unusual COM setup that's haunting me, but I was much more successful in just setting it up manually. But I'll post in a more C# oriented forum if I continue that route.

[csyonghe]

For explicit binding, I quickly gave it a try, and it seems that the following syntax should work for you:

layout(binding=4)
Sampler2D tex;

Alternatively, the following syntax also works:

[vk::binding(4)]
Sampler2D tex;

[Ollhax]

For explicit binding, I quickly gave it a try, and it seems that the following syntax should work for you:

layout(binding=4)
Sampler2D tex;

Alternatively, the following syntax also works:

[vk::binding(4)]
Sampler2D tex;

Oh, I only tried it with the : register(...) syntax. Thanks!

[Ollhax]

Okay, this is the best way I've managed to cook up:

layout(binding=0)
Sampler2D sampler1;

layout(binding=1)
Sampler2D sampler2;

cbuffer Constants : register(b2)
{
	float Time;
};

cbuffer Camera : register(b3)
{
	float4x4 ModelViewProjection;
};

I need to use layout(binding) for the Sampler2D objects like mentioned, but for cbuffers this does not work and I need to use the register syntax. I understand that I'm mixing GLSL and HLSL here, but it's unfortunate that I can't use the register syntax on Sampler2D's so that it's uniform. Or have some universal Slang way of manually specifying bindings.

[Ollhax]

Oh, nevermind - I got it to work with ConstantBuffers once I disabled a compiler flag (-fvk-b-shift) that I had tinkered with earlier:

layout(binding=0) Sampler2D sampler1;
layout(binding=1) Sampler2D sampler2;

struct Constants
{
	float Time;
};

struct Camera
{
	float4x4 ModelViewProjection;
};

layout(binding=3) ConstantBuffer<Constants> constants;
layout(binding=4) ConstantBuffer<Camera> camera;

[Ollhax]

I don't think I'll continue working on the C# bindings since I can avoid using reflection, but in case anyone is interested I'll just post my experiment here. I think it'd be better to get normal COM interop to work if someone manages it, but perhaps this route could work out well enough using some code generation.

[assembly: DisableRuntimeMarshalling]

using unsafe FindProfileDelegate = delegate* unmanaged[Stdcall]<IntPtr, char*, SlangProfileID>;

internal unsafe class GlobalSession(IntPtr comObject)
{
	private FindProfileDelegate findProfileDelegate = (FindProfileDelegate)Marshal.ReadIntPtr(Marshal.ReadIntPtr(comObject), IntPtr.Size * 4);

	public SlangProfileID FindProfile(string name)
	{
		using var namePtr = new MarshalString(name);
		return findProfileDelegate(comObject, namePtr);
	}
}

internal partial class Library
{
	[LibraryImport("slang.dll")]
	[UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvStdcall) })]
	public static unsafe partial int slang_createGlobalSession(long apiVersion, out IntPtr outGlobalSession);
}

internal unsafe readonly struct MarshalString(string str) : IDisposable
{
	private readonly IntPtr ptr = Marshal.StringToHGlobalAnsi(str);
	public void Dispose() => Marshal.FreeHGlobal(ptr);
	public static implicit operator char*(MarshalString value) => (char*)value.ptr;
}

internal static class SlangLoader
{
	public static void Run()
	{
		Library.slang_createGlobalSession(0, out var sessionPtr);

		GlobalSession globalSession = new GlobalSession(sessionPtr);
		int p = (int)globalSession.FindProfile("glsl_450"); // Returns the correct value		
	}
}

[csyonghe]

As an update, we now provide a simpler reflection interface via the ShaderReflection::toJson() function, which returns a json string for all the binding info on the shader. This is the same json that can be experimented on the Slang Playground.

[Ollhax]

That's excellent! Are there plans to expose that functionality in the command-line tool? From what I can tell right now I don't need reflection data, but it seems like a useful feature.

[csyonghe]

Yes, you can add -reflection-json reflection.json to the end of the slangc command line.