Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

feat(ui): offer a cube navigator alongside signed axes (#664)

Karl Von Richter7b34d57b2573
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 22b9d9e021..4ad89a234c 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -53,6 +53,7 @@ mod sketch_modify;
mod sketch_project;
mod surface;
mod surface_analysis;
+mod view_navigation;
use serde::Serialize;
use serde_json::Value;
@@ -219,6 +220,7 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {
v.extend(inspect::COMMANDS.iter());
v.extend(materials::COMMANDS.iter());
v.extend(section::COMMANDS.iter());
+ v.extend(view_navigation::COMMANDS.iter());
v.extend(diagnostics::COMMANDS.iter());
v
}
diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs
new file mode 100644
index 0000000000..a12586d147
--- /dev/null
+++ b/crates/engine/src/cmd/view_navigation.rs
@@ -0,0 +1,131 @@
+//! Stateless camera commands shared by the navigation cube and programmatic callers.
+use serde_json::{Value, json};
+use solidcraft_render::{Camera, StandardView};
+
+use super::CommandSpec;
+use crate::params::{bad, vec3};
+use crate::{Result, Session};
+
+pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("view.navigate", "Navigate View", navigate)
+ .icon("orbit")
+ .noundo()
+ .params("camera: Camera; direction?: [x,y,z] in the camera's up-axis frame; or action: left|right|up|down|clockwise|counterclockwise|home|fit → camera, fit")];
+
+fn navigate(_s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "view.navigate";
+ let mut cam: Camera =
+ serde_json::from_value(p.get("camera").cloned().ok_or_else(|| bad(cmd, "camera is required"))?).map_err(|_| bad(cmd, "invalid camera"))?;
+ if !cam.is_valid()
+ || !cam.fov.is_finite()
+ || !(0.0..std::f64::consts::PI).contains(&cam.fov)
+ || cam.yaw.abs() > 1e6
+ || cam.roll.abs() > 1e6
+ || cam.pitch.abs() > std::f64::consts::FRAC_PI_2
+ {
+ return Err(bad(cmd, "invalid camera"));
+ }
+ let mut fit = false;
+ if let Some(value) = p.get("direction") {
+ let dir = vec3(value)
+ .filter(|v| v.is_finite() && v.len() <= 2.0)
+ .and_then(|v| v.normalized())
+ .ok_or_else(|| bad(cmd, "direction must be a finite nonzero vector of length at most 2"))?;
+ let heading = cam.yaw;
+ cam = cam.looking_from(cam.from_frame(dir));
+ if dir.x.abs() < 1e-9 && dir.y.abs() < 1e-9 {
+ cam.yaw = square_heading(heading);
+ }
+ } else {
+ use std::f64::consts::FRAC_PI_2;
+ let (r, u, _) = cam.basis();
+ match p.get("action").and_then(Value::as_str) {
+ Some("left") => cam = cam.looking_from(-r),
+ Some("right") => cam = cam.looking_from(r),
+ Some("up") => cam = cam.looking_from(u),
+ Some("down") => cam = cam.looking_from(-u),
+ Some("clockwise") => cam.roll = (cam.roll + FRAC_PI_2).rem_euclid(std::f64::consts::TAU),
+ Some("counterclockwise") => cam.roll = (cam.roll - FRAC_PI_2).rem_euclid(std::f64::consts::TAU),
+ Some("home") => {
+ cam.set_view(StandardView::Iso);
+ fit = true;
+ }
+ Some("fit") => fit = true,
+ _ => return Err(bad(cmd, "unknown navigation action")),
+ }
+ }
+ Ok(json!({"camera": cam, "fit": fit}))
+}
+
+/// At a halfway tie prefer the heading nearer the front plan view.
+pub(crate) fn square_heading(yaw: f64) -> f64 {
+ if !yaw.is_finite() {
+ return 0.0;
+ }
+ let q = std::f64::consts::FRAC_PI_2;
+ let lo = (yaw / q).floor() * q;
+ let hi = lo + q;
+ if ((yaw - lo) - (hi - yaw)).abs() < 1e-6 {
+ let off_front = |a: f64| ((a + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI).abs();
+ if off_front(lo) <= off_front(hi) { lo } else { hi }
+ } else if yaw - lo < hi - yaw {
+ lo
+ } else {
+ hi
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use solidcraft_geom::Vec3;
+ use solidcraft_render::UpAxis;
+
+ #[test]
+ fn every_cube_direction_preserves_framing_without_editing_the_design() {
+ for up in [UpAxis::Z, UpAxis::Y] {
+ let mut s = Session::default();
+ let before = s.doc.to_json();
+ let cam = Camera { up, target: Vec3::new(10.0, 20.0, 30.0), distance: 123.0, ..Default::default() };
+ for x in [-1.0, 0.0, 1.0] {
+ for y in [-1.0, 0.0, 1.0] {
+ for z in [-1.0, 0.0, 1.0] {
+ let Some(dir) = Vec3::new(x, y, z).normalized() else { continue };
+ let result = s.execute("view.navigate", &json!({"camera":cam,"direction":[x,y,z]})).unwrap();
+ let to: Camera = serde_json::from_value(result["camera"].clone()).unwrap();
+ assert!(to.back().dist(cam.from_frame(dir)) < 2e-6);
+ assert_eq!((to.target, to.distance, to.fov, to.up), (cam.target, cam.distance, cam.fov, cam.up));
+ }
+ }
+ }
+ assert_eq!(s.doc.to_json(), before);
+ assert!(s.undo.is_empty());
+ }
+ }
+
+ #[test]
+ fn arrows_roll_and_home_are_programmatic_and_reject_hostile_input() {
+ let mut s = Session::default();
+ let cam = Camera::default();
+ let (r, u, _) = cam.basis();
+ for (action, dir) in [("left", -r), ("right", r), ("up", u), ("down", -u)] {
+ let result = navigate(&mut s, &json!({"camera":cam,"action":action})).unwrap();
+ let to: Camera = serde_json::from_value(result["camera"].clone()).unwrap();
+ assert!(to.back().dist(dir) < 2e-6);
+ }
+ let result = navigate(&mut s, &json!({"camera":cam,"action":"clockwise"})).unwrap();
+ let to: Camera = serde_json::from_value(result["camera"].clone()).unwrap();
+ assert_eq!(to.back(), cam.back());
+ assert!((to.basis().0 - u).len() < 1e-9);
+ for action in ["home", "fit"] {
+ assert_eq!(navigate(&mut s, &json!({"camera":cam,"action":action})).unwrap()["fit"], true);
+ }
+ for params in [
+ json!({}),
+ json!({"camera":cam,"direction":[0,0,0]}),
+ json!({"camera":cam,"direction":[1e308,0,0]}),
+ json!({"camera":cam,"action":"unknown"}),
+ ] {
+ assert!(s.execute("view.navigate", &params).is_err());
+ }
+ }
+}
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index b4475b8c3c..f4c5f3a163 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -95,7 +95,12 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->
let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };
let params = p.get("params").cloned().filter(|v| !v.is_null()).unwrap_or(json!({}));
let r = app.run(id, params);
- if r.is_ok() && app.session.active_sketch.is_none() && app.session.world_state().bodies.len() == 1 && app.session.undo.len() <= 2 {
+ if r.is_ok()
+ && id != "view.navigate"
+ && app.session.active_sketch.is_none()
+ && app.session.world_state().bodies.len() == 1
+ && app.session.undo.len() <= 2
+ {
app.fit_view();
}
// After the first-body fit, so a camera the command asked for (`view.apply`) wins.
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 3c447f6390..a9f20ea94a 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -465,6 +465,16 @@ impl SolveApp {
let r = self.session.execute(id, &params).map_err(|e| e.to_string());
self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS;
if let Ok(v) = &r {
+ if id == "view.navigate" {
+ let to: Camera = serde_json::from_value(v.get("camera").cloned().unwrap_or_default()).map_err(|e| e.to_string())?;
+ if v.get("fit").and_then(Value::as_bool).unwrap_or(false) {
+ let bounds = solidcraft_engine::view::bounds(&self.session);
+ self.animate_to(self.fitted(to));
+ self.pending_fit = Some((to, bounds, true));
+ } else {
+ self.animate_to(to);
+ }
+ }
// Curves drawn in construction (or centerline) mode take that line type.
sketch_palette::apply_mode(self, id, v);
}
diff --git a/crates/ui-egui/src/navigation_cube.rs b/crates/ui-egui/src/navigation_cube.rs
new file mode 100644
index 0000000000..fe8fa3cafc
--- /dev/null
+++ b/crates/ui-egui/src/navigation_cube.rs
@@ -0,0 +1,726 @@
+//! Original, code-drawn navigation cube. Flat faces share invisible picking regions.
+use super::*;
+
+pub(super) const SIZE: f32 = 112.0;
+// Paint and picking use the same original coordinate space, scaled as a group.
+pub(super) const DESIGN_SIZE: f32 = 164.0;
+const HALF: f64 = 40.0;
+// Corner squares lie on the six flat faces, preserving a sharp cube silhouette.
+// The remaining regions belong to the face, including the middle of each edge.
+const INSET: f64 = 0.68;
+
+struct Facet {
+ direction: Vec3,
+ points: Vec<Pos2>,
+ outer_edges: Vec<bool>,
+ centre: Pos2,
+ label: String,
+ text_axes: Option<(egui::Vec2, egui::Vec2)>,
+ depth: f64,
+}
+
+fn project(cam: &Camera, v: Vec3, scale: f64) -> egui::Vec2 {
+ let (r, u, _) = cam.basis();
+ let v = cam.from_frame(v);
+ vec2((v.dot(r) * scale) as f32, -(v.dot(u) * scale) as f32)
+}
+
+fn direction_label(d: Vec3) -> String {
+ [(d.z, "BOTTOM", "TOP"), (d.y, "FRONT", "BACK"), (d.x, "LEFT", "RIGHT")]
+ .into_iter()
+ .filter_map(|(v, neg, pos)| {
+ if v < 0.0 {
+ Some(neg)
+ } else if v > 0.0 {
+ Some(pos)
+ } else {
+ None
+ }
+ })
+ .collect::<Vec<_>>()
+ .join(" · ")
+}
+
+fn facets(cam: &Camera, c: Pos2, half: f64) -> Vec<Facet> {
+ if !cam.is_valid() {
+ return Vec::new();
+ }
+ let mut out = Vec::new();
+ let mut add = |d: Vec3, normal: Vec3, mut vertices: Vec<Vec3>, axes: Option<(Vec3, Vec3)>| {
+ let depth = cam.from_frame(normal).dot(cam.back());
+ if depth <= 1e-5 {
+ return;
+ }
+ let centre = vertices.iter().copied().fold(Vec3::ZERO, |sum, p| sum + p) / vertices.len() as f64;
+ let at = c + project(cam, centre, half);
+ vertices.sort_by(|a, b| {
+ let a = project(cam, *a - centre, half);
+ let b = project(cam, *b - centre, half);
+ a.y.atan2(a.x).total_cmp(&b.y.atan2(b.x))
+ });
+ let outer_edges = vertices
+ .iter()
+ .zip(vertices.iter().cycle().skip(1))
+ .take(vertices.len())
+ .map(|(a, b)| [(a.x, b.x), (a.y, b.y), (a.z, b.z)].into_iter().filter(|(a, b)| a.abs() == 1.0 && a == b).count() >= 2)
+ .collect();
+ let points = vertices.into_iter().map(|v| c + project(cam, v, half)).collect();
+ out.push(Facet {
+ direction: d,
+ points,
+ outer_edges,
+ centre: at,
+ label: direction_label(d),
+ text_axes: axes.map(|(r, u)| (project(cam, r, 1.0), -project(cam, u, 1.0))),
+ depth,
+ });
+ };
+ // Nine coplanar patches per square face. The middle and four side patches
+ // share the face target; three corner squares share one isometric target.
+ for (n, r, u) in [
+ (Vec3::X, Vec3::Y, Vec3::Z),
+ (-Vec3::X, -Vec3::Y, Vec3::Z),
+ (Vec3::Y, -Vec3::X, Vec3::Z),
+ (-Vec3::Y, Vec3::X, Vec3::Z),
+ (Vec3::Z, Vec3::X, Vec3::Y),
+ (-Vec3::Z, Vec3::X, -Vec3::Y),
+ ] {
+ let bands = [(-1.0, -INSET, -1.0), (-INSET, INSET, 0.0), (INSET, 1.0, 1.0)];
+ for (x0, x1, sx) in bands {
+ for (y0, y1, sy) in bands {
+ add(
+ if sx != 0.0 && sy != 0.0 { n + r * sx + u * sy } else { n },
+ n,
+ [(x0, y0), (x1, y0), (x1, y1), (x0, y1)].into_iter().map(|(x, y)| n + r * x + u * y).collect(),
+ if sx == 0.0 && sy == 0.0 { Some((r, u)) } else { None },
+ );
+ }
+ }
+ }
+ out.sort_by(|a, b| a.depth.total_cmp(&b.depth));
+ out
+}
+
+fn contains(points: &[Pos2], p: Pos2) -> bool {
+ if !p.is_finite() || points.len() < 3 {
+ return false;
+ }
+ let mut sign = 0.0_f32;
+ for (a, b) in points.iter().zip(points.iter().cycle().skip(1)).take(points.len()) {
+ let edge = *b - *a;
+ let offset = p - *a;
+ let cross = edge.x * offset.y - edge.y * offset.x;
+ if cross.abs() > 1e-3 {
+ if sign != 0.0 && sign.signum() != cross.signum() {
+ return false;
+ }
+ sign = cross;
+ }
+ }
+ sign != 0.0
+}
+
+fn hit(faces: &[Facet], p: Pos2) -> Option<usize> {
+ faces.iter().enumerate().rev().find(|(_, f)| contains(&f.points, p)).map(|(i, _)| i)
+}
+
+pub(super) fn drag_origin(cam: &Camera, centre: Pos2, pointer: Pos2, scale: f32) -> bool {
+ hit(&facets(cam, centre, HALF * f64::from(scale)), pointer).is_some()
+}
+
+// Private marker for label meshes with atlas-pixel UVs. The output hook replaces
+// it with the font texture before any renderer sees the frame.
+const LABEL_PIXELS: egui::TextureId = egui::TextureId::User(u64::from_le_bytes(*b"cubetext"));
+
+struct LabelAtlas;
+
+impl egui::plugin::Plugin for LabelAtlas {
+ fn debug_name(&self) -> &'static str {
+ "navigation cube label atlas"
+ }
+
+ fn output_hook(&mut self, ctx: &egui::Context, output: &mut egui::FullOutput) {
+ let size = ctx.fonts(|f| f.font_image_size());
+ let normalize = vec2(1.0 / size[0].max(1) as f32, 1.0 / size[1].max(1) as f32);
+ for shape in &mut output.shapes {
+ if let Shape::Mesh(mesh) = &mut shape.shape
+ && mesh.texture_id == LABEL_PIXELS
+ {
+ let mesh = std::sync::Arc::make_mut(mesh);
+ mesh.texture_id = egui::TextureId::default();
+ for v in &mut mesh.vertices {
+ v.uv = (v.uv.to_vec2() * normalize).to_pos2();
+ }
+ }
+ }
+ }
+}
+
+/// Warp the font mesh into the projected face, so labels turn with the model.
+fn face_text(painter: &egui::Painter, face: &Facet, ink: Color32, font_size: f32) {
+ let Some((r, down)) = face.text_axes else { return };
+ let opacity = ((face.depth - 0.18) / 0.17).clamp(0.0, 1.0) as f32;
+ if opacity <= 0.0 {
+ return;
+ }
+ let ink = ink.gamma_multiply(opacity);
+ let galley = painter.layout_no_wrap(face.label.clone(), FontId::proportional(font_size), ink);
+ let centre = galley.rect.center();
+ // Keep atlas-pixel UVs until the frame is complete: another label or widget
+ // can grow the atlas after this mesh is created, invalidating early UVs.
+ painter.ctx().add_plugin(LabelAtlas);
+ let text = Shape::Text(egui::epaint::TextShape::new(Pos2::ZERO, galley, ink));
+ let atlas = painter.ctx().fonts(|f| f.font_image_size());
+ let primitives =
+ painter.ctx().tessellate(vec![egui::epaint::ClippedShape { clip_rect: Rect::EVERYTHING, shape: text }], painter.ctx().pixels_per_point());
+ for primitive in primitives {
+ if let egui::epaint::Primitive::Mesh(mut mesh) = primitive.primitive {
+ mesh.texture_id = LABEL_PIXELS;
+ for v in &mut mesh.vertices {
+ v.uv = pos2(v.uv.x * atlas[0] as f32, v.uv.y * atlas[1] as f32);
+ let local = v.pos - centre;
+ v.pos = face.centre + r * local.x + down * (local.y * 1.35);
+ }
+ painter.add(Shape::mesh(mesh));
+ }
+ }
+}
+
+fn paint_cube(painter: &egui::Painter, faces: &[Facet], hovered: Option<usize>, t: Tokens, labels: bool, scale: f32) {
+ // A shared, opaque triangle mesh has no antialiasing fringes between facets.
+ // Per-polygon fringes and miter joins overlap as a face becomes edge-on.
+ let mut fill_mesh = egui::epaint::Mesh::default();
+ let mut edges: Vec<(Pos2, Pos2, usize, bool)> = Vec::new();
+ let hovered_direction = hovered.and_then(|i| faces.get(i)).map(|f| f.direction);
+ for face in faces {
+ let base = t.cube_face;
+ let shade = (0.72 + 0.28 * face.depth.min(1.0)) as f32;
+ let highlighted = hovered_direction == Some(face.direction);
+ let fill = if highlighted {
+ t.cube_hover
+ } else {
+ Color32::from_rgb((f32::from(base.r()) * shade) as u8, (f32::from(base.g()) * shade) as u8, (f32::from(base.b()) * shade) as u8)
+ };
+ let centre = fill_mesh.vertices.len() as u32;
+ fill_mesh.colored_vertex(face.centre, fill);
+ for &p in &face.points {
+ fill_mesh.colored_vertex(p, fill);
+ }
+ for (j, (&a, &b)) in face.points.iter().zip(face.points.iter().cycle().skip(1)).take(face.points.len()).enumerate() {
+ fill_mesh.add_triangle(centre, centre + 1 + j as u32, centre + 1 + ((j + 1) % face.points.len()) as u32);
+ // Coplanar picking regions have no visible seams. Only actual cube
+ // edges and the hovered target's boundary receive an outline.
+ let outer = face.outer_edges.get(j).copied().unwrap_or(false);
+ if !highlighted && !outer {
+ continue;
+ }
+ if let Some(edge) = edges
+ .iter_mut()
+ .find(|(p, q, _, _)| (p.distance_sq(a) < 1e-6 && q.distance_sq(b) < 1e-6) || (p.distance_sq(b) < 1e-6 && q.distance_sq(a) < 1e-6))
+ {
+ edge.2 += usize::from(highlighted);
+ edge.3 |= outer;
+ } else {
+ edges.push((a, b, usize::from(highlighted), outer));
+ }
+ }
+ }
+ painter.add(Shape::mesh(fill_mesh));
+ for (a, b, highlights, outer) in edges {
+ // Two highlighted coplanar patches share an internal subdivision, not
+ // a target boundary. Actual cube edges remain visible across faces.
+ if !outer && highlights != 1 {
+ continue;
+ }
+ let highlighted = highlights > 0;
+ painter.line_segment([a, b], Stroke::new(1.0, if highlighted { t.accent } else { t.cube_border }));
+ }
+ if labels {
+ for face in faces {
+ face_text(painter, face, t.cube_text, 14.0 * scale);
+ }
+ }
+}
+
+fn navigate(app: &mut SolveApp, action: Option<&str>, dir: Option<Vec3>) {
+ let mut params = json!({"camera":app.cam});
+ if let Some(action) = action {
+ params["action"] = json!(action);
+ }
+ if let Some(d) = dir {
+ params["direction"] = json!([d.x, d.y, d.z]);
+ }
+ let _ = app.run("view.navigate", params);
+}
+
+fn control(app: &mut SolveApp, ui: &mut egui::Ui, bounds: Rect, action: &str, tooltip: &str) -> bool {
+ crate::scenario::publish_handle(&format!("navigation_cube:control:{action}"), bounds.center());
+ let response = ui.interact(bounds, ui.id().with(("navigation_cube", action)), Sense::click()).on_hover_text(tooltip);
+ let hover = response.hovered();
+ if response.clicked() {
+ navigate(app, Some(action), None);
+ }
+ hover
+}
+
+fn arrow(painter: &egui::Painter, at: Pos2, direction: egui::Vec2, hover: bool, t: Tokens) {
+ let side = vec2(-direction.y, direction.x);
+ painter.add(Shape::convex_polygon(
+ vec![at + direction * 7.0, at - direction * 5.0 + side * 7.0, at - direction * 5.0 - side * 7.0],
+ if hover { t.accent_soft } else { t.cube_face },
+ Stroke::new(1.0, if hover { t.accent } else { t.cube_border }),
+ ));
+}
+
+fn curved_arrow(painter: &egui::Painter, at: Pos2, clockwise: bool, hover: bool, t: Tokens, scale: f32) {
+ let (start, end) =
+ if clockwise { (-std::f32::consts::FRAC_PI_4 + 0.12, 0.0) } else { (-std::f32::consts::FRAC_PI_4 - 0.12, -std::f32::consts::FRAC_PI_2) };
+ let points: Vec<_> = (0..=16)
+ .map(|i| {
+ let angle = egui::lerp(start..=end, f32::from(i as u8) / 16.0);
+ at + vec2(angle.cos(), angle.sin()) * (32.0 * scale)
+ })
+ .collect();
+ painter.add(Shape::line(points.clone(), Stroke::new(5.0 * scale, if hover { t.accent } else { t.cube_border })));
+ painter.add(Shape::line(points.clone(), Stroke::new(3.0 * scale, if hover { t.accent_soft } else { t.cube_face })));
+ if let Some(tip) = points.last() {
+ let sign = if clockwise { 1.0 } else { -1.0 };
+ arrow(painter, *tip, vec2(-end.sin(), end.cos()) * (sign * scale), hover, t);
+ }
+}
+
+pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {
+ let outer = axis_rect(app, rect);
+ if !outer.is_positive() {
+ app.viewport.axis_drag = None;
+ crate::scenario::publish_count("axis_view_highlights", 0.0);
+ return;
+ }
+ crate::scenario::publish_rect("axis_view:outer", outer);
+ let scale = outer.width() / DESIGN_SIZE;
+ let c = axis_center(app, rect);
+ let orbiting = axis_view_orbit(app, ui, rect);
+ let active = orbiting || ui.rect_contains_pointer(outer);
+ let t = Tokens::get().navigation_cube(active);
+ crate::scenario::publish_count("navigation_cube:active", f64::from(u8::from(active)));
+ let faces = facets(&app.cam, c, HALF * f64::from(scale));
+ let hover = ui.input(|i| i.pointer.hover_pos()).filter(|_| ui.rect_contains_pointer(rect));
+ let hovered = if orbiting { None } else { hover.and_then(|p| hit(&faces, p)) };
+ let painter = ui.painter_at(outer);
+ paint_cube(&painter, &faces, hovered, t, true, scale);
+ for (i, face) in faces.iter().enumerate() {
+ if faces.iter().take(i).any(|f| f.direction == face.direction) {
+ continue;
+ }
+ let pieces: Vec<_> = faces.iter().filter(|f| f.direction == face.direction).collect();
+ let centre = pieces.iter().fold(egui::Vec2::ZERO, |sum, f| sum + f.centre.to_vec2()) / pieces.len() as f32;
+ crate::scenario::publish_handle(&format!("navigation_cube:{}", face.label.to_ascii_lowercase().replace(" · ", "_")), centre.to_pos2());
+ // Keep principal-axis handles for existing automation, using only visible faces.
+ let world = app.cam.from_frame(face.direction);
+ let axis = match (world.x, world.y, world.z) {
+ (1.0, 0.0, 0.0) => Some("x"),
+ (-1.0, 0.0, 0.0) => Some("-x"),
+ (0.0, 1.0, 0.0) => Some("y"),
+ (0.0, -1.0, 0.0) => Some("-y"),
+ (0.0, 0.0, 1.0) => Some("z"),
+ (0.0, 0.0, -1.0) => Some("-z"),
+ _ => None,
+ };
+ if let Some(axis) = axis {
+ crate::scenario::publish_handle(&format!("axis_view:{axis}"), centre.to_pos2());
+ }
+ }
+ crate::scenario::publish_count("axis_view_highlights", f64::from(u8::from(hovered.is_some())));
+ if let Some(face) = hovered.and_then(|i| faces.get(i)) {
+ ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
+ ui.interact(Rect::from_center_size(hover.unwrap_or(face.centre), vec2(2.0, 2.0)), ui.id().with("navigation_cube_tip"), Sense::hover())
+ .on_hover_text(format!("{} view. Drag to orbit; hold Shift to snap.", face.label));
+ if ui.input(|i| i.pointer.primary_clicked()) {
+ navigate(app, None, Some(face.direction));
+ }
+ }
+ let square_on = faces.iter().filter(|f| f.text_axes.is_some()).count() == 1;
+ let (distance, button_size) = if square_on { (54.0, 20.0) } else { (74.0, 16.0) };
+ for (action, offset, direction, tooltip) in [
+ ("left", vec2(-distance, 0.0), vec2(1.0, 0.0), "Orbit left 90°"),
+ ("right", vec2(distance, 0.0), vec2(-1.0, 0.0), "Orbit right 90°"),
+ ("up", vec2(0.0, -distance), vec2(0.0, 1.0), "Orbit up 90°"),
+ ("down", vec2(0.0, distance), vec2(0.0, -1.0), "Orbit down 90°"),
+ ] {
+ let at = c + offset * scale;
+ let hovered = control(app, ui, Rect::from_center_size(at, vec2(button_size, button_size) * scale), action, tooltip);
+ if active {
+ arrow(&painter, at, direction * scale, hovered, t);
+ }
+ }
+ for (action, offset, size, clockwise, tooltip) in [
+ ("counterclockwise", vec2(42.0, -72.0), vec2(40.0, 20.0), false, "Rotate view counterclockwise 90°"),
+ ("clockwise", vec2(72.0, -42.0), vec2(20.0, 40.0), true, "Rotate view clockwise 90°"),
+ ] {
+ let hovered = control(app, ui, Rect::from_center_size(c + offset * scale, size * scale), action, tooltip);
+ if active {
+ curved_arrow(&painter, c + vec2(42.0, -42.0) * scale, clockwise, hovered, t, scale);
+ }
+ }
+ let home = Rect::from_center_size(c + vec2(-65.0, -65.0) * scale, vec2(26.0, 26.0) * scale);
+ crate::scenario::publish_rect("axis_view:home", home);
+ crate::scenario::publish_handle("axis_view:home", home.center());
+ let home_hover = control(app, ui, home, "home", "Home: isometric view and fit model");
+ if active {
+ icons::paint(&painter, home.shrink(4.0 * scale), "home", if home_hover { t.accent } else { t.cube_face }, t.cube_face, t.accent);
+ }
+ let fit = Rect::from_center_size(c + vec2(67.0, 67.0) * scale, vec2(22.0, 22.0) * scale);
+ let fit_hover = control(app, ui, fit, "fit", "Fit model in view");
+ if active {
+ painter.circle(fit.center(), 6.0 * scale, if fit_hover { t.accent_soft } else { t.cube_face }, Stroke::new(1.0, t.cube_border));
+ }
+ // Small world-axis triad below the cube; it follows the selected up-axis frame.
+ let origin = c + vec2(-60.0, 52.0) * scale;
+ for (d, color, label) in [(Vec3::X, t.axis_x, "X"), (Vec3::Y, t.axis_y, "Y"), (Vec3::Z, t.axis_z, "Z")] {
+ let (r, u, _) = app.cam.basis();
+ let tip = origin + vec2((d.dot(r) * 17.0) as f32, -(d.dot(u) * 17.0) as f32) * scale;
+ painter.line_segment([origin, tip], Stroke::new(1.5, color));
+ painter.text(tip, Align2::CENTER_CENTER, label, FontId::proportional(8.0), color);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use solidcraft_engine::render::{StandardView, UpAxis};
+
+ fn paint_frame(ctx: &egui::Context, paint: impl FnMut(&mut egui::Ui)) -> egui::FullOutput {
+ let mut output = ctx.run_ui(egui::RawInput::default(), paint);
+ // These tests inspect shapes without uploading textures to a renderer.
+ output.textures_delta.clear();
+ output
+ }
+
+ #[test]
+ fn cube_targets_are_only_six_faces_and_eight_corners_in_both_up_frames() {
+ for up in [UpAxis::Z, UpAxis::Y] {
+ let mut directions = Vec::new();
+ for view in [StandardView::Front, StandardView::Back, StandardView::Top, StandardView::Bottom, StandardView::Left, StandardView::Right] {
+ let mut cam = Camera { up, ..Default::default() };
+ cam.set_view(view);
+ for facet in facets(&cam, Pos2::ZERO, HALF) {
+ let axes = [facet.direction.x, facet.direction.y, facet.direction.z].into_iter().filter(|v| *v != 0.0).count();
+ assert!(axes == 1 || axes == 3, "cube edges must not be independent targets: {}", facet.label);
+ if !directions.contains(&facet.direction) {
+ directions.push(facet.direction);
+ }
+ }
+ }
+ assert_eq!(directions.len(), 14);
+ }
+ }
+
+ #[test]
+ fn former_edge_strips_click_the_face_and_hover_without_internal_seams() {
+ let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
+ let ctx = egui::Context::default();
+ h.app.preferences.look_at_anim = false;
+ for up in ["z", "y"] {
+ h.call("ui.prefs", json!({"up_axis":up}));
+ h.call("ui.view", json!({"view":"front"}));
+ let camera = h.app.cam;
+ let outer = crate::scenario::rect_of("axis_view:outer").unwrap();
+ let half = HALF * f64::from(outer.width() / DESIGN_SIZE);
+ let faces = facets(&camera, outer.center(), half);
+ assert!(crate::scenario::handle_at("navigation_cube:front_right").is_none());
+ assert!(crate::scenario::handle_at("navigation_cube:top_front").is_none());
+ for direction in [Vec3::X, -Vec3::X, Vec3::Z, -Vec3::Z] {
+ let p = outer.center() + project(&camera, direction * 0.84, half);
+ let hovered = hit(&faces, p).unwrap();
+ assert_eq!(faces[hovered].direction, -Vec3::Y);
+ h.call("ui.move", json!({"x":p.x,"y":p.y}));
+ h.call("ui.click", json!({"x":p.x,"y":p.y}));
+ assert_eq!(h.app.cam, camera, "a former edge strip must select FRONT, never a diagonal view");
+ let t = Tokens::light();
+ let output = paint_frame(&ctx, |ui| {
+ paint_cube(ui.painter(), &faces, Some(hovered), t, false, 1.0);
+ });
+ let centre = Rect::from_center_size(outer.center(), vec2(2.0, 2.0) * (INSET * half) as f32);
+ let mut outline = 0;
+ for shape in &output.shapes {
+ if let Shape::LineSegment { points: [a, b], stroke } = &shape.shape
+ && stroke.color == t.accent
+ {
+ outline += 1;
+ assert!(!centre.contains(a.lerp(*b, 0.5)), "face subdivisions must not draw hover seams");
+ }
+ }
+ assert_eq!(outline, 12, "one continuous face outline around the four corner targets");
+ }
+ }
+ }
+
+ #[test]
+ fn hovering_cube_sections_activates_then_leaving_restores_idle_without_navigation() {
+ let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
+ let camera = h.app.cam;
+ let design = h.app.session.doc.to_json();
+ let viewport = h.app.viewport.rect.unwrap();
+ for name in ["front", "right", "top_front_right"] {
+ let p = crate::scenario::handle_at(&format!("navigation_cube:{name}")).unwrap();
+ h.call("ui.move", json!({"x":p.x,"y":p.y}));
+ assert_eq!(crate::scenario::count_of("navigation_cube:active"), Some(1.0));
+ assert_eq!(crate::scenario::count_of("axis_view_highlights"), Some(1.0));
+ h.call("ui.move", json!({"x":viewport.center().x,"y":viewport.center().y}));
+ assert_eq!(crate::scenario::count_of("navigation_cube:active"), Some(0.0));
+ assert_eq!(crate::scenario::count_of("axis_view_highlights"), Some(0.0));
+ }
+ // Reveal auxiliary controls even before the pointer touches a facet.
+ let p = crate::scenario::handle_at("navigation_cube:control:home").unwrap();
+ h.call("ui.move", json!({"x":p.x,"y":p.y}));
+ assert_eq!(crate::scenario::count_of("navigation_cube:active"), Some(1.0));
+ assert_eq!(crate::scenario::count_of("axis_view_highlights"), Some(0.0));
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(h.app.session.doc.to_json(), design);
+ assert!(h.app.session.undo.is_empty());
+ }
+
+ #[test]
+ fn hovered_face_and_corner_have_a_pale_blue_opaque_fill_in_both_themes() {
+ let ctx = egui::Context::default();
+ let faces = facets(&Camera::default(), pos2(100.0, 100.0), HALF);
+ for t in [Tokens::light(), Tokens::dark()] {
+ assert_ne!(t.navigation_cube(false).cube_face, t.cube_face);
+ for name in ["FRONT", "RIGHT", "TOP · FRONT · RIGHT"] {
+ let hovered = faces.iter().position(|f| f.label == name).unwrap();
+ let output = paint_frame(&ctx, |ui| {
+ paint_cube(ui.painter(), &faces, Some(hovered), t.navigation_cube(true), false, 1.0);
+ });
+ let mesh = output.shapes.iter().find_map(|s| if let Shape::Mesh(m) = &s.shape { Some(m) } else { None }).unwrap();
+ let highlighted: Vec<_> = mesh.vertices.iter().filter(|v| v.color == t.cube_hover).collect();
+ let pieces: Vec<_> = faces.iter().filter(|f| f.direction == faces[hovered].direction).collect();
+ assert_eq!(
+ highlighted.len(),
+ pieces.iter().map(|f| f.points.len() + 1).sum::<usize>(),
+ "highlight the same target on adjacent flat faces"
+ );
+ assert!(highlighted.iter().all(|v| pieces.iter().any(|f| contains(&f.points, v.pos))));
+ assert!(mesh.vertices.iter().all(|v| v.color.a() == 255));
+ assert!(output.shapes.iter().any(|s| matches!(&s.shape, Shape::LineSegment { stroke, .. } if stroke.color == t.accent)));
+ }
+ }
+ }
+
+ #[test]
+ fn idle_principal_views_have_square_faces_without_visible_picking_seams() {
+ let ctx = egui::Context::default();
+ for up in [UpAxis::Z, UpAxis::Y] {
+ for view in [StandardView::Front, StandardView::Back, StandardView::Top, StandardView::Bottom, StandardView::Left, StandardView::Right] {
+ let mut cam = Camera { up, ..Default::default() };
+ cam.set_view(view);
+ let centre = pos2(100.0, 100.0);
+ let faces = facets(&cam, centre, HALF);
+ assert_eq!(faces.len(), 9, "one square face partitioned into nine coplanar picking regions");
+ let bounds = Rect::from_points(&faces.iter().flat_map(|f| f.points.iter().copied()).collect::<Vec<_>>());
+ let expected = Rect::from_center_size(centre, vec2(80.0, 80.0));
+ assert!(
+ bounds.min.distance(expected.min) < 1e-4 && bounds.max.distance(expected.max) < 1e-4,
+ "the silhouette must reach all four square corners"
+ );
+ let output = paint_frame(&ctx, |ui| {
+ paint_cube(ui.painter(), &faces, None, Tokens::light(), false, 1.0);
+ });
+ let mesh = output.shapes.iter().find_map(|s| if let Shape::Mesh(m) = &s.shape { Some(m) } else { None }).unwrap();
+ let fill = mesh.vertices.first().unwrap().color;
+ assert!(mesh.vertices.iter().all(|v| v.color == fill), "picking regions must have identical face shading");
+ for s in &output.shapes {
+ if let Shape::LineSegment { points: [a, b], .. } = &s.shape {
+ assert!(
+ (a.x - expected.left()).abs() < 1e-4 && (b.x - expected.left()).abs() < 1e-4
+ || (a.x - expected.right()).abs() < 1e-4 && (b.x - expected.right()).abs() < 1e-4
+ || (a.y - expected.top()).abs() < 1e-4 && (b.y - expected.top()).abs() < 1e-4
+ || (a.y - expected.bottom()).abs() < 1e-4 && (b.y - expected.bottom()).abs() < 1e-4,
+ "idle outlines must lie on the cube perimeter, never on a picking boundary"
+ );
+ }
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn projected_facets_pick_their_own_centres_in_all_views_and_up_frames() {
+ for up in [UpAxis::Z, UpAxis::Y] {
+ for view in [
+ StandardView::Front,
+ StandardView::Back,
+ StandardView::Top,
+ StandardView::Bottom,
+ StandardView::Left,
+ StandardView::Right,
+ StandardView::Iso,
+ ] {
+ let mut cam = Camera { up, ..Default::default() };
+ cam.set_view(view);
+ for roll in [0.0, 0.7, std::f64::consts::FRAC_PI_2] {
+ cam.roll = roll;
+ let faces = facets(&cam, Pos2::ZERO, HALF);
+ assert!(!faces.is_empty());
+ for (i, face) in faces.iter().enumerate() {
+ assert_eq!(hit(&faces, face.centre), Some(i), "{up:?} {view:?} {roll} {}", face.label);
+ }
+ assert!(hit(&faces, pos2(80.0, 80.0)).is_none());
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn face_labels_use_normalized_font_atlas_coordinates() {
+ let ctx = egui::Context::default();
+ let output = paint_frame(&ctx, |ui| {
+ let faces = facets(&Camera::default(), pos2(100.0, 100.0), HALF);
+ for face in &faces {
+ face_text(ui.painter(), face, Tokens::light().cube_text, 14.0);
+ }
+ });
+ let meshes: Vec<_> = output.shapes.iter().filter_map(|shape| if let Shape::Mesh(mesh) = &shape.shape { Some(mesh) } else { None }).collect();
+ assert_eq!(meshes.len(), 3, "the isometric view must show three face labels");
+ for mesh in meshes {
+ assert!(!mesh.vertices.is_empty());
+ assert!(mesh.vertices.iter().all(|v| (0.0..=1.0).contains(&v.uv.x) && (0.0..=1.0).contains(&v.uv.y)));
+ }
+ }
+
+ #[test]
+ fn label_uvs_follow_font_atlas_growth_later_in_the_same_frame() {
+ let ctx = egui::Context::default();
+ let mut pixel_uv = Pos2::ZERO;
+ let mut glyph_vertex = 0;
+ let mut early_size = [0; 2];
+ let output = paint_frame(&ctx, |ui| {
+ let mut cam = Camera::default();
+ cam.set_view(StandardView::Top);
+ let faces = facets(&cam, pos2(100.0, 100.0), HALF);
+ let face = faces.iter().find(|f| f.label == "TOP" && f.text_axes.is_some()).unwrap();
+ let galley = ui.painter().layout_no_wrap(face.label.clone(), FontId::proportional(14.0), Tokens::light().cube_text);
+ let (index, vertex) = galley.rows.first().unwrap().visuals.mesh.vertices.iter().enumerate().find(|(_, v)| v.uv.y > 1.0).unwrap();
+ glyph_vertex = index;
+ pixel_uv = vertex.uv;
+ face_text(ui.painter(), face, Tokens::light().cube_text, 14.0);
+ early_size = ctx.fonts(|f| f.font_image_size());
+ // Other widgets can allocate new glyphs after the cube has been drawn.
+ let text: String = (32_u8..127).map(char::from).collect();
+ let _ = ui.painter().layout_no_wrap(text, FontId::proportional(48.0), Color32::WHITE);
+ });
+ let size = ctx.fonts(|f| f.font_image_size());
+ assert!(size[1] > early_size[1], "the reproduction must grow the font atlas");
+ let vertex = output.shapes.iter().find_map(|s| if let Shape::Mesh(m) = &s.shape { m.vertices.get(glyph_vertex) } else { None }).unwrap();
+ assert!(output.shapes.iter().all(|s| !matches!(&s.shape, Shape::Mesh(m) if m.texture_id == LABEL_PIXELS)));
+ assert!((vertex.uv.x * size[0] as f32 - pixel_uv.x).abs() < 1e-3);
+ assert!((vertex.uv.y * size[1] as f32 - pixel_uv.y).abs() < 1e-3);
+ }
+
+ #[test]
+ fn rotating_cube_facets_stay_opaque_and_inside_the_projected_geometry() {
+ let ctx = egui::Context::default();
+ for up in [UpAxis::Z, UpAxis::Y] {
+ for view in [StandardView::Top, StandardView::Bottom, StandardView::Front, StandardView::Back, StandardView::Left, StandardView::Right] {
+ let from = Camera { up, ..Default::default() };
+ let mut to = from;
+ to.set_view(view);
+ for step in 0..=60 {
+ let cam = Camera::interpolate(&from, &to, f64::from(step) / 60.0);
+ let faces = facets(&cam, pos2(100.0, 100.0), HALF);
+ let bounds = Rect::from_points(&faces.iter().flat_map(|f| f.points.iter().copied()).collect::<Vec<_>>());
+ let output = paint_frame(&ctx, |ui| {
+ paint_cube(ui.painter(), &faces, Some(0), Tokens::light(), false, 1.0);
+ });
+ let fills: Vec<_> = output.shapes.iter().filter_map(|s| if let Shape::Mesh(m) = &s.shape { Some(m) } else { None }).collect();
+ assert_eq!(fills.len(), 1);
+ let mesh = fills[0];
+ assert!(mesh.is_valid());
+ assert!(mesh.vertices.iter().all(|v| v.color.a() == 255 && v.pos.is_finite() && bounds.contains(v.pos)));
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn control_navigation_keeps_its_transition_in_a_single_body_design() {
+ let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
+ h.app.run("solid.box", json!({"length":20,"width":20,"height":20})).unwrap();
+ h.frames(4);
+ let cam = h.app.cam;
+ let result = h.call("engine.execute", json!({"command":"view.navigate","params":{"camera":cam,"direction":[0,0,1]}}));
+ assert_eq!(result["ok"], true);
+ assert!(h.app.cam.back().dist(Vec3::Z) < 1e-6, "automatic model fitting must not cancel the navigation command");
+ assert_eq!(h.app.cam.target, cam.target);
+ assert_eq!(h.app.cam.distance, cam.distance);
+ }
+
+ #[test]
+ fn cube_navigation_eases_through_intermediate_views_and_can_be_interrupted() {
+ let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
+ assert!(h.app.preferences.look_at_anim);
+ for (action, direction) in [(None, Some(Vec3::Z)), (Some("right"), None), (Some("clockwise"), None), (Some("home"), None)] {
+ let from = h.app.cam;
+ navigate(&mut h.app, action, direction);
+ let anim = h.app.cam_anim.expect("cube navigation must animate");
+ assert_eq!(h.app.cam, from, "starting a transition must not jump the camera");
+ let mut previous = from;
+ for frame in 1..=60 {
+ let now = anim.start + anim.duration * f64::from(frame) / 60.0 + if frame == 60 { 1e-9 } else { 0.0 };
+ let (cam, done) = anim.sample(now);
+ let angle = |a: Vec3, b: Vec3| a.dot(b).clamp(-1.0, 1.0).acos().to_degrees();
+ assert!(angle(previous.back(), cam.back()).max(angle(previous.basis().0, cam.basis().0)) < 10.0);
+ assert_eq!(done, frame == 60);
+ if frame == 30 {
+ assert_ne!(cam.basis(), from.basis());
+ assert_ne!(cam.basis(), anim.to.basis());
+ }
+ previous = cam;
+ }
+ h.app.cam = anim.sample(anim.start + anim.duration / 2.0).0;
+ let intermediate = h.app.cam;
+ navigate(&mut h.app, Some("left"), None);
+ assert_eq!(h.app.cam_anim.unwrap().from, intermediate, "another click starts where the camera is");
+ h.app.cam = anim.to;
+ h.app.cancel_view_animation();
+ }
+ }
+
+ #[test]
+ fn cube_faces_corners_roll_and_home_drive_the_shared_command() {
+ let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
+ h.app.preferences.look_at_anim = false;
+ let before = h.app.session.doc.to_json();
+ for (name, direction) in [("top", Vec3::Z), ("front", -Vec3::Y), ("right", Vec3::X), ("top_front_right", Vec3::Z - Vec3::Y + Vec3::X)] {
+ h.call("ui.view", json!({"view":"iso"}));
+ let p = crate::scenario::handle_at(&format!("navigation_cube:{name}")).unwrap();
+ let scale = crate::scenario::rect_of("axis_view:outer").unwrap().width() / DESIGN_SIZE;
+ let offsets = if name == "top_front_right" {
+ vec![vec2(0.0, 0.0), vec2(8.0, 0.0), vec2(-8.0, 0.0), vec2(0.0, 8.0), vec2(0.0, -8.0)]
+ } else {
+ vec![vec2(0.0, 0.0)]
+ };
+ for offset in offsets {
+ let offset = offset * scale;
+ h.call("ui.view", json!({"view":"iso"}));
+ h.call("ui.click", json!({"x":p.x+offset.x,"y":p.y+offset.y}));
+ assert!(h.app.cam.back().dist(direction.normalized().unwrap()) < 2e-6, "{name} {offset:?}");
+ assert!(h.app.session.selection.is_empty());
+ }
+ }
+ let camera = h.app.cam;
+ let p = crate::scenario::handle_at("navigation_cube:control:clockwise").unwrap();
+ h.call("ui.click", json!({"x":p.x,"y":p.y}));
+ assert!((h.app.cam.roll - camera.roll - std::f64::consts::FRAC_PI_2).abs() < 1e-6);
+ assert!(h.app.cam.back().dist(camera.back()) < 1e-6);
+ let p = crate::scenario::handle_at("navigation_cube:control:home").unwrap();
+ h.call("ui.click", json!({"x":p.x,"y":p.y}));
+ assert!(h.app.cam.back().dist(Camera::default().back()) < 1e-6);
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert!(h.app.session.undo.is_empty());
+ }
+}
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index 516f1ba2f8..6193ab837f 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -173,6 +173,26 @@ pub const PAGE_GRAPHICS: usize = 4;
pub const THEMES: [(&str, &str); 3] = [("dark", "Dark"), ("light", "Light"), ("system", "System")];
pub const MSAA: [u32; 4] = [1, 2, 4, 8];
+/// Original view navigators, independent of the mouse navigation preset.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum NavigatorStyle {
+ #[default]
+ Axes,
+ Cube,
+}
+
+impl NavigatorStyle {
+ pub const ALL: [Self; 2] = [Self::Axes, Self::Cube];
+
+ pub fn label(self) -> &'static str {
+ match self {
+ Self::Axes => "Signed axes",
+ Self::Cube => "Cube",
+ }
+ }
+}
+
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Prefs {
@@ -180,6 +200,8 @@ pub struct Prefs {
pub default_units: String,
/// Mouse mapping: `fusion`, `solidworks` or `inventor`.
pub nav: String,
+ /// View orientation widget: original signed axes (default) or compact cube.
+ pub navigator_style: NavigatorStyle,
/// Show the radial ring and enable hold/flick gestures for viewport context menus.
pub radial_context_menu: bool,
/// The wheel zooms out when turned forward.
@@ -221,6 +243,7 @@ impl Default for Prefs {
Prefs {
default_units: "mm".into(),
nav: "fusion".into(),
+ navigator_style: NavigatorStyle::default(),
radial_context_menu: false,
zoom_reverse: false,
orbit_cursor: false,
@@ -332,6 +355,7 @@ fn defaults(app: &mut SolveApp, page: usize) {
}
1 => {
p.nav = d.nav;
+ p.navigator_style = d.navigator_style;
p.radial_context_menu = d.radial_context_menu;
p.zoom_reverse = d.zoom_reverse;
p.zoom_to_cursor = d.zoom_to_cursor;
@@ -839,6 +863,18 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
ui.label("Context menu");
ui.checkbox(&mut app.preferences.radial_context_menu, "Radial context menu");
ui.end_row();
+ ui.label("View navigator");
+ let picker =
+ egui::ComboBox::from_id_salt("pref_navigator_style").selected_text(app.preferences.navigator_style.label()).show_ui(ui, |ui| {
+ for style in NavigatorStyle::ALL {
+ let response = ui.selectable_value(&mut app.preferences.navigator_style, style, style.label());
+ crate::scenario::publish_rect(&format!("prefs:navigator:{}", style.label()), response.rect);
+ crate::scenario::publish_handle(&format!("prefs:navigator:{}", style.label()), response.rect.center());
+ }
+ });
+ crate::scenario::publish_rect("prefs:navigator", picker.response.rect);
+ crate::scenario::publish_handle("prefs:navigator", picker.response.rect.center());
+ ui.end_row();
ui.label("Reverse zoom direction");
ui.checkbox(&mut app.preferences.zoom_reverse, "");
ui.end_row();
@@ -1112,6 +1148,50 @@ mod tests {
assert_eq!(parse_length_mm("1e400", 1.0), None);
}
+ #[test]
+ fn navigator_picker_preserves_axes_and_follows_preferences_transactions() {
+ let old: Prefs = serde_json::from_value(json!({"nav":"solidworks"})).unwrap();
+ assert_eq!(old.navigator_style, NavigatorStyle::Axes);
+ let mut h = crate::scenario::Harness::new();
+ assert!(crate::scenario::handle_at("axis_view:z").is_some());
+ assert!(crate::scenario::handle_at("navigation_cube:front").is_none());
+ let camera = h.app.cam;
+ let design = h.app.session.doc.to_json();
+ let nav = h.app.preferences.nav.clone();
+ h.call("ui.prefs", json!({"open":"Navigation"}));
+ let picker = crate::scenario::rect_of("prefs:navigator").unwrap().center();
+ h.call("ui.click", json!({"x":picker.x,"y":picker.y}));
+ let cube = crate::scenario::rect_of("prefs:navigator:Cube").unwrap().center();
+ assert!(crate::scenario::rect_of("prefs:navigator:Signed axes").is_some());
+ h.call("ui.click", json!({"x":cube.x,"y":cube.y}));
+ assert_eq!(h.app.preferences.navigator_style, NavigatorStyle::Cube);
+ assert!(crate::scenario::handle_at("navigation_cube:front").is_some());
+ assert_eq!(h.app.preferences.nav, nav);
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(h.app.session.doc.to_json(), design);
+ let mut restored = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
+ restored.load_prefs(&h.app.prefs());
+ assert_eq!(restored.preferences.navigator_style, NavigatorStyle::Cube);
+ let before = h.app.preferences.clone();
+ assert!(control(&mut h.app, &json!({"navigator_style":"unknown", "nav":"solidworks"})).is_err());
+ assert_eq!(h.app.preferences, before, "invalid settings must fail atomically");
+ h.call("ui.prefs", json!({"button":"cancel"}));
+ assert_eq!(h.app.preferences.navigator_style, NavigatorStyle::Axes);
+ assert!(crate::scenario::handle_at("navigation_cube:front").is_none());
+ h.call("ui.prefs", json!({"open":"Navigation","navigator_style":"cube"}));
+ h.call("ui.prefs", json!({"button":"apply"}));
+ h.call("ui.prefs", json!({"button":"defaults"}));
+ assert_eq!(h.app.preferences.navigator_style, NavigatorStyle::Axes);
+ h.call("ui.prefs", json!({"button":"cancel"}));
+ assert_eq!(h.app.preferences.navigator_style, NavigatorStyle::Cube);
+ h.call("ui.prefs", json!({"navigator_style":"axes", "look_at_anim":false}));
+ h.call("ui.view", json!({"view":"front"}));
+ let axis = crate::scenario::handle_at("axis_view:-y").unwrap();
+ h.call("ui.click", json!({"x":axis.x,"y":axis.y}));
+ assert!(h.app.cam.back().dist(Vec3::Y) < 1e-6, "original axes retain click-again reversal");
+ assert_eq!(h.app.session.doc.to_json(), design);
+ }
+
#[test]
fn radial_context_menu_defaults_off_and_follows_preferences_transactions() {
assert!(!Prefs::default().radial_context_menu);
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index d971f739e3..1032c470a3 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -70,6 +70,12 @@ pub struct Tokens {
pub preview_add: Color32,
/// Removed material in a feature preview (translucent).
pub preview_cut: Color32,
+ /// Navigation cube faces, outline and labels.
+ pub cube_face: Color32,
+ pub cube_border: Color32,
+ pub cube_text: Color32,
+ /// Light blue hover fill, readable on the pale cube in either theme.
+ pub cube_hover: Color32,
// ---- viewport ----
/// Viewport background (top and bottom of the gradient; equal for a flat fill).
pub viewport_top: Color32,
@@ -128,6 +134,21 @@ impl Tokens {
if is_dark() { Tokens::dark() } else { Tokens::light() }
}
+ /// Fade idle cube colours into the viewport while retaining opaque facets.
+ pub fn navigation_cube(self, active: bool) -> Tokens {
+ if active {
+ return self;
+ }
+ let mut t = self;
+ t.cube_face = t.cube_face.lerp_to_gamma(t.viewport_top, 0.55);
+ t.cube_border = t.cube_border.lerp_to_gamma(t.viewport_top, 0.55);
+ t.cube_text = t.cube_text.lerp_to_gamma(t.viewport_top, 0.55);
+ t.axis_x = t.axis_x.lerp_to_gamma(t.viewport_top, 0.55);
+ t.axis_y = t.axis_y.lerp_to_gamma(t.viewport_top, 0.55);
+ t.axis_z = t.axis_z.lerp_to_gamma(t.viewport_top, 0.55);
+ t
+ }
+
pub const fn light() -> Tokens {
Tokens {
app_bar: Color32::from_rgb(52, 56, 64),
@@ -171,6 +192,10 @@ impl Tokens {
manipulator: Color32::from_rgb(40, 110, 220),
preview_add: Color32::from_rgb(112, 160, 226),
preview_cut: Color32::from_rgba_unmultiplied_const(232, 84, 44, 110),
+ cube_face: Color32::from_rgb(236, 239, 244),
+ cube_border: Color32::from_rgb(85, 94, 110),
+ cube_text: Color32::from_rgb(38, 42, 50),
+ cube_hover: Color32::from_rgb(190, 220, 252),
viewport_top: Color32::from_rgb(240, 243, 247),
viewport_bottom: Color32::from_rgb(203, 210, 221),
grid: Color32::from_rgb(196, 202, 212),
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index c8b389282b..a55256e073 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -23,6 +23,9 @@ mod appearance_tests;
#[path = "viewport_plane_target_tests.rs"]
mod plane_target_tests;
+#[path = "navigation_cube.rs"]
+mod navigation_cube;
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NavMode {
Orbit,
@@ -1179,6 +1182,13 @@ fn section_clip(app: &SolveApp) -> [f32; 4] {
}
/// Space kept free at the top right of the viewport for the axis view (docked dialogs start below).
+pub(crate) fn axis_view_size(style: crate::prefs::NavigatorStyle) -> f32 {
+ match style {
+ crate::prefs::NavigatorStyle::Axes => 116.0,
+ crate::prefs::NavigatorStyle::Cube => navigation_cube::SIZE,
+ }
+}
+// Keep command panels anchored independently of the compact cube's display size.
pub const AXIS_VIEW_CLEARANCE: f32 = 168.0;
/// Axis length as a multiple of the origin plane size (solid part 1, dashed beyond).
@@ -2700,27 +2710,25 @@ pub(crate) fn refresh_layout(app: &mut SolveApp, scale: f32) {
.into_iter()
.flatten()
.collect();
- app.viewport.layout = Some(crate::viewport_layout::Layout::new(rect, &docks, scale));
+ app.viewport.layout = Some(crate::viewport_layout::Layout::new(rect, &docks, scale, app.preferences.navigator_style));
}
}
-/// Compact orientation gizmo, drawn and hit-tested in world coordinates.
-const AXIS_LENGTH: f64 = 38.0;
-const AXIS_RADIUS: f32 = 11.0;
-
+/// Orientation controls share the layout reservation used by model fitting.
fn axis_center(app: &SolveApp, rect: Rect) -> Pos2 {
axis_rect(app, rect).center()
}
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(|| Rect::from_center_size(pos2(rect.right() - 68.0, rect.top() + 68.0), vec2(116.0, 116.0)))
+ 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))
+ })
}
+const AXIS_LENGTH: f64 = 38.0;
+const AXIS_RADIUS: f32 = 11.0;
+
/// Six signed world axes, sorted back to front so overlapping tips have one owner.
fn axis_tips(cam: &Camera, c: Pos2) -> Vec<(&'static str, Vec3, Pos2, f64)> {
let (r, u, b) = cam.basis();
@@ -2837,7 +2845,12 @@ fn axis_view_orbit(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) -> bool {
(p.primary_pressed(), p.primary_down(), p.is_decidedly_dragging(), p.press_origin(), p.interact_pos(), i.modifiers.shift)
});
if pressed && ui.rect_contains_pointer(rect) {
- app.viewport.axis_drag = origin.filter(|p| axis_rect(app, rect).contains(*p));
+ app.viewport.axis_drag = origin.filter(|p| match app.preferences.navigator_style {
+ crate::prefs::NavigatorStyle::Axes => axis_rect(app, rect).contains(*p),
+ crate::prefs::NavigatorStyle::Cube => {
+ navigation_cube::drag_origin(&app.cam, axis_center(app, rect), *p, axis_rect(app, rect).width() / navigation_cube::DESIGN_SIZE)
+ }
+ });
if app.viewport.axis_drag.is_some() {
app.viewport.orbit_free = None;
}
@@ -2857,6 +2870,13 @@ fn axis_view_orbit(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) -> bool {
}
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),
+ }
+}
+
+fn signed_axis_view(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {
if !axis_rect(app, rect).is_positive() {
app.viewport.axis_drag = None;
crate::scenario::publish_count("axis_view_highlights", 0.0);
@@ -3000,7 +3020,14 @@ fn nav_bar(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {
.map(|l| l.navigation)
.unwrap_or_else(|| Rect::from_center_size(pos2(rect.center().x, rect.bottom() - 22.0), vec2(w, 30.0)));
crate::scenario::publish_rect("nav:outer", bar);
- let painter = ui.painter_at(rect);
+ let active = ui.rect_contains_pointer(bar)
+ || ui.rect_contains_pointer(axis_rect(app, rect))
+ || app.viewport.axis_drag.is_some()
+ || app.viewport.nav.is_some()
+ || app.viewport.spin
+ || menu_open;
+ let mut painter = ui.painter_at(rect);
+ painter.set_opacity(if active || app.preferences.navigator_style == crate::prefs::NavigatorStyle::Axes { 1.0 } else { 0.45 });
painter.rect(bar, 6.0, t.overlay, Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
let columns = ((bar.width() - 10.0) / 30.0).round().clamp(1.0, 10.0) as usize;
for (i, (icon, tip)) in items.iter().enumerate() {
@@ -4318,14 +4345,15 @@ mod tests {
}
#[test]
- fn axis_view_click_again_flips_and_drag_snaps() {
+ fn navigation_cube_repeated_face_click_keeps_view_and_drag_snaps() {
let mut h = crate::scenario::Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":"cube"}));
h.run(&json!([
{"call":"ui.view","params":{"view":"home"}},
{"click":{"handle":"axis_view:z"}},
{"expect":{"camera":{"pitch_deg":90,"yaw_deg":0}}},
{"click":{"handle":"axis_view:z"}},
- {"expect":{"camera":{"pitch_deg":-90,"yaw_deg":0}}},
+ {"expect":{"camera":{"pitch_deg":90,"yaw_deg":0}}},
{"call":"ui.view","params":{"view":"front"}}
]))
.unwrap();
diff --git a/crates/ui-egui/src/viewport_layout.rs b/crates/ui-egui/src/viewport_layout.rs
index cf2c8393a8..973b0e7e54 100644
--- a/crates/ui-egui/src/viewport_layout.rs
+++ b/crates/ui-egui/src/viewport_layout.rs
@@ -39,13 +39,14 @@ fn free_rect(view: Rect, obstacles: &[Rect]) -> Rect {
}
impl Layout {
- pub fn new(viewport: Rect, docks: &[Rect], scale: f32) -> Self {
+ pub fn new(viewport: Rect, docks: &[Rect], scale: f32, style: crate::prefs::NavigatorStyle) -> Self {
let scale = if scale.is_finite() && scale > 0.0 { scale } else { 1.0 };
let mut obstacles: Vec<_> = docks.iter().take(6).copied().filter(|r| r.is_finite()).map(|r| r.expand(4.0)).collect();
// Navigation is anchored to the viewport, never to transient dialog space.
let available = viewport;
- let mut axis_view = if available.width() >= 116.0 && available.height() >= 116.0 {
- Rect::from_min_size(pos2(available.right() - 116.0, available.top()), vec2(116.0, 116.0))
+ let cube_size = super::viewport::axis_view_size(style);
+ let mut axis_view = if available.width() >= cube_size && available.height() >= cube_size {
+ Rect::from_min_size(pos2(available.right() - cube_size, available.top()), vec2(cube_size, cube_size))
} else {
Rect::NOTHING
};
@@ -60,7 +61,12 @@ impl Layout {
// On tiny viewports keep the bottom controls usable rather than overlapping them.
// This decision depends only on viewport size, never on an overlay.
if axis_view.intersect(navigation).is_positive() {
- axis_view = Rect::NOTHING;
+ let compact = (navigation.top() - viewport.top() - 4.0).min(cube_size);
+ axis_view = if style == crate::prefs::NavigatorStyle::Cube && compact >= 96.0 {
+ Rect::from_min_size(pos2(viewport.right() - compact, viewport.top()), vec2(compact, compact))
+ } else {
+ Rect::NOTHING
+ };
}
if axis_view.is_positive() {
obstacles.push(axis_view);
diff --git a/crates/ui-egui/src/viewport_layout_tests.rs b/crates/ui-egui/src/viewport_layout_tests.rs
index 0e68c0021c..71e827f4da 100644
--- a/crates/ui-egui/src/viewport_layout_tests.rs
+++ b/crates/ui-egui/src/viewport_layout_tests.rs
@@ -8,7 +8,7 @@ fn thin_rotated_bounds_fit_using_the_original_full_projection() {
for (width, height, scale) in [(1400.0, 900.0, 1.0), (700.0, 450.0, 2.0), (700.0, 360.0, 2.0), (900.0, 720.0, 1.0)] {
let vp = Rect::from_min_max(pos2(250.0, 126.0), pos2(width, height - 30.0));
let dock = Rect::from_min_max(pos2(width - 205.0, vp.top()), vp.max);
- let layout = Layout::new(vp, &[dock], scale);
+ let layout = Layout::new(vp, &[dock], scale, crate::prefs::NavigatorStyle::Axes);
assert!(layout.drawable.width() >= 80.0 && layout.drawable.height() >= 30.0, "{layout:?}");
assert!(layout.axis_view.is_positive() && layout.navigation.is_positive(), "{layout:?}");
assert!(!layout.drawable.intersect(dock).is_positive());
@@ -85,12 +85,12 @@ fn measured_palette_fit_exposes_endpoints_and_layout_changes_preserve_manual_vie
#[test]
fn hostile_or_empty_fit_keeps_the_existing_camera_valid() {
let cam = Camera::default();
- let layout = Layout::new(Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0)), &[], 1.0);
+ let layout = Layout::new(Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0)), &[], 1.0, crate::prefs::NavigatorStyle::Axes);
assert!(fit_bounds(cam, &Aabb3::EMPTY, &layout, false).is_none());
let bad = Aabb3 { min: Vec3::new(f64::NAN, 0.0, 0.0), max: Vec3::new(1.0, 1.0, 1.0) };
assert!(fit_bounds(cam, &bad, &layout, true).is_none());
let mut app = crate::SolveApp::new(Default::default(), Default::default());
- let tiny = Layout::new(Rect::from_min_size(pos2(0.0, 0.0), vec2(5.0, 5.0)), &[], 1.0);
+ let tiny = Layout::new(Rect::from_min_size(pos2(0.0, 0.0), vec2(5.0, 5.0)), &[], 1.0, crate::prefs::NavigatorStyle::Axes);
app.viewport.layout = Some(tiny);
let bounds = Aabb3 { min: Vec3::ZERO, max: Vec3::new(20.0, 1.0, 1.0) };
assert_eq!(app.fitted_bounds(cam, &bounds), cam);
@@ -122,69 +122,80 @@ fn fit_home_animation_and_manual_takeover_use_one_layout_solution() {
}
#[test]
-fn measured_axis_view_targets_home_and_drag_work_beside_the_palette_at_hidpi() {
- for (scale, width, height) in [(1.0, 900.0, 720.0), (2.0, 700.0, 450.0), (2.0, 700.0, 360.0)] {
- let mut h = Harness::new();
- h.app.preferences.look_at_anim = false;
- h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
- h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":1})).unwrap();
- h.call("ui.prefs", json!({"ui_scale":scale}));
- h.call("ui.resize", json!({"width":width,"height":height}));
- h.app.fit_view();
- h.settle();
- let baseline = h.app.session.doc.to_json();
- let undo = h.app.session.undo.len();
- h.call("ui.view", json!({"view":"front"}));
- let layout = h.app.viewport.layout.as_ref().unwrap().clone();
- let palette = h.app.viewport.palette_rect.unwrap();
- let outer = crate::scenario::rect_of("axis_view:outer").unwrap();
- let home = crate::scenario::rect_of("axis_view:home").unwrap();
- assert_eq!(outer, layout.axis_view);
- assert!(outer.contains_rect(home));
- assert!(layout.viewport.contains_rect(outer));
- assert_eq!(outer.right_top(), layout.viewport.right_top());
- if outer.intersect(palette).is_positive() {
- // Short palettes may cover the fixed anchor; covered controls never steal input.
- let covered = outer.intersect(palette).center();
- let camera = h.app.cam;
- h.call("ui.click", json!({"x":covered.x,"y":covered.y}));
- assert_eq!(h.app.cam, camera);
+fn measured_navigator_targets_home_and_drag_work_beside_the_palette_at_hidpi() {
+ for style in crate::prefs::NavigatorStyle::ALL {
+ for (scale, width, height) in [(1.0, 900.0, 720.0), (2.0, 700.0, 450.0), (2.0, 700.0, 360.0)] {
+ let mut h = Harness::new();
+ h.call("ui.prefs", json!({"navigator_style":style}));
+ h.app.preferences.look_at_anim = false;
+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
+ h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":1})).unwrap();
+ h.call("ui.prefs", json!({"ui_scale":scale}));
+ h.call("ui.resize", json!({"width":width,"height":height}));
+ h.app.fit_view();
+ h.settle();
+ let baseline = h.app.session.doc.to_json();
+ let undo = h.app.session.undo.len();
+ h.call("ui.view", json!({"view":"front"}));
+ let layout = h.app.viewport.layout.as_ref().unwrap().clone();
+ let palette = h.app.viewport.palette_rect.unwrap();
+ let outer = crate::scenario::rect_of("axis_view:outer").unwrap();
+ let home = crate::scenario::rect_of("axis_view:home").unwrap();
+ assert_eq!(outer, layout.axis_view);
+ assert!(outer.contains_rect(home));
+ assert!(layout.viewport.contains_rect(outer));
+ assert_eq!(outer.right_top(), layout.viewport.right_top());
+ if outer.intersect(palette).is_positive() {
+ // Short palettes may cover the fixed anchor; covered controls never steal input.
+ let covered = outer.intersect(palette).center();
+ let camera = h.app.cam;
+ h.call("ui.click", json!({"x":covered.x,"y":covered.y}));
+ assert_eq!(h.app.cam, camera);
+ assert!(h.app.viewport.axis_drag.is_none());
+ assert_eq!(crate::scenario::rect_of("axis_view:outer").unwrap(), outer);
+ assert_eq!(h.app.session.doc.to_json(), baseline);
+ assert_eq!(h.app.session.undo.len(), undo);
+ continue;
+ }
+ assert!(!layout.navigation.intersect(outer).is_positive());
+ if style == crate::prefs::NavigatorStyle::Cube {
+ let front = crate::scenario::handle_at("navigation_cube:front").unwrap();
+ assert!(outer.contains(front));
+ let up = crate::scenario::handle_at("navigation_cube:control:up").unwrap();
+ h.call("ui.click", json!({"x":up.x,"y":up.y}));
+ assert!(h.app.cam.back().dist(Vec3::Z) < 1e-5);
+ let top = crate::scenario::handle_at("navigation_cube:top").unwrap();
+ h.call("ui.click", json!({"x":top.x,"y":top.y}));
+ assert!(h.app.cam.back().dist(Vec3::Z) < 1e-5);
+ } else {
+ let z = crate::scenario::handle_at("axis_view:z").unwrap();
+ assert!(outer.contains(z));
+ h.call("ui.click", json!({"x":z.x,"y":z.y}));
+ assert!(h.app.cam.back().dist(Vec3::Z) < 1e-5);
+ let z = crate::scenario::handle_at("axis_view:z").unwrap();
+ h.call("ui.click", json!({"x":z.x,"y":z.y}));
+ assert!(h.app.cam.back().dist(-Vec3::Z) < 1e-5);
+ }
+ h.call("ui.view", json!({"view":"front"}));
+ h.app.viewport.nav = Some(crate::viewport::NavMode::Pan);
+ let before = h.app.cam;
+ let c = h.app.viewport.layout.as_ref().unwrap().axis_view.center();
+ h.call("ui.drag", json!({"x0":c.x,"y0":c.y,"x1":c.x+24.0,"y1":c.y+8.0,"steps":8}));
+ assert!((h.app.cam.yaw - before.yaw - 24.0 * 0.008).abs() < 1e-6);
+ assert!((h.app.cam.pitch - before.pitch - 8.0 * 0.008).abs() < 1e-6);
+ assert_eq!(h.app.cam.target, before.target);
+ assert_eq!(h.app.cam.distance, before.distance);
assert!(h.app.viewport.axis_drag.is_none());
- assert_eq!(crate::scenario::rect_of("axis_view:outer").unwrap(), outer);
+ assert!(h.app.viewport.boxsel.is_none());
+ let home = crate::scenario::handle_at("axis_view:home").unwrap();
+ h.call("ui.click", json!({"x":home.x,"y":home.y}));
+ let mut iso = h.app.cam;
+ iso.set_view(StandardView::Iso);
+ assert_eq!((h.app.cam.yaw, h.app.cam.pitch), (iso.yaw, iso.pitch));
assert_eq!(h.app.session.doc.to_json(), baseline);
assert_eq!(h.app.session.undo.len(), undo);
- continue;
+ assert!(h.app.session.selection.is_empty());
}
- assert!(!layout.navigation.intersect(outer).is_positive());
- for name in ["x", "-x", "y", "-y", "z", "-z"] {
- let p = crate::scenario::handle_at(&format!("axis_view:{name}")).unwrap();
- assert!(outer.contains_rect(Rect::from_center_size(p, vec2(22.0, 22.0))));
- }
- let z = crate::scenario::handle_at("axis_view:z").unwrap();
- h.call("ui.click", json!({"x":z.x,"y":z.y}));
- assert!(h.app.cam.back().dist(Vec3::Z) < 1e-5);
- let z = crate::scenario::handle_at("axis_view:z").unwrap();
- h.call("ui.click", json!({"x":z.x,"y":z.y}));
- assert!(h.app.cam.back().dist(-Vec3::Z) < 1e-5);
- h.call("ui.view", json!({"view":"front"}));
- h.app.viewport.nav = Some(crate::viewport::NavMode::Pan);
- let before = h.app.cam;
- let c = h.app.viewport.layout.as_ref().unwrap().axis_view.center();
- h.call("ui.drag", json!({"x0":c.x,"y0":c.y,"x1":c.x+24.0,"y1":c.y+8.0,"steps":8}));
- assert!((h.app.cam.yaw - before.yaw - 24.0 * 0.008).abs() < 1e-6);
- assert!((h.app.cam.pitch - before.pitch - 8.0 * 0.008).abs() < 1e-6);
- assert_eq!(h.app.cam.target, before.target);
- assert_eq!(h.app.cam.distance, before.distance);
- assert!(h.app.viewport.axis_drag.is_none());
- assert!(h.app.viewport.boxsel.is_none());
- let home = crate::scenario::handle_at("axis_view:home").unwrap();
- h.call("ui.click", json!({"x":home.x,"y":home.y}));
- let mut iso = h.app.cam;
- iso.set_view(StandardView::Iso);
- assert_eq!((h.app.cam.yaw, h.app.cam.pitch), (iso.yaw, iso.pitch));
- assert_eq!(h.app.session.doc.to_json(), baseline);
- assert_eq!(h.app.session.undo.len(), undo);
- assert!(h.app.session.selection.is_empty());
}
}
@@ -211,7 +222,7 @@ fn immediate_standard_view_cancels_fit_before_the_measured_frame() {
fn navigation_anchors_ignore_positioned_resized_and_covering_dialogs() {
for (width, height, scale) in [(1400.0, 900.0, 1.0), (700.0, 450.0, 2.0), (700.0, 360.0, 2.0)] {
let vp = Rect::from_min_max(pos2(250.0, 126.0), pos2(width, height - 30.0));
- let baseline = Layout::new(vp, &[], scale);
+ let baseline = Layout::new(vp, &[], scale, crate::prefs::NavigatorStyle::Axes);
assert!(baseline.axis_view.is_positive() && baseline.navigation.is_positive());
assert_eq!(baseline.axis_view.right_top(), vp.right_top());
assert_eq!(baseline.navigation.center().x, vp.center().x);
@@ -223,7 +234,7 @@ fn navigation_anchors_ignore_positioned_resized_and_covering_dialogs() {
vec![vp],
];
for docks in cases {
- let measured = Layout::new(vp, &docks, scale);
+ let measured = Layout::new(vp, &docks, scale, crate::prefs::NavigatorStyle::Axes);
assert_eq!(measured.axis_view, baseline.axis_view, "{docks:?}");
assert_eq!(measured.navigation, baseline.navigation, "{docks:?}");
assert!(vp.contains_rect(measured.axis_view));
@@ -269,8 +280,8 @@ fn tiny_viewports_never_overlap_navigation_and_axis_view() {
for width in [39.0, 40.0, 90.0, 120.0, 160.0, 310.0] {
for height in [30.0, 80.0, 130.0, 160.0, 240.0] {
let vp = Rect::from_min_size(pos2(20.0, 30.0), vec2(width, height));
- let clear = Layout::new(vp, &[], 1.0);
- let covered = Layout::new(vp, &[vp], 1.0);
+ let clear = Layout::new(vp, &[], 1.0, crate::prefs::NavigatorStyle::Axes);
+ let covered = Layout::new(vp, &[vp], 1.0, crate::prefs::NavigatorStyle::Axes);
assert_eq!(clear.axis_view, covered.axis_view);
assert_eq!(clear.navigation, covered.navigation);
assert!(!clear.axis_view.intersect(clear.navigation).is_positive());
diff --git a/crates/ui-egui/tests/scenarios/navigation_cube_hover.json b/crates/ui-egui/tests/scenarios/navigation_cube_hover.json
new file mode 100644
index 0000000000..3962fec7a3
--- /dev/null
+++ b/crates/ui-egui/tests/scenarios/navigation_cube_hover.json
@@ -0,0 +1,65 @@
+[
+ {"call":"ui.prefs","params":{"navigator_style":"cube"}},
+ {
+ "note": "Cube facets own one highlight at a time and choose principal views."
+ },
+ {
+ "call": "ui.view",
+ "params": {
+ "view": "home"
+ }
+ },
+ {
+ "move": {
+ "handle": "navigation_cube:top"
+ }
+ },
+ {
+ "expect": {
+ "count": {
+ "name": "axis_view_highlights",
+ "value": 1
+ }
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:top"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": 0,
+ "pitch_deg": 90
+ }
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:control:down"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": 0,
+ "pitch_deg": 0
+ }
+ }
+ },
+ {
+ "move": [
+ 800,
+ 500
+ ]
+ },
+ {
+ "expect": {
+ "count": {
+ "name": "axis_view_highlights",
+ "value": 0
+ }
+ }
+ }
+]
diff --git a/crates/ui-egui/tests/scenarios/navigation_cube_minimal_turn.json b/crates/ui-egui/tests/scenarios/navigation_cube_minimal_turn.json
new file mode 100644
index 0000000000..7feaeb5838
--- /dev/null
+++ b/crates/ui-egui/tests/scenarios/navigation_cube_minimal_turn.json
@@ -0,0 +1,74 @@
+[
+ {"call":"ui.prefs","params":{"navigator_style":"cube"}},
+ {
+ "note": "Cube top/bottom face clicks preserve the nearest square heading in each up frame."
+ },
+ {
+ "camera": {
+ "yaw": -2.356194490192345,
+ "pitch": 0.6154797086703874
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:top"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": -90,
+ "pitch_deg": 90
+ }
+ }
+ },
+ {
+ "camera": {
+ "yaw": 2.9670597283903604,
+ "pitch": -0.6
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:bottom"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": 180,
+ "pitch_deg": -90
+ }
+ }
+ },
+ {
+ "call": "ui.prefs",
+ "params": {
+ "up_axis": "y"
+ }
+ },
+ {
+ "camera": {
+ "yaw": -1.3962634015954636,
+ "pitch": 0.6
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:top"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": -90,
+ "pitch_deg": 90,
+ "back": [
+ 0,
+ 1,
+ 0
+ ]
+ }
+ }
+ }
+]
diff --git a/crates/ui-egui/tests/scenarios/navigation_cube_y_up.json b/crates/ui-egui/tests/scenarios/navigation_cube_y_up.json
new file mode 100644
index 0000000000..038b8ef5cf
--- /dev/null
+++ b/crates/ui-egui/tests/scenarios/navigation_cube_y_up.json
@@ -0,0 +1,54 @@
+[
+ {"call":"ui.prefs","params":{"navigator_style":"cube"}},
+ {
+ "note": "Cube face names follow the up-axis frame; with Y up, Top looks from +Y and Front from +Z."
+ },
+ {
+ "call": "ui.prefs",
+ "params": {
+ "up_axis": "y"
+ }
+ },
+ {
+ "call": "ui.view",
+ "params": {
+ "view": "home"
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:top"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": 0,
+ "pitch_deg": 90,
+ "back": [
+ 0,
+ 1,
+ 0
+ ]
+ }
+ }
+ },
+ {
+ "click": {
+ "handle": "navigation_cube:control:down"
+ }
+ },
+ {
+ "expect": {
+ "camera": {
+ "yaw_deg": 0,
+ "pitch_deg": 0,
+ "back": [
+ 0,
+ 0,
+ 1
+ ]
+ }
+ }
+ }
+]
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index bc99969132..ff1e985181 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -64,7 +64,7 @@ unit regardless of the design, pass an expression with one: `"value": "50 mm"` o
| `ui.sketchToScreen` | `points`: `[[x, y]…]` in active-sketch coordinates | their screen points (null when behind the camera) |
| `ui.dialogInput` | `index` | what clicking an input's Select chip does: picks go to that input |
| `ui.at` | `world: [x,y,z]` \| `sketch: [x,y]` \| `plane: "XY"` \| `axis: "Z"` \| `dimension: "d1"` (its value text) \| `handle: "arrow"` (a manipulator handle, see `scenario::publish_handle`) | the screen point (a scenario step's target; see `crates/ui-egui/src/scenario.rs`) |
-| `ui.handles` | `prefix?` | the handles drawn last frame, `[{name, x, y}]`: toolbar buttons and drop-down items `toolbar:<command id>` (the button alone: `button:<command id>`; a drop-down row: `dropdown:<command id>`, highlighted `dropdown_hot:<command id>`, its pin `dropdown_pin:<command id>`; Customize Toolbar's check boxes `customize:<command id>`), panel labels `panel:<tab>:<panel>`, browser rows `row:<label>` and fold arrows `fold:<label>`, manipulator handles; orientation tips `axis_view:x`, `axis_view:-x` (and y/z) |
+| `ui.handles` | `prefix?` | the handles drawn last frame, `[{name, x, y}]`: toolbar buttons and drop-down items `toolbar:<command id>` (the button alone: `button:<command id>`; a drop-down row: `dropdown:<command id>`, highlighted `dropdown_hot:<command id>`, its pin `dropdown_pin:<command id>`; Customize Toolbar's check boxes `customize:<command id>`), panel labels `panel:<tab>:<panel>`, browser rows `row:<label>` and fold arrows `fold:<label>`, manipulator handles; signed-axis tips `axis_view:z`, `axis_view:-y`; optional cube facets `navigation_cube:top`, `navigation_cube:top_front_right`, controls `navigation_cube:control:home` (and other actions), plus signed-axis aliases for visible cube faces; Preferences navigator picker `prefs:navigator`, options `prefs:navigator:Signed axes` and `prefs:navigator:Cube` |
| `ui.editFeature` | `feature` (id or name) | what double-clicking a timeline item does: rolls back to it and opens its dialog filled in (sketches open in sketch mode) |
| `ui.scroll` | `x`, `y`, `delta?` | wheel zoom at the cursor |
| `ui.key` | `key` (egui key name, `Enter`, `Escape`…), `cmd?`, `shift?` | |
@@ -99,10 +99,39 @@ channel; see [mcp.md](mcp.md).
{"id":5,"method":"ui.screenshot","params":{"path":"/tmp/part.png"}}
```
+Preferences → Navigation → View navigator offers **Signed axes** (the original default) and
+**Cube**. This choice is saved independently of the mouse preset. The control channel selects it
+with `ui.prefs {"navigator_style":"axes"}` or `ui.prefs {"navigator_style":"cube"}`.
+Existing settings without this field keep signed axes. Signed-axis tips choose principal views;
+clicking an aligned tip again reverses the view.
+
Hold Shift during an orbit gesture to snap to the nearest standard or diagonal view. This applies to
-right-drag, the Orbit navigation tool, and dragging the axis view. Under the default preset,
-Shift+middle also orbits with snapping; middle alone pans. Axis-view tips use world coordinates,
-regardless of the up-axis preference. Clicking an aligned tip again flips to its opposite.
+right-drag, the Orbit navigation tool, and dragging either view navigator. Under the default preset,
+Shift+middle also orbits with snapping; middle alone pans. Cube faces choose principal views,
+and corners choose isometric views. The middle of each cube edge belongs to its face. Face names
+follow the up-axis preference; the small X/Y/Z triad shows world axes. Clicking the same face keeps that view.
+The inward-pointing arrows orbit by 90 degrees; the curved arrows at the upper right roll the
+view by 90 degrees. The Home button at the upper left returns to isometric and the lower-right circle
+fits the model.
+
+The cube is subdued while idle. Hovering its area brightens the cube and navigation bar and
+reveals the surrounding controls; the picked face or corner gets a pale blue fill and
+blue outline. Moving away restores the subdued state. Navigation-bar controls also brighten
+when hovered or when a navigation tool is active.
+
+The cube has six face targets and eight corner targets, with no edge targets. Corner picking
+regions lie on the six flat faces, preserving sharp corners with no permanent subdivision
+lines. Hovering a corner highlights its parts on the adjacent visible faces together.
+
+The cube widget occupies a compact 112-point square in the viewport corner. A straight-on
+cube face is approximately 55 points wide; painting and picking scale together. Face labels
+are stretched vertically. View clicks ease through intermediate orientations when Navigation
+animated view changes is enabled (the default), at the configured animation speed.
+
+The cube runs `view.navigate` through the command engine. Programmatic callers pass `camera`
+and either `direction: [x,y,z]` in the camera's up-axis frame or `action` (`left`, `right`, `up`,
+`down`, `clockwise`, `counterclockwise`, `home`, `fit`). The result contains `camera` and `fit`;
+UI callers apply the camera with their animation preference, without editing the design.
Shift-orbit snapping includes 45-degree edge views and isometric corner views, with a
lightly damped spring transition and a small boundary margin to prevent flicker.
diff --git a/docs/features.md b/docs/features.md
index f4424318f4..6a7651429b 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -1,6 +1,6 @@
# Features
-SolidCraft's commands by area, generated by `cargo xtask features` from the command registry (`solidcraft-cli commands`). **322 commands.** Every command runs the same way from the toolbar, a script, `solidcraft-cli exec <id> '<json>'`, the control channel and MCP; parameters are in the [command reference](book/src/reference/commands.md) (`cargo xtask book`). Status and plans: [ROADMAP](../ROADMAP.md).
+SolidCraft's commands by area, generated by `cargo xtask features` from the command registry (`solidcraft-cli commands`). **328 commands.** Every command runs the same way from the toolbar, a script, `solidcraft-cli exec <id> '<json>'`, the control channel and MCP; parameters are in the [command reference](book/src/reference/commands.md) (`cargo xtask book`). Status and plans: [ROADMAP](../ROADMAP.md).
## Sketch (98)
@@ -207,7 +207,7 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
| Assign Plastic Rule | `plastic.assign_rule` | PLASTIC › SETUP |
| List Plastic Rules | `plastic.rules` | – |
-## Components (12)
+## Components (16)
| Command | Id | Toolbar |
|---|---|---|
@@ -223,6 +223,10 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
| Paste New | `component.paste_new` | – |
| Capture Position | `component.capture_position` | SOLID › POSITION |
| Revert Position | `component.revert_position` | SOLID › POSITION |
+| Insert Design | `component.insert_design` | – |
+| Update Links | `component.update_links` | – |
+| Break Link | `component.break_link` | – |
+| List Links | `component.links` | – |
## Assembly joints (11)
@@ -490,7 +494,7 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
|---|---|---|
| Delete | `selection.delete` | – |
-## `view.*` (5)
+## `view.*` (6)
| Command | Id | Toolbar |
|---|---|---|
@@ -499,3 +503,4 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
| Delete Named View | `view.delete` | – |
| List Named Views | `view.list` | – |
| Restore Named View | `view.apply` | – |
+| Navigate View | `view.navigate` | – |