Optimize the depth-cloud shader when depth=0 (#1729)

* Optimize the depth-cloud shader when depth=0

depth=0 is a degenerate case that causes a 1440x1920 depth-map
from #1538 take 75ms (!) on my
M1 MacBook Pro.

With this fix this goes down to 15 ms

However, if we zoom out a lot, so that the depth point cloud covers
a very small part of the screen, the slowness returns.

I suspect this is a GPU binning problem of some sort, where too many
points in too small of a screen area causes performence issues.

* Put happy-path first, and also handle NaNs

* var -> let

* Remove unnecessary parenthesis in wgsl if-statements

crates/re_renderer/shader/depth_cloud.wgsl

@@ -13,14 +13,6 @@
 
 // ---
 
-struct PointData {
-    pos_in_world: Vec3,
-    unresolved_radius: f32,
-    color: Vec4
-}
-
-// ---
-
 /// Keep in sync with `DepthCloudInfoUBO` in `depth_cloud.rs`.
 ///
 /// Same for all draw-phases.
@@ -66,6 +58,14 @@ struct VertexOut {
     @location(3) point_radius: f32,
 };
 
+// ---
+
+struct PointData {
+    pos_in_world: Vec3,
+    unresolved_radius: f32,
+    color: Vec4
+}
+
 // Backprojects the depth texture using the intrinsics passed in the uniform buffer.
 fn compute_point_data(quad_idx: i32) -> PointData {
     let wh = textureDimensions(depth_texture);
@@ -74,26 +74,32 @@ fn compute_point_data(quad_idx: i32) -> PointData {
     // TODO(cmc): expose knobs to linearize/normalize/flip/cam-to-plane depth.
     let world_space_depth = depth_cloud_info.world_depth_from_texture_value * textureLoad(depth_texture, texcoords, 0).x;
 
-    // TODO(cmc): albedo textures
-    let color = Vec4(colormap_linear(depth_cloud_info.colormap, world_space_depth / depth_cloud_info.max_depth_in_world), 1.0);
-
-    // TODO(cmc): This assumes a pinhole camera; need to support other kinds at some point.
-    let intrinsics = depth_cloud_info.depth_camera_intrinsics;
-    let focal_length = Vec2(intrinsics[0][0], intrinsics[1][1]);
-    let offset = Vec2(intrinsics[2][0], intrinsics[2][1]);
-
-    let pos_in_obj = Vec3(
-        (Vec2(texcoords) - offset) * world_space_depth / focal_length,
-        world_space_depth,
-    );
-
-    let pos_in_world = depth_cloud_info.world_from_obj * Vec4(pos_in_obj, 1.0);
-
     var data: PointData;
-    data.pos_in_world = pos_in_world.xyz;
-    data.unresolved_radius = depth_cloud_info.point_radius_from_world_depth * world_space_depth;
-    data.color = color;
-
+    if 0.0 < world_space_depth && world_space_depth < f32max {
+        // TODO(cmc): albedo textures
+        let color = Vec4(colormap_linear(depth_cloud_info.colormap, world_space_depth / depth_cloud_info.max_depth_in_world), 1.0);
+
+        // TODO(cmc): This assumes a pinhole camera; need to support other kinds at some point.
+        let intrinsics = depth_cloud_info.depth_camera_intrinsics;
+        let focal_length = Vec2(intrinsics[0][0], intrinsics[1][1]);
+        let offset = Vec2(intrinsics[2][0], intrinsics[2][1]);
+
+        let pos_in_obj = Vec3(
+            (Vec2(texcoords) - offset) * world_space_depth / focal_length,
+            world_space_depth,
+        );
+
+        let pos_in_world = depth_cloud_info.world_from_obj * Vec4(pos_in_obj, 1.0);
+
+        data.pos_in_world = pos_in_world.xyz;
+        data.unresolved_radius = depth_cloud_info.point_radius_from_world_depth * world_space_depth;
+        data.color = color;
+    } else {
+        // Degenerate case
+        data.pos_in_world = Vec3(0.0);
+        data.unresolved_radius = 0.0;
+        data.color = Vec4(0.0);
+    }
     return data;
 }
 
@@ -104,15 +110,22 @@ fn vs_main(@builtin(vertex_index) vertex_idx: u32) -> VertexOut {
     // Compute point data (valid for the entire quad).
     let point_data = compute_point_data(quad_idx);
 
-    // Span quad
-    let quad = sphere_quad_span(vertex_idx, point_data.pos_in_world, point_data.unresolved_radius, depth_cloud_info.radius_boost_in_ui_points);
-
     var out: VertexOut;
-    out.pos_in_clip = frame.projection_from_world * Vec4(quad.pos_in_world, 1.0);
-    out.pos_in_world = quad.pos_in_world;
     out.point_pos_in_world = point_data.pos_in_world;
     out.point_color = point_data.color;
-    out.point_radius = quad.point_resolved_radius;
+
+    if 0.0 < point_data.unresolved_radius {
+        // Span quad
+        let quad = sphere_quad_span(vertex_idx, point_data.pos_in_world, point_data.unresolved_radius, depth_cloud_info.radius_boost_in_ui_points);
+        out.pos_in_clip = frame.projection_from_world * Vec4(quad.pos_in_world, 1.0);
+        out.pos_in_world = quad.pos_in_world;
+        out.point_radius = quad.point_resolved_radius;
+    } else {
+        // Degenerate case - early-out!
+        out.pos_in_clip = Vec4(0.0);
+        out.pos_in_world = Vec3(0.0);
+        out.point_radius = 0.0;
+    }
 
     return out;
 }

crates/re_renderer/shader/instanced_mesh.wgsl

@@ -55,7 +55,7 @@ fn fs_main_shaded(in: VertexOut) -> @location(0) Vec4 {
                  * material.albedo_factor.rgb
                  + in.additive_tint_rgb;
 
-    if (all(in.normal_world_space == Vec3(0.0, 0.0, 0.0))) {
+    if all(in.normal_world_space == Vec3(0.0, 0.0, 0.0)) {
         // no normal, no shading
         return Vec4(albedo, 1.0);
     } else {