SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Render preview uses the shared camera navigation (#1462)
bherbruckbe985f136d47
diff --git a/AGENTS.md b/AGENTS.mdindex 662c0f539f..aaeb9c242e 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -81,6 +81,10 @@ People trust SolidCraft with their designs; a crash loses their work. **This outegui/eframe/winit/wgpu/rfd. **The UI crate is swappable.** Only `crates/kernel` may use `truck`.- **The UI is thin**: panels read engine state and act through `app.run(id, params)` /`app.start(id)`. Colours come from `theme::Tokens`.+- **One set of camera controls**: every page or canvas with a camera (viewport, Render+ preview, future flat pattern or drawing pages) calls `navigation::handle` with its `NavCaps`+ (orbit off for flat 2D pages). New canvases must use `navigation::handle`; never hand-roll+ camera input (a test rejects it).- **Rust only.** Units are millimetres and radians internally; Z is up. The one exception isJavaScript the browser requires: the service worker `apps/solidcraft-web/sw.js` (browsers onlyrun service workers as JavaScript) and the small inline scripts in `apps/solidcraft-web/index.html`.diff --git a/CONTRIBUTING.md b/CONTRIBUTING.mdindex 2ff450ce1c..8f15211f06 100644--- a/CONTRIBUTING.md+++ b/CONTRIBUTING.md@@ -116,6 +116,12 @@ The [README](README.md#architecture) has the layer table. The short version:5. **Everything is a command, with a test.** A new feature means a `CommandSpec` in`crates/engine/src/cmd/`, engine tests that measure the result (volume, area,face/edge/vertex counts against a value you can derive), and for UI work a scenario (below).+6. **One set of camera controls.** Every page or canvas that shows a view (the modelling+ viewport, the Render preview, and any new page such as a flat pattern or drawing) calls+ `navigation::handle` (`crates/ui-egui/src/navigation.rs`) for its camera input, with+ `NavCaps` saying whether it can orbit (off for flat 2D pages) and pick. New canvases must use+ `navigation::handle`; never read drags, the wheel or pinch to move the camera yourself. The+ `hand_rolled_camera_input_is_rejected` test fails if a page does.[AGENTS.md](AGENTS.md) has the long form of these rules. It's written for AI agents, but it'sthe most complete description of the house style.diff --git a/assets/locales/de.json b/assets/locales/de.jsonindex e76befe458..ca1e32789d 100644--- a/assets/locales/de.json+++ b/assets/locales/de.json@@ -867,7 +867,7 @@"render.reload_settings": "Gespeicherte Einstellungen laden","render.unavailable_preview": "Dieses Setup verlangt ein nicht verfügbares Vorschauprofil.","render.use_preview": "Integrierte Vorschau verwenden",- "render.navigation_help": "Ziehen zum Drehen; mit mittlerer Taste ziehen zum Verschieben; scrollen zum Zoomen. Setup speichern übernimmt die aktuelle Kamera.",+ "render.navigation_help": "Die Kamera bewegt sich wie im Konstruieren (Einstellungen › Navigation). Setup speichern übernimmt die aktuelle Kamera.","render.return_design": "Zurück zu Design","render.image_title": "Bild rendern","render.image_help": "CPU-Vorschaubild · PNG · angenäherte Transparenz",diff --git a/assets/locales/en.json b/assets/locales/en.jsonindex 5c57abe95e..8fa712e0d4 100644--- a/assets/locales/en.json+++ b/assets/locales/en.json@@ -1125,7 +1125,7 @@"render.reload_settings": "Reload Saved Settings","render.unavailable_preview": "This setup requests an unavailable preview profile.","render.use_preview": "Use Integrated Preview",- "render.navigation_help": "Drag to orbit; middle-drag to pan; scroll to zoom. Save Setup records the current camera.",+ "render.navigation_help": "The camera moves as in Design (Preferences › Navigation). Save Setup records the current camera.","render.return_design": "Return to Design","render.image_title": "Render Image","render.image_help": "CPU preview image · PNG · approximate transparency",diff --git a/assets/locales/fr.json b/assets/locales/fr.jsonindex b1abe9879f..e5eaf3217a 100644--- a/assets/locales/fr.json+++ b/assets/locales/fr.json@@ -1129,7 +1129,7 @@"render.reload_settings": "Recharger les réglages enregistrés","render.unavailable_preview": "Ce préréglage demande un profil d'aperçu indisponible.","render.use_preview": "Utiliser l'aperçu intégré",- "render.navigation_help": "Faire glisser pour orbiter ; glisser avec le bouton du milieu pour un panoramique ; molette pour zoomer. Enregistrer le préréglage mémorise la caméra actuelle.",+ "render.navigation_help": "La caméra se déplace comme dans Conception (Préférences › Navigation). Enregistrer le préréglage mémorise la caméra actuelle.","render.return_design": "Revenir à la conception","render.image_title": "Image de rendu","render.image_help": "Image d'aperçu CPU · PNG · transparence approximative",diff --git a/assets/locales/ja.json b/assets/locales/ja.jsonindex 05c731fe48..aaabd4eb3a 100644--- a/assets/locales/ja.json+++ b/assets/locales/ja.json@@ -1125,7 +1125,7 @@"render.reload_settings": "保存した設定を再読み込み","render.unavailable_preview": "このセットアップは利用できないプレビュープロファイルを要求しています。","render.use_preview": "統合プレビューを使用",- "render.navigation_help": "ドラッグで回転、中央ボタンのドラッグで移動、スクロールでズームします。「セットアップを保存」で現在のカメラを記録します。",+ "render.navigation_help": "カメラはデザインと同じように動きます(環境設定 › ナビゲーション)。「セットアップを保存」で現在のカメラを記録します。","render.return_design": "設計に戻る","render.image_title": "画像をレンダリング","render.image_help": "CPUプレビュー画像 · PNG · 近似透過",diff --git a/assets/locales/ko.json b/assets/locales/ko.jsonindex b7dd3f8e50..ccc557e2a6 100644--- a/assets/locales/ko.json+++ b/assets/locales/ko.json@@ -867,7 +867,7 @@"render.reload_settings": "저장된 설정 다시 불러오기","render.unavailable_preview": "이 설정은 사용할 수 없는 미리보기 프로필을 요청합니다.","render.use_preview": "통합 미리보기 사용",- "render.navigation_help": "드래그하여 회전하고, 가운데 버튼으로 드래그하여 이동하며, 스크롤하여 확대/축소합니다. 설정 저장은 현재 카메라를 기록합니다.",+ "render.navigation_help": "카메라는 디자인에서와 같이 움직입니다(환경설정 › 탐색). 설정 저장은 현재 카메라를 기록합니다.","render.return_design": "설계로 돌아가기","render.image_title": "이미지 렌더링","render.image_help": "CPU 미리 보기 이미지 · PNG · 근사 투명도",diff --git a/assets/locales/ru.json b/assets/locales/ru.jsonindex 28ab0481da..970cec9216 100644--- a/assets/locales/ru.json+++ b/assets/locales/ru.json@@ -1050,7 +1050,7 @@"render.reload_settings": "Загрузить сохранённые настройки","render.unavailable_preview": "Этот набор запрашивает недоступный профиль предпросмотра.","render.use_preview": "Использовать встроенный предпросмотр",- "render.navigation_help": "Перетаскивайте для вращения, используйте среднюю кнопку для перемещения и колесо для масштаба. Сохранение набора записывает текущую камеру.",+ "render.navigation_help": "Камера управляется так же, как в проектировании (Настройки › Навигация). Сохранение набора записывает текущую камеру.","render.return_design": "Вернуться к проектированию","render.image_title": "Рендеринг изображения","render.image_help": "Предпросмотр на CPU · PNG · приближённая прозрачность",diff --git a/assets/locales/zh.json b/assets/locales/zh.jsonindex 65331f4c38..70fe1d763b 100644--- a/assets/locales/zh.json+++ b/assets/locales/zh.json@@ -1125,7 +1125,7 @@"render.reload_settings": "重新加载已保存设置","render.unavailable_preview": "此设置请求了不可用的预览配置。","render.use_preview": "使用集成预览",- "render.navigation_help": "拖动以旋转,按住中键拖动以平移,滚动以缩放。保存设置会记录当前相机。",+ "render.navigation_help": "相机的操作与设计中相同(首选项 › 导航)。保存设置会记录当前相机。","render.return_design": "返回设计","render.image_title": "渲染图像","render.image_help": "CPU 预览图像 · PNG · 近似透明度",diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex d79edd06e0..431da63f2d 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -96,6 +96,7 @@ pub(crate) mod display_lod;mod file_load_ui_tests;#[cfg(test)]mod fillet_spline_handle_tests;+pub(crate) mod navigation;pub mod palette;pub mod params_dialog;pub mod prefs;@@ -1056,6 +1057,11 @@ impl SolveApp {/// Frame everything shown, keeping the orientation (animated; the selection is ignored).pub fn animate_fit_all(&mut self) {+ if render_workspace::active(self) {+ // The Render preview frames its product scene (see `fit_view`).+ self.fit_view();+ return;+ }self.pending_fit = None;let request = Some((self.cam, viewport::view_bounds(self), true));let to = self.fitted(self.cam);diff --git a/crates/ui-egui/src/navigation.rs b/crates/ui-egui/src/navigation.rsnew file mode 100644index 0000000000..64719c9df3--- /dev/null+++ b/crates/ui-egui/src/navigation.rs@@ -0,0 +1,743 @@+//! Camera navigation shared by every page that shows the model through a camera: the modelling+//! viewport and the Render preview today, and any future canvas (a 2D drawing or flat pattern+//! page calls it with orbit off, so pan and zoom still follow the user's bindings).+//!+//! One entry point, [`handle`], reads a frame's pointer, wheel, trackpad and modifier input over a+//! view and moves `app.cam` the way Preferences › Navigation says: the navigation preset (Fusion,+//! SolidWorks, Blender, Touchpad…), Orbit around, zoom to the cursor, the middle double-click and+//! orbit snapping. The SpaceMouse, view keys and the navigators act on `app.cam` independently of+//! the page. New canvases must call `navigation::handle` rather than reading drags or the wheel+//! themselves; `hand_rolled_camera_input_is_rejected` fails when they do.++use egui::{Pos2, Rect, pos2, vec2};+use serde_json::json;+use solidcraft_engine::geom::Vec3;+use solidcraft_engine::render::Camera;++use crate::SolveApp;+use crate::prefs::{OrbitAround, pivot_under};+use crate::viewport::{Hit, NavMode, axis_rect, nearest_quarter_turn, pick, pick_cached, projection};++/// What a page's camera may do.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) struct NavCaps {+ /// Orbit (and continuous orbit) is allowed; off for flat 2D pages, where pan and zoom remain.+ pub orbit: bool,+ /// What is under the pointer can be picked or dragged, so presses on it don't navigate the+ /// way presses on empty space do (OpenSCAD's left drag, Ctrl+left orbit).+ pub pick: bool,+}++impl NavCaps {+ /// The modelling viewport.+ pub const MODEL: NavCaps = NavCaps { orbit: true, pick: true };+ /// The Render workspace's product preview: the same navigation, nothing to select.+ pub const RENDER: NavCaps = NavCaps { orbit: true, pick: false };+}++/// Raw wheel/trackpad input for one frame, split by source.+///+/// Mouse wheels report lines or pages; trackpads report points. Trackpad+/// scrolls arrive bracketed (`Start` … `Move` … `End`, momentum included)+/// while mouse wheels send bare `Move` events, so phases tell them apart.+pub(crate) struct RawWheel {+ /// Vertical mouse-wheel input in points (zooms).+ zoom: f32,+ /// Trackpad point input, routed like the wheel (zooms when panning is off).+ point_zoom: f32,+ /// Bracketed two-finger scroll in points (pans when panning is on).+ pan: egui::Vec2,+ /// Bare horizontal input in points (thumb wheel: always pans sideways).+ mouse_pan: egui::Vec2,+}++/// Route wheel points to the vertical axis, matching egui's scroll modifiers.+pub(crate) fn route_wheel_vertical(points: egui::Vec2, modifiers: egui::Modifiers, options: egui::InputOptions) -> f32 {+ let horizontal = modifiers.matches_any(options.horizontal_scroll_modifier);+ let vertical = modifiers.matches_any(options.vertical_scroll_modifier);+ if horizontal && !vertical {+ 0.0+ } else if vertical && !horizontal {+ points.x + points.y+ } else {+ points.y+ }+}++/// Match egui's wheel units and modifier routing, without its temporal smoothing.+///+/// `gesture` tracks an ongoing bracketed trackpad scroll (`Start` … `End`):+/// moves inside one pan, bare `Move` input is a mouse (vertical zooms,+/// horizontal pans). Only point input brackets; line/page input always zooms.+pub(crate) fn immediate_wheel(input: &egui::InputState, options: egui::InputOptions, page_height: f32, gesture: &mut bool) -> RawWheel {+ let mut out = RawWheel { zoom: 0.0, point_zoom: 0.0, pan: egui::Vec2::ZERO, mouse_pan: egui::Vec2::ZERO };+ for event in &input.events {+ let egui::Event::MouseWheel { unit, delta, modifiers, phase } = event else { continue };+ if modifiers.matches_any(options.zoom_modifier) {+ continue;+ }+ let point = matches!(unit, egui::MouseWheelUnit::Point);+ match phase {+ egui::TouchPhase::Start => {+ if point {+ *gesture = true;+ }+ continue;+ }+ egui::TouchPhase::End | egui::TouchPhase::Cancel => {+ if point {+ *gesture = false;+ }+ continue;+ }+ egui::TouchPhase::Move => {}+ }+ let points = match unit {+ egui::MouseWheelUnit::Point => *delta,+ egui::MouseWheelUnit::Line => *delta * options.line_scroll_speed,+ egui::MouseWheelUnit::Page => *delta * page_height,+ };+ if point && *gesture {+ out.pan += points;+ // Legacy path only (ignored while panning is on).+ out.point_zoom += route_wheel_vertical(points, *modifiers, options);+ } else if point {+ // Bare moves are a mouse: vertical zooms, horizontal pans sideways.+ // A wheel needs the opposite sign of fingers for the same motion.+ out.zoom += route_wheel_vertical(points, *modifiers, options);+ out.mouse_pan += egui::vec2(-points.x, 0.0);+ } else {+ out.zoom += route_wheel_vertical(points, *modifiers, options);+ }+ }+ out+}++/// Combined pinch-to-zoom factor for one frame (1 = no pinch input).+pub(crate) fn pinch_factor(input: &egui::InputState) -> f32 {+ input+ .events+ .iter()+ .filter_map(|event| {+ let egui::Event::Zoom(f) = event else { return None };+ (*f).is_finite().then_some(*f).filter(|f| *f > 0.0)+ })+ .fold(1.0, |acc, f| acc * f)+}++/// Zoom anchor: the model point under the cursor, else the target's depth.+/// Preferences › Navigation › Zoom to the cursor (off: toward the view's centre).+pub(crate) fn zoom_anchor(app: &mut SolveApp, rect: egui::Rect, hover: Option<egui::Pos2>) -> Option<Vec3> {+ hover.filter(|_| app.preferences.zoom_to_cursor).map(|p| {+ let proj = projection(app, rect);+ // Toward the model's surface under the cursor, else the target's depth.+ if let Some(q) = pick_cached(app, &proj, p).iter().find_map(|h| if let Hit::Face { point, .. } = h { Some(*point) } else { None }) {+ return q;+ }+ let (o, d) = proj.ray(p);+ let n = app.cam.back();+ let den = d.dot(n);+ if den.abs() > 1e-9 { o + d * ((app.cam.target - o).dot(n) / den) } else { app.cam.target }+ })+}++/// Modifier-only navigation never borrows pointer movement from another widget or gesture.+pub(crate) fn modifier_motion(+ app: &mut SolveApp,+ ui: &egui::Ui,+ inside: bool,+ hover: Option<Pos2>,+ mods: egui::Modifiers,+ picking: bool,+) -> Option<(NavMode, egui::Vec2)> {+ let owns = inside+ && ui.input(|i| i.focused && !i.pointer.any_down() && !i.pointer.any_released() && !i.pointer.any_pressed())+ && !ui.ctx().egui_wants_keyboard_input()+ && !egui::Popup::is_any_open(ui.ctx())+ && !crate::dim_view::editing()+ && app.viewport.context_menu.is_none()+ && app.viewport.axis_drag.is_none()+ && app.viewport.point_drag.is_none()+ && app.viewport.text_drag.is_none()+ && app.viewport.boxsel.is_none()+ && !(picking && hover.is_some_and(|p| app.viewport.rect.is_some_and(|rect| crate::canvas::owns_pointer(app, &projection(app, rect), p))))+ && !hover.is_some_and(|p| app.viewport.layout.as_ref().is_some_and(|l| l.navigation.contains(p)));+ let next =+ hover.filter(|p| owns && p.is_finite()).and_then(|p| crate::prefs::nav_preset(&app.preferences.nav).motion_mode(mods).map(|mode| (mode, p)));+ let previous = app.viewport.modifier_nav;+ if previous.map(|(m, _)| m) != next.map(|(m, _)| m) {+ app.viewport.orbit_pivot = None;+ app.viewport.orbit_free = None;+ app.viewport.orbit_snap = None;+ }+ app.viewport.modifier_nav = next;+ next.map(|(mode, p)| {+ let delta = previous.filter(|(m, _)| *m == mode).map_or(egui::Vec2::ZERO, |(_, last)| p - last);+ let delta = if delta.is_finite() && delta.x.abs() <= 1e4 && delta.y.abs() <= 1e4 { delta } else { egui::Vec2::ZERO };+ (mode, delta)+ })+}++/// Continuous camera changes use the same JSON command as programmatic callers.+pub(crate) fn camera_motion(app: &mut SolveApp, rect: Rect, mut params: serde_json::Value) {+ let stored_fov = app.cam.fov;+ params["camera"] = json!(projection(app, rect).cam);+ params["viewport"] = json!([rect.width().max(1.0), rect.height().max(1.0)]);+ let _ = app.run("view.navigate", params);+ app.cam.fov = stored_fov;+}++/// What one frame of camera input saw and did, for the caller's hover, selection and drawing.+pub(crate) struct CameraInput {+ pub hover: Option<Pos2>,+ pub scroll: f32,+ pub mods: egui::Modifiers,+ pub middle: bool,+ pub secondary_down: bool,+ pub primary_down: bool,+ pub primary_pressed: bool,+ pub delta: egui::Vec2,+ /// The pointer is over this view (not a window, menu or the axis view above it).+ pub inside: bool,+ /// The axis view or navigation cube's rectangle.+ pub axes: Rect,+ pub pinch: f32,+ pub pan: egui::Vec2,+ /// The navigation bar's fixed mode, or the preset's left-button binding.+ pub primary_nav: Option<NavMode>,+ /// The navigation this frame's pointer input drives.+ pub mode: Option<NavMode>,+}++/// Camera input for one frame over `rect`: the navigation preset's buttons and modifiers, Orbit+/// around, wheel, trackpad and pinch zoom (to the cursor), middle double-click, continuous orbit+/// and orbit snapping. Every camera page calls this, so the mouse moves the camera the same way+/// in every workspace (#1454). With `caps.pick` off nothing under the pointer is treated as+/// selectable, so a press that would start a selection navigates as on empty space; with+/// `caps.orbit` off, bindings that orbit do nothing and pan and zoom work as usual.+pub(crate) fn handle(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, resp: &egui::Response, caps: NavCaps) -> CameraInput {+ let picking = caps.pick;+ let (hover, scroll, mods, middle, secondary_down, primary_down, primary_pressed, primary_released, delta) = ui.input(|i| {+ (+ i.pointer.hover_pos(),+ i.smooth_scroll_delta.y,+ i.modifiers,+ i.pointer.middle_down(),+ i.pointer.secondary_down(),+ i.pointer.primary_down(),+ i.pointer.primary_pressed(),+ i.pointer.primary_released(),+ i.pointer.delta(),+ )+ });+ // The right button belongs to the marking menu while it is open.+ let secondary_down = secondary_down && app.viewport.context_menu.is_none();+ // The axis view handles its own clicks; the model underneath must not see them.+ let axes = axis_rect(app, rect);+ // Floating windows and menus own input over the model, including wheel navigation. egui's+ // hit test also counts the model as under the pointer a few points past its own edge and+ // inside a window's or a list's edge (#678), so the pointer must be in the viewport too,+ // with no window or menu above it.+ let inside = resp.contains_pointer() && ui.rect_contains_pointer(rect) && hover.is_some_and(|p| !axes.contains(p));+ app.viewport.mouse = hover.filter(|_| inside);+ // Ctrl or Alt held: drawing and dragging don't snap.+ crate::drag_snap::set_suppressed(mods.ctrl || mods.alt || mods.command);+ middle_double_click(app, ui, inside, caps.orbit);++ // ---- navigation ----+ let trackpad_pan = app.preferences.trackpad_pans();+ if !app.preferences.smooth_wheel_zoom {+ app.viewport.wheel_zoom_raw_until_idle = true;+ } else if !ui.input(|i| i.is_scrolling()) {+ app.viewport.wheel_zoom_raw_until_idle = false;+ }+ let options = ui.ctx().options(|o| o.input_options);+ let page_height = ui.ctx().viewport_rect().height();+ let raw = ui.input(|i| immediate_wheel(i, options, page_height, &mut app.viewport.trackpad_gesture));+ if trackpad_pan && raw.pan != egui::Vec2::ZERO {+ // Swallow egui's smoothing tail while the trackpad runs (a wheel-only+ // tail ends the moment trackpad input starts; mixed input is rare).+ app.viewport.trackpad_until_idle = true;+ } else if !ui.input(|i| i.is_scrolling()) {+ app.viewport.trackpad_until_idle = false;+ // Self-healing: with no scroll activity no gesture can be mid-flight+ // (its End was lost); a stuck flag would pan future mouse input.+ app.viewport.trackpad_gesture = false;+ }+ let pan = if trackpad_pan { raw.pan } else { egui::Vec2::ZERO } + raw.mouse_pan;+ let scroll = if app.viewport.wheel_zoom_raw_until_idle || (trackpad_pan && app.viewport.trackpad_until_idle) {+ raw.zoom + if trackpad_pan { 0.0 } else { raw.point_zoom }+ } else {+ scroll+ };+ // Pinch-to-zoom (trackpad): direct manipulation, never smoothed.+ let pinch = ui.input(pinch_factor);+ let h = rect.height().max(1.0) as f64;+ if inside && pinch != 1.0 {+ app.viewport.orbit_snap = None;+ app.viewport.orbit_free = None;+ // Spread zooms in: the camera distance shrinks by the pinch factor.+ let f = f64::from(pinch).powf(-crate::prefs::zoom_sign(app));+ let anchor = zoom_anchor(app, rect, hover);+ if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {+ let mut params = json!({"motion":"zoom", "factor":f.clamp(0.05,20.0)});+ if let Some(anchor) = anchor {+ params["anchor"] = json!(anchor);+ }+ camera_motion(app, rect, params);+ } else {+ app.cancel_view_animation();+ app.cam.zoom_at(f, anchor);+ }+ }+ if inside && scroll != 0.0 {+ app.viewport.orbit_snap = None;+ app.viewport.orbit_free = None;+ let f = (-scroll as f64 * 0.0015 * crate::prefs::zoom_sign(app)).exp();+ let anchor = zoom_anchor(app, rect, hover);+ if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {+ let mut params = json!({"motion":"zoom", "factor":f.clamp(0.05,20.0)});+ if let Some(anchor) = anchor {+ params["anchor"] = json!(anchor);+ }+ camera_motion(app, rect, params);+ } else {+ app.cancel_view_animation();+ app.cam.zoom_at(f, anchor);+ }+ }+ // Two-finger scroll pans the model with the fingers.+ if inside && pan != egui::Vec2::ZERO {+ app.viewport.orbit_snap = None;+ app.viewport.orbit_free = None;+ if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {+ camera_motion(app, rect, json!({"motion":"pan","delta":[pan.x,pan.y]}));+ } else {+ app.cancel_view_animation();+ app.cam.pan(f64::from(pan.x), f64::from(pan.y), h);+ }+ }+ // A left press with the preset's keys (Alias: Shift+Alt) navigates until the button is let+ // go (kept through the release frame, so the end of the drag doesn't select either).+ if primary_pressed && inside {+ let empty_space = |app: &SolveApp| {+ app.viewport.context_menu.is_none()+ && hover.is_some_and(|p| {+ if !picking {+ return true;+ }+ let proj = projection(app, rect);+ pick(app, &proj, p).is_empty() && crate::dim_view::hit(p).is_none() && crate::sketch_tools::glyph_at(p).is_none()+ })+ };+ let openscad_orbit =+ app.preferences.nav == crate::prefs::OPENSCAD_NAV && app.tool.is_none() && app.dialog.is_none() && !mods.shift && empty_space(app);+ let preset = if app.preferences.nav != crate::prefs::OPENSCAD_NAV || openscad_orbit {+ crate::prefs::nav_mode(app, crate::prefs::NavButton::Left, mods)+ } else {+ None+ };+ // Ctrl+left drag from empty space orbits in every preset (Cmd on macOS). A Ctrl+click+ // still selects, and Ctrl on geometry still drags it without snapping.+ let ctrl_orbit = (mods.ctrl || mods.command) && !mods.shift && !mods.alt && empty_space(app);+ app.viewport.primary_nav = preset.or(ctrl_orbit.then_some(NavMode::Orbit));+ } else if !primary_down && !primary_released {+ app.viewport.primary_nav = None;+ }+ // The fixed navigation mode (navigation bar) or the preset's left-button binding.+ let primary_nav = app.viewport.nav.or(app.viewport.primary_nav);+ let button = if middle {+ Some(crate::prefs::NavButton::Middle)+ } else if secondary_down {+ Some(crate::prefs::NavButton::Right)+ } else {+ None+ };+ let dragging = resp.dragged() || (inside && button.is_some());+ // Without orbit (a flat page), bindings that orbit do nothing.+ let allowed = |m: NavMode| caps.orbit || m != NavMode::Orbit;+ let motion = modifier_motion(app, ui, inside, hover, mods, picking).filter(|(m, _)| allowed(*m));+ let mode = motion+ .map(|(m, _)| m)+ .or_else(|| {+ if dragging && app.viewport.axis_drag.is_none() {+ match button {+ Some(b) => crate::prefs::nav_mode(app, b, mods),+ None if primary_down => primary_nav,+ None => None,+ }+ } else {+ None+ }+ })+ .filter(|m| allowed(*m));+ if let Some((mode, delta)) = motion {+ if delta != egui::Vec2::ZERO {+ let mut params = json!({"motion":if mode == NavMode::Pan {"pan"} else {"orbit"},"delta":[delta.x,delta.y]});+ if mode == NavMode::Orbit {+ let pivot = match app.preferences.orbit_around {+ crate::prefs::OrbitAround::ViewCentre => None,+ crate::prefs::OrbitAround::Origin => Some(Vec3::ZERO),+ crate::prefs::OrbitAround::Cursor => Some(match app.viewport.orbit_pivot {+ Some(pivot) => pivot,+ None => {+ let pivot = crate::prefs::pivot_under(app, &projection(app, rect), hover.unwrap_or(rect.center()) - delta);+ app.viewport.orbit_pivot = Some(pivot);+ pivot+ }+ }),+ };+ if let Some(pivot) = pivot {+ params["pivot"] = json!(pivot);+ }+ }+ camera_motion(app, rect, params);+ }+ } else if mode == Some(NavMode::Orbit) {+ let press = ui.input(|i| i.pointer.press_origin());+ app.cancel_view_animation();+ // Shift can be required to enter orbit (Fusion/Inventor middle drag, Alias Shift+Alt),+ // rather than an additional request for snapping. Only an extra modifier snaps.+ let without_shift = egui::Modifiers { shift: false, ..mods };+ let snap = app.preferences.nav != crate::prefs::OPENSCAD_NAV+ && mods.shift+ && match button {+ Some(b) => crate::prefs::nav_mode(app, b, without_shift) == Some(NavMode::Orbit),+ None => app.viewport.nav.is_some(),+ };+ orbit_drag(app, rect, f64::from(delta.x), f64::from(delta.y), press, snap, true);+ } else {+ if matches!(mode, Some(NavMode::Pan | NavMode::Zoom)) {+ app.viewport.orbit_snap = None;+ }+ if app.viewport.axis_drag.is_none() {+ app.viewport.orbit_free = None;+ }+ if delta != egui::Vec2::ZERO {+ if mode.is_some() {+ app.cancel_view_animation();+ }+ match mode {+ Some(NavMode::Pan) => app.cam.pan(f64::from(delta.x), f64::from(delta.y), h),+ Some(NavMode::Zoom) => app.cam.zoom_at((f64::from(delta.y) * 0.01).exp(), None),+ _ => {}+ }+ }+ }+ if !dragging && motion.is_none() {+ app.viewport.orbit_pivot = None;+ }+ if app.viewport.spin {+ // A click on the navigation bar (its own button) is not a stop.+ let bar = app+ .viewport+ .layout+ .as_ref()+ .map(|l| l.navigation)+ .unwrap_or_else(|| Rect::from_center_size(pos2(rect.center().x, rect.bottom() - 22.0), vec2(320.0, 30.0)));+ let (pressed, key, dt) = ui.input(|i| {+ (+ i.pointer.any_pressed() && inside && !i.pointer.press_origin().is_some_and(|p| bar.contains(p)),+ i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. })),+ i.stable_dt,+ )+ });+ if pressed || key || dragging || motion.is_some() || !caps.orbit {+ app.viewport.spin = false;+ } else {+ app.cam.orbit(f64::from(dt.min(0.1)) * 30.0, 0.0);+ ui.ctx().request_repaint();+ }+ }+ if !app.cam.is_valid() {+ app.viewport.orbit_free = None;+ app.viewport.orbit_snap = None;+ app.cam = Camera::default();+ app.fit_view();+ }++ step_orbit_snap(app, rect, ui.input(|i| f64::from(i.stable_dt)));+ if app.viewport.orbit_snap.is_some() {+ ui.ctx().request_repaint();+ }+ CameraInput { hover, scroll, mods, middle, secondary_down, primary_down, primary_pressed, delta, inside, axes, pinch, pan, primary_nav, mode }+}++/// Six principal views, twelve edge diagonals and eight isometric corner directions.+pub(crate) fn snap_directions() -> impl Iterator<Item = Vec3> {+ [-1.0, 0.0, 1.0].into_iter().flat_map(|x| {+ [-1.0, 0.0, 1.0].into_iter().flat_map(move |y| [-1.0, 0.0, 1.0].into_iter().filter_map(move |z| Vec3::new(x, y, z).normalized()))+ })+}++/// Snap to the nearest standard or diagonal direction in the user's up-axis frame.+pub(crate) fn snapped_axis_camera(cam: Camera) -> Camera {+ let b = cam.to_frame(cam.back());+ let dir = snap_directions().max_by(|a, c| a.dot(b).total_cmp(&c.dot(b))).unwrap_or(Vec3::Z);+ let mut to = cam.looking_from(cam.from_frame(dir));+ if dir.x == 0.0 && dir.y == 0.0 {+ to.yaw = nearest_quarter_turn(cam.yaw);+ }+ to+}++pub(crate) struct OrbitSnap {+ pub(crate) target: Camera,+ pub(crate) yaw_velocity: f64,+ pub(crate) pitch_velocity: f64,+ pub(crate) pivot: Option<(Vec3, Pos2)>,+}++/// Pointer motion accumulates independently of the spring preview, so many small deltas+/// still cross snap boundaries. Keep a small angular margin to avoid boundary flicker.+pub(crate) fn orbit_drag(app: &mut SolveApp, rect: Rect, dx: f64, dy: f64, press: Option<Pos2>, snap: bool, around_cursor: bool) {+ let displayed = app.cam;+ if let Some(free) = app.viewport.orbit_free.take() {+ app.cam = free;+ }+ if around_cursor {+ orbit(app, rect, dx, dy, press);+ } else {+ app.cam.orbit(dx, dy);+ }+ let free = app.cam;+ app.viewport.orbit_free = Some(free);+ if snap || !around_cursor || app.viewport.orbit_snap.is_some() {+ let mut target = if snap { snapped_axis_camera(free) } else { free };+ if snap && let Some(previous) = app.viewport.orbit_snap.as_ref() {+ let b = free.back();+ if previous.target.back().dot(b) + 0.025 >= target.back().dot(b) {+ target.yaw = previous.target.yaw;+ target.pitch = previous.target.pitch;+ }+ }+ // The cursor and origin pivots stay still while a snap eases in; the axis gizmo has no+ // pivot (it orbits about the view centre, see `axis_view`).+ let pivot = if around_cursor {+ match app.preferences.orbit_around {+ crate::prefs::OrbitAround::Origin => Some(Vec3::ZERO),+ _ => app.viewport.orbit_pivot,+ }+ } else {+ None+ }+ .and_then(|p| {+ app.cam = displayed;+ projection(app, rect).to_screen(p).map(|at| (p, at))+ });+ let spring = app.viewport.orbit_snap.get_or_insert(OrbitSnap { target, yaw_velocity: 0.0, pitch_velocity: 0.0, pivot });+ spring.target = target;+ spring.pivot = pivot;+ app.cam = displayed;+ }+}++/// A lightly damped spring: mostly settled in about a third of a second, with a small+/// elastic finish. Bounded substeps keep the behavior consistent across frame rates.+pub(crate) fn step_orbit_snap(app: &mut SolveApp, rect: Rect, dt: f64) {+ let Some(mut spring) = app.viewport.orbit_snap.take() else { return };+ let dt = if dt.is_finite() { dt.clamp(0.0, 0.05) } else { 1.0 / 60.0 };+ let steps = (dt * 240.0).ceil().max(1.0) as usize;+ let h = dt / steps as f64;+ let omega = 16.0;+ let damping = 0.82;+ let yaw_error = |yaw: f64| (spring.target.yaw - yaw + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;+ for _ in 0..steps.min(12) {+ spring.yaw_velocity += (omega * omega * yaw_error(app.cam.yaw) - 2.0 * damping * omega * spring.yaw_velocity) * h;+ spring.pitch_velocity += (omega * omega * (spring.target.pitch - app.cam.pitch) - 2.0 * damping * omega * spring.pitch_velocity) * h;+ app.cam.yaw += spring.yaw_velocity * h;+ app.cam.pitch = (app.cam.pitch + spring.pitch_velocity * h).clamp(-std::f64::consts::FRAC_PI_2, std::f64::consts::FRAC_PI_2);+ }+ app.cam.target = spring.target.target;+ let done = yaw_error(app.cam.yaw).abs() < 1e-5+ && (spring.target.pitch - app.cam.pitch).abs() < 1e-5+ && spring.yaw_velocity.abs() < 1e-4+ && spring.pitch_velocity.abs() < 1e-4;+ if done {+ app.cam = spring.target;+ }+ if let Some((pivot, at)) = spring.pivot+ && let Some(after) = projection(app, rect).to_screen(pivot)+ {+ app.cam.pan(f64::from(at.x - after.x), f64::from(at.y - after.y), f64::from(rect.height().max(1.0)));+ }+ if !done {+ app.viewport.orbit_snap = Some(spring);+ }+}++/// A middle-button double-click goes Home (or fits, or nothing: Preferences › Navigation). Only+/// clicks count: a press that moves (a pan or orbit drag) or is held is not one, and the two+/// clicks must both be the middle button's, close together in time and place.+pub(crate) fn middle_double_click(app: &mut SolveApp, ui: &egui::Ui, inside: bool, orbit: bool) {+ use egui::PointerButton::{Extra1, Extra2, Middle, Primary, Secondary};+ let (double, releases, middle, other, dragging) = ui.input(|i| {+ (+ i.pointer.button_double_clicked(Middle),+ i.events.iter().filter(|e| matches!(e, egui::Event::PointerButton { button: Middle, pressed: false, .. })).count(),+ i.pointer.button_clicked(Middle),+ [Primary, Secondary, Extra1, Extra2].into_iter().any(|b| i.pointer.button_clicked(b)),+ i.pointer.is_decidedly_dragging(),+ )+ });+ // egui pairs clicks of any buttons; the first click must have been the middle one too (or+ // both arrive in this frame).+ let go = double && inside && !other && (app.viewport.middle_clicked || releases >= 2);+ app.viewport.middle_clicked = if other || dragging || go { false } else { middle || app.viewport.middle_clicked };+ if !go {+ return;+ }+ match crate::prefs::MiddleDoubleClick::of(app) {+ // Home turns the view; a flat page only frames its content.+ crate::prefs::MiddleDoubleClick::Home if orbit => app.animate_view("home"),+ crate::prefs::MiddleDoubleClick::Home => app.animate_fit_all(),+ crate::prefs::MiddleDoubleClick::Fit => app.animate_fit_all(),+ crate::prefs::MiddleDoubleClick::Off => {}+ }+}++/// Orbit by pixel deltas about the configured centre: the view's centre (default), the world+/// origin, or the model point that was under the cursor when the drag began. The origin and the+/// cursor pivot are kept still on screen; a cursor drag that begins over empty space turns around+/// the centre of the visible geometry instead, so the model never swings around a far-off point.+/// The cursor pivot is chosen once, when the drag begins.+pub fn orbit(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, press: Option<Pos2>) {+ let pivot = match app.preferences.orbit_around {+ OrbitAround::ViewCentre => None,+ OrbitAround::Origin => Some(Vec3::ZERO),+ OrbitAround::Cursor => Some(match app.viewport.orbit_pivot {+ Some(p) => p,+ None => {+ let proj = crate::viewport::projection(app, rect);+ let at = press.unwrap_or(rect.center());+ let p = pivot_under(app, &proj, at);+ app.viewport.orbit_pivot = Some(p);+ p+ }+ }),+ };+ let Some(pivot) = pivot else {+ app.cam.orbit(dx, dy);+ return;+ };+ orbit_about(app, rect, dx, dy, pivot);+}++/// Orbit by pixel deltas, keeping `pivot` still on screen: the camera turns about it and a pan+/// correction puts it back where it was.+pub(crate) fn orbit_about(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, pivot: Vec3) {+ let before = crate::viewport::projection(app, rect).to_screen(pivot);+ app.cam.orbit(dx, dy);+ let after = crate::viewport::projection(app, rect).to_screen(pivot);+ if let (Some(a), Some(b)) = (before, after) {+ app.cam.pan(f64::from(a.x - b.x), f64::from(a.y - b.y), f64::from(rect.height().max(1.0)));+ }+}++#[cfg(test)]+mod tests {+ /// Every page with a camera navigates through [`super::handle`] (#1454). A page that reads+ /// the wheel or moves the view camera itself would drift from the user's navigation settings,+ /// so outside this module (and the SpaceMouse driver, a device rather than a page) the camera+ /// may only be moved through it, the view commands or the navigators.+ #[test]+ fn hand_rolled_camera_input_is_rejected() {+ const PATTERNS: [&str; 7] =+ ["smooth_scroll_delta", "raw_scroll_delta", "zoom_delta()", "cam.orbit(", "cam.pan(", "cam.zoom_at(", "cam.roll_by("];+ let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));+ let dirs = [root.join("src"), root.join("../../apps/solidcraft/src")];+ let allowed = ["navigation.rs", "space_mouse.rs"];+ let mut offenders = Vec::new();+ let mut scanned = 0;+ let mut stack: Vec<std::path::PathBuf> = dirs.iter().filter(|d| d.is_dir()).cloned().collect();+ while let Some(dir) = stack.pop() {+ for entry in std::fs::read_dir(&dir).unwrap().flatten() {+ let path = entry.path();+ let name = path.file_name().and_then(|n| n.to_str()).unwrap_or_default().to_string();+ if path.is_dir() {+ stack.push(path);+ continue;+ }+ if !name.ends_with(".rs") || name.ends_with("_tests.rs") || allowed.contains(&name.as_str()) {+ continue;+ }+ scanned += 1;+ let text = std::fs::read_to_string(&path).unwrap();+ // In-file unit tests set cameras up directly; only the code above them counts.+ let code = text.split("\n#[cfg(test)]\nmod ").next().unwrap_or_default();+ for (n, line) in code.lines().enumerate() {+ if !line.trim_start().starts_with("//") && PATTERNS.iter().any(|p| line.contains(p)) {+ offenders.push(format!("{}:{}: {}", path.display(), n + 1, line.trim()));+ }+ }+ }+ }+ assert!(scanned > 50, "the source tree was scanned ({scanned} files)");+ assert!(offenders.is_empty(), "camera input outside navigation::handle; call it instead:\n{}", offenders.join("\n"));+ }++ /// A flat page (orbit off) pans and zooms with the same bindings and never turns the view.+ #[test]+ fn flat_pages_pan_and_zoom_with_the_same_bindings_but_never_orbit() {+ use egui::{Event, Modifiers, PointerButton, pos2, vec2};+ let flat = super::NavCaps { orbit: false, pick: false };+ for preset in crate::prefs::NAV_PRESETS.iter().map(|p| p.id) {+ let mut s = solidcraft_engine::Session::default();+ s.execute("solid.box", &serde_json::json!({"length":40,"width":30,"height":20})).unwrap();+ let mut app = crate::SolveApp::new(s, crate::Services::default());+ app.preferences.nav = preset.into();+ app.viewport.spin = true;+ let ctx = egui::Context::default();+ let mut time = 0.0;+ let mut frame = |app: &mut crate::SolveApp, mods: Modifiers, events: Vec<Event>| {+ time += 1.0 / 60.0;+ let events = std::iter::once(Event::ModifiersChanged(mods)).chain(events).collect();+ let raw = egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(800.0, 600.0))),+ time: Some(time),+ focused: true,+ events,+ ..Default::default()+ };+ let mut out = ctx.run_ui(raw, |ui| {+ let rect = ui.max_rect();+ app.viewport.rect = Some(rect);+ let resp = ui.interact(rect, ui.id().with("flat"), egui::Sense::click_and_drag());+ super::handle(app, ui, rect, &resp, flat);+ });+ out.textures_delta.clear();+ };+ frame(&mut app, Modifiers::NONE, vec![]);+ assert!(!app.viewport.spin, "{preset}: continuous orbit stops on a flat page");+ let mut panned = false;+ let at = pos2(200.0, 300.0);+ for button in [PointerButton::Primary, PointerButton::Middle, PointerButton::Secondary] {+ for mods in [Modifiers::NONE, Modifiers::SHIFT, Modifiers::CTRL, Modifiers::ALT, Modifiers::SHIFT | Modifiers::ALT] {+ let before = app.cam;+ frame(&mut app, mods, vec![Event::PointerMoved(at)]);+ frame(&mut app, mods, vec![Event::PointerButton { pos: at, button, pressed: true, modifiers: mods }]);+ for k in 1..5 {+ frame(&mut app, mods, vec![Event::PointerMoved(at + vec2(12.0, 7.0) * k as f32)]);+ }+ frame(&mut app, mods, vec![Event::PointerButton { pos: at + vec2(48.0, 28.0), button, pressed: false, modifiers: mods }]);+ frame(&mut app, Modifiers::NONE, vec![]);+ assert_eq!((app.cam.yaw, app.cam.pitch), (before.yaw, before.pitch), "{preset}: {button:?} with {mods:?} turned a flat page");+ panned |= app.cam.target != before.target;+ }+ }+ assert!(panned, "{preset}: some binding pans");+ let before = app.cam;+ let wheel = Event::MouseWheel {+ unit: egui::MouseWheelUnit::Line,+ delta: vec2(0.0, 3.0),+ modifiers: Modifiers::NONE,+ phase: egui::TouchPhase::Move,+ };+ frame(&mut app, Modifiers::NONE, vec![Event::PointerMoved(at), wheel]);+ for _ in 0..20 {+ frame(&mut app, Modifiers::NONE, vec![]);+ }+ assert_ne!(app.cam.distance, before.distance, "{preset}: the wheel zooms");+ }+ }+}diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex 0bd53b4688..c28d63e729 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -604,44 +604,6 @@ pub fn zoom_sign(app: &SolveApp) -> f64 {if app.preferences.zoom_reverse { -1.0 } else { 1.0 }}-/// Orbit by pixel deltas about the configured centre: the view's centre (default), the world-/// origin, or the model point that was under the cursor when the drag began. The origin and the-/// cursor pivot are kept still on screen; a cursor drag that begins over empty space turns around-/// the centre of the visible geometry instead, so the model never swings around a far-off point.-/// The cursor pivot is chosen once, when the drag begins.-pub fn orbit(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, press: Option<Pos2>) {- let pivot = match app.preferences.orbit_around {- OrbitAround::ViewCentre => None,- OrbitAround::Origin => Some(Vec3::ZERO),- OrbitAround::Cursor => Some(match app.viewport.orbit_pivot {- Some(p) => p,- None => {- let proj = crate::viewport::projection(app, rect);- let at = press.unwrap_or(rect.center());- let p = pivot_under(app, &proj, at);- app.viewport.orbit_pivot = Some(p);- p- }- }),- };- let Some(pivot) = pivot else {- app.cam.orbit(dx, dy);- return;- };- orbit_about(app, rect, dx, dy, pivot);-}--/// Orbit by pixel deltas, keeping `pivot` still on screen: the camera turns about it and a pan-/// correction puts it back where it was.-fn orbit_about(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, pivot: Vec3) {- let before = crate::viewport::projection(app, rect).to_screen(pivot);- app.cam.orbit(dx, dy);- let after = crate::viewport::projection(app, rect).to_screen(pivot);- if let (Some(a), Some(b)) = (before, after) {- app.cam.pan(f64::from(a.x - b.x), f64::from(a.y - b.y), f64::from(rect.height().max(1.0)));- }-}-/// The model point under a screen position. Over empty space: the centre of the visible bodies/// and sketches (what Fit frames), or the view's centre when nothing is visible.pub(crate) fn pivot_under(app: &SolveApp, proj: &crate::viewport::Proj, at: Pos2) -> Vec3 {@@ -1521,6 +1483,7 @@ mod tests {}use super::*;+ use crate::navigation::orbit;#[test]fn unsupported_saved_msaa_is_reset_to_the_default_with_a_notice() {diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 6045336c3d..42d2cdbc30 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -438,20 +438,11 @@ fn hash_surface(surface: Option<solidcraft_engine::render::surface::OpaqueSurfacpub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let rect = ui.max_rect();app.viewport.rect = Some(rect);- let response = ui.allocate_rect(rect, Sense::click_and_drag());- let delta = ui.input(|i| i.pointer.delta());- if response.dragged_by(egui::PointerButton::Primary) {- app.cam.orbit(f64::from(delta.x), f64::from(delta.y));- }- if response.dragged_by(egui::PointerButton::Middle) {- app.cam.pan(f64::from(delta.x), f64::from(delta.y), f64::from(rect.height()));- }- if response.hovered() {- let scroll = ui.input(|i| i.smooth_scroll_delta.y);- if scroll != 0.0 {- app.cam.zoom_at((-f64::from(scroll) * 0.0015 * crate::prefs::zoom_sign(app)).exp(), None);- }- }+ crate::viewport::refresh_layout(app, ui.ctx().pixels_per_point());+ let response = ui.interact(rect, ui.id().with("render_preview"), Sense::click_and_drag());+ // The modelling viewport's camera input (preset, Orbit around, zoom to the cursor, middle+ // double-click), with nothing to pick or select here.+ crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps::RENDER);let bg = app.render_workspace.view.draft.background;ui.painter().rect_filled(rect, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2]));let result = (|| -> Result<(), String> {@@ -533,4 +524,5 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {if let Err(error) = result {ui.painter().text(rect.center(), egui::Align2::CENTER_CENTER, error, egui::FontId::proportional(14.0), Tokens::get().text);}+ crate::viewport::axis_view(app, ui, rect);}diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rsindex 4645d703b2..c873df6154 100644--- a/crates/ui-egui/src/render_workspace_tests.rs+++ b/crates/ui-egui/src/render_workspace_tests.rs@@ -470,3 +470,169 @@ fn delayed_image_export_refuses_an_internally_replaced_document_even_with_overwrassert!(matches!(&h.app.status, Some((_, _, true))));}}++/// One frame of either the modelling viewport or the Render preview, over the same rectangle.+fn nav_frame(app: &mut crate::SolveApp, ctx: &egui::Context, render: bool, time: &mut f64, mods: egui::Modifiers, events: Vec<egui::Event>) {+ *time += 1.0 / 60.0;+ let events = std::iter::once(egui::Event::ModifiersChanged(mods)).chain(events).collect();+ let raw = egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0))),+ time: Some(*time),+ focused: true,+ events,+ ..Default::default()+ };+ let mut out = ctx.run_ui(raw, |ui| {+ if render {+ show(app, ui);+ } else {+ crate::viewport::show(app, ui);+ }+ });+ out.textures_delta.clear();+}++fn nav_app(render: bool, preset: &str, around: crate::prefs::OrbitAround) -> crate::SolveApp {+ let mut s = Session::default();+ s.execute("solid.box", &json!({"length":40,"width":30,"height":20,"body_name":"Product"})).unwrap();+ let mut app = crate::SolveApp::new(s, crate::Services::default());+ app.viewport.no_pixels = true;+ if render {+ enter(&mut app, true).unwrap();+ assert!(active(&app));+ }+ app.preferences.nav = preset.into();+ app.preferences.orbit_around = around;+ app.preferences.zoom_to_cursor = true;+ app.ui.perspective = true;+ let mut cam = Camera::default();+ cam.set_view(solidcraft_engine::render::StandardView::Iso);+ cam.fit(&solidcraft_engine::product_scene::extract(&app.session).unwrap().bounds);+ app.cam = cam;+ app+}++/// #1454: the same mouse, wheel and modifier input moves the Render preview's camera exactly as+/// it moves the modelling viewport's, under every navigation preset and Orbit around setting.+#[test]+fn render_preview_navigates_like_the_modelling_viewport_in_every_preset() {+ use egui::{Event, Modifiers, PointerButton, pos2, vec2};+ let none = Modifiers::NONE;+ let chords = [none, Modifiers::SHIFT, Modifiers::CTRL, Modifiers::ALT, Modifiers::SHIFT | Modifiers::ALT];+ let arounds = [crate::prefs::OrbitAround::ViewCentre, crate::prefs::OrbitAround::Cursor, crate::prefs::OrbitAround::Origin];+ for preset in crate::prefs::NAV_PRESETS.iter().map(|p| p.id) {+ for around in arounds {+ let (design_ctx, render_ctx) = (egui::Context::default(), egui::Context::default());+ let mut design = nav_app(false, preset, around);+ let mut render = nav_app(true, preset, around);+ let (mut design_time, mut render_time) = (0.0, 0.0);+ let mut both = |events: Vec<Event>, mods: Modifiers, design: &mut crate::SolveApp, render: &mut crate::SolveApp| {+ nav_frame(design, &design_ctx, false, &mut design_time, mods, events.clone());+ nav_frame(render, &render_ctx, true, &mut render_time, mods, events);+ };+ both(vec![], none, &mut design, &mut render);+ assert_eq!(design.viewport.rect, render.viewport.rect);+ // Presses start on empty space (the Render preview has nothing to pick), and the wheel+ // turns over the model, so zoom to the cursor anchors on its surface.+ let empty = pos2(90.0, 520.0);+ let proj = crate::viewport::projection(&design, design.viewport.rect.unwrap());+ assert!(crate::viewport::pick(&design, &proj, empty).is_empty());+ let model = proj.to_screen(design.cam.target).unwrap();+ assert!(!crate::viewport::pick(&design, &proj, model).is_empty());+ let mut moved = 0;+ for button in [PointerButton::Primary, PointerButton::Middle, PointerButton::Secondary] {+ for mods in chords {+ let before = design.cam;+ both(vec![Event::PointerMoved(empty)], mods, &mut design, &mut render);+ both(vec![Event::PointerButton { pos: empty, button, pressed: true, modifiers: mods }], mods, &mut design, &mut render);+ let mut at = empty;+ for _ in 0..5 {+ at += vec2(14.0, -9.0);+ both(vec![Event::PointerMoved(at)], mods, &mut design, &mut render);+ }+ both(vec![Event::PointerButton { pos: at, button, pressed: false, modifiers: mods }], mods, &mut design, &mut render);+ for _ in 0..30 {+ both(vec![], none, &mut design, &mut render);+ }+ assert_eq!(design.cam, render.cam, "{preset} {around:?}: {button:?} drag with {mods:?}");+ moved += usize::from(design.cam != before);+ // Let any snap settle and start the next gesture from the same view.+ design.cam = render.cam;+ }+ }+ assert!(moved >= 2, "{preset}: the preset's drags move the camera ({moved})");+ // Wheel over the model, then modifier-only motion (Touchpad: Shift pans, Alt orbits).+ let before = design.cam;+ both(vec![Event::PointerMoved(model)], none, &mut design, &mut render);+ let wheel = Event::MouseWheel { unit: egui::MouseWheelUnit::Line, delta: vec2(0.0, 3.0), modifiers: none, phase: egui::TouchPhase::Move };+ both(vec![wheel], none, &mut design, &mut render);+ for _ in 0..30 {+ both(vec![], none, &mut design, &mut render);+ }+ assert_ne!(design.cam, before, "{preset}: the wheel zooms");+ assert_eq!(design.cam, render.cam, "{preset} {around:?}: wheel zoom to the cursor");+ for mods in [Modifiers::SHIFT, Modifiers::ALT] {+ both(vec![Event::PointerMoved(empty)], mods, &mut design, &mut render);+ both(vec![Event::PointerMoved(empty + vec2(25.0, 15.0))], mods, &mut design, &mut render);+ both(vec![Event::PointerMoved(empty)], none, &mut design, &mut render);+ assert_eq!(design.cam, render.cam, "{preset} {around:?}: modifier motion with {mods:?}");+ }+ assert!(render.session.selection.is_empty(), "the Render preview never selects");+ }+ }+}++/// #1454: Fit (F6), a middle double-click, and the axis view's and navigation cube's Home and+/// view controls all work in the Render workspace, framing the product scene.+#[test]+fn render_workspace_view_keys_double_middle_click_and_navigators_work() {+ for style in [crate::prefs::NavigatorStyle::Axes, crate::prefs::NavigatorStyle::Cube] {+ let mut h = Harness::new();+ h.app.preferences.navigator_style = style;+ h.app.preferences.look_at_anim = false;+ h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Product"})).unwrap();+ enter(&mut h.app, true).unwrap();+ h.frames(3);+ let bounds = solidcraft_engine::product_scene::extract(&h.app.session).unwrap().bounds;+ let mut home = h.app.cam;+ home.set_view(solidcraft_engine::render::StandardView::Iso);+ home.fit(&bounds);+ let off = |h: &mut Harness| {+ h.app.cam.yaw += 0.7;+ h.app.cam.pitch = 0.1;+ h.app.cam.distance *= 3.0;+ h.app.cam.target.x += 25.0;+ h.frames(2);+ };+ // F6 fits, keeping the direction.+ off(&mut h);+ let mut fitted = h.app.cam;+ fitted.fit(&bounds);+ h.step(&json!({"key":"F6"})).unwrap();+ h.settle();+ assert_eq!(h.app.cam, fitted, "{style:?}: F6");+ // A middle double-click goes Home.+ off(&mut h);+ let centre = h.app.viewport.rect.unwrap().center();+ h.step(&json!({"click":[centre.x, centre.y], "double":true, "button":"middle"})).unwrap();+ h.settle();+ assert_eq!(h.app.cam, home, "{style:?}: middle double-click");+ // The navigator's Home control.+ off(&mut h);+ let handle = match style {+ crate::prefs::NavigatorStyle::Axes => "axis_view:home",+ crate::prefs::NavigatorStyle::Cube => "navigation_cube:control:home",+ };+ h.step(&json!({"click":{"handle":handle}})).unwrap();+ h.settle();+ assert!(+ (h.app.cam.yaw - home.yaw).abs() < 1e-6 && (h.app.cam.pitch - home.pitch).abs() < 1e-6,+ "{style:?}: navigator Home turns to the home view"+ );+ // A standard view from the navigator.+ h.step(&json!({"click":{"handle":"axis_view:z"}})).unwrap();+ h.settle();+ assert!(h.app.cam.back().dot(solidcraft_engine::geom::Vec3::Z) > 0.999, "{style:?}: view from +Z, got {:?}", h.app.cam.back());+ assert!(h.app.session.selection.is_empty());+ }+}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 2986093524..ddea6402bb 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -11,6 +11,7 @@ use solidcraft_engine::view::{colors, grid_step, sketch_lines_with_sampler};use std::hash::{Hash, Hasher};use crate::gpu::{GpuScene, GpuTarget, SceneSlot, ViewportCallback};+use crate::navigation::{CameraInput, NavCaps, OrbitSnap, orbit_drag};use crate::selection::{BoxSel, origin_quads, origin_size, ray_quad};use crate::theme::Tokens;use crate::{SolveApp, icons};@@ -52,7 +53,7 @@ pub struct ViewportState {/// Each body mesh's box (the mesh held, so its address stays its own), from the last state.mesh_bounds: std::sync::Mutex<std::collections::HashMap<usize, (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::geom::Aabb3)>>,/// The last click in the view was the middle button's (for the middle double-click).- middle_clicked: bool,+ pub(crate) middle_clicked: bool,/// The last pick (its key and hits): reused while nothing it depends on changed.last_pick: Option<(u64, Vec<Hit>)>,pub rect: Option<Rect>,@@ -76,7 +77,7 @@ pub struct ViewportState {/// when the button went down, so the drag neither selects nor moves sketch geometry.pub primary_nav: Option<NavMode>,/// Button-free gesture and its last owned pointer position, kept through pauses.- modifier_nav: Option<(NavMode, Pos2)>,+ pub(crate) modifier_nav: Option<(NavMode, Pos2)>,/// What a click would pick now (after the active command's filter).pub hover: Option<Hit>,pub mouse: Option<Pos2>,@@ -91,13 +92,13 @@ pub struct ViewportState {/// Continuous orbit: the view turns about the vertical until the next click or key.pub spin: bool,/// After immediate zoom, ignore egui's outstanding smoothing until the gesture ends.- wheel_zoom_raw_until_idle: bool,+ pub(crate) wheel_zoom_raw_until_idle: bool,/// While trackpad scrolling runs, ignore egui's smoothing tail for zoom so/// two-finger input is not replayed as zoom after it pans.- trackpad_until_idle: bool,+ pub(crate) trackpad_until_idle: bool,/// Inside a bracketed trackpad scroll (`Start` without its `End` yet):/// point moves pan, bare moves are a mouse.- trackpad_gesture: bool,+ pub(crate) trackpad_gesture: bool,/// A primary press on the axis gizmo: the pointer position used by its last orbit step.pub axis_drag: Option<Pos2>,/// Unsnapped camera while Shift-orbit previews a standard or diagonal view.@@ -1025,7 +1026,7 @@ fn screen_box(proj: &Proj, b: &solidcraft_engine::geom::Aabb3, px: f32) -> Optio/// What is under `pos`, reusing the last answer while the cursor, the camera and the model are/// unchanged.-fn pick_cached(app: &mut SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hit> {+pub(crate) fn pick_cached(app: &mut SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hit> {let mut h = std::collections::hash_map::DefaultHasher::new();pos.x.to_bits().hash(&mut h);pos.y.to_bits().hash(&mut h);@@ -2093,392 +2094,28 @@ pub fn delete_selection(app: &mut SolveApp) {crate::delete::delete_selection(app);}-/// Raw wheel/trackpad input for one frame, split by source.-///-/// Mouse wheels report lines or pages; trackpads report points. Trackpad-/// scrolls arrive bracketed (`Start` … `Move` … `End`, momentum included)-/// while mouse wheels send bare `Move` events, so phases tell them apart.-struct RawWheel {- /// Vertical mouse-wheel input in points (zooms).- zoom: f32,- /// Trackpad point input, routed like the wheel (zooms when panning is off).- point_zoom: f32,- /// Bracketed two-finger scroll in points (pans when panning is on).- pan: egui::Vec2,- /// Bare horizontal input in points (thumb wheel: always pans sideways).- mouse_pan: egui::Vec2,-}--/// Route wheel points to the vertical axis, matching egui's scroll modifiers.-fn route_wheel_vertical(points: egui::Vec2, modifiers: egui::Modifiers, options: egui::InputOptions) -> f32 {- let horizontal = modifiers.matches_any(options.horizontal_scroll_modifier);- let vertical = modifiers.matches_any(options.vertical_scroll_modifier);- if horizontal && !vertical {- 0.0- } else if vertical && !horizontal {- points.x + points.y- } else {- points.y- }-}--/// Match egui's wheel units and modifier routing, without its temporal smoothing.-///-/// `gesture` tracks an ongoing bracketed trackpad scroll (`Start` … `End`):-/// moves inside one pan, bare `Move` input is a mouse (vertical zooms,-/// horizontal pans). Only point input brackets; line/page input always zooms.-fn immediate_wheel(input: &egui::InputState, options: egui::InputOptions, page_height: f32, gesture: &mut bool) -> RawWheel {- let mut out = RawWheel { zoom: 0.0, point_zoom: 0.0, pan: egui::Vec2::ZERO, mouse_pan: egui::Vec2::ZERO };- for event in &input.events {- let egui::Event::MouseWheel { unit, delta, modifiers, phase } = event else { continue };- if modifiers.matches_any(options.zoom_modifier) {- continue;- }- let point = matches!(unit, egui::MouseWheelUnit::Point);- match phase {- egui::TouchPhase::Start => {- if point {- *gesture = true;- }- continue;- }- egui::TouchPhase::End | egui::TouchPhase::Cancel => {- if point {- *gesture = false;- }- continue;- }- egui::TouchPhase::Move => {}- }- let points = match unit {- egui::MouseWheelUnit::Point => *delta,- egui::MouseWheelUnit::Line => *delta * options.line_scroll_speed,- egui::MouseWheelUnit::Page => *delta * page_height,- };- if point && *gesture {- out.pan += points;- // Legacy path only (ignored while panning is on).- out.point_zoom += route_wheel_vertical(points, *modifiers, options);- } else if point {- // Bare moves are a mouse: vertical zooms, horizontal pans sideways.- // A wheel needs the opposite sign of fingers for the same motion.- out.zoom += route_wheel_vertical(points, *modifiers, options);- out.mouse_pan += egui::vec2(-points.x, 0.0);- } else {- out.zoom += route_wheel_vertical(points, *modifiers, options);- }- }- out-}--/// Combined pinch-to-zoom factor for one frame (1 = no pinch input).-fn pinch_factor(input: &egui::InputState) -> f32 {- input- .events- .iter()- .filter_map(|event| {- let egui::Event::Zoom(f) = event else { return None };- (*f).is_finite().then_some(*f).filter(|f| *f > 0.0)- })- .fold(1.0, |acc, f| acc * f)-}--/// Zoom anchor: the model point under the cursor, else the target's depth.-/// Preferences › Navigation › Zoom to the cursor (off: toward the view's centre).-fn zoom_anchor(app: &mut SolveApp, rect: egui::Rect, hover: Option<egui::Pos2>) -> Option<Vec3> {- hover.filter(|_| app.preferences.zoom_to_cursor).map(|p| {- let proj = projection(app, rect);- // Toward the model's surface under the cursor, else the target's depth.- if let Some(q) = pick_cached(app, &proj, p).iter().find_map(|h| if let Hit::Face { point, .. } = h { Some(*point) } else { None }) {- return q;- }- let (o, d) = proj.ray(p);- let n = app.cam.back();- let den = d.dot(n);- if den.abs() > 1e-9 { o + d * ((app.cam.target - o).dot(n) / den) } else { app.cam.target }- })-}--/// Modifier-only navigation never borrows pointer movement from another widget or gesture.-fn modifier_motion(app: &mut SolveApp, ui: &egui::Ui, inside: bool, hover: Option<Pos2>, mods: egui::Modifiers) -> Option<(NavMode, egui::Vec2)> {- let owns = inside- && ui.input(|i| i.focused && !i.pointer.any_down() && !i.pointer.any_released() && !i.pointer.any_pressed())- && !ui.ctx().egui_wants_keyboard_input()- && !egui::Popup::is_any_open(ui.ctx())- && !crate::dim_view::editing()- && app.viewport.context_menu.is_none()- && app.viewport.axis_drag.is_none()- && app.viewport.point_drag.is_none()- && app.viewport.text_drag.is_none()- && app.viewport.boxsel.is_none()- && !hover.is_some_and(|p| app.viewport.rect.is_some_and(|rect| crate::canvas::owns_pointer(app, &projection(app, rect), p)))- && !hover.is_some_and(|p| app.viewport.layout.as_ref().is_some_and(|l| l.navigation.contains(p)));- let next =- hover.filter(|p| owns && p.is_finite()).and_then(|p| crate::prefs::nav_preset(&app.preferences.nav).motion_mode(mods).map(|mode| (mode, p)));- let previous = app.viewport.modifier_nav;- if previous.map(|(m, _)| m) != next.map(|(m, _)| m) {- app.viewport.orbit_pivot = None;- app.viewport.orbit_free = None;- app.viewport.orbit_snap = None;- }- app.viewport.modifier_nav = next;- next.map(|(mode, p)| {- let delta = previous.filter(|(m, _)| *m == mode).map_or(egui::Vec2::ZERO, |(_, last)| p - last);- let delta = if delta.is_finite() && delta.x.abs() <= 1e4 && delta.y.abs() <= 1e4 { delta } else { egui::Vec2::ZERO };- (mode, delta)- })-}--/// Continuous camera changes use the same JSON command as programmatic callers.-fn camera_motion(app: &mut SolveApp, rect: Rect, mut params: serde_json::Value) {- let stored_fov = app.cam.fov;- params["camera"] = json!(projection(app, rect).cam);- params["viewport"] = json!([rect.width().max(1.0), rect.height().max(1.0)]);- let _ = app.run("view.navigate", params);- app.cam.fov = stored_fov;-}-pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let t = Tokens::get();let rect = ui.max_rect();app.viewport.rect = Some(rect);refresh_layout(app, ui.ctx().pixels_per_point());let resp = ui.interact(rect, ui.id().with("viewport"), Sense::click_and_drag());- let (hover, scroll, mods, middle, secondary_down, primary_down, primary_pressed, primary_released, delta) = ui.input(|i| {- (- i.pointer.hover_pos(),- i.smooth_scroll_delta.y,- i.modifiers,- i.pointer.middle_down(),- i.pointer.secondary_down(),- i.pointer.primary_down(),- i.pointer.primary_pressed(),- i.pointer.primary_released(),- i.pointer.delta(),- )- });- // The right button belongs to the marking menu while it is open.- let secondary_down = secondary_down && app.viewport.context_menu.is_none();- // The axis view handles its own clicks; the model underneath must not see them.- let axes = axis_rect(app, rect);- // Floating windows and menus own input over the model, including wheel navigation. egui's- // hit test also counts the model as under the pointer a few points past its own edge and- // inside a window's or a list's edge (#678), so the pointer must be in the viewport too,- // with no window or menu above it.- let inside = resp.contains_pointer() && ui.rect_contains_pointer(rect) && hover.is_some_and(|p| !axes.contains(p));- app.viewport.mouse = hover.filter(|_| inside);- // Ctrl or Alt held: drawing and dragging don't snap.- crate::drag_snap::set_suppressed(mods.ctrl || mods.alt || mods.command);- middle_double_click(app, ui, inside);-- // ---- navigation ----- let trackpad_pan = app.preferences.trackpad_pans();- if !app.preferences.smooth_wheel_zoom {- app.viewport.wheel_zoom_raw_until_idle = true;- } else if !ui.input(|i| i.is_scrolling()) {- app.viewport.wheel_zoom_raw_until_idle = false;- }- let options = ui.ctx().options(|o| o.input_options);- let page_height = ui.ctx().viewport_rect().height();- let raw = ui.input(|i| immediate_wheel(i, options, page_height, &mut app.viewport.trackpad_gesture));- if trackpad_pan && raw.pan != egui::Vec2::ZERO {- // Swallow egui's smoothing tail while the trackpad runs (a wheel-only- // tail ends the moment trackpad input starts; mixed input is rare).- app.viewport.trackpad_until_idle = true;- } else if !ui.input(|i| i.is_scrolling()) {- app.viewport.trackpad_until_idle = false;- // Self-healing: with no scroll activity no gesture can be mid-flight- // (its End was lost); a stuck flag would pan future mouse input.- app.viewport.trackpad_gesture = false;- }- let pan = if trackpad_pan { raw.pan } else { egui::Vec2::ZERO } + raw.mouse_pan;- let scroll = if app.viewport.wheel_zoom_raw_until_idle || (trackpad_pan && app.viewport.trackpad_until_idle) {- raw.zoom + if trackpad_pan { 0.0 } else { raw.point_zoom }- } else {- scroll- };- // Pinch-to-zoom (trackpad): direct manipulation, never smoothed.- let pinch = ui.input(pinch_factor);- let h = rect.height().max(1.0) as f64;- if inside && pinch != 1.0 {- app.viewport.orbit_snap = None;- app.viewport.orbit_free = None;- // Spread zooms in: the camera distance shrinks by the pinch factor.- let f = f64::from(pinch).powf(-crate::prefs::zoom_sign(app));- let anchor = zoom_anchor(app, rect, hover);- if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {- let mut params = json!({"motion":"zoom", "factor":f.clamp(0.05,20.0)});- if let Some(anchor) = anchor {- params["anchor"] = json!(anchor);- }- camera_motion(app, rect, params);- } else {- app.cancel_view_animation();- app.cam.zoom_at(f, anchor);- }- }- if inside && scroll != 0.0 {- app.viewport.orbit_snap = None;- app.viewport.orbit_free = None;- let f = (-scroll as f64 * 0.0015 * crate::prefs::zoom_sign(app)).exp();- let anchor = zoom_anchor(app, rect, hover);- if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {- let mut params = json!({"motion":"zoom", "factor":f.clamp(0.05,20.0)});- if let Some(anchor) = anchor {- params["anchor"] = json!(anchor);- }- camera_motion(app, rect, params);- } else {- app.cancel_view_animation();- app.cam.zoom_at(f, anchor);- }- }- // Two-finger scroll pans the model with the fingers.- if inside && pan != egui::Vec2::ZERO {- app.viewport.orbit_snap = None;- app.viewport.orbit_free = None;- if app.preferences.nav == crate::prefs::TOUCHPAD_NAV {- camera_motion(app, rect, json!({"motion":"pan","delta":[pan.x,pan.y]}));- } else {- app.cancel_view_animation();- app.cam.pan(f64::from(pan.x), f64::from(pan.y), h);- }- }- // A left press with the preset's keys (Alias: Shift+Alt) navigates until the button is let- // go (kept through the release frame, so the end of the drag doesn't select either).- if primary_pressed && inside {- let empty_space = |app: &SolveApp| {- app.viewport.context_menu.is_none()- && hover.is_some_and(|p| {- let proj = projection(app, rect);- pick(app, &proj, p).is_empty() && crate::dim_view::hit(p).is_none() && crate::sketch_tools::glyph_at(p).is_none()- })- };- let openscad_orbit =- app.preferences.nav == crate::prefs::OPENSCAD_NAV && app.tool.is_none() && app.dialog.is_none() && !mods.shift && empty_space(app);- let preset = if app.preferences.nav != crate::prefs::OPENSCAD_NAV || openscad_orbit {- crate::prefs::nav_mode(app, crate::prefs::NavButton::Left, mods)- } else {- None- };- // Ctrl+left drag from empty space orbits in every preset (Cmd on macOS). A Ctrl+click- // still selects, and Ctrl on geometry still drags it without snapping.- let ctrl_orbit = (mods.ctrl || mods.command) && !mods.shift && !mods.alt && empty_space(app);- app.viewport.primary_nav = preset.or(ctrl_orbit.then_some(NavMode::Orbit));- } else if !primary_down && !primary_released {- app.viewport.primary_nav = None;- }- // The fixed navigation mode (navigation bar) or the preset's left-button binding.- let primary_nav = app.viewport.nav.or(app.viewport.primary_nav);- let button = if middle {- Some(crate::prefs::NavButton::Middle)- } else if secondary_down {- Some(crate::prefs::NavButton::Right)- } else {- None- };- let dragging = resp.dragged() || (inside && button.is_some());- let motion = modifier_motion(app, ui, inside, hover, mods);- let mode = motion.map(|(m, _)| m).or_else(|| {- if dragging && app.viewport.axis_drag.is_none() {- match button {- Some(b) => crate::prefs::nav_mode(app, b, mods),- None if primary_down => primary_nav,- None => None,- }- } else {- None- }- });- if let Some((mode, delta)) = motion {- if delta != egui::Vec2::ZERO {- let mut params = json!({"motion":if mode == NavMode::Pan {"pan"} else {"orbit"},"delta":[delta.x,delta.y]});- if mode == NavMode::Orbit {- let pivot = match app.preferences.orbit_around {- crate::prefs::OrbitAround::ViewCentre => None,- crate::prefs::OrbitAround::Origin => Some(Vec3::ZERO),- crate::prefs::OrbitAround::Cursor => Some(match app.viewport.orbit_pivot {- Some(pivot) => pivot,- None => {- let pivot = crate::prefs::pivot_under(app, &projection(app, rect), hover.unwrap_or(rect.center()) - delta);- app.viewport.orbit_pivot = Some(pivot);- pivot- }- }),- };- if let Some(pivot) = pivot {- params["pivot"] = json!(pivot);- }- }- camera_motion(app, rect, params);- }- } else if mode == Some(NavMode::Orbit) {- let press = ui.input(|i| i.pointer.press_origin());- app.cancel_view_animation();- // Shift can be required to enter orbit (Fusion/Inventor middle drag, Alias Shift+Alt),- // rather than an additional request for snapping. Only an extra modifier snaps.- let without_shift = egui::Modifiers { shift: false, ..mods };- let snap = app.preferences.nav != crate::prefs::OPENSCAD_NAV- && mods.shift- && match button {- Some(b) => crate::prefs::nav_mode(app, b, without_shift) == Some(NavMode::Orbit),- None => app.viewport.nav.is_some(),- };- orbit_drag(app, rect, f64::from(delta.x), f64::from(delta.y), press, snap, true);- } else {- if matches!(mode, Some(NavMode::Pan | NavMode::Zoom)) {- app.viewport.orbit_snap = None;- }- if app.viewport.axis_drag.is_none() {- app.viewport.orbit_free = None;- }- if delta != egui::Vec2::ZERO {- if mode.is_some() {- app.cancel_view_animation();- }- match mode {- Some(NavMode::Pan) => app.cam.pan(f64::from(delta.x), f64::from(delta.y), h),- Some(NavMode::Zoom) => app.cam.zoom_at((f64::from(delta.y) * 0.01).exp(), None),- _ => {}- }- }- }- if !dragging && motion.is_none() {- app.viewport.orbit_pivot = None;- }- if app.viewport.spin {- // A click on the navigation bar (its own button) is not a stop.- let bar = app- .viewport- .layout- .as_ref()- .map(|l| l.navigation)- .unwrap_or_else(|| Rect::from_center_size(pos2(rect.center().x, rect.bottom() - 22.0), vec2(320.0, 30.0)));- let (pressed, key, dt) = ui.input(|i| {- (- i.pointer.any_pressed() && inside && !i.pointer.press_origin().is_some_and(|p| bar.contains(p)),- i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. })),- i.stable_dt,- )- });- if pressed || key || dragging || motion.is_some() {- app.viewport.spin = false;- } else {- app.cam.orbit(f64::from(dt.min(0.1)) * 30.0, 0.0);- ui.ctx().request_repaint();- }- }- if !app.cam.is_valid() {- app.viewport.orbit_free = None;- app.viewport.orbit_snap = None;- app.cam = Camera::default();- app.fit_view();- }-- step_orbit_snap(app, rect, ui.input(|i| f64::from(i.stable_dt)));- if app.viewport.orbit_snap.is_some() {- ui.ctx().request_repaint();- }+ let CameraInput {+ hover,+ scroll,+ mods,+ middle,+ secondary_down,+ primary_down,+ primary_pressed,+ delta,+ inside,+ axes,+ pinch,+ pan,+ primary_nav,+ mode,+ } = crate::navigation::handle(app, ui, rect, &resp, NavCaps::MODEL);app.viewport.physical_scale = ui.ctx().pixels_per_point();let proj = projection(app, rect);if let Ok(mut cache) = app.viewport.display.lock() {@@ -3368,7 +3005,7 @@ fn axis_center(app: &SolveApp, rect: Rect) -> Pos2 {axis_rect(app, rect).center()}-fn axis_rect(app: &SolveApp, rect: Rect) -> Rect {+pub(crate) fn axis_rect(app: &SolveApp, rect: Rect) -> Rect {app.viewport.layout.as_ref().filter(|l| l.viewport == rect).map(|l| l.axis_view).unwrap_or_else(|| {let size = axis_view_size(app.preferences.navigator_style);Rect::from_min_size(pos2(rect.right() - size, rect.top()), vec2(size, size))@@ -3393,109 +3030,6 @@ fn axis_hit(tips: &[(&str, Vec3, Pos2, f64)], p: Pos2) -> Option<usize> {tips.iter().enumerate().rev().find(|(_, (_, _, at, _))| at.distance(p) <= AXIS_RADIUS).map(|(i, _)| i)}-/// Six principal views, twelve edge diagonals and eight isometric corner directions.-fn snap_directions() -> impl Iterator<Item = Vec3> {- [-1.0, 0.0, 1.0].into_iter().flat_map(|x| {- [-1.0, 0.0, 1.0].into_iter().flat_map(move |y| [-1.0, 0.0, 1.0].into_iter().filter_map(move |z| Vec3::new(x, y, z).normalized()))- })-}--/// Snap to the nearest standard or diagonal direction in the user's up-axis frame.-fn snapped_axis_camera(cam: Camera) -> Camera {- let b = cam.to_frame(cam.back());- let dir = snap_directions().max_by(|a, c| a.dot(b).total_cmp(&c.dot(b))).unwrap_or(Vec3::Z);- let mut to = cam.looking_from(cam.from_frame(dir));- if dir.x == 0.0 && dir.y == 0.0 {- to.yaw = nearest_quarter_turn(cam.yaw);- }- to-}--pub(crate) struct OrbitSnap {- target: Camera,- yaw_velocity: f64,- pitch_velocity: f64,- pivot: Option<(Vec3, Pos2)>,-}--/// Pointer motion accumulates independently of the spring preview, so many small deltas-/// still cross snap boundaries. Keep a small angular margin to avoid boundary flicker.-fn orbit_drag(app: &mut SolveApp, rect: Rect, dx: f64, dy: f64, press: Option<Pos2>, snap: bool, around_cursor: bool) {- let displayed = app.cam;- if let Some(free) = app.viewport.orbit_free.take() {- app.cam = free;- }- if around_cursor {- crate::prefs::orbit(app, rect, dx, dy, press);- } else {- app.cam.orbit(dx, dy);- }- let free = app.cam;- app.viewport.orbit_free = Some(free);- if snap || !around_cursor || app.viewport.orbit_snap.is_some() {- let mut target = if snap { snapped_axis_camera(free) } else { free };- if snap && let Some(previous) = app.viewport.orbit_snap.as_ref() {- let b = free.back();- if previous.target.back().dot(b) + 0.025 >= target.back().dot(b) {- target.yaw = previous.target.yaw;- target.pitch = previous.target.pitch;- }- }- // The cursor and origin pivots stay still while a snap eases in; the axis gizmo has no- // pivot (it orbits about the view centre, see `axis_view`).- let pivot = if around_cursor {- match app.preferences.orbit_around {- crate::prefs::OrbitAround::Origin => Some(Vec3::ZERO),- _ => app.viewport.orbit_pivot,- }- } else {- None- }- .and_then(|p| {- app.cam = displayed;- projection(app, rect).to_screen(p).map(|at| (p, at))- });- let spring = app.viewport.orbit_snap.get_or_insert(OrbitSnap { target, yaw_velocity: 0.0, pitch_velocity: 0.0, pivot });- spring.target = target;- spring.pivot = pivot;- app.cam = displayed;- }-}--/// A lightly damped spring: mostly settled in about a third of a second, with a small-/// elastic finish. Bounded substeps keep the behavior consistent across frame rates.-fn step_orbit_snap(app: &mut SolveApp, rect: Rect, dt: f64) {- let Some(mut spring) = app.viewport.orbit_snap.take() else { return };- let dt = if dt.is_finite() { dt.clamp(0.0, 0.05) } else { 1.0 / 60.0 };- let steps = (dt * 240.0).ceil().max(1.0) as usize;- let h = dt / steps as f64;- let omega = 16.0;- let damping = 0.82;- let yaw_error = |yaw: f64| (spring.target.yaw - yaw + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;- for _ in 0..steps.min(12) {- spring.yaw_velocity += (omega * omega * yaw_error(app.cam.yaw) - 2.0 * damping * omega * spring.yaw_velocity) * h;- spring.pitch_velocity += (omega * omega * (spring.target.pitch - app.cam.pitch) - 2.0 * damping * omega * spring.pitch_velocity) * h;- app.cam.yaw += spring.yaw_velocity * h;- app.cam.pitch = (app.cam.pitch + spring.pitch_velocity * h).clamp(-std::f64::consts::FRAC_PI_2, std::f64::consts::FRAC_PI_2);- }- app.cam.target = spring.target.target;- let done = yaw_error(app.cam.yaw).abs() < 1e-5- && (spring.target.pitch - app.cam.pitch).abs() < 1e-5- && spring.yaw_velocity.abs() < 1e-4- && spring.pitch_velocity.abs() < 1e-4;- if done {- app.cam = spring.target;- }- if let Some((pivot, at)) = spring.pivot- && let Some(after) = projection(app, rect).to_screen(pivot)- {- app.cam.pan(f64::from(at.x - after.x), f64::from(at.y - after.y), f64::from(rect.height().max(1.0)));- }- if !done {- app.viewport.orbit_snap = Some(spring);- }-}-/// Dragging anywhere on the axis gizmo orbits about the view centre. A stationary press/// on a tip chooses its view. Floating windows own their input over the gizmo.fn axis_view_orbit(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) -> bool {@@ -3528,7 +3062,7 @@ fn axis_view_orbit(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) -> bool {true}-fn axis_view(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {+pub(crate) fn axis_view(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {match app.preferences.navigator_style {crate::prefs::NavigatorStyle::Axes => signed_axis_view(app, ui, rect),crate::prefs::NavigatorStyle::Cube => navigation_cube::show(app, ui, rect),@@ -3591,36 +3125,8 @@ fn signed_axis_view(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {}}-/// A middle-button double-click goes Home (or fits, or nothing: Preferences › Navigation). Only-/// clicks count: a press that moves (a pan or orbit drag) or is held is not one, and the two-/// clicks must both be the middle button's, close together in time and place.-fn middle_double_click(app: &mut SolveApp, ui: &egui::Ui, inside: bool) {- use egui::PointerButton::{Extra1, Extra2, Middle, Primary, Secondary};- let (double, releases, middle, other, dragging) = ui.input(|i| {- (- i.pointer.button_double_clicked(Middle),- i.events.iter().filter(|e| matches!(e, egui::Event::PointerButton { button: Middle, pressed: false, .. })).count(),- i.pointer.button_clicked(Middle),- [Primary, Secondary, Extra1, Extra2].into_iter().any(|b| i.pointer.button_clicked(b)),- i.pointer.is_decidedly_dragging(),- )- });- // egui pairs clicks of any buttons; the first click must have been the middle one too (or- // both arrive in this frame).- let go = double && inside && !other && (app.viewport.middle_clicked || releases >= 2);- app.viewport.middle_clicked = if other || dragging || go { false } else { middle || app.viewport.middle_clicked };- if !go {- return;- }- match crate::prefs::MiddleDoubleClick::of(app) {- crate::prefs::MiddleDoubleClick::Home => app.animate_view("home"),- crate::prefs::MiddleDoubleClick::Fit => app.animate_fit_all(),- crate::prefs::MiddleDoubleClick::Off => {}- }-}-/// At a halfway tie, prefer the square heading nearer the standard plan view.-fn nearest_quarter_turn(yaw: f64) -> f64 {+pub(crate) fn nearest_quarter_turn(yaw: f64) -> f64 {if !yaw.is_finite() {return 0.0;}@@ -3784,6 +3290,7 @@ fn view_menu(app: &mut SolveApp, ui: &mut egui::Ui, button: Rect) -> bool {#[cfg(test)]mod tests {use super::*;+ use crate::navigation::*;/// Bodies drawn from their display plans, evaluated on the GPU, look like the same bodies/// built into triangles on the CPU: the sample design rendered both ways through thediff --git a/docs/render-workspace.md b/docs/render-workspace.mdindex 983a010f9c..261b5b5360 100644--- a/docs/render-workspace.md+++ b/docs/render-workspace.md@@ -43,7 +43,9 @@ discards staged settings. Draft settings are separate for each open document.**Restore Saved Camera** runs `render.settings.apply {name}`, preserving target,distance, yaw, pitch, roll, FOV and up axis as view state. It neither edits the documentnor settles a stale model. The UI honours its up axis in Render; the Design camera-is restored when returning. Drag orbits, middle-drag pans, scrolling zooms, and+is restored when returning. The camera moves exactly as in Design: the navigation preset,+Orbit around, zoom to the cursor, the SpaceMouse, the middle double-click, F6 and the axis+view or navigation cube all work (nothing is picked or selected here), and**Fit Product** frames visible product bodies without including sketches or selection.Preview drafts do not make the document dirty until saved. Unknown backend preferences