Finalize move of SpatialSpaceView to SpaceViewClass trait framework

crates/re_data_store/src/entity_properties.rs

@@ -16,17 +16,24 @@ pub struct EntityPropertyMap {
 
 #[cfg(feature = "serde")]
 impl EntityPropertyMap {
+    #[inline]
     pub fn get(&self, entity_path: &EntityPath) -> EntityProperties {
         self.props.get(entity_path).cloned().unwrap_or_default()
     }
 
+    #[inline]
     pub fn set(&mut self, entity_path: EntityPath, prop: EntityProperties) {
         if prop == EntityProperties::default() {
             self.props.remove(&entity_path); // save space
         } else {
             self.props.insert(entity_path, prop);
         }
     }
+
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = (&EntityPath, &EntityProperties)> {
+        self.props.iter()
+    }
 }
 
 // ----------------------------------------------------------------------------

crates/re_renderer/examples/depth_cloud.rs

@@ -167,7 +167,7 @@ impl RenderDepthClouds {
             ..
         } = self;
 
-        let world_from_obj = glam::Mat4::from_scale(glam::Vec3::splat(*scale));
+        let world_from_obj = glam::Affine3A::from_scale(glam::Vec3::splat(*scale));
 
         let depth_cloud_draw_data = DepthCloudDrawData::new(
             re_ctx,

crates/re_renderer/src/renderer/depth_cloud.rs

@@ -102,7 +102,7 @@ mod gpu_data {
 
 pub struct DepthCloud {
     /// The extrinsics of the camera used for the projection.
-    pub world_from_obj: glam::Mat4,
+    pub world_from_obj: glam::Affine3A,
 
     /// The intrinsics of the camera used for the projection.
     ///
@@ -159,7 +159,7 @@ impl DepthCloud {
         for corner in corners {
             let depth = corner.z;
             let pos_in_obj = ((corner.truncate() - offset) * depth / focal_length).extend(depth);
-            let pos_in_world = self.world_from_obj.project_point3(pos_in_obj);
+            let pos_in_world = self.world_from_obj.transform_point3(pos_in_obj);
             bbox.extend(pos_in_world);
         }
 

crates/re_space_view/src/lib.rs

@@ -7,8 +7,10 @@ mod data_blueprint;
 mod empty_scene_context;
 mod empty_space_view_state;
 mod screenshot;
+mod unreachable_transform_reason;
 
 pub use data_blueprint::{DataBlueprintGroup, DataBlueprintTree};
 pub use empty_scene_context::EmptySceneContext;
 pub use empty_space_view_state::EmptySpaceViewState;
 pub use screenshot::ScreenshotMode;
+pub use unreachable_transform_reason::UnreachableTransformReason;

crates/re_space_view/src/unreachable_transform_reason.rs

@@ -0,0 +1,31 @@
+#[derive(Clone, Copy)]
+pub enum UnreachableTransformReason {
+    /// `SpaceInfoCollection` is outdated and can't find a corresponding space info for the given path.
+    ///
+    /// If at all, this should only happen for a single frame until space infos are rebuilt.
+    UnknownSpaceInfo,
+
+    /// More than one pinhole camera between this and the reference space.
+    NestedPinholeCameras,
+
+    /// Exiting out of a space with a pinhole camera that doesn't have a resolution is not supported.
+    InversePinholeCameraWithoutResolution,
+
+    /// Unknown transform between this and the reference space.
+    DisconnectedSpace,
+}
+
+impl std::fmt::Display for UnreachableTransformReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::UnknownSpaceInfo =>
+                "Can't determine transform because internal data structures are not in a valid state. Please file an issue on https://github.com/rerun-io/rerun/",
+            Self::NestedPinholeCameras =>
+                "Can't display entities under nested pinhole cameras.",
+            Self::DisconnectedSpace =>
+                "Can't display entities that are in an explicitly disconnected space.",
+            Self::InversePinholeCameraWithoutResolution =>
+                "Can't display entities that would require inverting a pinhole camera without a specified resolution.",
+        })
+    }
+}

crates/re_space_view_spatial/src/axis_lines.rs

@@ -0,0 +1,69 @@
+use egui::Color32;
+use re_data_store::EntityPath;
+use re_log_types::InstanceKey;
+use re_renderer::LineStripSeriesBuilder;
+
+const AXIS_COLOR_X: Color32 = Color32::from_rgb(255, 25, 25);
+const AXIS_COLOR_Y: Color32 = Color32::from_rgb(0, 240, 0);
+const AXIS_COLOR_Z: Color32 = Color32::from_rgb(80, 80, 255);
+
+pub fn add_axis_lines(
+    line_builder: &mut LineStripSeriesBuilder,
+    transform: macaw::IsoTransform,
+    ent_path: Option<&EntityPath>,
+    axis_length: f32,
+) {
+    use re_renderer::renderer::LineStripFlags;
+
+    // TODO(andreas): It would be nice if could display the semantics (left/right/up) as a tooltip on hover.
+    let line_radius = re_renderer::Size::new_scene(axis_length * 0.05);
+    let origin = transform.translation();
+
+    let mut line_batch =
+        line_builder
+            .batch("origin axis")
+            .picking_object_id(re_renderer::PickingLayerObjectId(
+                ent_path.map_or(0, |p| p.hash64()),
+            ));
+    let picking_instance_id = re_renderer::PickingLayerInstanceId(InstanceKey::SPLAT.0);
+
+    line_batch
+        .add_segment(
+            origin,
+            origin + transform.transform_vector3(glam::Vec3::X) * axis_length,
+        )
+        .radius(line_radius)
+        .color(AXIS_COLOR_X)
+        .flags(
+            LineStripFlags::FLAG_COLOR_GRADIENT
+                | LineStripFlags::FLAG_CAP_END_TRIANGLE
+                | LineStripFlags::FLAG_CAP_START_ROUND,
+        )
+        .picking_instance_id(picking_instance_id);
+    line_batch
+        .add_segment(
+            origin,
+            origin + transform.transform_vector3(glam::Vec3::Y) * axis_length,
+        )
+        .radius(line_radius)
+        .color(AXIS_COLOR_Y)
+        .flags(
+            LineStripFlags::FLAG_COLOR_GRADIENT
+                | LineStripFlags::FLAG_CAP_END_TRIANGLE
+                | LineStripFlags::FLAG_CAP_START_ROUND,
+        )
+        .picking_instance_id(picking_instance_id);
+    line_batch
+        .add_segment(
+            origin,
+            origin + transform.transform_vector3(glam::Vec3::Z) * axis_length,
+        )
+        .radius(line_radius)
+        .color(AXIS_COLOR_Z)
+        .flags(
+            LineStripFlags::FLAG_COLOR_GRADIENT
+                | LineStripFlags::FLAG_CAP_END_TRIANGLE
+                | LineStripFlags::FLAG_CAP_START_ROUND,
+        )
+        .picking_instance_id(picking_instance_id);
+}

crates/re_space_view_spatial/src/lib.rs

@@ -2,6 +2,7 @@
 //!
 //! Space Views that show entities in a 2D or 3D spatial relationship.
 
+mod axis_lines;
 mod eye;
 mod instance_hash_conversions;
 mod mesh_cache;
@@ -12,10 +13,5 @@ mod space_view_class;
 mod ui;
 mod ui_2d;
 mod ui_3d;
-mod ui_renderer_bridge;
 
-// TODO(andreas) should only make the main type public
-pub use space_view_class::SpatialSpaceViewClass;
-
-pub use scene::{SceneSpatial, TransformContext, UnreachableTransform};
-pub use ui::{SpatialNavigationMode, ViewSpatialState};
+pub use space_view_class::SpatialSpaceView;

crates/re_space_view_spatial/src/scene/contexts/depth_offsets.rs

@@ -2,7 +2,7 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use nohash_hasher::IntMap;
 use re_components::DrawOrder;
-use re_log_types::{Component, EntityPathHash};
+use re_log_types::{Component, EntityPath, EntityPathHash};
 use re_viewer_context::{ArchetypeDefinition, SceneContextPart};
 
 /// Context for creating a mapping from [`DrawOrder`] to [`re_renderer::DepthOffset`].
@@ -118,3 +118,9 @@ impl SceneContextPart for EntityDepthOffsets {
             .collect();
     }
 }
