@woosh/meep-engine 2.162.0 → 2.163.1

package/README.md

@@ -82,7 +82,7 @@ export default defineConfig({
 ```
 
 ### Reliability
-* **Tests:** 7,244 tests with 90%+ core coverage.
+* **Tests:** 7,554 tests with 90%+ core coverage.
 
 * **Stability:** Exhaustively tested corner cases over a decade of development.
 

package/package.json

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

package/src/core/color/xyz/rgb_to_xyz.d.ts

@@ -3,8 +3,8 @@
  * Assumes linear RGB space
  * Assumes D65 standard illuminant
  * @see https://www.image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
- * @param {vec3} out
- * @param {vec3} input
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number[]|Float32Array|Float64Array} input
  */
-export function rgb_to_xyz(out: vec3, input: vec3): void;
+export function rgb_to_xyz(out: number[] | Float32Array | Float64Array, input: number[] | Float32Array | Float64Array): void;
 //# sourceMappingURL=rgb_to_xyz.d.ts.map

package/src/core/color/xyz/rgb_to_xyz.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rgb_to_xyz.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/rgb_to_xyz.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yDASC"}
+{"version":3,"file":"rgb_to_xyz.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/rgb_to_xyz.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAW5C"}

package/src/core/color/xyz/rgb_to_xyz.js

@@ -3,8 +3,8 @@
  * Assumes linear RGB space
  * Assumes D65 standard illuminant
  * @see https://www.image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
- * @param {vec3} out
- * @param {vec3} input
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number[]|Float32Array|Float64Array} input
  */
 export function rgb_to_xyz(out, input) {
 

package/src/core/color/xyz/xyz_to_rgb.d.ts

@@ -2,8 +2,8 @@
  * CIE color model to linear RGB
  * Assumes D65 standard illuminant
  * @see https://www.image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
- * @param {vec3|number[]|Float32Array} out
- * @param {vec3|number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number[]|Float32Array|Float64Array} input
  */
-export function xyz_to_rgb(out: vec3 | number[] | Float32Array, input: vec3 | number[] | Float32Array): void;
+export function xyz_to_rgb(out: number[] | Float32Array | Float64Array, input: number[] | Float32Array | Float64Array): void;
 //# sourceMappingURL=xyz_to_rgb.d.ts.map

package/src/core/color/xyz/xyz_to_rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xyz_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/xyz_to_rgb.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,gCAHW,OAAK,MAAM,EAAE,GAAC,YAAY,SAC1B,OAAK,MAAM,EAAE,GAAC,YAAY,QAUpC"}
+{"version":3,"file":"xyz_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/xyz_to_rgb.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAU5C"}

package/src/core/color/xyz/xyz_to_rgb.js

@@ -2,8 +2,8 @@
  * CIE color model to linear RGB
  * Assumes D65 standard illuminant
  * @see https://www.image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
- * @param {vec3|number[]|Float32Array} out
- * @param {vec3|number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number[]|Float32Array|Float64Array} input
  */
 export function xyz_to_rgb(out, input) {
     const x = input[0];

package/src/core/geom/vec3/v3_array_scale.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Scale a 3d vector by a scalar, writing the result into `output`.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number} scalar
+ */
+export function v3_array_scale(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, scalar: number): void;
+//# sourceMappingURL=v3_array_scale.d.ts.map

package/src/core/geom/vec3/v3_array_scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_array_scale.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_array_scale.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,uCANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,UACN,MAAM,QAUhB"}

package/src/core/geom/vec3/v3_array_scale.js

@@ -0,0 +1,18 @@
+/**
+ * Scale a 3d vector by a scalar, writing the result into `output`.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number} scalar
+ */
+export function v3_array_scale(
+    output, output_offset,
+    input, input_offset,
+    scalar,
+) {
+    output[output_offset] = input[input_offset] * scalar;
+    output[output_offset + 1] = input[input_offset + 1] * scalar;
+    output[output_offset + 2] = input[input_offset + 2] * scalar;
+}

package/src/engine/EngineHarness.js

@@ -270,11 +270,11 @@ export class EngineHarness {
      */
     static async buildBasics({
                                  engine,
-                                 focus = new Vector3(10, 0, 10),
+                                 focus = new Vector3(0, 0, 0),
                                  heightMap,
                                  heightRange,
                                  pitch = 0.7,
-                                 yaw = -1.2,
+                                 yaw = 0,
                                  distance = 10,
                                  terrainSize = new Vector2(10, 10),
                                  terrainResolution = 10,
@@ -287,7 +287,7 @@ export class EngineHarness {
                                  cameraController = true,
                                  cameraAutoClip = true,
                                  shadowmapResolution,
-                                 showFps = true
+                                 showFps = false
                              }) {
 
         if (showFps) {

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

@@ -1,202 +1,218 @@
-import { BufferGeometry, Vector3 } from "three";
-import { assert } from "../../../../../../core/assert.js";
-import { v3_angle_cos_between } from "../../../../../../core/geom/vec3/v3_angle_cos_between.js";
-import { v3_length } from "../../../../../../core/geom/vec3/v3_length.js";
-import { CapType } from "../CapType.js";
-import { append_compute_cap_geometry_size, make_cap } from "./make_cap.js";
-import { make_ring_faces } from "./make_ring_faces.js";
-import { make_ring_vertices } from "./make_ring_vertices.js";
-import { StreamGeometryBuilder } from "./StreamGeometryBuilder.js";
-
-
-const v4_array = new Float32Array(4);
-
-/**
- * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
- * @see https://github.com/hofk/THREEg.js/blob/488f1128a25321a76888aa1fa19db64750318444/THREEg.js#L3483
- * @param {Float32Array|number[]} in_positions
- * @param {Vector3[]} in_normals
- * @param {Vector3[]} in_binormals
- * @param {Vector3[]} in_tangents
- * @param {number[]} shape
- * @param {number[]|Float32Array} shape_normal
- * @param {number} shape_length
- * @param {number[]|Float32Array} shape_transform
- * @param {boolean} [closed]
- * @param {CapType} [cap_type]
- * @returns {BufferGeometry}
- */
-export function makeTubeGeometry(
-    in_positions, in_normals, in_binormals, in_tangents,
-    shape, shape_normal, shape_length, shape_transform, closed = false, cap_type = CapType.Round
-) {
-    assert.enum(cap_type, CapType, 'cap_type');
-    assert.isBoolean(closed, 'closed');
-
-    assert.isNumber(shape_length, 'shape_length');
-    assert.isArrayLike(shape, 'shape');
-
-    const out = new StreamGeometryBuilder();
-
-    // helper variables
-
-    const point_count = in_positions.length / 3;
-    const tubular_segments = point_count - 1;
-
-
-    const geometry_size = {
-        vertex_count: (tubular_segments + 1) * (shape_length + 1),
-        polygon_count: tubular_segments * shape_length * 2
-    };
-
-    if (!closed) {
-        append_compute_cap_geometry_size(2, geometry_size, shape_length, cap_type);
-    }
-
-    out.allocate(
-        geometry_size.vertex_count,
-        geometry_size.polygon_count
-    );
-
-    // create buffer data
-
-    if (!closed) {
-        // start cap
-        make_cap(
-            out, 0,
-            in_positions, in_normals, in_binormals, in_tangents,
-            shape, shape_normal, shape_length, shape_transform, 1, cap_type
-        );
-    }
-
-    const index_offset = out.cursor_vertices;
-
-    for (let i = 0; i < tubular_segments; i++) {
-
-        generateSegment(i);
-
-    }
-
-    // if the geometry is not closed, generate the last row of vertices and normals
-    // at the regular position on the given path
-    //
-    // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
-
-    generateSegment((closed === false) ? tubular_segments : 0);
-
-    // finally create faces
-    make_ring_faces(out, index_offset, tubular_segments, shape_length);
-
-    if (!closed) {
-        // end cap
-        make_cap(
-            out, point_count - 1,
-            in_positions, in_normals, in_binormals, in_tangents,
-            shape, shape_normal, shape_length, shape_transform, -1, cap_type
-        );
-    }
-
-    /**
-     *
-     * @param {number} i
-     */
-    function generateSegment(i) {
-
-        // we use getPointAt to sample evenly distributed points from the given path
-
-        const i3 = i * 3;
-
-        const Px = in_positions[i3];
-        const Py = in_positions[i3 + 1];
-        const Pz = in_positions[i3 + 2];
-
-        // retrieve corresponding normal and binormal
-
-        const N = in_normals[i];
-        const B = in_binormals[i];
-
-        // generate normals and vertices for the current segment
-        compute_bend_normal(v4_array, i, tubular_segments, in_positions);
-
-        make_ring_vertices(
-            out,
-            Px, Py, Pz,
-            N, B, in_tangents[i],
-            i / tubular_segments, v4_array,
-            shape, shape_normal, shape_length, shape_transform
-        );
-
-    }
-
-
-    return out.build();
-}
-
-
-/**
- *
- * @param {number[]|Float32Array} out
- * @param {number} index
- * @param {number} index_count
- * @param {number[]|Float32Array} positions
- */
-function compute_bend_normal(
-    out,
-    index,
-    index_count,
-    positions
-) {
-    if (index <= 0 || index >= index_count - 1) {
-        // end points, no bending
-
-        out[0] = 0;
-        out[1] = 1;
-        out[2] = 0;
-        out[3] = 0;
-
-        return;
-    }
-
-    const index_next = index + 1;
-    const index_prev = index - 1;
-
-    const address_current = index * 3;
-    const address_next = index_next * 3;
-    const address_prev = index_prev * 3;
-
-    const i0_x = positions[address_prev];
-    const i0_y = positions[address_prev + 1];
-    const i0_z = positions[address_prev + 2];
-
-    const i1_x = positions[address_current];
-    const i1_y = positions[address_current + 1];
-    const i1_z = positions[address_current + 2];
-
-    const i2_x = positions[address_next];
-    const i2_y = positions[address_next + 1];
-    const i2_z = positions[address_next + 2];
-
-    const d0_x = i0_x - i1_x;
-    const d0_y = i0_y - i1_y;
-    const d0_z = i0_z - i1_z;
-
-    const d1_x = i1_x - i2_x;
-    const d1_y = i1_y - i2_y;
-    const d1_z = i1_z - i2_z;
-
-    // compute rotation axis
-    const cross_x = d0_y * d1_z - d0_z * d1_y;
-    const cross_y = d0_z * d1_x - d0_x * d1_z;
-    const cross_z = d0_x * d1_y - d0_y * d1_x;
-
-    const angle = v3_angle_cos_between(d0_x, d0_y, d0_z, d1_x, d1_y, d1_z);
-
-    const length_inv = 1 / v3_length(cross_x, cross_y, cross_z);
-
-    out[0] = cross_x * length_inv;
-    out[1] = cross_y * length_inv;
-    out[2] = cross_z * length_inv;
-
-    // bend amount
-    out[3] = (1 - Math.abs(angle)) * 0.5;
-}
+import { BufferGeometry, Vector3 } from "three";
+import { assert } from "../../../../../../core/assert.js";
+import { v3_angle_cos_between } from "../../../../../../core/geom/vec3/v3_angle_cos_between.js";
+import { v3_length } from "../../../../../../core/geom/vec3/v3_length.js";
+import { CapType } from "../CapType.js";
+import { append_compute_cap_geometry_size, make_cap } from "./make_cap.js";
+import { make_ring_faces } from "./make_ring_faces.js";
+import { make_ring_vertices } from "./make_ring_vertices.js";
+import { StreamGeometryBuilder } from "./StreamGeometryBuilder.js";
+
+
+const v4_array = new Float32Array(4);
+
+/**
+ * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
+ * @see https://github.com/hofk/THREEg.js/blob/488f1128a25321a76888aa1fa19db64750318444/THREEg.js#L3483
+ * @param {Float32Array|number[]} in_positions
+ * @param {Vector3[]} in_normals
+ * @param {Vector3[]} in_binormals
+ * @param {Vector3[]} in_tangents
+ * @param {number[]} shape
+ * @param {number[]|Float32Array} shape_normal
+ * @param {number} shape_length
+ * @param {number[]|Float32Array} shape_transform
+ * @param {boolean} [closed]
+ * @param {CapType} [cap_type]
+ * @returns {BufferGeometry}
+ */
+export function makeTubeGeometry(
+    in_positions, in_normals, in_binormals, in_tangents,
+    shape, shape_normal, shape_length, shape_transform, closed = false, cap_type = CapType.Round
+) {
+    assert.enum(cap_type, CapType, 'cap_type');
+    assert.isBoolean(closed, 'closed');
+
+    assert.isNumber(shape_length, 'shape_length');
+    assert.isArrayLike(shape, 'shape');
+
+    const out = new StreamGeometryBuilder();
+
+    // helper variables
+
+    const point_count = in_positions.length / 3;
+    const tubular_segments = point_count - 1;
+
+
+    const geometry_size = {
+        vertex_count: (tubular_segments + 1) * (shape_length + 1),
+        polygon_count: tubular_segments * shape_length * 2
+    };
+
+    if (!closed) {
+        append_compute_cap_geometry_size(2, geometry_size, shape_length, cap_type);
+    }
+
+    out.allocate(
+        geometry_size.vertex_count,
+        geometry_size.polygon_count
+    );
+
+    // create buffer data
+
+    if (!closed) {
+        // start cap
+        make_cap(
+            out, 0,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform, 1, cap_type
+        );
+    }
+
+    const index_offset = out.cursor_vertices;
+
+    for (let i = 0; i < tubular_segments; i++) {
+
+        generateSegment(i);
+
+    }
+
+    // if the geometry is not closed, generate the last row of vertices and normals
+    // at the regular position on the given path
+    //
+    // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
+
+    generateSegment((closed === false) ? tubular_segments : 0);
+
+    // finally create faces
+    make_ring_faces(out, index_offset, tubular_segments, shape_length);
+
+    if (!closed) {
+        // end cap
+        make_cap(
+            out, point_count - 1,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform, -1, cap_type
+        );
+    }
+
+    /**
+     *
+     * @param {number} i
+     */
+    function generateSegment(i) {
+
+        // we use getPointAt to sample evenly distributed points from the given path
+
+        const i3 = i * 3;
+
+        const Px = in_positions[i3];
+        const Py = in_positions[i3 + 1];
+        const Pz = in_positions[i3 + 2];
+
+        // retrieve corresponding normal and binormal
+
+        const N = in_normals[i];
+        const B = in_binormals[i];
+
+        // generate normals and vertices for the current segment
+        compute_bend_normal(v4_array, i, tubular_segments, in_positions);
+
+        make_ring_vertices(
+            out,
+            Px, Py, Pz,
+            N, B, in_tangents[i],
+            i / tubular_segments, v4_array,
+            shape, shape_normal, shape_length, shape_transform
+        );
+
+    }
+
+
+    return out.build();
+}
+
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} index
+ * @param {number} index_count
+ * @param {number[]|Float32Array} positions
+ */
+function compute_bend_normal(
+    out,
+    index,
+    index_count,
+    positions
+) {
+    if (index <= 0 || index >= index_count - 1) {
+        // end points, no bending
+
+        out[0] = 0;
+        out[1] = 1;
+        out[2] = 0;
+        out[3] = 0;
+
+        return;
+    }
+
+    const index_next = index + 1;
+    const index_prev = index - 1;
+
+    const address_current = index * 3;
+    const address_next = index_next * 3;
+    const address_prev = index_prev * 3;
+
+    const i0_x = positions[address_prev];
+    const i0_y = positions[address_prev + 1];
+    const i0_z = positions[address_prev + 2];
+
+    const i1_x = positions[address_current];
+    const i1_y = positions[address_current + 1];
+    const i1_z = positions[address_current + 2];
+
+    const i2_x = positions[address_next];
+    const i2_y = positions[address_next + 1];
+    const i2_z = positions[address_next + 2];
+
+    const d0_x = i0_x - i1_x;
+    const d0_y = i0_y - i1_y;
+    const d0_z = i0_z - i1_z;
+
+    const d1_x = i1_x - i2_x;
+    const d1_y = i1_y - i2_y;
+    const d1_z = i1_z - i2_z;
+
+    // compute rotation axis
+    const cross_x = d0_y * d1_z - d0_z * d1_y;
+    const cross_y = d0_z * d1_x - d0_x * d1_z;
+    const cross_z = d0_x * d1_y - d0_y * d1_x;
+
+    const angle = v3_angle_cos_between(d0_x, d0_y, d0_z, d1_x, d1_y, d1_z);
+
+    const cross_length = v3_length(cross_x, cross_y, cross_z);
+
+    if (cross_length < 1e-10) {
+        // Collinear (or duplicate) neighbours: zero curvature, so no bend.
+        // The rotation axis is undefined here and computing it would be
+        // 0 / 0 = NaN, poisoning this ring's vertices (visible as shattered
+        // geometry on short / straight resampled segments, e.g. the animated
+        // marching dashes). Emit the same no-bend value the path ends use.
+        out[0] = 0;
+        out[1] = 1;
+        out[2] = 0;
+        out[3] = 0;
+
+        return;
+    }
+
+    const length_inv = 1 / cross_length;
+
+    out[0] = cross_x * length_inv;
+    out[1] = cross_y * length_inv;
+    out[2] = cross_z * length_inv;
+
+    // bend amount
+    out[3] = (1 - Math.abs(angle)) * 0.5;
+}

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":"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"}
+{"version":3,"file":"make_cap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/make_cap.js"],"names":[],"mappings":"AAwQA;;;;;;;;;;;;;;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;wBA1UuB,OAAO;wBAMP,eAAe"}

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

@@ -106,8 +106,17 @@ function make_cap_round(
         tangent.multiplyScalar(-direction);
     }
 
-    const normal = direction > 0 ? N : N.clone().negate();
-    const binormal = direction > 0 ? B : B.clone().negate();
+    // Use the path frame's N/B directly for BOTH ends. The profile orientation
+    // must match the tube body it caps, otherwise the cap's cross-section is
+    // mis-aligned where it meets the body. Negating N/B for the end cap (as was
+    // done previously) point-reflects the profile in the N-B plane (a 180 degree
+    // turn about the tangent): invisible for a centrally-symmetric profile (a
+    // circle) but it twists the cap for any asymmetric one. The end cap's face
+    // winding is already corrected by the `j = cap_segment_count - i` ring-order
+    // reversal below (it advances the end-cap rings in the same direction vs `i`
+    // as the start cap), so no profile negation is needed.
+    const normal = N;
+    const binormal = B;
 
     const angular_step_i = (Math.PI / 2) / cap_segment_count;
 

package/src/engine/graphics/sh3/path_tracer/make_sky_hosek.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_sky_hosek.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/make_sky_hosek.js"],"names":[],"mappings":"AAQA,2LAmCC"}
+{"version":3,"file":"make_sky_hosek.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/make_sky_hosek.js"],"names":[],"mappings":"AASA,2LAmCC"}