@woosh/meep-engine 2.92.9 → 2.92.10

package/build/meep.module.js

@@ -54355,13 +54355,6 @@ function inverseLerp(a, b, value) {
     return scaledValue / range;
 }
 
-/**
- *
- * @param {number} min
- * @param {number} max
- * @constructor
- */
-
 class NumericInterval {
     /**
      *
@@ -54435,9 +54428,9 @@ class NumericInterval {
     }
 
     /**
-     * Performs inverse linear interpolation on a given input
-     * @param {number} v
-     * @returns {number}
+     * Compute normalized position of input within this interval, where result is 0 if input is equal to `min`, and 1 when input is equal to `max`
+     * @param {number} v value to be normalized
+     * @returns {number} value between 0..1 if input is within [min,max] range, otherwise result will be extrapolated proportionately outside the 0,1 region
      */
     normalizeValue(v) {
         return inverseLerp(this.min, this.max, v);
@@ -54465,7 +54458,7 @@ class NumericInterval {
      * @returns {number}
      */
     computeAverage() {
-        return (this.min + this.max) / 2;
+        return (this.min + this.max) * 0.5;
     }
 
     /**
@@ -55268,6 +55261,7 @@ class BinaryUint32BVH {
      * @param {number} count
      */
     setLeafCount(count) {
+
         this.__node_count_leaf = count;
 
         const twoLeafLimit = ceilPowerOfTwo(count);
@@ -66306,14 +66300,14 @@ class GeometrySpatialQueryAccelerator {
      * @returns {BinaryUint32BVH}
      */
     __buildBVH(geometry) {
+        const bvh = new BinaryUint32BVH();
+
         const position_attribute = geometry.getAttribute('position');
         const index_attribute = geometry.getIndex();
 
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
         const vertices = de_interleaved_position_attribute.array;
 
-        const bvh = new BinaryUint32BVH();
-
         if (index_attribute === undefined || index_attribute === null) {
             bvh32_from_unindexed_geometry(bvh, vertices);
         } else {

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.92.9",
+  "version": "2.92.10",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -204,6 +204,8 @@ export class BinaryUint32BVH {
      * @param {number} count
      */
     setLeafCount(count) {
+        assert.isNonNegativeInteger(count, 'count');
+
         this.__node_count_leaf = count;
 
         const twoLeafLimit = ceilPowerOfTwo(count);
@@ -240,6 +242,8 @@ export class BinaryUint32BVH {
         assert.notNaN(y1, 'y1');
         assert.notNaN(z1, 'z1');
 
+        assert.isNonNegativeInteger(payload, 'payload');
+
         const address = index * BVH_LEAF_NODE_SIZE + this.__node_count_binary * BVH_BINARY_NODE_SIZE;
 
         aabb3_array_set(

package/src/core/math/interval/NumericInterval.d.ts

@@ -34,9 +34,9 @@ export class NumericInterval {
      */
     multiplyScalar(value: number): void;
     /**
-     * Performs inverse linear interpolation on a given input
-     * @param {number} v
-     * @returns {number}
+     * Compute normalized position of input within this interval, where result is 0 if input is equal to `min`, and 1 when input is equal to `max`
+     * @param {number} v value to be normalized
+     * @returns {number} value between 0..1 if input is within [min,max] range, otherwise result will be extrapolated proportionately outside the 0,1 region
      */
     normalizeValue(v: number): number;
     /**

package/src/core/math/interval/NumericInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NumericInterval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/interval/NumericInterval.js"],"names":[],"mappings":"AAWA;IACI;;;;;OAKG;IACH,kBAJW,MAAM,QACN,MAAM,EAwBhB;IAZG;;;OAGG;IACH,KAFU,MAAM,CAEF;IACd;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd,0DAA6B;IAIjC;;;;OAIG;IACH,SAHW,MAAM,OACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAahB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gCAFa,MAAM,CAMlB;IAED,0BAEC;IAED;;;MAKC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAGC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;iBAUS,eAAe;mBAKf,eAAe;;mBA5MN,+BAA+B"}
+{"version":3,"file":"NumericInterval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/interval/NumericInterval.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,kBAJW,MAAM,QACN,MAAM,EAwBhB;IAZG;;;OAGG;IACH,KAFU,MAAM,CAEF;IACd;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd,0DAA6B;IAIjC;;;;OAIG;IACH,SAHW,MAAM,OACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAahB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gCAFa,MAAM,CAMlB;IAED,0BAEC;IAED;;;MAKC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAGC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;iBAUS,eAAe;mBAKf,eAAe;;mBA5MN,+BAA+B"}

package/src/core/math/interval/NumericInterval.js

@@ -1,13 +1,7 @@
-/**
- *
- * @param {number} min
- * @param {number} max
- * @constructor
- */
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
-import { inverseLerp } from "../inverseLerp.js";
 import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
+import { inverseLerp } from "../inverseLerp.js";
 
 export class NumericInterval {
     /**
@@ -23,7 +17,7 @@ export class NumericInterval {
         assert.isNumber(min, 'min');
         assert.isNumber(max, 'max');
 
-        assert.ok(max >= min, `max=${max} must be >= than min=${min}`);
+        assert.greaterThanOrEqual(max, min, `max [${max}] must be >= than min[${min}]`);
 
         /**
          *
@@ -93,9 +87,9 @@ export class NumericInterval {
     }
 
     /**
-     * Performs inverse linear interpolation on a given input
-     * @param {number} v
-     * @returns {number}
+     * Compute normalized position of input within this interval, where result is 0 if input is equal to `min`, and 1 when input is equal to `max`
+     * @param {number} v value to be normalized
+     * @returns {number} value between 0..1 if input is within [min,max] range, otherwise result will be extrapolated proportionately outside the 0,1 region
      */
     normalizeValue(v) {
         return inverseLerp(this.min, this.max, v);
@@ -123,7 +117,7 @@ export class NumericInterval {
      * @returns {number}
      */
     computeAverage() {
-        return (this.min + this.max) / 2;
+        return (this.min + this.max) * 0.5;
     }
 
     /**
@@ -132,7 +126,7 @@ export class NumericInterval {
      * @returns {number}
      */
     sampleRandom(random) {
-        assert.equal(typeof random, 'function', `random must be a function, instead was ${typeof random}`);
+        assert.isFunction(random, "random");
 
         return this.min + random() * (this.max - this.min);
     }

package/src/core/math/interval/NumericInterval.spec.js

@@ -78,3 +78,12 @@ test("sampleRandom", () => {
     expect(sut.sampleRandom(() => 1)).toBe(7);
     expect(sut.sampleRandom(() => 0.5)).toBeCloseTo(2);
 });
+
+test("computeAverage", () => {
+    expect(new NumericInterval(0, 0).computeAverage()).toBe(0);
+    expect(new NumericInterval(1, 1).computeAverage()).toBe(1);
+    expect(new NumericInterval(-1, -1).computeAverage()).toBe(-1);
+
+    expect(new NumericInterval(3, 7).computeAverage()).toBe(5);
+    expect(new NumericInterval(3.1, 7.1).computeAverage()).toBe(5.1);
+});

package/src/core/math/max3.spec.js

@@ -1,6 +1,8 @@
 import { max3 } from "./max3.js";
 
 test("max3", () => {
+    expect(max3(0, 0, 0)).toBe(0);
+
     expect(max3(-1, -3, 1)).toBe(1);
 
     expect(max3(-3, -1, 1)).toBe(1);

package/src/core/math/min3.spec.js

@@ -1,6 +1,8 @@
 import { min3 } from "./min3.js";
 
 test("min3", () => {
+    expect(min3(0,0,0)).toBe(0);
+
     expect(min3(-1, -3, 1)).toBe(-3);
 
     expect(min3(-3, -1, 1)).toBe(-3);

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -232,14 +232,14 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {BinaryUint32BVH}
      */
     __buildBVH(geometry) {
+        const bvh = new BinaryUint32BVH();
+
         const position_attribute = geometry.getAttribute('position');
         const index_attribute = geometry.getIndex();
 
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
         const vertices = de_interleaved_position_attribute.array;
 
-        const bvh = new BinaryUint32BVH();
-
         if (index_attribute === undefined || index_attribute === null) {
             bvh32_from_unindexed_geometry(bvh, vertices);
         } else {