@woosh/meep-engine 2.48.23 → 2.49.1

package/src/core/model/reactive/model/comparative/ReactiveEquals.js

@@ -25,7 +25,7 @@ export class ReactiveEquals extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveEquals && super.equals(other);
+        return (other.isReactiveEquals === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/model/reactive/model/comparative/ReactiveGreaterThan.js

@@ -23,9 +23,11 @@ export class ReactiveGreaterThan extends ReactiveBinaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveGreaterThan && super.equals(other);
+        return (other.isReactiveGreaterThan === true) && super.equals(other);
     }
+
     toCode() {
         return `( ${this.left.toCode()} > ${this.right.toCode()} )`
     }

package/src/core/model/reactive/model/comparative/ReactiveGreaterThanOrEqual.js

@@ -23,9 +23,11 @@ export class ReactiveGreaterThanOrEqual extends ReactiveBinaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveGreaterThanOrEqual && super.equals(other);
+        return (other.isReactiveGreaterThanOrEqual === true) && super.equals(other);
     }
+
     toCode() {
         return `( ${this.left.toCode()} >= ${this.right.toCode()} )`
     }

package/src/core/model/reactive/model/comparative/ReactiveLessThan.js

@@ -23,9 +23,11 @@ export class ReactiveLessThan extends ReactiveBinaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveLessThan && super.equals(other);
+        return (other.isReactiveLessThan === true) && super.equals(other);
     }
+
     toCode() {
         return `( ${this.left.toCode()} < ${this.right.toCode()} )`
     }

package/src/core/model/reactive/model/comparative/ReactiveLessThanOrEqual.js

@@ -23,9 +23,11 @@ export class ReactiveLessThanOrEqual extends ReactiveBinaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveLessThanOrEqual && super.equals(other);
+        return (other.isReactiveLessThanOrEqual === true) && super.equals(other);
     }
+
     toCode() {
         return `( ${this.left.toCode()} <= ${this.right.toCode()} )`
     }

package/src/core/model/reactive/model/comparative/ReactiveNotEquals.js

