forgecad 0.1.0

package/examples/iphone.forge.js

@@ -0,0 +1,114 @@
+// iPhone — parametric model
+// Tests ForgeCAD's sketch→extrude + smoothing workflow
+
+// === Dimensions (roughly iPhone 15 Pro proportions) ===
+const w = param("Width", 71.6, { min: 60, max: 80, unit: "mm" });
+const h = param("Height", 146.6, { min: 120, max: 170, unit: "mm" });
+const d = param("Depth", 8.25, { min: 6, max: 12, unit: "mm" });
+const cornerR = param("Corner Radius", 10, { min: 2, max: 20, unit: "mm" });
+const edgeR = param("Edge Radius", 1.5, { min: 0, max: 3, step: 0.1, unit: "mm" });
+
+// === Body ===
+// Strategy: create the body profile, extrude, then smooth edges.
+// smoothOut + refine rounds the sharp 90° edges where top/bottom meet sides.
+// We use low smoothness to avoid inflating the shape.
+const bodyProfile = roundedRect(w, h, cornerR, true);
+let body = bodyProfile.extrude(d, { center: true });
+
+if (edgeR > 0) {
+  // smoothOut marks edges for rounding, refine subdivides to actually curve them
+  // minSharpAngle=80 catches the 90° edges but leaves shallow angles alone
+  // minSmoothness controls how much rounding (0=sharp, 1=full round)
+  const smoothness = Math.min(edgeR / 3, 1);
+  body = body.toShape().smoothOut(80, smoothness).refine(3);
+}
+
+// === Screen cutout (inset from front face) ===
+const screenInset = param("Screen Inset", 2, { min: 1, max: 5, unit: "mm" });
+const screenDepth = 0.4;
+const screenProfile = roundedRect(w - screenInset * 2, h - screenInset * 2, cornerR - screenInset, true);
+const screenCut = screenProfile.extrude(screenDepth + 1)
+  .translate(0, 0, d / 2 - screenDepth);
+body = body.subtract(screenCut);
+
+// === Camera island (back, top-left area) ===
+const camSize = param("Camera Island", 36, { min: 25, max: 45, unit: "mm" });
+const camR = 8;
+const camBump = param("Camera Bump", 1.5, { min: 0.5, max: 3, unit: "mm" });
+const camX = -w / 2 + camSize / 2 + 4;
+const camY = h / 2 - camSize / 2 - 4;
+
+const camProfile = roundedRect(camSize, camSize, camR, true).translate(camX, camY);
+let camIsland = camProfile.extrude(camBump).translate(0, 0, -d / 2 - camBump);
+if (edgeR > 0) {
+  camIsland = camIsland.toShape().smoothOut(80, 0.4).refine(2);
+}
+
+// Camera lenses (3 in L-pattern)
+const lensR = param("Lens Radius", 6, { min: 3, max: 10, unit: "mm" });
+const lensSpacing = 12;
+const lensZ = -d / 2 - camBump;
+
+const makeLens = (x, y) =>
+  circle2d(lensR).translate(x, y).extrude(camBump + 1).translate(0, 0, lensZ - 0.5);
+
+const lens1 = makeLens(camX - lensSpacing / 2, camY + lensSpacing / 2);
+const lens2 = makeLens(camX + lensSpacing / 2, camY + lensSpacing / 2);
+const lens3 = makeLens(camX - lensSpacing / 2, camY - lensSpacing / 2);
+
+// === Charging port (bottom edge) ===
+const portW = param("Port Width", 9, { min: 6, max: 14, unit: "mm" });
+const portH = 3;
+const portDepth = 4;
+const portCut = roundedRect(portW, portH, portH / 2, true)
+  .extrude(portDepth)
+  .rotate(90, 0, 0)
+  .translate(0, -h / 2, 0);
+
+// === Speaker grille (bottom, right of port) ===
+const holeR = 0.5;
+const holeCount = param("Speaker Holes", 6, { min: 3, max: 10 });
+const holeSpacing = 2.2;
+const grillX0 = portW / 2 + 5;
+const speakerHoles = [];
+for (let i = 0; i < holeCount; i++) {
+  speakerHoles.push(
+    cylinder(portDepth, holeR, undefined, 12)
+      .rotate(90, 0, 0)
+      .translate(grillX0 + i * holeSpacing, -h / 2, 0)
+  );
+}
+
+// Mic holes (bottom, left of port)
+for (let i = 0; i < 2; i++) {
+  speakerHoles.push(
+    cylinder(portDepth, holeR, undefined, 12)
+      .rotate(90, 0, 0)
+      .translate(-grillX0 - i * holeSpacing, -h / 2, 0)
+  );
+}
+const grillCut = union(...speakerHoles);
+
+// === Side buttons ===
+const btnInset = 0.4;
+const btnThick = 1.6;
+
+const sideBtn = (bw, bx, by, side) => {
+  const profile = roundedRect(bw, btnThick, 0.5, true);
+  const btn = profile.extrude(btnInset);
+  if (side === 'left') return btn.rotate(90, 0, 90).translate(-w / 2 - edgeR - btnInset, by, 0);
+  return btn.rotate(90, 0, 90).translate(w / 2 + edgeR + btnInset, by, 0);
+};
+
+const volUp = sideBtn(14, 0, h / 2 - 35, 'left');
+const volDown = sideBtn(14, 0, h / 2 - 53, 'left');
+const actionBtn = sideBtn(8, 0, h / 2 - 13, 'left');
+const powerBtn = sideBtn(18, 0, h / 2 - 40, 'right');
+
+// === Assembly ===
+let phone = union(body, camIsland);
+phone = phone.subtract(lens1).subtract(lens2).subtract(lens3);
+phone = phone.subtract(portCut).subtract(grillCut);
+phone = union(phone, volUp, volDown, actionBtn, powerBtn);
+
+return phone;

