@woosh/meep-engine 2.33.22 → 2.33.26

package/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { WeightedRandomBehavior } from "../../../../intelligence/behavior/selector/WeightedRandomBehavior.js";
 import { WeightedElement } from "../../../../intelligence/behavior/selector/WeightedElement.js";
-import { computeHashFloat } from "../../../../../core/math/MathUtils.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class WeightedRandomActionDescription extends AbstractActionDescription {
     constructor() {

package/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js

@@ -1,6 +1,6 @@
 import { PointFitnessFunction } from "../PointFitnessFunction.js";
 import { assert } from "../../../../core/assert.js";
-import { gaussian } from "../../../../core/math/MathUtils.js";
+import { gaussian } from "../../../../core/math/gaussian.js";
 
 export class PointFitnessGaussianBlur extends PointFitnessFunction {
     constructor() {

package/engine/ecs/foliage/ecs/Foliage2.js

@@ -4,7 +4,7 @@ import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { InstancedFoliage } from "../InstancedFoliage.js";
 import { Base64 } from "../../../../core/binary/Base64.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
-import { computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class FoliageLayer {
     constructor() {

package/engine/ecs/fow/FogOfWar.js

@@ -75,6 +75,10 @@ export class FogOfWar {
          */
         this.texture = null;
 
+        /**
+         * Resolution scale of FoW versus terrain resolution, higher number makes FoW more detailed
+         * @type {Vector1}
+         */
         this.scale = new Vector1(1);
 
         /**

package/engine/ecs/fow/FogOfWarSystem.js

@@ -12,6 +12,7 @@ import { BlendingType } from "../../graphics/texture/sampler/BlendingType.js";
 import { FogOfWarRenderer } from "./shader/FogOfWarRenderer.js";
 import { StandardFrameBuffers } from "../../graphics/StandardFrameBuffers.js";
 import { CompositLayer } from "../../graphics/composit/CompositLayer.js";
+import { CompositingStages } from "../../graphics/composit/CompositingStages.js";
 
 
 const frustum = new Frustum();
@@ -133,6 +134,7 @@ export class FogOfWarSystem extends System {
 
         const compositerLayer = graphics.layerComposer.createLayer({}, BlendingType.Normal);
         compositerLayer.name = 'Fog of War';
+        compositerLayer.stage = CompositingStages.POST_TRANSPARENT;
 
         // Fog of war should be drawn last typically, over everything else, so we set order to a large number
         compositerLayer.order = 1000;

package/engine/ecs/fow/shader/FogOfWarRenderer.js

@@ -1,8 +1,8 @@
 import { buildScreenSpaceFogOfWarShader } from "./screenSpaceFogOfWarShader.js";
 import { assert } from "../../../../core/assert.js";
 import { Mesh, OrthographicCamera, Scene } from "three";
-import { isValueBetweenInclusive } from "../../../../core/math/MathUtils.js";
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../graphics/geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
 
 /**
  *

package/engine/ecs/gui/GUIElement.js

@@ -6,9 +6,9 @@ import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { assert } from "../../../core/assert.js";
-import { computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 
 /**
  *

package/engine/ecs/gui/hud/HeadsUpDisplay.js

@@ -7,7 +7,7 @@
 
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
-import { computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 
 class HeadsUpDisplay {
     /**

package/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -144,7 +144,9 @@ class HeadsUpDisplaySystem extends System {
                 up.set(worldPositionX, worldPositionY + 1, worldPositionZ, 1);
                 up.threeApplyMatrix4(projectionMatrix);
 
+                // compute perspective divide
                 const d = 1 / Math.abs(up.w);
+
                 up.x *= d;
                 up.y *= d;
                 up.z *= d;

package/engine/ecs/gui/position/ViewportPosition.js

@@ -5,7 +5,8 @@
 import Vector2 from "../../../../core/geom/Vector2.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  * @readonly

package/engine/ecs/system/AbstractContextSystem.js

@@ -38,7 +38,7 @@ export class AbstractContextSystem extends System {
                 // TODO
             },
             (ctx) => {
-                ctx.unlink();
+                //ctx.unlink();
             }
         );
 

package/engine/ecs/systems/RangedAttackSystem.js

@@ -8,7 +8,7 @@ import PhysicalBody from '../components/PhysicalBody.js';
 import Motion from '../components/Motion.js';
 import Renderable from '../components/Renderable.js';
 import { Matrix4 as ThreeMatrix4, Vector3 as ThreeVector3 } from 'three';
-import { solveQuadratic } from "../../../core/math/MathUtils.js";
+import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
 
 /**
  * Return the firing solution for a projectile starting at 'src' with

package/engine/ecs/systems/SteeringSystem.js

@@ -10,10 +10,10 @@ import PhysicalBody from '../components/PhysicalBody.js';
 import Motion from '../components/Motion.js';
 import { Transform } from '../transform/Transform.js';
 import Steering, { SteeringEvents, SteeringFlags } from '../components/Steering.js';
-import { solveQuadratic } from "../../../core/math/MathUtils.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { alignToVector } from "../terrain/ecs/ClingToTerrainSystem.js";
 import { v3_dot } from "../../../core/geom/v3_dot.js";
+import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
 
 /**
  *

package/engine/ecs/systems/TagSystem.js

@@ -13,6 +13,23 @@ class TagSystem extends System {
 
         this.entityManager = null;
     }
+
+    /**
+     *
+     * @param {string} tag
+     * @param {EntityComponentDataset} ecd
+     * @returns  {number[]}
+     */
+    static find_entities_with_tag(tag, ecd) {
+        const r = [];
+        ecd.traverseComponents(Tag, (t, e) => {
+            if (t.contains(tag)) {
+                r.push(e);
+            }
+        });
+
+        return r;
+    }
 }
 
 

package/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -14,7 +14,6 @@ import CheckersTexture from '../../../graphics/texture/CheckersTexture.js';
 import { MeshPhongMaterial } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { Color } from "../../../../core/color/Color.js";
-import { randomFloatBetween } from "../../../../core/math/MathUtils.js";
 import { noop } from "../../../../core/function/Functions.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
@@ -24,6 +23,7 @@ import { traverseBinaryNodeUsingVisitor } from "../../../../core/bvh2/traversal/
 import { aabb2_overlapExists } from "../../../../core/geom/AABB2.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetween.js";
 
 class TerrainTileManager {
     /**

package/engine/ecs/tooltip/TooltipComponent.js

@@ -1,3 +1,5 @@
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+
 export class TooltipComponent {
     constructor() {
         /**
@@ -7,6 +9,19 @@ export class TooltipComponent {
         this.key = '';
     }
 
+    hash() {
+        return computeStringHash(this.key);
+    }
+
+    /**
+     *
+     * @param {TooltipComponent} other
+     * @return {boolean}
+     */
+    equals(other) {
+        return this.key === other.key;
+    }
+
     toJSON() {
         return {
             key: this.key

package/engine/ecs/transform/Transform.js

@@ -5,14 +5,13 @@
 import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import { Matrix4 } from "../../../core/geom/Matrix4.js";
-import { Quaternion as ThreeQuaternion } from "three";
-import { composeMatrix4 } from "../../graphics/util/composeMatrix4.js";
+import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
+import { decompose_matrix_4_array } from "../../graphics/util/decompose_matrix_4_array.js";
 
 const delta = new Vector3();
 
 const m4_0 = new Matrix4();
 const m4_1 = new Matrix4();
-const threeQuaternion = new ThreeQuaternion();
 
 export class Transform {
     /**
@@ -166,9 +165,15 @@ export class Transform {
      * @param {Matrix4} matrix
      */
     fromThreeMatrix4(matrix) {
-        matrix.decompose(this.position, threeQuaternion, this.scale);
+        this.fromMatrix4(matrix.elements);
+    }
 
-        this.rotation.copy(threeQuaternion);
+    /**
+     *
+     * @param {mat4|number[]|Float32Array} m
+     */
+    fromMatrix4(m) {
+        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
     }
 
     /**
@@ -176,7 +181,15 @@ export class Transform {
      * @param {Matrix4} matrix
      */
     toThreeMatrix(matrix) {
-        composeMatrix4(matrix, this.position, this.rotation, this.scale);
+        this.toMatrix4(matrix.elements);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} result
+     */
+    toMatrix4(result) {
+        compose_matrix4_array(result, this.position, this.rotation, this.scale);
     }
 }
 

package/engine/ecs/util/hideEntityGracefully.js

@@ -15,10 +15,23 @@ import { DelayBehavior } from "../../intelligence/behavior/util/DelayBehavior.js
 import { Light } from "../../graphics/ecs/light/Light.js";
 import { TransitionPropertyVectorXBehavior } from "../../../../model/game/story/behaviors/generic/TransitionPropertyVectorXBehavior.js";
 
+/**
+ * @readonly
+ * @type {number}
+ */
 const SHUTDOWN_GRACE_PERIOD = 60;
 
+/**
+ *
+ * @type {Map<Class|function, function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number>}
+ */
 const component_shutdown = new Map();
 
+/**
+ * @template T
+ * @param {Class<T>} type
+ * @param {function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number} method
+ */
 function addShutdown(type, method) {
     component_shutdown.set(type, method);
 }
@@ -152,6 +165,11 @@ addShutdown(SoundEmitter, (soundEmitter, builder, createEntity, createEntityThis
  * @return {number} duration in seconds until the entity is completely hidden
  */
 export function hideEntityGracefully(builder, createEntity, createEntityThisArg) {
+    if (!builder.isBuilt) {
+        // already destroyed
+        return 0;
+    }
+
     let delay = 0;
 
     const components = builder.element;

package/engine/graphics/GraphicsEngine.js

@@ -40,6 +40,7 @@ import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
 import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
+import { CompositingStages } from "./composit/CompositingStages.js";
 
 /**
  *
@@ -96,7 +97,13 @@ function GraphicsEngine(camera, entityManger) {
         preRender: new Signal(),
         postRender: new Signal(),
 
+        /**
+         * @deprecated
+         */
         preComposite: new Signal(),
+        /**
+         * @deprecated
+         */
         postComposite: new Signal(),
 
         buffersRendered: new Signal(),
@@ -345,23 +352,6 @@ GraphicsEngine.prototype.start = function () {
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
 
-    let g = 0;
-    let t = 0;
-    webGLRenderer.info.memory = {
-        get geometries() {
-            return g;
-        },
-        set geometries(v) {
-            g = v;
-        },
-        get textures() {
-            return t;
-        },
-        set textures(v) {
-            t = v;
-        }
-    };
-
     //print GPU info
     const GPU_NAME = this.getGPUName();
 
@@ -387,7 +377,7 @@ GraphicsEngine.prototype.start = function () {
     const domElement = this.domElement = webGLRenderer.domElement;
     //disable selection
     const style = domElement.style;
-    domElement.classList.add("renderer-engine-render-canvas");
+    domElement.classList.add("graphics-engine-render-canvas");
     style.userSelect = style.webkitUserSelect = style.mozUserSelect = "none";
     // see : https://www.w3.org/TR/pointerevents/#the-touch-action-css-property
     style.touchAction = "none";
@@ -645,16 +635,14 @@ GraphicsEngine.prototype.render = function (renderTarget) {
     //do the opaque pass
     this.renderOpaque();
 
+    this.layerComposer.composite(renderer, CompositingStages.POST_OPAQUE);
+
     this.on.buffersRendered.send3(renderer, camera, scene);
 
     // transparent pass
     this.renderTransparent();
 
-    this.on.preComposite.send3(renderer, camera, scene);
-
-    this.layerComposer.composite(renderer);
-
-    this.on.postComposite.send3(renderer, camera, scene);
+    this.layerComposer.composite(renderer, CompositingStages.POST_TRANSPARENT);
 
 
     //dispatch post-render event

package/engine/graphics/camera/testClippingPlaneComputation.js

@@ -95,11 +95,11 @@ function makeConfig(engine) {
         new TopDownCameraControllerSystem(graphics),
         new TopDownCameraLanderSystem(),
         new CameraSystem(graphics.scene, graphics),
-        new MeshSystem(graphics, assetManager),
+        new MeshSystem(engine),
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),

package/engine/graphics/composit/CompositLayer.js

@@ -5,6 +5,7 @@ import { blendingType2three } from "../texture/sampler/blendingType2Three.js";
 import { ScreenSpaceQuadShader } from "../shaders/ScreenSpaceQuadShader.js";
 import { BlendingType } from "../texture/sampler/BlendingType.js";
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import Signal from "../../../core/events/signal/Signal.js";
 
 /**
  *
@@ -29,11 +30,15 @@ function assignMaterialBlending(material, blending) {
 export class CompositLayer {
     /**
      *
-     * @param {WebGLRenderTarget} renderTarget
+     * @param {THREE.WebGLRenderTarget} renderTarget
      * @param {BlendingType} blending
      * @param {number} renderTargetScale
      */
-    constructor({ renderTarget, blending, renderTargetScale = 1 }) {
+    constructor({
+                    renderTarget,
+                    blending,
+                    renderTargetScale = 1
+                }) {
         /**
          * Human-readable name, useful for debugging
          * @type {string}
@@ -57,9 +62,13 @@ export class CompositLayer {
          */
         this.renderTargetScale = renderTargetScale;
 
-        const material = this.buildMaterial();
+        this.object = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, this.buildMaterial());
 
-        this.object = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
+        /**
+         * Which compositing stage this layer belongs to, stages are rendered independently
+         * @type {number}
+         */
+        this.stage = 0;
 
         this.size = new Vector2();
 
@@ -74,6 +83,10 @@ export class CompositLayer {
          * @type {number}
          */
         this.__order = 0;
+
+        this.on = {
+            preRender: new Signal()
+        };
     }
 
     /**

package/engine/graphics/composit/CompositingStages.js

@@ -0,0 +1,8 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const CompositingStages = {
+    POST_OPAQUE: 1,
+    POST_TRANSPARENT: 0
+}

package/engine/graphics/composit/LayerCompositer.js

@@ -52,8 +52,6 @@ class LayerCompositer {
 
         layer.renderTarget.dispose();
 
-        this.scene.remove(layer.object);
-
         return true;
     }
 
@@ -113,8 +111,6 @@ class LayerCompositer {
 
         this.layerTargets.push(layer);
 
-        this.scene.add(layer.object);
-
         return true;
     }
 
@@ -138,13 +134,46 @@ class LayerCompositer {
 
     /**
      *
-     * @param {WebGLRenderer} renderer
+     * @param {number} stage
+     * @private
      */
-    composite(renderer) {
+    __prepare_scene_for_stage(stage) {
+        const layers = this.layerTargets;
+        const layer_count = layers.length;
+
+        const scene = this.scene;
+
+        let child_count = 0;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers[i];
+
+            if (layer.stage !== stage) {
+                continue;
+            }
+
+            scene.children[child_count++] = layer.object;
+
+            layer.on.preRender.send0();
+        }
+
+        scene.children.length = child_count;
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {number} stage
+     */
+    composite(renderer, stage) {
+        assert.isNonNegativeInteger(stage, 'stage');
+
         if (!this.hasActiveLayers()) {
             return;
         }
 
+        this.__prepare_scene_for_stage(stage);
+
         const camera = this.camera;
         const scene = this.scene;
 

package/engine/graphics/ecs/animation/animator/AnimationClip.js

@@ -1,8 +1,9 @@
-import { computeHashFloat, computeHashIntegerArray} from "../../../../../core/math/MathUtils.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { AnimationClipFlag } from "./AnimationClipFlag.js";
 import { LoopOnce, LoopRepeat } from "three";
 import { AnimationEventTypes } from "./AnimationEventTypes.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationClip {
     constructor() {

package/engine/graphics/ecs/animation/animator/AnimationClipDefinition.js

@@ -1,7 +1,8 @@
 import { isArrayEqual } from "../../../../../core/collection/ArrayUtils.js";
-import { computeHashArray, computeHashIntegerArray } from "../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
 
 /**
  *

package/engine/graphics/ecs/animation/animator/AnimationNotification.js

@@ -1,4 +1,5 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationNotification {
     constructor() {

package/engine/graphics/ecs/animation/animator/AnimationNotificationDefinition.js

@@ -1,6 +1,7 @@
-import { computeHashIntegerArray, computeObjectHash } from "../../../../../core/math/MathUtils.js";
 import { objectDeepEquals } from "../../../../../core/model/object/objectDeepEquals.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeObjectHash } from "../../../../../core/math/hash/computeObjectHash.js";
 
 export class AnimationNotificationDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/AnimationGraph.js

@@ -3,11 +3,12 @@ import { AnimationTransition } from "./AnimationTransition.js";
 import { AnimationStateType } from "./AnimationStateType.js";
 import { AnimationMixer } from "three";
 import { AnimationGraphFlag } from "./AnimationGraphFlag.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { writeAnimationGraphDefinitionToJSON } from "./definition/serialization/writeAnimationGraphDefinitionToJSON.js";
 import { readAnimationGraphDefinitionFromJSON } from "./definition/serialization/readAnimationGraphDefinitionFromJSON.js";
 import { assert } from "../../../../../../core/assert.js";
 import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationGraph {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationGraphDefinition.js

@@ -4,8 +4,9 @@ import { AnimationStateDefinition } from "./AnimationStateDefinition.js";
 import { AnimationClipDefinition } from "../../AnimationClipDefinition.js";
 import { AnimationClip } from "../../AnimationClip.js";
 import { isArrayEqual } from "../../../../../../../core/collection/ArrayUtils.js";
-import { computeHashArray, computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
 import { invokeObjectHash } from "../../../../../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class AnimationGraphDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationStateDefinition.js

@@ -1,5 +1,5 @@
 import { AnimationStateType } from "../AnimationStateType.js";
-import { computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class AnimationStateDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationTransitionDefinition.js

@@ -1,5 +1,6 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationTransitionDefinition {
     constructor() {

package/engine/graphics/ecs/camera/CameraClippingPlaneComputer.js

@@ -1,7 +1,7 @@
-import { isValueBetweenInclusive } from "../../../../core/math/MathUtils.js";
 import { frustumFromCamera } from "./CameraSystem.js";
 import { Frustum as ThreeFrustum } from "three";
 import { v3_dot } from "../../../../core/geom/v3_dot.js";
+import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
 
 const CLIPPING_EPSILON = 0.001;
 

package/engine/graphics/ecs/highlight/HighlightDefinition.js

@@ -1,7 +1,8 @@
 import { Color } from "../../../../core/color/Color.js";
 import { assert } from "../../../../core/assert.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../../../ecs/storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 export class HighlightDefinition {
     constructor() {