way to instantiate in vertex shader compiled in spirv from slang.

[Mikael256]

Hello, I thought about switching to slang for the language capabilities and got some issues converting my shaders in wgsl to slang at runtime.
In wgsl I instanciated my instance buffer using a second argument of my vertex shader entrypoint and got a

The type [6] cannot be used for user-defined entry point inputs or outputs

and if I try to get the SV_InstanceID in the input of my function I got a

unsupported capability DrawParameters

I cannot find anything related to DrawParameters in the features to activate ( or is it named differently ? )
Is using slang as shader language a bad idea as all spirv features are not implemented yet or is there solutions I'm not aware of ?

Thanks in advance for the possible help.

[cwfitzgerald]

We need to mark DrawParameters as allowed - we do support BaseInstance and BaseVertex, just not DrawId. We should allow this and just error on only DrawID.

[Mikael256]

ok thanks, is it a flag in the code that I can hack waiting for a patch?
And the solution with two parameters as in wgsl won't ever be possible?

[cwfitzgerald]

Btw is my solution to switch to slang a good idea?
I mean if the spirv implementation is not at the state of wgsl one it could possibly more an hassle than solution.

The spirv implementation should be basically same level, the problems arise when slang generates slightly different code than glslang does, which causes us to balk. These are generally bugs in slang but sometimes are issues with us.

[Mikael256]

struct VertexInput {
	float3 position;
	float3 normal;
	float3 border_normal;
	float3 material_index;
}

struct InstanceInput {
	matrix model_matrix;
}

struct VertexOutput {
	float4 clip_position: SV_Position;
	float3 normal;
	float3 light;
	float4 color_base;
	float4 color_base_light;
	float4 color_light;
	float3 shadow_position;
}

// vert
[[vk::binding(0, 0)]]
StructuredBuffer<InstanceInput> instances;
[[vk::binding(0, 1)]]
ConstantBuffer < Camera > camera;
[[vk::binding(0, 3)]]
ConstantBuffer < Camera > shadow_camera;
[[vk::binding(1, 3)]]
ConstantBuffer < float3 > light_vector;
[[vk::binding(0, 4)]]
ConstantBuffer < float3[16]> color_list;


// frag
[ [vk::binding(0, 2)] ] ConstantBuffer < Texture2D > shadow_texture;
[ [vk::binding(1, 2)] ] ConstantBuffer < SamplerComparisonState > shadow_sampler;
[ [vk::binding(2, 3)] ] ConstantBuffer < float2 > texture_size;

[shader("vertex")]
VertexOutput vs_main (
	VertexInput model,
	InstanceInput instance,
){
	VertexOutput out;
	out.clip_position = mul(float4(model.position, 1.0), camera.view_proj * instance.model_matrix );
	let pos_from_light = mul(float4(model.position, 1.0), shadow_camera.view_proj * instance.model_matrix );
	let centered = pos_from_light.xy * float2(0.5, -0.5) + float2(0.5, 0.5);
	out.shadow_position = float3(centered, pos_from_light.z);
	let model_matrix3 = float3x3(instance.model_matrix[0].xyz, instance.model_matrix[1].xyz, instance.model_matrix[2].xyz);
	out.normal = model.normal;
	let material_index_base = uint32_t(model.material_index[0] * 4.0);
	let material_index_base_light = uint32_t(float(material_index_base) + 1.0);
	let material_index_light = uint32_t(float(material_index_base) + 2.0);

	let color_base = color_list[material_index_base];
	let color_base_light = color_list[material_index_base_light];
	let color_light = color_list[material_index_light];

	out.color_base = float4(color_base, 1.0);
	out.color_base_light = float4(color_base_light, 1.0);
	out.color_light = float4(color_light, 1.0);

	out.light = normalize(mul( model_matrix3, light_vector.xyz ));
	return out;
}


float range(float val, float min,float max){
	let clamped = clamp(val, min, max);
	let size = max - min;

	return (clamped - min) / size;
}


