forgecad 0.10.4 → 0.11.0

package/examples/api/surface-fill-interior-constraints.forge.js

@@ -0,0 +1,59 @@
+/**
+ * n-sided filled surface pulled onto interior features with `Surface.Fill`.
+ *
+ * `Surface.Fill` already fills any closed loop of n >= 3 boundary curves
+ * (energy-minimizing constrained fill on the OCCT backend). Two optional fields
+ * shape the INTERIOR of that fill without changing the rim:
+ *
+ *  - `through` — interior constraint curves the surface must pass through. They
+ *    are NOT part of the boundary loop; they pull the fill onto an internal
+ *    feature line (here, a raised diagonal spine/crease).
+ *  - `points` — isolated interior points the surface must interpolate (here, a
+ *    single pinned bump lifted above the rim plane).
+ *
+ * The result is an open sheet, so `.thicken()` turns it into a thin solid.
+ * (Interior constraints require the default OCCT exact backend.)
+ */
+
+scene({
+  camera: { position: [120, -150, 110], target: [25, 25, 6], fov: 32 },
+  environment: { preset: 'studio' },
+});
+
+// A near-planar pentagon rim at z = 0 (five corners, five exact edges).
+const corners = [
+  [0, 0, 0],
+  [50, 0, 0],
+  [62, 38, 0],
+  [25, 60, 0],
+  [-12, 38, 0],
+];
+
+function edge(a, b) {
+  return Curve.Fit([corners[a], corners[b]]);
+}
+
+const boundaries = [
+  { name: 'a', curve: edge(0, 1) },
+  { name: 'b', curve: edge(1, 2) },
+  { name: 'c', curve: edge(2, 3) },
+  { name: 'd', curve: edge(3, 4) },
+  { name: 'e', curve: edge(4, 0) },
+];
+
+// Interior crease the fill must ride over: a raised diagonal spine.
+const spine = Curve.Fit([
+  [8, 8, 3],
+  [28, 30, 7],
+  [50, 48, 3],
+]);
+
+const skin = Surface.Fill({
+  boundaries,
+  through: [{ curve: spine }], // pull the fill onto the internal feature line
+  points: [[22, 14, 6]], // pin an interior bump above the rim plane
+}).thicken(1.2);
+
+skin.color('#bcd0d8');
+
+return skin;

package/examples/api/surface-variable-thickness-panel.forge.js

@@ -0,0 +1,62 @@
+/**
+ * Variable-thickness surface panel.
+ *
+ * `Surface.Net()` builds the carrier sheet. `Thickness.grid()` defines a scalar
+ * UV wall field, so the panel can be thin at one edge, thicker through the load
+ * path, and locally reinforced near one corner without hand-offset geometry.
+ */
+
+scene({
+  background: { top: '#eef4f7', bottom: '#f9fbfd' },
+  camera: { position: [150, -190, 92], target: [0, 0, 8], fov: 34 },
+  environment: { preset: 'studio', intensity: 0.25, background: false },
+  ground: { visible: true, color: '#d6dde3', height: -5, receiveShadow: true },
+});
+
+const panelWidth = param('Panel Width', 128);
+const panelDepth = param('Panel Depth', 82);
+const crownHeight = param('Crown Height', 15);
+
+const uCount = 6;
+const vCount = 5;
+const panelCage = [];
+
+for (let i = 0; i <= uCount; i++) {
+  const u = i / uCount;
+  const x = (u - 0.5) * panelWidth;
+  const row = [];
+
+  for (let j = 0; j <= vCount; j++) {
+    const v = j / vCount;
+    const y = (v - 0.5) * panelDepth;
+    const xProfile = 1 - (2 * u - 1) ** 2;
+    const yProfile = 1 - 0.42 * (2 * v - 1) ** 2;
+    const diagonalBias = 2.8 * u * (1 - v);
+    row.push([x, y, crownHeight * xProfile * yProfile + diagonalBias]);
+  }
+
+  panelCage.push(row);
+}
+
+const panel = Surface.Net()
+  .cage(panelCage)
+  .degree(3, 3)
+  .thickenInsideBy(
+    Thickness.grid(
+      [
+        [1.1, 1.3, 1.5],
+        [1.8, 2.4, 2.9],
+        [2.8, 3.5, 4.2],
+      ],
+      { easing: 'easeInOut' },
+    ),
+    { resolution: 56 },
+  )
+  .color('#5c8fb5')
+  .material({ roughness: 0.62, metalness: 0.04, clearcoat: 0.12 });
+
+verify.notEmpty('Variable-thickness panel produces solid geometry', panel);
+verify.volumeApprox('Variable thickness stays in the expected volume range', panel, panelWidth * panelDepth * 2.55, 6000);
+verify.physicalComponentCount('Variable-thickness panel is one connected component', 1);
+
+return [{ name: 'Variable Thickness Panel', shape: panel }];

