forgecad 0.6.3 → 0.8.0

package/examples/api/variable-sweep-pure-sdf-test.forge.js

@@ -0,0 +1,162 @@
+// Pure-SDF reference for the variableSweep taper test.
+// If this renders with clean sidewalls while variable-sweep-test.forge.js does not,
+// the artifact is in variableSweep()'s spine field construction rather than the
+// shared SDF meshing pipeline.
+
+const controlPoints = [
+  [0, 0, 0],
+  [20, 0, 10],
+  [40, 10, 20],
+  [60, 10, 30],
+];
+
+const spine = spline3d(controlPoints, { tension: 0.4 });
+const pathPoints = spine.sample(160);
+
+const cumulativeLengths = [0];
+for (let index = 1; index < pathPoints.length; index += 1) {
+  const [ax, ay, az] = pathPoints[index - 1];
+  const [bx, by, bz] = pathPoints[index];
+  cumulativeLengths.push(
+    cumulativeLengths[cumulativeLengths.length - 1] + Math.hypot(bx - ax, by - ay, bz - az),
+  );
+}
+const totalLength = cumulativeLengths[cumulativeLengths.length - 1];
+
+const smallRadius = 3;
+const largeRadius = 8;
+const maxRadius = largeRadius;
+const pad = maxRadius + 4;
+
+let minX = Infinity;
+let minY = Infinity;
+let minZ = Infinity;
+let maxX = -Infinity;
+let maxY = -Infinity;
+let maxZ = -Infinity;
+for (const [x, y, z] of pathPoints) {
+  minX = Math.min(minX, x);
+  minY = Math.min(minY, y);
+  minZ = Math.min(minZ, z);
+  maxX = Math.max(maxX, x);
+  maxY = Math.max(maxY, y);
+  maxZ = Math.max(maxZ, z);
+}
+
+const embeddedPath = JSON.stringify(pathPoints);
+const embeddedArc = JSON.stringify(cumulativeLengths);
+
+const pureSweepSdf = new Function(`
+  return (x, y, z) => (() => {
+    const pts = ${embeddedPath};
+    const arc = ${embeddedArc};
+    const totalLength = ${totalLength};
+    const smallRadius = ${smallRadius};
+    const largeRadius = ${largeRadius};
+
+    function clamp(v, lo, hi) {
+      return Math.max(lo, Math.min(hi, v));
+    }
+
+    function catmullScalar(p0, p1, p2, p3, t0, t1, t2, t3, t) {
+      const dt = Math.max(t2 - t1, 1e-9);
+      const local = clamp((t - t1) / dt, 0, 1);
+      const tt = local * local;
+      const ttt = tt * local;
+      const m1 = (p2 - p0) / Math.max(t2 - t0, 1e-9);
+      const m2 = (p3 - p1) / Math.max(t3 - t1, 1e-9);
+      const h00 = 2 * ttt - 3 * tt + 1;
+      const h10 = ttt - 2 * tt + local;
+      const h01 = -2 * ttt + 3 * tt;
+      const h11 = ttt - tt;
+      return h00 * p1 + h10 * dt * m1 + h01 * p2 + h11 * dt * m2;
+    }
+
+    function radiusAt(t) {
+      const tc = clamp(t, 0, 1);
+      if (tc <= 0) return smallRadius;
+      if (tc >= 1) return smallRadius;
+      if (tc <= 0.5) return catmullScalar(smallRadius, smallRadius, largeRadius, smallRadius, -0.5, 0, 0.5, 1, tc);
+      return catmullScalar(smallRadius, largeRadius, smallRadius, smallRadius, 0, 0.5, 1, 1.5, tc);
+    }
+
+    let bestDist2 = Infinity;
+    let bestIndex = 0;
+    let bestSegmentT = 0;
+    let bestPoint = pts[0];
+
+    for (let index = 0; index < pts.length - 1; index += 1) {
+      const a = pts[index];
+      const b = pts[index + 1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len2 = dx * dx + dy * dy + dz * dz;
+      if (len2 < 1e-12) continue;
+
+      const px = x - a[0];
+      const py = y - a[1];
+      const pz = z - a[2];
+      const segT = clamp((px * dx + py * dy + pz * dz) / len2, 0, 1);
+      const qx = a[0] + dx * segT;
+      const qy = a[1] + dy * segT;
+      const qz = a[2] + dz * segT;
+      const rx = x - qx;
+      const ry = y - qy;
+      const rz = z - qz;
+      const dist2 = rx * rx + ry * ry + rz * rz;
+
+      if (dist2 < bestDist2) {
+        bestDist2 = dist2;
+        bestIndex = index;
+        bestSegmentT = segT;
+        bestPoint = [qx, qy, qz];
+      }
+    }
+
+    const radiusT = (arc[bestIndex] + (arc[bestIndex + 1] - arc[bestIndex]) * bestSegmentT) / Math.max(totalLength, 1e-9);
+    let sdfValue = Math.sqrt(bestDist2) - radiusAt(radiusT);
+
+    if (bestIndex === 0 && bestSegmentT <= 1e-6) {
+      const a = pts[0];
+      const b = pts[1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (len > 1e-9) {
+        const tx = dx / len;
+        const ty = dy / len;
+        const tz = dz / len;
+        const startCap = -((x - a[0]) * tx + (y - a[1]) * ty + (z - a[2]) * tz);
+        sdfValue = Math.max(sdfValue, startCap);
+      }
+    } else if (bestIndex === pts.length - 2 && bestSegmentT >= 1 - 1e-6) {
+      const a = pts[pts.length - 2];
+      const b = pts[pts.length - 1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (len > 1e-9) {
+        const tx = dx / len;
+        const ty = dy / len;
+        const tz = dz / len;
+        const endCap = (x - b[0]) * tx + (y - b[1]) * ty + (z - b[2]) * tz;
+        sdfValue = Math.max(sdfValue, endCap);
+      }
+    }
+
+    return sdfValue;
+  })();
+`)();
+
+const tapered = sdf.fromFunction(
+  pureSweepSdf,
+  {
+    min: [minX - pad, minY - pad, minZ - pad],
+    max: [maxX + pad, maxY + pad, maxZ + pad],
+  },
+).toShape({ edgeLength: 0.8 });
+
+return tapered.color('#8899aa');

