Title bar: View menu (zoom, fit all, isolation, layouts) + Help links + phosphor icons

Author: RenzoraEngine

crates/renzora/src/core/mod.rs

@@ -824,6 +824,24 @@ pub struct OpenCodeEditorFile {
     pub path: std::path::PathBuf,
 }
 
+/// One-shot: request a viewport camera operation from the View menu.
+///
+/// Consumed by the camera controller in `renzora_camera`.
+#[derive(Resource, Clone, Copy, Debug)]
+pub enum CameraViewRequest {
+    ZoomIn,
+    ZoomOut,
+    ResetZoom,
+    FrameAll,
+}
+
+/// Toggle: when active, only the selected entity (and its ancestors/descendants)
+/// remain visible in the viewport. Toggled from the View menu.
+#[derive(Resource, Default)]
+pub struct IsolationMode {
+    pub active: bool,
+}
+
 /// Tracks whether a UI text input has keyboard focus.
 ///
 /// When `true`, keyboard shortcuts should not fire so typing is not interrupted.

crates/renzora_camera/src/lib.rs

@@ -172,6 +172,7 @@ impl Plugin for CameraPlugin {
                 handle_view_angle_keys,
                 focus_selected,
                 frame_all,
+                handle_camera_view_request,
                 camera_to_cursor,
                 camera_controller,
                 apply_nav_overlay,
@@ -374,6 +375,56 @@ fn frame_all(
     pivot_lock.0 = true;
 }
 
+/// Consume one-shot `CameraViewRequest`s from the View menu (Zoom In/Out,
+/// Reset Zoom, Fit All) and apply them to the orbit camera.
+fn handle_camera_view_request(
+    mut commands: Commands,
+    request: Option<Res<renzora::core::CameraViewRequest>>,
+    play_mode: Option<Res<renzora::core::PlayModeState>>,
+    mut orbit: ResMut<OrbitCameraState>,
+    mut pivot_lock: ResMut<PivotLock>,
+    meshes: Query<&GlobalTransform, (With<Mesh3d>, Without<EditorCamera>, Without<PlayModeCamera>)>,
+) {
+    let Some(request) = request else { return };
+    if play_mode.as_ref().map_or(false, |pm| pm.is_in_play_mode()) {
+        commands.remove_resource::<renzora::core::CameraViewRequest>();
+        return;
+    }
+    match *request {
+        renzora::core::CameraViewRequest::ZoomIn => {
+            let delta = orbit.distance * 0.2;
+            orbit.zoom(delta);
+        }
+        renzora::core::CameraViewRequest::ZoomOut => {
+            let delta = -orbit.distance * 0.2;
+            orbit.zoom(delta);
+        }
+        renzora::core::CameraViewRequest::ResetZoom => {
+            orbit.distance = OrbitCameraState::default().distance;
+        }
+        renzora::core::CameraViewRequest::FrameAll => {
+            let mut count = 0u32;
+            let mut centroid = Vec3::ZERO;
+            for gt in &meshes {
+                centroid += gt.translation();
+                count += 1;
+            }
+            if count > 0 {
+                centroid /= count as f32;
+                let mut max_dist = 1.0f32;
+                for gt in &meshes {
+                    let d = gt.translation().distance(centroid);
+                    if d > max_dist { max_dist = d; }
+                }
+                orbit.focus = centroid;
+                orbit.distance = (max_dist * 2.5).max(3.0);
+                pivot_lock.0 = true;
+            }
+        }
+    }
+    commands.remove_resource::<renzora::core::CameraViewRequest>();
+}
+
 /// Move the camera's orbit pivot to the point under the mouse cursor (ground
 /// plane intersection). Keeps the camera's world position unchanged — only
 /// the pivot/distance/yaw/pitch are recomputed.

crates/renzora_editor/src/lib.rs

@@ -381,7 +381,8 @@ impl Plugin for RenzoraEditorPlugin {
             .init_resource::<ShortcutRegistry>()
             .init_resource::<EditorActionHooks>()
             .init_resource::<MaterialThumbnailRegistry>()
-            .init_resource::<ModelThumbnailRegistry>();
+            .init_resource::<ModelThumbnailRegistry>()
+            .init_resource::<renzora::core::IsolationMode>();
 
         register_builtin_tools(
             &mut app.world_mut().resource_mut::<ToolbarRegistry>(),
@@ -435,6 +436,10 @@ impl Plugin for RenzoraEditorPlugin {
                 sync_active_tool_to_gizmo_mode.run_if(in_state(SplashState::Editor)),
             )
             .add_systems(Update, apply_vsync_setting)
+            .add_systems(
+                Update,
+                apply_isolation_mode.run_if(in_state(SplashState::Editor)),
+            )
             ;
     }
 }
@@ -459,6 +464,73 @@ fn apply_vsync_setting(
     }
 }
 