float get_bilinear(float3 shadow_position){
	let shadow_pixel_width = 1.0 / texture_size.x;
	let shadow_pixel_height = 1.0 / texture_size.y;


	let shadow_pixel_position = shadow_position.xy * texture_size;
	let shadow_pixel_base_position = abs(shadow_pixel_position);
	let shadow_pixel_position_ratios = shadow_pixel_position % 1.0;

	// AB
	// CD
	let shadow_a = shadow_pixel_base_position / texture_size;
	let shadow_b = shadow_a + float2(shadow_pixel_width, 0.0);
	let shadow_c = shadow_a + float2(0.0, shadow_pixel_height);
	let shadow_d = shadow_b + float2(0.0, shadow_pixel_height);

	let offsetted_depth = shadow_position.z - max(shadow_pixel_width, shadow_pixel_height);

	let out_shadow_level_a = shadow_texture.SampleCmp( shadow_sampler, shadow_a, offsetted_depth);
	let out_shadow_level_b = shadow_texture.SampleCmp( shadow_sampler, shadow_b, offsetted_depth);
	let out_shadow_level_c = shadow_texture.SampleCmp( shadow_sampler, shadow_c, offsetted_depth);
	let out_shadow_level_d = shadow_texture.SampleCmp( shadow_sampler, shadow_d, offsetted_depth);

	let ratio_x = shadow_pixel_position_ratios.x;
	let ratio_x_inv = 1.0 - ratio_x;
	let ratio_y = shadow_pixel_position_ratios.y;
	let ratio_y_inv = 1.0 - ratio_y;

	let ratio_a = ratio_x_inv * ratio_y_inv;
	let ratio_b = ratio_x * ratio_y_inv;
	let ratio_c = ratio_x_inv * ratio_y;
	let ratio_d = ratio_x * ratio_y;

	return out_shadow_level_a * ratio_a +
				out_shadow_level_b * ratio_b +
				out_shadow_level_c * ratio_c + 
				out_shadow_level_d * ratio_d;
}

[shader("fragment")]

float4 fs_main(VertexOutput input) {
	let out_shadow_level = get_bilinear(input.shadow_position);

	if ( input.shadow_position.x > 1.0 || input.shadow_position.x < 0.0 || input.shadow_position.y > 1.0 || input.shadow_position.y < 0.0 ){
		return float4(0.0, 0.0, 0.0, 1.0);
	}

	let light_dot = dot(input.normal, input.light);

	let in_light_dot = range(light_dot, 0.0, 1.0);
	let in_light_ratio = range(in_light_dot, 0.0, 0.1) * out_shadow_level;

	let in_shadow_ratio = range(light_dot, -1.0, 0.0);

	return lerp(lerp(input.color_base_light, input.color_base, in_shadow_ratio), input.color_light, in_light_ratio);
}

for slang

[Mikael256]

//Vertex shader

struct Camera {
  view_proj: mat4x4<f32>,
}

struct MaterialColors {
  color_base: vec4<f32>,
  color_base_light: vec4<f32>,
  color_light: vec4<f32>,
}

@group(0) @binding(0)
var<uniform> camera : Camera;
@group(2) @binding(0)
var<uniform> shadow_camera : Camera;
@group(2) @binding(1)
var<uniform> light_vector : vec3<f32>;
@group(3) @binding(0)
var<uniform> color_list : array<vec3<f32>, 16>;

struct VertexInput {
  @location(0) position: vec3<f32>,
  @location(1) normal: vec3<f32>,
  @location(2) border_normal: vec3<f32>,
  @location(3) material_index: vec2<f32>,
}
struct InstanceInput {
  @location(5) model_matrix_0: vec4<f32>,
  @location(6) model_matrix_1: vec4<f32>,
  @location(7) model_matrix_2: vec4<f32>,
  @location(8) model_matrix_3: vec4<f32>,
}

struct VertexOutput {
  @builtin(position) clip_position: vec4<f32>,
  @location(0) normal: vec3<f32>,
  @location(1) light: vec3<f32>,
  @location(2) color_base: vec4<f32>,
  @location(3) color_base_light: vec4<f32>,
  @location(4) color_light: vec4<f32>,
  @location(5) shadow_position: vec3<f32>,
}

@vertex
fn vs_main(
    model: VertexInput,
    instance: InstanceInput,
) -> VertexOutput {
    let model_matrix = mat4x4<f32 >(
        instance.model_matrix_0,
        instance.model_matrix_1,
        instance.model_matrix_2,
        instance.model_matrix_3,
    );
    var out: VertexOutput;
    out.clip_position = camera.view_proj * model_matrix * vec4<f32 >(model.position, 1.0);
    let pos_from_light = shadow_camera.view_proj * model_matrix * vec4<f32 >(model.position, 1.0);
    let centered = pos_from_light.xy * vec2<f32 >(0.5, -0.5) + vec2<f32 >(0.5, 0.5);
    out.shadow_position = vec3<f32 >(centered, pos_from_light.z);
    let model_matrix3 = mat3x3(model_matrix[0].xyz, model_matrix[1].xyz, model_matrix[2].xyz);
    out.normal = model.normal;
    let material_index_base = u32(model.material_index[0] * 4.0);
    let material_index_base_light = u32(f32(material_index_base) + 1.0);
    let material_index_light = u32(f32(material_index_base) + 2.0);

    let color_base = color_list[material_index_base];
    let color_base_light = color_list[material_index_base_light];
    let color_light = color_list[material_index_light];

    out.color_base = vec4(color_base, 1.0);
    out.color_base_light = vec4(color_base_light, 1.0);
    out.color_light = vec4(color_light, 1.0);

    out.light = normalize(light_vector.xyz * model_matrix3);
    return out;
}

