How many uniforms does bevy support with GLSL?

[david4shure]

I am trying to write an atmosphere shader and integrate it with a bevy project as a post processing effect, and I have run into many issues. Lemme first start out by showing my bind group, I have 5 of them.

        let layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("post_process_bind_group_layout"),
            entries: &[
                // The screen texture
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Float { filterable: true },
                        view_dimension: TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                // The sampler that will be used to sample the screen texture
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
                    count: None,
                },
                // The depth texture
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Depth,
                        view_dimension: TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                // The sampler that will be used to sample the depth texture
                BindGroupLayoutEntry {
                    binding: 3,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
                    count: None,
                },
                // The settings uniform that will control the effect
                BindGroupLayoutEntry {
                    binding: 4,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Buffer {
                        ty: bevy::render::render_resource::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: Some(AtmosphereSettings::min_size()),
                    },
                    count: None,
                },
            ],
        });

The atmosphere settings type referenced in the last element there is a struct that looks like the following

#[derive(Component, Default, Clone, Copy, ExtractComponent, ShaderType)]
pub struct AtmosphereSettings {
    pub sunPosition: Vec3,
    pub cameraPosition: Vec3,
    pub inverseProjection: Mat4,
    pub inverseView: Mat4,
    pub cameraNear: f32,
    pub cameraFar: f32,

    pub planetPosition: Vec3,
    pub planetRadius: f32,
    pub atmosphereRadius: f32,

    pub falloffFactor: f32,
    pub sunIntensity: f32,
    pub scatteringStrength: f32,
    pub densityModifier: f32,

    pub redWaveLength: f32,
    pub greenWaveLength: f32,
    pub blueWaveLength: f32,
}

Now, when I bind these pieces of information to the pipeline, it looks like this

        let bind_group = render_context.render_device().create_bind_group(
            "post_process_bind_group",
            &post_process_pipeline.layout,
            // It's important for this to match the BindGroupLayout defined in the PostProcessPipeline
            &BindGroupEntries::sequential((
                // Make sure to use the source view
                post_process.source,
                // Use the sampler created for the pipeline
                &post_process_pipeline.screen_sampler,
                &prepass_depth_texture.default_view,
                &post_process_pipeline.depth_sampler,
                // Set the settings binding
                settings_binding.clone(),
            )),
        );

I have written a bevy system that syncs out the following fields to the AtmosphereSettings struct

    pub sunPosition: Vec3,
    pub cameraPosition: Vec3,
    pub inverseProjection: Mat4,
    pub inverseView: Mat4,
    pub cameraNear: f32,
    pub cameraFar: f32,

