Use outlines for mesh selections instead of highlight colors (#1540)

* mesh highlighting is now done via outlines
* eliminate need for computing "old" selection highlight on meshes
* blend outlines among each other in linear space

crates/re_renderer/examples/outlines.rs

@@ -79,11 +79,11 @@ impl framework::Example for Outlines {
             .unwrap();
 
         let outline_mask_large_mesh = match ((seconds_since_startup * 0.5) as u64) % 5 {
-            0 => OutlineMaskPreference::None,
-            1 => Some([1, 0]), // Same as the the y spinning mesh.
-            2 => Some([2, 0]), // Different than both meshes, outline A.
-            3 => Some([0, 1]), // Same as the the x spinning mesh.
-            4 => Some([0, 2]), // Different than both meshes, outline B.
+            0 => OutlineMaskPreference::NONE,
+            1 => OutlineMaskPreference::some(1, 0), // Same as the the y spinning mesh.
+            2 => OutlineMaskPreference::some(2, 0), // Different than both meshes, outline A.
+            3 => OutlineMaskPreference::some(0, 1), // Same as the the x spinning mesh.
+            4 => OutlineMaskPreference::some(0, 2), // Different than both meshes, outline B.
             _ => unreachable!(),
         };
 
@@ -94,12 +94,12 @@ impl framework::Example for Outlines {
                 rotation: glam::Quat::IDENTITY,
             },
             MeshProperties {
-                outline_mask: Some([1, 0]),
+                outline_mask: OutlineMaskPreference::some(1, 0),
                 position: glam::vec3(2.0, 0.0, -3.0),
                 rotation: glam::Quat::from_rotation_y(seconds_since_startup),
             },
             MeshProperties {
-                outline_mask: Some([0, 1]),
+                outline_mask: OutlineMaskPreference::some(0, 1),
                 position: glam::vec3(-2.0, 1.0, 3.0),
                 rotation: glam::Quat::from_rotation_x(seconds_since_startup),
             },

crates/re_renderer/shader/outlines/outlines_from_voronoi.wgsl

@@ -1,6 +1,7 @@
 #import <../types.wgsl>
 #import <../global_bindings.wgsl>
 #import <../screen_triangle_vertex.wgsl>
+#import <../utils/srgb.wgsl>
 
 @group(1) @binding(0)
 var voronoi_texture: texture_2d<f32>;
@@ -18,9 +19,9 @@ fn main(in: FragmentInput) -> @location(0) Vec4 {
     let resolution = Vec2(textureDimensions(voronoi_texture).xy);
     let pixel_coordinates = resolution * in.texcoord;
     let closest_positions = textureSample(voronoi_texture, nearest_sampler, in.texcoord);
-    let to_closest_a_and_b = (closest_positions - pixel_coordinates.xyxy);
-    let distance_pixel_a = length(to_closest_a_and_b.xy);
-    let distance_pixel_b = length(to_closest_a_and_b.zw);
+
+    let distance_pixel_a = distance(pixel_coordinates, closest_positions.xy);
+    let distance_pixel_b = distance(pixel_coordinates, closest_positions.zw);
 
     let sharpness = 1.0; // Fun to play around with, but not exposed yet.
     let outline_a = saturate((uniforms.outline_radius_pixel - distance_pixel_a) * sharpness);
@@ -31,7 +32,9 @@ fn main(in: FragmentInput) -> @location(0) Vec4 {
 
     // Blend B over A.
     let color = color_a * (1.0 - color_b.a) + color_b;
-    return color;
+
+    // We're going directly to an srgb-gamma target without automatic conversion.
+    return srgba_from_linear(color);
 
     // Show only the outline. Useful for debugging.
     //return Vec4(color.rgb, 1.0);

crates/re_renderer/src/renderer/mesh_renderer.rs

@@ -130,7 +130,7 @@ impl Default for MeshInstance {
             mesh: None,
             world_from_mesh: macaw::Affine3A::IDENTITY,
             additive_tint: Color32::TRANSPARENT,
-            outline_mask: None,
+            outline_mask: OutlineMaskPreference::NONE,
         }
     }
 }
@@ -221,6 +221,7 @@ impl MeshDrawData {
                         additive_tint: instance.additive_tint,
                         outline_mask: instance
                             .outline_mask
+                            .0
                             .map_or([0, 0, 0, 0], |mask| [mask[0], mask[1], 0, 0]),
                     });
                 }

