Bevy instancing example throws an error

[GalaMana]

Hi, this is my first time posting so tell me if I do anything wrong. I want to make a 3D tile map using tiles with meshes and I want to have it as a single entity.
Generating a new mesh every time it changed was very slow so I wanted to learn making my own rendering stuff. Though I couldn't find any helpful explanations for it so in the end I copy pasted the Instancing example to try and work from there. I fixed some syntax that I'm guessing was outdated, but there was one error that I could not fix in runtime:

wgpu error: Validation Error

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

I don't really have any idea on how to fix it so any information helps!

Spawning code:

commands.spawn((
    asset_server.add::<Mesh>(shape::Cube::new(0.5).into()),
    SpatialBundle::from_transform(self.transform),
    InstanceMaterialData(vec![InstanceData::new(
        Vec3::new(0.0, 0.0, 0.0),
        1.0,
        Color::MIDNIGHT_BLUE.with_a(1.0)
    )]),
    self.tilemap.vector_grid.generate_collider(),
    self.tilemap.clone(),
    NoFrustumCulling,
))

Rendering code:

use bevy::{
    core_pipeline::core_3d::Transparent3d,
    ecs::{
        query::QueryItem,
        system::{lifetimeless::*, SystemParamItem},
    },
    pbr::{
        MeshPipeline, MeshPipelineKey, RenderMeshInstances, SetMeshBindGroup, SetMeshViewBindGroup,
    },
    prelude::*,
    render::{
        extract_component::{ExtractComponent, ExtractComponentPlugin},
        mesh::{GpuBufferInfo, MeshVertexBufferLayout},
        render_asset::RenderAssets,
        render_phase::{
            AddRenderCommand, DrawFunctions, PhaseItem, RenderCommand, RenderCommandResult,
            RenderPhase, SetItemPipeline, TrackedRenderPass,
        },
        render_resource::*,
        renderer::RenderDevice,
        view::ExtractedView,
        Render, RenderApp, RenderSet,
    },
};
use bytemuck::{Pod, Zeroable};


#[derive(Component, Deref)]
pub struct InstanceMaterialData(pub Vec<InstanceData>);

impl ExtractComponent for InstanceMaterialData {
    type Query = &'static InstanceMaterialData;
    type Filter = ();
    type Out = Self;

    fn extract_component(item: QueryItem<'_, Self::Query>) -> Option<Self> {
        Some(InstanceMaterialData(item.0.clone()))
    }
}

pub struct CustomMaterialPlugin;

impl Plugin for CustomMaterialPlugin {
    fn build(&self, app: &mut App) {
        println!("CustomMaterialPlugin. 1");
        app.add_plugins(ExtractComponentPlugin::<InstanceMaterialData>::default());
        app.sub_app_mut(RenderApp)
        .add_render_command::<Transparent3d, DrawCustom>()
        .init_resource::<SpecializedMeshPipelines<CustomPipeline>>()
        .add_systems(
            Render,
            (
                queue_custom.in_set(RenderSet::QueueMeshes),
                prepare_instance_buffers.in_set(RenderSet::PrepareResources),
            ),
        );
        
        println!("CustomMaterialPlugin. 2");
    }

    fn finish(&self, app: &mut App) {
        println!("CustomMaterialPlugin. 3");
        app.sub_app_mut(RenderApp).init_resource::<CustomPipeline>();
        println!("CustomMaterialPlugin. 4");
    }
}

#[derive(Clone, Copy, Pod, Zeroable)]
#[repr(C)]
pub struct InstanceData {
    position: Vec3,
    scale: f32,
    color: [f32; 4],
}

impl InstanceData {
    pub fn new(
        position: Vec3,
        scale: f32,
        color: Color,
    ) -> Self {
        Self { position, scale, color: color.into() }
    }
}