+
+impl EntityDepthOffsets {
+    pub fn get(&self, ent_path: &EntityPath) -> Option<re_renderer::DepthOffset> {
+        self.per_entity.get(&ent_path.hash()).cloned()
+    }
+}

crates/re_space_view_spatial/src/scene/contexts/mod.rs

@@ -1,5 +1,6 @@
 mod annotation_context;
 mod depth_offsets;
+mod non_interactive_entities;
 mod shared_render_builders;
 mod transform_context;
 
@@ -8,20 +9,23 @@ use std::sync::atomic::AtomicUsize;
 pub use annotation_context::AnnotationSceneContext;
 pub use depth_offsets::EntityDepthOffsets;
 pub use shared_render_builders::SharedRenderBuilders;
-pub use transform_context::{TransformContext, UnreachableTransform};
+pub use transform_context::TransformContext;
 
 // -----------------------------------------------------------------------------
 
 use re_log_types::EntityPath;
 use re_renderer::DepthOffset;
 use re_viewer_context::{Annotations, SceneContext};
 
+use self::non_interactive_entities::NonInteractiveEntities;
+
 #[derive(Default)]
 pub struct SpatialSceneContext {
     pub transforms: TransformContext,
     pub depth_offsets: EntityDepthOffsets,
     pub annotations: AnnotationSceneContext,
     pub shared_render_builders: SharedRenderBuilders,
+    pub non_interactive_entities: NonInteractiveEntities,
 
     pub num_primitives: AtomicUsize,
     pub num_3d_primitives: AtomicUsize,
@@ -34,6 +38,7 @@ impl SceneContext for SpatialSceneContext {
             depth_offsets,
             annotations,
             shared_render_builders,
+            non_interactive_entities,
             num_3d_primitives: _,
             num_primitives: _,
         } = self;
@@ -42,6 +47,7 @@ impl SceneContext for SpatialSceneContext {
             depth_offsets,
             annotations,
             shared_render_builders,
+            non_interactive_entities,
         ]
     }
 

