@woosh/meep-engine 2.33.23 → 2.33.24

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_objects.js

@@ -0,0 +1,131 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { spot_light_inside_volume } from "./spot_light_inside_volume.js";
+
+/**
+ *
+ * @type {(BinaryNode|LeafNode)[]}
+ */
+const stack = [];
+
+let stackPointer = 0;
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {PointLightData[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryNode<PointLightData>} root
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_objects(
+    destination,
+    destination_offset,
+    root, planes, points
+) {
+    let i = 0;
+    let j = 0;
+    // read out points
+    const stackOffset = stackPointer;
+
+    stack[stackPointer] = root;
+
+    stackPointer++;
+
+    stack_loop:while (stackPointer-- > stackOffset) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+
+        const n = stack[stackPointer];
+
+        if (n.isBinaryNode === true) {
+
+            for (j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n.x0, n.y0, n.z0,
+                    n.x1, n.y1, n.z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+            }
+
+
+            if (n.right !== null) {
+                stack[stackPointer] = n.right;
+                stackPointer++;
+            }
+
+            if (n.left !== null) {
+                stack[stackPointer] = n.left;
+                stackPointer++
+            }
+
+        } else {
+
+            // leaf node
+
+            /**
+             *
+             * @type {PointLightData}
+             */
+            const light_data = n.object;
+
+            const light = light_data.light;
+
+            if (light.isPointLight) {
+
+                const light_position = light.position;
+
+                const light_x = light_position.x;
+                const light_y = light_position.y;
+                const light_z = light_position.z;
+
+                const radius = light.radius.getValue();
+
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    continue;
+                }
+            } else if (light.isSpotLight) {
+                if (!spot_light_inside_volume(light, points, planes)) {
+                    continue;
+                }
+            }
+
+            destination[destination_offset + i] = light_data;
+
+            i++;
+        }
+
+    }
+
+    //drop the stack frame
+    stackPointer = stackOffset;
+
+    return i;
+}
+
+query_bvh_frustum_from_objects.iteration_count = 0;
+query_bvh_frustum_from_objects.rejection_count = 0;
+query_bvh_frustum_from_objects.rejection_sphere_count = 0;
+query_bvh_frustum_from_objects.plane_tests = 0;
+query_bvh_frustum_from_objects.plane_tests_early_exits = 0;
+query_bvh_frustum_from_objects.checks_sphere = 0;
+query_bvh_frustum_from_objects.checks_sphere_plane = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_corner = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_edge = 0;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -0,0 +1,129 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const stack = [];
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryUint32BVH} root
+ * @param {number[]|Uint8ClampedArray} source_data
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_texture(
+    destination,
+    destination_offset,
+    root,
+    source_data,
+    planes, points
+) {
+
+    let stackPointer = 1;
+    let result = 0;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[0] = 0;
+
+    const binary_node_count = root.getBinaryNodeCount();
+    const last_valid_index = binary_node_count + root.getLeafNodeCount();
+    const data_view = root.getDataView();
+
+    stack_loop:while (stackPointer-- > 0) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stackPointer];
+
+        if (node_index < binary_node_count) {
+            // is intermediate node
+            const node_address = node_index * BVH_BINARY_NODE_SIZE;
+
+            const n_x0 = data_view.getFloat32(node_address);
+            const n_y0 = data_view.getFloat32(node_address + 4);
+            const n_z0 = data_view.getFloat32(node_address + 8);
+            const n_x1 = data_view.getFloat32(node_address + 12);
+            const n_y1 = data_view.getFloat32(node_address + 16);
+            const n_z1 = data_view.getFloat32(node_address + 20);
+
+            for (let j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n_x0, n_y0, n_z0,
+                    n_x1, n_y1, n_z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+
+                // TODO under current scheme we can reserve 6 bit in what we push onto the stack for plane mask (allows us to skip some planar tests)
+            }
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            if (left_index < last_valid_index) {
+                stack[stackPointer] = left_index;
+                stackPointer++;
+            }
+
+            if (right_index < last_valid_index) {
+                stack[stackPointer] = right_index;
+                stackPointer++;
+            }
+
+
+        } else {
+            // leaf node
+            const leaf_index = node_index - binary_node_count;
+            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
+
+            const light_index = data_view.getUint32(node_address + 24);
+
+            const light_address = light_index * 8;
+
+            // TODO figure out light type from address
+
+
+            const light_x = source_data[light_address];
+            const light_y = source_data[light_address + 1];
+            const light_z = source_data[light_address + 2];
+
+            const radius = source_data[light_address + 3];
+
+            if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                continue;
+            }
+
+            // write to output
+            destination[destination_offset + result] = light_index;
+
+            result++;
+        }
+
+    }
+
+    return result;
+}