package/examples/ironman-helmet.js

@@ -0,0 +1,79 @@
+// Iron Man Helmet - Parametric Design
+
+// Parameters
+const scale = param("Scale", 1.0, { min: 0.5, max: 1.5, step: 0.1 });
+const chinWidth = param("Chin Width", 80, { min: 60, max: 100, unit: "mm" });
+const eyeWidth = param("Eye Width", 35, { min: 25, max: 50, unit: "mm" });
+const eyeHeight = param("Eye Height", 12, { min: 8, max: 20, unit: "mm" });
+const mouthWidth = param("Mouth Width", 25, { min: 15, max: 40, unit: "mm" });
+
+// Base dimensions (scaled)
+const baseWidth = 180 * scale;
+const baseHeight = 240 * scale;
+const baseDepth = 200 * scale;
+
+// Main helmet shell - elongated sphere for head shape
+const mainShell = sphere(baseWidth / 2)
+  .scale([1, 1.3, 1.1])
+  .translate(0, 0, baseHeight / 3);
+
+// Faceplate - angular front section
+const faceplateProfile = polygon([
+  [0, 0],
+  [chinWidth / 2, 0],
+  [baseWidth / 2, baseHeight * 0.4],
+  [baseWidth / 2, baseHeight * 0.7],
+  [baseWidth / 2 - 20, baseHeight * 0.85],
+  [0, baseHeight * 0.9]
+]);
+
+const faceplate = union2d(
+  faceplateProfile,
+  faceplateProfile.mirror([1, 0])
+).extrude(baseDepth / 2, { scaleTop: 0.7 });
+
+// Eye cutouts - angular slits
+const eyeLeft = rect(eyeWidth, eyeHeight)
+  .offset(2, 'Round')
+  .extrude(50)
+  .rotate(0, 10, -15)
+  .translate(-baseWidth / 4, baseHeight * 0.55, baseDepth / 2 - 10);
+
+const eyeRight = eyeLeft.mirror([1, 0, 0]);
+
+// Mouth/chin vent - triangular opening
+const mouthVent = polygon([
+  [-mouthWidth / 2, 0],
+  [mouthWidth / 2, 0],
+  [0, -15]
+]).extrude(30)
+  .translate(0, baseHeight * 0.15, baseDepth / 2 - 5);
+
+// Forehead arc reactor glow slot
+const foreheadSlot = rect(40, 8)
+  .offset(2, 'Round')
+  .extrude(20)
+  .translate(0, baseHeight * 0.75, baseDepth / 2 - 5);
+
+// Cheek vents - angular cuts
+const cheekVent = rect(15, 40)
+  .extrude(25)
+  .rotate(0, 15, 20)
+  .translate(baseWidth / 3, baseHeight * 0.35, baseDepth / 2 - 10);
+
+const cheekVentRight = cheekVent.mirror([1, 0, 0]);
+
+// Combine everything
+const helmet = intersection(mainShell, faceplate)
+  .subtract(eyeLeft)
+  .subtract(eyeRight)
+  .subtract(mouthVent)
+  .subtract(foreheadSlot)
+  .subtract(cheekVent)
+  .subtract(cheekVentRight);
+
+// Add chin detail - angular jaw line
+const chinDetail = box(chinWidth - 10, 15, 20, true)
+  .translate(0, baseHeight * 0.08, baseDepth / 2 - 10);
+
+return helmet.add(chinDetail);