+/// View menu Isolation Mode: when active, hide all mesh entities that aren't
+/// the current selection (or its ancestors/descendants). On deactivate,
+/// restore the entities we hid back to `Visibility::Inherited`.
+fn apply_isolation_mode(
+    iso: Res<renzora::core::IsolationMode>,
+    selection: Res<EditorSelection>,
+    children_q: Query<&Children>,
+    parent_q: Query<&ChildOf>,
+    mut visibility_q: Query<
+        (Entity, &mut Visibility),
+        (
+            With<Mesh3d>,
+            Without<renzora::core::EditorCamera>,
+            Without<renzora::core::HideInHierarchy>,
+        ),
+    >,
+    mut hidden_entities: Local<Vec<Entity>>,
+    mut last_active: Local<bool>,
+) {
+    if iso.active == *last_active {
+        return;
+    }
+    *last_active = iso.active;
+
+    if iso.active {
+        let mut keep: std::collections::HashSet<Entity> = std::collections::HashSet::new();
+        for sel in selection.get_all() {
+            keep.insert(sel);
+            let mut cur = sel;
+            while let Ok(child_of) = parent_q.get(cur) {
+                let parent = child_of.parent();
+                keep.insert(parent);
+                cur = parent;
+            }
+            collect_descendants(sel, &children_q, &mut keep);
+        }
+        hidden_entities.clear();
+        for (entity, mut vis) in &mut visibility_q {
+            if !keep.contains(&entity) && *vis != Visibility::Hidden {
+                *vis = Visibility::Hidden;
+                hidden_entities.push(entity);
+            }
+        }
+    } else {
+        let drained: Vec<Entity> = hidden_entities.drain(..).collect();
+        for entity in drained {
+            if let Ok((_, mut vis)) = visibility_q.get_mut(entity) {
+                *vis = Visibility::Inherited;
+            }
+        }
+    }
+}
+
+fn collect_descendants(
+    entity: Entity,
+    children_q: &Query<&Children>,
+    out: &mut std::collections::HashSet<Entity>,
+) {
+    if let Ok(children) = children_q.get(entity) {
+        for child in children.iter() {
+            if out.insert(child) {
+                collect_descendants(child, children_q, out);
+            }
+        }
+    }
+}
+
 /// Observer: show toast notifications when scripts are hot-reloaded.
 fn show_script_reload_toasts(
     trigger: On<renzora::ScriptsReloaded>,
@@ -841,6 +913,10 @@ pub fn editor_ui_system(world: &mut World) {
             )
         })
         .unwrap_or((false, false));
+    let isolation_active = world
+        .get_resource::<renzora::core::IsolationMode>()
+        .map(|m| m.active)
+        .unwrap_or(false);
     let title_action = renzora_ui::title_bar::render_title_bar(
         &ctx,
         &theme,
@@ -852,6 +928,7 @@ pub fn editor_ui_system(world: &mut World) {
         &mut window_queue,
         can_undo,
         can_redo,
+        isolation_active,
     );
 
     // 6. Document tabs (below title bar)
@@ -1166,6 +1243,25 @@ pub fn editor_ui_system(world: &mut World) {
             }
         }
         TitleBarAction::ResetLayout => reset_layout(world),
+        TitleBarAction::ZoomIn => {
+            world.insert_resource(renzora::core::CameraViewRequest::ZoomIn);
+        }
+        TitleBarAction::ZoomOut => {
+            world.insert_resource(renzora::core::CameraViewRequest::ZoomOut);
+        }
+        TitleBarAction::ResetZoom => {
+            world.insert_resource(renzora::core::CameraViewRequest::ResetZoom);
+        }
+        TitleBarAction::FrameAll => {
+            world.insert_resource(renzora::core::CameraViewRequest::FrameAll);
+        }
+        TitleBarAction::ToggleIsolation => {
+            let mut iso = world
+                .remove_resource::<renzora::core::IsolationMode>()
+                .unwrap_or_default();
+            iso.active = !iso.active;
+            world.insert_resource(iso);
+        }
         TitleBarAction::None => {}
     }