Hey there,

i am currently trying to integrate Dynamic Shader Linkage into my ShaderReflection Code. I examined the Win32 Sample Microsoft provided, where they are declaring a cbuffer like this:

cbuffer cbPerFrame : register( b0 )
{
   cAmbientLight     g_ambientLight;
   cHemiAmbientLight g_hemiAmbientLight;
   cDirectionalLight g_directionalLight;
   cEnvironmentLight g_environmentLight;
   float4            g_vEyeDir;   
};

interface iBaseLight
{
   float3 IlluminateAmbient(float3 vNormal);
   
   float3 IlluminateDiffuse(float3 vNormal);


   float3 IlluminateSpecular(float3 vNormal, int specularPower );
   
};


//--------------------------------------------------------------------------------------
// Classes
//--------------------------------------------------------------------------------------
class cAmbientLight : iBaseLight
{
   float3 m_vLightColor;     
   bool     m_bEnable;
   
   float3 IlluminateAmbient(float3 vNormal);
      
   float3 IlluminateDiffuse(float3 vNormal)
   { 
      return (float3)0;
   }


   float3 IlluminateSpecular(float3 vNormal, int specularPower )
   { 
      return (float3)0;
   }
};

Yes the constant buffer stays the same, regardless of which class implementation i am using at runtime. (Was this what you were asking?)

The abstract interface is used like this:

iBaseLight     g_abstractAmbientLighting;


struct PixelInput
{
float4 position : SV_POSITION;
float3 normals : NORMAL;
float2 tex: TEXCOORD0;
};


float4 main(PixelInput input) : SV_TARGET
{
float3 Ambient = (float3)0.0f;
Ambient = g_txDiffuse.Sample(g_samplerLin, input.tex) * g_abstractAmbientLighting.IlluminateAmbient(input.normals);


return float4(saturate(Ambient), 1.0f);
}

 g_pPSClassLinkage->GetClassInstance( varDesc.Name, 0, &g_pAmbientLightClass );

Well i found something which might help. If i use the GetInterfaceByIndex on the Shader Reflection type i get the expected class "D3D_SVC_INTERFACE_CLASS" which i suspect would be different or non-existent on a normal struct.

EDIT: The only thing now left for me is to find out if it is possible to get the name from here through shader reflection. Any Ideas?:

iBaseLight     g_abstractAmbientLighting;
               ^^^^^^^^^^^^^^^^^^^^^^^^

struct PixelInput
{
float4 position : SV_POSITION;
float3 normals : NORMAL;
float2 tex: TEXCOORD0;
};

Thanks for your answer ;).

Congratulations on being the first person that I've met who's actually trying to use dynamic shader linkage

Why is that? Is it to cumbersome, or bad performance wise? I find it a quite interesting idea, especially because it gives you the possibility to create new class instances in run time.

It *might* show up if you get the reflection interface for the default constant buffer, but I'd have to test to find out

How do i get the reflection interface for the default constant buffer? I already checked most of the reflection interfaces, including the constant buffers (with GetConstantBufferByIndex()) and bound resources (with GetResourceBindingDesc()). Sadly it does not show up on either of those.

Getting the global interface name by index would be nice, because then one would not have to change the code manually if something changes inside the shader code and it would be easy to "calculate" the offset into the dynamic linkage array.

How do i get the reflection interface for the default constant buffer?

If you compile your shader with FXC, and then check the output listing for the name of the buffer you should be able to use that name to reflect the constant buffer. Regarding the performance, I think there is a penalty for using the dynamic linkage (although I've never heard hard numbers on this before). Most of the systems I have heard of just generate the appropriate shader code and compile the needed variants accordingly.

Is that something that isn't a usable solution for you?

I also heard about this solution, but could not find any samples or good explanation of whats the best way to go with this kind of system. Do you have any of those at hand?

As i found out about the Dynamic Shader Linkage i was not expecting it being used so rarely, but the explanation from MJP now makes it quite clear why this might be the case.

So: Does anyone have a good article or something about how one would usually go about this kind of system?

Thank you for all your input!