Wire undo/redo to viewport toolbar and Edit menu

The viewport toolbar's undo/redo buttons were rendered dimmed and the
Edit menu items were no-ops. Hooked them up to the existing command-
based undo system.

- Extract undo_once / redo_once as public functions in renzora_undo so
  callers can drive the stack directly without bouncing through the
  message bus. Fixes a frame-timing bug where clicks queued in
  EguiPrimaryContextPass wrote RequestUndo messages that were rotated
  out before handle_undo's iter_current_update_messages could see them.

- Viewport toolbar buttons now render enabled/disabled based on
  UndoStacks::can_undo/can_redo and call undo_once/redo_once via
  EditorCommands on click.

- Added TitleBarAction::Undo / Redo variants; Edit -> Undo / Redo
  buttons now fire them.

- To dispatch undo/redo from renzora_editor_framework without adding a
  circular dep on renzora_undo, introduced EditorActionHooks { undo,
  redo } in the editor framework. UndoPlugin registers undo_once /
  redo_once as hooks on build (init_resource first so plugin ordering
  doesn't matter).

- Route Ctrl+Z / Ctrl+Y through KeyBindings::just_pressed(EditorAction::
  Undo/Redo) instead of hardcoded KeyCodes. User rebinds in Settings ->
  Shortcuts and command palette dispatches both work now.

- Mesh draw spawn is undoable: SpawnDrawnMeshCmd implements UndoCommand.
  execute spawns and captures the entity, undo despawns, redo respawns.

Author: RenzoraEngine

crates/core/renzora_undo/src/lib.rs

@@ -121,30 +121,47 @@ impl Plugin for UndoPlugin {
             .add_message::<RequestUndo>()
             .add_message::<RequestRedo>()
             .add_message::<UndoExhausted>()
+            // Ensure the hooks resource exists regardless of plugin order —
+            // RenzoraEditorPlugin also initialises it, but we can't rely on
+            // that running first.
+            .init_resource::<renzora_editor_framework::EditorActionHooks>()
             .add_systems(Update, (shortcut_input, handle_undo, handle_redo).chain());
+
+        // Register undo/redo as late-bound hooks so the editor framework's
+        // title bar / menu handlers can invoke them without taking a
+        // dependency on this crate (which would create a cycle).
+        let mut hooks = app
+            .world_mut()
+            .resource_mut::<renzora_editor_framework::EditorActionHooks>();
+        hooks.undo = Some(undo_once);
+        hooks.redo = Some(redo_once);
     }
 }
 
 fn shortcut_input(
     keys: Res<ButtonInput<KeyCode>>,
+    bindings: Option<Res<renzora_core::keybindings::KeyBindings>>,
     mut undo_w: MessageWriter<RequestUndo>,
     mut redo_w: MessageWriter<RequestRedo>,
 ) {
-    let ctrl = keys.pressed(KeyCode::ControlLeft) || keys.pressed(KeyCode::ControlRight)
-        || keys.pressed(KeyCode::SuperLeft) || keys.pressed(KeyCode::SuperRight);
-    if !ctrl { return; }
-    let shift = keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight);
-    if keys.just_pressed(KeyCode::KeyZ) {
-        if shift { redo_w.write(RequestRedo); } else { undo_w.write(RequestUndo); }
-    } else if keys.just_pressed(KeyCode::KeyY) {
+    // Route through KeyBindings so:
+    //   - User-rebound Undo/Redo keys are respected
+    //   - Command palette dispatches (KeyBindings::dispatch) fire the messages
+    let Some(bindings) = bindings else { return };
+    use renzora_core::keybindings::EditorAction;
+    if bindings.just_pressed(EditorAction::Undo, &keys) {
+        undo_w.write(RequestUndo);
+    }
+    if bindings.just_pressed(EditorAction::Redo, &keys) {
         redo_w.write(RequestRedo);
     }
 }
 
