forgecad 0.10.0 → 0.10.1

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

@@ -0,0 +1,343 @@
+// Scout Cam Rover — a two-wheel self-balancing camera robot, replicated from a
+// reference render. Fully home-buildable: FDM-printed teal PLA shells, black PLA
+// pods/turret, TPU tires, and cheap purchased electronics (2x N20 gearmotors,
+// ESP32-CAM behind the front bezel, SG90 pan servo under the top turret,
+// DRV8833 + MPU6050 + MP1584, 2x18650 pack high in the body — an inverted
+// pendulum balances better with mass up high; firmware: any ESP32 balance-bot
+// sketch, e.g. B-robot style PID on the MPU6050).
+//
+// World frame: Z up, ground z=0, axle along X at z=55, front faces -Y.
+// Motion joints: drive_left / drive_right (wheel spin, mirrored axes; MuJoCo
+// calibration confirms forward roll is drive_left=+θ with drive_right=−θ)
+// and turret_pan (SG90, ±90°).
+
+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 auditP = Param.bool('Audit collisions (slow)', false);
+
+const dimsMod = require('./lib/dims.js');
+const D = dimsMod.compute({ wall: wallP, wheelOD: wheelODP });
+
+const paramsDown = { wall_thickness: wallP, wheel_od: wheelODP };
+const wheelMod = require('./parts/wheel.forge.js', paramsDown);
+const chassisMod = require('./parts/chassis.forge.js', paramsDown);
+const bodyMod = require('./parts/body.forge.js', paramsDown);
+const turretMod = require('./parts/turret.forge.js', paramsDown);
+const hwMod = require('./parts/hardware.forge.js');
+
+const simMaterials = {
+  plaTeal: Sim.material('FDM PLA teal', {
+    densityKgM3: 1240,
+    staticFriction: 0.42,
+    dynamicFriction: 0.32,
+    restitution: 0.05,
+  }),
+  plaBlack: Sim.material('FDM PLA black', {
+    densityKgM3: 1240,
+    staticFriction: 0.4,
+    dynamicFriction: 0.3,
+    restitution: 0.05,
+  }),
+  tpu: Sim.material('TPU 95A tire', {
+    densityKgM3: 1200,
+    staticFriction: 1.0,
+    dynamicFriction: 0.85,
+    restitution: 0.18,
+  }),
+  steel: Sim.material('steel hardware', {
+    densityKgM3: 7850,
+    staticFriction: 0.35,
+    dynamicFriction: 0.25,
+    restitution: 0.04,
+  }),
+  electronics: Sim.material('electronics assembly', {
+    densityKgM3: 1500,
+    staticFriction: 0.45,
+    dynamicFriction: 0.32,
+    restitution: 0.04,
+  }),
+  battery: Sim.material('18650 lithium cell', {
+    densityKgM3: 2600,
+    staticFriction: 0.35,
+    dynamicFriction: 0.25,
+    restitution: 0.03,
+  }),
+};
+
+const simBody = (massKg, material, options = {}) => Sim.body({
+  massKg,
+  material,
+  collider: options.collider ?? Sim.collider.convexHull(),
+  contacts: options.contacts,
+});
+
+const wheelContact = { tread: Sim.contact.wheelSurface('tread') };
+const wheelRadiusMm = D.tireOD / 2;
+const wheelSeparationMm = 2 * (D.wheelMouthX + D.rim.z0 + D.tireW / 2);
+
+// ---- build all parts in their local frames ----------------------------------
+const tub = chassisMod.make.buildTub(D);
+const door = chassisMod.make.buildDoor(D);
+const podL = chassisMod.make.buildPod(D);
+const podR = chassisMod.make.buildPod(D);
+const motorL = chassisMod.make.buildMotor(D);
+const motorR = chassisMod.make.buildMotor(D);
+const mods = chassisMod.make.buildBoards(D);
+const rocker = chassisMod.make.buildSwitch(D);
+
+const shell = bodyMod.make.buildShell(D);
+const bezel = bodyMod.make.buildBezel(D);
+const cowl = bodyMod.make.buildCowl(D);
+const espParts = bodyMod.make.buildEsp(D);
+const servoParts = bodyMod.make.buildServo(D);
+const battHolder = bodyMod.make.buildBatteryHolder(D);
+const cellA = bodyMod.make.buildCell(D, -1);
+const cellB = bodyMod.make.buildCell(D, 1);
+
+const wheelL = wheelMod.make.buildWheel(D);
+const wheelR = wheelMod.make.buildWheel(D);
+const turret = turretMod.make.buildTurret(D);
+
+// ---- assembly ----------------------------------------------------------------
+let rover = assembly('Scout Cam Rover')
+  .addPart('Chassis Tub', tub, {
+    transform: Transform.translation(0, 0, D.tub.z0),
+    metadata: { material: 'PLA teal', process: 'FDM', qty: 1 },
+    sim: simBody(0.11, simMaterials.plaTeal),
+  })
+  .addPart('Service Door', door, { metadata: { material: 'PLA teal', process: 'FDM' }, sim: simBody(0.018, simMaterials.plaTeal) })
+  .addPart('Motor Pod L', podL, { metadata: { material: 'PLA black', process: 'FDM' }, sim: simBody(0.022, simMaterials.plaBlack) })
+  .addPart('Motor Pod R', podR, { metadata: { material: 'PLA black', process: 'FDM' }, sim: simBody(0.022, simMaterials.plaBlack) })
+  .addPart('Gearmotor L', motorL, { metadata: { material: 'purchased', notes: 'N20 6V 150RPM' }, sim: simBody(0.012, simMaterials.steel, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Gearmotor R', motorR, { metadata: { material: 'purchased', notes: 'N20 6V 150RPM' }, sim: simBody(0.012, simMaterials.steel, { collider: Sim.collider.boundingBox() }) })
+  .addPart('DRV8833', mods.drv, { metadata: { material: 'purchased' }, sim: simBody(0.004, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('MP1584 Buck', mods.buck, { metadata: { material: 'purchased' }, sim: simBody(0.006, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('MPU6050', mods.mpu, { metadata: { material: 'purchased' }, sim: simBody(0.003, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Rocker Switch', rocker, { metadata: { material: 'purchased' }, sim: simBody(0.006, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Body Shell', shell, { metadata: { material: 'PLA teal', process: 'FDM' }, sim: simBody(0.16, simMaterials.plaTeal) })
+  .addPart('Camera Bezel', bezel, { metadata: { material: 'PLA teal', process: 'FDM' }, sim: simBody(0.012, simMaterials.plaTeal) })
+  .addPart('Lens Cowl', cowl, { metadata: { material: 'PLA black', process: 'FDM' }, sim: simBody(0.008, simMaterials.plaBlack) })
+  .addPart('ESP32-CAM Board', espParts.board, { metadata: { material: 'purchased' }, sim: simBody(0.008, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('ESP32-CAM Optics', espParts.optics, { metadata: { material: 'purchased' }, sim: simBody(0.004, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Servo Body', servoParts.body, { metadata: { material: 'purchased', notes: 'SG90 9g' }, sim: simBody(0.009, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Servo Horn', servoParts.horn, { metadata: { material: 'purchased', notes: 'SG90 round horn' }, sim: simBody(0.002, simMaterials.plaBlack) })
+  .addPart('Battery Holder', battHolder, { metadata: { material: 'purchased', notes: '2x18650 holder' }, sim: simBody(0.025, simMaterials.electronics, { collider: Sim.collider.boundingBox() }) })
+  .addPart('18650 Cell A', cellA, { metadata: { material: 'purchased' }, sim: simBody(0.045, simMaterials.battery, { collider: Sim.collider.boundingBox() }) })
+  .addPart('18650 Cell B', cellB, { metadata: { material: 'purchased' }, sim: simBody(0.045, simMaterials.battery, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Wheel Rim L', wheelL.rim, { metadata: { material: 'PLA teal', process: 'FDM' }, sim: simBody(0.028, simMaterials.plaTeal) })
+  .addPart('Tire L', wheelL.tire, { metadata: { material: 'TPU 95A', process: 'FDM' }, sim: simBody(0.038, simMaterials.tpu, { contacts: wheelContact }) })
+  .addPart('Drive Shaft L', wheelL.shaft, { metadata: { material: 'purchased', notes: 'N20 output shaft' }, sim: simBody(0.002, simMaterials.steel, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Wheel Rim R', wheelR.rim, { metadata: { material: 'PLA teal', process: 'FDM' }, sim: simBody(0.028, simMaterials.plaTeal) })
+  .addPart('Tire R', wheelR.tire, { metadata: { material: 'TPU 95A', process: 'FDM' }, sim: simBody(0.038, simMaterials.tpu, { contacts: wheelContact }) })
+  .addPart('Drive Shaft R', wheelR.shaft, { metadata: { material: 'purchased', notes: 'N20 output shaft' }, sim: simBody(0.002, simMaterials.steel, { collider: Sim.collider.boundingBox() }) })
+  .addPart('Turret', turret, { metadata: { material: 'PLA black', process: 'FDM' }, sim: simBody(0.024, simMaterials.plaBlack) });
+
+// individual screws (separate purchased parts, one bearing connector each)
+const screwSpecs = [];
+for (let i = 0; i < 4; i++) screwSpecs.push([`Door Screw ${i + 1}`, 8, 'Chassis Tub', `door_screw_${i}`]);
+for (const sd of ['l', 'r']) for (let i = 0; i < 3; i++) {
+  screwSpecs.push([`Pod Screw ${sd.toUpperCase()}${i + 1}`, 8, 'Chassis Tub', `pod_screw_${sd}_${i}`]);
+}
+for (let i = 0; i < 4; i++) screwSpecs.push([`Shell Screw ${i + 1}`, 8, 'Chassis Tub', `shell_screw_${i}`]);
+for (let i = 0; i < 4; i++) screwSpecs.push([`Bezel Screw ${i + 1}`, 6, 'Body Shell', `bezel_screw_${i}`]);
+for (const [name, len, parent, conn] of screwSpecs) {
+  rover = rover.addPart(name, hwMod.make.screwM2(len), {
+    metadata: { material: 'steel', notes: `M2x${len}` },
+    sim: simBody(len >= 8 ? 0.0005 : 0.00035, simMaterials.steel, { collider: Sim.collider.boundingBox() }),
+  });
+  rover = rover.connect(`${parent}.${conn}`, `${name}.seat`, { as: `${conn}_joint`, type: 'fixed' });
+}
+
+// fixed mounts (each interface is a connector pair)
+rover = rover
+  .connect('Chassis Tub.door_frame', 'Service Door.back', { as: 'door_mount', type: 'fixed' })
+  .connect('Chassis Tub.pod_seat_l', 'Motor Pod L.flange', { as: 'pod_l_mount', type: 'fixed' })
+  .connect('Chassis Tub.pod_seat_r', 'Motor Pod R.flange', { as: 'pod_r_mount', type: 'fixed' })
+  .connect('Chassis Tub.motor_seat_l', 'Gearmotor L.nose', { as: 'motor_l_mount', type: 'fixed' })
+  .connect('Chassis Tub.motor_seat_r', 'Gearmotor R.nose', { as: 'motor_r_mount', type: 'fixed' })
+  .connect('Chassis Tub.boards_drv', 'DRV8833.mount', { as: 'drv_mount', type: 'fixed' })
+  .connect('Chassis Tub.boards_buck', 'MP1584 Buck.mount', { as: 'buck_mount', type: 'fixed' })
+  .connect('Chassis Tub.boards_mpu', 'MPU6050.mount', { as: 'mpu_mount', type: 'fixed' })
+  .connect('Chassis Tub.switch_seat', 'Rocker Switch.mount', { as: 'switch_mount', type: 'fixed' })
+  .connect('Chassis Tub.deck', 'Body Shell.base', { as: 'shell_mount', type: 'fixed' })
+  .connect('Body Shell.cam_recess', 'Camera Bezel.back', { as: 'bezel_mount', type: 'fixed' })
+  .connect('Body Shell.cam_cowl', 'Lens Cowl.back', { as: 'cowl_mount', type: 'fixed' })
+  .connect('Body Shell.esp_cradle', 'ESP32-CAM Board.face', { as: 'esp_mount', type: 'fixed' })
+  .connect('Body Shell.esp_optics', 'ESP32-CAM Optics.face', { as: 'esp_optics_mount', type: 'fixed' })
+  .connect('Body Shell.servo_mount', 'Servo Body.tabs', { as: 'servo_mount', type: 'fixed' })
+  .connect('Body Shell.servo_horn_mount', 'Servo Horn.tabs', { as: 'servo_horn_mount', type: 'fixed' })
+  .connect('Body Shell.batt_mount', 'Battery Holder.back', { as: 'batt_mount', type: 'fixed' })
+  .connect('Body Shell.cell_a', '18650 Cell A.back', { as: 'cell_a_mount', type: 'fixed' })
+  .connect('Body Shell.cell_b', '18650 Cell B.back', { as: 'cell_b_mount', type: 'fixed' });
+
+// motion joints; tires and shafts are fixed children of the spinning rims
+rover = rover
+  .connect('Gearmotor L.shaft_tip', 'Wheel Rim L.bore', {
+    as: 'drive_left', min: -720, max: 720, default: 0, unit: '°',
+    drive: Sim.drive.velocity({ maxTorqueNm: 0.08, maxSpeedRpm: 150, damping: 0.015, friction: 0.006 }),
+  })
+  .connect('Gearmotor R.shaft_tip', 'Wheel Rim R.bore', {
+    as: 'drive_right', min: -720, max: 720, default: 0, unit: '°',
+    drive: Sim.drive.velocity({ maxTorqueNm: 0.08, maxSpeedRpm: 150, damping: 0.015, friction: 0.006 }),
+  })
+  .connect('Wheel Rim L.tire_seat', 'Tire L.seat', { as: 'tire_l_fit', type: 'fixed' })
+  .connect('Wheel Rim L.shaft_seat', 'Drive Shaft L.seat', { as: 'shaft_l_fit', type: 'fixed' })
+  .connect('Wheel Rim R.tire_seat', 'Tire R.seat', { as: 'tire_r_fit', type: 'fixed' })
+  .connect('Wheel Rim R.shaft_seat', 'Drive Shaft R.seat', { as: 'shaft_r_fit', type: 'fixed' })
+  .connect('Servo Horn.spline', 'Turret.hub', {
+    as: 'turret_pan', min: -90, max: 90, default: 0, unit: '°',
+    drive: Sim.drive.velocity({ maxTorqueNm: 0.16, maxSpeedRpm: 60, damping: 0.04, friction: 0.01 }),
+  });
+
+rover = rover.withSimulation({
+  rootPart: 'Chassis Tub',
+  profile: Sim.profile.robotBodyRunnable(),
+  controllers: [
+    Sim.controller.diffDrive({
+      leftJoints: ['drive_left'],
+      rightJoints: ['drive_right'],
+      wheelRadiusMm,
+      wheelSeparationMm,
+    }),
+  ],
+});
+
+// ---- animations ---------------------------------------------------------------
+// forward roll = drive_left +θ, drive_right −θ (mirrored revolute axes)
+rover = rover
+  .addAnimation('Drive & scan', {
+    duration: 9, loop: true, continuous: true, default: true,
+    keyframes: [
+      { values: { drive_left: 0, drive_right: 0, turret_pan: 0 } },
+      { values: { drive_left: 240, drive_right: -240, turret_pan: 55 } },
+      { values: { drive_left: 480, drive_right: -480, turret_pan: -55 } },
+      { values: { drive_left: 720, drive_right: -720, turret_pan: 0 } },
+    ],
+  })
+  .addAnimation('Spin in place', {
+    duration: 6, loop: true, continuous: true,
+    keyframes: [
+      { values: { drive_left: 0, drive_right: 0, turret_pan: 0 } },
+      { values: { drive_left: -360, drive_right: -360, turret_pan: 45 } },
+      { values: { drive_left: -720, drive_right: -720, turret_pan: -45 } },
+      { values: { drive_left: -720, drive_right: -720, turret_pan: 0 } },
+    ],
+  })
+  .addAnimation('Camera sweep', {
+    duration: 4, loop: true, continuous: true,
+    keyframes: [
+      { values: { turret_pan: 0 } },
+      { values: { turret_pan: 88 } },
+      { values: { turret_pan: -88 } },
+      { values: { turret_pan: 0 } },
+    ],
+  });
+
+// ---- pose verification ---------------------------------------------------------
+const poses = [
+  { drive_left: 0, drive_right: 0, turret_pan: 0 },
+  { drive_left: -45, drive_right: 45, turret_pan: 60 },
+  { drive_left: -137, drive_right: 290, turret_pan: -90 },
+  { drive_left: 720, drive_right: -720, turret_pan: 90 },
+];
+for (const pose of poses) {
+  const s = rover.solve(pose);
+  const tag = `dl=${pose.drive_left} dr=${pose.drive_right} pan=${pose.turret_pan}`;
+  verify.that(`solve converges (${tag})`, () => s.warnings().length === 0,
+    `solver warnings: ${s.warnings().join('; ')}`);
+  verify.clearanceBetween(`wheel R clears pod R (${tag})`, s.getPart('Wheel Rim R'), s.getPart('Motor Pod R'), 0.4, 80);
+  verify.clearanceBetween(`wheel L clears tub (${tag})`, s.getPart('Wheel Rim L'), s.getPart('Chassis Tub'), 0.4, 80);
+  verify.clearanceBetween(`tire R clears body shell (${tag})`, s.getPart('Tire R'), s.getPart('Body Shell'), 2.0, 80);
+  verify.clearanceBetween(`turret clears shell neck (${tag})`, s.getPart('Turret'), s.getPart('Body Shell'), 0.4, 80);
+  verify.clearanceBetween(`turret clears servo body (${tag})`, s.getPart('Turret'), s.getPart('Servo Body'), 0.4, 80);
+}
+
+const sDefault = rover.solve({});
+const gDefault = sDefault.toGroup();
+verify.connectorDistance('wheel L bore on motor L shaft', gDefault, 'Wheel Rim L.bore', 'Gearmotor L.shaft_tip', 0, 0.01);
+verify.connectorDistance('wheel R bore on motor R shaft', gDefault, 'Wheel Rim R.bore', 'Gearmotor R.shaft_tip', 0, 0.01);
+verify.connectorDistance('turret hub on servo spline', gDefault, 'Turret.hub', 'Servo Horn.spline', 0, 0.01);
+verify.connectorDistance('shell base on tub deck', gDefault, 'Body Shell.base', 'Chassis Tub.deck', 0, 0.01);
+
+// ground contact: tire bottoms at z=0
+const wheelBB = sDefault.getPart('Tire L').boundingBox();
+verify.equal('left tire touches the ground', wheelBB.min[2], 0, 0.05);
+verify.equal('wheel OD as designed', wheelBB.max[2] - wheelBB.min[2], wheelODP, 0.1);
+
+// full pairwise audit (slow) — run with --param "Audit collisions (slow)=1"
+if (auditP) {
+  for (const pose of poses) {
+    const s = rover.solve(pose);
+    const findings = s.collisionReport({ minOverlapVolume: 0.5 });
+    verify.that(`no collisions at dl=${pose.drive_left} pan=${pose.turret_pan}`,
+      () => findings.length === 0,
+      findings.map(f => `${f.partA ?? f.a} vs ${f.partB ?? f.b}: ${JSON.stringify(f)}`).join(' | ').slice(0, 400));
+  }
+}
+
+verify.physicalComponentCount('one jointed assembly', 1);
+
+// ---- BOM ------------------------------------------------------------------------
+bom(1, 'chassis tub', { material: 'PLA teal', process: 'FDM printed' });
+bom(1, 'service door', { material: 'PLA teal', process: 'FDM printed' });
+bom(1, 'body shell', { material: 'PLA teal', process: 'FDM printed' });
+bom(1, 'camera bezel', { material: 'PLA teal', process: 'FDM printed' });
+bom(2, 'wheel rim', { material: 'PLA teal', process: 'FDM printed' });
+bom(2, 'motor pod', { material: 'PLA black', process: 'FDM printed' });
+bom(1, 'lens cowl', { material: 'PLA black', process: 'FDM printed' });
+bom(1, 'pan turret', { material: 'PLA black', process: 'FDM printed' });
+bom(2, 'tire', { material: 'TPU 95A gray', process: 'FDM printed', notes: 'print ID 0.5mm under rim OD for stretch fit' });
+bom(2, 'N20 micro gearmotor 6V 150RPM, 3mm D-shaft', { notes: '~$3 ea' });
+bom(1, 'ESP32-CAM (AI-Thinker) + OV2640', { notes: 'camera + wifi + controller, ~$9' });
+bom(1, 'SG90 micro servo + round horn', { notes: 'turret pan, ~$2.5' });
+bom(1, 'DRV8833 dual H-bridge module', { notes: '~$2' });
+bom(1, 'MPU6050 IMU module', { notes: 'balance sensing, ~$2' });
+bom(1, 'MP1584EN 5V buck module', { notes: '~$1.5' });
+bom(1, 'KCD11 mini rocker switch', { notes: '~$0.5' });
+bom(1, '2x18650 battery holder (wire leads)', { notes: '~$1.5' });
+bom(2, '18650 Li-ion cell, flat top', { notes: 'charge externally' });
+bom(14, 'M2x8 self-tapping screw', { notes: 'door 4, pods 6, shell 4' });
+bom(4, 'M2x6 self-tapping screw, bezel set');
+bom(2, 'M2x6 screw, servo tabs' );
+bom(2, 'M2x6 screw, battery holder');
+bom(1, 'M2x10 screw, turret-to-horn retention');
+bom(1, 'hookup wire + heat-shrink set', { notes: 'motor, battery, servo runs' });
+
+// ---- dimension annotations -------------------------------------------------------
+const trackOuter = D.wheelMouthX + D.rim.z0 + D.tireW;
+dim([-trackOuter, 0, D.axleZ], [trackOuter, 0, D.axleZ], { label: 'Overall width', offset: 30 });
+dim([0, -D.tireOD / 2, 0], [0, -D.tireOD / 2, D.tireOD], { label: 'Wheel OD', offset: 20 });
+dim([0, 60, 0], [0, 60, D.tub.z0 + D.tub.h + D.body.h + D.neck.h + D.turret.baseH + D.turret.barrelH + D.turret.capH + D.turret.gapAboveNeck],
+  { label: 'Overall height', offset: 24 });
+dim([-D.body.w / 2, -4, D.tub.z0 + D.tub.h + 2], [D.body.w / 2, -4, D.tub.z0 + D.tub.h + 2], { label: 'Body width', offset: 16 });
+dim([-D.tub.w / 2, 0, D.tub.z0], [D.tub.w / 2, 0, D.tub.z0], { label: 'Tub width', offset: 12 });
+dim([0, 0, 0], [0, 0, D.axleZ], { label: 'Axle height', offset: 18 });
+
+// ---- scene -----------------------------------------------------------------------
+scene({
+  background: { top: '#c3ccd7', bottom: '#566474' },
+  camera: { position: [320, -380, 300], target: [0, 0, 100], fov: 38 },
+  environment: { preset: 'studio', intensity: 0.2, background: false },
+  lights: [
+    { type: 'ambient', color: '#efe7dc', intensity: 0.16 },
+    { type: 'directional', position: [260, -320, 420], color: '#ffe2bf', intensity: 2.8, castShadow: true },
+    { type: 'directional', position: [-260, 210, 220], color: '#d4e6fb', intensity: 0.85 },
+    { type: 'hemisphere', skyColor: '#c7d3df', groundColor: '#495463', intensity: 0.15 },
+  ],
+  ground: { visible: true, color: '#3c4654', height: 0, receiveShadow: true },
+  postProcessing: {
+    bloom: { intensity: 0.04, threshold: 0.94, radius: 0.28 },
+    vignette: { darkness: 0.4, offset: 0.32 },
+    toneMappingExposure: 1.1,
+  },
+  views: {
+    hero: { camera: { position: [320, -380, 300], target: [0, 0, 100], up: [0, 0, 1], fov: 38 } },
+    front: { camera: { position: [0, -520, 130], target: [0, 0, 105], up: [0, 0, 1], fov: 32 } },
+    side: { camera: { position: [520, 0, 130], target: [0, 0, 105], up: [0, 0, 1], fov: 32 } },
+    rear: { camera: { position: [-300, 380, 280], target: [0, 0, 100], up: [0, 0, 1], fov: 38 } },
+    top: { camera: { position: [10, -40, 560], target: [0, 0, 80], up: [0, 1, 0], fov: 32 } },
+    underside: { camera: { position: [180, -260, -180], target: [0, 0, 70], up: [0, 0, 1], fov: 40 } },
+  },
+});
+
+return rover;

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