Specialized mesh pipeline only renders meshes furthest away

[TheCodeLamp]

Hello, we are working on a voxel renderer and wanted to implement some instancing for performance. However, when we are running our custom pipeline it only wants to render the mesh which is furthest away (according to the Transparent3d distance field).

This is a github repo with the issue highlighted:
https://github.com/TheCodeLamp/bevy_meshing_issues

Edit: We have updated the sample repository. See Linus' latest comment for details.

[nicopap]

I did investigate this a tinny bit. The reproduction code seems to be pretty similar to the custom_shader_instancing example.

The custom_shader_instancing has only a single mesh, I added a second mesh to see if I can reproduce, but I'm not sure how to interpret the results.

The fact that only the furthest mesh shows up kinda hint at some sort of overwritting. iirc bevy sorts entities based on how far from the camera they are before passing them to the various rendering systems. But the painter's algorithm would have the closest entity to the camera be the last processed, so not sure what's going on here.

I don't get anything conclusive from the renderdoc output, but I don't have enough experience to even call myself "neophyte".

[LinusKall]

We actually improved the example (forgot to take vertex instancing into account, making only half the quads visible).
We also did as the custom_shader_instancing example suggested and made sure to send the mesh's current_uniform_index as a separate uniform like so:

fn prepare_mesh_slot_bind_groups(
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    custom: Res<CustomPipeline>,
    render_mesh_instances: Res<RenderMeshInstances>,
    mut commands: Commands,
    // iterate your render-world entities that you draw
    query: Query<(Entity, &MainEntity), With<InstanceMaterialData>>,
) {
    for (render_entity, main_entity) in &query {
        // Ask Bevy what index this draw should use with get_world_from_local()
        if let Some(qd) = render_mesh_instances.render_mesh_queue_data(*main_entity) {
            let idx = qd.current_uniform_index.0;

            info!(entity=%main_entity.entity(), index=%idx);

            let data = MeshSlotUniform { index: idx };
            let mut uniform = UniformBuffer::default();
            uniform.set(data);
            uniform.set_label(Some("mesh_slot_uniform_buffer"));
            uniform.add_usages(BufferUsages::UNIFORM | BufferUsages::COPY_DST);
            uniform.write_buffer(&render_device, &render_queue);

            let bind_group = render_device.create_bind_group(
                Some("mesh_slot_bind_group"),
                &custom.mesh_slot_layout,
                &[BindGroupEntry {
                    binding: 0,
                    resource: uniform
                        .buffer()
                        .expect("was just created")
                        .as_entire_binding(),
                }],
            );

            commands
                .entity(render_entity)
                .insert(MeshSlot(bind_group, uniform));
        }
    }
}

Update draw call:

type DrawCustom = (
    SetItemPipeline,
    SetMeshViewBindGroup<0>,
    SetMeshBindGroup<1>,
    SetMaterialBindGroup<StandardMaterial, 2>,
    SetMeshSlotBindGroup<3>, // New!
    DrawMeshInstanced,
);

pub struct SetMeshSlotBindGroup<const I: usize>;
impl<P: PhaseItem, const I: usize> RenderCommand<P> for SetMeshSlotBindGroup<I> {
    type Param = ();
    type ViewQuery = ();
    type ItemQuery = Read<MeshSlot>;

    fn render<'w>(
        item: &P,
        _view: (),
        mesh_slot: Option<&'w MeshSlot>,
        _param: SystemParamItem<'w, '_, Self::Param>,
        pass: &mut TrackedRenderPass<'w>,
    ) -> RenderCommandResult {
        // info!(entity = %item.entity(),"set uniform {mesh_slot:?}");
        let mesh_slot = mesh_slot.unwrap();
        pass.set_bind_group(I.try_into().unwrap(), &mesh_slot.0, &[]);

        RenderCommandResult::Success
    }
}

In the wgsl, we then have this:

@group(3) @binding(0)
var<uniform> mesh_slot: MeshSlot;


@vertex
fn vertex(v: Vertex) -> VertexOutput {

    ...
    
    let world_from_local = get_world_from_local(mesh_slot.index * 2); // Magic times 2 for some reason?
    
    ...
    
}

and now the quads at least look as expected, but we get the same issue as you described where the sorting appears to work incorrectly.

My theory is that the mesh_slot.index order might be incorrect, but I don't know if it holds any water.
It might be easy to test by attaching vertex colors to each separate voxel, looking for where each colored voxel appears and should appear

[LinusKall]

It seems my theory holds some water after all!

The camera is located somewhere in the +X +Y +Z direction, looking at X=0, Y=0, Z=0.

Here we get this:

Spawn order	Position	Expected color	Actual color
0	Up	Green	White
1	Down	Magenta	Green
2	Right	Red	Magenta
3	Left	Cyan	Blue
4	Front	Blue	Yellow
5	Back	Yellow	Red
6	Center	White	Cyan