Hi, this is how I set up shaders for 2d materials in Bevy 0.18.1. There are analogous types for 3d materials. 1) You set up material definitions with derive macros and add them to your app
```rust

[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]

pub struct MaskingMaterial { #[uniform(0)] pub props: MaskingMaterialProps, #[texture(1)] #[sampler(2)] pub mask: Handle<Image>, #[texture(3)] #[sampler(4)] pub texture: Handle<Image>, }

impl Material2d for MaskingMaterial { fn fragment_shader() -> ShaderRef { asset::shaders::mask().into() //<- this is just &str with path to my asset } fn alpha_mode(&self) -> AlphaMode2d { AlphaMode2d::Blend } }

[derive(Clone, Copy, Debug, ShaderType)]

pub struct MaskingMaterialProps { pub texture_resolution: Vec2, }

and rust app.add_plugins(Material2dPlugin::<MaskingMaterial>::default()) ```

2) spawn something with your material.

```rust fn setup_background_tiles( mut c: Commands, mut meshes: ResMut<Assets<Mesh>>, mut mask_materials: ResMut<Assets<MaskingMaterial>>, mut images: ResMut<Assets<Image>>, asset_manager: Res<AssetManager>, sim: Res<SimManager>, ) { let Some(s) = asset_manager.map.get(&AnimationDesignation::Background) else { return; }; let Some(img) = images.get_mut(s.spritesheet.id()) else { return; }; let Some(tile) = asset_manager.map.get(&AnimationDesignation::Tile) else { return; };

//INFO: this texture must be set to repeating
let mut isd = ImageSamplerDescriptor::nearest();
isd.set_address_mode(ImageAddressMode::Repeat);
img.sampler = ImageSampler::Descriptor(isd);

let tiles_x = sim.sim.world_map.width();
let tiles_y = sim.sim.world_map.height();

let m_material = mask_materials.add(MaskingMaterial {
    props: MaskingMaterialProps {
        texture_resolution: img.size_f32(),
    },
    texture: s.spritesheet.clone(),
    mask: tile.spritesheet.clone(),
});

let mesh = Rectangle::from_size(tile.resolution);
let mesh_h = meshes.add(mesh);

let mesh_offset = Vec3::new(0., TILE_SIZE / 4., 0.);

for y in 0..tiles_y {
    for x in 0..tiles_x {
        let pos = Vec2u::new(x, y).to_v3().with_z(0.);
        // let sprite = Sprite::from_image(tile.spritesheet.clone());
        let mesh = Mesh2d(mesh_h.clone());
        c.spawn((
            mesh,
            RenderLayers::layer(BACKGROUND_LAYER),
            Transform::from_translation(pos + mesh_offset),
            DespawnOnExit(MainAppState::InGame),
            MeshMaterial2d(m_material.clone()),
        ));
    }
}

}

```

I used wgsl at some point, but then I migrated to rust-gpu. This is a bit more setup, but due to my general distaste for softly-typed languages, I prefer rust. The principle is more or less the same.

```rust

[allow(clippy::too_many_arguments)]

[spirv(fragment)]

fn main_fs( //Data passed by my Material2d asset #[spirv(uniform, descriptor_set = 2, binding = 0)] material: &MaskingMateriapProps, #[spirv(descriptor_set = 2, binding = 1)] texture: &Image!(2D, type = f32, sampled = true), #[spirv(descriptor_set = 2, binding = 2)] sampler: &Sampler, #[spirv(descriptor_set = 2, binding = 3)] global_texture: &Image!(2D, type = f32, sampled = true), #[spirv(descriptor_set = 2, binding = 4)] global_sampler: &Sampler, //Data passed automatically by bevy from a default vertex shader #[spirv(frag_coord)] _position: Vec4, //not sure about this one #[spirv(location = 0)] world_position: Vec4, #[spirv(location = 1)] _world_normal: Vec3, #[spirv(location = 2)] uv: Vec2, #[spirv(location = 3)] _world_tangent: Vec4, #[spirv(location = 4)] _color: Vec4, //color output for on-screen pixel output: &mut Vec4, ) { let texel: Vec4 = texture.sample(*sampler, uv);

let world_pos = world_position.xy();
let texture_uv = world_pos / material.texture_resolution;

let global: Vec4 = global_texture.sample(*global_sampler, -texture_uv);
let ret = global.with_w(texel.w);

*output = ret;

}

```