My question is the following, when I try to run this program (of which I've tried to include as much relevant detail here as I can), I get the following error:

2023-11-07T15:02:19.698748Z ERROR wgpu::backend::direct: Handling wgpu errors as fatal by default    
thread 'Compute Task Pool (7)' panicked at C:\Users\johnn\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.1\src\backend\direct.rs:3056:5:
wgpu error: Validation Error

Caused by:
    In Device::create_render_pipeline
      note: label = `post_process_pipeline`
    Error matching ShaderStages(FRAGMENT) shader requirements against the pipeline
    Shader global ResourceBinding { group: 1, binding: 2 } is not available in the layout pipeline layout
    Binding is missing from the pipeline layout

It's saying the group 1, binding 2 is not available in the layout pipeline layout, IE its missing. I'm a little lost here and could use some help, the example on post processing shaders wasn't up to date, and doesn't really show you how to do much. I've so far been able to write out the screen texture, screen Texture Sampler, the depth texture, and depth Texture Sampler to a post processing shader, and it worked just fine with these bindings, so I don't think thats really the issue. I suspect this error has something to do with my AtmosphereSettings uniform struct.

[IceSentry]

I'm not super familiar with GLSL, but your bind group indices and binding indices don't seem to match the bind group layout you specified. Also, the settings binding should be one big struct in binding 4 of whatever bind group this layout is used for not a bunch of separate uniforms

[david4shure]

Damn, well I still see this error :(

Caused by:
    In Device::create_render_pipeline
      note: label = `post_process_pipeline`
    Error matching ShaderStages(FRAGMENT) shader requirements against the pipeline
    Shader global ResourceBinding { group: 1, binding: 1 } is not available in the layout pipeline layout
    Binding is missing from the pipeline layout

[david4shure]

I ended up porting this shader to wgsl, and I am seeing some similar errors to the glsl version. In fact I was able to strip down the shader and verify that the screen, screenSampler, depth, depthSampler were being passed properly. Then, I implement my shader and add the AtmosphereSettings uniform, and now all of the sudden it says my layout is wrong.

@group(0) @binding(0) var screen_texture: texture_2d<f32>;
@group(0) @binding(1) var screen_texture_sampler: sampler;

@group(0) @binding(2) var depth_texture: texture_2d<f32>;
@group(0) @binding(3) var depth_texture_sampler: sampler;

struct AtmosphereSettings {
    sunPosition: vec3<f32>,
    cameraPosition: vec3<f32>,
    inverseProjection: mat4x4<f32>,
    inverseView: mat4x4<f32>,
    cameraNear: f32,
    cameraFar: f32,

    planetPosition: vec3<f32>,
    planetRadius: f32,
    atmosphereRadius: f32,

    falloffFactor: f32,
    sunIntensity: f32,
    scatteringStrength: f32,
    densityModifier: f32,

    redWaveLength: f32,
    greenWaveLength: f32,
    blueWaveLength: f32,
    #ifdef SIXTEEN_BYTE_ALIGNMENT
        // WebGL2 structs must be 16 byte aligned.
        _webgl2_padding: vec3<f32>
    #endif
}

@group(0) @binding(4) var<uniform> atmosphere_settings: AtmosphereSettings;

Bind group:

        let bind_group = render_context.render_device().create_bind_group(
            "post_process_bind_group",
            &post_process_pipeline.layout,
            // It's important for this to match the BindGroupLayout defined in the PostProcessPipeline
            &BindGroupEntries::sequential((
                // Make sure to use the source view
                post_process.source,
                // Use the sampler created for the pipeline
                &post_process_pipeline.screen_sampler,
                &prepass_depth_texture.default_view,
                &post_process_pipeline.depth_sampler,
                // Set the settings binding
                settings_binding.clone(),
            )),
        );

...


        let layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("post_process_bind_group_layout"),
            entries: &[
                // The screen texture
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Float { filterable: true },
                        view_dimension: TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                // The sampler that will be used to sample the screen texture
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
                    count: None,
                },
                // The depth texture
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Depth,
                        view_dimension: TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                // The sampler that will be used to sample the depth texture
                BindGroupLayoutEntry {
                    binding: 3,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
                    count: None,
                },
                // The settings uniform that will control the effect
                BindGroupLayoutEntry {
                    binding: 4,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Buffer {
                        ty: bevy::render::render_resource::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: Some(AtmosphereSettings::min_size()),
                    },
                    count: None,
                },
            ],
        });

This is an absolutely baffling API to me, I don't know why this has to be so cumbersome. The error I get is this

Caused by:
    In Device::create_render_pipeline
      note: label = `post_process_pipeline`
    Error matching ShaderStages(FRAGMENT) shader requirements against the pipeline
    Shader global ResourceBinding { group: 0, binding: 2 } is not available in the layout pipeline layout
    Texture class Depth { multi: false } doesn't match the shader Sampled { kind: Float, multi: false }

[david4shure]

@JMS55 any ideas here? Thank you for your help already.

[david4shure]

This is the shader I am porting
https://github.com/BarthPaleologue/volumetric-atmospheric-scattering

[JMS55]

You're trying to bind the depth texture as a sampled texture. Either change the layout to be a sampled texture, or change your shader to specify a depth texture instead of texture_2d.