package/examples/kitchen.forge.js

@@ -0,0 +1,231 @@
+// Modern Kitchen — L-shaped counter with appliances
+// Demonstrates: multi-object scene, colors, parametric layout
+
+const counterW = param("Counter Width", 2400, { min: 1800, max: 3500, unit: "mm" });
+const counterD = param("Counter Depth", 600, { min: 500, max: 800, unit: "mm" });
+const counterH = param("Counter Height", 900, { min: 800, max: 1000, unit: "mm" });
+const sideLen = param("Side Length", 1600, { min: 1000, max: 2500, unit: "mm" });
+const cabinetH = param("Cabinet Height", 720, { min: 600, max: 850, unit: "mm" });
+const topT = param("Countertop Thick", 30, { min: 15, max: 50, unit: "mm" });
+const kickH = 100;
+const kickD = 50;
+
+// ─── Base cabinets (L-shape) ───
+
+// Main run along back wall
+const mainCab = box(counterW, counterD, cabinetH)
+  .translate(0, 0, counterH - cabinetH - topT);
+
+// Side run perpendicular
+const sideCab = box(counterD, sideLen - counterD, cabinetH)
+  .translate(0, counterD, counterH - cabinetH - topT);
+
+// Kick plates (recessed at bottom)
+const mainKick = box(counterW, counterD - kickD, kickH)
+  .translate(0, kickD, 0);
+const sideKick = box(counterD - kickD, sideLen - counterD, kickH)
+  .translate(kickD, counterD, 0);
+
+const cabinets = union(mainCab, sideCab).subtract(mainKick).subtract(sideKick);
+
+// Cabinet doors — vertical lines
+const doorGap = 2;
+const doorW = 500;
+const doorCount = Math.floor(counterW / doorW);
+const doorLines = [];
+for (let i = 1; i < doorCount; i++) {
+  doorLines.push(
+    box(doorGap, 3, cabinetH)
+      .translate(i * doorW, counterD - 1, counterH - cabinetH - topT)
+  );
+}
+// Side cabinet doors
+const sideDoorCount = Math.floor((sideLen - counterD) / doorW);
+for (let i = 1; i < sideDoorCount; i++) {
+  doorLines.push(
+    box(3, doorGap, cabinetH)
+      .translate(counterD - 1, counterD + i * doorW, counterH - cabinetH - topT)
+  );
+}
+
+// Handles — horizontal bars on each door
+const handles = [];
+const handleW = 120;
+const handleH = 10;
+const handleZ = counterH - cabinetH - topT + cabinetH * 0.75;
+for (let i = 0; i < doorCount; i++) {
+  handles.push(
+    box(handleW, 8, handleH, true)
+      .translate(i * doorW + doorW / 2, counterD + 4, handleZ)
+  );
+}
+for (let i = 0; i < sideDoorCount; i++) {
+  handles.push(
+    box(8, handleW, handleH, true)
+      .translate(counterD + 4, counterD + i * doorW + doorW / 2, handleZ)
+  );
+}
+
+const allHandles = handles.length > 0 ? union(...handles) : box(1, 1, 1);
+const allDoorLines = doorLines.length > 0 ? union(...doorLines) : box(1, 1, 1);
+
+// ─── Countertop ───
+
+const mainTop = box(counterW + 20, counterD + 20, topT)
+  .translate(-10, -10, counterH - topT);
+const sideTop = box(counterD + 20, sideLen - counterD + 10, topT)
+  .translate(-10, counterD, counterH - topT);
+const countertop = union(mainTop, sideTop);
+
+// ─── Sink (in main counter) ───
+
+const sinkW = param("Sink Width", 500, { min: 350, max: 700, unit: "mm" });
+const sinkD = 400;
+const sinkDepth = 180;
+const sinkX = counterW * 0.4;
+
+const sinkOuter = box(sinkW, sinkD, sinkDepth + topT, true);
+const sinkInner = box(sinkW - 20, sinkD - 20, sinkDepth + topT + 2, true);
+const sinkBowl = sinkOuter.subtract(sinkInner)
+  .translate(sinkX, counterD / 2, counterH - sinkDepth / 2);
+
+// Drain
+const drain = cylinder(sinkDepth + topT + 2, 20)
+  .translate(sinkX, counterD / 2, counterH - sinkDepth - topT);
+
+// Faucet
+const faucetBase = cylinder(40, 15)
+  .translate(sinkX, counterD * 0.15, counterH);
+const faucetArm = box(12, 180, 12, true)
+  .translate(sinkX, counterD * 0.15 + 90, counterH + 40 + 6);
+const faucetNeck = cylinder(50, 6)
+  .translate(sinkX, counterD * 0.15, counterH);
+const faucetSpout = cylinder(30, 4)
+  .translate(sinkX, counterD / 2, counterH + 30);
+
+const faucet = union(faucetBase, faucetNeck, faucetArm, faucetSpout);
+
+// Cut sink hole in countertop
+const sinkHole = box(sinkW - 10, sinkD - 10, topT + 2, true)
+  .translate(sinkX, counterD / 2, counterH - topT / 2);
+
+// ─── Stovetop (right side of main counter) ───
+
+const stoveX = counterW * 0.78;
+const stoveW = 580;
+const stoveD = 510;
+
+// Stovetop surface (slightly raised)
+const stoveSurface = box(stoveW, stoveD, 3, true)
+  .translate(stoveX, counterD / 2, counterH + 1.5);
+
+// Burners — 4 circles
+const burnerPositions = [
+  [-120, -100], [120, -100],
+  [-120, 100], [120, 100],
+];
+const burnerRings = [];
+for (const [bx, by] of burnerPositions) {
+  const r = Math.abs(by) < 50 ? 90 : 70; // back burners larger
+  const ring = circle2d(r).subtract(circle2d(r - 8))
+    .extrude(2)
+    .translate(stoveX + bx, counterD / 2 + by, counterH + 3);
+  burnerRings.push(ring);
+}
+const burners = union(...burnerRings);
+
+// Knobs (front of stove area)
+const knobs = [];
+for (let i = 0; i < 4; i++) {
+  knobs.push(
+    cylinder(8, 12)
+      .translate(stoveX - 180 + i * 120, counterD + 5, counterH - topT + cabinetH * 0.92)
+  );
+}
+const stoveKnobs = union(...knobs);
+
+// ─── Range hood (above stove) ───
+
+const hoodW = stoveW + 60;
+const hoodD = counterD - 50;
+const hoodH = 120;
+const hoodZ = counterH + 650;
+
+const hoodBody = box(hoodW, hoodD, hoodH, true)
+  .translate(stoveX, counterD / 2, hoodZ);
+// Chimney
+const chimneyW = hoodW * 0.4;
+const chimneyH = 400;
+const chimney = box(chimneyW, hoodD * 0.5, chimneyH, true)
+  .translate(stoveX, counterD / 2, hoodZ + hoodH / 2 + chimneyH / 2);
+
+const rangeHood = union(hoodBody, chimney);
+
+// ─── Upper cabinets (on back wall above counter) ───
+
+const upperH = param("Upper Cab Height", 700, { min: 500, max: 900, unit: "mm" });
+const upperD = 350;
+const upperZ = counterH + 500;
+const upperW = counterW * 0.35; // left section only (right has hood)
+
+const upperCab = box(upperW, upperD, upperH)
+  .translate(0, 0, upperZ);
+
+// Upper door lines
+const upperDoorW = upperW / 2;
+const upperDoorLine = box(doorGap, 3, upperH)
+  .translate(upperDoorW, upperD - 1, upperZ);
+
+// Upper handles
+const upperHandle1 = box(handleW, 8, handleH, true)
+  .translate(upperDoorW / 2, upperD + 4, upperZ + upperH * 0.2);
+const upperHandle2 = box(handleW, 8, handleH, true)
+  .translate(upperDoorW + upperDoorW / 2, upperD + 4, upperZ + upperH * 0.2);
+
+const upperSection = union(upperCab, upperDoorLine);
+const upperHandles = union(upperHandle1, upperHandle2);
+
+// ─── Refrigerator (at far left end) ───
+
+const fridgeW = param("Fridge Width", 700, { min: 600, max: 900, unit: "mm" });
+const fridgeD = 650;
+const fridgeH = 1800;
+const fridgeX = -fridgeW - 30; // left of counter
+
+const fridgeBody = box(fridgeW, fridgeD, fridgeH)
+  .translate(fridgeX, 0, 0);
+
+// Fridge door split (top 60%, bottom 40%)
+const splitZ = fridgeH * 0.4;
+const fridgeSplit = box(fridgeW + 2, 3, 3)
+  .translate(fridgeX - 1, fridgeD - 1, splitZ);
+
+// Fridge handles
+const fridgeHandleTop = box(8, 30, 250, true)
+  .translate(fridgeX + fridgeW - 30, fridgeD + 15, splitZ + (fridgeH - splitZ) / 2);
+const fridgeHandleBot = box(8, 30, 150, true)
+  .translate(fridgeX + fridgeW - 30, fridgeD + 15, splitZ / 2);
+
+const fridge = union(fridgeBody, fridgeSplit);
+const fridgeHandles = union(fridgeHandleTop, fridgeHandleBot);
+
+// ─── Assemble ───
+
+const counterWithSink = countertop.subtract(sinkHole);
+const cabsWithLines = cabinets.subtract(allDoorLines);
+
+return [
+  { name: "Cabinets", shape: cabsWithLines, color: "#f5f0e8" },
+  { name: "Handles", shape: allHandles, color: "#888888" },
+  { name: "Countertop", shape: counterWithSink, color: "#404040" },
+  { name: "Sink", shape: sinkBowl.subtract(drain), color: "#c0c0c0" },
+  { name: "Faucet", shape: faucet, color: "#a0a0a0" },
+  { name: "Stove Surface", shape: stoveSurface, color: "#1a1a1a" },
+  { name: "Burners", shape: burners, color: "#cc3300" },
+  { name: "Stove Knobs", shape: stoveKnobs, color: "#333333" },
+  { name: "Range Hood", shape: rangeHood, color: "#c0c0c0" },
+  { name: "Upper Cabinets", shape: union(upperSection), color: "#f5f0e8" },
+  { name: "Upper Handles", shape: upperHandles, color: "#888888" },
+  { name: "Refrigerator", shape: fridge, color: "#d0d0d0" },
+  { name: "Fridge Handles", shape: fridgeHandles, color: "#888888" },
+];