//#[allow(clippy::too_many_arguments)]
fn queue_custom(
    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
    custom_pipeline: Res<CustomPipeline>,
    msaa: Res<Msaa>,
    mut pipelines: ResMut<SpecializedMeshPipelines<CustomPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    meshes: Res<RenderAssets<Mesh>>,
    render_mesh_instances: Res<RenderMeshInstances>,
    material_meshes: Query<Entity, With<InstanceMaterialData>>,
    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
) {
    println!("CustomMaterialPlugin. 5");
    let draw_custom = transparent_3d_draw_functions.read().id::<DrawCustom>();

    let msaa_key = MeshPipelineKey::from_msaa_samples(msaa.samples());

    for (view, mut transparent_phase) in &mut views {
        let view_key = msaa_key | MeshPipelineKey::from_hdr(view.hdr);
        let rangefinder = view.rangefinder3d();
        for entity in &material_meshes {
            let Some(mesh_instance) = render_mesh_instances.get(&entity) else {
                continue;
            };
            let Some(mesh) = meshes.get(mesh_instance.mesh_asset_id) else {
                continue;
            };
            let key = view_key | MeshPipelineKey::from_primitive_topology(mesh.primitive_topology);
            let pipeline = pipelines
                .specialize(&pipeline_cache, &custom_pipeline, key, &mesh.layout)
                .unwrap();
            transparent_phase.add(Transparent3d {
                entity,
                pipeline,
                draw_function: draw_custom,
                distance: rangefinder
                    .distance_translation(&mesh_instance.transforms.transform.translation),
                batch_range: 0..1,
                dynamic_offset: None,
            });
        }
    }
    println!("CustomMaterialPlugin. 6");
}

#[derive(Component)]
struct InstanceBuffer {
    buffer: Buffer,
    length: usize,
}

fn prepare_instance_buffers(
    mut commands: Commands,
    query: Query<(Entity, &InstanceMaterialData)>,
    render_device: Res<RenderDevice>,
) {
    for (entity, instance_data) in &query {
        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
            label: Some("instance data buffer"),
            contents: bytemuck::cast_slice(instance_data.as_slice()),
            usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
        });
        commands.entity(entity).insert(InstanceBuffer {
            buffer,
            length: instance_data.len(),
        });
    }
}

#[derive(Resource)]
struct CustomPipeline {
    shader: Handle<Shader>,
    mesh_pipeline: MeshPipeline,
}

impl FromWorld for CustomPipeline {
    fn from_world(world: &mut World) -> Self {
        let asset_server = world.resource::<AssetServer>();
        let shader = asset_server.load("shaders/instancing.wgsl");

        let mesh_pipeline = world.resource::<MeshPipeline>();

        CustomPipeline {
            shader,
            mesh_pipeline: mesh_pipeline.clone(),
        }
    }
}

impl SpecializedMeshPipeline for CustomPipeline {
    type Key = MeshPipelineKey;

    fn specialize(
        &self,
        key: Self::Key,
        layout: &MeshVertexBufferLayout,
    ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
        let mut descriptor = self.mesh_pipeline.specialize(key, layout)?;
        
        descriptor.vertex.shader = self.shader.clone();
        descriptor.vertex.buffers.push(VertexBufferLayout {
            array_stride: std::mem::size_of::<InstanceData>() as u64,
            step_mode: VertexStepMode::Instance,
            attributes: vec![
                VertexAttribute {
                    format: VertexFormat::Float32x4,
                    offset: 0,
                    shader_location: 3, // shader locations 0-2 are taken up by Position, Normal and UV attributes
                },
                VertexAttribute {
                    format: VertexFormat::Float32x4,
                    offset: VertexFormat::Float32x4.size(),
                    shader_location: 4,
                },
            ],
        });
        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
        Ok(descriptor)
    }
}

type DrawCustom = (
    SetItemPipeline,
    SetMeshViewBindGroup<0>,
    SetMeshBindGroup<1>,
    DrawMeshInstanced,
);

