feat: add configurable toolbar, game view zoom, and menu bar extensions (#4)

Bli-AIk · web-flow · commit c7d7b5a054b7 · 2026-03-01T14:23:34.000+08:00
* feat(bevy_workbench): add GameViewPlugin and reorder initialization

* feat(workbench): add configurable toolbar and game view

* feat(workbench): add menu bar extensions and game view zoom controls
diff --git a/examples/control_link.rs b/examples/control_link.rs
@@ -43,8 +43,7 @@ fn main() {
             }),
     )
     .insert_resource(ClearColor(Color::BLACK))
-    .add_plugins(WorkbenchPlugin::default())
-    .add_plugins(GameViewPlugin);
+    .add_plugins(WorkbenchPlugin::default());
 
     common::register_types(&mut app);
     register_panels(&mut app);
diff --git a/examples/minimal.rs b/examples/minimal.rs
@@ -29,8 +29,7 @@ fn main() {
             }),
     )
     .insert_resource(ClearColor(Color::BLACK))
-    .add_plugins(WorkbenchPlugin::default())
-    .add_plugins(GameViewPlugin);
+    .add_plugins(WorkbenchPlugin::default());
 
     common::register_types(&mut app);
 
diff --git a/src/dock.rs b/src/dock.rs
@@ -153,7 +153,7 @@ impl TileLayoutState {
         let slot = match panel.id() {
             id if id.contains("inspector") => PanelSlot::Right,
             id if id.contains("console") || id.contains("timeline") => PanelSlot::Bottom,
-            id if id.contains("game_view") => PanelSlot::Center,
+            id if id.contains("game_view") || id.contains("preview") => PanelSlot::Center,
             _ => PanelSlot::Left,
         };
         let visible = panel.default_visible();
@@ -213,7 +213,7 @@ impl TileLayoutState {
             let slot = match str_id.as_str() {
                 id if id.contains("inspector") => PanelSlot::Right,
                 id if id.contains("console") || id.contains("timeline") => PanelSlot::Bottom,
-                id if id.contains("game_view") => PanelSlot::Center,
+                id if id.contains("game_view") || id.contains("preview") => PanelSlot::Center,
                 _ => PanelSlot::Left,
             };
             let tile_id = tiles.insert_pane(PaneEntry { panel_id });
diff --git a/src/game_view.rs b/src/game_view.rs
@@ -7,11 +7,22 @@ use bevy::state::prelude::DespawnOnEnter;
 
 use crate::dock::{TileLayoutState, WorkbenchPanel};
 use crate::mode::EditorMode;
+use crate::theme::gray;
 
 /// Marker component for the preview camera that renders to the game view texture.
 #[derive(Component)]
 pub struct GameViewCamera;
 
+/// Zoom mode for the game view panel.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum ViewZoom {
+    /// Fit the image within the available panel space, preserving aspect ratio.
+    #[default]
+    Auto,
+    /// Display at a fixed scale factor (1.0 = 100%).
+    Fixed(f32),
+}
+
 /// Resource holding the game view render state.
 #[derive(Resource)]
 pub struct GameViewState {
@@ -130,6 +141,8 @@ pub struct GameViewPanel {
     pub is_playing: bool,
     /// Localized "press play" text.
     pub press_play_text: String,
+    /// Current zoom mode.
+    pub zoom: ViewZoom,
 }
 
 impl WorkbenchPanel for GameViewPanel {
@@ -157,37 +170,77 @@ impl WorkbenchPanel for GameViewPanel {
         }
 
         if let Some(tex_id) = self.egui_texture_id {
-            let available = ui.available_size();
             let res = if self.resolution.x > 0 && self.resolution.y > 0 {
                 self.resolution
             } else {
                 UVec2::new(1280, 720)
             };
+
+            // Zoom toolbar
+            ui.horizontal(|ui| {
+                let zoom_label = match self.zoom {
+                    ViewZoom::Auto => "Auto".to_string(),
+                    ViewZoom::Fixed(z) => format!("{:.0}%", z * 100.0),
+                };
+                egui::ComboBox::from_id_salt("game_view_zoom")
+                    .selected_text(&zoom_label)
+                    .show_ui(ui, |ui| {
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Auto, "Auto");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(0.5), "50%");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(0.75), "75%");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(1.0), "100%");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(1.25), "125%");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(1.5), "150%");
+                        ui.selectable_value(&mut self.zoom, ViewZoom::Fixed(2.0), "200%");
+                    });
+
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    ui.colored_label(gray::S550, format!("{}×{}", res.x, res.y));
+                });
+            });
+
+            ui.separator();
+
+            let available = ui.available_size();
             let aspect = res.x as f32 / res.y as f32;
 
