Why is { load: LoadOp::Load, store: StoreOp::Discard } treated as read_only: false?

[LukasKalbertodt]

Setting the following in my RenderPassDescriptor::depth_stencil_attachment:

                depth_ops: Some(wgpu::Operations {
                    load: wgpu::LoadOp::Load,
                    store: wgpu::StoreOp::Discard,
                }),

Results in an error because I also want to read from the same texture in my shader. I dug a bit into the code and I think it comes down to this:

wgpu/wgpu/src/backend/direct.rs

Lines 419 to 448 in e26a853

	fn map_pass_channel<V: Copy + Default>(
	ops: Option<&Operations<V>>,
	) -> wgc::command::PassChannel<V> {
	match ops {
	Some(&Operations {
	load: LoadOp::Clear(clear_value),
	store,
	}) => wgc::command::PassChannel {
	load_op: wgc::command::LoadOp::Clear,
	store_op: map_store_op(store),
	clear_value,
	read_only: false,
	},
	Some(&Operations {
	load: LoadOp::Load,
	store,
	}) => wgc::command::PassChannel {
	load_op: wgc::command::LoadOp::Load,
	store_op: map_store_op(store),
	clear_value: V::default(),
	read_only: false,
	},
	None => wgc::command::PassChannel {
	load_op: wgc::command::LoadOp::Load,
	store_op: wgc::command::StoreOp::Store,
	clear_value: V::default(),
	read_only: true,
	},
	}
	}

It makes sense to me that LoadOp::Clear as well as StoreOp::Store would both write to the texture. But the above Operations seems read_only: true to me, so why is it treated as read_only: false?

---

I can make this work simply by setting depth_ops: None. But I only came up with this after reading the above code. So I'm curious.

[cwfitzgerald]

It's perfectly valid to do Load -> Discard and still write to the attachment. An example could be a depth buffer that you used in a previous pass, will do rendering against, but then don't need again.

[LukasKalbertodt]

I'm not sure I understand :/

So in one render pass, I add this specific texture as depth attachment with (Load, Discard). The pipeline performs z-tests against it, but DepthStencilState::depth_write_enabled is false. I also have it in a bind group in order to read it from shader. So nothing in this render pass changes the texture and this should be fine, right? But it causes the ResourceUsageConflict error.
Am I misunderstanding LoadOp::Load? It just means "don't clear the texture before using it", right? What even is the difference between None and Some(wgpu::Operations { load: LoadOp::Load, store: StoreOp::Discard })?

Sorry for taking your time and thanks for the help.

[cwfitzgerald]

Sorry for taking your time and thanks for the help.

Don't worry about it!

I think the important part to understand is that we need to make the read-only/read-write decision at the beginning of the renderpass, based only on the operations provided. While in theory we could try to determine if the attachment is written to in the body of the renderpass, that would require us to do a full pass over the renderpass before we start validation of it - in general WebGPU prefers asking the user for the information and then validating it inline.

What even is the difference between None and Some(wgpu::Operations { load: LoadOp::Load, store: StoreOp::Discard })?

The difference is if you're allowed to use read/write pipelines. If None, you're not allowed, if Some you are.

[LukasKalbertodt]

Hu, interesting.

let pipeline = gfx.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
    depth_stencil: Some(wgpu::DepthStencilState {
        depth_write_enabled: true,
        ...
    }),
    ...
});

let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
    depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
        depth_ops: Some(wgpu::Operations {
            load: wgpu::LoadOp::Load,
            store: wgpu::StoreOp::Discard,
        }),
        ...
    }),
    ...
});

That code does not result in a validation error. And that's intended? I guess it's useful to re-use pipelines that usually write depth, but in a render pass you can override that decision and say "not this time" basically? Then maybe I understood it.