forgecad 0.10.0 → 0.10.1

package/examples/robotics/scout-cam-rover-simready/parts/chassis.forge.js

@@ -0,0 +1,320 @@
+// Chassis of the scout cam rover: printed tub + service door + motor pods,
+// purchased N20 gearmotors, driver/IMU/buck boards, and a rocker switch.
+// Tub-local frame: centered on XY, floor at z=0, axle along X at z=tub.axleZl.
+// Connector recipe (probed): child parts are built +Z from a `z=0, axis [0,0,-1]`
+// connector; the parent connector axis is the desired world direction of the child.
+
+const wallP = param('wall_thickness', 2.4, { min: 2.0, max: 3.0, step: 0.1, unit: 'mm' });
+const wheelODP = param('wheel_od', 110, { min: 96, max: 130, step: 1, unit: 'mm' });
+
+const dimsMod = require('../lib/dims.js');
+
+const COL_TEAL = '#2fb3b8';
+const COL_BLACK = '#1f2023';
+const COL_STEEL = '#b9bdc4';
+const COL_SCREW = '#3a3d42';
+
+function tealMat(s) { return s.color(COL_TEAL).material({ metalness: 0.05, roughness: 0.45 }); }
+
+// ---------------------------------------------------------------- tub --------
+function buildTub(D) {
+  const T = D.tub, M = D.motor, dr = D.door, P = D.pod, B = D.boards, SW = D.sw;
+  const hw = T.w / 2, hd = T.d / 2;
+  const ihw = hw - T.wall, ihd = hd - T.wall;
+  const az = T.axleZl;
+
+  let tub = roundedRect(T.w, T.d, T.cornerR).extrude(T.h);
+  tub = tub.subtract(
+    roundedRect(2 * ihw, 2 * ihd, T.cornerR - 2).extrude(T.h - T.floorT + 2).translate(0, 0, T.floorT)
+  );
+
+  // corner posts that receive the body-shell plugs (welded 0.3mm into the walls).
+  // The outward diagonal corner is chamfered flat so the web to the rounded
+  // outer wall corner stays >= 1.4mm (a square corner leaves a 0.4mm sliver).
+  const pcx = hw - T.wall - T.postInset, pcy = hd - T.wall - T.postInset;
+  const ocx = hw - T.cornerR, ocy = hd - T.cornerR; // outer corner arc centers
+  for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+    let post = box(T.postSq + 0.6, T.postSq + 0.6, T.h - T.floorT)
+      .translate(sx * pcx, sy * pcy, T.floorT);
+    const diag = Math.SQRT1_2;
+    const cut = box(20, 20, T.h + 4).rotate([0, 0, 1], 45)
+      .translate(sx * (ocx + (T.cornerR - 1.4 + 10) * diag), sy * (ocy + (T.cornerR - 1.4 + 10) * diag), T.floorT - 2);
+    post = post.subtract(cut);
+    post = post.subtract(
+      box(D.body.socketSq, D.body.socketSq, D.body.socketDepth + 1)
+        .translate(sx * pcx, sy * pcy, T.h - D.body.socketDepth)
+    );
+    tub = tub.add(post);
+  }
+  // horizontal shell-screw clearance holes through the side walls into the sockets
+  for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+    tub = tub.subtract(
+      cylinder(8, 1.0).pointAlong([sx, 0, 0]).translate(sx * (hw - 7), sy * pcy, T.sideScrewZ)
+    );
+  }
+
+  // raised border frame around the service door (reference look: inset panel in a frame)
+  const frameSk = roundedRect(dr.panelW + 12, dr.panelH + 12, 4)
+    .subtract(roundedRect(dr.panelW + 2 * dr.recessSlop + 4, dr.panelH + 2 * dr.recessSlop + 4, 3));
+  // welded 1.7 deep: the front face recedes up to 1.5mm where the frame spans
+  // the rounded wall corners, and a shallow weld leaves knife-edge slivers
+  tub = tub.add(
+    frameSk.extrude(1.4 + 1.7).rotate([1, 0, 0], 90).translate(0, -hd + 1.7, dr.zc)
+      .trimByPlane([0, 0, 1], 0.8) // keep the border inside the tub footprint
+  );
+
+  // service-door recess + opening + screw bosses (front wall, -Y)
+  tub = tub.subtract(
+    box(dr.panelW + 2 * dr.recessSlop, dr.recess + 0.05, dr.panelH + 2 * dr.recessSlop)
+      .translate(0, -hd + (dr.recess + 0.05) / 2 - 0.05, dr.zc - (dr.panelH + 2 * dr.recessSlop) / 2)
+  );
+  tub = tub.subtract(
+    box(dr.openW, T.wall + dr.recess + 1, dr.openH)
+      .translate(0, -hd + (T.wall + dr.recess) / 2, dr.zc - dr.openH / 2)
+  );
+  for (const sx of [-1, 1]) for (const sz of [-1, 1]) {
+    const bz = dr.zc + sz * dr.screwDZ;
+    tub = tub.add(
+      cylinder(dr.bossLen + 0.3, dr.bossD / 2).pointAlong([0, 1, 0])
+        .translate(sx * dr.screwDX, -ihd - 0.3, bz)
+    );
+    tub = tub.subtract(
+      cylinder(7.2, dr.pilotD / 2).pointAlong([0, 1, 0])
+        .translate(sx * dr.screwDX, -hd + dr.recess - 0.1, bz)
+    );
+  }
+
+  // motor wall slots (gearbox nose passes through, flush with outer face),
+  // plus the pod screw clearance holes — one batched subtract per side
+  for (const sx of [-1, 1]) {
+    const cuts = [
+      box(T.wall + 3, M.w + 0.6, M.h + 0.6).translate(sx * (hw - (T.wall + 3) / 2 + 1), 0, az - (M.h + 0.6) / 2),
+    ];
+    for (const pt of circularLayout(P.screwN, P.screwR, { startDeg: 90 })) {
+      cuts.push(cylinder(6, P.wallClearD / 2).pointAlong([sx, 0, 0]).translate(sx * (hw - 5), pt.x, az + pt.y));
+    }
+    tub = tub.subtract(...cuts);
+  }
+
+  // motor saddles: base + side cheeks + rear stop rib with terminal notch
+  const sadY = M.w / 2 + 0.15; // cheek inner face
+  const motorBackX = hw - M.len;
+  for (const sx of [-1, 1]) {
+    const x0 = motorBackX - 0.2, x1 = ihw + 0.4; // welded into the wall
+    const sadLen = x1 - x0;
+    tub = tub.add(box(sadLen, 2 * sadY + 4.8, az - M.h / 2 - T.floorT + 0.2)
+      .translate(sx * (x0 + sadLen / 2), 0, T.floorT - 0.2));
+    for (const sy of [-1, 1]) {
+      tub = tub.add(box(sadLen, 2.4, M.h - 3)
+        .translate(sx * (x0 + sadLen / 2), sy * (sadY + 1.2), az - M.h / 2 - 0.2));
+    }
+    let rib = box(2.4, 2 * sadY + 4.8, az + M.h / 2 + 2.8 - T.floorT)
+      .translate(sx * (motorBackX - 1.2), 0, T.floorT - 0.2);
+    rib = rib.subtract(box(3, 9, M.h - 1).translate(sx * (motorBackX - 1.2), 0, az - M.h / 2 + 0.5));
+    tub = tub.add(rib);
+  }
+
+  // board standoff posts (4 per module, corner-inset 2.5mm)
+  for (const bd of [B.drv, B.buck, B.mpu]) {
+    for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+      tub = tub.add(
+        cylinder(B.standoffH + 0.3, 2).translate(bd.x + sx * (bd.w / 2 - 2.5), bd.y + sy * (bd.d / 2 - 2.5), T.floorT - 0.3)
+      );
+    }
+  }
+
+  // rocker-switch opening (rear wall, +Y)
+  tub = tub.subtract(
+    box(SW.w + 0.4, T.wall + 1, SW.h + 0.4).translate(0, hd - (T.wall + 1) / 2 + 0.4, SW.zc - (SW.h + 0.4) / 2)
+  );
+
+  // connector map, incl. one bearing-plane connector per screw
+  const conns = {
+    deck: connector('mount', { origin: [0, 0, T.h], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' }),
+    door_frame: connector('mount', { origin: [0, -hd + dr.recess, dr.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    pod_seat_l: connector('mount', { origin: [-hw, 0, az], axis: [-1, 0, 0], up: [0, 0, 1], kind: 'fixed' }),
+    pod_seat_r: connector('mount', { origin: [hw, 0, az], axis: [1, 0, 0], up: [0, 0, 1], kind: 'fixed' }),
+    motor_seat_l: connector('mount', { origin: [-hw, 0, az], axis: [-1, 0, 0], up: [0, 0, 1], kind: 'fixed' }),
+    motor_seat_r: connector('mount', { origin: [hw, 0, az], axis: [1, 0, 0], up: [0, 0, 1], kind: 'fixed' }),
+    boards_drv: connector('mount', { origin: [0, 0, T.floorT], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' }),
+    boards_buck: connector('mount', { origin: [0, 0, T.floorT], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' }),
+    boards_mpu: connector('mount', { origin: [0, 0, T.floorT], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' }),
+    switch_seat: connector('mount', { origin: [0, hd, SW.zc], axis: [0, 1, 0], up: [0, 0, 1], kind: 'fixed' }),
+  };
+  // door screws bear on the panel face
+  let di = 0;
+  for (const sx of [-1, 1]) for (const sz of [-1, 1]) {
+    conns[`door_screw_${di++}`] = connector('mount', {
+      origin: [sx * dr.screwDX, -hd + dr.recess - dr.panelT, dr.zc + sz * dr.screwDZ],
+      axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed',
+    });
+  }
+  // pod screws bear on the inner wall face (heads inside the tub)
+  for (const side of [-1, 1]) {
+    let pi = 0;
+    for (const pt of circularLayout(P.screwN, P.screwR, { startDeg: 90 })) {
+      conns[`pod_screw_${side < 0 ? 'l' : 'r'}_${pi++}`] = connector('mount', {
+        origin: [side * ihw, pt.x, az + pt.y], axis: [-side, 0, 0], up: [0, 0, 1], kind: 'fixed',
+      });
+    }
+  }
+  // shell screws bear on the outer side walls
+  let si = 0;
+  for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+    conns[`shell_screw_${si++}`] = connector('mount', {
+      origin: [sx * hw, sy * pcy, T.sideScrewZ], axis: [sx, 0, 0], up: [0, 0, 1], kind: 'fixed',
+    });
+  }
+  return tealMat(tub).withConnectors(conns);
+}
+
+// ------------------------------------------------------------- door ----------
+function buildDoor(D) {
+  const dr = D.door;
+  let panel = roundedRect(dr.panelW, dr.panelH, 3).extrude(dr.panelT);
+  const plug = roundedRect(dr.openW - 2 * dr.slop, dr.openH - 2 * dr.slop, 2)
+    .extrude(dr.plugT).translate(0, 0, -dr.plugT);
+  let door = panel.add(plug);
+  for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+    door = door.subtract(cylinder(dr.plugT + dr.panelT + 1, 1.0)
+      .translate(sx * dr.screwDX, sy * dr.screwDZ, -dr.plugT - 0.5));
+  }
+  return tealMat(door).withConnectors({
+    back: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+  });
+}
+
+// ------------------------------------------------------------- pods ----------
+function buildPod(D) {
+  const P = D.pod;
+  let pod = cylinder(P.len, P.od / 2).subtract(cylinder(P.len + 1, P.boreD / 2).translate(0, 0, -0.5));
+  for (const pt of circularLayout(P.screwN, P.screwR, { startDeg: 90 })) {
+    pod = pod.subtract(cylinder(P.pilotDepth + 0.1, P.pilotD / 2).translate(pt.x, pt.y, -0.1));
+  }
+  // cosmetic face groove
+  pod = pod.subtract(
+    cylinder(1.0, P.od / 2 - 2).subtract(cylinder(1.4, P.od / 2 - 3.4).translate(0, 0, -0.2))
+      .translate(0, 0, P.len - 1)
+  );
+  return pod.color(COL_BLACK).material({ metalness: 0.1, roughness: 0.6 }).withConnectors({
+    flange: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+  });
+}
+
+// ------------------------------------------------------------ motor ----------
+function buildMotor(D) {
+  const M = D.motor;
+  // single Shape (not a group) so collision/clearance verifies stay exact
+  const body = box(M.w, M.h, M.len).translate(0, 0, -M.len);
+  const nose = cylinder(M.noseBossL, M.noseBossD / 2);
+  // only a stub of the D-shaft: the exposed shaft is modeled on the wheel part,
+  // where it turns with the wheel (a static D-shaft in a turning D-bore would
+  // interpenetrate at every non-zero joint angle)
+  const stub = cylinder(1.3, M.shaftD / 2);
+  const terms = box(1.2, 3, 1.9).translate(3, 0, -M.len - 1.5)
+    .add(box(1.2, 3, 1.9).translate(-3, 0, -M.len - 1.5));
+  return body.add(nose, stub, terms)
+    .color(COL_STEEL).material({ metalness: 0.85, roughness: 0.35 })
+    .withConnectors({
+      nose: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+      shaft_tip: connector('axle', { origin: [0, 0, 1.5], axis: [0, 0, 1], up: [0, 1, 0], kind: 'revolute' }),
+    });
+}
+
+// ----------------------------------------------------- electronics -----------
+function buildBoards(D) {
+  const B = D.boards;
+  const mk = (bd, colPcb, chipW, chipD) => {
+    const pcb = box(bd.w, bd.d, bd.t).translate(bd.x, bd.y, B.standoffH);
+    const chip = box(chipW, chipD, 1.2).translate(bd.x, bd.y, B.standoffH + bd.t);
+    return pcb.add(chip).color(colPcb).material({ metalness: 0.1, roughness: 0.5 })
+      .withConnectors({
+        mount: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+      });
+  };
+  // three separate purchased modules, each its own Shape (exact collision checks)
+  return {
+    drv: mk(B.drv, '#6b21a8', 6, 6),
+    buck: mk(B.buck, '#1e6fb8', 8, 7),
+    mpu: mk(B.mpu, '#1e40af', 5, 5),
+  };
+}
+
+function buildSwitch(D) {
+  const SW = D.sw;
+  // local frame: +Z = outward, mating plane (plate back on wall outer face) at z=0
+  const plateL = box(SW.plateW, SW.plateH, SW.plateT);
+  const bodyL = box(SW.w, SW.h, SW.t).translate(0, 0, -SW.t);
+  const rocker = box(8, 5, 1.6).translate(0, 0, SW.plateT);
+  let sw = plateL.add(bodyL).add(rocker);
+  return sw.color('#15161a').material({ metalness: 0.15, roughness: 0.45 }).withConnectors({
+    mount: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+  });
+}
+
+// ------------------------------------------------------------------------------
+const D = dimsMod.compute({ wall: wallP, wheelOD: wheelODP });
+
+const make = { buildTub, buildDoor, buildPod, buildMotor, buildBoards, buildSwitch };
+
+if (require.main === module) {
+  const hw = require('./hardware.forge.js');
+  const tub = buildTub(D);
+  const door = buildDoor(D).matchTo(tub, 'back', 'door_frame');
+  const screws = [];
+  for (let i = 0; i < 4; i++) screws.push({ name: `Door Screw ${i + 1}`, shape: hw.make.screwM2(8).matchTo(tub, 'seat', `door_screw_${i}`) });
+  for (const sd of ['l', 'r']) for (let i = 0; i < 3; i++) {
+    screws.push({ name: `Pod Screw ${sd.toUpperCase()} ${i + 1}`, shape: hw.make.screwM2(8).matchTo(tub, 'seat', `pod_screw_${sd}_${i}`) });
+  }
+  for (let i = 0; i < 4; i++) screws.push({ name: `Shell Screw ${i + 1}`, shape: hw.make.screwM2(8).matchTo(tub, 'seat', `shell_screw_${i}`) });
+  const podL = buildPod(D).matchTo(tub, 'flange', 'pod_seat_l');
+  const podR = buildPod(D).matchTo(tub, 'flange', 'pod_seat_r');
+  const motorL = buildMotor(D).matchTo(tub, 'nose', 'motor_seat_l');
+  const motorR = buildMotor(D).matchTo(tub, 'nose', 'motor_seat_r');
+  const mods = buildBoards(D);
+  const drv = mods.drv.matchTo(tub, 'mount', 'boards_drv');
+  const buck = mods.buck.matchTo(tub, 'mount', 'boards_buck');
+  const mpu = mods.mpu.matchTo(tub, 'mount', 'boards_mpu');
+  const rocker = buildSwitch(D).matchTo(tub, 'mount', 'switch_seat');
+
+  verify.notColliding('motor L clear of tub', motorL, tub);
+  verify.notColliding('motor R clear of tub', motorR, tub);
+  verify.notColliding('DRV8833 clear of tub', drv, tub);
+  verify.notColliding('buck clear of tub', buck, tub);
+  verify.notColliding('IMU clear of tub', mpu, tub);
+  verify.notColliding('door clear of tub', door, tub);
+  verify.notColliding('pod L clear of motor L', podL, motorL);
+  verify.notColliding('switch clear of tub', rocker, tub);
+  verify.clearanceBetween('door seats in recess', door, tub, -0.01, 0.1);
+  verify.clearanceBetween('motor L seats on saddle', motorL, tub, -0.01, 0.1);
+  verify.clearanceBetween('pod L seats on wall', podL, tub, -0.01, 0.1);
+  verify.clearanceBetween('IMU seats on standoffs', mpu, tub, -0.01, 0.1);
+
+  scene({
+    camera: { position: [180, -190, 150], target: [0, 0, 26], fov: 40 },
+    environment: { preset: 'studio', intensity: 0.25, background: false },
+    lights: [
+      { type: 'ambient', color: '#efe7dc', intensity: 0.18 },
+      { type: 'directional', position: [140, -160, 220], color: '#ffe2bf', intensity: 2.6, castShadow: true },
+      { type: 'directional', position: [-130, 110, 110], color: '#d4e6fb', intensity: 0.8 },
+    ],
+  });
+  return {
+    preview: [
+      { name: 'Tub', shape: tub },
+      { name: 'Door', shape: door },
+      ...screws,
+      { name: 'Pod L', shape: podL },
+      { name: 'Pod R', shape: podR },
+      { name: 'Motor L', shape: motorL },
+      { name: 'Motor R', shape: motorR },
+      { name: 'DRV8833', shape: drv },
+      { name: 'MP1584 Buck', shape: buck },
+      { name: 'MPU6050 IMU', shape: mpu },
+      { name: 'Switch', shape: rocker },
+    ],
+    make,
+  };
+}
+
+return { make };

package/examples/robotics/scout-cam-rover-simready/parts/hardware.forge.js

@@ -0,0 +1,21 @@
+// Shared purchased hardware builders for the scout cam rover.
+// screwM2(len): pan-head M2 self-tapping screw, modeled at thread minor diameter
+// (1.6) so clearance holes (1.9-2.0) and pilots (1.7) never interpenetrate.
+// Local frame: bearing plane (under-head) at z=0, head +Z, shank -Z.
+// Connector 'seat': recipe frame — parent connector axis = world direction of the head side.
+
+function screwM2(len) {
+  const head = cylinder(1.5, 1.9);
+  const shank = cylinder(len, 0.8).translate(0, 0, -len);
+  return head.add(shank)
+    .color('#3a3d42').material({ metalness: 0.8, roughness: 0.4 })
+    .withConnectors({
+      seat: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+    });
+}
+
+if (require.main === module) {
+  return { preview: [{ name: 'M2x8', shape: screwM2(8) }], make: { screwM2 } };
+}
+
+return { make: { screwM2 } };

package/examples/robotics/scout-cam-rover-simready/parts/turret.forge.js

@@ -0,0 +1,70 @@
+// Pan turret of the scout cam rover (printed in black PLA).
+// Rides the SG90 round horn through the neck bore: the central column reaches
+// down through the neck, its socket ceiling rests on the horn top (M2 screw up
+// through the horn into the spline retains it — purchased hardware, see BOM).
+// Turret-local frame: base underside at z=0, +Z up, spline axis = Z.
+
+const wallP = param('wall_thickness', 2.4, { min: 2.0, max: 3.0, step: 0.1, unit: 'mm' });
+const wheelODP = param('wheel_od', 110, { min: 96, max: 130, step: 1, unit: 'mm' });
+
+const dimsMod = require('../lib/dims.js');
+
+const COL_BLACK = '#1f2023';
+
+function buildTurret(D) {
+  const T = D.turret;
+
+  // base disc with 4 cosmetic lugs
+  let tr = cylinder(T.baseH, T.baseD / 2);
+  for (const pt of circularLayout(T.lugN, T.baseD / 2 + T.lugT / 2 - 0.3, { startDeg: 45 })) {
+    tr = tr.add(
+      box(T.lugW, T.lugT, T.lugH).translate(pt.x, pt.y, 0)
+        .rotate([0, 0, 1], (Math.atan2(pt.y, pt.x) * 180) / Math.PI, { pivot: [pt.x, pt.y, 0] })
+    );
+  }
+
+  // barrel + cap
+  tr = tr.add(cylinder(T.barrelH, T.barrelD / 2).translate(0, 0, T.baseH));
+  tr = tr.add(cylinder(T.capH, T.capD / 2).translate(0, 0, T.baseH + T.barrelH));
+
+  // emblem on top: two engraved rings + a small dome
+  const capTop = T.baseH + T.barrelH + T.capH;
+  const ringCut = (rOut, rIn) =>
+    cylinder(1.0, rOut).subtract(cylinder(1.4, rIn).translate(0, 0, -0.2)).translate(0, 0, capTop - 0.8);
+  tr = tr.subtract(ringCut(10, 8), ringCut(5, 3.4));
+  tr = tr.add(sphere(2.2).scale([1, 1, 0.55]).translate(0, 0, capTop - 0.4));
+
+  // central column down through the neck to the servo horn
+  const colTop = 0.5; // weld into the base disc
+  let col = cylinder(T.colLen + colTop, T.colD / 2).translate(0, 0, -T.colLen);
+  col = col.add(cylinder(T.colHubH, T.colHubD / 2).translate(0, 0, -T.colLen));
+  // horn socket: open downward, ceiling rests on the horn top face
+  col = col.subtract(cylinder(T.socketDepth + 0.1, T.socketD / 2).translate(0, 0, -T.colLen - 0.1));
+  // clearance bore above the socket for the M2 retention screw head
+  col = col.subtract(cylinder(6, 2.6).translate(0, 0, -T.colLen + T.socketDepth - 0.1));
+  tr = tr.add(col);
+
+  return tr.color(COL_BLACK).material({ metalness: 0.15, roughness: 0.5, clearcoat: 0.3 })
+    .withConnectors({
+      hub: connector('axle', {
+        origin: [0, 0, -T.colLen + T.socketDepth], axis: [0, 0, -1], up: [0, 1, 0], kind: 'revolute',
+      }),
+    });
+}
+
+const D = dimsMod.compute({ wall: wallP, wheelOD: wheelODP });
+
+if (require.main === module) {
+  scene({
+    camera: { position: [90, -100, 80], target: [0, 0, 8], fov: 40 },
+    environment: { preset: 'studio', intensity: 0.3, background: false },
+    lights: [
+      { type: 'ambient', color: '#efe7dc', intensity: 0.25 },
+      { type: 'directional', position: [80, -90, 130], color: '#ffe2bf', intensity: 2.4, castShadow: true },
+      { type: 'directional', position: [-70, 60, 60], color: '#d4e6fb', intensity: 0.9 },
+    ],
+  });
+  return { preview: [{ name: 'Turret', shape: buildTurret(D) }], make: { buildTurret } };
+}
+
+return { make: { buildTurret } };

package/examples/robotics/scout-cam-rover-simready/parts/wheel.forge.js

@@ -0,0 +1,116 @@
+// Wheel for the scout cam rover: printed rim (PLA) + printed tire (TPU).
+// Wheel-local frame: z=0 is the hub bore mouth (faces the robot), +Z points outboard.
+// The hub boss runs inside the motor-pod bore and grips the N20 D-shaft (press fit).
+
+const wallP = param('wall_thickness', 2.4, { min: 2.0, max: 3.0, step: 0.1, unit: 'mm' });
+const wheelODP = param('wheel_od', 110, { min: 96, max: 130, step: 1, unit: 'mm' });
+
+const dimsMod = require('../lib/dims.js');
+
+const COL_TEAL = '#2fb3b8';
+const COL_TIRE = '#cfc8bc';
+
+function buildRim(D) {
+  const hub = D.hub, web = D.web;
+  const rimOR = D.rimOD / 2, rimIR = D.rimID / 2;
+
+  // hub boss with D-bore for the N20 shaft
+  let boss = cylinder(hub.bossL, hub.bossD / 2);
+  const flatY = hub.boreFlat - hub.boreD / 2; // flat plane offset from center
+  const dProfile = circle2d(hub.boreD / 2)
+    .intersect(rect(hub.boreD + 0.4, hub.boreFlat).translate(0, (hub.boreFlat / 2) - hub.boreD / 2));
+  const dBore = dProfile.extrude(hub.boreDepth + 0.1).translate(0, 0, -0.1);
+  boss = boss.subtract(dBore);
+  verify.greaterThan('D-bore flat offset is positive', flatY + hub.boreD / 2, 0);
+
+  // spoke web: hub disc + crosshair spokes + mid ring, welded 1mm into the rim band
+  const webReach = rimIR + 1;
+  const webSk = circle2d(11)
+    .add(rect(webReach * 2, 8))
+    .add(rect(8, webReach * 2))
+    .add(circle2d(28).subtract(circle2d(24)));
+  let webSolid = webSk.extrude(web.t).translate(0, 0, web.z0);
+
+  // rim band
+  const rimBand = cylinder(D.rimW, rimOR).subtract(cylinder(D.rimW + 2, rimIR).translate(0, 0, -1))
+    .translate(0, 0, D.rim.z0);
+
+  let rimPart = union(boss, webSolid, rimBand);
+
+  // cosmetic hub-face dimples (visible on the outboard web face)
+  for (const pt of circularLayout(hub.faceHoleN, hub.faceHoleR, { startDeg: 90 })) {
+    rimPart = rimPart.subtract(
+      cylinder(1.6, hub.faceHoleD / 2).translate(pt.x, pt.y, web.z0 + web.t - 1.5)
+    );
+  }
+  return rimPart.color(COL_TEAL).material({ metalness: 0.05, roughness: 0.45 });
+}
+
+function buildTire(D) {
+  const rimOR = D.rimOD / 2, tireOR = D.tireOD / 2;
+  let prof = rect(tireOR - rimOR, D.tireW).translate(rimOR + (tireOR - rimOR) / 2, D.tireW / 2);
+  prof = prof.filletCorner([tireOR, 0], 2.5).filletCorner([tireOR, D.tireW], 2.5);
+  return prof.revolve()
+    .translate(0, 0, D.rim.z0)
+    .color(COL_TIRE).material({ metalness: 0.0, roughness: 0.85 });
+}
+
+function buildShaft(D) {
+  // The N20 D-shaft rides in the wheel's D-bore and turns WITH the wheel, so it
+  // is modeled as a child of the wheel part (the motor keeps a short stub).
+  const M = D.motor;
+  const prof = circle2d(M.shaftD / 2)
+    .intersect(rect(M.shaftD + 0.4, M.shaftFlat).translate(0, M.shaftFlat / 2 - M.shaftD / 2));
+  return prof.extrude(8.5).translate(0, 0, -0.1)
+    .color('#d8dbe0').material({ metalness: 0.9, roughness: 0.25 });
+}
+
+// Returns the wheel as three separate single-body parts that share the same
+// local frame: the rim carries the joint bore plus identity seats for the tire
+// (stretch fit on the rim band) and the N20 D-shaft (turns with the wheel).
+function buildWheel(D) {
+  const idSeat = () => connector('mount', { origin: [0, 0, 0], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' });
+  const idChild = () => connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' });
+  const rimPart = buildRim(D).withConnectors({
+    bore: connector('axle', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'revolute' }),
+    tire_seat: idSeat(),
+    shaft_seat: idSeat(),
+  });
+  const tirePart = buildTire(D).withConnectors({
+    seat: idChild(),
+    tread: connector('contact', {
+      origin: [0, -D.tireOD / 2, D.rim.z0 + D.tireW / 2],
+      axis: [0, -1, 0],
+      up: [0, 0, 1],
+    }),
+  });
+  const shaftPart = buildShaft(D).withConnectors({ seat: idChild() });
+  verify.clearanceBetween('tire seats on rim band', tirePart, rimPart, -0.01, 0.05);
+  verify.clearanceBetween('D-shaft rides in the D-bore', shaftPart, rimPart, 0.02, 0.15);
+  return { rim: rimPart, tire: tirePart, shaft: shaftPart };
+}
+
+const D = dimsMod.compute({ wall: wallP, wheelOD: wheelODP });
+
+if (require.main === module) {
+  scene({
+    camera: { position: [160, -150, 120], target: [0, 0, 17], fov: 40 },
+    environment: { preset: 'studio', intensity: 0.25, background: false },
+    lights: [
+      { type: 'ambient', color: '#efe7dc', intensity: 0.18 },
+      { type: 'directional', position: [140, -160, 220], color: '#ffe2bf', intensity: 2.6, castShadow: true },
+      { type: 'directional', position: [-130, 110, 110], color: '#d4e6fb', intensity: 0.8 },
+    ],
+  });
+  const wp = buildWheel(D);
+  return {
+    preview: [
+      { name: 'Rim', shape: wp.rim },
+      { name: 'Tire', shape: wp.tire },
+      { name: 'Drive Shaft', shape: wp.shaft },
+    ],
+    make: { buildWheel },
+  };
+}
+
+return { make: { buildWheel } };

package/examples/robotics/simready-asset-crate.forge.js

@@ -0,0 +1,79 @@
+const pine = Sim.material("pine crate", {
+  densityKgM3: 520,
+  staticFriction: 0.55,
+  dynamicFriction: 0.42,
+  restitution: 0.08,
+});
+
+const woodMaterial = { roughness: 0.78, metalness: 0.02 };
+const darkEndgrain = { roughness: 0.86, metalness: 0.01 };
+
+const rim = group(
+  { name: "Front Top Rail", shape: box(132, 8, 8).translate(0, -50, 37).color("#6f4a25").material(darkEndgrain) },
+  { name: "Back Top Rail", shape: box(132, 8, 8).translate(0, 50, 37).color("#6f4a25").material(darkEndgrain) },
+  { name: "Left Top Rail", shape: box(8, 92, 8).translate(-66, 0, 37).color("#6f4a25").material(darkEndgrain) },
+  { name: "Right Top Rail", shape: box(8, 92, 8).translate(66, 0, 37).color("#6f4a25").material(darkEndgrain) },
+);
+
+const cornerPosts = group(
+  { name: "Front Left Post", shape: box(10, 10, 78).translate(-64, -48, 0).color("#714d27").material(darkEndgrain) },
+  { name: "Front Right Post", shape: box(10, 10, 78).translate(64, -48, 0).color("#714d27").material(darkEndgrain) },
+  { name: "Back Left Post", shape: box(10, 10, 78).translate(-64, 48, 0).color("#714d27").material(darkEndgrain) },
+  { name: "Back Right Post", shape: box(10, 10, 78).translate(64, 48, 0).color("#714d27").material(darkEndgrain) },
+);
+
+const sideSlats = group(
+  { name: "Front Upper Slat", shape: box(118, 7, 12).translate(0, -52, 18).color("#81582c").material(woodMaterial) },
+  { name: "Front Lower Slat", shape: box(118, 7, 12).translate(0, -52, -12).color("#9a6a38").material(woodMaterial) },
+  { name: "Back Upper Slat", shape: box(118, 7, 12).translate(0, 52, 18).color("#81582c").material(woodMaterial) },
+  { name: "Back Lower Slat", shape: box(118, 7, 12).translate(0, 52, -12).color("#9a6a38").material(woodMaterial) },
+  { name: "Left Upper Slat", shape: box(7, 78, 12).translate(-70, 0, 18).color("#81582c").material(woodMaterial) },
+  { name: "Left Lower Slat", shape: box(7, 78, 12).translate(-70, 0, -12).color("#9a6a38").material(woodMaterial) },
+  { name: "Right Upper Slat", shape: box(7, 78, 12).translate(70, 0, 18).color("#81582c").material(woodMaterial) },
+  { name: "Right Lower Slat", shape: box(7, 78, 12).translate(70, 0, -12).color("#9a6a38").material(woodMaterial) },
+);
+
+const floorPlanks = group(
+  { name: "Floor Left", shape: box(36, 86, 8).translate(-40, 0, -36).color("#a8733d").material(woodMaterial) },
+  { name: "Floor Center", shape: box(36, 86, 8).translate(0, 0, -36).color("#b47b42").material(woodMaterial) },
+  { name: "Floor Right", shape: box(36, 86, 8).translate(40, 0, -36).color("#a8733d").material(woodMaterial) },
+);
+
+const forkliftSkids = group(
+  { name: "Left Fork Pocket", shape: box(112, 10, 8).translate(0, -28, -50).color("#6f4a25").material(darkEndgrain) },
+  { name: "Right Fork Pocket", shape: box(112, 10, 8).translate(0, 28, -50).color("#6f4a25").material(darkEndgrain) },
+  { name: "Left Spacer", shape: box(14, 10, 18).translate(-46, -28, -42).color("#714d27").material(darkEndgrain) },
+  { name: "Right Spacer", shape: box(14, 10, 18).translate(46, 28, -42).color("#714d27").material(darkEndgrain) },
+);
+
+const handles = group(
+  { name: "Front Handhold", shape: box(48, 5, 14).translate(0, -56, 3).color("#3f2a18").material({ roughness: 0.9 }) },
+  { name: "Back Handhold", shape: box(48, 5, 14).translate(0, 56, 3).color("#3f2a18").material({ roughness: 0.9 }) },
+);
+
+const crate = group(
+  { name: "Rim", group: rim },
+  { name: "Posts", group: cornerPosts },
+  { name: "Side Slats", group: sideSlats },
+  { name: "Floor Planks", group: floorPlanks },
+  { name: "Forklift Skids", group: forkliftSkids },
+  { name: "Handles", group: handles },
+).withConnectors({
+  grip: connector({ origin: [0, -56, 3], axis: [0, -1, 0], up: [0, 0, 1] }),
+  floor_contact: connector({ origin: [0, 0, -54], axis: [0, 0, -1], up: [1, 0, 0] }),
+});
+
+return assembly("SimReady Asset Crate")
+  .addPart("Body", crate, {
+    sim: Sim.body({
+      massKg: 2.4,
+      material: pine,
+      collider: Sim.collider.convexHull(),
+      contacts: {
+        grip: Sim.contact.gripperSurface("grip"),
+      },
+    }),
+  })
+  .withSimulation({
+    profile: Sim.profile.roboticsAssetPhysx(),
+  });