Meshlet single pass depth downsampling (SPD)

[JMS55]

Objective

• Using multiple raster passes to generate the depth pyramid is extremely slow
• Pulling data from the source image is the largest bottleneck, it's important to sample in a cache-aware pattern
• Barriers and pipeline drain between the raster passes is the second largest bottleneck
• Each separate RenderPass on the CPU is really expensive

Solution

• Port FidelityFX SPD to WGSL, replacing meshlet's existing multiple raster passes with a single two compute dispatches. Lack of coherent buffers means we have to do the the last 64x64 tile from mip 7+ in a separate dispatch to ensure the mip 6 writes were flushed :(
• Workgroup shared memory version only at the moment, as the subgroup operation is blocked by our upgrade to wgpu 0.20 Wgpu 0.20 #13186
• Don't enforce a power-of-2 depth pyramid texture size, simply scaling by 0.5 is fine

[pcwalton]

Which parts do you want me to review? Presumably downsample_depth.wgsl? Anything else?

[JMS55]

The downsample shader, yeah. I can't post a link ATM, but you can find the full PR diff by changing the GitHub diff to compare against my meshlet-previous-frame-depth-pyramid branch.

[pcwalton]

Overall a straightforward port of FidelityFX, but I'm concerned about the lack of texture barrier and some more comments explaining the approach would be nice. Seems fine other than that.

[pcwalton]

I'm not a big fan of the way there's so much repetition here, but I see that you're copying from FidelityFX, so I'm OK with it.

[pcwalton]

Ok, I had to stare at this a while. I assume what you're doing here is to work around the lack of subgroupQuadSwapX intrinsics. That's why you do local_invocation_index < 64 instead of local_invocation_index % 16 == 0 like FidelityFX does.

Can you add a comment saying that this is a workaround for lack of subgroup quad swap operations?

[pcwalton]

Oh wait, I guess this is similar to SpdDownsampleMips_0_1_LDS. OK, I see. Maybe add a TODO here so we can remember to update it when we have subgroup ops.

[pcwalton]

I'd add a brief comment here explaining the overall approach. Perhaps:

Every thread we dispatch is responsible for four 2x2 quads in the original depth buffer. Each workgroup has a shared 16x16 texel tile to work with. Different approaches are used at each mip level:
Mip level 0 (64x64): Use texture gather instructions to sample at the center of each 2x2 quad. Do this 4 times for the 4 quads we're responsible for. Save each downsampled depth value, effectively slicing each 32x32 piece into four 16x16 pieces.
Mip level 1 (32x32): For each of the four 16x16 pieces we have, copy it into the tile memory, then downsample it and barrier. This results in a 16x16 tile, which we store in our tile memory.
Mip levels 2-5 (16x16 to 2x2): The entire tile fits in memory, so we just downsample it in place.
Mip levels 6+: Load from the global texture and downsample 4 pixels at a time. Only one workgroup remains at this point.

[JMS55]

Downscale is broken, will need to debug. Might be the barrier issue.

[pcwalton]

Looks good now. Looking forward to this!

[atlv24]

looks good. i've already looked through this code a few times before, just never left an approve

[IceSentry]

I guess this could help a bit

Suggested change

	texture_depth_2d(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	texture_storage_2d(
	TextureFormat::R32Float,
	StorageTextureAccess::ReadWrite,
	),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	write_only_r32float(),
	// view depth
	texture_depth_2d(),
	// mip 1
	write_only_r32float(),
	// mip 2
	write_only_r32float(),
	// mip 3
	write_only_r32float(),
	// mip 4
	write_only_r32float(),
	// mip 5
	write_only_r32float(),
	// mip 6
	texture_storage_2d(
	TextureFormat::R32Float,
	StorageTextureAccess::ReadWrite,
	),
	// mip 7
	write_only_r32float(),
	// mip 8
	write_only_r32float(),
	// mip 9
	write_only_r32float(),
	// mip 10
	write_only_r32float(),
	// mip 11
	write_only_r32float(),
	// mip 12
	write_only_r32float(),

[IceSentry]

I didn't go over the shader code, but I trust the other reviewers on that.

[otoomey]

I believe that there might be an improvement that can be made here:

fn reduce_load_mip_0(tex: vec2u) -> f32 {
    let uv = (vec2f(tex) + 0.5) / vec2f(textureDimensions(mip_0));
    return reduce_4(textureGather(mip_0, samplr, uv));
}

From what I understand from the spec, textureGather already computes the four component minimum and stores it in the w channel. So there is no need to reduce, just do the following:

fn reduce_load_mip_0(tex: vec2u) -> f32 {
    let uv = (vec2f(tex) + 0.5) / vec2f(textureDimensions(mip_0));
    return textureGather(mip_0, samplr, uv).w;
}

It is very possible that the compiler spots this optimization already.

Frankly I'm not sure how textureGather works exactly, in Vulkan you needed a VK_SAMPLER_REDUCTION_MODE_MIN sampler and corresponding extension to do this.

[JMS55]

textureGather does not return the minimum of the 4 values. The w component is the (u_min, v_min) value of the sample footprint. I.e. given 4 texels (the sample footprint) arranged in a 2x2 quad, the w component is the value at location (u_min, v_min).

Yes, ideally I would be able to use VK_SAMPLER_REDUCTION_MODE_MIN, but unfortunately wgpu does not support it.