@woosh/meep-engine 2.160.0 → 2.162.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/graphics/ecs/path/tube/build/make_cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_cap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/make_cap.js"],"names":[],"mappings":"AAgNA;;;;;;;;;;;;;;GAcG;AACH,4DAbW,MAAM,gBACN,YAAY,GAAC,MAAM,EAAE,cACrB,OAAO,EAAE,gBACT,OAAO,EAAE,eAET,OAAO,EAAE,SACT,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,mBACN,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,QACN,OAAO,QA6BjB;AAED;;;;;;GAMG;AACH,wDALW,MAAM,OACN;IAAC,aAAa,EAAC,MAAM,CAAC;IAAC,YAAY,EAAC,MAAM,CAAA;CAAC,mBAC3C,MAAM,QACN,OAAO,QAiBjB;wBAlRuB,OAAO;wBAMP,eAAe"}
+{"version":3,"file":"make_cap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/make_cap.js"],"names":[],"mappings":"AA+PA;;;;;;;;;;;;;;GAcG;AACH,4DAbW,MAAM,gBACN,YAAY,GAAC,MAAM,EAAE,cACrB,OAAO,EAAE,gBACT,OAAO,EAAE,eAET,OAAO,EAAE,SACT,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,mBACN,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,QACN,OAAO,QA6BjB;AAED;;;;;;GAMG;AACH,wDALW,MAAM,OACN;IAAC,aAAa,EAAC,MAAM,CAAC;IAAC,YAAY,EAAC,MAAM,CAAA;CAAC,mBAC3C,MAAM,QACN,OAAO,QAiBjB;wBAjUuB,OAAO;wBAMP,eAAe"}

package/src/engine/graphics/ecs/path/tube/build/make_cap.js

@@ -79,10 +79,32 @@ function make_cap_round(
     const B = in_binormals[index];
     const T = in_tangents[index];
 
-    const tangent = new Vector3();
-    tangent.crossVectors(N, B);
-    tangent.normalize();
-    tangent.multiplyScalar(-direction);
+    // Outward cap axis. Derive it from the PATH itself (the segment between the
+    // cap and its neighbour sample) rather than from N x B: the Frenet frame's
+    // tangent can flip sign at curvature features, and an N x B-derived axis
+    // would then make the cap bulge inward for a frame ("cap twists off-axis").
+    // The path direction is always well-defined and outward. Fall back to the
+    // frame only if the neighbour sample is coincident (degenerate segment).
+    const point_count = in_positions.length / 3;
+    const neighbour = direction > 0
+        ? Math.min(index + 1, point_count - 1)
+        : Math.max(index - 1, 0);
+    const n3 = neighbour * 3;
+
+    const tangent = new Vector3(
+        Px - in_positions[n3],
+        Py - in_positions[n3 + 1],
+        Pz - in_positions[n3 + 2]
+    );
+
+    if (tangent.lengthSq() > 1e-12) {
+        tangent.normalize();
+    } else {
+        // degenerate: neighbour coincides with the cap point, use the frame
+        tangent.crossVectors(N, B);
+        tangent.normalize();
+        tangent.multiplyScalar(-direction);
+    }
 
     const normal = direction > 0 ? N : N.clone().negate();
     const binormal = direction > 0 ? B : B.clone().negate();
@@ -138,6 +160,31 @@ function make_cap_round(
     }
 
     make_ring_faces(out, index_offset, cap_segment_count, shape_length);
+
+    // Correct the cap vertex normals. make_ring_vertices wrote the tube WALL
+    // normal (purely radial) for each cap ring, which shades the dome like a
+    // flat cylinder end. Every cap vertex lies on the sphere of radius `radius`
+    // centred at the cap base (Px, Py, Pz), so the true outward normal is just
+    // the direction from that centre to the vertex. This bends the normals from
+    // radial (at the base ring) to axial (at the pole), independent of the
+    // path frame's roll.
+    const cap_normals = out.normals;
+    const cap_positions = out.positions;
+    for (let v = index_offset; v < out.cursor_vertices; v++) {
+        const v3 = v * 3;
+
+        const nx = cap_positions[v3] - Px;
+        const ny = cap_positions[v3 + 1] - Py;
+        const nz = cap_positions[v3 + 2] - Pz;
+
+        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        if (length > 1e-8) {
+            const inv = 1 / length;
+            cap_normals[v3] = nx * inv;
+            cap_normals[v3 + 1] = ny * inv;
+            cap_normals[v3 + 2] = nz * inv;
+        }
+    }
 }
 
 const m3_zero = new Float32Array(9);