diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index 2b62ebeed..511d558ad 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -6,8 +6,10 @@ use solidcraft_render::{Camera, StandardView}; use super::CommandSpec; use crate::params::{bad, num, req_vec2, req_vec3, vec3}; use crate::schema::view_navigation::{ - CameraReply, NavigatorParams, NormalToParams, RenderBrowser, RenderFocus, RenderLive, RenderSelect, RibbonTabsOnly, RibbonTabsOnlyParams, - StandardViewParams, TabStep, TabStepParams, ZoomTool, + AmbientOcclusionParams, AmbientOcclusionResult, CameraReply, GraphicsPreset, GraphicsPresetParams, GraphicsPresetResult, HistoryDock, + HistoryLayoutParams, HistoryLayoutResult, LayoutMode, LayoutParams, LayoutResult, NavigateParams, NavigateResult, NavigatorParams, + NormalToParams, PresetQuality, RenderBrowser, RenderFocus, RenderLive, RenderSelect, RibbonTabsOnly, RibbonTabsOnlyParams, StandardViewParams, + TabStep, TabStepParams, ZoomTool, }; use crate::schema::{TypedContract, output_schema_for}; use crate::{Result, Sel, Session}; @@ -21,6 +23,11 @@ const TAB_STEP_CONTRACT: TypedContract = TypedContract::new(); const STANDARD_VIEW_CONTRACT: TypedContract = TypedContract::new(); const NORMAL_TO_CONTRACT: TypedContract = TypedContract::new(); const RIBBON_TABS_ONLY_CONTRACT: TypedContract = TypedContract::new(); +const LAYOUT_CONTRACT: TypedContract = TypedContract::new(); +const HISTORY_LAYOUT_CONTRACT: TypedContract = TypedContract::new(); +const GRAPHICS_PRESET_CONTRACT: TypedContract = TypedContract::new(); +const AMBIENT_OCCLUSION_CONTRACT: TypedContract = TypedContract::new(); +const NAVIGATE_CONTRACT: TypedContract = TypedContract::new(); // Both existing request forms share the Browser command and its published schema. #[derive(serde::Deserialize, serde::Serialize, schemars::JsonSchema)] @@ -115,22 +122,24 @@ CommandSpec::new("view.render_dock", "Move Render Dock", crate::checked!("view.r .contract(&RENDER_DOCK_CONTRACT) .output(crate::schema::output_schema_for::) .params("panel: inspector|browser; side: left|right → {panel, side}; Render dock UI preference; headless echo only, no document edits or undo"), -CommandSpec::new("view.layout", "Workspace layout", layout) - .icon("settings").noundo().doc_only().params("mode: floating|compact → validated workspace layout; display only, never opens a dialog"), -CommandSpec::new("view.history_layout", "History layout", history_layout) - .icon("settings").noundo().doc_only().params("width?: 1..1000000; dock?: bottom|left|under_browser|browser (browser: the history in the browser, no timeline); collapsed?: bool → validated layout request; display only, never opens a dialog"), -CommandSpec::new("view.graphics_preset", "Graphics Preset", graphics_preset) - .icon("settings").noundo().doc_only().params("preset: performance|quality → preset, enabled, display_quality, supersampling, supersampling_adaptive; Quality: AO, Fine, adaptive 2x SSAA; Performance: no AO, Normal, no SSAA"), -CommandSpec::new("view.ambient_occlusion", "Ambient Occlusion", ambient_occlusion) - .icon("settings").noundo().doc_only().params("enabled: bool → enabled; apply soft contact shading in the GPU viewport"), +CommandSpec::new("view.layout", "Workspace layout", crate::checked!("view.layout", layout)) + .icon("settings").noundo().doc_only().contract(&LAYOUT_CONTRACT).output(output_schema_for::).params("mode: floating|compact → validated workspace layout; display only, never opens a dialog"), +CommandSpec::new("view.history_layout", "History layout", crate::checked!("view.history_layout", history_layout)) + .icon("settings").noundo().doc_only().contract(&HISTORY_LAYOUT_CONTRACT).output(output_schema_for::).params("width?: 1..1000000; dock?: bottom|left|under_browser|browser (browser: the history in the browser, no timeline); collapsed?: bool → validated layout request; display only, never opens a dialog"), +CommandSpec::new("view.graphics_preset", "Graphics Preset", crate::checked!("view.graphics_preset", graphics_preset)) + .icon("settings").noundo().doc_only().contract(&GRAPHICS_PRESET_CONTRACT).output(output_schema_for::).params("preset: performance|quality → preset, enabled, display_quality, supersampling, supersampling_adaptive; Quality: AO, Fine, adaptive 2x SSAA; Performance: no AO, Normal, no SSAA"), +CommandSpec::new("view.ambient_occlusion", "Ambient Occlusion", crate::checked!("view.ambient_occlusion", ambient_occlusion)) + .icon("settings").noundo().doc_only().contract(&AMBIENT_OCCLUSION_CONTRACT).output(output_schema_for::).params("enabled: bool → enabled; apply soft contact shading in the GPU viewport"), CommandSpec::new("view.perspective", "Perspective view", perspective) .icon("perspective").noundo().doc_only().params("enabled: bool → enabled; draw the view in perspective, or orthographic when false; a sketch being edited is always shown orthographic"), CommandSpec::new("view.angle_readout", "View Angles", crate::checked!("view.angle_readout", angle_readout)) .icon("camera").noundo().doc_only().contract(&ANGLE_READOUT_CONTRACT).output(crate::schema::output_schema_for::).params("enabled: bool → enabled; show the view's pitch, yaw and roll (degrees, as view.apply's camera in radians) and Ortho or Persp under the orientation gizmo; display only, never opens a dialog"), -CommandSpec::new("view.navigate", "Navigate View", navigate) +CommandSpec::new("view.navigate", "Navigate View", crate::checked!("view.navigate", navigate)) .icon("orbit") .noundo() .doc_only() + .contract(&NAVIGATE_CONTRACT) + .output(output_schema_for::) .params("camera: Camera; direction?: [x,y,z] in the camera's up-axis frame; or action: left|right|up|down|clockwise|counterclockwise|home|fit, degrees?: 0..180 (how far left|right|up|down turn; default 90), fit?: bool (frame the whole model from the new direction as well, as home does; default false); or motion: pan|orbit|zoom, delta?: [dx,dy] (pixels, each ±10000), free_orbit?: bool (orbit through poles, default false), viewport?: [width,height] (1..1000000, required for pan or pivot), pivot?: [x,y,z], factor?: 0.05..20 (required for zoom), anchor?: [x,y,z] → camera, fit, continuous?"), CommandSpec::new("view.normal_to", "Normal to Selection", crate::checked!("view.normal_to", normal_to)) .icon("camera") @@ -467,31 +476,39 @@ fn layout(_s: &mut Session, p: &Value) -> Result { .and_then(Value::as_str) .filter(|mode| matches!(*mode, "floating" | "compact")) .ok_or_else(|| bad("view.layout", "mode must be floating or compact"))?; - Ok(json!({"mode": mode})) + let mode = if mode == "compact" { LayoutMode::Compact } else { LayoutMode::Floating }; + typed_reply("view.layout", LayoutResult { mode, param_warnings: Vec::new() }) +} + +/// A command's typed reply as the JSON it sends. +fn typed_reply(cmd: &str, reply: impl serde::Serialize) -> Result { + serde_json::to_value(reply).map_err(|e| bad(cmd, e.to_string())) } fn history_layout(_s: &mut Session, p: &Value) -> Result { let cmd = "view.history_layout"; - let mut result = serde_json::Map::new(); + let mut result = HistoryLayoutResult { width: None, dock: None, collapsed: None, param_warnings: Vec::new() }; if let Some(value) = p.get("width") { let width = value .as_f64() .filter(|v| v.is_finite() && (1.0..=1_000_000.0).contains(v)) .ok_or_else(|| bad(cmd, "width must be finite and within 1..1000000"))?; - result.insert("width".into(), json!(width)); + result.width = Some(width); } if let Some(value) = p.get("dock") { - let dock = value - .as_str() - .filter(|v| matches!(*v, "bottom" | "left" | "under_browser" | "browser")) - .ok_or_else(|| bad(cmd, "dock must be bottom, left, under_browser or browser"))?; - result.insert("dock".into(), json!(dock)); + let dock = match value.as_str() { + Some("bottom") => HistoryDock::Bottom, + Some("left") => HistoryDock::Left, + Some("under_browser") => HistoryDock::UnderBrowser, + Some("browser") => HistoryDock::Browser, + _ => return Err(bad(cmd, "dock must be bottom, left, under_browser or browser")), + }; + result.dock = Some(dock); } if let Some(value) = p.get("collapsed") { - let collapsed = value.as_bool().ok_or_else(|| bad(cmd, "collapsed must be a boolean"))?; - result.insert("collapsed".into(), json!(collapsed)); + result.collapsed = Some(value.as_bool().ok_or_else(|| bad(cmd, "collapsed must be a boolean"))?); } - Ok(Value::Object(result)) + typed_reply(cmd, result) } fn navigate(_s: &mut Session, p: &Value) -> Result { @@ -559,7 +576,7 @@ fn navigate(_s: &mut Session, p: &Value) -> Result { _ => return Err(bad(cmd, "unknown navigation action")), } } - Ok(json!({"camera": cam, "fit": fit})) + typed_reply(cmd, NavigateResult { camera: cam, fit, continuous: None, param_warnings: Vec::new() }) } /// Direct manipulation is stateless, bounded and independent of document evaluation. @@ -611,7 +628,7 @@ fn continuous(mut cam: Camera, p: &Value) -> Result { if !cam.is_valid() { return Err(bad(cmd, "motion produced an invalid camera")); } - Ok(json!({"camera":cam, "fit":false, "continuous":true})) + typed_reply(cmd, NavigateResult { camera: cam, fit: false, continuous: Some(true), param_warnings: Vec::new() }) } /// At a halfway tie prefer the heading nearer the front plan view. @@ -1060,7 +1077,7 @@ mod tests { fn ambient_occlusion(_s: &mut Session, p: &Value) -> Result { let enabled = p.get("enabled").and_then(Value::as_bool).ok_or_else(|| bad("view.ambient_occlusion", "enabled must be a boolean"))?; - Ok(json!({"enabled": enabled})) + typed_reply("view.ambient_occlusion", AmbientOcclusionResult { enabled, param_warnings: Vec::new() }) } fn perspective(_s: &mut Session, p: &Value) -> Result { @@ -1139,14 +1156,23 @@ mod ambient_occlusion_tests { /// One preset for contact shading, tessellation and supersampling. MSAA stays independent. fn graphics_preset(_s: &mut Session, p: &Value) -> Result { - let preset = p.get("preset").and_then(Value::as_str); - let enabled = match preset { - Some("quality") => true, - Some("performance") => false, + let preset = match p.get("preset").and_then(Value::as_str) { + Some("quality") => GraphicsPreset::Quality, + Some("performance") => GraphicsPreset::Performance, _ => return Err(bad("view.graphics_preset", "preset must be performance or quality")), }; - Ok(json!({"preset": preset, "enabled": enabled, "display_quality": if enabled { "fine" } else { "normal" }, - "supersampling": if enabled { 2.0 } else { 1.0 }, "supersampling_adaptive": true})) + let enabled = preset == GraphicsPreset::Quality; + typed_reply( + "view.graphics_preset", + GraphicsPresetResult { + preset, + enabled, + display_quality: if enabled { PresetQuality::Fine } else { PresetQuality::Normal }, + supersampling: if enabled { 2.0 } else { 1.0 }, + supersampling_adaptive: true, + param_warnings: Vec::new(), + }, + ) } #[cfg(test)] diff --git a/crates/engine/src/schema/unconverted.txt b/crates/engine/src/schema/unconverted.txt index bfe59f609..4f68cd0b7 100644 --- a/crates/engine/src/schema/unconverted.txt +++ b/crates/engine/src/schema/unconverted.txt @@ -285,13 +285,8 @@ timeline.roll_to timeline.rollback timeline.suppress timeline.ungroup -view.ambient_occlusion view.apply view.delete -view.graphics_preset -view.history_layout -view.layout view.list -view.navigate view.rename view.save diff --git a/crates/engine/src/schema/view_navigation.rs b/crates/engine/src/schema/view_navigation.rs index 1213f9a7b..9bf9386d2 100644 --- a/crates/engine/src/schema/view_navigation.rs +++ b/crates/engine/src/schema/view_navigation.rs @@ -1,9 +1,13 @@ //! Render shell requests. The UI applies validated echoes without design edits. use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema}; use serde::{Deserialize, Deserializer, Serialize}; -use serde_json::Value; +use serde_json::{Value, json}; use std::borrow::Cow; +use super::check::whole; +use solidcore_record::{Vec2, Vec3}; +use solidcraft_geom::Vec3Geom; + use super::types::{CameraParam, present}; #[derive(Debug, Deserialize, Serialize, JsonSchema)] @@ -316,6 +320,468 @@ fn nullable<'de, D: Deserializer<'de>>(d: D) -> Result>, D Option::::deserialize(d).map(Some) } +/// A key's value as its handler reads it: `read` takes the raw JSON value, and anything it +/// refuses gets the handler's own message, whole (no key put in front). +fn read_with<'de, D: Deserializer<'de>, T>(d: D, message: &str, read: impl FnOnce(&Value) -> Option) -> Result, D::Error> { + let value = Value::deserialize(d)?; + read(&value).map(Some).ok_or_else(|| serde::de::Error::custom(whole(message))) +} + +/// A value `T` deserializes from, or the handler's message. +fn read_as<'de, D: Deserializer<'de>, T: serde::de::DeserializeOwned>(d: D, message: &str) -> Result, D::Error> { + read_with(d, message, |v| serde_json::from_value(v.clone()).ok()) +} + +/// A deserializer for a key, with the handler's message for a value it refuses. +macro_rules! reads { + ($name:ident -> $ty:ty, $message:literal) => { + fn $name<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + read_as(d, $message) + } + }; + ($name:ident -> $ty:ty, $message:literal, $read:expr) => { + fn $name<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + read_with(d, $message, $read) + } + }; +} + +/// A key the handlers refuse when it is left out, with their message: optional in the type, so +/// the check leaves the refusal to the handler, and required in the schema. +fn require(schema: &mut Schema, key: &str) { + super::motion::require(schema, key); +} + +fn mode_required(schema: &mut Schema) { + require(schema, "mode"); +} + +fn preset_required(schema: &mut Schema) { + require(schema, "preset"); +} + +fn enabled_required(schema: &mut Schema) { + require(schema, "enabled"); +} + +fn camera_required(schema: &mut Schema) { + require(schema, "camera"); +} + +/// How the workspace is drawn. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "lowercase")] +pub enum LayoutMode { + Floating, + Compact, +} + +reads!(layout_mode -> LayoutMode, "mode must be floating or compact"); + +/// `view.layout`: the workspace layout, floating or compact. A display preference the app keeps; +/// the design, the camera and the active tool are not changed, and it never opens a dialog. +#[derive(Debug, Deserialize, JsonSchema)] +#[schemars(deny_unknown_fields, transform = mode_required)] +pub struct LayoutParams { + // Optional in the type and required in the schema (`mode_required`): left out, the handler + // refuses it with its own message. + /// `floating` or `compact`. + #[serde(default, deserialize_with = "layout_mode", skip_serializing_if = "Option::is_none")] + #[schemars(with = "LayoutMode")] + pub mode: Option, +} + +/// What `view.layout` returns: the layout asked for. +#[derive(Debug, Serialize, JsonSchema)] +pub struct LayoutResult { + pub mode: LayoutMode, + /// In the warn parameter-check mode: what the call's parameters got wrong. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub param_warnings: Vec, +} + +/// Where the history sits. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum HistoryDock { + Bottom, + Left, + UnderBrowser, + /// The history in the browser, with no timeline. + Browser, +} + +reads!(history_width -> f64, "width must be finite and within 1..1000000", |v| v.as_f64().filter(|w| w.is_finite() && (1.0..=1_000_000.0).contains(w))); +reads!(history_dock -> HistoryDock, "dock must be bottom, left, under_browser or browser"); +reads!(history_collapsed -> bool, "collapsed must be a boolean"); + +/// `view.history_layout`: the history's width, dock and whether it is collapsed; each given +/// key is checked and echoed, and a key left out stays as it is. A display preference the app +/// keeps; the design is not changed and it never opens a dialog. +#[derive(Debug, Deserialize, JsonSchema)] +#[schemars(deny_unknown_fields)] +pub struct HistoryLayoutParams { + /// The history's width, 1 to 1000000. + #[serde(default, deserialize_with = "history_width", skip_serializing_if = "Option::is_none")] + #[schemars(with = "f64", range(min = 1.0, max = 1000000.0))] + pub width: Option, + /// Where the history sits. + #[serde(default, deserialize_with = "history_dock", skip_serializing_if = "Option::is_none")] + #[schemars(with = "HistoryDock")] + pub dock: Option, + /// True collapses the history, false opens it. + #[serde(default, deserialize_with = "history_collapsed", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub collapsed: Option, +} + +/// What `view.history_layout` returns: the keys given, checked. +#[derive(Debug, Serialize, JsonSchema)] +pub struct HistoryLayoutResult { + #[serde(skip_serializing_if = "Option::is_none")] + pub width: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub dock: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub collapsed: Option, + /// In the warn parameter-check mode: what the call's parameters got wrong. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub param_warnings: Vec, +} + +/// A graphics preset. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "lowercase")] +pub enum GraphicsPreset { + Performance, + Quality, +} + +/// The tessellation a graphics preset asks for. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, JsonSchema)] +#[serde(rename_all = "lowercase")] +pub enum PresetQuality { + Fine, + Normal, +} + +reads!(graphics_preset_value -> GraphicsPreset, "preset must be performance or quality"); + +/// `view.graphics_preset`: one preset for ambient occlusion, tessellation and supersampling. +/// Quality: ambient occlusion on, Fine, adaptive 2x supersampling. Performance: no ambient +/// occlusion, Normal, no supersampling. MSAA stays independent. A display setting the app keeps; +/// the design is not changed. +#[derive(Debug, Deserialize, JsonSchema)] +#[schemars(deny_unknown_fields, transform = preset_required)] +pub struct GraphicsPresetParams { + // Optional in the type and required in the schema (`preset_required`), as `mode` above. + /// `performance` or `quality`. + #[serde(default, deserialize_with = "graphics_preset_value", skip_serializing_if = "Option::is_none")] + #[schemars(with = "GraphicsPreset")] + pub preset: Option, +} + +/// What `view.graphics_preset` returns: the preset and the settings it stands for. +#[derive(Debug, Serialize, JsonSchema)] +pub struct GraphicsPresetResult { + pub preset: GraphicsPreset, + /// Ambient occlusion on or off. + pub enabled: bool, + pub display_quality: PresetQuality, + /// The supersampling factor: 2 for Quality, 1 for Performance. + pub supersampling: f64, + pub supersampling_adaptive: bool, + /// In the warn parameter-check mode: what the call's parameters got wrong. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub param_warnings: Vec, +} + +reads!(ambient_occlusion_enabled -> bool, "enabled must be a boolean"); + +/// `view.ambient_occlusion`: soft contact shading in the GPU viewport, on or off. A display +/// setting the app keeps; the design is not changed. +#[derive(Debug, Deserialize, JsonSchema)] +#[schemars(deny_unknown_fields, transform = enabled_required)] +pub struct AmbientOcclusionParams { + // Optional in the type and required in the schema (`enabled_required`), as `mode` above. + /// True turns it on, false off. + #[serde(default, deserialize_with = "ambient_occlusion_enabled", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub enabled: Option, +} + +/// What `view.ambient_occlusion` returns. +#[derive(Debug, Serialize, JsonSchema)] +pub struct AmbientOcclusionResult { + /// Whether it is on now. + pub enabled: bool, + /// In the warn parameter-check mode: what the call's parameters got wrong. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub param_warnings: Vec, +} + +/// What a navigation turns the camera by. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum NavigateAction { + Left, + Right, + Up, + Down, + Clockwise, + Counterclockwise, + /// The isometric view, framed on the whole model. + Home, + /// Frame the whole model. + Fit, +} + +/// A direct manipulation of the camera. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum NavigateMotion { + Pan, + Orbit, + Zoom, +} + +/// A point of finite numbers, `[x, y]` or `[x, y, z]` (or an object with those keys), each +/// within `lo..=hi`. +fn bounded_point(keys: &[&str], lo: f64, hi: f64) -> Schema { + let n = keys.len(); + // `params::finite` takes numbers below 1e9 in size; the others' bounds are inclusive. + let number = if hi >= 1e9 { + json!({"type": "number", "exclusiveMinimum": lo, "exclusiveMaximum": hi}) + } else { + json!({"type": "number", "minimum": lo, "maximum": hi}) + }; + let properties: serde_json::Map = keys.iter().map(|k| ((*k).to_string(), number.clone())).collect(); + json_schema!({ + "anyOf": [ + {"type": "array", "items": number, "minItems": n, "maxItems": n}, + {"type": "object", "properties": properties, "required": keys} + ] + }) +} + +fn degrees_schema(_: &mut SchemaGenerator) -> Schema { + json_schema!({"description": "Degrees, above 0 and at most 180.", "type": "number", "exclusiveMinimum": 0, "maximum": 180}) +} + +fn point3_schema(_: &mut SchemaGenerator) -> Schema { + let mut s = bounded_point(&["x", "y", "z"], -1e9, 1e9); + s.insert("description".into(), "A point [x, y, z] or {\"x\", \"y\", \"z\"}, of numbers.".into()); + s +} + +fn delta_schema(_: &mut SchemaGenerator) -> Schema { + let mut s = bounded_point(&["x", "y"], -1e4, 1e4); + s.insert("description".into(), "Pixels [dx, dy] (or {\"x\", \"y\"}), each within ±10000.".into()); + s +} + +fn viewport_schema(_: &mut SchemaGenerator) -> Schema { + let mut s = bounded_point(&["x", "y"], 1.0, 1e6); + s.insert("description".into(), "The viewport's size in pixels [width, height] (or {\"x\", \"y\"}), each 1 to 1000000.".into()); + s +} + +/// The camera `view.navigate` turns: as the other view commands read it, and also with yaw and +/// roll within ±1e6 and pitch within ±π/2 (else "invalid camera"). Read before anything else. +fn navigate_camera<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + read_with(d, "invalid camera", |v| { + crate::cmd::camera_form(v) + .filter(|c| c.yaw.abs() <= 1e6 && c.roll.abs() <= 1e6 && c.pitch.abs() <= std::f64::consts::FRAC_PI_2) + .map(CameraParam) + }) +} + +reads!(navigate_fit -> bool, "fit must be a boolean"); +reads!( + navigate_direction -> Vec3, + "direction must be a finite nonzero vector of length at most 2", + |v| crate::params::vec3(v).filter(|v| v.is_finite() && v.len() <= 2.0 && v.normalized().is_some()) +); +reads!(navigate_action -> NavigateAction, "unknown navigation action"); +reads!( + navigate_degrees -> f64, + "degrees must be a number above 0 and at most 180", + |v| v.as_f64().filter(|d| d.is_finite() && *d > 0.0 && *d <= 180.0) +); +reads!(navigate_motion -> NavigateMotion, "unknown navigation motion"); +reads!(navigate_free_orbit -> bool, "free_orbit must be a boolean"); +/// A pan or orbit's `delta` and an orbit's `viewport` are read in two steps, as the handler +/// does: a point, then its bounds, each with its own message. +fn bounded_point_key<'de, D: Deserializer<'de>>(d: D, key: &str, in_bounds: fn(Vec2) -> bool, out_of_bounds: &str) -> Result, D::Error> { + let point = read_with(d, &format!("`{key}` must be a point [x, y]"), crate::params::vec2)?; + match point { + Some(p) if !in_bounds(p) => Err(serde::de::Error::custom(whole(out_of_bounds))), + point => Ok(point), + } +} + +fn navigate_delta<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + bounded_point_key(d, "delta", |p| p.x.abs() <= 1e4 && p.y.abs() <= 1e4, "motion deltas must be within ±10000 pixels") +} + +fn navigate_viewport<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + bounded_point_key(d, "viewport", |p| (1.0..=1e6).contains(&p.x) && (1.0..=1e6).contains(&p.y), "viewport dimensions must be in 1..1000000") +} +reads!(navigate_pivot -> Vec3, "`pivot` must be a point [x, y, z]", crate::params::vec3); +reads!(navigate_anchor -> Vec3, "`anchor` must be a point [x, y, z]", crate::params::vec3); +reads!( + navigate_factor -> f64, + "factor must be in 0.05..20", + |v| v.as_f64().filter(|f| f.is_finite() && f.abs() < 1e9 && (0.05..=20.0).contains(f)) +); + +/// `view.navigate`: turn, pan, orbit or zoom a camera without changing the design or adding to +/// undo. `camera` is always needed, and then one of three: `direction` (look from it), `action` +/// (a turn, a roll, home or fit) or `motion` (direct manipulation, which wins when given and +/// does not take `fit`). Keys of the other forms are not used. +// Deserialize is written out below rather than derived: the handler reads only the keys of the +// form it takes, so a key of another form is neither read nor checked. +#[derive(Debug, JsonSchema)] +#[schemars(deny_unknown_fields, transform = camera_required)] +pub struct NavigateParams { + // Optional in the type and required in the schema (`camera_required`), as `mode` above. + /// The camera to move, as `ui.inspect` gives it. Its yaw and roll must also be within ±1e6 + /// and its pitch within ±π/2. + #[serde(default, deserialize_with = "navigate_camera", skip_serializing_if = "Option::is_none")] + #[schemars(with = "CameraParam")] + pub camera: Option, + /// Also frame the whole model from the new direction, as home does. Not with `motion`. + /// Default: false. + #[serde(default, deserialize_with = "navigate_fit", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub fit: Option, + /// Look from this direction, in the camera's up-axis frame: a finite nonzero vector of + /// length at most 2. + #[serde(default, deserialize_with = "navigate_direction", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "point3_schema")] + pub direction: Option, + /// A turn without `direction`: left, right, up or down turn the view `degrees`, clockwise and + /// counterclockwise roll it a quarter turn, home shows the isometric view framed, fit frames + /// the model. + #[serde(default, deserialize_with = "navigate_action", skip_serializing_if = "Option::is_none")] + #[schemars(with = "NavigateAction")] + pub action: Option, + /// How far left, right, up or down turn the view, above 0 and at most 180. Default: 90. + #[serde(default, deserialize_with = "navigate_degrees", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "degrees_schema")] + pub degrees: Option, + /// Direct manipulation: pan and orbit need `delta`, pan and an orbit about a `pivot` need + /// `viewport`, zoom needs `factor`. + #[serde(default, deserialize_with = "navigate_motion", skip_serializing_if = "Option::is_none")] + #[schemars(with = "NavigateMotion")] + pub motion: Option, + /// Pan or orbit by this many pixels. + #[serde(default, deserialize_with = "navigate_delta", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "delta_schema")] + pub delta: Option, + /// Orbit through the poles. Default: false. + #[serde(default, deserialize_with = "navigate_free_orbit", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub free_orbit: Option, + /// The viewport's size in pixels, for a pan or an orbit about a pivot. + #[serde(default, deserialize_with = "navigate_viewport", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "viewport_schema")] + pub viewport: Option, + /// Orbit about this point (mm) rather than the camera's target. + #[serde(default, deserialize_with = "navigate_pivot", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "point3_schema")] + pub pivot: Option, + /// The zoom factor, 0.05 to 20. + #[serde(default, deserialize_with = "navigate_factor", skip_serializing_if = "Option::is_none")] + #[schemars(with = "f64", range(min = 0.05, max = 20.0))] + pub factor: Option, + /// Zoom towards this point (mm). Default: the camera's target. + #[serde(default, deserialize_with = "navigate_anchor", skip_serializing_if = "Option::is_none")] + #[schemars(schema_with = "point3_schema")] + pub anchor: Option, +} + +impl<'de> Deserialize<'de> for NavigateParams { + fn deserialize>(d: D) -> Result { + let p = serde_json::Map::::deserialize(d)?; + navigate_form(&p).map_err(serde::de::Error::custom) + } +} + +/// A key's value through its reader, or `None` when the key is left out. +fn navigate_key<'a, T>( + p: &'a serde_json::Map, + key: &str, + read: impl FnOnce(&'a Value) -> Result, serde_json::Error>, +) -> Result, serde_json::Error> { + p.get(key).map_or(Ok(None), read) +} + +/// The keys `view.navigate`'s handler reads, in its order: the camera and `fit`, then those of +/// a motion (each motion its own), of a direction, or of an action. +fn navigate_form(p: &serde_json::Map) -> Result { + let mut form = NavigateParams { + camera: navigate_key(p, "camera", navigate_camera)?, + fit: navigate_key(p, "fit", navigate_fit)?, + direction: None, + action: None, + degrees: None, + motion: None, + delta: None, + free_orbit: None, + viewport: None, + pivot: None, + factor: None, + anchor: None, + }; + if p.contains_key("motion") { + form.free_orbit = navigate_key(p, "free_orbit", navigate_free_orbit)?; + form.motion = navigate_key(p, "motion", navigate_motion)?; + match form.motion { + Some(NavigateMotion::Pan) => { + form.delta = navigate_key(p, "delta", navigate_delta)?; + form.viewport = navigate_key(p, "viewport", navigate_viewport)?; + } + Some(NavigateMotion::Orbit) => { + form.delta = navigate_key(p, "delta", navigate_delta)?; + // An orbit needs the viewport only about a pivot. + if p.contains_key("pivot") { + form.pivot = navigate_key(p, "pivot", navigate_pivot)?; + form.viewport = navigate_key(p, "viewport", navigate_viewport)?; + } + } + Some(NavigateMotion::Zoom) => { + form.factor = navigate_key(p, "factor", navigate_factor)?; + form.anchor = navigate_key(p, "anchor", navigate_anchor)?; + } + None => {} + } + } else if p.contains_key("direction") { + form.direction = navigate_key(p, "direction", navigate_direction)?; + } else { + form.degrees = navigate_key(p, "degrees", navigate_degrees)?; + form.action = navigate_key(p, "action", navigate_action)?; + } + Ok(form) +} + +/// What `view.navigate` returns: the camera after the move, and whether the window should also +/// frame the whole model. The window applies both; the design is not changed. +#[derive(Debug, Serialize, JsonSchema)] +pub struct NavigateResult { + /// The camera now. + #[schemars(with = "CameraParam")] + pub camera: solidcraft_render::Camera, + /// Frame the whole model from the new direction. + pub fit: bool, + /// True for a `motion`; absent for a turn. + #[serde(skip_serializing_if = "Option::is_none")] + pub continuous: Option, + /// In the warn parameter-check mode: what the call's parameters got wrong. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub param_warnings: Vec, +} + #[cfg(test)] #[path = "view_navigation_tests.rs"] mod tests; diff --git a/crates/engine/src/schema/view_navigation_tests.rs b/crates/engine/src/schema/view_navigation_tests.rs index 6aedc7856..bd324b149 100644 --- a/crates/engine/src/schema/view_navigation_tests.rs +++ b/crates/engine/src/schema/view_navigation_tests.rs @@ -1,6 +1,9 @@ use serde_json::{Value, json}; -use super::{AngleReadoutParams, CameraReply, NormalToParams, StandardViewParams, TabStep, TabStepParams}; +use super::{ + AmbientOcclusionParams, AmbientOcclusionResult, AngleReadoutParams, CameraReply, GraphicsPresetParams, GraphicsPresetResult, HistoryLayoutParams, + HistoryLayoutResult, LayoutParams, LayoutResult, NavigateParams, NavigateResult, NormalToParams, StandardViewParams, TabStep, TabStepParams, +}; use crate::Session; use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms}; use crate::schema::types::CameraParam; @@ -11,6 +14,14 @@ fn schemas_and_the_key_check_agree() { assert_keys(input_schema_for::(), &["enabled"]); assert_keys(input_schema_for::(), &["camera"]); assert_keys(input_schema_for::(), &["camera"]); + assert_keys(input_schema_for::(), &["mode"]); + assert_keys(input_schema_for::(), &["collapsed", "dock", "width"]); + assert_keys(input_schema_for::(), &["preset"]); + assert_keys(input_schema_for::(), &["enabled"]); + assert_keys( + input_schema_for::(), + &["action", "anchor", "camera", "degrees", "delta", "direction", "factor", "fit", "free_orbit", "motion", "pivot", "viewport"], + ); } const STANDARD_VIEWS: [&str; 7] = ["view.front", "view.back", "view.left", "view.right", "view.top", "view.bottom", "view.isometric"]; @@ -303,3 +314,333 @@ fn navigator_checks_and_echoes_its_settings_and_refuses_a_missing_body() { let spec = crate::find_command("view.navigator").unwrap(); assert!(!spec.undoable && spec.contract.is_some() && spec.output.is_some()); } + +const LAYOUT_COMMANDS: [&str; 5] = ["view.layout", "view.history_layout", "view.graphics_preset", "view.ambient_occlusion", "view.navigate"]; + +/// A camera for `view.navigate`. +fn nav_camera() -> Value { + camera(json!({"target": [0, 0, 0], "yaw": 0.0, "pitch": 0.0, "distance": 100, "fov": 0.0})) +} + +/// A `view.navigate` call: the camera and `extra`'s keys. +fn nav(extra: Value) -> Value { + let mut p = json!({"camera": nav_camera()}); + if let (Some(o), Some(extra)) = (p.as_object_mut(), extra.as_object()) { + o.extend(extra.clone()); + } + p +} + +/// Each command publishes its input and output schemas with a contract, is display only, and its +/// required keys are the ones its handler refuses a call without. +#[test] +fn the_commands_publish_contracts_and_schemas() { + let mut s = Session::default(); + for id in LAYOUT_COMMANDS { + let spec = crate::find_command(id).unwrap(); + assert!(spec.contract.is_some() && spec.output.is_some() && !spec.undoable, "{id}"); + let d = s.execute("engine.describe", &json!({"command": id})).unwrap(); + assert_eq!(d["input"]["additionalProperties"], false, "{id}"); + assert_eq!(d["output"]["type"], "object", "{id}"); + } + let mut required = |id: &str| { + let d = s.execute("engine.describe", &json!({"command": id})).unwrap(); + d["input"]["required"].clone() + }; + assert_eq!(required("view.layout"), json!(["mode"])); + assert_eq!(required("view.graphics_preset"), json!(["preset"])); + assert_eq!(required("view.ambient_occlusion"), json!(["enabled"])); + assert_eq!(required("view.navigate"), json!(["camera"])); + assert_eq!(required("view.history_layout"), Value::Null); + let d = Session::default().execute("engine.describe", &json!({"command": "view.history_layout"})).unwrap(); + assert_eq!(d["input"]["properties"]["width"]["minimum"], 1.0); + assert_eq!(d["input"]["properties"]["width"]["maximum"], 1000000.0); + let d = Session::default().execute("engine.describe", &json!({"command": "view.navigate"})).unwrap(); + assert_eq!(d["input"]["properties"]["degrees"]["exclusiveMinimum"], 0.0); + assert_eq!(d["input"]["properties"]["degrees"]["maximum"], 180.0); + assert_eq!(d["input"]["properties"]["factor"]["minimum"], 0.05); + assert_eq!(d["input"]["properties"]["pivot"]["anyOf"][0]["items"]["exclusiveMaximum"], 1e9); + let d = Session::default().execute("engine.describe", &json!({"command": "view.history_layout"})).unwrap(); + let dock = serde_json::to_string(&d["input"]).unwrap(); + for name in ["bottom", "left", "under_browser", "browser"] { + assert!(dock.contains(&format!("\"{name}\"")), "dock {name}: {dock}"); + } +} + +/// The replies are the JSON the handlers returned before the types: exactly these values. +#[test] +fn replies_are_todays_json() { + let mut s = Session::default(); + let mut run = |id: &str, p: Value| s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}")); + assert_eq!(run("view.layout", json!({"mode": "compact"})), json!({"mode": "compact"})); + assert_eq!(run("view.layout", json!({"mode": "floating"})), json!({"mode": "floating"})); + assert_eq!(run("view.history_layout", json!({})), json!({})); + assert_eq!( + run("view.history_layout", json!({"width": 320, "dock": "under_browser", "collapsed": false})), + json!({"width": 320.0, "dock": "under_browser", "collapsed": false}) + ); + assert_eq!(run("view.history_layout", json!({"dock": "browser"})), json!({"dock": "browser"})); + assert_eq!( + run("view.graphics_preset", json!({"preset": "quality"})), + json!({"preset": "quality", "enabled": true, "display_quality": "fine", "supersampling": 2.0, "supersampling_adaptive": true}) + ); + assert_eq!( + run("view.graphics_preset", json!({"preset": "performance"})), + json!({"preset": "performance", "enabled": false, "display_quality": "normal", "supersampling": 1.0, "supersampling_adaptive": true}) + ); + assert_eq!(run("view.ambient_occlusion", json!({"enabled": false})), json!({"enabled": false})); + let cam: solidcraft_render::Camera = serde_json::from_value(nav_camera()).unwrap(); + let turned = run("view.navigate", json!({"camera": nav_camera(), "action": "fit"})); + assert_eq!(turned, json!({"camera": cam, "fit": true})); + let moved = run("view.navigate", json!({"camera": nav_camera(), "motion": "zoom", "factor": 2})); + assert_eq!(moved["fit"], false); + assert_eq!(moved["continuous"], true); + assert_eq!(moved.as_object().map(|o| o.len()), Some(3)); +} + +/// Real replies of each command, in Warn, match their output schema; a misspelt key's warning +/// still matches. +#[test] +fn replies_match_the_output_schemas() { + let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() }; + let mut run = |id: &str, p: Value| s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}")); + let calls: Vec<(&str, Value, schemars::Schema)> = vec![ + ("view.layout", json!({"mode": "compact"}), output_schema_for::()), + ("view.layout", json!({"mode": "floating"}), output_schema_for::()), + ("view.history_layout", json!({}), output_schema_for::()), + ("view.history_layout", json!({"width": 250.5, "dock": "left", "collapsed": true}), output_schema_for::()), + ("view.graphics_preset", json!({"preset": "quality"}), output_schema_for::()), + ("view.graphics_preset", json!({"preset": "performance"}), output_schema_for::()), + ("view.ambient_occlusion", json!({"enabled": true}), output_schema_for::()), + ("view.navigate", nav(json!({"direction": [1, 1, 1]})), output_schema_for::()), + ("view.navigate", nav(json!({"action": "left", "degrees": 15})), output_schema_for::()), + ("view.navigate", nav(json!({"action": "home"})), output_schema_for::()), + ("view.navigate", nav(json!({"action": "clockwise", "fit": true})), output_schema_for::()), + ("view.navigate", nav(json!({"motion": "pan", "delta": [10, -5], "viewport": [800, 600]})), output_schema_for::()), + ( + "view.navigate", + nav(json!({"motion": "orbit", "delta": [10, -5], "pivot": [1, 2, 3], "viewport": [800, 600]})), + output_schema_for::(), + ), + ("view.navigate", nav(json!({"motion": "orbit", "delta": [10, -5], "free_orbit": true})), output_schema_for::()), + ("view.navigate", nav(json!({"motion": "zoom", "factor": 0.5, "anchor": [1, 2, 3]})), output_schema_for::()), + ]; + for (id, p, schema) in calls { + let reply = run(id, p.clone()); + let schema = schema.as_value(); + assert!(conforms(schema, schema, &reply), "{id} {p}: {reply} doesn't match {schema}"); + assert!(reply.get("param_warnings").is_none(), "{id} {p}: {reply}"); + let again = run(id, { + let mut q = p.clone(); + q["zoomm"] = json!(1); + q + }); + assert!(again["param_warnings"].as_array().is_some_and(|w| !w.is_empty()), "{id}: {again}"); + assert!(conforms(schema, schema, &again), "{id}: {again} doesn't match {schema}"); + } +} + +/// Strict refuses with the handler's own message whatever the handler refuses. +#[test] +fn view_layout_commands_keep_todays_errors() { + let mut cases: Vec<(&str, Value)> = vec![ + ("view.layout", json!({})), + ("view.layout", json!({"mode": "grid"})), + ("view.layout", json!({"mode": 1})), + ("view.layout", json!({"mode": null})), + ("view.history_layout", json!({"width": 0})), + ("view.history_layout", json!({"width": 1000001})), + ("view.history_layout", json!({"width": "300"})), + ("view.history_layout", json!({"width": null})), + ("view.history_layout", json!({"dock": "top"})), + ("view.history_layout", json!({"dock": 3})), + ("view.history_layout", json!({"collapsed": "yes"})), + ("view.history_layout", json!({"collapsed": null})), + ("view.graphics_preset", json!({})), + ("view.graphics_preset", json!({"preset": "fast"})), + ("view.graphics_preset", json!({"preset": true})), + ("view.graphics_preset", json!({"preset": null})), + ("view.ambient_occlusion", json!({})), + ("view.ambient_occlusion", json!({"enabled": 1})), + ("view.ambient_occlusion", json!({"enabled": "true"})), + ("view.ambient_occlusion", json!({"enabled": null})), + ("view.navigate", json!({})), + ("view.navigate", json!({"camera": null, "action": "fit"})), + ("view.navigate", json!({"camera": 5, "action": "fit"})), + ("view.navigate", json!({"action": "fit"})), + ]; + for c in [ + camera(json!({"yaw": 2e6})), + camera(json!({"roll": -2e6})), + camera(json!({"pitch": 2.0})), + camera(json!({"distance": 0})), + camera(json!({"fov": 4})), + ] { + cases.push(("view.navigate", json!({"camera": c, "action": "fit"}))); + } + for extra in [ + json!({"action": "fit", "fit": 1}), + json!({"action": "fit", "fit": null}), + json!({"direction": [0, 0, 0]}), + json!({"direction": [3, 0, 0]}), + json!({"direction": "front"}), + json!({"direction": null}), + json!({"action": "spin"}), + json!({"action": 4}), + json!({"action": null}), + json!({"action": "left", "degrees": 0}), + json!({"action": "left", "degrees": 181}), + json!({"action": "left", "degrees": "90"}), + json!({"motion": "slide"}), + json!({"motion": null}), + json!({"motion": "zoom", "fit": true, "factor": 2}), + json!({"motion": "zoom", "factor": 0.01}), + json!({"motion": "zoom", "factor": 21}), + json!({"motion": "zoom", "factor": 2, "anchor": [1, 2]}), + json!({"motion": "zoom", "factor": 2, "anchor": null}), + json!({"motion": "pan", "delta": [20000, 0], "viewport": [800, 600]}), + json!({"motion": "pan", "delta": [1], "viewport": [800, 600]}), + json!({"motion": "pan", "viewport": [800, 600]}), + json!({"motion": "pan", "delta": [1, 1], "viewport": [0, 600]}), + json!({"motion": "pan", "delta": [1, 1], "viewport": [800, 2000000]}), + json!({"motion": "pan", "delta": [1, 1]}), + json!({"motion": "orbit", "delta": [1, 1], "free_orbit": "yes"}), + json!({"motion": "orbit", "delta": [1, 1], "pivot": [1, 2]}), + json!({"motion": "orbit", "delta": [1, 1], "pivot": null}), + ] { + cases.push(("view.navigate", nav(extra))); + } + assert_strict_keeps_todays_errors(&cases); +} + +/// A value of a key is accepted by the type exactly when the handler accepts it (the other keys +/// being fine): the schemas never say yes where today's reader says no, or the other way round. +#[test] +fn the_types_read_each_key_as_its_handler_does() { + let accepts = |id: &str, p: &Value| Session::default().execute(id, p).is_ok(); + let check = |id: &str, base: Value, key: &str, values: Vec| { + for v in values { + let mut p = base.clone(); + p[key] = v.clone(); + let ok = accepts(id, &p); + let typed = match id { + "view.layout" => serde_json::from_value::(p.clone()).is_ok(), + "view.history_layout" => serde_json::from_value::(p.clone()).is_ok(), + "view.graphics_preset" => serde_json::from_value::(p.clone()).is_ok(), + "view.ambient_occlusion" => serde_json::from_value::(p.clone()).is_ok(), + _ => serde_json::from_value::(p.clone()).is_ok(), + }; + assert_eq!(typed, ok, "{id} {p}"); + } + }; + let junk = || vec![json!(null), json!(true), json!(0), json!(1.5), json!("x"), json!([]), json!({})]; + let with = |mut v: Vec| { + v.extend(junk()); + v + }; + check("view.layout", json!({}), "mode", with(vec![json!("floating"), json!("compact"), json!("Compact")])); + check("view.history_layout", json!({}), "width", with(vec![json!(1), json!(1e6), json!(0.5), json!(1000001), json!(-4), json!(300)])); + check( + "view.history_layout", + json!({}), + "dock", + with(vec![json!("bottom"), json!("left"), json!("under_browser"), json!("browser"), json!("Left")]), + ); + check("view.history_layout", json!({}), "collapsed", with(vec![json!(true), json!(false)])); + check("view.graphics_preset", json!({}), "preset", with(vec![json!("quality"), json!("performance"), json!("Quality")])); + check("view.ambient_occlusion", json!({}), "enabled", with(vec![json!(true), json!(false)])); + let base = json!({"camera": nav_camera(), "action": "fit"}); + let all_actions: Vec = + ["left", "right", "up", "down", "clockwise", "counterclockwise", "home", "fit", "spin"].iter().map(|a| json!(a)).collect(); + check("view.navigate", json!({"camera": nav_camera()}), "action", with(all_actions)); + check("view.navigate", base.clone(), "fit", with(vec![json!(true), json!(false)])); + check( + "view.navigate", + base.clone(), + "direction", + with(vec![ + json!([1, 0, 0]), + json!([0, 0, 1]), + json!([2, 0, 0]), + json!([2.1, 0, 0]), + json!([0, 0, 0]), + json!({"x": 0, "y": 1, "z": 0}), + json!([1, 2]), + json!([1e10, 0, 0]), + ]), + ); + check( + "view.navigate", + json!({"camera": nav_camera(), "action": "left"}), + "degrees", + with(vec![json!(1), json!(180), json!(90), json!(90.0), json!(0), json!(-1), json!(181), json!(0.001)]), + ); + let all_keys = json!({"camera": nav_camera(), "delta": [1, 1], "viewport": [800, 600], "factor": 2}); + check("view.navigate", all_keys, "motion", with(vec![json!("zoom"), json!("pan"), json!("orbit")])); + let pan = json!({"camera": nav_camera(), "motion": "pan", "viewport": [800, 600]}); + check( + "view.navigate", + pan.clone(), + "delta", + with(vec![json!([1, 2]), json!({"x": 1, "y": 2}), json!([10000, -10000]), json!([10001, 0]), json!([1, 2, 3]), json!([1e10, 0])]), + ); + let pan = json!({"camera": nav_camera(), "motion": "pan", "delta": [1, 1]}); + check( + "view.navigate", + pan, + "viewport", + with(vec![json!([1, 1]), json!([1e6, 1e6]), json!([0.5, 5]), json!([5, 1000001]), json!({"x": 3, "y": 4}), json!([3])]), + ); + let zoom = json!({"camera": nav_camera(), "motion": "zoom", "factor": 2}); + check("view.navigate", zoom.clone(), "anchor", with(vec![json!([1, 2, 3]), json!({"x": 1, "y": 2, "z": 3}), json!([1, 2]), json!([1e10, 0, 0])])); + check( + "view.navigate", + json!({"camera": nav_camera(), "motion": "zoom"}), + "factor", + with(vec![json!(0.05), json!(20), json!(0.04), json!(20.5), json!(1)]), + ); + let orbit = json!({"camera": nav_camera(), "motion": "orbit", "delta": [1, 1], "viewport": [800, 600]}); + check("view.navigate", orbit.clone(), "pivot", with(vec![json!([1, 2, 3]), json!([1, 2]), json!({"x": 1, "y": 2, "z": 3})])); + check("view.navigate", orbit, "free_orbit", with(vec![json!(true), json!(false)])); + let camera_values = vec![ + nav_camera(), + camera(json!({"yaw": 1e6})), + camera(json!({"yaw": 1.1e6})), + camera(json!({"roll": 1.1e6})), + camera(json!({"pitch": std::f64::consts::FRAC_PI_2})), + camera(json!({"pitch": 1.58})), + camera(json!({"pitch": -1.58})), + camera(json!({"distance": 0})), + camera(json!({"fov": 3.2})), + camera(json!({"up": "y"})), + camera(json!({"up": "w"})), + ]; + check("view.navigate", json!({"action": "fit"}), "camera", with(camera_values)); +} + +/// A key of another form than the one the handler takes is not used, so the contract does not +/// read it either: such a call replies as it does with the check off, in warn and in strict. +#[test] +fn navigate_reads_only_the_keys_of_its_form() { + for p in [ + // A motion wins over an action and a direction. + json!({"camera": nav_camera(), "motion": "zoom", "factor": 2, "action": "bogus", "direction": "up"}), + // Each motion reads its own keys: a pan has no factor, a zoom no delta. + json!({"camera": nav_camera(), "motion": "pan", "delta": [3, 4], "viewport": [800, 600], "factor": 99}), + json!({"camera": nav_camera(), "motion": "zoom", "factor": 2, "delta": "far", "viewport": 0, "pivot": "here"}), + // An orbit reads the viewport only about a pivot. + json!({"camera": nav_camera(), "motion": "orbit", "delta": [3, 4], "viewport": 0}), + // A direction has no degrees or action. + json!({"camera": nav_camera(), "direction": [0, 0, 1], "degrees": 500, "action": "bogus"}), + ] { + let off = Session::default().execute("view.navigate", &p).unwrap(); + for check in [ParamCheck::Warn, ParamCheck::Strict] { + let checked = Session { param_check: check, ..Session::default() }.execute("view.navigate", &p).unwrap(); + assert_eq!(checked, off, "{check:?} {p}"); + } + } + // The keys of the form taken are still checked. + let p = json!({"camera": nav_camera(), "motion": "pan", "delta": [3, 4], "viewport": [0, 600]}); + let strict = Session { param_check: ParamCheck::Strict, ..Session::default() }.execute("view.navigate", &p); + assert!(strict.unwrap_err().to_string().contains("viewport dimensions must be in 1..1000000")); +}