package/examples/lamp-shade.sketch.js

@@ -0,0 +1,17 @@
+// Lamp Shade profile — trapezoid cross-section for revolution
+// Returns a Sketch (revolved by the parent .forge.js)
+
+const topR = param("Top Radius", 15, { min: 8, max: 30, unit: "mm" });
+const bottomR = param("Bottom Radius", 30, { min: 15, max: 50, unit: "mm" });
+const shadeH = param("Shade Height", 35, { min: 20, max: 60, unit: "mm" });
+const wall = param("Wall Thickness", 1.5, { min: 0.5, max: 4, unit: "mm" });
+
+// Outer trapezoid profile (right half for revolution around Y axis)
+const outer = polygon([
+  [topR, shadeH],
+  [bottomR, 0],
+  [bottomR, -wall],      // bottom lip thickness
+  [topR - wall, shadeH], // inner top
+]);
+
+return outer;

package/examples/laptop.forge.js

@@ -0,0 +1,144 @@
+// Laptop — parametric with opening hinge
+// Demonstrates: joint(), multi-object, roundedRect, boolean ops
+
+const w = param("Width", 320, { min: 250, max: 400, unit: "mm" });
+const d = param("Depth", 220, { min: 170, max: 300, unit: "mm" });
+const baseH = param("Base Height", 15, { min: 8, max: 25, unit: "mm" });
+const lidH = param("Lid Height", 6, { min: 3, max: 12, unit: "mm" });
+const cornerR = param("Corner Radius", 10, { min: 3, max: 25, unit: "mm" });
+const screenInset = param("Screen Bezel", 8, { min: 3, max: 20, unit: "mm" });
+const kbInsetX = param("KB Inset X", 25, { min: 10, max: 50, unit: "mm" });
+const kbInsetY = param("KB Inset Y", 15, { min: 8, max: 40, unit: "mm" });
+
+// ─── Base ───
+const baseProfile = roundedRect(w, d, cornerR, true);
+let base = baseProfile.extrude(baseH);
+
+// Keyboard recess
+const kbW = w - kbInsetX * 2;
+const kbD = d * 0.55;
+const kbDepth = 1.5;
+const kbRecess = roundedRect(kbW, kbD, 4, true)
+  .extrude(kbDepth + 1)
+  .translate(0, d * 0.1, baseH - kbDepth);
+base = base.subtract(kbRecess);
+
+// Trackpad recess
+const tpW = w * 0.3;
+const tpD = d * 0.22;
+const tpRecess = roundedRect(tpW, tpD, 3, true)
+  .extrude(kbDepth + 1)
+  .translate(0, -d * 0.28, baseH - kbDepth);
+base = base.subtract(tpRecess);
+
+// Key grid (simplified — rows of small boxes subtracted)
+const keyW = 14;
+const keyH = 14;
+const keyGap = 2;
+const keyStep = keyW + keyGap;
+const keyCols = Math.floor(kbW / keyStep);
+const keyRows = Math.floor(kbD / keyStep);
+const keyStartX = -((keyCols - 1) * keyStep) / 2;
+const keyStartY = d * 0.1 - ((keyRows - 1) * keyStep) / 2;
+
+const keys = [];
+for (let r = 0; r < keyRows; r++) {
+  for (let c = 0; c < keyCols; c++) {
+    keys.push(
+      roundedRect(keyW, keyH, 1, true)
+        .extrude(1)
+        .translate(keyStartX + c * keyStep, keyStartY + r * keyStep, baseH - kbDepth - 0.5)
+    );
+  }
+}
+const keyboard = union(...keys);
+
+// Ports — left side
+const usbC1 = roundedRect(9, 3.5, 1.5, true).extrude(8)
+  .rotate(0, 0, 90)
+  .translate(-w / 2, -d * 0.1, baseH * 0.4);
+const usbC2 = roundedRect(9, 3.5, 1.5, true).extrude(8)
+  .rotate(0, 0, 90)
+  .translate(-w / 2, d * 0.05, baseH * 0.4);
+base = base.subtract(usbC1).subtract(usbC2);
+
+// Headphone jack — right side
+const hpJack = cylinder(8, 2)
+  .rotate(0, 90, 0)
+  .translate(w / 2, -d * 0.1, baseH * 0.5);
+base = base.subtract(hpJack);
+
+// Vent slots on bottom
+const ventSlots = [];
+const ventCount = 12;
+const ventW = w * 0.4;
+const ventGap = 3;
+for (let i = 0; i < ventCount; i++) {
+  ventSlots.push(
+    roundedRect(ventW, 1.5, 0.5, true)
+      .extrude(2)
+      .translate(0, -d * 0.1 + i * ventGap, -1)
+  );
+}
+base = difference(base, ...ventSlots);
+
+// ─── Lid ───
+const lidProfile = roundedRect(w, d, cornerR, true);
+let lid = lidProfile.extrude(lidH);
+
+// Screen cutout (inset from inner face)
+const screenW = w - screenInset * 2;
+const screenD = d - screenInset * 2;
+const screenCutDepth = 1;
+const screenCut = roundedRect(screenW, screenD, cornerR - screenInset / 2, true)
+  .extrude(screenCutDepth + 1)
+  .translate(0, 0, -0.5);
+lid = lid.subtract(screenCut);
+
+// Camera dot (tiny cylinder on top bezel)
+const cameraDot = cylinder(lidH + 2, 2)
+  .translate(0, d / 2 - screenInset / 2, -1);
+lid = lid.subtract(cameraDot);
+
+// Screen panel (thin slab filling the cutout)
+const screenPanel = roundedRect(screenW - 1, screenD - 1, cornerR - screenInset / 2 - 1, true)
+  .extrude(screenCutDepth)
+  .translate(0, 0, 0);
+
+// ─── Hinge: rotate lid open ───
+// Lid pivots around the back edge of the base
+const hingeY = d / 2;
+const hingeZ = baseH;
+
+// Position lid at hinge point, then use joint to rotate
+const lidAtHinge = lid.translate(0, -hingeY, 0)
+  .rotate(180, 0, 0)
+  .translate(0, hingeY, hingeZ);
+
+const screenAtHinge = screenPanel.translate(0, -hingeY, 0)
+  .rotate(180, 0, 0)
+  .translate(0, hingeY, hingeZ);
+
+const lidAngle = param("Lid Angle", 110, { min: 0, max: 135, unit: "°" });
+
+const openLid = lidAtHinge.rotateAround([1, 0, 0], lidAngle, [0, hingeY, hingeZ]);
+const openScreen = screenAtHinge.rotateAround([1, 0, 0], lidAngle, [0, hingeY, hingeZ]);
+
+// Hinge cylinders (cosmetic)
+const hingeR = baseH * 0.35;
+const hingeLen = 40;
+const hingeL = cylinder(hingeLen, hingeR)
+  .pointAlong([-1, 0, 0])
+  .translate(-w * 0.25 + hingeLen / 2, hingeY, hingeZ);
+const hingeR2 = cylinder(hingeLen, hingeR)
+  .pointAlong([1, 0, 0])
+  .translate(w * 0.25 - hingeLen / 2, hingeY, hingeZ);
+
+return [
+  { name: "Base", shape: base, color: "#2a2a2a" },
+  { name: "Keyboard", shape: keyboard, color: "#1a1a1a" },
+  { name: "Lid", shape: openLid, color: "#2a2a2a" },
+  { name: "Screen", shape: openScreen, color: "#0a0a1a" },
+  { name: "Hinge L", shape: hingeL, color: "#444444" },
+  { name: "Hinge R", shape: hingeR2, color: "#444444" },
+];