package/examples/api/variable-sweep-test.forge.js

@@ -8,8 +8,8 @@ const spine = spline3d([
   [60, 10, 30],
 ], { tension: 0.4 });
 
-const smallCircle = circle2d(3, 24);
-const largeCircle = circle2d(8, 24);
+const smallCircle = circle2d(3);
+const largeCircle = circle2d(8);
 
 const tapered = variableSweep(spine, [
   { t: 0.0, profile: smallCircle },

package/examples/api/wood-joinery.forge.js

@@ -0,0 +1,60 @@
+// Wood Joinery — dado, rabbet, mortise & tenon
+// Demonstrates joint cuts and assembled positioning.
+
+const t = 18; // stock thickness
+
+// ─── BOOKCASE CORNER ───────────────────────────────────────────
+// Side panel lies flat: width=250 (X, depth), height=400 (Y, vertical), thickness=18 (Z, face)
+const side = Wood.board(250, 400, t, { species: 'birch' });
+const shelf = Wood.board(250, 300, t, { species: 'birch' });
+
+// Dado: channel across the face of side for shelf to sit in
+Wood.dado(side, shelf, { fromBottom: 150 });
+
+// Rabbet: step on the back face for a back panel
+Wood.rabbet(side, { edge: 'back', width: 6, depth: 9 });
+
+// Assemble the bookcase corner:
+// Side panel stands upright — rotate so Y (400mm) becomes vertical (Z)
+const sideAssembled = side.shape.rotateX(90).color('#c4956a');
+
+// Shelf sits in the dado channel
+// After side.rotateX(90): side is in XZ plane, dado channel is at Z = -200 + 150 + 9 = -41
+// Shelf needs its 18mm thickness edge in the dado
+const shelfAssembled = shelf.shape
+  .rotateX(90)        // stand upright
+  .rotateZ(90)        // perpendicular to side
+  .translate(0, t, -200 + 150 + t / 2)
+  .color('#b8864e');
+
+// ─── TABLE JOINT: MORTISE & TENON ──────────────────────────────
+// Leg: width=45 (X), height=400 (Y, vertical), thickness=45 (Z, face for mortise)
+// The mortise cuts into Z (45mm face), positioned along Y (400mm height)
+const leg = Wood.board(45, 400, 45, { species: 'oak' });
+const apron = Wood.board(300, 80, 20, { species: 'oak' });
+
+Wood.mortiseAndTenon(leg, apron, {
+  style: 'blind',
+  position: { fromTop: 25 },
+  cornerRadius: 4,
+});
+
+// Tenon defaults: thickness = 20/3 ≈ 6.7mm, width = min(48, 320) = 48mm, length = 45*2/3 = 30mm
+
+// Assemble: leg stands on its Y-axis (already vertical), apron connects to face
+const legAssembled = leg.shape
+  .translate(500, 0, 0)
+  .color('#a07040');
+
+// Apron: tenon protrudes from +X end. Rotate so it points into the leg's Z-face.
+const apronAssembled = apron.shape
+  .rotateY(90)                        // tenon now points +Z (into leg face)
+  .translate(500, 200 - 25 - 24, 45)  // align with mortise position on leg
+  .color('#8b6030');
+
+return [
+  { name: 'Side (dado + rabbet)', shape: sideAssembled },
+  { name: 'Shelf', shape: shelfAssembled },
+  { name: 'Leg (mortise)', shape: legAssembled },
+  { name: 'Apron (tenon)', shape: apronAssembled },
+];

package/examples/compiler-corpus/enclosure-shell-cuts.forge.js

@@ -1,9 +1,9 @@
 // Guard part: shell + face-driven cuts + mirrored feet in one ordinary enclosure workflow.
 
-const base = roundedRect(120, 80, 10, true).extrude(36);
+const base = roundedRect(120, 80, 10).extrude(36);
 const shell = base.shell(3, { openFaces: ['top'] });
 
-const displayCut = roundedRect(34, 18, 3, true)
+const displayCut = roundedRect(34, 18, 3)
   .onFace(base, 'front', { u: 0, v: 8, protrude: 0.25, selfAnchor: 'center' })
   .extrude(10);
 
@@ -11,7 +11,7 @@ const cableCut = circle2d(7)
   .onFace(base, 'right', { u: -12, v: -8, protrude: 0.25, selfAnchor: 'center' })
   .extrude(10);
 
-const foot = roundedRect(18, 18, 4, true)
+const foot = roundedRect(18, 18, 4)
   .onFace(base, 'bottom', { u: 36, v: 20, protrude: 0, selfAnchor: 'center' })
   .extrude(6);
 

package/examples/compiler-corpus/fastener-plate-variants.forge.js

@@ -1,11 +1,11 @@
 // Guard part: counterbore/countersink hole variants plus an up-to-face service pocket in one ordinary plate workflow.
 
-const plate = roundedRect(118, 76, 8, true).extrude(18);
+const plate = roundedRect(118, 76, 8).extrude(18);
 const entryFace = plate.face('top');
 const exitFace = plate.face('bottom');
 const pocketExitFace = plate.face('side-top');
 
-const servicePocket = roundedRect(34, 18, 4, true)
+const servicePocket = roundedRect(34, 18, 4)
   .onFace(plate, 'front', { u: 0, v: -2, selfAnchor: 'center' });
 
 const fastenerPlate = plate

package/examples/constraints/01-fully-constrained-rect.forge.js

@@ -21,7 +21,7 @@ sk.horizontal(bottom);
 sk.vertical(right);
 sk.parallel(bottom, top);
 sk.parallel(right, left);
-sk.length(bottom, param("width", 40, { unit: "mm" }));
-sk.length(right, param("height", 30, { unit: "mm" }));
+sk.length(bottom, Param.number("width", 40, { unit: "mm" }));
+sk.length(right, Param.number("height", 30, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/02-underconstrained-triangle.forge.js

@@ -17,6 +17,6 @@ sk.addLoop([p1, p2, p3]);
 // Only constrain shape, not position
 sk.equal(l1, l2);
 sk.equal(l1, l3);
-sk.length(l1, param("side", 20, { unit: "mm" }));
+sk.length(l1, Param.number("side", 20, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/03-redundant-constraints.forge.js

@@ -24,7 +24,7 @@ sk.absoluteAngle(lBottom, 0);  // line must be at 0 degrees (= horizontal)
 sk.vertical(lRight);
 sk.vertical(lLeft);
 sk.horizontal(lTop);
-sk.length(lBottom, param("width", 10, { unit: "mm" }));
-sk.length(lRight, param("height", 5, { unit: "mm" }));
+sk.length(lBottom, Param.number("width", 10, { unit: "mm" }));
+sk.length(lRight, Param.number("height", 5, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/05-parallel-with-linedistance.forge.js

@@ -20,10 +20,10 @@ sk.addLoop([p1, p2, p4, p3]);
 sk.fix(p1);
 sk.horizontal(bottom);
 sk.vertical(left);
-sk.length(bottom, param("width", 20, { unit: "mm" }));
+sk.length(bottom, Param.number("width", 20, { unit: "mm" }));
 
 // lineDistance already implies parallel:
-sk.lineDistance(bottom, top, param("height", 10, { unit: "mm" }));
+sk.lineDistance(bottom, top, Param.number("height", 10, { unit: "mm" }));
 sk.parallel(bottom, top);  // redundant — lineDistance already forces parallel
 
 sk.parallel(left, right);

package/examples/constraints/06-complex-spectrogram.forge.js

@@ -1,4 +1,4 @@
-const width = param('width', 39);
+const width = Param.number('width', 39);
 
 /** Create an open polyline of `count` segments from startPoint to endPoint. */
 function polyline(sk, startPoint, endPoint, count) {

package/examples/constraints/07-perpendicular-chain.forge.js

@@ -20,9 +20,9 @@ sk.absoluteAngle(l1, 0);
 sk.perpendicular(l1, l2);
 sk.perpendicular(l2, l3);
 sk.perpendicular(l3, l4);
-sk.length(l1, param("seg1", 20, { unit: "mm" }));
-sk.length(l2, param("seg2", 15, { unit: "mm" }));
-sk.length(l3, param("seg3", 15, { unit: "mm" }));
-sk.length(l4, param("seg4", 15, { unit: "mm" }));
+sk.length(l1, Param.number("seg1", 20, { unit: "mm" }));
+sk.length(l2, Param.number("seg2", 15, { unit: "mm" }));
+sk.length(l3, Param.number("seg3", 15, { unit: "mm" }));
+sk.length(l4, Param.number("seg4", 15, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/08-symmetric-bracket.forge.js

@@ -47,9 +47,9 @@ sk.vertical(lLeft);
 sk.horizontal(lLeftTop);
 sk.vertical(lLeftUp);
 
-sk.length(lBottom, param("base_width", 50, { unit: "mm" }));
-sk.length(lLeft, param("leg_height", 20, { unit: "mm" }));
-sk.length(lLeftTop, param("step_width", 15, { unit: "mm" }));
-sk.length(lLeftUp, param("top_height", 20, { unit: "mm" }));
+sk.length(lBottom, Param.number("base_width", 50, { unit: "mm" }));
+sk.length(lLeft, Param.number("leg_height", 20, { unit: "mm" }));
+sk.length(lLeftTop, Param.number("step_width", 15, { unit: "mm" }));
+sk.length(lLeftUp, Param.number("top_height", 20, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/09-stress-spiral.forge.js

@@ -6,7 +6,7 @@
 const sk = constrainedSketch();
 
 const N = 50; // number of segments
-const SEG_LEN = param("seg_len", 5, { unit: "mm" });
+const SEG_LEN = Param.number("seg_len", 5, { unit: "mm" });
 
 // Build a spiral: each segment turns 90° left from the previous,
 // with increasing runs (1,1,2,2,3,3,4,4,...) to form a square spiral.

package/examples/constraints/10-stress-honeycomb.forge.js

@@ -8,7 +8,7 @@ const sk = constrainedSketch();
 
 const COLS = 3;
 const ROWS = 2;
-const SIDE = param("cell_size", 8, { unit: "mm" });
+const SIDE = Param.number("cell_size", 8, { unit: "mm" });
 
 // Flat-top hex: vertex 0 at 0° (right), CCW
 const vAngles = [0, 60, 120, 180, 240, 300].map(d => d * Math.PI / 180);

package/examples/constraints/11-surface-grid.forge.js

@@ -6,8 +6,8 @@
 
 const sk = constrainedSketch();
 
-const W = param("width", 150, { unit: "mm" });
-const H = param("height", 100, { unit: "mm" });
+const W = Param.number("width", 150, { unit: "mm" });
+const H = Param.number("height", 100, { unit: "mm" });
 
 // Outer box corners
 const p00 = sk.point(0, 0);

package/examples/constraints/12-surface-nested.forge.js

@@ -6,10 +6,10 @@
 
 const sk = constrainedSketch();
 
-const OW = param("outer_w", 120, { unit: "mm" });
-const OH = param("outer_h", 100, { unit: "mm" });
-const IW = param("inner_w", 60, { unit: "mm" });
-const IH = param("inner_h", 50, { unit: "mm" });
+const OW = Param.number("outer_w", 120, { unit: "mm" });
+const OH = Param.number("outer_h", 100, { unit: "mm" });
+const IW = Param.number("inner_w", 60, { unit: "mm" });
+const IH = Param.number("inner_h", 50, { unit: "mm" });
 
 // Outer rectangle
 const o1 = sk.point(0, 0);

package/examples/constraints/13-surface-complex.forge.js

@@ -5,7 +5,7 @@
 
 const sk = constrainedSketch();
 
-const SIZE = param("size", 60, { unit: "mm" });
+const SIZE = Param.number("size", 60, { unit: "mm" });
 
 // L-shape vertices (going CCW)
 //   (0,60)────(60,60)

package/examples/exact-arc-housing.forge.js

@@ -0,0 +1,12 @@
+// Bearing housing with exact circular arc (not polyline-approximated)
+const profile = path()
+  .moveTo(0, 0)
+  .lineTo(50, 0)
+  .lineTo(50, 10)
+  .exactArcTo(40, 20, { radius: 10 })
+  .lineTo(0, 20)
+  .close();
+
+const housing = profile.extrude(30);
+const bore = cylinder(30, 8).translate(25, 10, 0);
+return difference(housing, bore);

package/examples/experiments/drone-arm.forge.js

@@ -0,0 +1,53 @@
+// Smooth drone arm: flat rectangular mount → organic taper → circular motor mount
+// Tests: cross-section morphing, S-curve sweep, shell, G2 transitions
+
+// --- Spine: gentle S-curve from origin to motor mount ---
+const armLength = 120;
+const spine = spline3d([
+  [0, 0, 0],
+  [armLength * 0.3, 0, 8],
+  [armLength * 0.7, 0, -5],
+  [armLength, 0, 3],
+], { tension: 0.3 });
+
+// --- Cross-sections ---
+
+// Mount end: flat rectangle with rounded corners
+const mountProfile = roundedRect(20, 6, 1.5);
+
+// Mid-section: transitional rounded rectangle
+const midProfile = roundedRect(14, 10, 4);
+
+// Motor end: circle
+const motorProfile = circle2d(8);
+
+// --- Variable sweep: morph between profiles along spine ---
+const solidArm = variableSweep(spine, [
+  { t: 0, profile: mountProfile },
+  { t: 0.4, profile: midProfile },
+  { t: 1, profile: motorProfile },
+], { edgeLength: 1.5 });
+
+// --- Hollow it out ---
+const arm = solidArm.shell(1.5);
+
+// --- Mounting holes at the flat end ---
+const mountHole = cylinder(10, 2).translate(0, 0, -5);
+const mountHoles = union(
+  mountHole.translate(-6, 0, 0),
+  mountHole.translate(6, 0, 0),
+);
+
+// --- Motor mount ring at the far end ---
+// Place at the end of the spine
+const motorRing = difference(
+  cylinder(4, 10),
+  cylinder(4, 7),
+).translate(armLength, 0, 3);
+
+const result = difference(
+  union(arm, motorRing),
+  mountHoles,
+);
+
+return result;

package/examples/furniture/adjustable-table.forge.js

@@ -5,19 +5,19 @@
 // BUILD NOTES (at bottom of file):
 // Materials, dimensions, and assembly instructions for actually building this.
 
-const topW = param("Top Width", 120, { min: 80, max: 200, unit: "cm" });
-const topD = param("Top Depth", 60, { min: 40, max: 100, unit: "cm" });
-const topThick = param("Top Thickness", 3, { min: 2, max: 5, unit: "cm" });
-const minH = param("Min Height", 72, { min: 60, max: 80, unit: "cm" });
-const maxH = param("Max Height", 120, { min: 100, max: 140, unit: "cm" });
-const heightPct = param("Height %", 30, { min: 0, max: 100, unit: "%" });
-const outerLeg = param("Outer Leg", 6, { min: 4, max: 10, unit: "cm" });
-const innerLeg = param("Inner Leg", 4, { min: 3, max: 8, unit: "cm" });
-const legWall = param("Leg Wall", 0.3, { min: 0.2, max: 0.5, unit: "cm" });
-const inset = param("Leg Inset", 5, { min: 2, max: 15, unit: "cm" });
-const braceW = param("Brace Width", 3, { min: 2, max: 5, unit: "cm" });
-const braceH = param("Brace Height", 1.5, { min: 1, max: 3, unit: "cm" });
-const crankR = param("Crank Radius", 8, { min: 5, max: 15, unit: "cm" });
+const topW = Param.number("Top Width", 120, { min: 80, max: 200, unit: "cm" });
+const topD = Param.number("Top Depth", 60, { min: 40, max: 100, unit: "cm" });
+const topThick = Param.number("Top Thickness", 3, { min: 2, max: 5, unit: "cm" });
+const minH = Param.number("Min Height", 72, { min: 60, max: 80, unit: "cm" });
+const maxH = Param.number("Max Height", 120, { min: 100, max: 140, unit: "cm" });
+const heightPct = Param.number("Height %", 30, { min: 0, max: 100, unit: "%" });
+const outerLeg = Param.number("Outer Leg", 6, { min: 4, max: 10, unit: "cm" });
+const innerLeg = Param.number("Inner Leg", 4, { min: 3, max: 8, unit: "cm" });
+const legWall = Param.number("Leg Wall", 0.3, { min: 0.2, max: 0.5, unit: "cm" });
+const inset = Param.number("Leg Inset", 5, { min: 2, max: 15, unit: "cm" });
+const braceW = Param.number("Brace Width", 3, { min: 2, max: 5, unit: "cm" });
+const braceH = Param.number("Brace Height", 1.5, { min: 1, max: 3, unit: "cm" });
+const crankR = Param.number("Crank Radius", 8, { min: 5, max: 15, unit: "cm" });
 
 // Current height based on slider
 const currentH = minH + (maxH - minH) * heightPct / 100;
@@ -75,7 +75,7 @@ for (const [lx, ly] of legPositions) {
       // Through-hole in Y direction
       pinHoles.push(
         cylinder(outerLeg + 2, pinHoleR)
-          .rotateAround([0, 0, 0], 90, 0, 0)
+          .rotateX(90)
           .translate(legCenterX, ly - 1, pz)
       );
     }
@@ -105,7 +105,7 @@ const shaftY = inset + outerLeg / 2;
 const shaftZ = legH - outerLegH + 25;
 const shaftLen = topW - 2 * inset;
 const shaft = cylinder(shaftLen, 0.8)
-  .rotateAround([0, 0, 0], 0, 90, 0)
+  .rotateY(90)
   .translate(inset, shaftY, shaftZ);
 
 // Crank handle (on the right side)