-fn handle_undo(world: &mut World) {
-    let count = world.get_resource::<Messages<RequestUndo>>()
-        .map(|m| m.iter_current_update_messages().count()).unwrap_or(0);
-    if count == 0 { return; }
+/// Undo the most recent action on the active stack. Callable from anywhere
+/// with `&mut World` — bypasses the message bus so it works from deferred
+/// callers (toolbar clicks, menu items, command palette) without frame-timing
+/// concerns.
+pub fn undo_once(world: &mut World) {
     let active = world.resource::<UndoStacks>().active.clone();
     let cmd = world.resource_mut::<UndoStacks>().stacks
         .get_mut(&active).and_then(|s| s.undo.pop_back());
@@ -155,10 +172,8 @@ fn handle_undo(world: &mut World) {
     }
 }
 
-fn handle_redo(world: &mut World) {
-    let count = world.get_resource::<Messages<RequestRedo>>()
-        .map(|m| m.iter_current_update_messages().count()).unwrap_or(0);
-    if count == 0 { return; }
+/// Redo the most recently undone action on the active stack.
+pub fn redo_once(world: &mut World) {
     let active = world.resource::<UndoStacks>().active.clone();
     let cmd = world.resource_mut::<UndoStacks>().stacks
         .get_mut(&active).and_then(|s| s.redo.pop_back());
@@ -169,6 +184,20 @@ fn handle_redo(world: &mut World) {
     }
 }
 
+fn handle_undo(world: &mut World) {
+    let count = world.get_resource::<Messages<RequestUndo>>()
+        .map(|m| m.iter_current_update_messages().count()).unwrap_or(0);
+    if count == 0 { return; }
+    undo_once(world);
+}
+
+fn handle_redo(world: &mut World) {
+    let count = world.get_resource::<Messages<RequestRedo>>()
+        .map(|m| m.iter_current_update_messages().count()).unwrap_or(0);
+    if count == 0 { return; }
+    redo_once(world);
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Built-in commands for common scene operations.
 // Plugins may use these or define their own.

crates/editor/renzora_editor/src/lib.rs

@@ -27,6 +27,16 @@ pub use renzora_macros::{Inspectable, post_process};
 pub use selection::EditorSelection;
 pub use shortcut_registry::{ShortcutEntry, ShortcutRegistry};
 pub use toolbar_registry::{ToolEntry, ToolSection, ToolbarRegistry};
+
+/// Late-bound hooks for actions that live in downstream crates the editor
+/// framework can't depend on directly (avoids a cycle with `renzora_undo`).
+/// Downstream crates install hooks in their `Plugin::build`; the menu /
+/// title bar handlers call them when present.
+#[derive(bevy::prelude::Resource, Default, Clone)]
+pub struct EditorActionHooks {
+    pub undo: Option<fn(&mut bevy::prelude::World)>,
+    pub redo: Option<fn(&mut bevy::prelude::World)>,
+}
 pub use viewport_overlay::{ViewportOverlayDrawer, ViewportOverlayRegistry};
 pub use settings::{CustomFonts, EditorSettings, MonoFont, SelectionHighlightMode, SettingsTab, UiFont};
 
@@ -181,7 +191,8 @@ impl Plugin for RenzoraEditorPlugin {
             .init_resource::<ComponentIconRegistry>()
             .init_resource::<ViewportOverlayRegistry>()
             .init_resource::<ToolbarRegistry>()
-            .init_resource::<ShortcutRegistry>();
+            .init_resource::<ShortcutRegistry>()
+            .init_resource::<EditorActionHooks>();
 
         register_builtin_tools(
             &mut app.world_mut().resource_mut::<ToolbarRegistry>(),
@@ -918,6 +929,16 @@ pub fn editor_ui_system(world: &mut World) {
         TitleBarAction::StartTutorial => {
             world.insert_resource(renzora_core::TutorialRequested);
         }
+        TitleBarAction::Undo => {
+            if let Some(hook) = world.get_resource::<EditorActionHooks>().and_then(|h| h.undo) {
+                hook(world);
+            }
+        }
+        TitleBarAction::Redo => {
+            if let Some(hook) = world.get_resource::<EditorActionHooks>().and_then(|h| h.redo) {
+                hook(world);
+            }
+        }
         TitleBarAction::None => {}
     }
 

crates/editor/renzora_mesh_draw/src/lib.rs

@@ -390,7 +390,11 @@ fn handle_mouse_input(
                 let current_mode = state.tool_mode;
                 if let Some(cmds) = cmds {
                     cmds.push(move |world: &mut World| {
-                        spawn_drawn_mesh(world, recipe);
+                        renzora::undo::execute(
+                            world,
+                            renzora::undo::UndoContext::Scene,
+                            Box::new(SpawnDrawnMeshCmd { recipe, entity: None }),
+                        );
                         // Auto-deactivate after committing so the next click
                         // doesn't immediately start another shape.
                         deactivate_tool(world, current_mode);
@@ -548,8 +552,9 @@ fn draw_cursor_overlay(ui: &mut egui::Ui, world: &World, rect: egui::Rect) {
 
 // ── Commit drawn meshes ────────────────────────────────────────────────────
 
-fn spawn_drawn_mesh(world: &mut World, recipe: MeshDrawRecipe) {
-    let (mesh, pivot) = build_recipe_mesh(&recipe);
+/// Spawn a mesh built from `recipe` and return its entity.
+fn spawn_drawn_mesh(world: &mut World, recipe: &MeshDrawRecipe) -> Entity {
+    let (mesh, pivot) = build_recipe_mesh(recipe);
     let is_polygon = matches!(recipe.footprint, Footprint::Polygon { .. });
     let mesh_handle = world.resource_mut::<Assets<Mesh>>().add(mesh);
     let material_handle = world.resource_mut::<Assets<StandardMaterial>>().add(
@@ -562,14 +567,40 @@ fn spawn_drawn_mesh(world: &mut World, recipe: MeshDrawRecipe) {
             ..default()
         }
     );
-    world.spawn((
-        Name::new("DrawnMesh"),
-        Mesh3d(mesh_handle),
-        MeshMaterial3d(material_handle),
-        Transform::from_translation(pivot),
-        Visibility::default(),
-        recipe,
-    ));
+    world
+        .spawn((
+            Name::new("DrawnMesh"),
+            Mesh3d(mesh_handle),
+            MeshMaterial3d(material_handle),
+            Transform::from_translation(pivot),
+            Visibility::default(),
+            recipe.clone(),
+        ))
+        .id()
+}
+
+/// Undoable spawn: `execute` creates the entity and remembers its id;
+/// `undo` despawns it; `execute` runs again on redo and respawns with the
+/// original recipe.
+struct SpawnDrawnMeshCmd {
+    recipe: MeshDrawRecipe,
+    entity: Option<Entity>,
+}
+
+impl renzora::undo::UndoCommand for SpawnDrawnMeshCmd {
+    fn label(&self) -> &str { "Draw Mesh" }
+
+    fn execute(&mut self, world: &mut World) {
+        self.entity = Some(spawn_drawn_mesh(world, &self.recipe));
+    }
+
+    fn undo(&mut self, world: &mut World) {
+        if let Some(entity) = self.entity.take() {
+            if let Ok(ent) = world.get_entity_mut(entity) {
+                ent.despawn();
+            }
+        }
+    }
 }
 
 /// Build a mesh from a recipe. Returns `(mesh, pivot)` where pivot is the

crates/editor/renzora_viewport/src/toolbar.rs

@@ -111,21 +111,28 @@ pub fn render_tool_overlay(ctx: &egui::Context, world: &World, content_rect: Rec
                 // Divider before undo/redo
                 draw_divider(ui, &mut y, panel_pos.x, panel_w, border_color);
 
-                // Undo | Redo (dimmed — no command history yet)
-                let disabled_color = Color32::from_rgba_unmultiplied(inactive_color.r(), inactive_color.g(), inactive_color.b(), 80);
-                let disabled_icon_color = Color32::from_white_alpha(40);
+                // Undo | Redo — enabled when the active undo stack has entries.
+                let stacks = world.get_resource::<renzora::undo::UndoStacks>();
+                let (can_undo, can_redo) = match stacks {
+                    Some(s) => (s.can_undo(&s.active), s.can_redo(&s.active)),
+                    None => (false, false),
+                };
 
                 let undo_rect = Rect::from_min_size(Pos2::new(col0_x, y), BTN_SIZE);
-                ui.allocate_rect(undo_rect, Sense::hover());
-                ui.painter().rect_filled(undo_rect, CornerRadius::same(3), disabled_color);
-                ui.painter().text(undo_rect.center(), egui::Align2::CENTER_CENTER, ARROW_U_UP_LEFT, FontId::proportional(16.0), disabled_icon_color);
-                ui.allocate_rect(undo_rect, Sense::hover()).on_hover_text("Undo (Ctrl+Z)");
+                let r = undo_redo_button(ui, undo_rect, ARROW_U_UP_LEFT, can_undo,
+                    inactive_color, hovered_color);
+                if r.clicked() {
+                    cmds.push(|w: &mut World| { renzora::undo::undo_once(w); });
+                }
+                r.on_hover_text("Undo (Ctrl+Z)");
 
                 let redo_rect = Rect::from_min_size(Pos2::new(col1_x, y), BTN_SIZE);
-                ui.allocate_rect(redo_rect, Sense::hover());
-                ui.painter().rect_filled(redo_rect, CornerRadius::same(3), disabled_color);
-                ui.painter().text(redo_rect.center(), egui::Align2::CENTER_CENTER, ARROW_U_UP_RIGHT, FontId::proportional(16.0), disabled_icon_color);
-                ui.allocate_rect(redo_rect, Sense::hover()).on_hover_text("Redo (Ctrl+Y)");
+                let r = undo_redo_button(ui, redo_rect, ARROW_U_UP_RIGHT, can_redo,
+                    inactive_color, hovered_color);
+                if r.clicked() {
+                    cmds.push(|w: &mut World| { renzora::undo::redo_once(w); });
+                }
+                r.on_hover_text("Redo (Ctrl+Y)");
                 y += row_step;
 
                 // Terrain section — only rendered if any entries are currently visible
@@ -273,6 +280,43 @@ fn render_tool_section(
     if tools.len() % 2 == 1 { *y += row_step; }
 }
 
+/// A toolbar button for undo/redo — enabled state accepts clicks; disabled
+/// state renders dimmed and only shows a tooltip.
+fn undo_redo_button(
+    ui: &mut egui::Ui,
+    rect: Rect,
+    icon: &str,
+    enabled: bool,
+    inactive_color: Color32,
+    hovered_color: Color32,
+) -> egui::Response {
+    if !enabled {
+        let resp = ui.allocate_rect(rect, Sense::hover());
+        if ui.is_rect_visible(rect) {
+            let dim_bg = Color32::from_rgba_unmultiplied(
+                inactive_color.r(), inactive_color.g(), inactive_color.b(), 80,
+            );
+            ui.painter().rect_filled(rect, CornerRadius::same(3), dim_bg);
+            ui.painter().text(
+                rect.center(), egui::Align2::CENTER_CENTER, icon,
+                FontId::proportional(16.0), Color32::from_white_alpha(40),
+            );
+        }
+        return resp;
+    }
+    let resp = ui.allocate_rect(rect, Sense::click());
+    if resp.hovered() { ui.ctx().set_cursor_icon(CursorIcon::PointingHand); }
+    if ui.is_rect_visible(rect) {
+        let bg = if resp.hovered() { hovered_color } else { inactive_color };
+        ui.painter().rect_filled(rect, CornerRadius::same(3), bg);
+        ui.painter().text(
+            rect.center(), egui::Align2::CENTER_CENTER, icon,
+            FontId::proportional(16.0), Color32::WHITE,
+        );
+    }
+    resp
+}
+
 fn viewport_tool_button(
     ui: &mut egui::Ui, rect: Rect, icon: &str, active: bool,
     active_color: Color32, inactive_color: Color32, hovered_color: Color32,

crates/ui/renzora_ui/src/title_bar.rs

@@ -27,6 +27,8 @@ pub enum TitleBarAction {
     Pause,
     ScriptsOnly,
     StartTutorial,
+    Undo,
+    Redo,
 }
 
 const TITLE_BAR_HEIGHT: f32 = 28.0;
@@ -114,9 +116,11 @@ pub fn render_title_bar(
 
                 ui.menu_button("Edit", |ui| {
                     if ui.button("Undo").clicked() {
+                        action = TitleBarAction::Undo;
                         ui.close();
                     }
                     if ui.button("Redo").clicked() {
+                        action = TitleBarAction::Redo;
                         ui.close();
                     }
                 });