Fix inputs when tracking entity (#11822)

### Related

* Fixes regression in #11788

### What

Fixes regression when tracking entity where inputs don't work correctly
when tracking an entity.


* [x] another round of manual testing on the web viewer build

Author: IsseW

crates/viewer/re_view_spatial/src/eye.rs

@@ -229,8 +229,6 @@ struct ControlEye {
     fov_y: Option<f32>,
 
     did_interact: bool,
-
-    written_radius: bool,
 }
 
 impl ControlEye {
@@ -287,22 +285,13 @@ impl ControlEye {
                 .0,
         );
 
-        let has_look_target = eye_property
-            .component_or_empty::<Position3D>(EyeControls3D::descriptor_look_target().component)?
-            .is_some();
-
-        let has_position = eye_property
-            .component_or_empty::<Position3D>(EyeControls3D::descriptor_position().component)?
-            .is_some();
-
         Ok(Self {
             pos,
             look_target,
             kind,
             speed,
             eye_up,
             did_interact: false,
-            written_radius: has_position && has_look_target,
             fov_y,
         })
     }
@@ -602,7 +591,7 @@ impl ControlEye {
     }
 }
 
-fn find_camera(space_cameras: &[SpaceCamera3D], needle: &EntityPath) -> Option<Eye> {
+pub fn find_camera(space_cameras: &[SpaceCamera3D], needle: &EntityPath) -> Option<Eye> {
     let mut found_camera = None;
 
     for camera in space_cameras {
@@ -618,52 +607,6 @@ fn find_camera(space_cameras: &[SpaceCamera3D], needle: &EntityPath) -> Option<E
     found_camera.and_then(Eye::from_camera)
 }
 
-/// Returns the new center and orbit radius for the eye.
-fn entity_target_eye(
-    entity_path: &EntityPath,
-    bounding_boxes: &SceneBoundingBoxes,
-    eye: &mut ControlEye,
-) {
-    // Note that we may want to focus on an _instance_ instead in the future:
-    // The problem with that is that there may be **many** instances (think point cloud)
-    // and they may not be consistent over time.
-    // -> we don't know the bounding box of every instance (right now)
-    // -> tracking instances over time may not be desired
-    //    (this can happen with entities as well, but is less likely).
-    //
-    // For future reference, it's also worth pointing out that for interactions in the view we
-    // already have the 3D position:
-    // if let Some(SelectedSpaceContext::ThreeD {
-    //     pos: Some(clicked_point),
-    //     ..
-    // }) = ctx.selection_state().hovered_space_context()
-
-    if let Some(entity_bbox) = bounding_boxes.per_entity.get(&entity_path.hash()) {
-        let radius = entity_bbox.centered_bounding_sphere_radius() * 1.5;
-        let orbit_radius = if radius < 0.0001 {
-            // Handle zero-sized bounding boxes:
-            (bounding_boxes.current.centered_bounding_sphere_radius() * 1.5).at_least(0.01)
-        } else if eye.written_radius {
-            eye.pos.distance(eye.look_target)
-        } else {
-            radius
-        };
-
-        let fwd = eye.fwd();
-
-        match eye.kind {
-            Eye3DKind::FirstPerson => {
-                eye.pos = entity_bbox.center();
-                eye.look_target = entity_bbox.center() + fwd;
-            }
-            Eye3DKind::Orbital => {
-                eye.look_target = entity_bbox.center();
-                eye.pos = entity_bbox.center() - fwd * orbit_radius;
-            }
-        }
-    }
-}
-
 fn ease_out(t: f32) -> f32 {
     1. - (1. - t) * (1. - t)
 }
@@ -681,6 +624,10 @@ impl EyeState {
         }
     }
 
+    fn stop_interpolation(&mut self) {
+        self.interpolation = None;
+    }
+
     /// Gets and updates the current target eye from/to the blueprint.
     fn control_and_sync_with_blueprint(
         &mut self,
@@ -702,9 +649,17 @@ impl EyeState {
 
         let mut drag_threshold = 0.0;
 
-        let tracking_entity = eye_property.component_or_empty::<re_types::components::EntityPath>(
-            EyeControls3D::descriptor_tracking_entity().component,
-        )?;
+        let tracking_entity = eye_property
+            .component_or_empty::<re_types::components::EntityPath>(
+                EyeControls3D::descriptor_tracking_entity().component,
+            )?
+            .and_then(|tracking_entity| {
+                if tracking_entity.is_empty() {
+                    None
+                } else {
+                    Some(tracking_entity)
+                }
+            });
 
         if let Some(tracking_entity) = &tracking_entity {
             let tracking_entity = EntityPath::from(tracking_entity.as_str());
@@ -717,6 +672,17 @@ impl EyeState {
         // to stop tracking.
         eye.handle_input(self, response, drag_threshold);
 
+        eye.save_to_blueprint(
+            ctx.viewer_ctx,
+            eye_property,
+            old_pos,
+            old_look_target,
+            old_eye_up,
+        );
+
+        // Handle spinning after saving to blueprint to not continuously write to the blueprint.
+        self.handle_spinning(ctx, eye_property, &mut eye)?;
+
         if let Some(tracked_eye) = self.handle_tracking_entity(
             ctx,
             eye_property,
@@ -730,17 +696,6 @@ impl EyeState {
             return Ok(tracked_eye);
         }
 
-        eye.save_to_blueprint(
-            ctx.viewer_ctx,
-            eye_property,
-            old_pos,
-            old_look_target,
-            old_eye_up,
-        );
-
-        // Handle spinning after saving to blueprint to not continuously write to the blueprint.
-        self.handle_spinning(ctx, eye_property, &mut eye)?;
-
         self.last_look_target = Some(eye.look_target);
         self.last_orbit_radius = Some(eye.pos.distance(eye.look_target));
         self.last_eye_up = Some(eye.up());
@@ -764,10 +719,13 @@ impl EyeState {
         tracking_entity: Option<&re_types::components::EntityPath>,
     ) -> Option<Eye> {
         if let Some(tracking_entity) = &tracking_entity {
+            // Don't do normal interpolation when tracking.
+            self.stop_interpolation();
             let tracking_entity = EntityPath::from(tracking_entity.as_str());
-            if self.last_tracked_entity.as_ref() == Some(&tracking_entity) {
+
+            let new_tracking = self.last_tracked_entity.as_ref() != Some(&tracking_entity);
+            if new_tracking {
                 self.last_tracked_entity = Some(tracking_entity.clone());
-                self.start_interpolation();
             }
 
             let did_eye_change = match eye.kind {
@@ -790,8 +748,69 @@ impl EyeState {
                     EyeControls3D::descriptor_tracking_entity(),
                 );
             } else {
-                self.start_interpolation();
-                entity_target_eye(&tracking_entity, bounding_boxes, eye);
+                // Note that we may want to focus on an _instance_ instead in the future:
+                // The problem with that is that there may be **many** instances (think point cloud)
+                // and they may not be consistent over time.
+                // -> we don't know the bounding box of every instance (right now)
+                // -> tracking instances over time may not be desired
+                //    (this can happen with entities as well, but is less likely).
+                //
+                // For future reference, it's also worth pointing out that for interactions in the view we
+                // already have the 3D position:
+                // if let Some(SelectedSpaceContext::ThreeD {
+                //     pos: Some(clicked_point),
+                //     ..
+                // }) = ctx.selection_state().hovered_space_context()
+
+                if let Some(entity_bbox) = bounding_boxes.per_entity.get(&tracking_entity.hash()) {
+                    // If we're tracking something new, set the current position & look target to the correct view.
+                    if new_tracking {
+                        let fwd = eye.fwd();
+                        let radius = entity_bbox.centered_bounding_sphere_radius() * 1.5;
+                        let radius = if radius < 0.0001 {
+                            // Handle zero-sized bounding boxes:
+                            (bounding_boxes.current.centered_bounding_sphere_radius() * 1.5)
+                                .at_least(0.02)
+                        } else {
+                            radius
+                        };
+                        eye.pos = eye.look_target - fwd * radius;
+                        // Force write of pos and look target to not use fallbacks for that.
+                        eye_property.save_blueprint_component(
+                            ctx.viewer_ctx,
+                            &EyeControls3D::descriptor_position(),
+                            &Position3D::from(eye.pos),
+                        );
+
+                        eye_property.save_blueprint_component(
+                            ctx.viewer_ctx,
+                            &EyeControls3D::descriptor_look_target(),
+                            &Position3D::from(eye.look_target),
+                        );
+                    }
+
+                    let orbit_radius = eye.pos.distance(eye.look_target);
+
+                    let pos = entity_bbox.center();
+
+                    let fwd = eye.fwd();
+
+                    match eye.kind {
+                        Eye3DKind::FirstPerson => {
+                            eye.pos = pos;
+                            eye.look_target = pos + fwd;
+                        }
+                        Eye3DKind::Orbital => {
+                            eye.look_target = pos;
+                            eye.pos = pos - fwd * orbit_radius;
+                        }
+                    }
+                }
+
+                self.last_look_target = Some(eye.look_target);
+                self.last_eye_up = Some(eye.eye_up);
+                self.last_orbit_radius = Some(eye.pos.distance(eye.look_target));
+
                 return Some(eye.get_eye());
             }
         } else {
@@ -841,6 +860,57 @@ impl EyeState {
         Ok(())
     }
 
+    pub fn focus_entity(
+        &self,
+        ctx: &ViewContext<'_>,
+        space_cameras: &[SpaceCamera3D],
+        bounding_boxes: &SceneBoundingBoxes,
+        eye_property: &ViewProperty,
+        focused_entity: &EntityPath,
+    ) -> Result<(), ViewPropertyQueryError> {
+        let mut eye = ControlEye::from_blueprint(ctx, eye_property, self.fov_y)?;
+        eye.did_interact = true;
+        let ControlEye {
+            pos: old_pos,
+            look_target: old_look_target,
+            eye_up: old_eye_up,
+            ..
+        } = eye;
+        // Focusing cameras is not something that happens now, since those are always tracked.
+        if let Some(target_eye) = find_camera(space_cameras, focused_entity) {
+            eye.pos = target_eye.pos_in_world();
+            eye.look_target = target_eye.pos_in_world() + target_eye.forward_in_world();
+            eye.eye_up = target_eye.world_from_rub_view.transform_vector3(Vec3::Y);
+        } else if let Some(entity_bbox) = bounding_boxes.per_entity.get(&focused_entity.hash()) {
+            let fwd = self
+                .last_eye
+                .map(|eye| eye.forward_in_world())
+                .unwrap_or_else(|| Vec3::splat(f32::sqrt(1.0 / 3.0)));
+            let radius = entity_bbox.centered_bounding_sphere_radius() * 1.5;
+            let radius = if radius < 0.0001 {
+                // Handle zero-sized bounding boxes:
+                (bounding_boxes.current.centered_bounding_sphere_radius() * 1.5).at_least(0.02)
+            } else {
+                radius
+            };
+            eye.look_target = entity_bbox.center();
+            eye.pos = eye.look_target - fwd * radius;
+        }
+
+        eye.save_to_blueprint(
+            ctx.viewer_ctx,
+            eye_property,
+            old_pos,
+            old_look_target,
+            old_eye_up,
+        );
+
+        eye_property
+            .clear_blueprint_component(ctx.viewer_ctx, EyeControls3D::descriptor_tracking_entity());
+
+        Ok(())
+    }
+
     pub fn update(
         &mut self,
         ctx: &ViewContext<'_>,
@@ -893,13 +963,10 @@ impl EyeState {
 
             interpolation.start.lerp(&target_eye, t)
         } else {
+            self.stop_interpolation();
             target_eye
         };
 
-        if eye == target_eye {
-            self.interpolation = None;
-        }
-
         self.last_eye = Some(eye);
 
         Ok(eye)

crates/viewer/re_view_spatial/src/ui_3d.rs

@@ -27,6 +27,7 @@ use re_viewport_blueprint::ViewProperty;
 
 use crate::{
     SpatialView3D,
+    eye::find_camera,
     space_camera_3d::SpaceCamera3D,
     ui::{SpatialViewState, create_labels},
     view_kind::SpatialViewKind,
@@ -313,13 +314,26 @@ impl SpatialView3D {
             };
 
             if let Some(entity_path) = focused_entity {
-                if state.last_tracked_entity() != Some(entity_path) {
-                    eye_property.save_blueprint_component(
-                        ctx,
-                        &EyeControls3D::descriptor_tracking_entity(),
-                        &re_types::components::EntityPath::from(entity_path),
-                    );
-                    state.state_3d.eye_state.last_interaction_time = Some(ui.time());
+                if ui.ctx().input(|i| i.modifiers.alt)
+                    || find_camera(space_cameras, entity_path).is_some()
+                {
+                    if state.last_tracked_entity() != Some(entity_path) {
+                        eye_property.save_blueprint_component(
+                            ctx,
+                            &EyeControls3D::descriptor_tracking_entity(),
+                            &re_types::components::EntityPath::from(entity_path),
+                        );
+                        state.state_3d.eye_state.last_interaction_time = Some(ui.time());
+                    }
+                } else {
+                    state.state_3d.eye_state.start_interpolation();
+                    state.state_3d.eye_state.focus_entity(
+                        &self.view_context(ctx, query.view_id, state),
+                        space_cameras,
+                        &state.bounding_boxes,
+                        &eye_property,
+                        entity_path,
+                    )?;
                 }
             }