Unable to render to and then read a texture

[casey]

I'm using wgpu and trying to render from one texture to another, and then render from the second texture to the screen, but I can't seem to get it to work.

Here's my render function:

https://github.com/casey/texture-read-issue/blob/0a57f5d6ebe65dd698b78660b0802c8cffc8d930/src/renderer.rs#L235

I'm using a Target struct to store a texture, texture view, and bind group that makes the texture available to the shader:

struct Target {
  bind_group: BindGroup,
  texture: Texture,
  texture_view: TextureView,
}

The renderer has two targets.

Here, I zero-initialize self.target[0].texture:

https://github.com/casey/texture-read-issue/blob/0a57f5d6ebe65dd698b78660b0802c8cffc8d930/src/renderer.rs#L245

Then in the first pass I render using target 0 as the source, target 1 as the destination, and with the shader uniform i set to 0, which should cause it to sample target 0 and invert the sampled color:

https://github.com/casey/texture-read-issue/blob/0a57f5d6ebe65dd698b78660b0802c8cffc8d930/src/renderer.rs#L270

And then in the second pass I render using target 1 as the source, and the current frame as the destination, with shader uniform set to 1, which should cause it to sample target 1 and pass through the sampled color:

https://github.com/casey/texture-read-issue/blob/0a57f5d6ebe65dd698b78660b0802c8cffc8d930/src/renderer.rs#L300

However, when I render, the output is black when it should be white.

Am I doing something that's obviously silly here? I'm on MacOS, btw.

[kpreid]

You’re interleaving calls to wgpu::Queue with constructing a single wgpu::CommandEncoder, which doesn’t work the way you intend. Operations are executed in the order they are put on the Queue, and so all commands you encoded were enqueued at the point you submitted the command buffer to the queue, not when you encoded them. Here’s the sequence of your queue usage:

queue.write_texture(...0x00...)
queue.write_buffer({i: 0})
queue.write_buffer({i: 1})
queue.submit([encoder.finish()])

So, all of your draw calls are executed with i = 1, because all of them executed after you wrote 1 to the buffer.

To make this work as you want, you can do one of these things:

• Encode two command buffers, so that you can submit one of them after the first write_buffer and before the second write_buffer.
• Create two different bind groups, one for the uniforms of each render pass. (This does not mean necessarily using two buffers, because each bind group can have a different offset into a single buffer.)
• Use dynamic offsets, which do the same thing but you pick the offset into the buffer when you call set_bind_group(), so you only need one bind group.

[casey]

Awesome, I'm so glad it's something simple. That makes perfect sense. I think the best option is going to be writing the uniforms for all render passes to a single buffer, and then using dynamic offsets for each render pass to select the correct set of uniforms. Thank you for the detailed explanation!