Files
solidcraft/crates/ui-egui/src/preview.rs
T
7bd66b7c06 Sketch dimensions: enter the value in a small window with step arrows (#7246) (#7251)
* claim: #7246

* feat(sketch): enter a dimension's value in a small window with step arrows (#7246)

* Dimension window: fit the layer split, and keep the wheel off the camera over the window

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 05:12:31 +00:00

1669 lines
78 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Live operation previews. While a feature dialog is open, its commands are evaluated on a
//! scratch copy of the session ([`solidcraft_engine::Session::preview`]), off the UI thread
//! where threads exist, and the result is drawn in place of the bodies it changes: new surface
//! tinted (unless Graphics' Tint new surface in a preview is off, when a changed body is drawn
//! as itself), removed material as a translucent ghost. The last good preview stays up while
//! the next one computes; once the current inputs make the feature fail, nothing is previewed
//! and the error shows in the dialog (#3254).
//! Nothing here touches the document or the undo history.
//!
//! A feature that adds or removes a tool body (join, cut, intersect) shows only its tool. That
//! is all its preview builds: its boolean, which can take seconds (a text joined onto a part),
//! runs once, on OK, and an error it finds shows then, the dialog staying open.
use solidcraft_engine::geom::prelude::*;
use std::hash::{Hash, Hasher};
use std::sync::Arc;
use std::sync::mpsc::{Receiver, TryRecvError};
use serde_json::Value;
use solidcore_record::Vec3;
use solidcraft_engine::Session;
use solidcraft_engine::doc::ModelState;
use solidcraft_engine::doc::progress::Progress;
use solidcraft_engine::geom::{Aabb3, Mesh, Ring};
use solidcraft_engine::kernel::history::Change;
use crate::SolveApp;
use crate::gpu::{GpuScene, SceneSlot};
use crate::theme::Tokens;
/// Colours a preview is drawn with (straight sRGBA).
#[derive(Clone, Copy, Debug)]
pub struct Colors {
pub body: [u8; 4],
/// The tool a join, cut or intersect adds, a datum plane a preview creates, and, where the
/// preference asks for it (`tint_new`), the surface a feature adds to a body it changes.
pub added: [u8; 4],
/// A body the preview creates (New Body), so it doesn't look like a join.
pub new_body: [u8; 4],
pub removed: [u8; 4],
pub edge: [u8; 4],
/// Whether a moved component's old place is drawn as a ghost (Drive Joints' Show ghost).
pub ghost: bool,
/// Whether the surface a feature adds to a body it changes is drawn in the added colour
/// (Graphics' Tint new surface in a preview). Off: that body is drawn as itself, and which
/// of its faces are new is never worked out.
pub tint_new: bool,
/// Whether removed material is filled in the cut colour (Graphics' Show removed material in
/// red): the see-through cut and the ghost of the shape a feature replaces. Off: those fills
/// are left out altogether, so they are fully transparent and only outlines are drawn.
pub cut_tint: bool,
}
impl Colors {
pub fn from_tokens(t: &Tokens) -> Colors {
let c = |c: egui::Color32| c.to_srgba_unmultiplied();
Colors {
body: c(t.body),
added: c(t.preview_add),
new_body: c(t.preview_new),
removed: c(t.preview_cut),
edge: c(t.body_edge),
ghost: true,
tint_new: true,
cut_tint: true,
}
}
fn for_tool(t: &Tokens, tab: &str, active: bool) -> Colors {
let mut colors = Self::from_tokens(t);
let accent = crate::theme::TabAccent::for_tab(t, tab);
if active && accent.color != t.accent {
colors.added = accent.color.to_srgba_unmultiplied();
colors.new_body = t.body.lerp_to_gamma(accent.color, 0.45).to_srgba_unmultiplied();
}
// Removed material retains its warning colour and opacity.
colors
}
}
pub struct SketchPreview {
pub sketch: std::sync::Arc<solidcraft_engine::doc::SolvedSketch>,
pub curves: Vec<usize>,
pub points: Vec<usize>,
}
/// A computed preview: the scene to draw and the bodies it stands in for.
pub struct Built {
pub scene: GpuScene,
pub sketches: Vec<SketchPreview>,
pub replaced: Vec<String>,
/// Why the feature failed, when the scene only shows its tool body.
pub error: Option<String>,
/// Extent of what the preview shows (the view's depth range must cover it).
pub bounds: Aabb3,
/// The smallest and largest radius a fillet used when it reduced one too large for its edges
/// (`fit: reduce`).
pub applied: Option<(f64, f64)>,
/// The radius spline of each edge a fillet tapered (`fit: taper`), with a point on the edge.
pub tapered: Vec<(Vec3, solidcraft_engine::kernel::Taper)>,
/// The reply of a previewed drive that stopped short of the asked values (the dialog says
/// where and why, in the UI's language).
pub stopped: Option<serde_json::Value>,
}
type Job = Result<Built, String>;
/// How many obsolete preview jobs may still run, left behind for newer inputs (#7167). Beyond
/// them, a new job waits for the running one as before, so a quick series of picks keeps at
/// most this many kernel computations going beside the current one.
const DETACHED: usize = 2;
#[derive(Default)]
pub struct PreviewState {
/// Key of the commands whose result (or error) is shown.
shown_key: Option<u64>,
running: Option<(u64, Receiver<Job>)>,
/// Asks the running job to stop between features once it is obsolete.
running_progress: Option<Arc<Progress>>,
/// Jobs left behind for inputs that changed to another setup (#7167): asked to stop, their
/// results are dropped when they come. With [`DETACHED`] of them running, the next obsolete
/// job is waited for.
detached: Vec<Receiver<Job>>,
/// The running job builds a tool alone (for a join, cut or intersect).
running_tool: bool,
/// Inputs of a joint or distance preview, excluding only its driven values.
running_stream_key: Option<u64>,
/// Bodies the preview stands in for (hidden in the model scene).
pub replaced: Vec<String>,
/// The preview scene for the GPU and its key (changes whenever the scene does).
pub slot: SceneSlot,
pub key: u64,
/// Is a preview scene up?
pub active: bool,
pub sketches: Vec<SketchPreview>,
/// Why the current inputs don't make a feature (nothing is previewed then).
pub error: Option<String>,
/// A preview is being computed.
pub busy: bool,
/// Extent of the preview scene.
pub bounds: Aabb3,
/// Time the last preview took (ms), for `ui.inspect`.
pub ms: f64,
started: f64,
/// The smallest and largest radius the previewed fillet used when it reduced the one asked for.
pub applied: Option<(f64, f64)>,
/// The reply of a previewed drive that stopped short (see [`Built::stopped`]).
pub stopped: Option<serde_json::Value>,
/// The radius splines the previewed fillet tapered its edges with.
pub tapered: Vec<(Vec3, solidcraft_engine::kernel::Taper)>,
straight: crate::extrude_preview::StraightPreview,
moving: crate::move_preview::MovePreview,
/// PreviewReselect: Primary held - hide the preview and restore replaced bodies for picks.
pub rolled_back: bool,
}
impl PreviewState {
/// Bodies the model scene should hide for the preview (empty while rolled back).
pub fn effective_replaced(&self) -> &[String] {
if self.rolled_back { &[] } else { &self.replaced }
}
/// Stop drawing the preview scene and give the bodies it stood in for back to the model.
fn hide_scene(&mut self) {
if self.active || !self.replaced.is_empty() {
self.active = false;
self.bounds = Aabb3::EMPTY;
self.replaced.clear();
self.set_scene(GpuScene::default());
}
}
fn clear(&mut self) {
self.straight.clear();
self.moving.clear();
self.detach();
self.running_tool = false;
self.running_stream_key = None;
self.shown_key = None;
self.error = None;
self.applied = None;
self.stopped = None;
self.tapered.clear();
self.sketches.clear();
self.busy = false;
self.rolled_back = false;
self.hide_scene();
}
/// Drop the preview of a design that leaves the window. Its scene goes too: the viewport
/// keeps drawing the last scene it took until the slot it reads hands it another, so a fresh
/// state (another slot, empty) would leave the old preview drawn over the next design.
pub fn reset(&mut self) {
self.detach();
let (slot, key, detached) = (std::mem::take(&mut self.slot), self.key, std::mem::take(&mut self.detached));
*self = PreviewState { slot, key, detached, ..PreviewState::default() };
self.set_scene(GpuScene::default());
}
fn set_scene(&mut self, sc: GpuScene) {
if let Ok(mut slot) = self.slot.lock() {
*slot = Some(sc);
}
self.key = self.key.wrapping_add(1);
}
fn apply(&mut self, key: u64, job: Job) {
self.shown_key = Some(key);
self.ms = crate::now_ms() - self.started;
match job {
Ok(b) => {
self.sketches = b.sketches;
self.replaced = b.replaced;
self.bounds = b.bounds;
self.active = true;
self.error = b.error;
self.applied = b.applied;
self.stopped = b.stopped;
self.tapered = b.tapered;
self.set_scene(b.scene);
}
// The current inputs make no feature: the last good geometry would contradict
// them (a 1 mm extrusion still drawn at 0 mm), so nothing is drawn.
Err(e) => {
self.hide_scene();
self.sketches.clear();
self.error = Some(e);
self.applied = None;
self.stopped = None;
self.tapered.clear();
}
}
}
/// Errors validate only the current inputs. Keep the last good geometry while
/// computing new inputs, but never let an obsolete result block their Apply.
fn poll(&mut self, key: u64, stream_key: Option<u64>) {
if self.shown_key != Some(key) {
self.sketches.clear();
self.error = None;
}
if let Some((k, rx)) = &self.running {
let k = *k;
let job = match rx.try_recv() {
Ok(job) => Some(job),
Err(TryRecvError::Empty) => None,
Err(TryRecvError::Disconnected) => Some(Err("the preview failed".into())),
};
if let Some(job) = job {
self.running = None;
let good = matches!(&job, Ok(b) if b.error.is_none());
let intermediate = good && (self.running_tool || stream_key.is_some() && self.running_stream_key == stream_key);
self.running_stream_key = None;
self.running_tool = false;
// A held slider, a dragged arrow or an animation may advance faster than the
// worker. Show completed joint/distance results from the same setup, and tools built for
// inputs since changed, then compute the latest. Errors still require an exact
// key.
if k == key || intermediate {
self.apply(k, job);
}
}
}
// A detached job's result is never shown: drop it once it is done.
self.detached.retain(|rx| matches!(rx.try_recv(), Err(TryRecvError::Empty)));
// The inputs moved to another setup (another selection, for the features whose distance,
// radius or pose streams) while a job runs: its result could only be dropped, so stop
// waiting for it and let the current inputs start now (#7167). A tool, or a value
// streaming within one setup, still shows each finished result; inputs that don't stream
// wait as before. At most `DETACHED` jobs are left behind; while they run, the next
// obsolete one is waited for as before.
let other_setup = !self.running_tool && stream_key.is_some() && self.running_stream_key.is_some() && self.running_stream_key != stream_key;
if self.running.as_ref().is_some_and(|(k, _)| *k != key) && other_setup && self.detached.len() < DETACHED {
self.detach();
}
}
/// Stop waiting for the running job: ask it to stop between features, and count it among the
/// detached jobs until its thread ends (also when a closed dialog or another design leaves it
/// behind, so `DETACHED` bounds what runs).
fn detach(&mut self) {
if let Some(progress) = self.running_progress.take() {
progress.cancel();
}
if let Some((_, rx)) = self.running.take() {
self.detached.push(rx);
}
self.running_tool = false;
self.running_stream_key = None;
}
}
/// Joint motion can stream successful intermediate poses while values change. Include
/// every other input, the document revision and colours so a different joint, changed
/// limits, feature dialog or document cannot reuse an obsolete pose.
fn motion_key(cmds: &[(String, Value)], revision: u64, colors: Colors) -> Option<u64> {
if !cmds.iter().any(|(c, p)| c == "joint.drive" || c == "joint.create" && p.get("values").is_some())
|| !cmds.iter().all(|(c, _)| {
matches!(
c.as_str(),
"joint.drive"
| "joint.create"
| "joint.as_built"
| "joint.edit"
| "joint.limits"
| "joint.gear"
| "joint.rack_pinion"
| "joint.screw"
| "joint.cam"
)
})
{
return None;
}
let mut setup = cmds.to_vec();
for (command, params) in &mut setup {
if matches!(command.as_str(), "joint.drive" | "joint.create")
&& let Some(p) = params.as_object_mut()
{
p.remove("values");
if command == "joint.drive" {
p.remove("value");
}
}
}
let mut h = std::collections::hash_map::DefaultHasher::new();
serde_json::to_string(&setup).ok()?.hash(&mut h);
revision.hash(&mut h);
format!("{colors:?}").hash(&mut h);
Some(h.finish())
}
/// Tool previews already stream in `poll`. New-body extrusions, face offsets, fillets and
/// chamfers instead build their full result; allow successful intermediate distances (a
/// fillet's radii, a chamfer's distances and angle) only within the same setup. Preserve selections, feature identity, extent mode, revision and colours. The
/// exact job key still ensures the latest distance is computed and errors never go stale.
fn stream_key(cmds: &[(String, Value)], revision: u64, colors: Colors) -> Option<u64> {
if let Some(key) = motion_key(cmds, revision, colors) {
return Some(key);
}
if cmds.is_empty() || as_new_body(cmds).is_some() {
return None;
}
let mut setup = cmds.to_vec();
for (command, params) in &mut setup {
let (command, params) = if command == "timeline.redefine" {
let command = params.get("command")?.as_str()?.to_string();
(command, params.get_mut("params")?)
} else {
(command.clone(), params)
};
let fields: &[&str] = match command.as_str() {
"solid.extrude" => &["distance", "distance2", "to_offset"],
"solid.offset_face" => &["distance"],
// A radius dragged or typed: each result shows while the next computes, rather than
// the preview holding still until the input stops changing.
"solid.fillet" => &["radius", "radius2", "mid"],
"solid.chamfer" => &["distance", "distance2", "angle"],
_ => return None,
};
let params = params.as_object_mut()?;
for field in fields {
// Keep presence: changing extent mode must not reuse the old result.
if let Some(value) = params.get_mut(*field) {
*value = Value::Null;
}
}
}
Some(job_key(&setup, revision, colors))
}
/// Keep the preview in step with the open dialog: start a computation when its inputs changed,
/// take finished results. Called once per frame.
pub fn update(app: &mut SolveApp, ctx: &egui::Context) {
let cmds = match app.dialog.as_ref().filter(|d| d.previews() && d.preview_enabled).map(|d| crate::dialogs::preview_commands(app, d)) {
Some(Ok(c)) if !c.is_empty() => c,
_ if crate::sketch_attachment_ui::commands(app).is_some() => crate::sketch_attachment_ui::commands(app).unwrap_or_default(),
// A parameter being edited in Change Parameters.
_ if app.params.as_ref().and_then(|p| p.preview_commands()).is_some() => {
app.params.as_ref().and_then(|p| p.preview_commands()).unwrap_or_default()
}
// No dialog, or inputs still missing: nothing to preview.
_ => {
app.preview.clear();
return;
}
};
let mut colors = Colors::for_tool(&Tokens::get(), &app.ui.tab, app.tool.is_some() || app.dialog.is_some());
if app.dialog.as_ref().is_some_and(|d| matches!(d.kind, crate::dialogs::Kind::Assembly(crate::dialogs_assembly::Asm::Drive { .. }))) {
colors.ghost = app.preferences.drive_joints_ghost;
}
colors.tint_new = app.preferences.preview_tint_new_faces;
colors.cut_tint = app.preferences.cut_preview_tint;
let key = job_key(&cmds, app.session.revision, colors);
let stream_key = stream_key(&cmds, app.session.revision, colors);
let tool = as_new_body(&cmds).is_some();
let pv = &mut app.preview;
pv.poll(key, stream_key);
if pv.running.is_none() && pv.shown_key != Some(key) {
pv.started = crate::now_ms();
pv.running_stream_key = stream_key;
let mut straight = std::mem::take(&mut app.preview.straight);
let mut job = straight.compute(app, &cmds, colors);
app.preview.straight = straight;
if job.is_none() {
let mut moving = std::mem::take(&mut app.preview.moving);
job = moving.compute(app, &cmds, colors);
app.preview.moving = moving;
}
if let Some(job) = job {
app.preview.apply(key, job);
app.preview.busy = false;
return;
}
let scratch = app.session.scratch();
spawn(&mut app.preview, key, scratch, cmds, colors, tool, Arc::new(Progress::default()));
}
app.preview.busy = app.preview.running.is_some();
if app.preview.busy {
ctx.request_repaint_after(std::time::Duration::from_millis(16));
}
}
/// What tells one preview computation from another: its commands, the document revision they
/// run on and the colours.
fn job_key(cmds: &[(String, Value)], revision: u64, colors: Colors) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
serde_json::to_string(cmds).unwrap_or_default().hash(&mut h);
revision.hash(&mut h);
format!("{colors:?}").hash(&mut h);
h.finish()
}
/// Start computing the preview of `cmds`: for a tool feature (`tool`), only its tool.
#[cfg(not(target_arch = "wasm32"))]
fn spawn(pv: &mut PreviewState, key: u64, scratch: Session, cmds: Vec<(String, Value)>, colors: Colors, tool: bool, progress: Arc<Progress>) {
let (tx, rx) = std::sync::mpsc::channel();
// Watched by `progress`, so a job left behind for other inputs skips its remaining features.
let watched = progress.clone();
let spawned = std::thread::Builder::new().name("preview".into()).spawn(move || {
let job = solidcraft_engine::doc::progress::watch(watched, || {
if tool { compute_tool(&scratch, &cmds, colors) } else { compute(&scratch, &cmds, colors) }
});
let _ = tx.send(job);
});
match spawned {
Ok(_) => {
pv.running = Some((key, rx));
pv.running_progress = Some(progress);
pv.running_tool = tool;
}
Err(e) => pv.apply(key, Err(e.to_string())),
}
}
/// No threads on the web: compute right away.
#[cfg(target_arch = "wasm32")]
fn spawn(pv: &mut PreviewState, key: u64, scratch: Session, cmds: Vec<(String, Value)>, colors: Colors, tool: bool, _progress: Arc<Progress>) {
pv.apply(key, if tool { compute_tool(&scratch, &cmds, colors) } else { compute(&scratch, &cmds, colors) });
}
/// Evaluate the commands on the scratch session and build the preview scene.
/// Features that add or remove a tool body (extrude, revolve, primitives with join, cut or
/// intersect) show the tool itself: tinted for join, see-through red for cut. Other features
/// show their result in place of the bodies they change. When the feature fails (a boolean the
/// kernel can't do yet), the tool body is still shown, with the error.
pub fn compute(s: &Session, cmds: &[(String, Value)], colors: Colors) -> Job {
if cmds.iter().any(|(command, params)| {
matches!(
command.as_str(),
"sketch.redefine"
| "sketch.mirror"
| "sketch.pattern.rectangular"
| "sketch.pattern.circular"
| "sketch.offset"
| "sketch.fillet"
| "sketch.chamfer.equal_distance"
| "sketch.chamfer.two_distance"
| "sketch.chamfer.distance_angle"
| "sketch.insert_svg"
| "sketch.insert_dxf"
) || command == "construct.plane.along_path"
|| params.get("command").and_then(Value::as_str) == Some("construct.plane.along_path")
}) {
let preview = s.preview_visible_world(cmds).map_err(|error| error.to_string())?;
return std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let mut built = build(&preview.before, &preview.after, colors);
built.bounds = state_bounds(&preview.after);
built
}))
.map_err(|_| "the preview failed".to_string());
}
// Joints and drives move occurrences: shown on the placed model.
if let Some(job) = crate::dialogs_assembly::world_preview(s, cmds, colors) {
return job;
}
match as_new_body(cmds) {
Some(_) => {
let mut b = compute_tool(s, cmds, colors)?;
b.error = s.preview(cmds).err().map(|e| e.to_string());
Ok(b)
}
None => {
let p = s.preview(cmds).map_err(|e| e.to_string())?;
let guard =
|f: &dyn Fn() -> Built| std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)).map_err(|_| "the preview failed".to_string());
let mut b = guard(&|| build(&p.before, &p.after, colors))?;
b.bounds = state_bounds(&p.after);
// The radius a previewed fillet used when it reduced the one asked for (a new
// fillet or an edited one: the feature the replies name).
let features = || p.replies.iter().filter_map(|r| r.get("feature").and_then(Value::as_u64));
b.applied = features().find_map(|id| p.after.fitted_range(id));
b.tapered = features().find_map(|id| p.after.tapered(id)).map(<[_]>::to_vec).unwrap_or_default();
Ok(b)
}
}
}
/// The tool body of a feature that adds or removes one, built on its own (as a new body): what
/// its live preview shows, without the boolean. When even the tool fails, the feature's own
/// error. Other features: their whole preview ([`compute`]).
fn compute_tool(s: &Session, cmds: &[(String, Value)], colors: Colors) -> Job {
let Some((alt, op)) = as_new_body(cmds) else { return compute(s, cmds, colors) };
// Where the view shows it: in a component placed away from its own frame (an imported
// part stood upright) the model's frame would draw the tool at right angles to the face.
let tool = match s.preview_world(&alt) {
Ok(t) => t,
Err(e) => return Err(s.preview(cmds).err().map_or_else(|| e.to_string(), |r| r.to_string())),
};
let mut b = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| build_tool(&tool.before, &tool.after, colors, &op)))
.map_err(|_| "the preview failed".to_string())?;
b.bounds = state_bounds(&tool.after);
Ok(b)
}
fn extrusion_params<'a>(id: &str, params: &'a Value) -> Option<&'a Value> {
match id {
"solid.extrude" => Some(params),
"timeline.redefine" if params.get("command").and_then(Value::as_str) == Some("solid.extrude") => params.get("params"),
_ => None,
}
}
/// Check references without intersecting the tool with the target's geometry.
pub(crate) fn extrusion_target_error(s: &Session, cmds: &[(String, Value)], before: &ModelState) -> Option<String> {
for (id, params) in cmds {
let params = extrusion_params(id, params)?;
let op = params.get("operation").and_then(Value::as_str).unwrap_or("new");
if op == "new" {
continue;
}
let targets = params
.get("targets")
.and_then(Value::as_array)
.filter(|targets| !targets.is_empty())
.or_else(|| params.get("participants").and_then(Value::as_array));
let mut found = false;
if let Some(targets) = targets.filter(|targets| !targets.is_empty()) {
for target in targets.iter().filter_map(Value::as_str) {
if target == "*" {
found |= !before.bodies.is_empty();
} else if before.body(target).is_some() {
found = true;
} else {
return Some(format!("unknown body `{target}`"));
}
}
} else {
// A cut or intersect from a component with no body of its own takes part in every
// body: the command decides that (#1234), and the preview asks it the same (#3085).
found = params.get("faces").and_then(|_| params.get("face_body")).and_then(Value::as_str).map_or_else(
|| {
before.bodies.iter().any(|body| s.doc.model_body_component(body) == s.active_component)
|| (matches!(op, "cut" | "intersect") && s.cut_takes_every_body(before))
},
|name| crate::open_meshing::session_world(s).body(name).is_some(),
);
}
if !found && matches!(op, "cut" | "intersect") {
return Some("there is no body to cut or intersect".into());
}
}
None
}
fn state_bounds(st: &ModelState) -> Aabb3 {
st.bodies.iter().fold(Aabb3::EMPTY, |b, x| b.union(&x.mesh().bounds()))
}
/// The tool bodies a join/cut/intersect adds: opaque and tinted for join, see-through for cut
/// (red) and intersect.
fn build_tool(before: &ModelState, after: &ModelState, c: Colors, op: &str) -> Built {
let mut sc = GpuScene::default();
let removed = sc.color(c.removed);
let intersect = sc.color([c.added[0], c.added[1], c.added[2], c.removed[3]]);
let added = sc.color(c.added);
let edge = if op == "cut" { sc.color([c.removed[0], c.removed[1], c.removed[2], 255]) } else { sc.color(c.edge) };
for a in after.bodies.iter().filter(|a| before.body(&a.name).is_none()) {
let m = a.mesh();
for t in &m.triangles {
for k in t {
let i = *k as usize;
if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
match op {
"cut" if !c.cut_tint => {}
"cut" => sc.xray_tri(p.to_f32(), n.to_f32(), removed),
"intersect" => sc.xray_tri(p.to_f32(), n.to_f32(), intersect),
_ => sc.tri(p.to_f32(), n.to_f32(), added),
}
}
}
}
for (ei, e) in m.edges.iter().enumerate() {
if m.shaded_edge_visible(ei) {
for w in e.windows(2) {
sc.line(w[0].to_f32(), w[1].to_f32(), edge, 1.3, op != "join");
}
}
}
}
Built {
scene: sc,
sketches: Vec::new(),
replaced: Vec::new(),
error: None,
bounds: Aabb3::EMPTY,
applied: None,
tapered: Vec::new(),
stopped: None,
}
}
/// The same commands making a new body instead of joining, cutting or intersecting, and the
/// operation they had.
fn as_new_body(cmds: &[(String, Value)]) -> Option<(Vec<(String, Value)>, String)> {
let mut out = cmds.to_vec();
let mut changed: Option<String> = None;
for (command, p) in &mut out {
let inner = p.get("command").and_then(Value::as_str).map(str::to_string);
// A combine's operation is between bodies that already exist: it has no new-body form
// (and no tool body of its own to show).
if inner.as_deref().unwrap_or(command.as_str()) == "solid.combine" {
continue;
}
let p = if p.get("command").is_some() { p.get_mut("params")? } else { p };
if let Some(op) = p.get_mut("operation")
&& let Some(o) = op.as_str().filter(|o| *o != "new").map(str::to_string)
{
*op = Value::from("new");
changed = Some(o);
}
}
changed.map(|op| (out, op))
}
fn same(a: &Mesh, b: &Mesh) -> bool {
a.triangles.len() == b.triangles.len() && a.positions == b.positions
}
/// The preview scene: changed and new bodies (new surface tinted) and, as a ghost, the old
/// version of changed or removed bodies.
pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {
let mut sc = GpuScene::default();
let added_color = sc.color(c.added);
let added_plane = sc.color([c.added[0], c.added[1], c.added[2], 64]);
let body_color = sc.color(c.body);
let new_body = sc.color(c.new_body);
let removed = sc.color(c.removed);
let edge = sc.color(c.edge);
let mut replaced = Vec::new();
for construct in &after.construct {
if before.construct.iter().any(|old| old == construct) {
continue;
}
if let solidcraft_engine::doc::construct::ConstructGeom::Plane(plane) = construct.geom {
let (o, x, y) = (plane.origin, plane.x * 10.0, plane.y * 10.0);
let quad = [o - x - y, o + x - y, o + x + y, o - x + y];
for triangle in [[quad[0], quad[1], quad[2]], [quad[0], quad[2], quad[3]]] {
for p in triangle {
sc.xray_tri(p.to_f32(), plane.normal().to_f32(), added_plane);
}
}
for (a, b) in Ring::from(quad).edges() {
sc.line(a.to_f32(), b.to_f32(), added_color, 1.3, true);
}
}
}
for a in &after.bodies {
let am = a.mesh();
let old = before.body(&a.name).map(|b| b.mesh());
if old.as_ref().is_some_and(|bm| same(bm, &am)) {
continue;
}
// Material removed from a body (a hole, a pocket): its new faces also show through the
// body in the cut colour, so the cut is seen from any side.
let cut = c.cut_tint && old.as_ref().is_some_and(|bm| am.measure().volume < bm.measure().volume - 1e-6);
// Which of the body's faces the feature made, asked only when something is drawn from
// the answer: the cut above, and the tint the preference offers. A changed body is
// otherwise drawn as itself, so a preview looks like the model and nothing has to be
// worked out face by face.
let new_face: Vec<bool> = match &old {
Some(bm) if cut || c.tint_new => {
let mut new = new_faces(&am, am.tri_face.iter().max().map_or(0, |m| *m as usize + 1), bm);
// The kernel recorded which faces the operation that made this body generated,
// i.e. has no face of an input under it. The two answers are taken together
// because each misses something on its own: geometry cannot see a round small
// beside the part, which lies within its tolerance of the faces it is tangent
// to all along both of its sides, while the record may be of a later operation
// than the one previewed (a parameter change re-evaluates the design, and a
// body keeps the history of whatever last made it), so the record only ever
// adds faces to the answer.
if let Some(history) = a.body.history() {
for (is_new, face) in new.iter_mut().zip(&history.faces) {
*is_new |= face.change == Change::Generated;
}
}
new
}
_ => Vec::new(),
};
let kept = if old.is_some() { body_color } else { new_body };
for (t, f) in am.triangles.iter().zip(&am.tri_face) {
let new = new_face.get(*f as usize).copied().unwrap_or(false);
let col = if new && c.tint_new { added_color } else { kept };
let through = cut && new;
for k in t {
let i = *k as usize;
if let (Some(p), Some(n)) = (am.positions.get(i), am.normals.get(i)) {
sc.tri(p.to_f32(), n.to_f32(), col);
if through {
sc.xray_tri(p.to_f32(), n.to_f32(), removed);
}
}
}
}
for (ei, e) in am.edges.iter().enumerate() {
if !am.shaded_edge_visible(ei) {
continue;
}
for w in e.windows(2) {
sc.line(w[0].to_f32(), w[1].to_f32(), edge, 1.3, false);
}
}
if old.is_some() {
replaced.push(a.name.clone());
}
}
for b in &before.bodies {
let gone = after.body(&b.name).is_none();
if !gone && !replaced.contains(&b.name) {
continue;
}
let m = b.mesh();
if c.cut_tint {
// A changed body's surface it keeps is not removed material: drawn as ghost there it
// lies on the new body's face, and where that face is curved and meshed anew (its
// boundary moved) the two triangulations cross by up to their chord error, far past the
// ghost's depth bias, so the ghost showed through the new face in slivers.
let kept = if gone { None } else { after.body(&b.name).and_then(|a| SurfaceIndex::new(&a.mesh())) };
for t in &m.triangles {
let Some(corners) = m.tri(t) else { continue };
if kept.as_ref().is_some_and(|k| on_surface(k, corners)) {
continue;
}
for k in t {
let i = *k as usize;
if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
sc.ghost_tri(p.to_f32(), n.to_f32(), removed);
}
}
}
}
if gone {
replaced.push(b.name.clone());
}
}
let sketches = after.sketches.iter().filter_map(|sketch| sketch_changes(before.sketch(sketch.feature), sketch)).collect();
Built { scene: sc, sketches, replaced, error: None, bounds: Aabb3::EMPTY, applied: None, tapered: Vec::new(), stopped: None }
}
/// Does the triangle lie on the surface `index` holds: its corners, the middles of its sides
/// and its centroid all on it?
fn on_surface(index: &SurfaceIndex, [a, b, c]: [Vec3; 3]) -> bool {
[a, b, c, (a + b) / 2.0, (b + c) / 2.0, (c + a) / 2.0, (a + b + c) / 3.0].into_iter().all(|p| index.contains(p))
}
/// Points of one face the vote in [`new_faces`] asks about: every centroid of a face with no
/// more than this many triangles, so its answer doesn't ride on where that face's rows of
/// facets happen to fall, and a spread sample of a larger one. The lookups per face stay
/// bounded, so a modeled thread's thousands of faces still cost little.
const FACE_SAMPLES: usize = 24;
/// What of `sketch` differs from `old`, the same sketch before a change: the curves whose shape
/// or points moved and the points that moved (`None`: nothing did).
pub(crate) fn sketch_changes(
old: Option<&solidcraft_engine::doc::SolvedSketch>,
sketch: &std::sync::Arc<solidcraft_engine::doc::SolvedSketch>,
) -> Option<SketchPreview> {
let old_curves = old.into_iter().flat_map(|s| s.sketch.curves.iter().map(|c| (c.id.as_str(), c))).collect::<std::collections::HashMap<_, _>>();
let old_points =
old.into_iter().flat_map(|s| s.sketch.points.iter().map(|p| (p.id.as_str(), p.pos))).collect::<std::collections::HashMap<_, _>>();
let indices = sketch
.sketch
.curves
.iter()
.enumerate()
.filter_map(|(index, curve)| {
let unchanged = old_curves.get(curve.id.as_str()).is_some_and(|previous| {
previous.kind == curve.kind && curve.kind.point_ids().iter().all(|i| old.and_then(|s| s.sketch.point(*i)) == sketch.sketch.point(*i))
});
if unchanged { None } else { Some(index) }
})
.collect::<Vec<_>>();
let points = sketch
.sketch
.points
.iter()
.enumerate()
.filter_map(|(i, p)| if old_points.get(p.id.as_str()) == Some(&p.pos) { None } else { Some(i) })
.collect::<Vec<_>>();
if indices.is_empty() && points.is_empty() { None } else { Some(SketchPreview { sketch: sketch.clone(), curves: indices, points }) }
}
/// Which of the `nf` faces of `m` are new surface, i.e. not on the old mesh? Each is decided by
/// a vote of points on it (triangle centroids spread over the face). One pass over `m`'s
/// triangles gathers the centroids, and the old mesh is indexed once, so the cost stays
/// near-linear however many faces there are (a modeled thread has thousands).
fn new_faces(m: &Mesh, nf: usize, old: &Mesh) -> Vec<bool> {
let mut cents: Vec<Vec<Vec3>> = vec![Vec::new(); nf];
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
if let (Some(face), Some([a, b, c])) = (cents.get_mut(*f as usize), m.tri(t)) {
face.push((a + b + c) / 3.0);
}
}
let index = SurfaceIndex::new(old);
cents
.iter()
.map(|cents| {
let Some(index) = &index else { return true };
if cents.is_empty() {
return true;
}
let samples: Vec<&Vec3> = if cents.len() <= FACE_SAMPLES {
cents.iter().collect()
} else {
// Spread by the golden ratio rather than at a fixed step: a face's triangles
// come in rows across its curve, and a step that divides the row length would
// ask about the same place in every row (a blend's tangent sides, say), so two
// alike faces could be told apart by nothing but how long they are.
let len = cents.len() as f64;
(0..FACE_SAMPLES).filter_map(|i| cents.get(((i as f64 * 0.618_033_988_75).fract() * len) as usize)).collect()
};
let off = samples.iter().filter(|p| !index.contains(***p)).count();
// More than an eighth of the face off the old surface is new surface. A blend meets
// the faces it rounds tangentially, so the rows of facets along both of its sides
// lie within the tolerance of the old surface and only the band through its middle
// is clearly off: a small round on a large part never reaches the third the vote
// asked for before, and was drawn as if it had always been there.
off * 8 > samples.len()
})
.collect()
}
/// The triangles of a mesh in a uniform grid, to ask whether a point lies on the surface (within
/// its tessellation tolerance) by looking only at the triangles near it.
struct SurfaceIndex {
tris: Vec<[Vec3; 3]>,
tol: f64,
lo: [f64; 3],
cell: [f64; 3],
res: usize,
cells: Vec<Vec<u32>>,
}
impl SurfaceIndex {
/// Most triangle-in-cell entries the grid may hold; a coarser grid is used beyond it.
const BUDGET: usize = 4_000_000;
/// None for a mesh with no surface.
fn new(m: &Mesh) -> Option<SurfaceIndex> {
let bb = m.bounds();
if bb.is_empty() {
return None;
}
let tol = (bb.diagonal() * 2e-3).max(1e-4);
let tris: Vec<[Vec3; 3]> = m.triangles.iter().filter_map(|t| m.tri(t)).collect();
let lo = [bb.min.x - tol, bb.min.y - tol, bb.min.z - tol];
let ext = [bb.max.x - bb.min.x + 2.0 * tol, bb.max.y - bb.min.y + 2.0 * tol, bb.max.z - bb.min.z + 2.0 * tol];
let mut res = ((tris.len() as f64).cbrt().round() as usize).clamp(1, 48);
loop {
let cell = [ext[0] / res as f64, ext[1] / res as f64, ext[2] / res as f64];
let mut index = SurfaceIndex { tris: Vec::new(), tol, lo, cell, res, cells: vec![Vec::new(); res * res * res] };
let mut entries = 0usize;
'fill: for (i, t) in tris.iter().enumerate() {
let (a, b) = index.range(t);
for x in a[0]..=b[0] {
for y in a[1]..=b[1] {
for z in a[2]..=b[2] {
entries += 1;
if entries > Self::BUDGET && res > 1 {
break 'fill;
}
if let Some(c) = index.cells.get_mut((x * res + y) * res + z) {
c.push(i as u32);
}
}
}
}
}
if entries <= Self::BUDGET || res == 1 {
index.tris = tris;
return Some(index);
}
res /= 2;
}
}
fn cell_of(&self, v: f64, axis: usize) -> usize {
let (lo, cell) = (self.lo.get(axis).copied().unwrap_or(0.0), self.cell.get(axis).copied().unwrap_or(1.0));
let k = ((v - lo) / cell).floor();
if k.is_finite() { (k.max(0.0) as usize).min(self.res - 1) } else { 0 }
}
/// The cells (inclusive corners) a triangle, grown by the tolerance, touches.
fn range(&self, t: &[Vec3; 3]) -> ([usize; 3], [usize; 3]) {
let (mut a, mut b) = ([0; 3], [0; 3]);
for axis in 0..3 {
let c = t.map(|p| [p.x, p.y, p.z][axis]);
let (lo, hi) = (c[0].min(c[1]).min(c[2]) - self.tol, c[0].max(c[1]).max(c[2]) + self.tol);
a[axis] = self.cell_of(lo, axis);
b[axis] = self.cell_of(hi, axis);
}
(a, b)
}
/// Does `p` lie on the surface?
fn contains(&self, p: Vec3) -> bool {
let (x, y, z) = (self.cell_of(p.x, 0), self.cell_of(p.y, 1), self.cell_of(p.z, 2));
let Some(cell) = self.cells.get((x * self.res + y) * self.res + z) else { return false };
cell.iter().filter_map(|i| self.tris.get(*i as usize)).any(|[a, b, c]| point_triangle_dist(p, *a, *b, *c) < self.tol)
}
}
pub fn point_triangle_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 {
let n = (b - a).cross(c - a);
let Some(nn) = n.normalized() else { return f64::INFINITY };
let h = (p - a).dot(nn);
let q = p - nn * h;
let inside = [(a, b), (b, c), (c, a)].iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(n) >= -1e-12);
if inside { h.abs() } else { [(a, b), (b, c), (c, a)].iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min) }
}
/// The same computed sketch preview is drawn over both native GPU and CPU viewports.
pub fn paint_sketches(app: &SolveApp, painter: &egui::Painter, proj: &crate::viewport::Proj) {
if app.preview.rolled_back {
return;
}
if !app
.dialog
.as_ref()
.is_some_and(|d| matches!(d.kind, crate::dialogs::Kind::SketchModify(_) | crate::dialogs::Kind::InsertDrawing(_)) && d.previews())
{
return;
}
let mut budget = solidcraft_engine::render::SamplingBudget::new(32_768, 65_536);
let curves: usize = app.preview.sketches.iter().map(|preview| paint_sketch(preview, painter, proj, &mut budget)).sum();
crate::scenario::publish_count("sketch_preview_curves", curves as f64);
}
/// Draw what a change moves in a sketch, its curves and points, in the preview colour; returns
/// how many curves it drew.
pub(crate) fn paint_sketch(
preview: &SketchPreview,
painter: &egui::Painter,
proj: &crate::viewport::Proj,
budget: &mut solidcraft_engine::render::SamplingBudget,
) -> usize {
let stroke = egui::Stroke::new(2.5, Tokens::get().preview_sketch);
let sketch = &preview.sketch;
for index in &preview.curves {
crate::tools::paint_curve(&sketch.sketch, *index, &sketch.plane, painter, proj, stroke, budget);
}
for index in &preview.points {
if let Some(point) = sketch.sketch.point(*index).and_then(|p| proj.to_screen(sketch.plane.to_world(p))) {
painter.circle_filled(point, 3.0, stroke.color);
}
}
preview.curves.len()
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn tool_preview_follows_tab_without_recolouring_removal_or_idle_previews() {
for dark in [false, true] {
for vision in crate::theme::ColorVision::ALL {
let t = Tokens::themed(dark, vision);
let base = Colors::from_tokens(&t);
for tab in ["MODEL", "SKETCH", "SURFACE", "ASSEMBLE", "INSERT", "INSPECT", "MANAGE", "VIEW", "SHEET METAL", "RENDER"] {
for active in [false, true] {
let colors = Colors::for_tool(&t, tab, active);
assert_eq!(colors.removed, base.removed);
assert_eq!(colors.body, base.body);
assert_eq!(colors.edge, base.edge);
if !active || crate::theme::TabAccent::for_tab(&t, tab).color == t.accent {
assert_eq!(colors.added, base.added);
assert_eq!(colors.new_body, base.new_body);
} else {
let accent = crate::theme::TabAccent::for_tab(&t, tab);
assert_eq!(colors.added, accent.color.to_srgba_unmultiplied());
assert_ne!(colors.new_body, colors.added);
}
}
}
}
}
}
fn colors() -> Colors {
Colors {
body: [1, 1, 1, 255],
added: [2, 2, 2, 255],
new_body: [4, 4, 4, 255],
removed: [3, 3, 3, 100],
edge: [0, 0, 0, 255],
ghost: true,
tint_new: true,
cut_tint: true,
}
}
#[test]
fn correcting_inputs_clears_old_errors_and_discards_late_old_jobs() {
let mut pv = PreviewState {
shown_key: Some(1),
error: Some("unknown_angle".into()),
active: true,
replaced: vec!["Turn".into()],
key: 9,
..PreviewState::default()
};
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((1, rx));
pv.poll(2, None);
assert!(pv.error.is_none(), "the corrected inputs can Apply while their preview computes");
assert!(pv.running.is_some());
assert!(pv.active);
assert_eq!(pv.replaced, ["Turn"]);
assert_eq!(pv.key, 9, "the last good geometry stays visible");
tx.send(Err("unknown_angle".into())).unwrap();
pv.poll(2, None);
assert!(pv.error.is_none(), "a late obsolete result cannot disable Apply again");
assert!(pv.running.is_none());
assert_eq!(pv.shown_key, Some(1));
assert_eq!(pv.key, 9);
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((2, rx));
tx.send(Err("current invalid expression".into())).unwrap();
pv.poll(2, None);
assert_eq!(pv.error.as_deref(), Some("current invalid expression"));
assert_eq!(pv.shown_key, Some(2));
assert!(!pv.active && pv.replaced.is_empty(), "the current inputs failed: nothing is previewed (#3254)");
assert_ne!(pv.key, 9, "the viewport takes the empty scene");
pv.poll(2, None);
assert_eq!(pv.error.as_deref(), Some("current invalid expression"), "current errors still prevent invalid Apply");
}
fn pose() -> Built {
Built {
scene: GpuScene::default(),
sketches: Vec::new(),
replaced: vec!["Lid".into()],
error: None,
bounds: Aabb3::EMPTY,
applied: None,
tapered: Vec::new(),
stopped: None,
}
}
/// The worker completes while the slider is still held or Play keeps advancing.
/// Intermediate successful poses must reach the viewport, and the final value
/// must still be computed rather than treating that intermediate pose as current.
#[test]
fn joint_motion_shows_completed_poses_while_inputs_keep_advancing() {
let mut pv = PreviewState::default();
for (running, wanted) in [(1, 2), (2, 3), (3, 4)] {
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((running, rx));
pv.running_stream_key = Some(42);
pv.poll(wanted, Some(42));
assert!(pv.running.is_some());
tx.send(Ok(pose())).unwrap();
pv.poll(wanted, Some(42));
assert!(pv.active, "motion should be visible before input stops");
assert_eq!(pv.replaced, ["Lid"]);
assert_eq!(pv.key, running, "every completed pose reaches the scene");
assert_eq!(pv.shown_key, Some(running));
assert_ne!(pv.shown_key, Some(wanted), "the latest pose still needs a job");
}
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((4, rx));
pv.running_stream_key = Some(42);
tx.send(Ok(pose())).unwrap();
pv.poll(4, Some(42));
assert_eq!(pv.shown_key, Some(4), "release catches up to the exact final pose");
assert!(pv.running.is_none());
}
#[test]
fn intermediate_motion_rejects_other_setups_and_obsolete_errors() {
for (context, job) in [
(None, Ok(pose())),
(Some(43), Ok(pose())),
(Some(42), Err("old invalid value".into())),
(Some(42), Ok(Built { error: Some("old tool preview error".into()), ..pose() })),
] {
let mut pv = PreviewState { running_stream_key: Some(42), ..PreviewState::default() };
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((1, rx));
tx.send(job).unwrap();
pv.poll(2, context);
assert!(!pv.active);
assert!(pv.error.is_none(), "obsolete errors must not block Apply");
assert!(pv.running.is_none());
}
}
#[test]
fn motion_context_changes_only_when_the_joint_setup_changes() {
let commands = |angle| {
vec![
("joint.edit".into(), json!({"joint": 1, "flip": true})),
("joint.limits".into(), json!({"joint": 1, "min": "-135 deg", "max": "0 deg"})),
("joint.drive".into(), json!({"joint": 1, "values": [angle]})),
]
};
let key = motion_key(&commands("-30 deg"), 7, colors());
assert!(key.is_some());
assert_eq!(key, motion_key(&commands("-60 deg"), 7, colors()));
assert_ne!(key, motion_key(&commands("-60 deg"), 8, colors()));
let mut different = commands("-60 deg");
different[2].1["joint"] = json!(2);
assert_ne!(key, motion_key(&different, 7, colors()));
different = commands("-60 deg");
different[1].1["min"] = json!("-90 deg");
assert_ne!(key, motion_key(&different, 7, colors()));
different = commands("-60 deg");
different[0].1["flip"] = json!(false);
assert_ne!(key, motion_key(&different, 7, colors()));
let mut other_colors = colors();
other_colors.body = [9, 9, 9, 255];
assert_ne!(key, motion_key(&commands("-60 deg"), 7, other_colors));
assert!(motion_key(&[("solid.extrude".into(), json!({"distance": 10}))], 7, colors()).is_none());
for command in ["joint.create", "joint.drive"] {
assert_eq!(
motion_key(&[(command.into(), json!({"joint": 1, "values": [0]}))], 7, colors()),
motion_key(&[(command.into(), json!({"joint": 1, "values": [90]}))], 7, colors()),
);
}
// A gear dialog playing its driving joint streams its poses too.
let gear = |angle: &str| {
vec![
("joint.gear".to_string(), json!({"a": 1, "b": 2, "ra": 10, "rb": 20})),
("joint.drive".to_string(), json!({"joint": 1, "values": [angle]})),
]
};
assert!(motion_key(&gear("0 deg"), 7, colors()).is_some());
assert_eq!(motion_key(&gear("0 deg"), 7, colors()), motion_key(&gear("90 deg"), 7, colors()));
// So does a cam dialog turning its cam.
let cam = |angle: &str| {
vec![
("joint.cam".to_string(), json!({"a": 1, "b": 2, "profile": {"sketch": 3}})),
("joint.drive".to_string(), json!({"joint": 1, "values": [angle]})),
]
};
assert!(motion_key(&cam("0 deg"), 7, colors()).is_some());
assert_eq!(motion_key(&cam("0 deg"), 7, colors()), motion_key(&cam("90 deg"), 7, colors()));
}
#[test]
fn edited_pattern_preview_includes_moved_instances_only() -> Result<(), Box<dyn std::error::Error>> {
for (command, initial, edits) in [
(
"sketch.pattern.rectangular",
json!({"entities":["seed"],"count":3,"spacing":10,"count2":2,"spacing2":15}),
vec![(json!({"spacing":14}), 4), (json!({"spacing2":19}), 3)],
),
(
"sketch.pattern.circular",
json!({"entities":["seed"],"center":"origin","count":5}),
vec![(json!({"count":20}), 19), (json!({"count":2}), 1)],
),
] {
let mut s = Session::default();
s.execute("sketch.create", &json!({"plane":"XY"}))?;
s.execute("sketch.circle.center", &json!({"center":[-50,0],"radius":2,"id":"seed"}))?;
let pattern = s.execute(command, &initial)?;
// An identical result must not draw the seed or any existing copies.
let unchanged = compute(&s, &[(command.into(), json!({"pattern":pattern["pattern"]}))], colors())?;
assert!(unchanged.sketches.is_empty());
for (mut edit, expected) in edits {
edit["pattern"] = pattern["pattern"].clone();
let built = compute(&s, &[(command.into(), edit)], colors())?;
assert_eq!(built.sketches.len(), 1, "{command}");
for preview in &built.sketches {
assert_eq!(preview.curves.len(), expected, "{command}");
assert_eq!(preview.points.len(), expected, "{command}");
assert!(preview.curves.iter().all(|i| preview.sketch.sketch.curves.get(*i).is_some_and(|c| c.id != "seed")));
}
}
}
Ok(())
}
#[test]
fn sketch_preview_includes_changed_curve_shapes() -> Result<(), Box<dyn std::error::Error>> {
let mut s = Session::default();
s.execute("sketch.create", &json!({"plane":"XY"}))?;
s.execute("sketch.circle.center", &json!({"center":[0,0],"radius":2,"id":"circle"}))?;
s.execute("sketch.line", &json!({"points":[[10,0],[20,0]],"ids":["line"]}))?;
let before = s.model.state();
let mut after = before.as_ref().clone();
for sketch in &mut after.sketches {
let sketch = &mut std::sync::Arc::make_mut(sketch).sketch;
for curve in &mut sketch.curves {
match &mut curve.kind {
solidcraft_engine::sketch::CurveKind::Circle { r, .. } => *r = 3.0,
solidcraft_engine::sketch::CurveKind::Line { a, b } => std::mem::swap(a, b),
_ => {}
}
}
}
let built = build(&before, &after, colors());
assert_eq!(built.sketches.len(), 1);
for preview in &built.sketches {
assert_eq!(preview.curves, vec![0, 1]);
assert!(preview.points.is_empty());
}
Ok(())
}
/// Combine previews its result (cut, join or intersect between existing bodies) without an
/// error, so its dialog's OK is enabled. Before, the preview also tried the command as a new
/// body, which a combine has no form of, and always reported "operation must be join, cut or
/// intersect".
#[test]
fn combine_previews_its_result_without_an_error() {
let mut s = solidcraft_engine::Session::default();
s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "Cube"})).unwrap();
s.execute("solid.cylinder", &json!({"base": [10, 10, -5], "diameter": 6, "height": 30, "body_name": "Pin"})).unwrap();
for op in ["cut", "join", "intersect"] {
let cmd = ("solid.combine".to_string(), json!({"target": "Cube", "tools": ["Pin"], "operation": op, "keep_tools": false}));
let built = compute(&s, &[cmd], colors()).unwrap_or_else(|e| panic!("{op}: {e}"));
assert!(built.error.is_none(), "{op}: {:?}", built.error);
}
}
/// A plate in its own component, stood up by its placement (an imported part set upright)
/// and edited with that component active: the extrusion's tool is drawn where the plate is
/// shown, on its top face, not at right angles to it in the component's own frame.
#[test]
fn a_tool_on_a_turned_component_previews_where_it_is_shown() {
let mut s = Session::default();
let made = s.execute("component.create", &json!({"name": "Plate", "grounded": false})).unwrap();
s.execute("solid.box", &json!({"length": 20, "width": 8, "height": 30, "corner": [0, 0, -30], "body_name": "Plate"})).unwrap();
s.execute("occurrence.move", &json!({"occurrence": made["occurrence"], "axis": [1, 0, 0], "angle": "90 deg"})).unwrap();
s.execute("component.activate", &json!({"component": made["component"], "occurrence": made["occurrence"], "path": [made["occurrence"]]}))
.unwrap();
// Shown lying flat: 20 × 30, 8 high. Its top face pulled up 10.
let cmd = ("solid.extrude".to_string(), json!({"face": [10, 15, 8], "face_body": "Plate", "distance": "10 mm", "operation": "join"}));
let b = compute_tool(&s, &[cmd], colors()).unwrap().bounds;
assert!((b.max.z - 18.0).abs() < 1e-6 && (b.max.y - 30.0).abs() < 1e-6, "on top, not at right angles: {b:?}");
}
fn count(scene: &GpuScene, bytes: &[u8], stride: usize, col: [u8; 4]) -> usize {
bytes
.chunks(stride)
.filter(|v| {
let Some(i) = v.get(24..28).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes) else { return false };
scene.palette.get(crate::gpu::PaletteIndex(i)) == Some(col)
})
.count()
}
#[test]
fn a_hole_shows_its_cut_through_the_body() {
let mut s = solidcraft_engine::Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
let p = s.preview(&[("solid.hole".to_string(), json!({"position": [20, 15, 20], "diameter": 5, "depth": 10}))]).unwrap();
let b = build(&p.before, &p.after, colors());
// The hole's walls are drawn see-through in the cut colour (seen from any side).
assert!(count(&b.scene, &b.scene.xray, 28, colors().removed) > 0);
// A feature that only adds material shows no cut.
let p = s.preview(&[("solid.box".to_string(), json!({"length": 10, "width": 10, "height": 30, "operation": "join"}))]).unwrap();
let b = build(&p.before, &p.after, colors());
assert_eq!(count(&b.scene, &b.scene.xray, 28, colors().removed), 0);
}
/// Graphics' Show removed material in red, off: the cut and the ghost of the shape the
/// feature replaces are left out, and the body itself is still drawn.
#[test]
fn removed_material_can_be_left_fully_transparent() {
let mut s = solidcraft_engine::Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
let cmds = [("solid.hole".to_string(), json!({"position": [20, 15, 20], "diameter": 5, "depth": 10}))];
let p = s.preview(&cmds).unwrap();
let plain = colors();
let b = build(&p.before, &p.after, plain);
assert!(count(&b.scene, &b.scene.ghost, 28, plain.removed) > 0, "the replaced shape is ghosted while the tint is on");
let quiet = Colors { cut_tint: false, ..plain };
let b = build(&p.before, &p.after, quiet);
assert_eq!(count(&b.scene, &b.scene.xray, 28, quiet.removed), 0, "no see-through cut");
assert_eq!(count(&b.scene, &b.scene.ghost, 28, quiet.removed), 0, "no ghost of the old shape");
assert!(count(&b.scene, &b.scene.tris, 28, quiet.body) > 0, "the body is still drawn");
// The tool of a cut is left out too, its outline alone showing where it goes.
let cmds = [("solid.box".to_string(), json!({"length": 10, "width": 10, "height": 30, "operation": "new"}))];
let p = s.preview(&cmds).unwrap();
let shown = build_tool(&p.before, &p.after, plain, "cut");
assert!(count(&shown.scene, &shown.scene.xray, 28, plain.removed) > 0, "the tool is see-through red while the tint is on");
let b = build_tool(&p.before, &p.after, quiet, "cut");
assert_eq!(count(&b.scene, &b.scene.xray, 28, quiet.removed), 0, "no see-through tool");
assert!(!b.scene.overlay.is_empty(), "the tool's outline still shows where the cut goes");
}
fn plate() -> Session {
let mut s = Session::default();
for (id, p) in [
("sketch.create", json!({"plane": "XY"})),
("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 30]})),
("sketch.finish", json!({})),
("solid.extrude", json!({"distance": 20})),
] {
s.execute(id, &p).unwrap();
}
s
}
/// The surface test the preview used to run per face against every triangle.
fn brute_force_on_surface(m: &Mesh, p: Vec3) -> bool {
let bb = m.bounds();
let tol = (bb.diagonal() * 2e-3).max(1e-4);
m.triangles.iter().filter_map(|t| m.tri(t)).any(|[a, b, c]| point_triangle_dist(p, a, b, c) < tol)
}
/// A flat sheet of `n × n` squares, two triangles and one face each, lifted by `z`.
fn sheet(n: usize, z: f64) -> Mesh {
let mut m = Mesh::default();
for i in 0..=n {
for j in 0..=n {
m.positions.push(Vec3::new(i as f64, j as f64, z));
m.normals.push(Vec3::Z);
}
}
for i in 0..n {
for j in 0..n {
let a = (i * (n + 1) + j) as u32;
let (b, c, d) = (a + 1, a + n as u32 + 1, a + n as u32 + 2);
m.triangles.extend([[a, c, d], [a, d, b]]);
m.tri_face.extend([(i * n + j) as u32; 2]);
}
}
m
}
/// The grid answers as a scan of every triangle does, inside, beside and far from the mesh.
#[test]
fn surface_index_matches_a_scan() {
let m = sheet(12, 0.0);
let index = SurfaceIndex::new(&m).unwrap();
for k in 0..2000 {
let f = k as f64;
let p = Vec3::new((f * 0.37).rem_euclid(15.0) - 1.5, (f * 0.61).rem_euclid(15.0) - 1.5, ((f * 0.13).rem_euclid(1.0) - 0.5) * 0.05);
assert_eq!(index.contains(p), brute_force_on_surface(&m, p), "{p:?}");
}
assert!(SurfaceIndex::new(&Mesh::default()).is_none());
}
/// How long the faces of a sheet of `n × n` squares take to classify against an old sheet of
/// the same size. The meshes are built before the clock starts and the faces are collected
/// before it stops: only the classification, the work that used to freeze the app, is measured.
fn classify_sheet(n: usize) -> std::time::Duration {
let (old, same, lifted) = (sheet(n, 0.0), sheet(n, 0.0), sheet(n, 5.0));
let nf = n * n;
let started = std::time::Instant::now();
let on = new_faces(&same, nf, &old);
let off = new_faces(&lifted, nf, &old);
let took = started.elapsed();
assert!(on.iter().all(|new| !new), "faces on the old surface are not new");
assert!(off.iter().all(|new| *new), "faces off the old surface are new");
took
}
/// Whether a job four times the size took at most about twice linear: `pair` times the small job,
/// then the big one. Linear is 4x, the quadratic that the bug cost 16x or more, so eight times the
/// small time is the limit. The load of the other test binaries can rise between the two runs, so a
/// pair that misses is measured again, up to three times. Load only ever slows a run, so each size
/// keeps its fastest time and the ratio is taken of those: a retry cannot pass a regression on a
/// small run that a spike happened to slow, once an earlier small run was fast.
///
/// `slack` is the room the noise of a busy machine gets, on top of the ratio.
fn scales_linearly(mut pair: impl FnMut() -> (std::time::Duration, std::time::Duration), slack: std::time::Duration) -> Result<(), String> {
let limit = |small: f64| 8.0 * small + slack.as_secs_f64();
let (mut small, mut big) = (f64::INFINITY, f64::INFINITY);
let mut runs = Vec::new();
for _ in 0..3 {
let (s, b) = pair();
small = small.min(s.as_secs_f64());
big = big.min(b.as_secs_f64());
runs.push(format!("{s:?} then {b:?}"));
if big < limit(small) {
return Ok(());
}
}
Err(format!("{}; fastest {small:.3} s and {big:.3} s, limit {:.3} s", runs.join(", "), limit(small)))
}
#[test]
fn scales_linearly_keeps_each_sizes_fastest_run() {
let pairs = |p: Vec<(u64, u64)>| {
let mut p = p.into_iter().map(|(s, b)| (std::time::Duration::from_millis(s), std::time::Duration::from_millis(b)));
move || p.next().unwrap_or((std::time::Duration::from_secs(1), std::time::Duration::from_secs(1)))
};
let slack = std::time::Duration::from_millis(0);
// Linear: four times the work, four times the time.
assert!(scales_linearly(pairs(vec![(5, 20)]), slack).is_ok());
// A big run slowed by load, then a quiet pair.
assert!(scales_linearly(pairs(vec![(5, 80), (5, 20)]), slack).is_ok());
// A quadratic cost (16x) whose later small runs a spike slowed: the fast first one still counts.
let r = scales_linearly(pairs(vec![(5, 80), (15, 80), (15, 80)]), slack);
assert!(r.as_ref().is_err_and(|e| e.contains("fastest 0.005 s and 0.080 s, limit 0.040 s")), "{r:?}");
}
/// Thousands of faces (a modeled thread's) are classified at once, not face by face against
/// every triangle: filleting beside a thread froze the app for minutes.
///
/// A ratio and not a limit: a test must not depend on wall-clock timing (CONTRIBUTING.md), the
/// machine is busy. 900 faces are classified, then 3 600, four times as many: linear is 4x, the
/// face-against-triangle cost 16x or more.
#[test]
fn many_faces_are_classified_quickly() {
/// The room the noise of a run on a busy machine gets, on top of the ratio: the 900 faces
/// take a fraction of a second, so this is the noise of one run and not a change of scale.
const SLACK: std::time::Duration = std::time::Duration::from_millis(20);
if let Err(missed) = scales_linearly(|| (classify_sheet(30), classify_sheet(60)), SLACK) {
panic!("the faces do not scale linearly: {missed}");
}
}
/// A fillet preview stands in for the body: the round face is new, the rest is kept, and the
/// old body is the ghost. The session is unchanged.
#[test]
fn fillet_preview_scene() {
let s = plate();
let (rev, undo) = (s.revision, s.undo.len());
let b = compute(&s, &[("solid.fillet".into(), json!({"edges": [[0, 0, 10]], "radius": 3}))], colors()).unwrap();
assert_eq!(b.replaced, vec!["Body1".to_string()]);
let added = count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().added);
let kept = count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().body);
assert!(added > 0 && kept > 0, "added {added} kept {kept}");
assert!(!b.scene.ghost.is_empty());
assert_eq!(s.revision, rev);
assert_eq!(s.undo.len(), undo);
}
/// A fillet running into a boss: the boss's cylinder face keeps its surface but is meshed
/// anew (the fillet's end moves its boundary), so the ghost leaves it out. Drawn as ghost it
/// crossed the new triangulation and showed through the face in slivers.
#[test]
fn a_fillet_preview_ghosts_only_the_removed_material() {
let s = session_of(&[
("solid.box", json!({"length": 60, "width": 40, "height": 30, "center": [0, 0, 15]})),
("solid.cylinder", json!({"radius": 12, "height": 50, "base": [10, -20, 0], "operation": "join"})),
]);
let b = compute(&s, &[("solid.fillet".into(), json!({"edges": [[-16, -20, 30]], "radius": 4}))], colors()).unwrap();
assert_eq!(b.replaced, vec!["Body1".to_string()]);
// Ghost triangles on the boss's side, well away from the fillet.
let on_boss = b.scene.ghost.as_chunks::<28>().0.as_chunks::<3>().0.iter().filter(|t| {
t.iter().all(|v| {
let f = |k: usize| f32::from_le_bytes([v[4 * k], v[4 * k + 1], v[4 * k + 2], v[4 * k + 3]]) as f64;
let (x, y, z) = (f(0), f(1), f(2));
(((x - 10.0).powi(2) + (y + 20.0).powi(2)).sqrt() - 12.0).abs() < 1e-3 && z > 36.0
})
});
assert_eq!(on_boss.count(), 0, "the boss keeps its surface: no ghost on it");
assert!(!b.scene.ghost.is_empty(), "the edge the fillet removes is still shown as ghost");
}
/// Graphics' Tint new surface in a preview, off: the changed body is drawn as itself, and
/// no face of it is worked out.
#[test]
fn the_tint_on_new_surface_can_be_turned_off() {
let s = plate();
let cmds = [("solid.fillet".to_string(), json!({"edges": [[0, 0, 10]], "radius": 3}))];
let plain = Colors { tint_new: false, ..colors() };
let b = compute(&s, &cmds, plain).unwrap();
assert_eq!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, plain.added), 0, "nothing is tinted");
assert!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, plain.body) > 0, "the body is drawn as itself");
}
/// With the tint on, a round far smaller than the part is new surface too. Every facet of
/// this one lies within the preview's tolerance (half a millimetre here) of the faces it is
/// tangent to, so no point on it is off the old body and only the kernel's record of what
/// the fillet generated can tell.
#[test]
fn a_small_round_on_a_large_part_is_tinted_as_new() {
let mut s = Session::default();
for (id, p) in [
("sketch.create", json!({"plane": "XY"})),
("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [200, 150]})),
("sketch.finish", json!({})),
("solid.extrude", json!({"distance": 10})),
] {
s.execute(id, &p).unwrap();
}
// The plate's diagonal is 250 mm, so a point counts as on the old surface within half a
// millimetre: a 0.5 mm round never leaves it, bulging 0.15 mm at the most.
let tinted = Colors { tint_new: true, ..colors() };
let b = compute(&s, &[("solid.fillet".into(), json!({"edges": [[100, 0, 10]], "radius": 0.5}))], tinted).unwrap();
let added = count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, tinted.added);
assert!(added > 0, "the round is drawn as new surface, not as part of the old body");
assert!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, tinted.body) > 0, "the rest of the plate is kept");
}
/// A cut shows its tool see-through and replaces nothing.
#[test]
fn cut_preview_scene() {
let mut s = plate();
s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();
s.execute("sketch.circle.center", &json!({"center": [20, 15], "radius": 5})).unwrap();
s.execute("sketch.finish", &json!({})).unwrap();
let b = compute(&s, &[("solid.extrude".into(), json!({"distance": 20, "operation": "cut"}))], colors()).unwrap();
assert!(b.replaced.is_empty());
assert!(b.scene.tris.is_empty() && !b.scene.xray.is_empty());
assert!(b.error.is_none());
}
/// A new body is all new surface and replaces nothing; a bad value is an error.
#[test]
fn extrude_preview_scene() {
let mut s = Session::default();
s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();
s.execute("sketch.circle.center", &json!({"center": [0, 0], "radius": 5})).unwrap();
s.execute("sketch.finish", &json!({})).unwrap();
let b = compute(&s, &[("solid.extrude".into(), json!({"distance": "15 mm"}))], colors()).unwrap();
assert!(b.replaced.is_empty());
assert_eq!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().body), 0);
// #1805: a new body has its own colour, not a join's.
assert!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().new_body) > 0);
assert_eq!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().added), 0);
assert!(b.scene.ghost.is_empty());
assert!(compute(&s, &[("solid.extrude".into(), json!({"distance": "1 +"}))], colors()).is_err());
assert!(s.model.state().bodies.is_empty());
}
fn session_of(cmds: &[(&str, Value)]) -> Session {
let mut s = Session::default();
for (id, p) in cmds {
s.execute(id, p).unwrap();
}
s
}
/// A block and a two-letter text to cut into it.
fn text_on_block() -> (Session, Vec<(String, Value)>) {
let s = session_of(&[
("sketch.create", json!({"plane": "XY"})),
("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [60, 20]})),
("sketch.finish", json!({})),
("solid.extrude", json!({"distance": 10})),
("sketch.create", json!({"plane": "XY"})),
("sketch.text", json!({"text": "AB", "at": [5, 5], "height": 10})),
("sketch.finish", json!({})),
]);
(s, vec![("solid.extrude".to_string(), json!({"distance": 2, "operation": "cut"}))])
}
/// A tool feature's live preview builds its tool without the boolean: a cut into nothing
/// shows its tool with no error (OK will report it), while the whole preview has the error.
#[test]
fn a_tool_preview_builds_the_tool_without_the_boolean() {
let s = session_of(&[
("sketch.create", json!({"plane": "XY"})),
("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]})),
("sketch.finish", json!({})),
]);
let cmds = vec![("solid.extrude".to_string(), json!({"distance": 2, "operation": "cut"}))];
let tool = compute_tool(&s, &cmds, colors()).unwrap();
assert!(tool.error.is_none() && !tool.scene.xray.is_empty(), "{:?}", tool.error);
let whole = compute(&s, &cmds, colors()).unwrap();
assert!(whole.error.as_deref().is_some_and(|e| e.contains("no body to cut")), "{:?}", whole.error);
assert_eq!(whole.scene.xray.len(), tool.scene.xray.len());
}
/// #3085: a cut sketched in the root, where every body lives in a component, cuts every body
/// it meets (#1234). The preview said "there is no body to cut or intersect" all the same,
/// while the cut itself went through.
#[test]
fn a_cut_from_an_empty_root_is_not_refused_by_its_preview() {
let mut s = session_of(&[
("component.create", json!({"name": "Part"})),
("solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Block"})),
("component.activate", json!({"component": "root"})),
("sketch.create", json!({"plane": "XY"})),
("sketch.rectangle.two_point", json!({"p0": [3, 3], "p1": [7, 7]})),
("sketch.finish", json!({})),
]);
let params = json!({"distance": 20, "operation": "cut"});
let cmds = vec![("solid.extrude".to_string(), params.clone())];
assert_eq!(extrusion_target_error(&s, &cmds, &s.model.state()), None);
s.execute("solid.extrude", &params).unwrap();
let volume = s.model.state().body("Block").map(|b| solidcraft_engine::kernel::measure(&b.body).unwrap().volume).unwrap_or(0.0);
assert!((volume - (1000.0 - 160.0)).abs() < 1e-6, "{volume}");
}
/// While an arrow is dragged the inputs change faster than a tool is built: a tool built
/// for inputs since changed is shown anyway (then the latest computed), an error only for
/// the inputs it belongs to.
#[test]
fn a_tool_for_inputs_since_changed_still_shows() {
let (s, cmds) = text_on_block();
let tool = compute_tool(&s, &cmds, colors()).unwrap();
let mut pv = PreviewState::default();
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((1, rx));
pv.running_tool = true;
tx.send(Ok(tool)).unwrap();
pv.poll(2, None);
assert!(pv.running.is_none() && pv.active && pv.shown_key == Some(1), "shown, and key 2 still to compute");
let (tx, rx) = std::sync::mpsc::channel();
pv.running = Some((3, rx));
pv.running_tool = true;
tx.send(Err("too far".into())).unwrap();
pv.poll(4, None);
assert!(pv.error.is_none() && pv.shown_key == Some(1), "an old error is dropped");
}
/// A design leaving the window (another tab) takes its preview off the viewport: an empty
/// scene in the slot the viewport reads, under a new key. A fresh slot left the fillet
/// preview of the old design drawn over the new tab's empty design.
#[test]
fn reset_hands_the_viewport_an_empty_scene() {
let mut pv = PreviewState::default();
let mut sc = GpuScene::default();
let white = sc.color([255; 4]);
sc.xray_tri([0.0; 3], [0.0, 0.0, 1.0], white);
pv.set_scene(sc);
pv.active = true;
pv.replaced = vec!["Body1".into()];
let slot = pv.slot.clone();
let key = pv.key;
// The viewport took the scene.
assert!(slot.lock().unwrap().take().is_some_and(|s| !s.xray.is_empty()));
pv.reset();
assert!(std::sync::Arc::ptr_eq(&slot, &pv.slot), "the slot the viewport reads");
assert_ne!(pv.key, key, "a new key: the viewport takes the slot again");
assert!(slot.lock().unwrap().as_ref().is_some_and(|s| s.xray.is_empty() && s.blocks.is_empty()));
assert!(!pv.active && pv.replaced.is_empty());
}
}
#[cfg(test)]
#[path = "preview_drag_tests.rs"]
mod drag_tests;