Cameras are now handled like other scene parts (#738)

* "the camera" is now consistently at the projection matrix
   * this is what is shown when a camera is selected, Fixes #638
* It is not necessary to define a rigid transform to define a camera - the camera just picks the rigid transform at the place where it sits in the hierarchy, i.e. it defaults to identity and transforms can be higher up in the tree above the projection transform
* `SpaceCoordinates` default now to RUB and can be logged anywhere at or above the projection matrix of a camera, Fixes #731

crates/re_viewer/src/misc/space_info.rs

@@ -79,32 +79,6 @@ impl SpaceInfo {
         }
     }
 
-    /// Recursively gather all descendants that have no or only a rigid transform.
-    pub fn descendants_with_rigid_or_no_transform(
-        &self,
-        spaces_info: &SpacesInfo,
-    ) -> IntSet<ObjPath> {
-        fn gather_rigidly_transformed_children(
-            space: &SpaceInfo,
-            spaces_info: &SpacesInfo,
-            objects: &mut IntSet<ObjPath>,
-        ) {
-            objects.extend(space.descendants_without_transform.iter().cloned());
-
-            for (child_path, transform) in &space.child_spaces {
-                if let re_log_types::Transform::Rigid3(_) = transform {
-                    if let Some(child_space) = spaces_info.get(child_path) {
-                        gather_rigidly_transformed_children(child_space, spaces_info, objects);
-                    }
-                }
-            }
-        }
-
-        let mut objects = IntSet::default();
-        gather_rigidly_transformed_children(self, spaces_info, &mut objects);
-        objects
-    }
-
     pub fn parent<'a>(&self, spaces_info: &'a SpacesInfo) -> Option<(&'a SpaceInfo, &Transform)> {
         self.parent.as_ref().and_then(|(parent_path, transform)| {
             spaces_info.get(parent_path).map(|space| (space, transform))
@@ -279,7 +253,7 @@ fn query_view_coordinates_arrow(
     view_coords
 }
 
-fn query_view_coordinates(
+pub fn query_view_coordinates(
     obj_db: &ObjDb,
     time_ctrl: &TimeControl,
     obj_path: &ObjPath,

crates/re_viewer/src/ui/space_view.rs

@@ -1,3 +1,5 @@
+use std::collections::BTreeMap;
+
 use re_data_store::{InstanceId, ObjPath, ObjectTree, ObjectsProperties, TimeInt};
 
 use nohash_hasher::IntSet;
@@ -65,29 +67,33 @@ pub(crate) struct SpaceView {
 
     /// Set to `false` the first time the user messes around with the list of queried objects.
     pub allow_auto_adding_more_object: bool,
+
+    /// Transforms seen last frame, renewed every frame.
+    /// TODO(andreas): This should probably live on `SpacesInfo` and created there lazily?
+    ///                 See also [#741](https://github.com/rerun-io/rerun/issues/741)
+    #[serde(skip)]
+    cached_transforms: TransformCache,
 }
 
 impl SpaceView {
     pub fn new(
-        ctx: &ViewerContext<'_>,
         category: ViewCategory,
         space_info: &SpaceInfo,
-        spaces_info: &SpacesInfo,
-        default_spatial_naviation_mode: SpatialNavigationMode,
+        queried_objects: IntSet<ObjPath>,
+        default_spatial_navigation_mode: SpatialNavigationMode,
+        initial_transforms: TransformCache,
     ) -> Self {
         let mut view_state = ViewState::default();
 
         if category == ViewCategory::Spatial {
-            view_state.state_spatial.nav_mode = default_spatial_naviation_mode;
+            view_state.state_spatial.nav_mode = default_spatial_navigation_mode;
         }
 
         let root_path = space_info.path.iter().next().map_or_else(
             || space_info.path.clone(),
             |c| ObjPath::from(vec![c.to_owned()]),
         );
 
-        let queried_objects = Self::default_queried_objects(ctx, category, space_info, spaces_info);
-
         let name = if queried_objects.len() == 1 {
             // a single object in this space-view - name the space after it
             let obj_path = queried_objects.iter().next().unwrap();
@@ -110,43 +116,86 @@ impl SpaceView {
             view_state,
             category,
             allow_auto_adding_more_object: true,
+            cached_transforms: initial_transforms,
         }
     }
 
-    /// List of objects a space view queries by default.
+    /// List of objects a space view queries by default for a given category.
+    ///
+    /// These are all objects in the given space which have the requested category and are reachable by a transform.
     pub fn default_queried_objects(
         ctx: &ViewerContext<'_>,
         category: ViewCategory,
-        root_space: &SpaceInfo,
+        space_info: &SpaceInfo,
         spaces_info: &SpacesInfo,
+        transforms: &TransformCache,
     ) -> IntSet<ObjPath> {
         crate::profile_function!();
 
         let timeline = ctx.rec_cfg.time_ctrl.timeline();
         let log_db = &ctx.log_db;
 
-        root_space
-            .descendants_with_rigid_or_no_transform(spaces_info)
-            .iter()
-            .cloned()
-            .filter(|obj_path| categorize_obj_path(timeline, log_db, obj_path).contains(category))
-            .collect()
+        let mut objects = IntSet::default();
+        space_info.visit_descendants(spaces_info, &mut |space| {
+            objects.extend(
+                space
+                    .descendants_without_transform
+                    .iter()
+                    .filter(|obj_path| {
+                        transforms.reference_from_obj(obj_path).is_reachable()
+                            && categorize_obj_path(timeline, log_db, obj_path).contains(category)
+                    })
+                    .cloned(),
+            );
+        });
+        objects
+    }
+
+    /// List of objects a space view queries by default for all any possible category.
+    pub fn default_queried_objects_by_category(
+        ctx: &ViewerContext<'_>,
+        space_info: &SpaceInfo,
+        transforms: &TransformCache,
+    ) -> BTreeMap<ViewCategory, IntSet<ObjPath>> {
+        let timeline = ctx.rec_cfg.time_ctrl.timeline();
+        let log_db = &ctx.log_db;
+
+        let mut groups: BTreeMap<ViewCategory, IntSet<ObjPath>> = Default::default();
+        for obj_path in transforms.objects_with_reachable_transform() {
+            if obj_path == &space_info.path || obj_path.is_descendant_of(&space_info.path) {
+                for category in categorize_obj_path(timeline, log_db, obj_path) {
+                    groups.entry(category).or_default().insert(obj_path.clone());
+                }
+            }
+        }
+        groups
     }
 
     pub fn on_frame_start(&mut self, ctx: &mut ViewerContext<'_>, spaces_info: &SpacesInfo) {
         self.data_blueprint.on_frame_start();
 
-        if !self.allow_auto_adding_more_object {
-            return;
-        }
-        let Some(space) = spaces_info.get(&self.space_path) else {
+        let Some(space_info) =  spaces_info.get(&self.space_path) else {
             return;
         };
-        // Add objects that have been logged since we were created
-        self.queried_objects =
-            Self::default_queried_objects(ctx, self.category, space, spaces_info);
-        self.data_blueprint
-            .insert_objects_according_to_hierarchy(&self.queried_objects, &self.space_path);
+
+        self.cached_transforms = TransformCache::determine_transforms(
+            spaces_info,
+            space_info,
+            self.data_blueprint.data_blueprints_projected(),
+        );
+
+        if self.allow_auto_adding_more_object {
+            // Add objects that have been logged since we were created
+            self.queried_objects = Self::default_queried_objects(
+                ctx,
+                self.category,
+                space_info,
+                spaces_info,
+                &self.cached_transforms,
+            );
+            self.data_blueprint
+                .insert_objects_according_to_hierarchy(&self.queried_objects, &self.space_path);
+        }
     }
 
     pub fn selection_ui(&mut self, ctx: &mut ViewerContext<'_>, ui: &mut egui::Ui) {
@@ -380,7 +429,6 @@ impl SpaceView {
         &mut self,
         ctx: &mut ViewerContext<'_>,
         ui: &mut egui::Ui,
-        spaces_info: &SpacesInfo,
         reference_space_info: &SpaceInfo,
         latest_at: TimeInt,
     ) {
@@ -413,26 +461,17 @@ impl SpaceView {
             }
 
             ViewCategory::Spatial => {
-                let Some(reference_space) = spaces_info.get(&self.space_path) else {
-                    return;
-                };
-                let transforms = TransformCache::determine_transforms(
-                    spaces_info,
-                    reference_space,
-                    self.data_blueprint.data_blueprints_projected(),
-                );
                 let mut scene = view_spatial::SceneSpatial::default();
                 scene.load_objects(
                     ctx,
                     &query,
-                    &transforms,
+                    &self.cached_transforms,
                     self.view_state.state_spatial.hovered_instance_hash(),
                 );
                 self.view_state.ui_spatial(
                     ctx,
                     ui,
                     &self.space_path,
-                    spaces_info,
                     reference_space_info,
                     scene,
                     self.data_blueprint.data_blueprints_projected(),
@@ -477,27 +516,18 @@ pub(crate) struct ViewState {
 
 impl ViewState {
     // TODO(andreas): split into smaller parts, some of it shouldn't be part of the ui path and instead scene loading.
-    #[allow(clippy::too_many_arguments)]
     fn ui_spatial(
         &mut self,
         ctx: &mut ViewerContext<'_>,
         ui: &mut egui::Ui,
         space: &ObjPath,
-        spaces_info: &SpacesInfo,
         space_info: &SpaceInfo,
         scene: view_spatial::SceneSpatial,
         obj_properties: &ObjectsProperties,
     ) {
         ui.vertical(|ui| {
-            self.state_spatial.view_spatial(
-                ctx,
-                ui,
-                space,
-                scene,
-                spaces_info,
-                space_info,
-                obj_properties,
-            );
+            self.state_spatial
+                .view_spatial(ctx, ui, space, scene, space_info, obj_properties);
         });
     }
 

crates/re_viewer/src/ui/transform_cache.rs

@@ -1,15 +1,15 @@
 use nohash_hasher::IntMap;
 use re_data_store::{ObjPath, ObjectsProperties};
-use re_log_types::ObjPathHash;
 
 use crate::misc::space_info::{SpaceInfo, SpacesInfo};
 
 /// Provides transforms from an object to a chosen reference space for all elements in the scene.
 ///
 /// The renderer then uses this reference space as its world space,
 /// making world and reference space equivalent for a given space view.
+#[derive(Clone, Default)]
 pub struct TransformCache {
-    reference_from_obj_per_object: IntMap<ObjPathHash, ReferenceFromObjTransform>,
+    reference_from_obj_per_object: IntMap<ObjPath, ReferenceFromObjTransform>,
 }
 
 #[derive(Clone, Copy)]
@@ -33,6 +33,15 @@ pub enum ReferenceFromObjTransform {
     Reachable(glam::Mat4),
 }
 
+impl ReferenceFromObjTransform {
+    pub fn is_reachable(&self) -> bool {
+        match self {
+            ReferenceFromObjTransform::Unreachable(_) => false,
+            ReferenceFromObjTransform::Reachable(_) => true,
+        }
+    }
+}
+
 impl TransformCache {
     /// Determines transforms for all objects relative to a `reference_space`.
     /// I.e. the resulting transforms are "reference from scene"
@@ -149,7 +158,7 @@ impl TransformCache {
             space
                 .descendants_without_transform
                 .iter()
-                .map(|obj| (*obj.hash(), transform.clone())),
+                .map(|obj| (obj.clone(), transform.clone())),
         );
     }
 
@@ -242,10 +251,19 @@ impl TransformCache {
     /// This is typically used as the "world space" for the renderer in a given frame.
     pub fn reference_from_obj(&self, obj_path: &ObjPath) -> ReferenceFromObjTransform {
         self.reference_from_obj_per_object
-            .get(obj_path.hash())
+            .get(obj_path)
             .cloned()
             .unwrap_or(ReferenceFromObjTransform::Unreachable(
                 UnreachableTransformReason::Unconnected,
             ))
     }
+
+    pub fn objects_with_reachable_transform(&self) -> impl Iterator<Item = &ObjPath> {
+        self.reference_from_obj_per_object
+            .iter()
+            .filter_map(|(obj, transform)| match transform {
+                ReferenceFromObjTransform::Unreachable(_) => None,
+                ReferenceFromObjTransform::Reachable(_) => Some(obj),
+            })
+    }
 }

crates/re_viewer/src/ui/view_category.rs

@@ -1,7 +1,4 @@
-use std::collections::BTreeMap;
-
-use nohash_hasher::IntSet;
-use re_data_store::{LogDb, ObjPath, Timeline};
+use re_data_store::{query_transform, LogDb, ObjPath, Timeline};
 use re_log_types::DataPath;
 
 #[derive(
@@ -48,7 +45,13 @@ pub fn categorize_obj_path(
 ) -> ViewCategorySet {
     crate::profile_function!();
 
-    let Some(obj_type) = log_db.obj_db.types.get(obj_path.obj_type_path())  else {
+    let Some(obj_type) = log_db.obj_db.types.get(obj_path.obj_type_path()) else {
+        // If it has a transform we might want to visualize it in space
+        // (as of writing we do that only for projections, i.e. cameras, but visualizations for rigid transforms may be added)
+        if query_transform(&log_db.obj_db, timeline, obj_path, Some(i64::MAX)).is_some() {
+            return ViewCategory::Spatial.into();
+        }
+
         return ViewCategorySet::default();
     };
 
@@ -97,17 +100,3 @@ pub fn categorize_obj_path(
         }
     }
 }
-
-pub fn group_by_category<'a>(
-    timeline: &Timeline,
-    log_db: &LogDb,
-    objects: impl Iterator<Item = &'a ObjPath>,
-) -> BTreeMap<ViewCategory, IntSet<ObjPath>> {
-    let mut groups: BTreeMap<ViewCategory, IntSet<ObjPath>> = Default::default();
-    for obj_path in objects {
-        for category in categorize_obj_path(timeline, log_db, obj_path) {
-            groups.entry(category).or_default().insert(obj_path.clone());
-        }
-    }
-    groups
-}