@@ -25,7 +25,7 @@ export class ReactiveNotEquals extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveNotEquals && super.equals(other);
+        return (other.isReactiveNotEquals === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/model/reactive/model/logic/ReactiveAnd.js

@@ -35,7 +35,7 @@ export class ReactiveAnd extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveAnd && super.equals(other);
+        return (other.isReactiveAnd === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/model/reactive/model/logic/ReactiveNot.js

@@ -22,9 +22,11 @@ export class ReactiveNot extends ReactiveUnaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveNot && super.equals(other);
+        return (other.isReactiveNot === true) && super.equals(other);
     }
+
     toCode() {
         return `!${this.source.toCode()}`
     }

package/src/core/model/reactive/model/logic/ReactiveOr.js

@@ -35,7 +35,7 @@ export class ReactiveOr extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveOr && super.equals(other);
+        return (other.isReactiveOr === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/primitives/numbers/computeHashFloat.spec.js

@@ -5,3 +5,10 @@ test("computeHashFloat", () => {
 
     expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
 });
+
+test("hash is an integer", () => {
+    const hash = computeHashFloat(1.237);
+
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});

package/src/core/process/task/util/iteratorTask.js

@@ -1,18 +1,20 @@
 import Task from "../Task.js";
 import { TaskSignal } from "../TaskSignal.js";
 import { assert } from "../../../assert.js";
+import { anyOf, equalTo } from "../../../debug/matchers/matchers.js";
 
 /**
  *
  * @param {string} name
  * @param {Iterator} iterator
- * @param {TaskSignal.Continue|TaskSignal.Yield} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
+ * @param {(TaskSignal.Continue)|(TaskSignal.Yield)} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
  * @returns {Task}
  */
 export function iteratorTask(name, iterator, cycle_signal = TaskSignal.Continue) {
     assert.defined(iterator, 'iterator');
     assert.notNull(iterator, 'iterator');
     assert.isFunction(iterator.next, 'iterator.next');
+    assert.that(cycle_signal, 'cycle_signal', anyOf(equalTo(TaskSignal.Continue), equalTo(TaskSignal.Yield)));
 
     return new Task({
         name,

package/src/engine/animation/curve/AnimationCurve.js

@@ -2,6 +2,7 @@ import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { lerp } from "../../../core/math/lerp.js";
 import { invokeObjectToJSON } from "../../../core/model/object/invokeObjectToJSON.js";
 import { Keyframe } from "./Keyframe.js";
+import { binarySearchHighIndex } from "../../../core/collection/array/binarySearchHighIndex.js";
 
 /**
  *
@@ -28,6 +29,16 @@ function evaluate(t, keyframe0, keyframe1) {
     return a * keyframe0.value + b * m0 + c * m1 + d * keyframe1.value;
 }
 
+/**
+ *
+ * @param {number} time
+ * @param {Keyframe} keyframe
+ * @return {number}
+ */
+function compareKeyframeToTime(time, keyframe) {
+    return time - keyframe.time;
+}
+
 /**
  * Modelled on unity's AnimationCurve
  * @see https://github.com/nothke/ThreadableCurve/blob/master/ThreadableCurve.cs
@@ -46,8 +57,26 @@ export class AnimationCurve {
      * @param {Keyframe} key
      */
     add(key) {
-        // TODO figure out the right place to insert the key
-        this.keys.push(key);
+        const keys = this.keys;
+
+        const last_key_index = keys.length - 1;
+
+        if (
+            last_key_index < 0
+            || keys[last_key_index].time <= key.time
+        ) {
+
+            // inserted key goes at the end
+            keys.push(key);
+
+        } else {
+
+            // figure out the right place to insert the key
+            const i = binarySearchHighIndex(keys, key.time, compareKeyframeToTime, 0, last_key_index);
+
+            // insert key at the right place
+            keys.splice(i, 0, key);
+        }
     }
 
     /**
@@ -144,7 +173,7 @@ export class AnimationCurve {
     /**
      *
      * @param {number} index
-     * @param {number} weight
+     * @param {number} weight value between 0 and 1
      */
     smoothTangents(index, weight) {
         const keys = this.keys;
@@ -173,10 +202,10 @@ export class AnimationCurve {
 
     }
 
-    smoothAllTangents(){
+    smoothAllTangents() {
         const n = this.length;
         for (let i = 0; i < n; i++) {
-            this.smoothTangents(i,0);
+            this.smoothTangents(i, 0);
         }
     }
 

package/src/engine/animation/curve/AnimationCurve.spec.js

@@ -0,0 +1,100 @@
+import { AnimationCurve } from "./AnimationCurve.js";
+import { Keyframe } from "./Keyframe.js";
+
+test("constructor does not throw", () => {
+    expect(() => new AnimationCurve()).not.toThrow();
+});
+
+test("adding key increases length", () => {
+    const curve = new AnimationCurve();
+
+    curve.add(Keyframe.from(1, 7));
+
+    expect(curve.length).toBe(1);
+});
+
+test("removing non-existent key", () => {
+    const curve = new AnimationCurve();
+
+    expect(curve.remove(Keyframe.from(1, 7))).toBe(false);
+
+    expect(curve.length).toBe(0);
+
+});
+
+test("clear removes all keys", () => {
+
+    const curve = new AnimationCurve();
+
+    curve.add(Keyframe.from(0, 0));
+    curve.add(Keyframe.from(0, 0));
+
+    curve.clear();
+
+    expect(curve.length).toBe(0);
+});
+
+test("removing exising key", () => {
+    const curve = new AnimationCurve();
+
+    const key = Keyframe.from(1, 7);
+
+    curve.add(key);
+
+    expect(curve.remove(key)).toBe(true);
+
+    expect(curve.length).toBe(0);
+});
+
+
+test("sample linear curve with 2 points", () => {
+    const curve = new AnimationCurve();
+    curve.add(Keyframe.from(0, -3, 6, 6));
+    curve.add(Keyframe.from(1, 3, 6, 6));
+
+    expect(curve.evaluate(0)).toBeCloseTo(-3);
+    expect(curve.evaluate(1)).toBeCloseTo(3);
+    expect(curve.evaluate(0.5)).toBeCloseTo(0);
+});
+
+test("insert key out of order, should end up ordered", () => {
+
+    const curve = new AnimationCurve();
+
+    curve.add(Keyframe.from(0, 3));
+    curve.add(Keyframe.from(5, 7));
+
+    const out_of_order_key = Keyframe.from(1, 11);
+    curve.add(out_of_order_key);
+
+    expect(curve.keys[1]).toBe(out_of_order_key);
+
+});
+
+test("smooth tangents with a single keyframe does not throw", () => {
+    const curve = new AnimationCurve();
+
+    curve.add(Keyframe.from(0, 7));
+
+    expect(() => curve.smoothTangents(0, 1)).not.toThrow()
+});
+
+test("to/from JSON consistency", () => {
+
+    const curve = new AnimationCurve();
+
+    curve.add(Keyframe.from(3, -7, 13, -17));
+
+    const c2 = new AnimationCurve();
+
+    c2.fromJSON(curve.toJSON());
+
+    expect(c2.length).toBe(1);
+
+    const first_key = c2.keys[0];
+
+    expect(first_key.time).toBe(3);
+    expect(first_key.value).toBe(-7);
+    expect(first_key.inTangent).toBe(13);
+    expect(first_key.outTangent).toBe(-17);
+});

package/src/engine/asset/AssetTransformer.js

@@ -1,6 +1,7 @@
 /**
  * Applies a transformation to an asset. Such as performing mesh simplification for example.
  * Transformation is executed by the {@link AssetManager}
+ * Useful for modifying/extending post-processing done on various asset types
  * @template {Asset<T>} A
  * @template T
  */

package/src/engine/computeStridedIntegerArrayHash.js

@@ -1,12 +1,14 @@
 /**
- *
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
  * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
  * @param {number} offset
  * @param {number} length
  * @param {number} stride
  * @return {number}
  */
-export function computeStridedIntegerArrayHash(array, offset, length, stride) {
+export function computeStridedIntegerArrayHash(
+    array, offset, length, stride
+) {
     let result = length;
 
     for (let i = offset; i < length; i += stride) {

package/src/engine/ecs/components/Renderable.d.ts

@@ -8,7 +8,7 @@ export default class Renderable {
     matrixAutoUpdate: boolean
     boundingBoxNeedsUpdate: boolean
 
-    bvh: LeafNode
+    bvh: LeafNode<Object3D>
 
     constructor(object: Object3D)
 }

package/src/{ecs → engine/ecs}/grid/pick.js

@@ -1,7 +1,7 @@
-import { assert } from "../../core/assert.js";
-import Vector3 from "../../core/geom/Vector3.js";
-import { SurfacePoint3 } from "../../core/geom/3d/SurfacePoint3.js";
-import Vector2 from "../../core/geom/Vector2.js";
+import { assert } from "../../../core/assert.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
+import Vector2 from "../../../core/geom/Vector2.js";
 
 /**
  *

package/src/engine/ecs/parent/entity_node_compute_bounding_box.js

@@ -1,5 +1,5 @@
 import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
+import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
 
 const scratch_aabb3 = new AABB3();
 

package/src/engine/ecs/storage/binary/collection/BinaryCollectionSerializer.js

@@ -3,14 +3,6 @@ import { BinaryCollectionHeaderCodec, BinaryCollectionHeaderLayout } from "./Bin
 import { HashMap } from "../../../../../core/collection/HashMap.js";
 import { returnEmptyArray } from "../../../../../core/function/Functions.js";
 
-/**
- *
- * @returns {Array}
- */
-function makeEmptyArray() {
-    return [];
-}
-
 export class BinaryCollectionSerializer {
     constructor() {
 
@@ -70,16 +62,7 @@ export class BinaryCollectionSerializer {
          * @type {Map<any, number>}
          */
         this.dictionary = new HashMap({
-            keyHashFunction(key) {
-                return key.hash();
-            },
-            keyEqualityFunction(k0, k1) {
-                if (k0 === k1) {
-                    return true;
-                } else {
-                    return k0.equals(k1);
-                }
-            }
+            capacity: 1024, //pre-allocate larger size to avoid rehashing
         });
     }
 

package/src/engine/ecs/systems/MotionSystem.js

@@ -17,7 +17,13 @@ class MotionSystem extends System {
 
     update(timeDelta) {
         const entityManager = this.entityManager;
-        entityManager.traverseEntities([Motion, Transform], function (motion, transform) {
+        const ecd = entityManager.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseEntities([Motion, Transform], function (motion, transform) {
             const positionDelta = motion.velocity.clone().multiplyScalar(timeDelta);
             transform.position.add(positionDelta);
         });

package/src/engine/ecs/systems/SynchronizePositionSystem.js

@@ -17,9 +17,15 @@ class SynchronizePositionSystem extends System {
 
     update(timeDelta) {
         const em = this.entityManager;
-        em.traverseEntities([SynchronizePosition, Transform], function (sync, transform) {
+        const ecd = em.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseEntities([SynchronizePosition, Transform], function (sync, transform) {
             const targetEntity = sync.targetEntity;
-            const targetTransform = em.getComponent(targetEntity, Transform);
+            const targetTransform = ecd.getComponent(targetEntity, Transform);
             if (sync.x) {
                 transform.position.x = targetTransform.position.x;
             }

package/src/engine/ecs/transform/Transform.js

@@ -7,7 +7,7 @@ import Quaternion from "../../../core/geom/Quaternion.js";
 import { decompose_matrix_4_array } from "../../../core/geom/3d/decompose_matrix_4_array.js";
 import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 import { TransformFlags } from "./TransformFlags.js";
-import { allocate_transform_m4 } from "../../graphics/ecs/mesh-v2/allocate_transform_m4.js";
+import { allocate_transform_m4 } from "../../../core/geom/3d/matrix/allocate_transform_m4.js";
 import { assert } from "../../../core/assert.js";
 import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
 import { MATRIX_4_IDENTITY } from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";

package/src/engine/graphics/camera/makeScreenScissorFrustum.js

@@ -14,11 +14,11 @@ const nearBR = new ThreeVector3();
 
 /**
  *
- * @param {Frustum} frustum
+ * @param {Frustum} output
  * @param {AABB2} box screen-space 2d box in NDC (-1,+1)
  * @param {THREE.Camera} camera
  */
-export function makeScreenScissorFrustum(frustum, box, camera) {
+export function makeScreenScissorFrustum(output, box, camera) {
 
     camera.updateProjectionMatrix();
     camera.updateMatrixWorld();
@@ -46,7 +46,7 @@ export function makeScreenScissorFrustum(frustum, box, camera) {
     nearBR.unproject(camera);
 
     //create frustum planes
-    const planes = frustum.planes;
+    const planes = output.planes;
 
     //set planes
     planes[0].setFromCoplanarPoints(nearTL, farTL, farTR);

package/src/engine/graphics/camera/testClippingPlaneComputation.js

@@ -39,7 +39,7 @@ import { FogOfWarRevealerSystem } from "../../ecs/fow/FogOfWarRevealerSystem.js"
 import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
 import { SerializationMetadataSystem } from "../../ecs/systems/SerializationMetadataSystem.js";
 import { InverseKinematicsSystem } from "../../ecs/animation/InverseKinematicsSystem.js";
-import { PathDisplaySystem } from "../../../../model/engine/visual/path/PathDisplaySystem.js";
+import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
 import RenderSystem from "../../ecs/systems/RenderSystem.js";
 import { makeEngineOptionsModel } from "../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../editor/enableEditor.js";
@@ -79,7 +79,7 @@ function makeConfig(engine) {
     const guiSystem = new GUIElementSystem(engine.gui.view, engine);
     const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
 
-    config.systems.push(
+    config.addManySystems(
         new ScriptSystem(),
         new FacingDirectionSystem(),
         new PathFollowingSystem(),
@@ -286,16 +286,16 @@ function makeCameraClippingDebug(engine) {
     const special_hits_1 = [];
     const special_hits_2 = [];
 
-    ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_0.add((x, y, z) => {
-        special_hits_0.push(new Vector3(x, y, z));
-    });
-
-    ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_1.add((x, y, z) => {
-        special_hits_1.push(new Vector3(x, y, z));
-    });
-    ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.add((x, y, z) => {
-        special_hits_2.push(new Vector3(x, y, z));
-    });
+    // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_0.add((x, y, z) => {
+    //     special_hits_0.push(new Vector3(x, y, z));
+    // });
+    //
+    // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_1.add((x, y, z) => {
+    //     special_hits_1.push(new Vector3(x, y, z));
+    // });
+    // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.add((x, y, z) => {
+    //     special_hits_2.push(new Vector3(x, y, z));
+    // });
 
     const buffer = new RingBuffer(100);
 
@@ -381,7 +381,7 @@ function main(engine) {
         enableTerrain: true,
         terrainSize: new Vector2(100, 100),
         focus: new Vector3(102, 0, 61),
-        pitch: -0.5,
+        pitch: 0.5,
         yaw: 2.2,
         distance: 3
         // pitch: -0.12,

package/src/engine/graphics/ecs/camera/Camera.js

@@ -14,7 +14,7 @@ import { frustum_from_camera } from "./frustum_from_camera.js";
 import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
 import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 import { ProjectionType } from "./ProjectionType.js";
-import { computePlaneRayIntersection } from "../../../../core/geom/Plane.js";
+import { computePlaneRayIntersection } from "../../../../core/geom/3d/plane/computePlaneRayIntersection.js";
 
 /**
  * @class

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -1,5 +1,5 @@
 import { entity_node_compute_bounding_box } from "../../../../ecs/parent/entity_node_compute_bounding_box.js";
-import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
+import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
 
 export const SGMeshFlags = {
     CastShadow: 1,

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -10,6 +10,9 @@ import { ParentEntity } from "../../../../ecs/parent/ParentEntity.js";
 import { EntityNode } from "../../../../ecs/parent/EntityNode.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
+import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
+import { TransformAttachment } from "../../../../ecs/transform-attachment/TransformAttachment.js";
 
 
 /**
@@ -48,6 +51,12 @@ export class SGMeshSystem extends System {
         this.__assetManager = engine.assetManager;
 
         this.dependencies = [SGMesh, Transform];
+        this.components_used = [
+            ResourceAccessSpecification.from(SGMesh, ResourceAccessKind.Read | ResourceAccessKind.Write),
+            ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read),
+            ResourceAccessSpecification.from(ShadedGeometry, ResourceAccessKind.Create),
+            ResourceAccessSpecification.from(TransformAttachment, ResourceAccessKind.Create),
+        ];
 
         /**
          *

package/src/engine/graphics/geometry/MikkT/MikkTSpace.js

@@ -8,7 +8,7 @@ import { InitTriInfo } from "./InitTriInfo.js";
 import { GenerateTSpaces } from "./GenerateTSpaces.js";
 import { DegenEpilogue } from "./DegenEpilogue.js";
 import { Build4RuleGroups } from "./Build4RuleGroups.js";
-import { allocate_v3 } from "../../ecs/mesh-v2/allocate_v3.js";
+import { allocate_v3 } from "../../../../core/geom/3d/vector/allocate_v3.js";
 import { m_getNumFaces } from "./m_getNumFaces.js";
 import { GenerateInitialVerticesIndexList } from "./GenerateInitialVerticesIndexList.js";
 import { DegenPrologue } from "./DegenPrologue.js";

package/src/engine/graphics/geometry/MikkT/STSpace.js

@@ -1,5 +1,5 @@
 import { vec3 } from "gl-matrix";
-import { allocate_v3 } from "../../ecs/mesh-v2/allocate_v3.js";
+import { allocate_v3 } from "../../../../core/geom/3d/vector/allocate_v3.js";
 
 export class STSpace {
     constructor() {

package/src/engine/graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js

@@ -1,7 +1,7 @@
 import Vector3 from "../../../../../core/geom/Vector3.js";
 
 import { Vector3 as ThreeVector3 } from 'three';
-import { rayTriangleIntersection } from "../../../../../core/geom/rayTriangleIntersection.js";
+import { rayTriangleIntersection } from "../../../../../core/geom/3d/triangle/rayTriangleIntersection.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { assert } from "../../../../../core/assert.js";
 import { v3_length } from "../../../../../core/geom/v3_length.js";

package/src/engine/graphics/material/optimization/MaterialOptimizationContext.js

@@ -22,7 +22,7 @@ import { BUFFER_GEOMETRY_UVS } from "./BUFFER_GEOMETRY_UVS.js";
 import { is_compliant_mesh } from "./is_compliant_mesh.js";
 import { MaterialDescriptor } from "./MaterialDescriptor.js";
 import { computeThreeTextureTypeFromDataType } from "../../texture/computeThreeTextureTypeFromDataType.js";
-import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
+import { typedArrayToDataType } from "../../../../core/collection/array/typed/typedArrayToDataType.js";
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import {
     compute_typed_array_constructor_from_data_type

package/src/engine/graphics/particles/particular/engine/MovingBoundingBox.js

@@ -1,4 +1,4 @@
-import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
+import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
 import { RowFirstTable } from "../../../../../core/collection/table/RowFirstTable.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";

package/src/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -125,6 +125,7 @@ export class ParameterLookupTable {
      */
     sample(position, result) {
         assert.isNumber(position, 'position');
+        assert.notNaN(position, 'position');
         // assert.greaterThanOrEqual(position, 0, 'position');
         // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
 

package/src/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -77,7 +77,7 @@ import TopDownCameraController from "../../../../../ecs/camera/topdown/TopDownCa
 import { randomFloatBetween } from "../../../../../../../core/math/random/randomFloatBetween.js";
 import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlugin.js";
 import { obtainTerrain } from "../../../../../../ecs/terrain/util/obtainTerrain.js";
-import { pick } from "../../../../../../../ecs/grid/pick.js";
+import { pick } from "../../../../../../ecs/grid/pick.js";
 import { clamp01 } from "../../../../../../../core/math/clamp01.js";
 import { randomFromArray } from "../../../../../../../core/math/random/randomFromArray.js";
 import { SamplingFunctionKind } from "./SamplingFunctionKind.js";