@woosh/meep-engine 2.34.19 → 2.34.24

package/core/binary/BitSet.js

@@ -509,6 +509,26 @@ BitSet.prototype.getAndClear = function (index) {
     return v;
 };
 
+/**
+ *
+ * @param {number} distance
+ * @param {number} start_index
+ * @param {number} end_index
+ */
+BitSet.prototype.shift = function (distance, start_index, end_index) {
+    if (distance > 0) {
+        for (let i = end_index; i >= start_index; i--) {
+            const v = this.get(i);
+            this.set(i + distance, v);
+        }
+    } else {
+        for (let i = start_index; i <= end_index; i++) {
+            const v = this.get(i);
+            this.set(i + distance, v);
+        }
+    }
+};
+
 /**
  * Sets all of the bits in this BitSet to false.
  */

package/core/bvh2/aabb3/aabb3_nearest_point_on_surface.js

@@ -0,0 +1,65 @@
+import { clamp } from "../../math/clamp.js";
+import { min2 } from "../../math/min2.js";
+
+//
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>} result
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} r_x
+ * @param {number} r_y
+ * @param {number} r_z
+ */
+export function aabb3_nearest_point_on_surface(result, x0, y0, z0, x1, y1, z1, r_x, r_y, r_z) {
+    const ar_x0 = Math.abs(r_x - x0);
+    const ar_x1 = Math.abs(r_x - x1);
+    const ar_x_min = min2(ar_x0, ar_x1);
+
+    const ar_y0 = Math.abs(r_y - y0);
+    const ar_y1 = Math.abs(r_y - y1);
+    const ar_y_min = min2(ar_y0, ar_y1);
+
+    const ar_z0 = Math.abs(r_z - z0);
+    const ar_z1 = Math.abs(r_z - z1);
+    const ar_z_min = min2(ar_z0, ar_z1);
+
+    // figure out closest face to the reference point
+    if (ar_x_min > ar_y_min && ar_x_min > ar_z_min) {
+        // X is smallest, project onto X axis
+        if (ar_x0 <= ar_x1) {
+            result[0] = x0;
+        } else {
+            result[0] = x1;
+        }
+
+        result[1] = clamp(r_y, y0, y1);
+        result[2] = clamp(r_z, z0, z1);
+    } else if (ar_y_min > ar_x_min && ar_y_min > ar_z_min) {
+        // Y is smallest, project onto X axis
+        if (ar_y0 <= ar_y1) {
+            result[1] = y0;
+        } else {
+            result[1] = y1;
+        }
+
+        result[0] = clamp(r_x, x0, x1);
+        result[2] = clamp(r_z, z0, z1);
+    } else {
+        // project onto Z axis
+
+        if (ar_z0 <= ar_z1) {
+            result[2] = z0;
+        } else {
+            result[2] = z1;
+        }
+
+        result[0] = clamp(r_x, x0, x1);
+        result[1] = clamp(r_y, y0, y1);
+    }
+}

package/core/collection/list/List.js

@@ -919,4 +919,34 @@ List.prototype.equals = function (other) {
     return true;
 };
 
+/**
+ *
+ * @param {List<T>} other
+ * @returns {number}
+ */
+List.prototype.compare = function (other) {
+    const l = this.length;
+
+    const other_length = other.length;
+    if (l !== other_length) {
+        return l - other_length;
+    }
+
+    for (let i = 0; i < l; i++) {
+        const a = this.get(i);
+
+        const b = other.get(i);
+
+        const delta = a.compare(b);
+
+        if (delta !== 0) {
+            return delta;
+        }
+
+    }
+
+    // same
+    return 0;
+};
+
 export default List;

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -4,8 +4,8 @@ import { v3_length } from "../../v3_length.js";
 import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
 import { min2 } from "../../../math/min2.js";