struct DrawMeshInstanced;

impl<P: PhaseItem> RenderCommand<P> for DrawMeshInstanced {
    type Param = (SRes<RenderAssets<Mesh>>, SRes<RenderMeshInstances>);
    type ViewWorldQuery = ();
    type ItemWorldQuery = Read<InstanceBuffer>;

    //#[inline]
    fn render<'w>(
        item: &P,
        _view: (),
        instance_buffer: &'w InstanceBuffer,
        (meshes, render_mesh_instances): SystemParamItem<'w, '_, Self::Param>,
        pass: &mut TrackedRenderPass<'w>,
    ) -> RenderCommandResult {
        let Some(mesh_instance) = render_mesh_instances.get(&item.entity()) else {
            return RenderCommandResult::Failure;
        };
        let Some(gpu_mesh) = meshes.into_inner().get(mesh_instance.mesh_asset_id) else {
            return RenderCommandResult::Failure;
        };
        //let instance_buffer = instance_buffer;

        pass.set_vertex_buffer(0, gpu_mesh.vertex_buffer.slice(..));
        pass.set_vertex_buffer(1, instance_buffer.buffer.slice(..));

        match &gpu_mesh.buffer_info {
            GpuBufferInfo::Indexed {
                buffer,
                index_format,
                count,
            } => {
                pass.set_index_buffer(buffer.slice(..), 0, *index_format);
                pass.draw_indexed(0..*count, 0, 0..instance_buffer.length as u32);
            }
            GpuBufferInfo::NonIndexed => {
                pass.draw(0..gpu_mesh.vertex_count, 0..instance_buffer.length as u32);
            }
        }
        RenderCommandResult::Success
    }
}

[NiklasEi]

From the code it seems that you copied the example for version 0.12. This might have been fixed in the mean time. Any chance you could try with a newer version like 0.13.2 (https://github.com/bevyengine/bevy/blob/release-0.13.2/examples/shader/shader_instancing.rs)?

If the latest example still fails for you, you could open an issue.

[GalaMana]

Okay, I've cloned it and in that folder, the example works, which if very weird because if I have the same file in my project, I get a bunch of syntax highlighting for unresolved imports. I don't think I'm importing the wrong things. I'll list them either way if it helps:

[dependencies]
rand = "*"
bevy = { version = "*" }
bevy_rapier2d = { version = "*", features = ["debug-render-2d"]}
serde = { version = "*" }
typetag = { version = "*" }
dyn-clone = "*"
bytemuck = "*"
postcard = "*"

[GalaMana]

I now also see that the bevy version that gets cloned is 0.14.0-dev but the file from bevyengine.org is still the one that isn't working

[GalaMana]

Hey I'm sorry if I'm hard to work with. But if I don't get a reply then I really don't know where to go from here. Even if you don't know how to fix it then I would still very much appreciate it if you told me.

[NiklasEi]

Could you double-check that your Bevy version matches the version of the example code you are copying? You already saw that the example that runs locally for you is for 0.14.0-dev, but your project is likely using 0.13.2 (you can check that by searching for bevy in your Cargo.lock). Once you verified what version you are using in your project, checkout that version in your local copy of Bevy (e.g. git checkout release-0.13.2). Now you can

1. check that the example still runs in that version of the Bevy clone
2. copy the example code over to your project and see if that fixes the issues

If the issues persist, you could follow the GitHub documentation I linked further above to open an issue in the Bevy repository. In the issue, paste the errors and describe what you tried to fix them. Alternatively, if you have Discord, you could try asking for help in the official Bevy Discord server. You might get more people responding there.

[GalaMana]

Hey, I messed around with the Cargo.toml in my project and out of nowhere, all the errors suddently dissappeared. It's not any different so It must have just fixed itself when I changed stuff. That error was driving me insane and I wouldn't have fixed it without your help on the version stuff. Thanks a lot for helping me. Have a great day!