//Fragment shader
@group(1) @binding(0)
var shadow_texture : texture_depth_2d;
@group(1) @binding(1)
var shadow_sampler : sampler_comparison;
@group(2) @binding(2)
var<uniform> texture_size : vec2<f32>;

fn range(val: f32, min: f32, max: f32) -> f32 {
    let clamped = clamp(val, min, max);
    let size = max - min;

    return (clamped - min) / size;
}

fn get_bilinear(shadow_position: vec3<f32>) -> f32 {
    let shadow_pixel_width = 1.0 / texture_size.x;
    let shadow_pixel_height = 1.0 / texture_size.y;


    let shadow_pixel_position = shadow_position.xy * texture_size;
    let shadow_pixel_base_position = abs(shadow_pixel_position);
    let shadow_pixel_position_ratios = shadow_pixel_position % 1.0;

    // AB
    // CD
    let shadow_a = shadow_pixel_base_position / texture_size;
    let shadow_b = shadow_a + vec2(shadow_pixel_width, 0.0);
    let shadow_c = shadow_a + vec2(0.0, shadow_pixel_height);
    let shadow_d = shadow_b + vec2(0.0, shadow_pixel_height);

    let offsetted_depth = shadow_position.z - max(shadow_pixel_width, shadow_pixel_height);

    let out_shadow_level_a = textureSampleCompare(shadow_texture, shadow_sampler, shadow_a, offsetted_depth);
    let out_shadow_level_b = textureSampleCompare(shadow_texture, shadow_sampler, shadow_b, offsetted_depth);
    let out_shadow_level_c = textureSampleCompare(shadow_texture, shadow_sampler, shadow_c, offsetted_depth);
    let out_shadow_level_d = textureSampleCompare(shadow_texture, shadow_sampler, shadow_d, offsetted_depth);

    let ratio_x = shadow_pixel_position_ratios.x;
    let ratio_x_inv = 1.0 - ratio_x;
    let ratio_y = shadow_pixel_position_ratios.y;
    let ratio_y_inv = 1.0 - ratio_y;

    let ratio_a = ratio_x_inv * ratio_y_inv;
    let ratio_b = ratio_x * ratio_y_inv;
    let ratio_c = ratio_x_inv * ratio_y;
    let ratio_d = ratio_x * ratio_y;

    return out_shadow_level_a * ratio_a + out_shadow_level_b * ratio_b + out_shadow_level_c * ratio_c + out_shadow_level_d * ratio_d;
}

@fragment

fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {

    let out_shadow_level = get_bilinear(in.shadow_position);
    // let out_shadow_level = textureSampleCompare(shadow_texture, shadow_sampler, in.shadow_position.xy, in.shadow_position.z - 0.0005);


    if in.shadow_position.x > 1.0 || in.shadow_position.x < 0.0 || in.shadow_position.y > 1.0 || in.shadow_position.y < 0.0 {
        return vec4(0.0, 0.0, 0.0, 1.0);
    }

    let light_dot = dot(in.normal, in.light);

    let in_light_dot = range(light_dot, 0.0, 1.0);
    let in_light_ratio = range(in_light_dot, 0.0, 0.1) * out_shadow_level;

    let in_shadow_ratio = range(light_dot, -1.0, 0.0);

    return mix(mix(in.color_base_light, in.color_base, in_shadow_ratio), in.color_light, in_light_ratio);
}

for wgsl

[cwfitzgerald]

Just like in wgsl, you need to split your matrix into 4 vec4s. That should make things work.

As for SV_InstanceID, this is a mess of everyone trying to emulate everyone else. I'm going to file a bug against slang.

[cwfitzgerald]

Filed shader-slang/slang#6992

[cwfitzgerald]

I will also note that you can use slang to target wgsl directly, which may be better for your use case, if you don't need features that aren't in upstream wgsl.

[Mikael256]

nice thanks it solved it! ( well partially, I have other issues but unrelated )
for spirv I was thinking maybe it would be lighter to provide with compiled shader than long strings to compile at runtime.
Maybe compiling to wgsl would help for debugging.