* assembly(feat): ground first parts and drag free joint chains Ground the first top-level part when it is created and let face dragging reposition free occurrences or any member of a floating joint chain in one undo step. Preserve exact repeated-placement frames, joint values, modifier selection and Escape cancellation. Keep the accumulated fixture, viewport layout and documentation integration fixes from the existing PR. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(fix): update movable fixtures for first-part grounding Accept the documented grounded override in component creation, explicitly free movement fixtures, and keep linked clipboard pastes movable even in an empty document. Cover first and reused linked pastes, default insertion grounding, and single-step undo in the existing link tests. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(test): keep the motion-cost crank free Unground the first component in the document-level joint-face measurement fixture so its motion samples can rotate after first-part grounding. Preserve the rotation and shared-measurement assertions that caught the Linux CI failure. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(test): free the frame placement fixture Create the frame-member placement fixture ungrounded before moving it above its root sketch. Keep its world-space member assertions while respecting first-part grounding in the frame tests added on main. Signed-off-by: Karl Von Richter<karl@embeint.com> --------- Signed-off-by: Karl Von Richter<karl@embeint.com>
265 lines
16 KiB
Rust
265 lines
16 KiB
Rust
//! Placement-cache changes must retain physical picking, pending positions and named joints.
|
|
use crate::{Session, geom::Vec3};
|
|
use serde_json::{Value, json};
|
|
use std::sync::Arc;
|
|
|
|
fn run(session: &mut Session, command: &str, params: Value) -> Value {
|
|
session.execute(command, ¶ms).unwrap_or_else(|error| panic!("{command}: {error}"))
|
|
}
|
|
|
|
#[test]
|
|
fn world_placement_cache_preserves_pending_picks_materials_scratch_and_named_joint_frames() {
|
|
let mut session = Session::default();
|
|
let created = run(&mut session, "component.create", json!({"name":"Part"}));
|
|
let component = created["component"].as_u64().unwrap();
|
|
let first = created["occurrence"].as_u64().unwrap();
|
|
run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
|
|
run(&mut session, "material.assign", json!({"bodies":["Block"],"material":"Brass"}));
|
|
let second = run(&mut session, "occurrence.copy", json!({"occurrence":first}))["occurrence"].as_u64().unwrap();
|
|
run(&mut session, "occurrence.move", json!({"occurrence":second,"translate":[10,20,0],"axis":[0,0,1],"angle":"90 deg","capture":false}));
|
|
let pending = session.pending_moves.clone();
|
|
let path = vec![second];
|
|
let placement = session.occurrence_placement(&path).unwrap();
|
|
let name = placement.bodies[0].world.clone();
|
|
let world = session.world_state();
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
let source_state = session.model.state();
|
|
let source = source_state.body("Block").unwrap();
|
|
let placed = world.body(&name).unwrap();
|
|
assert_eq!(placed.source_name.as_deref(), Some("Block"));
|
|
assert_eq!(placed.component, component);
|
|
let bounds = placed.mesh().bounds();
|
|
assert!(bounds.min.dist(Vec3::new(7., 20., 0.)) < 1e-9);
|
|
assert!(bounds.max.dist(Vec3::new(10., 22., 4.)) < 1e-9);
|
|
assert_eq!(session.doc.model_body_look(placed), session.doc.model_body_look(source));
|
|
let source_names = crate::doc::naming::face_names(source);
|
|
assert_eq!(source_names, crate::doc::naming::face_names(placed));
|
|
let pick = Vec3::new(8.5, 21., 4.);
|
|
let top = placed.body.faces(0.001).unwrap().into_iter().find(|face| face.plane_normal.is_some_and(|n| n.z > 0.99)).unwrap().index;
|
|
run(&mut session, "select.set", json!({"items":[{"type":"face","body":name,"index":top,"point":[pick.x,pick.y,pick.z]}]}));
|
|
assert!(matches!(&session.selection[0], crate::Sel::Face { body, index, .. } if body == &name && *index == top));
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()), "selection changes must not discard prepared placements");
|
|
let scratch = session.scratch();
|
|
assert_eq!(scratch.pending_moves, pending);
|
|
let scratch_world = scratch.world_state();
|
|
assert!(Arc::ptr_eq(&world, &scratch_world));
|
|
let scratch_body = scratch_world.body(&name).unwrap();
|
|
assert!(scratch_body.mesh().bounds().min.dist(bounds.min) < 1e-9);
|
|
assert_eq!(crate::doc::naming::face_names(scratch_body), source_names);
|
|
run(&mut session, "component.capture_position", json!({}));
|
|
run(&mut session, "joint.origin", json!({"name":"Top joint","occurrence":second,"face":[pick.x,pick.y,pick.z]}));
|
|
let joint = session.doc.assembly.origins[0].origin.clone();
|
|
let local_frame = crate::doc::joints::resolve_origin(&session.doc, &session.model.state(), &joint).unwrap();
|
|
let before_joint = crate::doc::mat_mul(&crate::doc::joints::occurrence_world(&session.doc, second), &local_frame);
|
|
assert!(crate::doc::apply_point(&before_joint, Vec3::ZERO).dist(pick) < 1e-9);
|
|
run(&mut session, "occurrence.move", json!({"occurrence":second,"translate":[5,0,0],"capture":true}));
|
|
let moved = session.world_state();
|
|
assert!(!Arc::ptr_eq(&world, &moved), "a changed transform must invalidate placed meshes");
|
|
assert!(moved.body(&name).unwrap().mesh().bounds().min.dist(bounds.min + Vec3::new(5., 0., 0.)) < 1e-9);
|
|
assert!(world.body(&name).unwrap().mesh().bounds().min.dist(bounds.min) < 1e-9, "prior snapshots must remain immutable");
|
|
assert_eq!(crate::doc::naming::face_names(moved.body(&name).unwrap()), source_names);
|
|
let local_frame = crate::doc::joints::resolve_origin(&session.doc, &session.model.state(), &joint).unwrap();
|
|
let after_joint = crate::doc::mat_mul(&crate::doc::joints::occurrence_world(&session.doc, second), &local_frame);
|
|
assert!(crate::doc::apply_point(&after_joint, Vec3::ZERO).dist(pick + Vec3::new(5., 0., 0.)) < 1e-9);
|
|
let reopened = Session::new(crate::doc::Document::from_json(&session.doc.to_json()).unwrap());
|
|
assert!(reopened.world_state().body(&name).unwrap().mesh().bounds().min.dist(bounds.min + Vec3::new(5., 0., 0.)) < 1e-9);
|
|
assert_eq!(reopened.model.results.iter().filter(|r| r.error.is_some()).count(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn selection_visibility_section_and_view_revisions_reuse_world_geometry() {
|
|
let mut session = Session::default();
|
|
run(&mut session, "component.create", json!({"name":"Part"}));
|
|
run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
|
|
let world = session.world_state();
|
|
let revision = session.revision;
|
|
run(&mut session, "select.set", json!({"items":[{"type":"body","name":"Block"}]}));
|
|
assert!(session.revision > revision);
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
run(&mut session, "select.clear", json!({}));
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
run(&mut session, "browser.visibility", json!({"items":["Block"],"visible":false}));
|
|
assert!(!session.body_visible("Block"));
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
run(&mut session, "inspect.section", json!({"plane":{"origin":[0,0,2],"normal":[0,0,1]}}));
|
|
assert!(session.section.is_some());
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
session.invalidate_view(session.revision + 10);
|
|
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
|
assert!(Arc::ptr_eq(&world, &session.scratch().world_state()));
|
|
}
|
|
|
|
#[test]
|
|
fn world_cache_requires_exact_design_model_pending_and_author_context() {
|
|
let mut session = Session::default();
|
|
let created = run(&mut session, "component.create", json!({"name":"Part"}));
|
|
let component = created["component"].as_u64().unwrap();
|
|
let first = created["occurrence"].as_u64().unwrap();
|
|
run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
|
|
let sketch = run(&mut session, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();
|
|
run(&mut session, "sketch.finish", json!({}));
|
|
let second = run(&mut session, "occurrence.copy", json!({"occurrence":first}))["occurrence"].as_u64().unwrap();
|
|
let initial = session.world_state();
|
|
run(&mut session, "occurrence.move", json!({"occurrence":second,"translate":[10,20,0],"capture":false}));
|
|
let pending = session.world_state();
|
|
assert!(!Arc::ptr_eq(&initial, &pending));
|
|
let name = session.occurrence_placement(&[second]).unwrap().bodies[0].world.clone();
|
|
assert!(pending.body(&name).unwrap().mesh().bounds().min.dist(Vec3::new(10., 20., 0.)) < 1e-9);
|
|
run(&mut session, "component.activate", json!({"component":component,"occurrence":second,"path":[second]}));
|
|
let authored = session.world_state();
|
|
assert!(!Arc::ptr_eq(&pending, &authored));
|
|
assert!(authored.sketch(sketch).unwrap().plane.origin.dist(Vec3::new(10., 20., 0.)) < 1e-9);
|
|
let mut scratch = session.scratch();
|
|
assert!(Arc::ptr_eq(&authored, &scratch.world_state()));
|
|
scratch.active_occurrence_path = Some(vec![first]);
|
|
let scratch_world = scratch.world_state();
|
|
assert!(!Arc::ptr_eq(&authored, &scratch_world));
|
|
assert!(scratch_world.sketch(sketch).unwrap().plane.origin.dist(Vec3::ZERO) < 1e-9);
|
|
assert!(Arc::ptr_eq(&authored, &session.world_state()), "scratch context must not replace the source cache");
|
|
run(&mut session, "appearance.assign", json!({"bodies":["Block"],"color":"#ff0000"}));
|
|
let painted = session.world_state();
|
|
assert!(!Arc::ptr_eq(&authored, &painted));
|
|
assert_ne!(session.doc.model_body_look(painted.body("Block").unwrap()), None);
|
|
run(&mut session, "edit.undo", json!({}));
|
|
let undone = session.world_state();
|
|
assert!(!Arc::ptr_eq(&painted, &undone));
|
|
run(&mut session, "edit.redo", json!({}));
|
|
let redone = session.world_state();
|
|
assert!(!Arc::ptr_eq(&undone, &redone));
|
|
assert!(session.doc.model_body_look(redone.body("Block").unwrap()).is_some());
|
|
let before_edit = session.world_state();
|
|
run(&mut session, "solid.box", json!({"length":5,"width":6,"height":7,"body_name":"Other","operation":"new"}));
|
|
let edited = session.world_state();
|
|
assert!(!Arc::ptr_eq(&before_edit, &edited));
|
|
assert!(edited.body("Other").is_some());
|
|
session.doc = Arc::new(crate::doc::Document::from_json(&session.doc.to_json()).unwrap());
|
|
let replaced = session.world_state();
|
|
assert!(!Arc::ptr_eq(&edited, &replaced), "equal contents in a different document cannot share the cache key");
|
|
session.model = crate::doc::Model::default();
|
|
session.model.evaluate(&session.doc);
|
|
assert!(!Arc::ptr_eq(&replaced, &session.world_state()), "a new evaluated model must invalidate even when the document Arc is unchanged");
|
|
}
|
|
|
|
#[test]
|
|
fn adopted_scratch_keeps_its_warm_geometry_and_history_stages_invalidate_it() {
|
|
let mut session = Session::default();
|
|
run(&mut session, "component.create", json!({"name":"Part"}));
|
|
run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
|
|
let source = session.world_state();
|
|
let source_json = session.doc.to_json();
|
|
let mut scratch = session.scratch();
|
|
run(&mut scratch, "solid.box", json!({"length":5,"width":6,"height":7,"body_name":"Draft","operation":"new"}));
|
|
let warmed = scratch.world_state();
|
|
assert!(!Arc::ptr_eq(&source, &warmed));
|
|
assert_eq!(session.doc.to_json(), source_json);
|
|
assert!(Arc::ptr_eq(&source, &session.world_state()));
|
|
assert!(source.body("Draft").is_none());
|
|
let feature = warmed.body("Draft").unwrap().feature;
|
|
session.accept_computed(scratch);
|
|
assert!(Arc::ptr_eq(&warmed, &session.world_state()), "adoption/view revision must retain the worker's prepared geometry");
|
|
session.invalidate_view(session.revision + 20);
|
|
assert!(Arc::ptr_eq(&warmed, &session.world_state()));
|
|
run(&mut session, "timeline.rollback", json!({"position":1}));
|
|
let rolled = session.world_state();
|
|
assert!(!Arc::ptr_eq(&warmed, &rolled));
|
|
assert!(rolled.body("Block").is_some());
|
|
assert!(rolled.body("Draft").is_none());
|
|
run(&mut session, "timeline.rollback", json!({}));
|
|
let restored = session.world_state();
|
|
assert!(!Arc::ptr_eq(&rolled, &restored));
|
|
assert!(restored.body("Draft").is_some());
|
|
run(&mut session, "timeline.suppress", json!({"feature":feature,"suppressed":true}));
|
|
let suppressed = session.world_state();
|
|
assert!(!Arc::ptr_eq(&restored, &suppressed));
|
|
assert!(suppressed.body("Draft").is_none());
|
|
run(&mut session, "timeline.suppress", json!({"feature":feature,"suppressed":false}));
|
|
assert!(session.world_state().body("Draft").is_some());
|
|
}
|
|
|
|
/// A moved component's bodies keep their placed geometry and display mesh while the design
|
|
/// changes elsewhere: each new body used to transform and mesh every body of every moved
|
|
/// component again. A body that changes, or a placement that moves, is placed afresh.
|
|
#[test]
|
|
fn moved_component_bodies_are_not_placed_again_when_something_else_changes() {
|
|
let mut session = Session::default();
|
|
let created = run(&mut session, "component.create", json!({"name":"Wheel","grounded":false}));
|
|
let occurrence = created["occurrence"].as_u64().unwrap();
|
|
run(&mut session, "solid.box", json!({"length":60,"width":60,"height":5,"body_name":"Rim"}));
|
|
run(&mut session, "component.activate", json!({"component":"root"}));
|
|
run(&mut session, "occurrence.move", json!({"occurrence":occurrence,"translate":[100,0,0]}));
|
|
let placed = session.world_state();
|
|
let rim = placed.bodies.iter().find(|b| b.source_name.as_deref() == Some("Rim")).unwrap().clone();
|
|
let mesh = rim.mesh();
|
|
assert!(mesh.bounds().min.dist(Vec3::new(100., 0., 0.)) < 1e-6);
|
|
// A body added elsewhere: the rim is the same placed body, already meshed.
|
|
run(&mut session, "solid.box", json!({"length":5,"width":6,"height":7,"body_name":"Frame"}));
|
|
let after = session.world_state();
|
|
let again = after.body(&rim.name).unwrap();
|
|
assert!(Arc::ptr_eq(&mesh, &again.mesh()), "an unchanged placed body keeps its mesh");
|
|
assert!(again.body.same(&rim.body));
|
|
// The placement moves: new world coordinates, reusing the definition's triangulation.
|
|
run(&mut session, "occurrence.move", json!({"occurrence":occurrence,"translate":[0,50,0]}));
|
|
let moved = session.world_state();
|
|
let moved_rim = moved.bodies.iter().find(|b| b.source_name.as_deref() == Some("Rim")).unwrap();
|
|
assert!(!Arc::ptr_eq(&mesh, &moved_rim.mesh()));
|
|
assert!(moved_rim.mesh().bounds().min.dist(Vec3::new(100., 50., 0.)) < 1e-6);
|
|
// The body itself changes: placed again too, and the old snapshot is untouched.
|
|
run(&mut session, "body.rename", json!({"body":"Frame","name":"Frame tube"}));
|
|
let source = session.model.state().body("Rim").unwrap().clone();
|
|
let world = session.world_state();
|
|
let kept = world.bodies.iter().find(|b| b.source_name.as_deref() == Some("Rim")).unwrap();
|
|
assert!(Arc::ptr_eq(&moved_rim.mesh(), &kept.mesh()));
|
|
assert_eq!(kept.source_transform, moved_rim.source_transform);
|
|
assert!(source.mesh().bounds().min.dist(Vec3::ZERO) < 1e-6);
|
|
assert!(mesh.bounds().min.dist(Vec3::new(100., 0., 0.)) < 1e-6);
|
|
}
|
|
|
|
/// Driving an unchanged definition must map its warm reference triangles, not re-tessellate
|
|
/// the placed B-rep on the first mesh read of every new pose (viewport bounds does that read).
|
|
#[test]
|
|
fn joint_drive_reuses_reference_tessellation_across_rigid_poses() {
|
|
let mut session = Session::default();
|
|
run(&mut session, "solid.cylinder", json!({"radius":3,"height":8,"base":[4,0,0],"body_name":"Crank"}));
|
|
run(&mut session, "component.create", json!({"name":"Crank","parent":"root","activate":false,"grounded":false}));
|
|
run(&mut session, "component.move_bodies", json!({"bodies":["Crank"],"component":"Crank"}));
|
|
run(
|
|
&mut session,
|
|
"joint.as_built",
|
|
json!({"type":"revolute","name":"Crank","a":0,"b":"Crank","at":{"occurrence":0,"point":[0,0,0],"z":[0,0,1]}}),
|
|
);
|
|
let definitions = session.model.state();
|
|
let original = session.world_state();
|
|
let local = original.body("Crank").unwrap().mesh();
|
|
let bounds = local.bounds();
|
|
for angle in [37., 91., 37., 0.] {
|
|
let driven = run(&mut session, "joint.drive", json!({"joint":"Crank","value":angle}));
|
|
assert_eq!(driven["moved"], true);
|
|
assert!(Arc::ptr_eq(&definitions, &session.model.state()));
|
|
let world = session.world_state();
|
|
let body = world.body("Crank").unwrap();
|
|
let (mesh, work) = crate::kernel::profile::capture(|| body.mesh());
|
|
assert_eq!(work.tessellate_ms, 0., "a warm definition must not enter the kernel mesher at a new pose: {work:?}");
|
|
assert_eq!(mesh.positions.len(), local.positions.len());
|
|
assert_eq!(mesh.normals.len(), local.normals.len());
|
|
assert_eq!(mesh.edges.iter().map(Vec::len).collect::<Vec<_>>(), local.edges.iter().map(Vec::len).collect::<Vec<_>>());
|
|
assert_eq!(mesh.triangles, local.triangles);
|
|
assert_eq!(mesh.tri_face, local.tri_face);
|
|
assert_eq!(mesh.edge_faces, local.edge_faces);
|
|
assert_eq!(mesh.seams, local.seams);
|
|
assert_eq!(mesh.smooth_edges, local.smooth_edges);
|
|
assert_eq!(mesh.sharp_edges, local.sharp_edges);
|
|
for (p, q) in local.positions.iter().zip(&mesh.positions) {
|
|
assert!(crate::doc::apply_point(&body.source_transform, *p).dist(*q) < 1e-8);
|
|
}
|
|
for (n, q) in local.normals.iter().zip(&mesh.normals) {
|
|
assert!(crate::doc::apply_vector(&body.source_transform, *n).dist(*q) < 1e-8);
|
|
}
|
|
for (edge, placed) in local.edges.iter().zip(&mesh.edges) {
|
|
for (p, q) in edge.iter().zip(placed) {
|
|
assert!(crate::doc::apply_point(&body.source_transform, *p).dist(*q) < 1e-8);
|
|
}
|
|
}
|
|
}
|
|
assert_eq!(local.bounds(), bounds, "old snapshots stay immutable");
|
|
}
|