package/engine/graphics/render/forward_plus/query/spot_light_inside_volume.js

@@ -0,0 +1,33 @@
+import { computeConePlaneSide } from "../../../../../core/geom/3d/cone/computeConePlaneSide.js";
+
+/**
+ *
+ * @param {SpotLight} light
+ * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+export function spot_light_inside_volume(light, points, planes) {
+    for (let j = 0; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = computeConePlaneSide(
+            plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+            light.position.x, light.position.y, light.position.z,
+            light.direction.x, light.direction.y, light.direction.z,
+            light.angle.getValue(), light.distance.getValue()
+        );
+
+        if (side < 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/forward_plus/read_frustum_corner.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} source_index
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ */
+export function read_frustum_corner(source, source_index, destination, destination_offset) {
+    const address = source_index * 3;
+
+    destination[destination_offset] = source[address];
+    destination[destination_offset + 1] = source[address + 1];
+    destination[destination_offset + 2] = source[address + 2];
+}

package/engine/graphics/render/forward_plus/testClusterEquality.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {number[]} light_data
+ * @param {number} count
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array|Uint8ClampedArray} light_lookup_texture_data
+ * @param {number} address
+ * @returns {boolean}
+ */
+export function testClusterEquality(light_data, count, light_lookup_texture_data, address) {
+    for (let i = 0; i < count; i++) {
+
+        const existing_light_address = light_lookup_texture_data[address + i];
+
+        const datum = light_data[i] * 2;
+
+        if (datum !== existing_light_address) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -2,6 +2,7 @@ import { BitSet } from "../../../../core/binary/BitSet.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
+import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
 
 /**
  * @readonly
@@ -68,6 +69,16 @@ export class IncrementalDeltaSet {
         this.state = IncrementalDeltaSetState.Clear;
     }
 
+
+    /**
+     *
+     * @param {function(T):number} score_function
+     * @param {*} [score_context]
+     */
+    sort(score_function, score_context) {
+        arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);
+    }
+
     /**
      *
      * @param {V} element

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -62,7 +62,6 @@ import { buildCanvasViewFromTexture } from "./buildCanvasViewFromTexture.js";
 import { BatchOcclusionQuery } from "./query/BatchOcclusionQuery.js";
 import HeadsUpDisplay from "../../../../ecs/gui/hud/HeadsUpDisplay.js";
 import LabelView from "../../../../../view/common/LabelView.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
@@ -71,6 +70,7 @@ import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 import { mat4 } from "gl-matrix";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 const engineHarness = new EngineHarness();
 

package/engine/graphics/texture/sampler/HarmonicDiffusionGrid.spec.js

@@ -1,6 +1,6 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { HarmonicDiffusionGrid } from "./HarmonicDiffusionGrid.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new HarmonicDiffusionGrid([], 0, 0);

package/engine/graphics/texture/sampler/SampleTraverser.js

@@ -3,8 +3,8 @@
  */
 import QuadTree from '../../../../core/geom/2d/quad-tree/PointQuadTree.js';
 import AABB2 from '../../../../core/geom/AABB2.js';
-import { makeRangedRandom} from '../../../../core/math/MathUtils.js';
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { makeRangedRandom } from "../../../../core/math/random/makeRangedRandom.js";
 
 
 const Point2 = function (x, y) {

package/engine/graphics/texture/sampler/distanceField.spec.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "./Sampler2D.js";
 import { computeUnsignedDistanceField } from "./distanceField.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 describe('computeUnsignedDistanceField', () => {
     test('empty', () => {

package/engine/grid/components/GridObstacle.js

@@ -4,11 +4,11 @@
 
 
 import Vector2 from '../../../core/geom/Vector2.js';
-import { computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { computeIntegerArrayHash } from "../../../core/primitives/array/computeIntegerArrayHash.js";
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 
 class GridObstacle {
     constructor() {

package/engine/intelligence/behavior/selector/WeightedElement.js

@@ -1,7 +1,8 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { assert } from "../../../../core/assert.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 export class WeightedElement {
 

package/engine/intelligence/optimization/RandomOptimizer.js

@@ -1,5 +1,5 @@
-import { randomFromArray} from "../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 
 /**
  * Hill climbing optimizer based on random moves

package/engine/navigation/ecs/components/Path.js

@@ -3,7 +3,6 @@
  */
 
 
-import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 
 import { CatmullRomCurve3 } from "three";
@@ -18,6 +17,7 @@ import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { InterpolationType } from "./InterpolationType.js";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
+import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
 
 const v3_a = new Vector3();
 const v3_b = new Vector3();

package/engine/navigation/grid/FastBinaryHeap.spec.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import BinaryHeap from "./FastBinaryHeap.js";
 import { passThrough, returnZero } from "../../../core/function/Functions.js";
-import { randomIntegerBetween} from "../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new BinaryHeap(returnZero);

package/engine/sound/ecs/emitter/SoundEmitter.js

@@ -10,11 +10,12 @@ import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundAttenuationFunction } from "./SoundAttenuationFunction.js";
 import { attenuateSoundLinear } from "./attenuate/attenuateSoundLinear.js";
 import { attenuateSoundLogarithmic } from "./attenuate/attenuateSoundLogarithmic.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { SoundPanningModelType } from "./SoundPanningModelType.js";
 import { attenuateSoundSmith } from "./attenuate/attenuateSoundSmith.js";
 import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue.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";
 
 /**
  * Convert decibel to percentage volume

package/engine/sound/ecs/emitter/SoundTrack.js

@@ -1,8 +1,9 @@
 import Signal from "../../../../core/events/signal/Signal.js";
 import { SoundTrackFlags } from "./SoundTrackFlags.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { assert } from "../../../../core/assert.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";
 
 const DEFAULT_FLAGS = SoundTrackFlags.StartWhenReady;
 

package/engine/sound/material/concrete/RandomSoundMaterial.js

@@ -1,6 +1,6 @@
 import { AbstractSoundMaterialDefinition } from "../AbstractSoundMaterialDefinition.js";
-import { randomFromArray } from "../../../../core/math/MathUtils.js";
 import { SoundAssetPlaybackSpec } from "../../asset/SoundAssetPlaybackSpec.js";
+import { randomFromArray } from "../../../../core/math/random/randomFromArray.js";
 
 export class RandomSoundMaterial extends AbstractSoundMaterialDefinition {
     constructor() {

package/engine/ui/notification/notificationGenerator.js

@@ -1,6 +1,6 @@
 import { Notification } from "../../notify/Notification.js";
-import { randomFromArray } from "../../../core/math/MathUtils.js";
 import { NotificationAreaKind } from "../GUIEngine.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 
 function notificationGenerator(callback, timeout = 5) {
     const phrases = [

package/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -1,5 +1,5 @@
 import { CellFilter } from "../../CellFilter.js";
-import { gaussian } from "../../../../core/math/MathUtils.js";
+import { gaussian } from "../../../../core/math/gaussian.js";
 
 function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
     const half_samples_x = (samplesX / 2);

package/generation/grid/generation/GridTaskExecuteRuleTimes.js

@@ -3,9 +3,10 @@ import { GridTaskGenerator } from "../GridTaskGenerator.js";
 import Task from "../../../core/process/task/Task.js";
 import TaskSignal from "../../../core/process/task/TaskSignal.js";
 import { BitSet } from "../../../core/binary/BitSet.js";
-import { PI_HALF, randomIntegerBetween} from "../../../core/math/MathUtils.js";
+import { PI_HALF } from "../../../core/math/MathUtils.js";
 import { actionTask } from "../../../core/process/task/TaskUtils.js";
 import TaskGroup from "../../../core/process/task/TaskGroup.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 export class GridTaskExecuteRuleTimes extends GridTaskGenerator {
     constructor() {

package/generation/markers/actions/MarkerNodeActionSelectRandom.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { MarkerNodeAction } from "./MarkerNodeAction.js";
 import { assert } from "../../../core/assert.js";
-import { randomFromArray} from "../../../core/math/MathUtils.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 
 export class MarkerNodeActionSelectRandom extends MarkerNodeAction {
     constructor() {

package/generation/markers/transform/MarkerNodeTransformerRecordUniqueRandomEnum.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
-import { randomIntegerBetween} from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 export class MarkerNodeTransformerRecordUniqueRandomEnum extends MarkerNodeTransformer {
     constructor() {

package/generation/placement/action/random/CellActionSelectRandom.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { GridCellAction } from "../GridCellAction.js";
-import { randomFromArray} from "../../../../core/math/MathUtils.js";
 import { assert } from "../../../../core/assert.js";
+import { randomFromArray } from "../../../../core/math/random/randomFromArray.js";
 
 export class CellActionSelectRandom extends GridCellAction {
     constructor() {

package/generation/theme/ThemeEngine.js

@@ -1,7 +1,6 @@
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { assert } from "../../core/assert.js";
 import { obtainTerrain } from "../../../model/game/scenes/SceneUtils.js";
-import { randomFloatBetween } from "../../core/math/MathUtils.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 import { TerrainLayerRuleAggregator } from "./TerrainLayerRuleAggregator.js";
 import { actionTask, countTask, emptyTask, futureTask } from "../../core/process/task/TaskUtils.js";
@@ -17,6 +16,7 @@ import { HashMap } from "../../core/collection/HashMap.js";
 import { TerrainLayer } from "../../engine/ecs/terrain/ecs/layers/TerrainLayer.js";
 import { TerrainFlags } from "../../engine/ecs/terrain/ecs/TerrainFlags.js";
 import { binarySearchLowIndex } from "../../core/collection/array/binarySearchLowIndex.js";
+import { randomFloatBetween } from "../../core/math/random/randomFloatBetween.js";
 
 /**
  *

package/misc/makeMaterialIconCached.js

@@ -1,8 +1,8 @@
 import { Cache } from "../core/cache/Cache.js";
-import { computeHashIntegerArray } from "../core/math/MathUtils.js";
 import { computeMaterialEquality } from "../engine/asset/loaders/material/computeMaterialEquality.js";
 import { computeMaterialHash } from "../engine/asset/loaders/material/computeMaterialHash.js";
 import { makeMaterialIcon } from "./makeMaterialIcon.js";
+import { computeHashIntegerArray } from "../core/collection/array/computeHashIntegerArray.js";
 
 /**
  *
@@ -47,4 +47,4 @@ export function makeMaterialIconCached(material, renderer, size) {
     }
 
     return sampler;
-}
+}

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.23",
+  "version": "2.33.24",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",

package/view/elements/image/HTMLElementCacheKey.js

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

package/view/elements/radial/RadialText.js

@@ -1,7 +1,8 @@
 import View from "../../View.js";
 import SVG, { svgCircularPath } from "../../SVG.js";
-import { isValueBetween, PI2 } from "../../../core/math/MathUtils.js";
+import { PI2 } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
+import { isValueBetween } from "../../../core/math/isValueBetween.js";
 
 let idCount = 0;