-            // Fit-to-panel while preserving aspect ratio
-            let (w, h) = {
-                let w_from_h = available.y * aspect;
-                if w_from_h <= available.x {
-                    (w_from_h, available.y)
-                } else {
-                    (available.x, available.x / aspect)
+            let display_size = match self.zoom {
+                ViewZoom::Auto => {
+                    let w = available.x;
+                    let h = w / aspect;
+                    if h > available.y {
+                        egui::vec2(available.y * aspect, available.y)
+                    } else {
+                        egui::vec2(w, h)
+                    }
                 }
+                ViewZoom::Fixed(z) => egui::vec2(res.x as f32 * z, res.y as f32 * z),
             };
 
-            // Center the image within the panel
-            let response = ui
-                .with_layout(
+            let padding = (available - display_size).max(egui::Vec2::ZERO) * 0.5;
+
+            // For fixed zoom that overflows, use a scroll area
+            let response = if matches!(self.zoom, ViewZoom::Fixed(_))
+                && (display_size.x > available.x || display_size.y > available.y)
+            {
+                egui::ScrollArea::both()
+                    .show(ui, |ui| {
+                        ui.image(egui::load::SizedTexture::new(tex_id, display_size))
+                    })
+                    .inner
+            } else {
+                ui.add_space(padding.y);
+                ui.with_layout(
                     egui::Layout::centered_and_justified(ui.layout().main_dir()),
-                    |ui| ui.image(egui::load::SizedTexture::new(tex_id, [w, h])),
+                    |ui| ui.image(egui::load::SizedTexture::new(tex_id, display_size)),
                 )
-                .inner;
+                .inner
+            };
 
             // Update focus resource
             let hovered = response.hovered();
             let image_rect = response.rect;
 
-            // Compute cursor position in render target coordinates
             let cursor_viewport_pos = if hovered {
                 ui.ctx().pointer_latest_pos().and_then(|pointer_pos| {
                     if image_rect.contains(pointer_pos) {
@@ -202,7 +255,6 @@ impl WorkbenchPanel for GameViewPanel {
                 None
             };
 
-            // Show focus border when hovered
             if hovered {
                 let painter = ui.painter();
                 painter.rect_stroke(
diff --git a/src/lib.rs b/src/lib.rs
@@ -35,6 +35,13 @@ pub struct WorkbenchConfig {
     pub layout: layout::LayoutMode,
     pub show_menu_bar: bool,
     pub show_console: bool,
+    /// Whether to show the built-in Play/Stop/Pause toolbar.
+    /// Set to `false` for tools that don't use the game mode system
+    /// (e.g., animation editors that are always "running").
+    pub show_toolbar: bool,
+    /// Whether to enable the built-in GameView render-to-texture pipeline.
+    /// Set to `false` if your app has its own preview/rendering setup.
+    pub enable_game_view: bool,
 }
 
 impl Default for WorkbenchConfig {
@@ -43,6 +50,8 @@ impl Default for WorkbenchConfig {
             layout: layout::LayoutMode::Auto,
             show_menu_bar: true,
             show_console: true,
+            show_toolbar: true,
+            enable_game_view: true,
         }
     }
 }
@@ -94,39 +103,63 @@ impl Plugin for WorkbenchPlugin {
             })
             .insert_resource(i18n::I18n::new(settings.locale))
             .insert_resource(font::FontState::default())
+            .add_message::<menu_bar::MenuAction>()
             .add_systems(Update, layout::detect_layout_system)
-            .add_systems(Update, mode::mode_input_system)
-            .add_systems(Update, mode::run_game_schedule_system)
-            .add_systems(OnEnter(mode::EditorMode::Play), mode::on_enter_play)
-            .add_systems(
-                OnEnter(mode::EditorMode::Play),
-                console::console_auto_clear_system,
-            )
-            .add_systems(OnEnter(mode::EditorMode::Pause), mode::on_enter_pause)
-            .add_systems(OnEnter(mode::EditorMode::Edit), mode::on_enter_edit)
             .add_systems(Update, undo::undo_input_system)
             .add_systems(PreUpdate, assign_primary_egui_context_system)
             .add_systems(PreUpdate, console::console_drain_system)
-            .add_systems(PreUpdate, inspector::mark_internal_entities_system)
-            // UI systems must run in EguiPrimaryContextPass (bevy_egui 0.39 multi-pass mode)
-            .add_systems(
-                EguiPrimaryContextPass,
+            .add_systems(PreUpdate, inspector::mark_internal_entities_system);
+
+        // Mode system (Play/Stop/Pause) — only when toolbar is enabled
+        if self.config.show_toolbar {
+            app.add_systems(Update, mode::mode_input_system)
+                .add_systems(Update, mode::run_game_schedule_system)
+                .add_systems(OnEnter(mode::EditorMode::Play), mode::on_enter_play)
+                .add_systems(
+                    OnEnter(mode::EditorMode::Play),
+                    console::console_auto_clear_system,
+                )
+                .add_systems(OnEnter(mode::EditorMode::Pause), mode::on_enter_pause)
+                .add_systems(OnEnter(mode::EditorMode::Edit), mode::on_enter_edit);
+        }
+
+        // UI systems must run in EguiPrimaryContextPass (bevy_egui 0.39 multi-pass mode)
+        {
+            let ui_systems = (
                 (
-                    (
-                        config::config_apply_system,
-                        font::install_fonts_system,
-                        theme::apply_theme_system,
-                    )
-                        .chain(),
-                    game_view::game_view_sync_system,
-                    menu_bar::menu_bar_system,
-                    dock::tiles_ui_system,
+                    config::config_apply_system,
+                    font::install_fonts_system,
+                    theme::apply_theme_system,
                 )
                     .chain(),
-            );
+                game_view::game_view_sync_system
+                    .run_if(resource_exists::<game_view::GameViewState>),
+                menu_bar::menu_bar_system,
+            )
+                .chain();
+
+            if self.config.show_toolbar {
+                app.add_systems(
+                    EguiPrimaryContextPass,
+                    (ui_systems, menu_bar::toolbar_system, dock::tiles_ui_system).chain(),
+                );
+            } else {
+                app.add_systems(
+                    EguiPrimaryContextPass,
+                    (ui_systems, dock::tiles_ui_system).chain(),
+                );
+            }
+        }
+
+        // Game view render-to-texture pipeline
+        if self.config.enable_game_view {
+            app.add_plugins(game_view::GameViewPlugin);
+        }
 
         // Register built-in panels
-        app.register_panel(game_view::GameViewPanel::default());
+        if self.config.enable_game_view {
+            app.register_panel(game_view::GameViewPanel::default());
+        }
         app.register_panel(inspector::InspectorPanel);
         if self.config.show_console {
             app.register_panel(console::ConsolePanel);
diff --git a/src/menu_bar.rs b/src/menu_bar.rs
@@ -7,20 +7,61 @@ use crate::dock::{TileLayoutState, WorkbenchPanel};
 use crate::mode::EditorMode;
 use crate::theme::gray;
 
+/// A custom item to inject into the File menu.
+pub struct MenuExtItem {
+    /// Unique identifier for this action (e.g., "open", "save").
+    pub id: &'static str,
+    /// Display label (e.g., "Open...", "Save").
+    pub label: String,
+    /// Whether the item is clickable.
+    pub enabled: bool,
+}
+
+/// Resource for extending the workbench menu bar with custom items.
+#[derive(Resource, Default)]
+pub struct MenuBarExtensions {
+    /// Custom items prepended to the File menu (before built-in "Settings").
+    pub file_items: Vec<MenuExtItem>,
+    /// Info text displayed after all menus (e.g., project title, resolution).
+    pub info_text: Option<String>,
+}
+
+/// Message sent when a custom menu item is clicked.
+#[derive(Message)]
+pub struct MenuAction {
+    pub id: &'static str,
+}
+
 /// System that renders the top menu bar.
 pub fn menu_bar_system(
     mut contexts: EguiContexts,
-    current_mode: Res<State<EditorMode>>,
-    mut next_mode: ResMut<NextState<EditorMode>>,
     mut tile_state: ResMut<TileLayoutState>,
     i18n: Res<crate::i18n::I18n>,
     mut undo_stack: ResMut<crate::undo::UndoStack>,
+    extensions: Option<Res<MenuBarExtensions>>,
+    mut menu_actions: MessageWriter<MenuAction>,
 ) {
     let Ok(ctx) = contexts.ctx_mut() else { return };
     egui::TopBottomPanel::top("workbench_menu_bar").show(ctx, |ui| {
         egui::MenuBar::new().ui(ui, |ui| {
             // Left side: menus
             ui.menu_button(i18n.t("menu-file"), |ui| {
+                // Custom file menu items (from extensions)
+                if let Some(ref ext) = extensions {
+                    for item in &ext.file_items {
+                        if ui
+                            .add_enabled(item.enabled, egui::Button::new(&item.label))
+                            .clicked()
+                        {
+                            menu_actions.write(MenuAction { id: item.id });
+                            ui.close();
+                        }
+                    }
+                    if !ext.file_items.is_empty() {
+                        ui.separator();
+                    }
+                }
+
                 if ui.button(i18n.t("menu-file-settings")).clicked() {
                     tile_state.request_open_panel("settings");
                     ui.close();
@@ -115,10 +156,30 @@ pub fn menu_bar_system(
                     }
                 }
             });
+
+            // Extension info text (e.g., project title)
+            if let Some(ref ext) = extensions
+                && let Some(ref text) = ext.info_text
+            {
+                ui.separator();
+                ui.label(text);
+            }
         });
     });
 
     // Secondary toolbar — centered Play/Pause/Stop
+}
+
+/// System that renders the Play/Pause/Stop toolbar.
+/// Only added when `WorkbenchConfig::show_toolbar` is `true`.
+pub fn toolbar_system(
+    mut contexts: EguiContexts,
+    current_mode: Res<State<EditorMode>>,
+    mut next_mode: ResMut<NextState<EditorMode>>,
+    i18n: Res<crate::i18n::I18n>,
+) {
+    let Ok(ctx) = contexts.ctx_mut() else { return };
+
     let btn_fill = gray::S250;
     egui::TopBottomPanel::top("workbench_toolbar").show(ctx, |ui| {
         ui.horizontal_centered(|ui| {
diff --git a/src/prelude.rs b/src/prelude.rs
@@ -9,12 +9,12 @@ pub use crate::console::{ConsolePanel, console_log_layer};
 pub use crate::dock::{PanelSlot, TileLayoutState, WorkbenchPanel};
 pub use crate::font::FontConfig;
 pub use crate::game_view::{
-    GameViewCamera, GameViewFocus, GameViewPanel, GameViewPlugin, GameViewState,
+    GameViewCamera, GameViewFocus, GameViewPanel, GameViewPlugin, GameViewState, ViewZoom,
 };
 pub use crate::i18n::{I18n, Locale};
 pub use crate::inspector::InspectorPanel;
-pub use crate::keybind::{KeyBind, KeyBindSlot, KeyBindings};
 pub use crate::layout::{LayoutMode, LayoutState};
+pub use crate::menu_bar::{MenuAction, MenuBarExtensions, MenuExtItem};
 pub use crate::mode::{EditorMode, GameClock, GameSchedule, ModeController, on_fresh_play};
 pub use crate::theme::{ThemeConfig, ThemePreset, ThemeState};
 pub use crate::undo::{UndoAction, UndoStack};

Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,7 @@ fn main() {`
`43`	`43`	`}),`
`44`	`44`	`)`
`45`	`45`	`.insert_resource(ClearColor(Color::BLACK))`
`46`		`- .add_plugins(WorkbenchPlugin::default())`
`47`		`- .add_plugins(GameViewPlugin);`
	`46`	`+ .add_plugins(WorkbenchPlugin::default());`
`48`	`47`
`49`	`48`	`common::register_types(&mut app);`
`50`	`49`	`register_panels(&mut app);`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,7 @@ fn main() {`
`29`	`29`	`}),`
`30`	`30`	`)`
`31`	`31`	`.insert_resource(ClearColor(Color::BLACK))`
`32`		`- .add_plugins(WorkbenchPlugin::default())`
`33`		`- .add_plugins(GameViewPlugin);`
	`32`	`+ .add_plugins(WorkbenchPlugin::default());`
`34`	`33`
`35`	`34`	`common::register_types(&mut app);`
`36`	`35`