riggen 0.2.1.dev0__tar.gz → 0.6.0__tar.gz

{riggen-0.2.1.dev0 → riggen-0.6.0}/Cargo.lock

@@ -3223,7 +3223,7 @@ version = "0.0.1"
 
 [[package]]
 name = "riggen-app"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "console_error_panic_hook",
  "eframe",
@@ -3250,7 +3250,7 @@ dependencies = [
 
 [[package]]
 name = "riggen-core"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "riggen-mesh",
  "serde",
@@ -3259,7 +3259,7 @@ dependencies = [
 
 [[package]]
 name = "riggen-export"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "quick-xml 0.36.2",
  "riggen-core",
@@ -3271,7 +3271,7 @@ dependencies = [
 
 [[package]]
 name = "riggen-mesh"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "glam 0.30.10",
  "parry3d-f64",
@@ -3281,7 +3281,7 @@ dependencies = [
 
 [[package]]
 name = "riggen-py"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "pyo3",
  "riggen-core",
@@ -3293,7 +3293,7 @@ dependencies = [
 
 [[package]]
 name = "riggen-viewport"
-version = "0.2.1-dev"
+version = "0.6.0"
 dependencies = [
  "bytemuck",
  "egui",

{riggen-0.2.1.dev0 → riggen-0.6.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/riggen-mesh", "crates/riggen-core", "crates/riggen-export", "crates/riggen-py"]
 
 [workspace.package]
-version = "0.2.1-dev"
+version = "0.6.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 

{riggen-0.2.1.dev0 → riggen-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riggen
-Version: 0.2.1.dev0
+Version: 0.6.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
@@ -29,7 +29,7 @@ Project-URL: Repository, https://github.com/Divelix/riggen
 Drop meshes in, get a simulation-ready MJCF, URDF or SDF out — in a
 window, or from ten lines of Python.
 
-![The sample arm in riggen, opened in View: the joint tree with its scrubbers, the viewport with joint glyphs](https://raw.githubusercontent.com/Divelix/riggen/main/docs/assets/arm.png)
+![The sample arm in riggen, opened in View: the joint tree with its scrubbers, the viewport with its joint glyphs, the ground grid and the ViewCube](https://raw.githubusercontent.com/Divelix/riggen/main/docs/assets/arm.png)
 
 ## Try it in the browser
 
@@ -64,11 +64,21 @@ without a wheel, `pip install` builds the SDK from source with `cargo` on
    tree on the left, the viewport with the robot. Drag with the left
    button to orbit and with the right to pan (shift+left pans too, for a
    trackpad; the middle button orbits and shift+middle pans), zoom with the
-   wheel, `Home` to frame everything. The five buttons top-right are the
-   **visibility row**: joints, joint names, frames, links, collision
-   geometry. Switching one off takes it out of the picture *and* out of
-   the cursor's reach, so with joints off you get the robot and nothing
-   else — the status bar says what is hidden.
+   wheel, `Home` to frame everything. The **ViewCube** in the top-right
+   says which way you are looking, and the red, green and blue arms on its
+   corner are X, Y and Z: click a face, edge or corner to fly to that view,
+   drag it to orbit, click an arrow round it to turn the view 15°, click
+   the house to frame everything, and the button under it switches
+   perspective and orthographic. `W A S D E Q`
+   walk the camera *into* the assembly — the point it orbits around comes
+   with you, so a joint buried in a shell can be put in front of you and
+   then turned around locally. The arm stands on a **ground grid** at
+   z = 0, so a part at the origin reads as resting on something. The six
+   buttons left of the cube are the **visibility row**: ground, joints, joint
+   names, frames, links, collision geometry. Switching one off takes it
+   out of the picture *and* out of the cursor's reach, so with joints off
+   you get the robot and nothing else — the status bar says what is
+   hidden.
 2. Pose it: drag a joint's bar in the tree, or turn the wheel over it —
    or over the joint's glyph in the viewport, which steps it by 5° (1°
    with shift) instead of zooming. A click on a glyph selects the joint;
@@ -85,7 +95,7 @@ without a wheel, `pip install` builds the SDK from source with `cargo` on
    back.
 4. **File › Export…**, tick the formats you want (all three by default),
    choose a directory. The dialog lists anything that would stop the
-   export (a link with no mass, a joint with no axis) and writes
+   export (a moving link with no mass, a joint with no axis) and writes
    `arm.xml`, `arm.urdf` and `arm.sdf` beside `meshes/*.stl` when there is
    nothing.
 5. Load it:
@@ -122,7 +132,8 @@ mount — which Move and Rotate land on a picked feature the same way.
   `.sdf`, and the forward kinematics of both agree with riggen's (those
   are CI jobs, not hopes).
 - **Imports**: an existing URDF or MJCF — `package://` paths resolved
-  beside the file, MuJoCo's `<default>` classes and degrees understood, a
+  beside the file, and a package that is not found asks for its folder
+  (`--package NAME=DIR` on the command line), MuJoCo's `<default>` classes and degrees understood, a
   model spelled across several files opened through its main one
   (`<include>` and MuJoCo 3's `<frame>` are resolved on the way in) — to
   fix and convert it. Whatever the file held that the document cannot is
@@ -136,7 +147,7 @@ mount — which Move and Rotate land on a picked feature the same way.
 usage:
   riggen [FILE...]        open a .riggen document, or drop meshes (.stl, .obj) as links
   riggen --example arm    open the bundled sample arm
-  riggen --export mjcf|urdf|sdf|both|all --out DIR [--fk-samples] INPUT
+  riggen --export mjcf|urdf|sdf|both|all --out DIR [--fk-samples] [--package NAME=DIR]... INPUT
                           write INPUT's export to DIR without opening a window
 
 options:
@@ -144,6 +155,7 @@ options:
   --export FORMAT         headless export of INPUT (.riggen, .urdf or .xml): mjcf, urdf, sdf, both or all
   --out DIR               where --export writes; created if missing
   --fk-samples            with --export: also write <name>.fk.json, five sampled joint configurations
+  --package NAME=DIR      with --export: a .urdf's package://NAME/ meshes are under DIR; repeatable
   --timing                print the time from launch to the first frame on stderr
   -h, --help              print this help
   -V, --version           print the version and the git commit it was built from

{riggen-0.2.1.dev0 → riggen-0.6.0}/README.md

@@ -7,7 +7,7 @@
 Drop meshes in, get a simulation-ready MJCF, URDF or SDF out — in a
 window, or from ten lines of Python.
 
-![The sample arm in riggen, opened in View: the joint tree with its scrubbers, the viewport with joint glyphs](https://raw.githubusercontent.com/Divelix/riggen/main/docs/assets/arm.png)
+![The sample arm in riggen, opened in View: the joint tree with its scrubbers, the viewport with its joint glyphs, the ground grid and the ViewCube](https://raw.githubusercontent.com/Divelix/riggen/main/docs/assets/arm.png)
 
 ## Try it in the browser
 
@@ -42,11 +42,21 @@ without a wheel, `pip install` builds the SDK from source with `cargo` on
    tree on the left, the viewport with the robot. Drag with the left
    button to orbit and with the right to pan (shift+left pans too, for a
    trackpad; the middle button orbits and shift+middle pans), zoom with the
-   wheel, `Home` to frame everything. The five buttons top-right are the
-   **visibility row**: joints, joint names, frames, links, collision
-   geometry. Switching one off takes it out of the picture *and* out of
-   the cursor's reach, so with joints off you get the robot and nothing
-   else — the status bar says what is hidden.
+   wheel, `Home` to frame everything. The **ViewCube** in the top-right
+   says which way you are looking, and the red, green and blue arms on its
+   corner are X, Y and Z: click a face, edge or corner to fly to that view,
+   drag it to orbit, click an arrow round it to turn the view 15°, click
+   the house to frame everything, and the button under it switches
+   perspective and orthographic. `W A S D E Q`
+   walk the camera *into* the assembly — the point it orbits around comes
+   with you, so a joint buried in a shell can be put in front of you and
+   then turned around locally. The arm stands on a **ground grid** at
+   z = 0, so a part at the origin reads as resting on something. The six
+   buttons left of the cube are the **visibility row**: ground, joints, joint
+   names, frames, links, collision geometry. Switching one off takes it
+   out of the picture *and* out of the cursor's reach, so with joints off
+   you get the robot and nothing else — the status bar says what is
+   hidden.
 2. Pose it: drag a joint's bar in the tree, or turn the wheel over it —
    or over the joint's glyph in the viewport, which steps it by 5° (1°
    with shift) instead of zooming. A click on a glyph selects the joint;
@@ -63,7 +73,7 @@ without a wheel, `pip install` builds the SDK from source with `cargo` on
    back.
 4. **File › Export…**, tick the formats you want (all three by default),
    choose a directory. The dialog lists anything that would stop the
-   export (a link with no mass, a joint with no axis) and writes
+   export (a moving link with no mass, a joint with no axis) and writes
    `arm.xml`, `arm.urdf` and `arm.sdf` beside `meshes/*.stl` when there is
    nothing.
 5. Load it:
@@ -100,7 +110,8 @@ mount — which Move and Rotate land on a picked feature the same way.
   `.sdf`, and the forward kinematics of both agree with riggen's (those
   are CI jobs, not hopes).
 - **Imports**: an existing URDF or MJCF — `package://` paths resolved
-  beside the file, MuJoCo's `<default>` classes and degrees understood, a
+  beside the file, and a package that is not found asks for its folder
+  (`--package NAME=DIR` on the command line), MuJoCo's `<default>` classes and degrees understood, a
   model spelled across several files opened through its main one
   (`<include>` and MuJoCo 3's `<frame>` are resolved on the way in) — to
   fix and convert it. Whatever the file held that the document cannot is
@@ -114,7 +125,7 @@ mount — which Move and Rotate land on a picked feature the same way.
 usage:
   riggen [FILE...]        open a .riggen document, or drop meshes (.stl, .obj) as links
   riggen --example arm    open the bundled sample arm
-  riggen --export mjcf|urdf|sdf|both|all --out DIR [--fk-samples] INPUT
+  riggen --export mjcf|urdf|sdf|both|all --out DIR [--fk-samples] [--package NAME=DIR]... INPUT
                           write INPUT's export to DIR without opening a window
 
 options:
@@ -122,6 +133,7 @@ options:
   --export FORMAT         headless export of INPUT (.riggen, .urdf or .xml): mjcf, urdf, sdf, both or all
   --out DIR               where --export writes; created if missing
   --fk-samples            with --export: also write <name>.fk.json, five sampled joint configurations
+  --package NAME=DIR      with --export: a .urdf's package://NAME/ meshes are under DIR; repeatable
   --timing                print the time from launch to the first frame on stderr
   -h, --help              print this help
   -V, --version           print the version and the git commit it was built from

{riggen-0.2.1.dev0 → riggen-0.6.0}/crates/riggen-core/src/command.rs

@@ -47,7 +47,8 @@ pub enum Command {
     /// Moves a joint's frame **without moving anything in the world**: the
     /// new `origin` (the child link frame in the parent frame) and `axis`
     /// (in the *new* child frame, since the joint frame is the child link
-    /// frame) are written, and the child's geom poses, its own child joints'
+    /// frame) are written, and the child's visual and collision geom poses
+    /// (`Meshes` and `Primitives`), its own child joints'
     /// origins, its frames and an `Override` inertial are all re-expressed
     /// so no world pose in the zero configuration changes. Only the pivot
     /// the joint turns about moves.
@@ -156,6 +157,13 @@ pub enum Command {
     ///
     /// [`SetActuator`]: Command::SetActuator
     SetActuators(Option<ActuatorSpec>),
+    /// Gives the material to every link [`Robot::unweighed_links`] names —
+    /// geometry, no material, and an inertial that needs a density it has
+    /// not got — in one history entry (ADR-0032 §5). The one-click answer to
+    /// an import full of links nothing weighs, shaped like `SetActuators`:
+    /// many links, one command, one undo. Refused for a material the
+    /// document has not got; a no-op when no link qualifies.
+    AssignMaterialToUnweighed(String),
 }
 
 /// What a command created, for the caller that selects it afterwards.
@@ -436,6 +444,25 @@ impl Command {
                     for geom in &mut link.visuals {
                         geom.pose = delta.compose(&geom.pose);
                     }
+                    // Collision the document holds itself is in link frame
+                    // too; the derived policies follow the visuals above.
+                    match &mut link.collision {
+                        CollisionPolicy::Meshes(geoms) => {
+                            for geom in geoms {
+                                geom.pose = delta.compose(&geom.pose);
+                            }
+                        }
+                        CollisionPolicy::Primitives(prims) => {
+                            for prim in prims {
+                                let pose = prim.pose_mut();
+                                *pose = delta.compose(pose);
+                            }
+                        }
+                        CollisionPolicy::None
+                        | CollisionPolicy::SameAsVisual
+                        | CollisionPolicy::ConvexHull
+                        | CollisionPolicy::ConvexDecomposition { .. } => {}
+                    }
                     // A measured inertial is in link axes about `com`, and
                     // the link frame just moved under it (M3 has the UI).
                     if let InertialSpec::Override { com, inertia, .. } = &mut link.inertial {
@@ -651,6 +678,14 @@ impl Command {
                     );
                 }
             }
+            Command::AssignMaterialToUnweighed(material) => {
+                if !robot.materials.contains_key(&material) {
+                    return Err(EditError::UnknownMaterial(material));
+                }
+                for link in robot.unweighed_links() {
+                    link_mut(robot, link)?.material = Some(material.clone());
+                }
+            }
         }
         Ok(None)
     }
@@ -661,7 +696,7 @@ mod tests {
     use super::*;
     use crate::fk::{JointState, fk, frames};
     use crate::ids::FrameId;
-    use crate::robot::{ActuatorSpec, Frame, JointKind, Limits, Mimic, TendonJoint};
+    use crate::robot::{ActuatorSpec, Frame, JointKind, Limits, Mimic, Primitive, TendonJoint};
     use riggen_mesh::glam::{DQuat, DVec3};
     use std::collections::BTreeMap;
     use std::f64::consts::FRAC_PI_2;
@@ -758,19 +793,49 @@ mod tests {
         (robot, [arm, hand, tip, tail])
     }
 
-    /// Every geom of every link at `q = 0`, in world coordinates: what a
-    /// frame move must leave alone.
-    fn world_geoms(robot: &Robot) -> Vec<(LinkId, GeomId, Pose)> {
+    /// Which piece of a link's geometry a world pose belongs to.
+    #[derive(Debug, Clone, Copy, PartialEq)]
+    enum Slot {
+        Visual(GeomId),
+        Collision(GeomId),
+        Primitive(usize),
+    }
+
+    /// Every geom of every link at `q = 0` — visuals, collision meshes and
+    /// primitives — in world coordinates: what a frame move must leave alone.
+    fn world_geoms(robot: &Robot) -> Vec<(LinkId, Slot, Pose)> {
         let world = fk(robot, &JointState::default());
         let mut out = Vec::new();
         for (&link, l) in &robot.links {
+            let at = |pose: &Pose| world[&link].compose(pose);
             for geom in &l.visuals {
-                out.push((link, geom.id, world[&link].compose(&geom.pose)));
+                out.push((link, Slot::Visual(geom.id), at(&geom.pose)));
+            }
+            for geom in l.collision.geoms() {
+                out.push((link, Slot::Collision(geom.id), at(&geom.pose)));
+            }
+            if let CollisionPolicy::Primitives(prims) = &l.collision {
+                for (i, prim) in prims.iter().enumerate() {
+                    out.push((link, Slot::Primitive(i), at(&prim.pose())));
+                }
             }
         }
         out
     }
 
+    /// Every pose in `before` is still where it was in `robot`'s world.
+    fn assert_world_geoms_kept(robot: &Robot, before: &[(LinkId, Slot, Pose)]) {
+        let now = world_geoms(robot);
+        assert_eq!(now.len(), before.len(), "no geom appears or vanishes");
+        for (link, slot, pose) in before {
+            let (_, _, now) = now
+                .iter()
+                .find(|(l, s, _)| l == link && s == slot)
+                .expect("the geom survives");
+            assert_pose_eq(now, pose);
+        }
+    }
+
     /// The `arm()` chain with a geom on every link, so a frame move has
     /// geometry to re-express as well as child joints.
     fn arm_with_geoms() -> (Robot, [LinkId; 4]) {
@@ -831,12 +896,109 @@ mod tests {
         }
         assert_pose_eq(&after[&hand], &origin_in_world(&robot, hand));
         // Every geom, on the moved link and on its grandchildren, stays put.
-        for (link, geom, pose) in before_geoms {
-            let (_, _, now) = world_geoms(&robot)
-                .into_iter()
-                .find(|(l, g, _)| *l == link && *g == geom)
-                .expect("the geom survives");
-            assert_pose_eq(&now, &pose);
+        assert_world_geoms_kept(&robot, &before_geoms);
+    }
+
+    #[test]
+    fn moving_a_joint_frame_leaves_collision_in_the_world() {
+        let (mut robot, [arm, hand, tip, _tail]) = arm_with_geoms();
+        let mesh = robot.add_asset(asset());
+        let posed = |i: f64| {
+            Pose::from_xyz_rpy(
+                DVec3::new(0.05 * i, 0.3, -0.1 * i),
+                DVec3::new(-0.3 * i, 0.5, 0.1 * i),
+            )
+        };
+        // `hand` holds its own collision meshes, `arm` all four primitives,
+        // `tip` a policy derived from its visuals.
+        let hull: GeomId = robot.next_id.alloc();
+        let commands = [
+            Command::SetCollision(
+                hand,
+                CollisionPolicy::Meshes(vec![Geom {
+                    id: hull,
+                    mesh,
+                    pose: posed(1.0),
+                    color: None,
+                }]),
+            ),
+            Command::SetCollision(
+                arm,
+                CollisionPolicy::Primitives(vec![
+                    Primitive::Box {
+                        pose: posed(1.0),
+                        size: DVec3::new(0.1, 0.2, 0.3),
+                    },
+                    Primitive::Cylinder {
+                        pose: posed(2.0),
+                        radius: 0.04,
+                        length: 0.25,
+                    },
+                    Primitive::Sphere {
+                        pose: posed(3.0),
+                        radius: 0.07,
+                    },
+                    Primitive::Capsule {
+                        pose: posed(4.0),
+                        radius: 0.03,
+                        length: 0.15,
+                    },
+                ]),
+            ),
+            Command::SetCollision(tip, CollisionPolicy::SameAsVisual),
+        ];
+        for command in commands {
+            apply(&mut robot, command).unwrap();
+        }
+
+        let mut history = crate::History::new();
+        for link in [arm, hand, tip] {
+            let joint = robot.parent_joint(link).unwrap();
+            let before = robot.clone();
+            let before_geoms = world_geoms(&robot);
+            // A pivot that both turns and translates.
+            let origin =
+                Pose::from_xyz_rpy(DVec3::new(0.7, -0.35, 0.2), DVec3::new(-0.6, 0.4, 1.1));
+            history
+                .apply(
+                    &mut robot,
+                    Command::MoveJointFrame {
+                        joint,
+                        origin,
+                        axis: DVec3::X,
+                    },
+                )
+                .unwrap();
+
+            assert_world_geoms_kept(&robot, &before_geoms);
+            // Only the poses were rewritten: every shape is bitwise as it was.
+            match (
+                &before.links[&link].collision,
+                &robot.links[&link].collision,
+            ) {
+                (CollisionPolicy::Meshes(old), CollisionPolicy::Meshes(new)) => {
+                    assert_eq!(old.len(), new.len());
+                    for (old, new) in old.iter().zip(new) {
+                        assert!((old.pose.t - new.pose.t).length() > EPS, "re-expressed");
+                        assert_eq!((old.id, old.mesh, old.color), (new.id, new.mesh, new.color));
+                    }
+                }
+                (CollisionPolicy::Primitives(old), CollisionPolicy::Primitives(new)) => {
+                    assert_eq!(old.len(), new.len());
+                    for (old, new) in old.iter().zip(new) {
+                        assert!((old.pose().t - new.pose().t).length() > EPS, "re-expressed");
+                        let mut shape = new.clone();
+                        *shape.pose_mut() = old.pose();
+                        assert_eq!(&shape, old);
+                    }
+                }
+                (old, new) => assert_eq!(old, new, "a derived policy is stored as it was"),
+            }
+
+            // One undo is the whole move; redo it to move the next pivot on.
+            assert!(history.undo(&mut robot));
+            assert_eq!(robot, before);
+            assert!(history.redo(&mut robot));
         }
     }
 
@@ -1264,6 +1426,17 @@ mod tests {
         let moved = Pose::from_translation(DVec3::Z);
         apply(&mut robot, Command::SetGeomPose(arm, gid, moved)).unwrap();
         assert_eq!(robot.links[&arm].visuals[0].pose, moved);
+        // A NaN is refused by the edit that makes it, and changes nothing.
+        let before = robot.clone();
+        let nan = Pose::from_translation(DVec3::new(f64::NAN, 0.0, 0.0));
+        assert_eq!(
+            apply(&mut robot, Command::SetGeomPose(arm, gid, nan)),
+            Err(ValidationError::NonFinite {
+                what: format!("pose of geom {gid} of link {arm}")
+            }
+            .into())
+        );
+        assert_eq!(robot, before);
         assert_eq!(
             apply(
                 &mut robot,
@@ -1279,6 +1452,34 @@ mod tests {
         assert!(robot.links[&arm].visuals.is_empty());
     }
 
+    /// What the SDK's `set_geom_pose({"t": …, "r": [0, 0, 0, 0]})` hands
+    /// the command: finite, and no rotation. Refused, so no writer
+    /// normalises it into NaN, and the document is left as it was.
+    #[test]
+    fn a_zero_length_rotation_from_the_sdk_is_refused() {
+        let (mut robot, [arm, ..]) = arm();
+        let mesh = robot.add_asset(asset());
+        let gid: GeomId = robot.next_id.alloc();
+        let geom = Geom {
+            id: gid,
+            mesh,
+            pose: Pose::IDENTITY,
+            color: None,
+        };
+        apply(&mut robot, Command::AddGeom(arm, geom)).unwrap();
+        let pose: Pose =
+            serde_json::from_str(r#"{"t": [0.0, 0.0, 0.5], "r": [0.0, 0.0, 0.0, 0.0]}"#).unwrap();
+        let before = robot.clone();
+        assert_eq!(
+            apply(&mut robot, Command::SetGeomPose(arm, gid, pose)),
+            Err(ValidationError::DegenerateRotation {
+                what: format!("pose of geom {gid} of link {arm}")
+            }
+            .into())
+        );
+        assert_eq!(robot, before);
+    }
+
     #[test]
     fn set_joint_keeps_the_endpoints() {
         let (mut robot, [arm, _, _, tail]) = arm();
@@ -1775,6 +1976,106 @@ mod tests {
         assert!(robot.actuators.is_empty());
     }
 
+    /// `AssignMaterialToUnweighed` (ADR-0032 §5): every link with geometry,
+    /// no material and an inertial that takes its density from one gets the
+    /// material, in one history entry; a link with an `Override`, a
+    /// material, a density override or no geometry is untouched; an unknown
+    /// material is refused; and once nothing is unweighed the command
+    /// changes nothing, so it records nothing.
+    #[test]
+    fn assign_material_to_unweighed_is_one_undo_over_every_unweighed_link() {
+        use crate::history::History;
+        let (mut robot, [arm, hand, tip, tail]) = arm_with_geoms();
+        let empty = robot.root;
+        let set = |robot: &mut Robot, link: LinkId, material: Option<&str>, spec: InertialSpec| {
+            let l = robot.links.get_mut(&link).unwrap();
+            l.material = material.map(Into::into);
+            l.inertial = spec;
+        };
+        let unset = InertialSpec::Computed {
+            density_override: None,
+        };
+        set(&mut robot, arm, None, unset.clone());
+        set(&mut robot, hand, None, InertialSpec::Hybrid { mass: 0.3 });
+        set(
+            &mut robot,
+            tip,
+            None,
+            InertialSpec::Override {
+                mass: 1.0,
+                com: DVec3::ZERO,
+                inertia: riggen_mesh::glam::DMat3::IDENTITY,
+            },
+        );
+        set(&mut robot, tail, Some("PLA"), unset.clone());
+        set(&mut robot, empty, None, unset);
+        let dense = add(
+            &mut robot,
+            tail,
+            "dense",
+            fixed("dense_joint", Pose::IDENTITY),
+        );
+        let geom = robot.links[&tail].visuals[0].clone();
+        set(
+            &mut robot,
+            dense,
+            None,
+            InertialSpec::Computed {
+                density_override: Some(1000.0),
+            },
+        );
+        let id = robot.next_id.alloc();
+        robot
+            .links
+            .get_mut(&dense)
+            .unwrap()
+            .visuals
+            .push(Geom { id, ..geom });
+        assert_eq!(robot.unweighed_links(), [arm, hand]);
+        let before = robot.clone();
+
+        let mut history = History::new();
+        assert_eq!(
+            history.apply(
+                &mut robot,
+                Command::AssignMaterialToUnweighed("unobtainium".into())
+            ),
+            Err(EditError::UnknownMaterial("unobtainium".into()))
+        );
+        assert_eq!(robot, before, "a refusal changes nothing");
+
+        history
+            .apply(
+                &mut robot,
+                Command::AssignMaterialToUnweighed("aluminium".into()),
+            )
+            .unwrap();
+        let material = |robot: &Robot, l: LinkId| robot.links[&l].material.clone();
+        assert_eq!(material(&robot, arm).as_deref(), Some("aluminium"));
+        assert_eq!(material(&robot, hand).as_deref(), Some("aluminium"));
+        for l in [tip, empty, dense] {
+            assert_eq!(material(&robot, l), None, "{l}");
+        }
+        assert_eq!(material(&robot, tail).as_deref(), Some("PLA"));
+        assert!(robot.unweighed_links().is_empty());
+        assert_eq!(history.undo_depth(), 1);
+
+        history
+            .apply(
+                &mut robot,
+                Command::AssignMaterialToUnweighed("aluminium".into()),
+            )
+            .unwrap();
+        assert_eq!(
+            history.undo_depth(),
+            1,
+            "nothing qualified, nothing recorded"
+        );
+
+        assert!(history.undo(&mut robot));
+        assert_eq!(robot, before, "one undo reverts every link");
+    }
+
     /// The table's own quartet, following `AddFrame` / `SetFrame` /
     /// `RenameFrame` / `RemoveFrame` (ADR-0023): the id comes back from the
     /// command, a dangling target is refused, and an actuator carries a

{riggen-0.2.1.dev0 → riggen-0.6.0}/crates/riggen-core/src/file.rs

@@ -753,6 +753,17 @@ mod tests {
             Err(FileError::Invalid { .. })
         ));
         assert!(!target.exists());
+        // So is a NaN, rather than written as the `null` serde_json spells
+        // one — a file that would then not load.
+        let mut nan = robot.clone();
+        nan.links.get_mut(&root).unwrap().visuals[0].pose.t.x = f64::NAN;
+        assert!(matches!(
+            to_json(&nan, &target),
+            Err(FileError::Invalid {
+                source: ValidationError::NonFinite { .. },
+                ..
+            })
+        ));
         assert!(matches!(
             load(&dir.join("nope.riggen")),
             Err(FileError::Io { .. })