package/examples/mechanical/airplane-propeller.forge.js

@@ -16,6 +16,13 @@
 //
 //   Thickness:  24% at root (structural) → 6% at tip (aerodynamic)
 //   Camber:     4% at root → 1.5% at tip (Cl margin at low-speed root)
+//
+//   Skin:       The blade is lofted through the closed airfoil sections with
+//               Shape.fromSlices — an ordered slice loft that keeps a smooth
+//               section-to-section correspondence, so the blade reads class-A
+//               (no spanwise faceting) even on the default Manifold backend.
+//               Run with `--backend truck` (or occt) for an exact kernel-native
+//               NURBS solid — preferred for STEP export.
 
 // ─── Design Parameters ──────────────────────────────────────────
 const diameter    = Param.number("Diameter",       1900, { min: 1200, max: 2600, unit: "mm" });
@@ -171,49 +178,98 @@ function camberAt(rNorm) {
 //   - Zero pitch → chord along tangential (Y in world)
 //   - Positive β → leading edge tilts toward thrust axis (+Z)
 
-const NUM_STATIONS = 24;
-const NACA_PTS     = 40;      // points per airfoil surface (80 total outline)
+const NUM_STATIONS = 28;      // a few more stations than the old loft for a smoother span
+const NACA_PTS     = 48;      // points per airfoil surface (96 total outline)
 const CAMBER_POS   = 0.4;     // max camber at 40% chord (standard for props)
 const rRoot        = rHub * 0.55;  // blade shank starts inside the spinner
 
-// Airfoil section at a given normalized span position (clamped to the
-// aerodynamic range — the shank inside the spinner reuses the hub section).
-function bladeSection(rNorm, r) {
+// Airfoil section as a 2D point list (before it becomes a Sketch), already
+// rotated for twist. The buried shank can blend toward a fuller, rounder cuff:
+//   rNorm  — normalized span for the aerodynamic distributions
+//   r      — true radius (drives the BEMT twist)
+//   fatten — root-cuff blend 0..1: 0 = pure airfoil, 1 = fully rounded fat
+//            shank. Pulls each outline point toward an enclosing ellipse so the
+//            blade meets the spinner with a beefy, non-spindly junction instead
+//            of necking down to a thin stalk (the old root-quality defect).
+function bladeSectionPoints(rNorm, r, fatten) {
   const chord  = chordAt(rNorm);
   const thick  = thicknessRatioAt(rNorm);
   const camber = camberAt(rNorm);
   const twist  = twistAt(Math.max(r, rHub));
 
   let pts = nacaPoints(camber, CAMBER_POS, thick, chord, NACA_PTS);
-  pts = rotate2D(pts, 90 + twist);  // 90° aligns chord with tangential, +twist adds pitch
-  return polygon(pts);
+
+  if (fatten > 0) {
+    // Blend toward an enclosing ellipse centered at the quarter-chord origin —
+    // fills the thin airfoil into a fuller shank without changing the point
+    // count or ordering, so the loft keeps a clean ordered correspondence.
+    const exA = chord * 0.34;                                  // half-length along chord
+    const exB = Math.max(chord * thick * 0.62, chord * 0.16);  // half-thickness, floored fat
+    pts = pts.map(([x, y]) => {
+      const ang = Math.atan2(y, x);
+      const ex = exA * Math.cos(ang);
+      const ey = exB * Math.sin(ang);
+      return [x + (ex - x) * fatten, y + (ey - y) * fatten];
+    });
+  }
+
+  // 90° aligns chord with the tangential direction; +twist adds pitch.
+  return rotate2D(pts, 90 + twist);
 }
 
-const profiles = [];
-const heights  = [];
+function bladeSection(rNorm, r, fatten) {
+  return polygon(bladeSectionPoints(rNorm, r, fatten || 0));
+}
 
-// Shank stations buried inside the spinner — a constant hub section carries
-// the blade to a structural attachment instead of floating at the hub surface.
-for (const r of [rRoot, rHub * 0.92]) {
-  profiles.push(bladeSection(0, rHub));
-  heights.push(r);
+// Ordered station list: span coordinate (world X, radial in the disk) + the
+// closed airfoil section's points. Sections sit perpendicular to X, so the
+// blade extends radially with no post-loft rotation.
+const stationX = [];
+const stationPoints = [];
+
+// Two buried shank stations inside the spinner: the deepest is a fully round
+// cuff, the next blends back toward the airfoil so the aero blade grows
+// smoothly out of the shank instead of pinching at the hub.
+const shankStations = [
+  { x: rRoot,       fatten: 1.0  },
+  { x: rHub * 0.86, fatten: 0.55 },
+];
+for (const { x, fatten } of shankStations) {
+  stationX.push(x);
+  stationPoints.push(bladeSectionPoints(0, rHub, fatten));
 }
 
 // Aerodynamic stations from the hub surface to the tip. Cosine spacing
 // clusters stations at the root (where the BEMT twist gradient is steepest)
-// and at the tip (where the planform rounds off).
+// and at the tip (where the planform rounds off). A light residual cuff on the
+// first aero stations avoids a sudden chord/thickness step at the hub line.
 for (let i = 0; i <= NUM_STATIONS; i++) {
-  const rNorm = 0.5 - 0.5 * Math.cos(Math.PI * i / NUM_STATIONS);
-  const r     = rHub + rNorm * (R - rHub);
-  profiles.push(bladeSection(rNorm, r));
-  heights.push(r);
+  const rNorm  = 0.5 - 0.5 * Math.cos(Math.PI * i / NUM_STATIONS);
+  const r      = rHub + rNorm * (R - rHub);
+  const fatten = rNorm < 0.06 ? 0.25 * (1 - rNorm / 0.06) : 0;
+  stationX.push(r);
+  stationPoints.push(bladeSectionPoints(rNorm, r, fatten));
 }
 
-// Loft all profiles into a smooth blade solid
-const bladeRaw = loft(profiles, heights, { edgeLength: meshRes });
-
-// Rotate blade from Z-axis (span) to X-axis (radial in propeller disk)
-const blade = bladeRaw.rotateY(90);
+// Loft the closed sections into a smooth blade solid. Shape.fromSlices keeps an
+// ordered, smooth section-to-section correspondence (no SDF faceting). On the
+// default Manifold backend edgeLength tunes the mesh; the truck/occt kernel
+// ignores it and builds an exact NURBS solid.
+const blade = Shape.fromSlices(
+  stationX.map((x, i) => Shape.slicePerpendicularToX(x, polygon(stationPoints[i]))),
+  { edgeLength: meshRes },
+);
+
+// Blade-shaped cutouts through the spinner: the same ordered sections grown
+// ~5% for running clearance, lofted the same exact way so the cut tracks the
+// blade skin (keeping the span direction exact).
+const CLEARANCE = 1.05;
+const bladeCutout = Shape.fromSlices(
+  stationX.map((x, i) => Shape.slicePerpendicularToX(
+    x, polygon(stationPoints[i].map(([px, py]) => [px * CLEARANCE, py * CLEARANCE])),
+  )),
+  { edgeLength: meshRes },
+);
 
 // ─── Spinner / Hub ──────────────────────────────────────────────
 //
@@ -269,10 +325,7 @@ const hubBarrel = cylinder(spinnerLen * 0.5, rHub * 0.62)
 
 const bladeAssembly = union(allBlades, hubBarrel);
 
-// Blade-shaped cutouts through the spinner with a small running
-// clearance: the blade cross-section is grown in chord and thickness
-// (x/y before the radial rotation), keeping the span direction exact.
-const bladeCutout = bladeRaw.scale([1.04, 1.04, 1]).rotateY(90);
+// Pattern the blade-shaped cutouts (defined with the blade above) around the disk.
 const spinnerCutouts = circularPattern(bladeCutout, numBlades);
 
 // ─── Optional: Airfoil Section Visualization ────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://forgecad.io",
@@ -44,6 +44,9 @@
       "export": {
         "description": "Export Forge models to manufacturing, simulation, and exchange formats."
       },
+      "fea": {
+        "description": "Run, inspect, render, compare, and check structural FEA studies."
+      },
       "inspect": {
         "description": "Inspect ForgeCAD models with targeted visual, physical, and manufacturing evidence."
       },
@@ -112,7 +115,7 @@
     "dev:cli": "npm run build:solver:if-missing && npm run build:geometry:if-missing && tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --sourcemap --external typescript && node scripts/copy-cli-assets.mjs dist-cli",
     "build:cli": "npm run build:solver:if-missing && npm run build:geometry:if-missing && tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --clean --external typescript && node scripts/copy-cli-assets.mjs dist-cli",
     "build:native-occt": "node scripts/build-native-occt.mjs",
-    "build:backend": "npm run build:native-occt && tsup apps/backend/src/server.ts apps/backend/src/nativeOcctWorker.ts --format esm --platform node --target node20 --out-dir dist-backend --clean --sourcemap",
+    "build:backend": "npm run build:geometry:if-missing && npm run build:native-occt && tsup apps/backend/src/server.ts apps/backend/src/nativeOcctWorker.ts --format esm --platform node --target node20 --out-dir dist-backend --clean --sourcemap && node scripts/copy-wasm-assets.mjs dist-backend",
     "build:binary": "node scripts/build-binary.mjs",
     "build:binary:all": "node scripts/build-binary.mjs --all",
     "bundle:offline": "node scripts/build-install-bundle.mjs",