Render points with per-fragment depth.

crates/re_renderer/shader/point_cloud.wgsl

@@ -4,6 +4,7 @@
 #import <./utils/flags.wgsl>
 #import <./utils/size.wgsl>
 #import <./utils/sphere_quad.wgsl>
+#import <./utils/sphere_depth.wgsl>
 #import <./utils/depth_offset.wgsl>
 
 @group(1) @binding(0)
@@ -64,8 +65,20 @@ struct VertexOut {
 
     @location(4) @interpolate(flat)
     picking_instance_id: vec2u,
+
+    // Offset on the projected Z axis corresponding to the frontmost point on the sphere.
+    @location(5) @interpolate(flat)
+    sphere_radius_projected_depth: f32,
 };
 
+struct FragmentOut {
+    @location(0)
+    color: vec4f,
+
+    @builtin(frag_depth)
+    depth: f32
+}
+
 struct PointData {
     pos: vec3f,
     unresolved_radius: f32,
@@ -120,6 +133,7 @@ fn vs_main(@builtin(vertex_index) vertex_idx: u32) -> VertexOut {
     out.world_position = quad.pos_in_world;
     out.point_center = point_data.pos;
     out.picking_instance_id = point_data.picking_instance_id;
+    out.sphere_radius_projected_depth = sphere_radius_projected_depth(point_data.pos, world_radius);
 
     return out;
 }
@@ -147,20 +161,28 @@ fn coverage(world_position: vec3f, radius: f32, point_center: vec3f) -> f32 {
 
 
 @fragment
-fn fs_main(in: VertexOut) -> @location(0) vec4f {
+fn fs_main(in: VertexOut) -> FragmentOut {
     let coverage = coverage(in.world_position, in.radius, in.point_center);
     if coverage < 0.001 {
         discard;
     }
 
-    // TODO(andreas): Do we want manipulate the depth buffer depth to actually render spheres?
+    let depth_offset = sphere_fragment_projected_depth(
+        in.radius,
+        in.sphere_radius_projected_depth,
+        in.world_position - in.point_center,
+    );
+
     // TODO(andreas): Proper shading
     // TODO(andreas): This doesn't even use the sphere's world position for shading, the world position used here is flat!
     var shading = 1.0;
     if has_any_flag(batch.flags, FLAG_ENABLE_SHADING) {
         shading = max(0.4, sqrt(1.2 - distance(in.point_center, in.world_position) / in.radius)); // quick and dirty coloring
     }
-    return vec4f(in.color.rgb * shading, coverage);
+    return FragmentOut(
+        vec4f(in.color.rgb * shading, coverage),
+        in.position.z + depth_offset,
+    );
 }
 
 @fragment

crates/re_renderer/shader/utils/sphere_depth.wgsl

@@ -0,0 +1,52 @@
+#import <../global_bindings.wgsl>
+
+// Routines for computing per-fragment depth of billboarded spheres or cylinders.
+//
+// Note: This technique is only an approximation. It ignores that depth is non-linear, so the
+// curve of the sphere's surface will be distorted.
+//
+// It also ignores the fact that spheres not in line with the camera's optical axis are
+// distorted by perspective projection in an asymmetric way — their outlines may be ellipses,
+// but the peak of the screen-space depth is *not* centered on the screen-space center of the
+// ellipse. In addition to that lack of distortion, the `projected_with_offset` point is the
+// nearest to the camera in world space, but is not the point with the nearest depth in screen
+// space, so the sphere's depth is lower than it should be.
+//
+// To get it right, we'd need to, essentially, compute the ray-tracing of a sphere.
+// But, overall, this produces spheres that have roughly consistent depth behavior independent of
+// view direction, which is good enough to, for example, make the look of intersections of
+// points and lines consistent as the camera orbits them. Just don't look too closely.
+
+
+// Compute the maximum `frag_depth` offset that a sphere, of radius `object_radius`
+// with center located at `object_position`, should have on the middle of its surface.
+// This may be used for cylinders too by giving the position of the nearest point on its
+// center line.
+fn sphere_radius_projected_depth(object_position: vec3f, object_radius: f32) -> f32 {
+    // If the billboard were a round mesh, where would the point on its surface nearest the camera be?
+    let front_point = object_position
+        + normalize(frame.camera_position - object_position) * object_radius;
+
+    // Project that point and the object's center point.
+    let projected_without_offset = frame.projection_from_world * vec4f(object_position, 1.0);
+    let projected_with_offset = frame.projection_from_world * vec4f(front_point, 1.0);
+
+    // Take the difference of the projected values.
+    return projected_with_offset.z / projected_with_offset.w
+         - projected_without_offset.z / projected_without_offset.w;
+}
+
+// Given the value computed by `sphere_radius_projected_depth()`, and the world-space position
+// of the current fragment, compute what should be added to its `frag_depth` to produce the
+// (approximate) depth value of the sphere.
+fn sphere_fragment_projected_depth(
+    object_radius: f32,
+    sphere_radius_projected_depth: f32,
+    world_frag_offset_from_center: vec3f,
+) -> f32 {
+    let offset_radius_squared =
+        dot(world_frag_offset_from_center, world_frag_offset_from_center);
+    let normalized_radius_squared = offset_radius_squared / (object_radius * object_radius);
+
+    return sphere_radius_projected_depth * sqrt(clamp(1.0 - normalized_radius_squared, 0.0, 1.0));
+}

crates/re_renderer/src/workspace_shaders.rs

@@ -187,6 +187,12 @@ pub fn init() {
         fs.create_file(virtpath, content).unwrap();
     }
 
+    {
+        let virtpath = Path::new("shader/utils/sphere_depth.wgsl");
+        let content = include_str!("../shader/utils/sphere_depth.wgsl").into();
+        fs.create_file(virtpath, content).unwrap();
+    }
+
     {
         let virtpath = Path::new("shader/utils/sphere_quad.wgsl");
         let content = include_str!("../shader/utils/sphere_quad.wgsl").into();