What is the simplest way to utilise a depth buffer with MSAA?

[konall]

Hi there,

Thanks very much for all the great work on this project, it's amazing!

I have a quick question that I'm hoping has a wgpu-specific answer (because I don't mean to waste your time ingorantly asking for explanations of general computer graphics concepts!)- is there a simple way to utilise a depth buffer while also using MSAA?

I have MSAA working perfectly without depth buffering, and I have depth buffering working perfectly without MSAA, so it seems very tempting to assume there is a final little step to take to combine the two- the problem I'm facing when I naively try to drop both of them in is that I can't have attachments with different sample counts (MSAA > 1, depth buffer = 1) in the same render pipeline.

My render process is very simple:

    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
    
    let frame = swap_chain.get_current_frame()?.output;

    {
        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("render_pass"),
            color_attachments: &[wgpu::RenderPassColorAttachment {
                view: &msaa_target,
                resolve_target: Some(&frame.view),
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                    store: true,
                },
            }],
            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                view: &depth_texture_view,
                depth_ops: Some(wgpu::Operations {
                    load: wgpu::LoadOp::Clear(-1.0),
                    store: true,
                }),
                stencil_ops: Some(wgpu::Operations {
                    load: wgpu::LoadOp::Clear(0),
                    store: true,
                }),
            }),
        });

        render_pass.set_pipeline(&render_pipeline);
        render_pass.set_bind_group(0, &global_bind_group, &[]);

        for item in render_queue {
            render_pass.set_bind_group(1, &item.resources.bind_group, &[]);
            render_pass.set_vertex_buffer(0, item.resources.vb.slice(..));
            render_pass
                .set_index_buffer(item.resources.ib.slice(..), wgpu::IndexFormat::Uint16);
            render_pass.draw_indexed(0..item.resources.num_indices, 0, 0..1);
        }
    }

However, as I mentioned, the above configuration doesn't work because of the differing sample counts.

Any help would be greatly appreciated- apologies again if this question concerns a broader concept than just a wgpu implementation, if that's the case then I'll look elsewhere for hints.

Thank you!

[cwfitzgerald]

Thanks for the kind words! The solution is pretty simple, you just need to create a multi-sampled depth buffer. It will then do depth tests on every single sample not just every pixel. You can make a multisampled depth buffer the same was as a normal texture by making its sample count != 1.

[konall]

D'oh!

I'm certain I tried this earlier and got an error, but I must have tweaked something else simultaneously and mistakenly blamed the resulting error on the multisampled depth buffer!

Thanks very much for your quick reply, and thanks again for your work on this project!!

[kvark]

This story isn't complete yet, see gpuweb/gpuweb#1924

[konall]

I'm afraid I mightn't be able to offer much insight into this issue because my problem wasn't caused by depth sampling directly in shaders, I'm invoking depth sampling and MSAA using only the render pass- @cwfitzgerald 's simple fix worked for me because I only needed to change the sample count for the depth texture used by the depth stencil attachment in my render pass (my previous confusion was due to errors originating from wgpu_glyph, as it turns out its render pipeline doesn't have support for MSAA)