forgecad 0.9.15 → 0.10.0

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

@@ -121,20 +121,28 @@ function twistAt(r) {
   return Math.atan(Math.tan(pitchAngle * DEG) * 0.75 * R / r) / DEG;
 }
 
-// Chord: GA propeller distribution — structural root + Betz-optimal taper.
-// Peaks near 25% span, maintains width at root for structural attachment,
-// smooth cosine taper to tip.
+// Chord: GA propeller distribution — structural root + Betz-optimal taper,
+// closed by an elliptical rounded tip. Peaks near 25% span, maintains width
+// at root for structural attachment, cosine taper to 92% span, then an
+// elliptical arc rounds the tip in planform (real propellers never taper to
+// a razor point — the tip cap needs finite chord to close cleanly).
+const TIP_ROUND_START = 0.92;
+
 function chordAt(rNorm) {
-  const r = rNorm;
+  const r = Math.min(rNorm, TIP_ROUND_START);
   // Root: rises from 55% at hub to 100% at ~25% span
   const rootRise = r < 0.25
     ? 0.55 + 0.45 * Math.pow(r / 0.25, 0.7)
     : 1.0;
-  // Cosine taper from peak to tip (exponent < 1 for fuller planform)
+  // Cosine taper from peak to the start of the tip round
   const tipTaper = r < 0.25
     ? 1.0
     : Math.pow(Math.cos(Math.PI / 2 * ((r - 0.25) / 0.75)), 0.5);
-  return maxChord * rootRise * tipTaper;
+  const base = maxChord * rootRise * tipTaper;
+  if (rNorm <= TIP_ROUND_START) return base;
+  // Elliptical closure from 92% span to the tip, floored for a clean cap
+  const s = (rNorm - TIP_ROUND_START) / (1 - TIP_ROUND_START);
+  return Math.max(base * Math.sqrt(Math.max(0, 1 - s * s)), maxChord * 0.05);
 }
 
 // Thickness ratio: thick root for structure, thin tip for aero.
@@ -163,27 +171,41 @@ function camberAt(rNorm) {
 //   - Zero pitch → chord along tangential (Y in world)
 //   - Positive β → leading edge tilts toward thrust axis (+Z)
 
-const NUM_STATIONS = 12;
+const NUM_STATIONS = 24;
 const NACA_PTS     = 40;      // points per airfoil surface (80 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
 
-const profiles = [];
-const heights  = [];
-
-for (let i = 0; i <= NUM_STATIONS; i++) {
-  const rNorm = i / NUM_STATIONS;
-  const r     = rHub + rNorm * (R - rHub);
-
-  const chord = Math.max(chordAt(rNorm), 5);  // minimum 5mm to avoid degenerate polygon
-  const thick = thicknessRatioAt(rNorm);
+// 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) {
+  const chord  = chordAt(rNorm);
+  const thick  = thicknessRatioAt(rNorm);
   const camber = camberAt(rNorm);
-  const twist = twistAt(r);
+  const twist  = twistAt(Math.max(r, rHub));
 
-  // Generate NACA points and rotate to blade orientation
   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);
+}
+
+const profiles = [];
+const heights  = [];
 
-  profiles.push(polygon(pts));
+// 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);
+}
+
+// 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).
+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);
 }
 
@@ -195,24 +217,27 @@ const blade = bladeRaw.rotateY(90);
 
 // ─── Spinner / Hub ──────────────────────────────────────────────
 //
-// Ogive spinner: parabolic nose + cylindrical body + rear taper.
+// Ogive spinner: elliptical nose + cylindrical body + rear taper.
 // Built as a loft of circular profiles along the propeller axis (Z).
+// The cylindrical body is centered on the blade plane (z = 0) so the
+// blade shanks bury fully into the spinner at maximum radius.
 
 const spinnerLen = hubDiameter * 1.3;
 const spinnerR   = rHub * 0.95;