crates/re_renderer/src/renderer/outlines.rs

@@ -67,7 +67,27 @@ use smallvec::smallvec;
 ///
 /// Object index 0 is special: It is the default background of each outline channel, thus rendering with it
 /// is a form of "active no outline", effectively subtracting from the outline channel.
-pub type OutlineMaskPreference = Option<[u8; 2]>;
+#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub struct OutlineMaskPreference(pub Option<[u8; 2]>);
+
+impl OutlineMaskPreference {
+    pub const NONE: OutlineMaskPreference = OutlineMaskPreference(None);
+
+    #[inline]
+    pub fn some(channel_a: u8, channel_b: u8) -> Self {
+        OutlineMaskPreference(Some([channel_a, channel_b]))
+    }
+
+    #[inline]
+    pub fn is_some(self) -> bool {
+        self.0.is_some()
+    }
+
+    #[inline]
+    pub fn is_none(self) -> bool {
+        self.0.is_none()
+    }
+}
 
 #[derive(Clone, Debug)]
 pub struct OutlineConfig {

crates/re_viewer/src/misc/selection_state.rs

@@ -1,7 +1,9 @@
 use ahash::{HashMap, HashSet};
+use egui::NumExt;
 use nohash_hasher::IntMap;
 use re_data_store::{EntityPath, LogDb};
 use re_log_types::{component_types::InstanceKey, EntityPathHash};
+use re_renderer::renderer::OutlineMaskPreference;
 
 use crate::ui::{Blueprint, HistoricalSelection, SelectionHistory, SpaceView, SpaceViewId};
 
@@ -134,12 +136,41 @@ impl<'a> OptionalSpaceViewEntityHighlight<'a> {
     }
 }
 
+#[derive(Default)]
+pub struct SpaceViewOutlineMasks {
+    overall: OutlineMaskPreference,
+    instances: ahash::HashMap<InstanceKey, OutlineMaskPreference>,
+    pub any_selection_highlight: bool,
+}
+
+#[derive(Copy, Clone)]
+pub struct OptionalSpaceViewOutlineMask<'a>(Option<&'a SpaceViewOutlineMasks>);
+
+impl<'a> OptionalSpaceViewOutlineMask<'a> {
+    pub fn index_outline_mask(&self, instance_key: InstanceKey) -> OutlineMaskPreference {
+        self.0
+            .map_or(OutlineMaskPreference::NONE, |entity_outline_mask| {
+                entity_outline_mask
+                    .instances
+                    .get(&instance_key)
+                    .cloned()
+                    .unwrap_or_default()
+                    .max(entity_outline_mask.overall)
+            })
+    }
+
+    pub fn any_selection_highlight(&self) -> bool {
+        self.0.map_or(false, |mask| mask.any_selection_highlight)
+    }
+}
+
 /// Highlights in a specific space view.
 ///
 /// Using this in bulk on many objects is faster than querying single objects.
 #[derive(Default)]
 pub struct SpaceViewHighlights {
     highlighted_entity_paths: IntMap<EntityPathHash, SpaceViewEntityHighlight>,
+    outlines_masks: IntMap<EntityPathHash, SpaceViewOutlineMasks>,
 }
 
 impl SpaceViewHighlights {
@@ -149,6 +180,13 @@ impl SpaceViewHighlights {
     ) -> OptionalSpaceViewEntityHighlight<'_> {
         OptionalSpaceViewEntityHighlight(self.highlighted_entity_paths.get(&entity_path_hash))
     }
+
+    pub fn entity_outline_mask(
+        &self,
+        entity_path_hash: EntityPathHash,
+    ) -> OptionalSpaceViewOutlineMask<'_> {
+        OptionalSpaceViewOutlineMask(self.outlines_masks.get(&entity_path_hash))
+    }
 }
 
 /// Selection and hover state
