forgecad 0.10.0 → 0.10.2

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

@@ -0,0 +1,304 @@
+// Upper body of the scout cam rover: printed shell (rounded cube + neck + vents
+// + camera recess + corner plugs + servo bridge), camera bezel + black lens cowl,
+// ESP32-CAM module, SG90 pan servo, and the 2x18650 battery holder.
+// Shell-local frame: centered on XY, base z=0 (sits on the tub deck), front = -Y.
+
+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_SCREW = '#3a3d42';
+
+function tealMat(s) { return s.color(COL_TEAL).material({ metalness: 0.05, roughness: 0.45 }); }
+
+// ----------------------------------------------------------------- shell -----
+function buildShell(D) {
+  const B = D.body, N = D.neck, C = D.cam, V = D.vent, S = D.servo, BR = D.bridge;
+  const hw = B.w / 2, hd = B.d / 2;
+  const w = D.wall;
+
+  let sh = roundedRect(B.w, B.d, B.cornerR).extrude(B.h).shell(w, { openFaces: ['bottom'] });
+
+  // ---- neck + ring on top (one printed piece with the shell)
+  let neckSolid = cylinder(N.h + 0.3, N.od / 2).translate(0, 0, B.h - 0.3)
+    .add(cylinder(N.ringH, N.ringOD / 2).translate(0, 0, B.h + N.h - N.ringH));
+  neckSolid = neckSolid.subtract(cylinder(N.h + 1, N.boreD / 2).translate(0, 0, B.h - 0.1));
+  sh = sh.add(neckSolid);
+  // top-wall opening under the neck: bore minus a bridge bar (servo hangs from it)
+  const topHole = circle2d(N.boreD / 2 - 2).subtract(rect(N.boreD + 2, BR.w))
+    .add(circle2d(BR.holeD / 2)); // central pass-through for the servo tower/spline
+  sh = sh.subtract(topHole.extrude(w + 2).translate(0, 0, B.h - w - 1));
+
+  // ---- camera recess, through-hole, bezel pilots (front face, -Y) — one batched cut
+  const fw = -hd; // front outer face
+  const camCuts = [
+    cylinder(C.recessDepth + 0.1, C.recessD / 2).pointAlong([0, -1, 0]).translate(0, fw + C.recessDepth, C.zc),
+    cylinder(w + 2, C.holeD / 2).pointAlong([0, -1, 0]).translate(0, fw + w + 1, C.zc),
+  ];
+  for (const pt of circularLayout(C.screwN, C.screwR, { startDeg: C.screwStartDeg })) {
+    camCuts.push(cylinder(6.2, C.pilotD / 2).pointAlong([0, 1, 0])
+      .translate(pt.x, fw + C.recessDepth - 0.1, C.zc + pt.y));
+  }
+  sh = sh.subtract(...camCuts);
+
+  // ---- ESP32-CAM slide rails on the inner front wall
+  const innerF = fw + w; // inner front wall face
+  const pcbFrontY = innerF + 2.7; // PCB front face plane (barrel tip flush with cowl face)
+  for (const sx of [-1, 1]) {
+    let rail = box(3.4, 6.4, 38).translate(sx * 15.3, innerF + 6.4 / 2 - 0.3, 24);
+    rail = rail.subtract(
+      box(2.2, 2.0, 40).translate(sx * (13.4 + 1.1), pcbFrontY + 1.0, 28)
+    );
+    sh = sh.add(rail);
+  }
+
+  // ---- side vent bands: skewed recessed panel + 5 through slots (both faces)
+  const slope = V.skewDZ / V.bandW;
+  const bandPts = [
+    [V.yc - V.bandW / 2, V.zc - V.bandH / 2],
+    [V.yc + V.bandW / 2, V.zc - V.bandH / 2 + V.skewDZ],
+    [V.yc + V.bandW / 2, V.zc + V.bandH / 2],
+    [V.yc - V.bandW / 2, V.zc + V.bandH / 2 - V.skewDZ],
+  ];
+  // rotate([1,1,1],120) maps sketch X -> world Y, sketch Y -> world Z, extrusion -> world X
+  const recessCut = polygon(bandPts).extrude(V.recessDepth + 0.4)
+    .rotate([1, 1, 1], 120).translate(hw - V.recessDepth, 0, 0);
+  let slotSk = null;
+  for (let i = 0; i < V.n; i++) {
+    const yi = V.yc + (i - (V.n - 1) / 2) * V.pitch;
+    const zi = V.zc + (yi - V.yc) * slope;
+    const one = slot(V.slotL, V.slotW).rotate(90).translate(yi, zi);
+    slotSk = slotSk ? slotSk.add(one) : one;
+  }
+  const slotCut = slotSk.extrude(w + 3).rotate([1, 1, 1], 120).translate(hw - w - 1.5, 0, 0);
+  sh = sh.subtract(recessCut, slotCut,
+    recessCut.mirrorThrough([0, 0, 0], [1, 0, 0]), slotCut.mirrorThrough([0, 0, 0], [1, 0, 0]));
+
+  // ---- corner plugs (drop into the tub posts) + bridge ribs to the side walls
+  // tub posts are at tub-centered (±26.6, ±27.6); shell is offset yOff toward the front
+  const T = D.tub;
+  const pcx = T.w / 2 - T.wall - T.postInset, pcy = T.d / 2 - T.wall - T.postInset;
+  for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+    const px = sx * pcx, py = sy * pcy - B.yOff;
+    let plug = box(B.plugSq, B.plugSq, B.plugL + 6).translate(px, py, -B.plugL);
+    // pilot for the horizontal shell screw (world z = tub.sideScrewZ)
+    const pz = T.sideScrewZ - T.h; // shell-local
+    plug = plug.subtract(cylinder(5.7, 0.85).pointAlong([-sx, 0, 0])
+      .translate(sx * (B.plugSq / 2 + pcx + 0.1), py, pz));
+    const ribLen = (B.w / 2 - w + 0.4) - (pcx + B.plugSq / 2);
+    const rib = box(ribLen, B.plugSq, 6)
+      .translate(sx * (pcx + B.plugSq / 2 + ribLen / 2), py, 0);
+    sh = sh.add(plug, rib);
+  }
+
+  // ---- servo bosses hanging from the bridge bar
+  for (const hx of [S.bodyXc + S.tabHoleXa, S.bodyXc + S.tabHoleXb]) {
+    let boss = box(4, S.bossSq, B.h - w + 0.4 - S.tabPlaneZ)
+      .translate(hx, 0, S.tabPlaneZ);
+    boss = boss.subtract(cylinder(5.2, 0.85).translate(hx, 0, S.tabPlaneZ - 0.1));
+    sh = sh.add(boss);
+  }
+
+  // ---- battery-holder standoff bosses + pilots (rear inner wall is curved at
+  // the holder's corners, so the holder mounts 2.4mm off the wall on two bosses)
+  const bi = hd - w; // rear inner face at the wall centerline
+  const battBack = bi - 2.4;
+  for (const sx of [-1, 1]) {
+    sh = sh.add(cylinder(2.7, 3).pointAlong([0, -1, 0])
+      .translate(sx * D.batt.mountHoleSpan / 2, bi + 0.3, D.batt.zc));
+  }
+  sh = sh.subtract(
+    cylinder(4.5, 0.85).pointAlong([0, 1, 0]).translate(-D.batt.mountHoleSpan / 2, battBack - 0.1, D.batt.zc),
+    cylinder(4.5, 0.85).pointAlong([0, 1, 0]).translate(D.batt.mountHoleSpan / 2, battBack - 0.1, D.batt.zc),
+  );
+
+  const conns = {
+    base: connector('mount', { origin: [0, -B.yOff, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+    cam_recess: connector('mount', { origin: [0, fw + C.recessDepth, C.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    cam_cowl: connector('mount', { origin: [0, fw + C.recessDepth, C.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    esp_cradle: connector('mount', { origin: [0, pcbFrontY, C.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    esp_optics: connector('mount', { origin: [0, pcbFrontY, C.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    servo_mount: connector('mount', { origin: [0, 0, S.tabPlaneZ], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+    servo_horn_mount: connector('mount', { origin: [0, 0, S.tabPlaneZ], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+    batt_mount: connector('mount', { origin: [0, battBack, D.batt.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    cell_a: connector('mount', { origin: [0, battBack, D.batt.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+    cell_b: connector('mount', { origin: [0, battBack, D.batt.zc], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed' }),
+  };
+  // bezel screws bear on the bezel front face (proud of the recess)
+  const bezelFaceY = fw + C.recessDepth - C.bezelT;
+  let bi2 = 0;
+  for (const pt of circularLayout(C.screwN, C.screwR, { startDeg: C.screwStartDeg })) {
+    conns[`bezel_screw_${bi2++}`] = connector('mount', {
+      origin: [pt.x, bezelFaceY, C.zc + pt.y], axis: [0, -1, 0], up: [0, 0, 1], kind: 'fixed',
+    });
+  }
+  return tealMat(sh).withConnectors(conns);
+}
+
+// ----------------------------------------------------------------- bezel -----
+function buildBezel(D) {
+  const C = D.cam;
+  let bz = cylinder(C.bezelT, C.bezelOD / 2).subtract(cylinder(C.bezelT + 1, C.bezelID / 2).translate(0, 0, -0.5));
+  for (const pt of circularLayout(C.screwN, C.screwR, { startDeg: C.screwStartDeg })) {
+    bz = bz.subtract(cylinder(C.bezelT + 1, 1.0).translate(pt.x, pt.y, -0.5));
+  }
+  return tealMat(bz).withConnectors({
+    back: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+  });
+}
+
+function buildCowl(D) {
+  const C = D.cam;
+  let cw = cylinder(C.cowlT, C.cowlD / 2, C.cowlD / 2 - 1.4);
+  cw = cw.subtract(cylinder(C.cowlT + 1, C.apertureD / 2).translate(0, 0, -0.5));
+  return cw.color(COL_BLACK).material({ metalness: 0.1, roughness: 0.35, clearcoat: 0.5 })
+    .withConnectors({
+      back: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+    });
+}
+
+// -------------------------------------------------------------- ESP32-CAM ----
+function buildEsp(D) {
+  const E = D.esp;
+  // local: z=0 at the PCB front face, lens barrel +Z. union() keeps only the
+  // first operand's color, so board and optics are separate shapes in a group.
+  const pcb = box(E.pcbW, E.pcbH, E.pcbT).translate(0, 0, -E.pcbT);
+  const shield = box(18, 17, E.compT).translate(0, -8, -E.pcbT - E.compT);
+  const camChip = box(9, 9, 1.4).translate(0, 0, -E.pcbT - 1.4);
+  const board = pcb.add(shield, camChip).color('#1a7a3a').material({ metalness: 0.3, roughness: 0.5 });
+  const barrel = cylinder(E.barrelL, E.barrelD / 2);
+  const lens = cylinder(1.3, 2.6).translate(0, 0, E.barrelL - 0.3); // welded into the barrel
+  const optics = barrel.add(lens).color(COL_BLACK)
+    .material({ metalness: 0.2, roughness: 0.35 });
+  const faceConn = () => connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' });
+  return {
+    board: board.withConnectors({ face: faceConn() }),
+    optics: optics.withConnectors({ face: faceConn() }),
+  };
+}
+
+// ------------------------------------------------------------------ servo ----
+function buildServo(D) {
+  const S = D.servo;
+  // local: z=0 tab top plane, spline axis at x=0, body hangs -Z
+  const body = box(S.bodyW, S.bodyD, S.bodyDown + S.bodyUp)
+    .translate(S.bodyXc, 0, -S.bodyDown);
+  const tabs = box(S.tabSpan, S.bodyD, S.tabT).translate(S.bodyXc, 0, -S.tabT);
+  const tower = cylinder(S.towerH, S.towerD / 2).translate(0, 0, S.bodyUp);
+  const spline = cylinder(S.splineH, S.splineD / 2).translate(0, 0, S.bodyUp + S.towerH);
+  const hornHub = cylinder(4.6, S.hornHubD / 2).translate(0, 0, S.bodyUp + S.towerH + S.splineH - 2.4);
+  const hornDisc = cylinder(S.hornT, S.hornD / 2).translate(0, 0, S.bodyUp + S.towerH + S.splineH + 2.2 - S.hornT);
+  // two M2 screws up through the tab holes into the boss pilots
+  let screws = null;
+  for (const hx of [S.bodyXc + S.tabHoleXa, S.bodyXc + S.tabHoleXb]) {
+    const sc = cylinder(1.5, 1.9).translate(hx, 0, -S.tabT - 1.5)
+      .add(cylinder(6.5, 0.8).translate(hx, 0, -S.tabT));
+    screws = screws ? screws.add(sc) : sc;
+  }
+  const blue = body.add(tabs, screws.color(COL_SCREW)).color('#2563b0')
+    .material({ metalness: 0.15, roughness: 0.55 });
+  const white = tower.add(spline, hornHub, hornDisc).color('#e8e6df')
+    .material({ metalness: 0.05, roughness: 0.5 });
+  const hornTopZ = S.bodyUp + S.towerH + S.splineH + 2.2;
+  const tabsConn = () => connector('mount', { origin: [0, 0, 0], axis: [0, 0, 1], up: [0, 1, 0], kind: 'fixed' });
+  return {
+    body: blue.withConnectors({ tabs: tabsConn() }),
+    horn: white.withConnectors({
+      tabs: tabsConn(),
+      spline: connector('axle', { origin: [0, 0, hornTopZ], axis: [0, 0, 1], up: [0, 1, 0], kind: 'revolute' }),
+    }),
+  };
+}
+
+// ---------------------------------------------------------------- battery ----
+function buildBatteryHolder(D) {
+  const BT = D.batt;
+  // local: z=0 back face (on the standoff bosses), +Z toward the interior
+  let holder = box(BT.w, BT.h, BT.d);
+  holder = holder.subtract(box(65, BT.h - 3.2, BT.d).translate(0, 0, 1.6));
+  return holder.color('#23262b').material({ metalness: 0.1, roughness: 0.6 }).withConnectors({
+    back: connector('mount', { origin: [0, 0, 0], axis: [0, 0, -1], up: [0, 1, 0], kind: 'fixed' }),
+  });
+}
+
+function buildCell(D, sy) {
+  return cylinder(65, 9.2).pointAlong([1, 0, 0]).translate(-32.5, sy * 9.4, 1.6 + 9.2)
+    .color('#2e6647').material({ metalness: 0.5, roughness: 0.35 }).withConnectors({
+      back: 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 = {
+  buildShell, buildBezel, buildCowl, buildEsp,
+  buildServo, buildBatteryHolder, buildCell,
+};
+
+if (require.main === module) {
+  const sh = buildShell(D);
+  const bezel = buildBezel(D).matchTo(sh, 'back', 'cam_recess');
+  const cowl = buildCowl(D).matchTo(sh, 'back', 'cam_cowl');
+  const hw = require('./hardware.forge.js');
+  const bezelScrews = [];
+  for (let i = 0; i < 4; i++) {
+    bezelScrews.push({ name: `Bezel Screw ${i + 1}`, shape: hw.make.screwM2(6).matchTo(sh, 'seat', `bezel_screw_${i}`) });
+  }
+  const espParts = buildEsp(D);
+  const espBoard = espParts.board.matchTo(sh, 'face', 'esp_cradle');
+  const espOptics = espParts.optics.matchTo(sh, 'face', 'esp_optics');
+  const servoParts = buildServo(D);
+  const servoBody = servoParts.body.matchTo(sh, 'tabs', 'servo_mount');
+  const servoHorn = servoParts.horn.matchTo(sh, 'tabs', 'servo_horn_mount');
+  const holder = buildBatteryHolder(D).matchTo(sh, 'back', 'batt_mount');
+  const cellA = buildCell(D, -1).matchTo(sh, 'back', 'cell_a');
+  const cellB = buildCell(D, 1).matchTo(sh, 'back', 'cell_b');
+
+  verify.notColliding('bezel clear of shell', bezel, sh);
+  verify.notColliding('cowl clear of shell', cowl, sh);
+  verify.notColliding('cowl clear of bezel', cowl, bezel);
+  verify.notColliding('ESP32 board clear of shell', espBoard, sh);
+  verify.notColliding('ESP32 optics clear of shell', espOptics, sh);
+  verify.notColliding('ESP32 optics clear of cowl', espOptics, cowl);
+  verify.notColliding('servo body clear of shell', servoBody, sh);
+  verify.notColliding('servo horn clear of shell', servoHorn, sh);
+  verify.notColliding('battery holder clear of shell', holder, sh);
+  verify.notColliding('cell A clear of holder', cellA, holder);
+  verify.notColliding('cells clear of each other', cellA, cellB);
+  verify.clearanceBetween('bezel seats in recess', bezel, sh, -0.01, 0.1);
+  verify.clearanceBetween('ESP32 board held by rails', espBoard, sh, -0.01, 0.3);
+  verify.clearanceBetween('servo tabs seat on bosses', servoBody, sh, -0.01, 0.1);
+  verify.clearanceBetween('holder seats on rear wall', holder, sh, -0.01, 0.1);
+
+  scene({
+    camera: { position: [200, -230, 200], target: [0, 0, 55], fov: 40 },
+    environment: { preset: 'studio', intensity: 0.25, background: false },
+    lights: [
+      { type: 'ambient', color: '#efe7dc', intensity: 0.18 },
+      { type: 'directional', position: [140, -200, 260], color: '#ffe2bf', intensity: 2.6, castShadow: true },
+      { type: 'directional', position: [-150, 120, 140], color: '#d4e6fb', intensity: 0.8 },
+    ],
+  });
+  return {
+    preview: [
+      { name: 'Body Shell', shape: sh },
+      { name: 'Camera Bezel', shape: bezel },
+      { name: 'Lens Cowl', shape: cowl },
+      ...bezelScrews,
+      { name: 'ESP32-CAM Board', shape: espBoard },
+      { name: 'ESP32-CAM Optics', shape: espOptics },
+      { name: 'Servo Body', shape: servoBody },
+      { name: 'Servo Horn', shape: servoHorn },
+      { name: 'Battery Holder', shape: holder },
+      { name: '18650 Cell A', shape: cellA },
+      { name: '18650 Cell B', shape: cellB },
+    ],
+    make,
+  };
+}
+
+return { make };

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 } };