-const HUB_STATIONS = 10;
+const HUB_STATIONS = 36;
 
 const hubProfiles = [];
 const hubHeights  = [];
 
 for (let i = 0; i <= HUB_STATIONS; i++) {
-  const t = i / HUB_STATIONS;   // 0 = nose (front), 1 = back
+  // Cosine clustering at the nose, where curvature is highest
+  const t = 1 - Math.cos(Math.PI / 2 * i / HUB_STATIONS);   // 0 = nose (front), 1 = back
 
   let r;
   if (t < 0.35) {
-    // Nose: parabolic ogive for low drag
-    const tn = t / 0.35;
-    r = spinnerR * Math.sqrt(tn);
+    // Nose: elliptical ogive — rounds to a closed dome instead of a flat disc
+    const tn = (0.35 - t) / 0.35;
+    r = spinnerR * Math.sqrt(Math.max(0, 1 - tn * tn));
   } else if (t < 0.7) {
     // Cylindrical body where blades attach
     r = spinnerR;
@@ -222,41 +247,51 @@ for (let i = 0; i <= HUB_STATIONS; i++) {
     r = spinnerR * (1 - 0.25 * tb * tb);
   }
 
-  hubProfiles.push(circle2d(Math.max(r, 3)));
-  hubHeights.push(-spinnerLen * 0.35 + t * spinnerLen);
+  hubProfiles.push(circle2d(Math.max(r, 0.8)));
+  hubHeights.push(-spinnerLen * 0.525 + t * spinnerLen);
 }
 
 const spinner = loft(hubProfiles, hubHeights, { edgeLength: meshRes });
 
 // ─── Assembly ───────────────────────────────────────────────────
+//
+// Real propellers are built from separate parts: the blades bolt into an
+// internal hub barrel, and the spinner is a thin dome with blade-shaped
+// cutouts (with running clearance) that the blades pass through. Modeling
+// it that way also keeps the aerodynamic skin free of boolean cuts and
+// near-tangent surface overlaps.
 
 const allBlades = circularPattern(blade, numBlades);
 
+// Internal hub barrel the blade shanks merge into (hidden by the spinner)
+const hubBarrel = cylinder(spinnerLen * 0.5, rHub * 0.62)
+  .translate(0, 0, -spinnerLen * 0.2);
+
+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);
+const spinnerCutouts = circularPattern(bladeCutout, numBlades);
+
 // ─── Optional: Airfoil Section Visualization ────────────────────
 //
 // When enabled, shows thin extrusions of each airfoil cross-section
 // along the blade, revealing the twist and chord distribution.
 
 const result = [
-  { name: "Blades",  shape: allBlades.color('#2d2d30') },
-  { name: "Spinner", shape: spinner.color('#c8c8cc') },
+  { name: "Blades",  shape: bladeAssembly.color('#2d2d30') },
+  { name: "Spinner", shape: spinner.subtract(spinnerCutouts).color('#c8c8cc') },
 ];
 
 if (showSections) {
   const sectionShapes = [];
   for (let i = 0; i <= NUM_STATIONS; i++) {
-    const rNorm = i / NUM_STATIONS;
+    const rNorm = 0.5 - 0.5 * Math.cos(Math.PI * i / NUM_STATIONS);
     const r     = rHub + rNorm * (R - rHub);
 
-    const chord = Math.max(chordAt(rNorm), 5);
-    const thick = thicknessRatioAt(rNorm);
-    const camber = camberAt(rNorm);
-    const twist = twistAt(r);
-
-    let pts = nacaPoints(camber, CAMBER_POS, thick, chord, NACA_PTS);
-    pts = rotate2D(pts, 90 + twist);
-
-    const section = polygon(pts).extrude(2)
+    const section = bladeSection(rNorm, r).extrude(2)
       .rotateY(90)
       .translate(r, 0, 0)
       .color('#ff4422');

package/examples/nurbs-surface.forge.js

@@ -5,4 +5,4 @@ const grid = [
   [[0,20,1], [10,20,6], [20,20,6], [30,20,1]],
   [[0,30,0], [10,30,2], [20,30,2], [30,30,0]],
 ];
-return nurbsSurface(grid, { thickness: 1.5 });
+return Surface.Nurbs(grid, { thickness: 1.5 });

package/examples/products/iphone.forge.js

@@ -51,7 +51,7 @@ const lensR = Param.number("Lens Radius", 6, { min: 3, max: 10, unit: "mm" });
 const lensGap = Param.number("Lens Gap", 3, { min: 1, max: 8, unit: "mm" });
 
 // Use Rectangle2D entity to derive lens positions from island bounds
-const camRect = Rectangle2D.fromCenterAndDimensions(point(camX, camY), camSize, camSize);
+const camRect = Rectangle2D.fromCenterAndDimensions(new Point2D(camX, camY), camSize, camSize);
 const triRadius = camSize / 2 - lensR - lensGap;
 
 // Equilateral triangle: two lenses stacked on outer (left) edge,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.9.15",
+  "version": "0.10.0",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://forgecad.io",
@@ -32,6 +32,9 @@
       "check": {
         "description": "Run model-focused readiness checks."
       },
+      "context": {
+        "description": "Read and render submitted marker context for agent workflows."
+      },
       "compare": {
         "description": "Compare ForgeCAD scripts and imported 3D assets."
       },