@@ -325,6 +363,20 @@ impl SelectionState {
 
         let mut highlighted_entity_paths =
             IntMap::<EntityPathHash, SpaceViewEntityHighlight>::default();
+        let mut outlines_masks = IntMap::<EntityPathHash, SpaceViewOutlineMasks>::default();
+
+        let mut selection_mask_index: u8 = 0;
+        let mut hover_mask_index: u8 = 0;
+        let mut next_selection_mask_index = || {
+            // We don't expect to overflow u8, but if we do, don't use the "background mask".
+            selection_mask_index = selection_mask_index.wrapping_add(1).at_least(1);
+            selection_mask_index
+        };
+        let mut next_hover_mask_index = || {
+            // We don't expect to overflow u8, but if we do, don't use the "background mask".
+            hover_mask_index = hover_mask_index.wrapping_add(1).at_least(1);
+            hover_mask_index
+        };
 
         for current_selection in self.selection.iter() {
             match current_selection {
@@ -333,6 +385,11 @@ impl SelectionState {
                 Item::DataBlueprintGroup(group_space_view_id, group_handle) => {
                     if *group_space_view_id == space_view_id {
                         if let Some(space_view) = space_views.get(group_space_view_id) {
+                            // Everything in the same group should receive the same selection outline.
+                            // (Due to the way outline masks work in re_renderer, we can't leave the hover channel empty)
+                            let selection_mask =
+                                OutlineMaskPreference::some(next_selection_mask_index(), 0);
+
                             space_view.data_blueprint.visit_group_entities_recursively(
                                 *group_handle,
                                 &mut |entity_path: &EntityPath| {
@@ -341,36 +398,55 @@ impl SelectionState {
                                         .or_default()
                                         .overall
                                         .selection = SelectionHighlight::SiblingSelection;
+                                    let outline_mask =
+                                        outlines_masks.entry(entity_path.hash()).or_default();
+                                    outline_mask.overall = outline_mask.overall.max(selection_mask);
+                                    outline_mask.any_selection_highlight = true;
                                 },
                             );
                         }
                     }
                 }
 
                 Item::InstancePath(selected_space_view_context, selected_instance) => {
-                    let highlight = if *selected_space_view_context == Some(space_view_id) {
-                        SelectionHighlight::Selection
-                    } else {
-                        SelectionHighlight::SiblingSelection
-                    };
-
-                    let highlighted_entity = highlighted_entity_paths
-                        .entry(selected_instance.entity_path.hash())
-                        .or_default();
-
-                    let highlight_target = if let Some(selected_index) =
-                        selected_instance.instance_key.specific_index()
                     {
-                        &mut highlighted_entity
-                            .instances
-                            .entry(selected_index)
-                            .or_default()
-                            .selection
-                    } else {
-                        &mut highlighted_entity.overall.selection
-                    };
-
-                    *highlight_target = (*highlight_target).max(highlight);
+                        let highlight = if *selected_space_view_context == Some(space_view_id) {
+                            SelectionHighlight::Selection
+                        } else {
+                            SelectionHighlight::SiblingSelection
+                        };
+
+                        let highlighted_entity = highlighted_entity_paths
+                            .entry(selected_instance.entity_path.hash())
+                            .or_default();
+                        let highlight_target = if let Some(selected_index) =
+                            selected_instance.instance_key.specific_index()
+                        {
+                            &mut highlighted_entity
+                                .instances
+                                .entry(selected_index)
+                                .or_default()
+                                .selection
+                        } else {
+                            &mut highlighted_entity.overall.selection
+                        };
+                        *highlight_target = (*highlight_target).max(highlight);
+                    }
+                    {
+                        let outline_mask = outlines_masks
+                            .entry(selected_instance.entity_path.hash())
+                            .or_default();
+                        outline_mask.any_selection_highlight = true;
+                        let outline_mask_target = if let Some(selected_index) =
+                            selected_instance.instance_key.specific_index()
+                        {
+                            outline_mask.instances.entry(selected_index).or_default()
+                        } else {
+                            &mut outline_mask.overall
+                        };
+                        *outline_mask_target = (*outline_mask_target)
+                            .max(OutlineMaskPreference::some(next_selection_mask_index(), 0));
+                    }
                 }
             };
         }
@@ -384,6 +460,10 @@ impl SelectionState {
                     // since they are truly local to a space view.
                     if *group_space_view_id == space_view_id {
                         if let Some(space_view) = space_views.get(group_space_view_id) {
+                            // Everything in the same group should receive the same selection outline.
+                            let hover_mask =
+                                OutlineMaskPreference::some(0, next_hover_mask_index());
+
                             space_view.data_blueprint.visit_group_entities_recursively(
                                 *group_handle,
                                 &mut |entity_path: &EntityPath| {
@@ -392,36 +472,55 @@ impl SelectionState {
                                         .or_default()
                                         .overall
                                         .hover = HoverHighlight::Hovered;
+                                    let mask =
+                                        outlines_masks.entry(entity_path.hash()).or_default();
+                                    mask.overall = mask.overall.max(hover_mask);
                                 },
                             );
                         }
                     }
                 }
 
                 Item::InstancePath(_, selected_instance) => {
-                    let highlighted_entity = highlighted_entity_paths
-                        .entry(selected_instance.entity_path.hash())
-                        .or_default();
-
-                    let highlight_target = if let Some(selected_index) =
-                        selected_instance.instance_key.specific_index()
                     {
-                        &mut highlighted_entity
-                            .instances
-                            .entry(selected_index)
-                            .or_default()
-                            .hover
-                    } else {
-                        &mut highlighted_entity.overall.hover
-                    };
-
-                    *highlight_target = HoverHighlight::Hovered;
+                        let highlighted_entity = highlighted_entity_paths
+                            .entry(selected_instance.entity_path.hash())
+                            .or_default();
+
+                        let highlight_target = if let Some(selected_index) =
+                            selected_instance.instance_key.specific_index()
+                        {
+                            &mut highlighted_entity
+                                .instances
+                                .entry(selected_index)
+                                .or_default()
+                                .hover
+                        } else {
+                            &mut highlighted_entity.overall.hover
+                        };
+                        *highlight_target = HoverHighlight::Hovered;
+                    }
+                    {
+                        let outlined_entity = outlines_masks
+                            .entry(selected_instance.entity_path.hash())
+                            .or_default();
+                        let outline_mask_target = if let Some(selected_index) =
+                            selected_instance.instance_key.specific_index()
+                        {
+                            outlined_entity.instances.entry(selected_index).or_default()
+                        } else {
+                            &mut outlined_entity.overall
+                        };
+                        *outline_mask_target = (*outline_mask_target)
+                            .max(OutlineMaskPreference::some(0, next_selection_mask_index()));
+                    }
                 }
             };
         }
 
         SpaceViewHighlights {
             highlighted_entity_paths,
+            outlines_masks,
         }
     }
 }

crates/re_viewer/src/ui/view_spatial/scene/mod.rs

@@ -6,7 +6,7 @@ use re_log_types::{
     component_types::{ClassId, KeypointId, Tensor},
     MeshId,
 };
-use re_renderer::{Color32, Size};
+use re_renderer::{renderer::OutlineMaskPreference, Color32, Size};
 
 use super::{eye::Eye, SpaceCamera3D, SpatialNavigationMode};
 use crate::{
@@ -55,7 +55,7 @@ pub struct MeshSource {
     // TODO(andreas): Make this Conformal3 once glow is gone?
     pub world_from_mesh: macaw::Affine3A,
     pub mesh: Arc<LoadedMesh>,
-    pub additive_tint: Color32,
+    pub outline_mask: OutlineMaskPreference,
 }
 
 pub struct Image {

crates/re_viewer/src/ui/view_spatial/scene/picking.rs

@@ -167,6 +167,7 @@ pub fn picking(
         points,
         meshes,
         depth_clouds: _, // no picking for depth clouds yet
+        any_outlines: _,
     } = primitives;
 
     picking_points(&context, &mut state, points);