-import { clamp } from "../../../math/clamp.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { aabb3_nearest_point_on_surface } from "../../../bvh2/aabb3/aabb3_nearest_point_on_surface.js";
 
 export class UnitCubeShape3D extends AbstractShape3D {
 
@@ -18,43 +18,13 @@ export class UnitCubeShape3D extends AbstractShape3D {
         const r_y = reference[1];
         const r_z = reference[2];
 
-        // figure out closest face to the reference point
-        const ar_x = Math.abs(r_x);
-        const ar_y = Math.abs(r_y);
-        const ar_z = Math.abs(r_z);
+        aabb3_nearest_point_on_surface(
+            result,
+            -0.5, -0.5, -0.5,
+            0.5, 0.5, 0.5,
+            r_x, r_y, r_z
+        );
 
-        if (ar_x > ar_y && ar_x > ar_z) {
-            // X is smallest, project onto X axis
-            if (r_x <= 0) {
-                result[0] = -0.5;
-            } else {
-                result[0] = 0.5;
-            }
-
-            result[1] = clamp(r_y, -0.5, 0.5);
-            result[2] = clamp(r_z, -0.5, 0.5);
-        } else if (ar_y > ar_x && ar_y > ar_z) {
-            // Y is smallest, project onto X axis
-            if (r_y <= 0) {
-                result[1] = -0.5;
-            } else {
-                result[1] = 0.5;
-            }
-
-            result[0] = clamp(r_x, -0.5, 0.5);
-            result[2] = clamp(r_z, -0.5, 0.5);
-        } else {
-            // project onto Z axis
-
-            if (r_z <= 0) {
-                result[2] = -0.5;
-            } else {
-                result[2] = 0.5;
-            }
-
-            result[0] = clamp(r_x, -0.5, 0.5);
-            result[1] = clamp(r_y, -0.5, 0.5);
-        }
     }
 
     signed_distance_gradient_at_point(result, point) {

package/core/geom/3d/sphere/sphere_array_intersects_ray.js

@@ -0,0 +1,25 @@
+//
+
+import { sphere_intersects_ray } from "./sphere_intersects_ray.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>} sphere
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function sphere_array_intersects_ray(
+    sphere,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    return sphere_intersects_ray(sphere[0], sphere[1], sphere[2], sphere[3],
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    );
+}

package/core/geom/3d/sphere/sphere_intersects_ray.js

@@ -0,0 +1,51 @@
+//
+
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {number} center_x
+ * @param {number} center_y
+ * @param {number} center_z
+ * @param {number} radius
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function sphere_intersects_ray(
+    center_x, center_y, center_z, radius,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    const delta_x = center_x - origin_x;
+    const delta_y = center_y - origin_y;
+    const delta_z = center_z - origin_z;
+
+    const tca = v3_dot(delta_x, delta_y, delta_z, direction_x, direction_y, direction_z);
+    const d2 = v3_dot(delta_x, delta_y, delta_z, delta_x, delta_y, delta_z) - tca * tca;
+
+    const radius2 = radius * radius;
+
+    if (d2 > radius2) {
+        return false;
+    }
+
+    const thc = Math.sqrt(radius2 - d2);
+
+    // t0 = first intersect point - entrance on front of sphere
+    const t0 = tca - thc;
+
+    // t1 = second intersect point - exit point on back of sphere
+    const t1 = tca + thc;
+
+    // test to see if both t0 and t1 are behind the ray - if so, no intersection
+    if (t0 < 0 && t1 < 0) {
+        return false;
+    }
+
+    return true;
+}

package/core/model/object/invokeObjectClone.js

@@ -6,3 +6,5 @@
 export function invokeObjectClone(object) {
     return object.clone();
 }
+
+

package/core/model/object/invokeObjectCompare.js

@@ -0,0 +1,9 @@
+/**
+ * @template {{compare:function(T):number}} T
+ * @param {T} a
+ * @param {T} b
+ * @return {number}
+ */
+export function invokeObjectCompare(a, b) {
+    return a.compare(b);
+}

package/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -513,7 +513,13 @@ export async function merge_patches(
         return 0;
     } else if (node_count === 1) {
         // only 1 patch, no merge opportunity, forward it to output directly
-        output[output_offset.value++] = nodes[0];
+        const node = nodes[0];
+
+        //set group bounds to produce a valid root
+        node.group_aabb.copy(node.bounding_box);
+        node.group_bounding_sphere.set(node.bounding_sphere);
+
+        output[output_offset.value++] = node;
         return 1;
     } else {
 

package/engine/graphics/micron/format/MicronGeometry.js

@@ -3,6 +3,7 @@ import { assert } from "../../../../core/assert.js";
 import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
+import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
 
 let id_counter = 0;
 
@@ -104,16 +105,23 @@ export class MicronGeometry {
 
             const patch = stack[stack_cursor];
 
-            // using group bounding box because it's conservative, as we want to be able to hit LOD_0
-            const bb = patch.group_bounding_box;
+            // using group bounds because it's conservative, as we want to be able to hit LOD_0
 
-            const bb_intersection_exists = aabb3_array_intersects_ray(
-                bb,
+            // sphere test
+            if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
                 origin_x, origin_y, origin_z,
                 direction_x, direction_y, direction_z
-            );
+            )) {
+                continue;
+            }
+
 
-            if (!bb_intersection_exists) {
+            // box test (more expensive, different volume)
+            if (!aabb3_array_intersects_ray(
+                patch.group_bounding_box,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            )) {
                 // no intersection
                 continue;
             }
@@ -122,6 +130,16 @@ export class MicronGeometry {
                 // LOD 0 - source geometry
 
                 // cast against bounds
+
+                // sphere test
+                if (!sphere_array_intersects_ray(patch.bounding_sphere,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                )) {
+                    continue;
+                }
+
+                // box test
                 if (!aabb3_array_intersects_ray(
                     patch.bounding_box,
                     origin_x, origin_y, origin_z,

package/engine/graphics/micron/format/serialization/deserialize_patch.js

@@ -1,6 +1,7 @@
 import { aabb3_build_corners } from "../../../../../core/geom/3d/aabb/aabb3_build_corners.js";
 import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { v3_distance } from "../../../../../core/geom/v3_distance.js";
 
 /**
  *
@@ -18,17 +19,6 @@ export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
     buffer.readFloat32Array(gbb, 0, 6);
     buffer.readFloat32Array(patch.group_bounding_sphere, 0, 4);
 
-    // reconstruct corners
-    aabb3_build_corners(
-        patch.group_bounding_box_corners,
-        0,
-        gbb[0],
-        gbb[1],
-        gbb[2],
-        gbb[3],
-        gbb[4],
-        gbb[5]
-    );
 
     patch.group_error = buffer.readFloat32();
     patch.lod = buffer.readUintVar();
@@ -101,4 +91,43 @@ export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
 
         patch.vertex_attribute_arrays[i] = array;
     }
+
+
+    // validate and fix group bounds as necessary
+    if (
+        patch.group_bounding_box[0] > patch.bounding_box[0] // x0
+        || patch.group_bounding_box[1] > patch.bounding_box[1] // y0
+        || patch.group_bounding_box[2] > patch.bounding_box[2] // x0
+        || patch.group_bounding_box[3] < patch.bounding_box[3] // x1
+        || patch.group_bounding_box[4] < patch.bounding_box[4] // y1
+        || patch.group_bounding_box[5] < patch.bounding_box[5] // z1
+    ) {
+        // bounds are violated, fix
+        patch.group_bounding_box.set(patch.bounding_box);
+    }
+
+    if (v3_distance(
+        patch.group_bounding_sphere[0],
+        patch.group_bounding_sphere[1],
+        patch.group_bounding_sphere[2],
+        patch.bounding_sphere[0],
+        patch.bounding_sphere[1],
+        patch.bounding_sphere[2]
+    ) + patch.bounding_sphere[3] > patch.group_bounding_sphere[3]) {
+        // group's sphere bounds are violated, fix
+        patch.group_bounding_sphere.set(patch.bounding_sphere);
+    }
+
+
+    // reconstruct corners
+    aabb3_build_corners(
+        patch.group_bounding_box_corners,
+        0,
+        gbb[0],
+        gbb[1],
+        gbb[2],
+        gbb[3],
+        gbb[4],
+        gbb[5]
+    );
 }

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

@@ -42,6 +42,9 @@ import { Decal } from "./model/Decal.js";
 import { ReferencedTextureAtlas } from "../../texture/atlas/ReferencedTextureAtlas.js";
 import { v3_morton_encode_transformed } from "../../../../core/geom/3d/morton/v3_morton_encode_transformed.js";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
+import { invokeObjectCompare } from "../../../../core/model/object/invokeObjectCompare.js";
 
 const LOOKUP_CACHE_SIZE = 1024; // must be power of two
 
@@ -227,7 +230,13 @@ export class LightManager {
          * @readonly
          * @private
          */
-        this.__visible_lights = new IncrementalDeltaSet();
+        this.__visible_lights = new IncrementalDeltaSet(invokeObjectCompare);
+        /**
+         *
+         * @type {PointLightData[]}
+         * @private
+         */
+        this.__sorted_visible_lights = [];
 
         /**
          *
@@ -520,10 +529,18 @@ export class LightManager {
      * @private
      */
     __sort_visible_light() {
-        this.__visible_lights.sort(
-            this.__sort_visible_light_score,
-            this
-        );
+        const sorted_lights = this.__sorted_visible_lights;
+        const visible_light_set = this.__visible_lights;
+        const visible_light_count = visible_light_set.size;
+
+        if (sorted_lights.length > visible_light_count) {
+            // crop array if it's too big
+            sorted_lights.splice(visible_light_count, sorted_lights.length - visible_light_count)
+        }
+
+        array_copy(visible_light_set.elements, 0, sorted_lights, 0, visible_light_count);
+
+        arrayQuickSort(sorted_lights, this.__sort_visible_light_score, this, 0, visible_light_count - 1);
     }
 
     __update_visible_bvh() {
@@ -615,7 +632,7 @@ export class LightManager {
          *
          * @type {PointLightData[]}
          */
-        const visible_lights = this.__visible_lights.elements;
+        const visible_lights = this.__sorted_visible_lights;
 
         // write light data into texture
         const visible_light_count = visible_lights.length;

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

@@ -21,6 +21,15 @@ export class PointLightData {
         this.bvh_leaf_main = new LeafNode(this, 0, 0, 0, 0, 0, 0);
     }
 
+    /**
+     *
+     * @param {PointLightData} other
+     * @returns {number}
+     */
+    compare(other) {
+        return this.light.compare(other.light);
+    }
+
     update() {
 
         const leaf = this.bvh_leaf_main;

package/engine/graphics/render/forward_plus/model/AbstractLight.js

@@ -1,4 +1,9 @@
+let id_counter = 0;
+
 export class AbstractLight {
+    constructor() {
+        this.id = id_counter++;
+    }
 
     /**
      *
@@ -47,4 +52,15 @@ export class AbstractLight {
     toArray(destination, address) {
         throw new Error('Not Implemented');
     }
+
+    /**
+     *
+     * @param {AbstractLight} other
+     * @returns {number}
+     */
+    compare(other) {
+        return this.id - other.id;
+    }
 }
+
+AbstractLight.prototype.type = 'Abstract';

package/engine/graphics/render/layers/RenderLayer.js

@@ -12,6 +12,7 @@ import { ThreeFrustumsIntersectionBVHVisitor } from "../../../../core/bvh2/trave
 import { traverseBinaryNodeUsingVisitor } from "../../../../core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js";
 import { ThreeClippingPlaneComputingBVHVisitor } from "../../../../core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js";
 import { RenderLayerState } from "./RenderLayerState.js";
+import { compare_three_objects } from "../../three/compare_three_objects.js";
 
 
 class VisibleLeafCollector extends BVHVisitor {
@@ -109,9 +110,9 @@ export class RenderLayer {
 
         /**
          * Contains visible elements across all views, if element is in at least one view - it will be here
-         * @type {IncrementalDeltaSet<Object3D>}
+         * @type {IncrementalDeltaSet<THREE.Object3D>}
          */
-        this.visibleSet = new IncrementalDeltaSet();
+        this.visibleSet = new IncrementalDeltaSet(compare_three_objects);
 
         /**
          *

package/engine/graphics/render/view/CameraView.js

@@ -5,6 +5,7 @@ import { frustumFromCamera } from "../../ecs/camera/CameraSystem.js";
 import { Frustum } from "three";
 import { read_frustum_planes_to_array } from "../forward_plus/cluster/read_frustum_planes_to_array.js";
 import Signal from "../../../../core/events/signal/Signal.js";
+import { compare_three_objects } from "../../three/compare_three_objects.js";
 
 const DEFAULT_FLAGS = CameraViewFlags.Active
     | CameraViewFlags.AdaptivePlaneNear
@@ -52,7 +53,7 @@ export class CameraView {
          *
          * @type {IncrementalDeltaSet<THREE.Object3D>}
          */
-        this.visible_objects = new IncrementalDeltaSet();
+        this.visible_objects = new IncrementalDeltaSet(compare_three_objects);
 
         /**
          *

package/engine/graphics/render/visibility/IncrementalDeltaSet.d.ts

@@ -3,6 +3,8 @@ export class IncrementalDeltaSet<T> {
     version: number
     size: number
 
+    constructor(compare: (a: T, b: T) => number)
+
     contains(element: T): boolean
 
     push(element: T): void
@@ -14,6 +16,4 @@ export class IncrementalDeltaSet<T> {
     initializeUpdate(): void
 
     finalizeUpdate(): void
-
-    sort(f: (T) => number, ctx?: any): void
 }

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

@@ -2,7 +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";
+import { binarySearchHighIndex } from "../../../../core/collection/array/binarySearchHighIndex.js";
 
 /**
  * @readonly
@@ -16,15 +16,30 @@ const IncrementalDeltaSetState = {
 
 /**
  * accelerated Set data structure optimized for incremental re-building
+ * Always sorted
  * @template V
  */
 export class IncrementalDeltaSet {
-    constructor() {
+    /**
+     *
+     * @param {function(V,V):number} compare stable comparator
+     */
+    constructor(compare) {
+        assert.isFunction(compare, 'compare');
+
         /**
          *
          * @type {V[]}
+         * @private
          */
-        this.elements = [];
+        this.__elements = [];
+
+        /**
+         *
+         * @type {function(V, V): number}
+         * @private
+         */
+        this.__compare = compare;
 
         /**
          * Current version of the state, each time the set is updated - version changes
@@ -69,15 +84,39 @@ export class IncrementalDeltaSet {
         this.state = IncrementalDeltaSetState.Clear;
     }
 
+    /**
+     *
+     * @return {V[]}
+     */
+    get elements() {
+        return this.__elements;
+    }
 
     /**
      *
+     * @param {(V)=>any} visitor
+     * @param {*} [visitorContext]
+     */
+    forEach(visitor, visitorContext) {
+        const n = this.size;
+        const elements = this.__elements;
+
+        for (let i = 0; i < n; i++) {
+            const el = elements[i];
+
+            visitor.call(visitorContext, el);
+        }
+    }
+
+
+    /**
+     * @deprecated
      * @param {function(T):number} score_function
      * @param {*} [score_context]
      * @returns {void}
      */
     sort(score_function, score_context) {
-        arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);
+        throw new Error('Deprecated, the set is always sorted');
     }
 
     /**
@@ -86,7 +125,33 @@ export class IncrementalDeltaSet {
      * @returns {boolean}
      */
     contains(element) {
-        return this.elements.indexOf(element) !== -1;
+        return this.__indexOf(element) !== -1;
+    }
+
+    /**
+     *
+     * @param {V} element
+     * @return {number}
+     * @private
+     */
+    __indexOf(element) {
+        const i = this.__indexExpected(element);
+
+        if (this.__elements[i] === element) {
+            return i;
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     *
+     * @param {V} element
+     * @return {number}
+     * @private
+     */
+    __indexExpected(element) {
+        return binarySearchHighIndex(this.__elements, element, this.__compare, 0, this.size - 1);
     }
 
     /**
@@ -99,10 +164,10 @@ export class IncrementalDeltaSet {
             throw new IllegalStateException("Cannot remove during build");
         }
 
-        const i = this.elements.indexOf(element, 0);
+        const i = this.__indexOf(element);
 
         if (i !== -1) {
-            this.elements.splice(i, 1);
+            this.__elements.splice(i, 1);
             this.size--;
 
             this.version++;
@@ -119,7 +184,7 @@ export class IncrementalDeltaSet {
             return;
         }
 
-        this.elements.splice(0, this.size);
+        this.__elements.splice(0, this.size);
         this.size = 0;
         this.flags.reset();
 
@@ -153,14 +218,17 @@ export class IncrementalDeltaSet {
         let deletions = 0;
 
         //go through all dirty flags and remove corresponding elements
+        const flags = this.flags;
+        const elements = this.__elements;
+
         for (
-            let i = this.flags.nextSetBit(0);
+            let i = flags.nextSetBit(0);
             i !== -1;
-            i = this.flags.nextSetBit(i + 1)
+            i = flags.nextSetBit(i + 1)
         ) {
             const index = i - deletions;
 
-            const removed = this.elements.splice(index, 1);
+            const removed = elements.splice(index, 1);
 
             this.onRemoved.send1(removed[0]);
 
@@ -170,7 +238,7 @@ export class IncrementalDeltaSet {
         //update size
         this.size -= deletions;
 
-        this.flags.reset();
+        flags.reset();
 
         this.state = IncrementalDeltaSetState.Ready;
 
@@ -184,19 +252,26 @@ export class IncrementalDeltaSet {
      */
     push(element) {
         //check if element is already in the set
-        const elements = this.elements;
-        const i = elements.indexOf(element); //TODO this can probably be done faster. Maybe use a bloom filter? or some kind of a hash
+        const index = this.__indexExpected(element);
 
-        if (i === -1) {
-            elements.push(element);
+        const elements = this.__elements;
+
+        if (elements[index] !== element) {
+            // element is not in the set
+
+            // shift flags to make space for it
+            this.flags.shift(1, index, this.size);
+
+            // insert
+            elements.splice(index, 0, element);
             this.size++;
 
             this.onAdded.send1(element);
-        } else {
-            //Existing element. We're keeping it. clear dirty flag
-            this.flags.clear(i);
         }
 
+        // clear flag for inserted element
+        this.flags.clear(index);
+
     }
 
     /**
@@ -204,7 +279,7 @@ export class IncrementalDeltaSet {
      * @param {IncrementalDeltaSet<V>} other
      */
     pushOther(other) {
-        const elements = other.elements;
+        const elements = other.__elements;
         const n = other.size;
         for (let i = 0; i < n; i++) {
             const el = elements[i];

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

@@ -0,0 +1,46 @@
+import { IncrementalDeltaSet } from "./IncrementalDeltaSet.js";
+import { compareNumbersAscending } from "../../../../core/function/Functions.js";
+
+test('set is sorted after insert, push 1,2', () => {
+    const set = new IncrementalDeltaSet(compareNumbersAscending);
+
+    set.push(1);
+    set.push(2);
+
+    expect(set.elements[0]).toBe(1);
+    expect(set.elements[1]).toBe(2);
+});
+
+test('set is sorted after insert, push 2,1', () => {
+    const set = new IncrementalDeltaSet(compareNumbersAscending);
+
+    set.push(2);
+    set.push(1);
+
+    expect(set.elements[0]).toBe(1);
+    expect(set.elements[1]).toBe(2);
+});
+
+test('set is sorted after insert, push 1,2,3', () => {
+    const set = new IncrementalDeltaSet(compareNumbersAscending);
+
+    set.push(1);
+    set.push(2);
+    set.push(3);
+
+    expect(set.elements[0]).toBe(1);
+    expect(set.elements[1]).toBe(2);
+    expect(set.elements[2]).toBe(3);
+});
+
+test('set is sorted after insert, push 3,2,1', () => {
+    const set = new IncrementalDeltaSet(compareNumbersAscending);
+
+    set.push(3);
+    set.push(2);
+    set.push(1);
+
+    expect(set.elements[0]).toBe(1);
+    expect(set.elements[1]).toBe(2);
+    expect(set.elements[2]).toBe(3);
+});

package/engine/graphics/three/compare_three_objects.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {THREE.Object3D} a
+ * @param {THREE.Object3D} b
+ */
+export function compare_three_objects(a, b) {
+    return a.id - b.id;
+}

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

@@ -16,6 +16,8 @@ import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { compareStrings } from "../../../../core/primitives/strings/compareStrings.js";
+import { compareNumbers } from "../../../../core/primitives/numbers/compareNumbers.js";
 
 /**
  * Convert decibel to percentage volume
@@ -127,6 +129,63 @@ export class SoundEmitter {
 
     }
 
+    /**
+     *
+     * @param {SoundEmitter} other
+     * @returns number
+     */
+    compare(other) {
+        const tracks = this.tracks.compare(other.tracks);
+
+        if (tracks !== 0) {
+            return tracks;
+        }
+
+        const channel = compareStrings(this.channel, other.channel);
+
+        if (channel !== 0) {
+            return channel;
+        }
+
+        const distanceMin = compareNumbers(this.__distanceMin, other.__distanceMin);
+
+        if (distanceMin !== 0) {
+            return distanceMin;
+        }
+        const distanceMax = compareNumbers(this.__distanceMax, other.__distanceMax);
+
+        if (distanceMax !== 0) {
+            return distanceMax;
+        }
+
+        const panningModel = compareNumbers(this.panningModel, other.panningModel);
+
+        if (panningModel !== 0) {
+            return panningModel;
+        }
+
+        const attenuation = compareNumbers(this.attenuation, other.attenuation);
+
+        if (attenuation !== 0) {
+            return attenuation;
+        }
+
+        const flags = compareNumbers(this.flags, other.flags);
+
+        if (flags !== 0) {
+            return flags;
+        }
+
+        const volume = compareNumbers(this.volume.getValue(), other.volume.getValue());
+
+        if (volume !== 0) {
+            return volume;
+        }
+
+
+        return 0;
+    }
+
 
     /**
      *

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

@@ -45,6 +45,14 @@ export class SoundEmitterComponentContext {
         this.__isConnected = false;
     }
 
+    /**
+     *
+     * @param {SoundEmitterComponentContext} other
+     */
+    compare(other) {
+        return this.emitter.compare(other.emitter);
+    }
+
     update() {
 
         const position = this.transform.position;

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

@@ -18,6 +18,7 @@ import { tryRotateSingleNode } from "../../../../core/bvh2/transform/RotationOpt
 import { SoundEmitterComponentContext } from "./SoundEmitterComponentContext.js";
 import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundEmitterChannel } from "./SoundEmitterChannel.js";
+import { invokeObjectCompare } from "../../../../core/model/object/invokeObjectCompare.js";
 
 /**
  * @readonly
@@ -96,7 +97,7 @@ export class SoundEmitterSystem extends System {
          *
          * @type {IncrementalDeltaSet<SoundEmitterComponentContext>}
          */
-        this.activeSet = new IncrementalDeltaSet();
+        this.activeSet = new IncrementalDeltaSet(invokeObjectCompare);
 
         /**
          * Spatial index

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

@@ -4,6 +4,8 @@ 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";
+import { compareStrings } from "../../../../core/primitives/strings/compareStrings.js";
+import { compareNumbers } from "../../../../core/primitives/numbers/compareNumbers.js";
 
 const DEFAULT_FLAGS = SoundTrackFlags.StartWhenReady;
 
@@ -55,6 +57,45 @@ export class SoundTrack {
         this.nodes = null;
     }
 
+    /**
+     *
+     * @param {SoundTrack} other
+     * @returns number
+     */
+    compare(other) {
+        const url = compareStrings(this.url, other.url);
+
+        if (url !== 0) {
+            return url;
+        }
+
+        const time = compareNumbers(this.time, other.time);
+
+        if (time !== 0) {
+            return time;
+        }
+
+        const channel = compareStrings(this.channel, other.channel);
+
+        if (channel !== 0) {
+            return channel;
+        }
+
+        const volume = compareNumbers(this.__volume, other.__volume);
+
+        if (volume !== 0) {
+            return volume;
+        }
+
+        const flags = compareNumbers(this.flags, other.flags);
+
+        if (flags !== 0) {
+            return flags;
+        }
+
+        return 0;
+    }
+
     /**
      *
      * @param {number|SoundEmitterFlags} flag

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.19",
+  "version": "2.34.24",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",