Help rendering image with depth info

[That-One-Axolotl]

Hello, I've made a few small projects with bevy before, but I'm still quite new.

I want to render an image retrieved from a compute shader while preserving the depth of pixels in the image (the depth data is an array of f32s) so that rasterized objects is the scene will be properly occluded by certain parts of the image. I'm unaware of any way to do this in bevy, so any and all suggestions would be great.

[MukundaKatta]

Short answer: yes, this is possible — you need to write your compute-shader output to both a color attachment and a depth attachment, and then make sure your main 3D pass uses that depth texture as its depth input rather than a freshly-cleared one.

There are three ways to do it in Bevy 0.14+ depending on how much of the render pipeline you want to own:

1. Minimal: full-screen triangle pass that writes depth

This is usually what people actually want — the "sprite-ish with depth" look.

1. Store your compute output as:
   • a TextureDimension::D2 color image (RGBA8)
   • a TextureDimension::D2 depth image (Depth32Float) built from your f32 array
2. Create a custom RenderGraph node that runs before your main 3D pass and does a trivial fullscreen triangle draw with a fragment shader that writes both @location(0) color and the @builtin(frag_depth) from the texture.
3. Schedule the node with an edge before(bevy::core_pipeline::core_3d::graph::Node3d::MainOpaquePass).

The fragment shader is tiny:

@group(0) @binding(0) var color_tex: texture_2d<f32>;
@group(0) @binding(1) var depth_tex: texture_2d<f32>;
@group(0) @binding(2) var samp: sampler;

struct Out {
    @location(0) color: vec4<f32>,
    @builtin(frag_depth) depth: f32,
}

@fragment
fn fs(@builtin(position) pos: vec4<f32>, @location(0) uv: vec2<f32>) -> Out {
    let c = textureSample(color_tex, samp, uv);
    let d = textureSample(depth_tex, samp, uv).r;
    return Out(c, d);
}

Two crucial details most people get wrong:

• frag_depth must be in the same space as the camera's depth buffer. Bevy uses reverse-Z (1.0 = near, 0.0 = far). If your compute shader's depth is in linear world-space metres, convert it in the fragment shader:

  // Convert linear world-z into reverse-Z NDC for Bevy's depth buffer.
  fn to_reverse_z(linear_z: f32, near: f32, far: f32) -> f32 {
      // Reverse-Z with infinite far: 1/linear_z mapping
      return near / linear_z;
  }

  Whether you use the infinite-far projection or a finite far plane determines the formula; check your Camera3d projection.

• The depth texture format must match the main 3D pass's depth attachment. Bevy's default is Depth32Float. If you declare yours Depth24Plus, validation will scream at you.

2. Medium: inject a depth texture into the main pass' attachment

Instead of a separate pass, you can preload the main 3D pass's depth attachment with your compute output:

1. Create a ViewDepthTexture resource that wraps your compute-generated depth.
2. Attach it as the main pass's depth when the frame starts — the prepare_view_depth_textures system is where Bevy writes this.
3. With LoadOp::Load (not Clear) on the depth attachment, your compute depth is preserved and the rasterized meshes occlude correctly.

This is a bigger change — you need to override extract_default_ui_camera_view or write a render-phase plugin — but it avoids the fullscreen triangle overhead and keeps everything inside one pass. Only worth it at very high resolutions.

3. Heavy: full custom render graph

If you need more than depth (e.g., stencil, G-buffer terms, MRT), the full solution is to fork the 3D pipeline graph. See bevy::core_pipeline::core_3d::Core3dPlugin for the existing graph. You add nodes with render_app.add_render_graph_node::<_>(Core3d, ...) and connect them with edges to Bevy's built-in nodes.

Concrete starter

Pieces I'd stitch together if I were writing this:

• bevy::core_pipeline::fullscreen_vertex_shader — the vertex half is one line.
• ViewTarget — gives you the camera's main color attachment to write into.
• ViewDepthTexture — the depth attachment you want to write.
• An Extract system that copies your Image handles into a render-world resource so the node can bind them.

The post_processing example in Bevy's repo is the closest reference — it adds a custom node after the main pass. Your use case is the same plumbing but before Node3d::MainOpaquePass with depth output enabled.

What to watch out for

• Coordinate handedness and reverse-Z — easily 80% of the bugs in "my depth doesn't occlude" questions. Log a few sample depth values after conversion and compare against what bevy::render::view::ViewUniform thinks the near/far are.
• MSAA — if your main pass uses MSAA, the depth write from the fullscreen triangle needs a resolve step. Either disable MSAA for this camera or make the compute-output depth texture multisampled and write the same value to every sample.
• Viewport vs framebuffer size — your compute output has to be at the camera's rendered resolution, not window resolution. Use a Camera::target_size hook to resize the compute texture when the window resizes.

If you drop a repro (even pseudocode with the sizes/types), I can give more specific guidance on which of the three paths suits it.