crates/re_space_view_spatial/src/scene/contexts/non_interactive_entities.rs

@@ -0,0 +1,36 @@
+use nohash_hasher::IntSet;
+use re_log_types::EntityPathHash;
+use re_viewer_context::SceneContextPart;
+
+/// List of all non-interactive entities for lookup during picking evaluation.
+///
+/// TODO(wumpf/jleibs): This is a temporary solution until the picking code can query propagated blueprint properties directly.
+#[derive(Default)]
+pub struct NonInteractiveEntities(pub IntSet<EntityPathHash>);
+
+impl SceneContextPart for NonInteractiveEntities {
+    fn archetypes(&self) -> Vec<re_viewer_context::ArchetypeDefinition> {
+        Vec::new()
+    }
+
+    fn populate(
+        &mut self,
+        _ctx: &mut re_viewer_context::ViewerContext<'_>,
+        query: &re_viewer_context::SceneQuery<'_>,
+        _space_view_state: &dyn re_viewer_context::SpaceViewState,
+    ) {
+        re_tracing::profile_function!();
+
+        self.0 = query
+            .entity_props_map
+            .iter()
+            .filter_map(|(entity_path, props)| {
+                if props.interactive {
+                    None
+                } else {
+                    Some(entity_path.hash())
+                }
+            })
+            .collect();
+    }
+}

crates/re_space_view_spatial/src/scene/contexts/shared_render_builders.rs

@@ -1,5 +1,5 @@
 use parking_lot::{Mutex, MutexGuard};
-use re_renderer::{LineStripSeriesBuilder, PointCloudBuilder};
+use re_renderer::{LineStripSeriesBuilder, PointCloudBuilder, RenderContext};
 use re_viewer_context::{ArchetypeDefinition, SceneContextPart};
 
 use crate::scene::{
@@ -22,6 +22,32 @@ impl SharedRenderBuilders {
     pub fn points(&self) -> MutexGuard<'_, PointCloudBuilder> {
         self.points.as_ref().unwrap().lock()
     }
+
+    pub fn queuable_draw_data(
+        &mut self,
+        render_ctx: &mut RenderContext,
+    ) -> Vec<re_renderer::QueueableDrawData> {
+        let mut result = Vec::new();
+        result.extend(self.lines.take().and_then(
+            |l| match l.into_inner().to_draw_data(render_ctx) {
+                Ok(d) => Some(d.into()),
+                Err(err) => {
+                    re_log::error_once!("Failed to build line strip draw data: {err}");
+                    None
+                }
+            },
+        ));
+        result.extend(self.points.take().and_then(
+            |l| match l.into_inner().to_draw_data(render_ctx) {
+                Ok(d) => Some(d.into()),
+                Err(err) => {
+                    re_log::error_once!("Failed to build point draw data: {err}");
+                    None
+                }
+            },
+        ));
+        result
+    }
 }
 
 impl SceneContextPart for SharedRenderBuilders {