@woosh/meep-engine 2.36.22 → 2.36.23

package/core/binary/BitSet.js

@@ -278,12 +278,13 @@ BitSet.prototype.nextSetBit = function (fromIndex) {
     }
 
 
-    //scan the rest
+    //scan the rest of the words
     const word_count = bit_length / 32;
     for (; word_index < word_count; word_index++) {
         word = data[word_index];
 
         if (word === 0) {
+            // all 0s
             continue;
         }
 

package/core/bvh2/LeafNode.d.ts

@@ -2,4 +2,6 @@ import {Node} from "./Node";
 
 export class LeafNode<T> extends Node<T> {
     object: T
+
+    constructor(object: T, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number)
 }

package/core/collection/array/arrayQuickSort.js

@@ -35,15 +35,15 @@ export function arrayQuickSort(data, score_function, score_function_context, sta
 
         const pivotIndex = (left + right) >> 1;
 
-        const pivot = score_function.call(score_function_context,data[pivotIndex]);
+        const pivot = score_function.call(score_function_context, data[pivotIndex]);
 
         /* partition */
         while (i <= j) {
-            while (score_function.call(score_function_context,data[i]) < pivot) {
+            while (score_function.call(score_function_context, data[i]) < pivot) {
                 i++;
             }
 
-            while (score_function.call(score_function_context,data[j]) > pivot) {
+            while (score_function.call(score_function_context, data[j]) > pivot) {
                 j--;
             }
 
@@ -70,3 +70,73 @@ export function arrayQuickSort(data, score_function, score_function_context, sta
         }
     }
 }
+
+/**
+ * @template T
+ * @param {T[]} data
+ * @param {function(T,T):number} compare_function
+ * @param {*} compare_function_context
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_comparator(data, compare_function, compare_function_context, start, end) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    let stackPointer = 2;
+    let i, j;
+
+    stack[0] = start;
+    stack[1] = end;
+
+    while (stackPointer > 0) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = data[pivotIndex];
+
+        /* partition */
+        while (i <= j) {
+            while (compare_function.call(compare_function_context, data[i], pivot) < 0) {
+                i++;
+            }
+
+            while (compare_function.call(compare_function_context, data[j], pivot) > 0) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    const tmp = data[i];
+                    data[i] = data[j];
+                    data[j] = tmp;
+
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stackPointer++] = left;
+            stack[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack[stackPointer++] = i;
+            stack[stackPointer++] = right;
+        }
+    }
+}

package/core/collection/array/array_shrink_to_size.js

@@ -0,0 +1,14 @@
+//
+
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {number} length
+ */
+export function array_shrink_to_size(array, length) {
+    const delta = array.length - length;
+
+    if (delta > 0) {
+        array.splice(length, delta);
+    }
+}

package/engine/ecs/EntityComponentDataset.js

@@ -7,6 +7,7 @@ import Signal, {
 import { EventType } from "./EntityManager.js";
 import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
 import { arraySetDiff } from "../../core/collection/array/arraySetDiff.js";
+import { array_shrink_to_size } from "../../core/collection/array/array_shrink_to_size.js";
 
 /**
  *
@@ -1088,7 +1089,9 @@ export class EntityComponentDataset {
         //map classes to indices
         const indices = scratch_array_0;
 
+        // prepare sorted array of component indices
         const numClasses = classes.length;
+
         for (i = 0; i < numClasses; i++) {
             const k = classes[i];
 
@@ -1108,11 +1111,8 @@ export class EntityComponentDataset {
 
         // crop args array to the right length (since we're re-using a scratch array)
         const args_length_intended = numClasses + 1;
-        const args_length_current = scratch_array_1.length;
 
-        if (args_length_current > args_length_intended) {
-            scratch_array_1.splice(args_length_intended, args_length_current - args_length_intended);
-        }
+        array_shrink_to_size(scratch_array_1, args_length_intended);
 
         const entityOccupancy = this.entityOccupancy;
 
@@ -1120,7 +1120,12 @@ export class EntityComponentDataset {
         const component_occupancy = this.componentOccupancy;
         const components = this.components;
 
-        entity_loop: for (entityIndex = entityOccupancy.nextSetBit(0); entityIndex !== -1; entityIndex = entityOccupancy.nextSetBit(entityIndex + 1)) {
+        entity_loop: for (
+            entityIndex = entityOccupancy.nextSetBit(0);
+            entityIndex !== -1;
+            entityIndex = entityOccupancy.nextSetBit(entityIndex + 1)
+        ) {
+
             const componentOccupancyAddress = entityIndex * component_type_count;
 
             for (i = 0; i < numClasses; i++) {

package/engine/graphics/GraphicsEngine.d.ts

@@ -5,12 +5,15 @@ import Vector2 from "../../core/geom/Vector2";
 import View from "../../view/View";
 
 export class GraphicsEngine {
-    scene: Scene
-    camera: PerspectiveCamera
+    readonly scene: Scene
+    readonly camera: PerspectiveCamera
 
-    viewport: View
+    readonly viewport: View
 
-    layers: RenderLayerManager
+    /**
+     * @deprecated
+     */
+    readonly layers: RenderLayerManager
 
     get domElement(): HTMLCanvasElement
 

package/engine/graphics/GraphicsEngine.js

@@ -559,10 +559,12 @@ GraphicsEngine.prototype.prepareRenderPass = function (passType) {
     let j = 0;
 
     const visible_objects = this.main_view.visible_objects;
+
     const element_count = visible_objects.size;
+    const elements = visible_objects.elements;
 
     for (let i = 0; i < element_count; i++) {
-        const object3D = visible_objects.elements[i];
+        const object3D = elements[i];
 
         const object_pass = classifyPassTypeFromObject(object3D);
 

package/engine/graphics/ecs/mesh/MeshSystem.js

@@ -215,9 +215,10 @@ export class MeshSystem extends System {
             return;
         }
 
-        const visibleElements = this.renderLayer.visibleSet.elements;
+        const visibleSet = this.renderLayer.visibleSet;
+        const visibleElements = visibleSet.elements;
 
-        const n = visibleElements.length;
+        const n = visibleSet.size;
 
         for (let i = 0; i < n; i++) {
 

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -4,14 +4,53 @@ import { DrawMode } from "./DrawMode.js";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 
-const _aabb3 = new AABB3();
-
+/**
+ * @readonly
+ * @type {Float32Array}
+ */
 const scratch_aabb3_array = new Float32Array(6);
 
 const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
+const FLAG_SET_EQUALITY = ShadedGeometryFlags.CastShadow
+    | ShadedGeometryFlags.ReceiveShadow
+;
+
+/**
+ *
+ * @type {number}
+ */
+const TRANSFORM_ALLOCATOR_BUCKET_CAPACITY = 16;
+/**
+ *
+ * @type {ArrayBuffer|null}
+ */
+let transform_bucket = null;
+/**
+ *
+ * @type {number}
+ */
+let transform_bucket_cursor = TRANSFORM_ALLOCATOR_BUCKET_CAPACITY;
+
+/**
+ * custom Float32Array allocator, allocated memory in continuous chunks
+ * @returns {Float32Array}
+ */
+function allocate_transform_m4() {
+    if (transform_bucket_cursor >= TRANSFORM_ALLOCATOR_BUCKET_CAPACITY) {
+        transform_bucket = new ArrayBuffer(TRANSFORM_ALLOCATOR_BUCKET_CAPACITY * 4 * 16);
+        transform_bucket_cursor = 0;
+    }
+
+    const result = new Float32Array(transform_bucket, transform_bucket_cursor * 16 * 4, 16);
+
+    transform_bucket_cursor++;
+
+    return result;
+}
+
 export class ShadedGeometry {
     constructor() {
         /**
@@ -27,24 +66,23 @@ export class ShadedGeometry {
 
         /**
          *
-         * @type {DrawMode|number}
+         * @type {number}
+         * @private
          */
-        this.mode = DrawMode.Triangles;
+        this.__bvh_leaf_id = -1;
 
         /**
          *
-         * @type {LeafNode<ShadedGeometry>}
+         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
          * @private
          */
-        this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+        this.__bvh_tree = null;
 
-        this.__bvh_leaf_id = -1;
         /**
-         *
-         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
+         * @readonly
+         * @type {number[]|Float32Array}
          * @private
          */
-        this.__bvh_tree = null;
         this.__bvh_aabb = new Float32Array(6);
 
         /**
@@ -65,12 +103,19 @@ export class ShadedGeometry {
          * Transform matrix
          * Transient, assigned in the system
          * @type {number[]|null}
+         * @readonly
          * @private
          */
-        this.__transform = new Float32Array(16);
+        this.__transform = allocate_transform_m4();
+
+        /**
+         *
+         * @type {DrawMode|number}
+         */
+        this.mode = DrawMode.Triangles;
 
         /**
-         * Transient property signifying how to render object
+         * Transient property signifying how to render object, such as using INSTANCED draw
          * @type {number}
          */
         this.draw_method = 0;
@@ -135,7 +180,12 @@ export class ShadedGeometry {
      * @return {number}
      */
     hash() {
-        return this.geometry.id ^ this.material.id;
+        return this.geometry.id
+            ^ this.material.id
+            ^ (this.flags & FLAG_SET_EQUALITY)
+            ^ (this.draw_method << 16)
+            ^ (this.mode << 12)
+            ;
     }
 
     /**
@@ -146,6 +196,9 @@ export class ShadedGeometry {
     equals(other) {
         return this.geometry.id === other.geometry.id
             && this.material.id === other.material.id
+            && this.draw_method === other.draw_method
+            && this.mode === other.mode
+            && (this.flags & FLAG_SET_EQUALITY) === (other.flags & FLAG_SET_EQUALITY)
             ;
     }
 
@@ -171,7 +224,7 @@ export class ShadedGeometry {
      * @returns {LeafNode<ShadedGeometry>}
      */
     get bvh() {
-        return this.__bvh_leaf;
+        throw new Error('Deprecated, use #getBoundingBox method instead');
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -217,11 +217,6 @@ export class ShadedGeometrySystem extends System {
         t.toMatrix4(sg.__transform);
         sg.update_bounds();
 
-        const leaf_node = sg.bvh;
-
-        // record entity on the BVH leaf
-        leaf_node.entity = entity;
-
         // remember entity for lookups
         sg.__entity = entity;
 
@@ -256,9 +251,14 @@ export class ShadedGeometrySystem extends System {
 
         // disconnect BVH
         const node_id = sg.__bvh_leaf_id;
+
         this.__bvh_binary.remove_leaf(node_id);
         this.__bvh_binary.release_node(node_id);
 
+        // reset BVH references
+        sg.__bvh_leaf_id = -1;
+        sg.__bvh_tree = null;
+
         const geometry_id = sg.geometry.id;
         const count_existing = this.__geometry_usage_counters.get(geometry_id);
 

package/engine/graphics/ecs/mesh-v2/render/adapters/InstancedRendererAdapter.js

@@ -119,7 +119,7 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
 
         mesh.setTransformAt(index, sg.transform);
 
-        mesh.count++;
+        mesh.count = new_size;
 
         this.__active_meshes.add(mesh);
     }

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -20,8 +20,11 @@ import { randomFromArray } from "../../../../../core/math/random/randomFromArray
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
-import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
+import {
+    MicronShadedGeometryRenderAdapter
+} from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
 import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
 
 const eh = new EngineHarness();
 
@@ -65,12 +68,16 @@ async function main(engine) {
     await em.addSystem(sgs);
     await em.addSystem(new BehaviorSystem(engine));
 
+    const TERRAIN_SIZE = 200;
+
     EngineHarness.buildBasics({
         engine,
         yaw: -0.8,
         pitch: 1,
         distance: 46,
-        focus: new Vector3(10, 0, 10)
+        terrainSize: new Vector2(TERRAIN_SIZE / 2, TERRAIN_SIZE / 2),
+        terrainResolution: 1,
+        focus: new Vector3(TERRAIN_SIZE / 2, 0, TERRAIN_SIZE / 2)
     });
 
 
@@ -86,7 +93,7 @@ async function main(engine) {
 
     const random = seededRandom(0);
 
-    const INSTANCE_COUNT = 10000;
+    const INSTANCE_COUNT = 100000;
 
     const geometries = [];
 
@@ -108,12 +115,12 @@ async function main(engine) {
         new EntityBuilder()
             .add(Transform.fromJSON({
                 position: {
-                    x: randomFloatBetween(random, 0, 20),
+                    x: randomFloatBetween(random, 0, TERRAIN_SIZE),
                     y: randomFloatBetween(random, 0, 10),
-                    z: randomFloatBetween(random, 0, 20)
+                    z: randomFloatBetween(random, 0, TERRAIN_SIZE)
                 },
                 rotation: Quaternion.random(random),
-                scale: 0.05
+                scale: 0.1
             }))
             .add(sg)
             .build(ecd);

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -12,6 +12,7 @@ import { composeCompile } from "../../material/composeCompile.js";
 import { typed_array_copy } from "../../../../core/collection/array/typed/typed_array_copy.js";
 import { rewriteMaterial } from "./rewriteMaterial.js";
 import { max3 } from "../../../../core/math/max3.js";
+import { min2 } from "../../../../core/math/min2.js";
 
 export class InstancedMeshGroup {
     /**
@@ -217,8 +218,10 @@ export class InstancedMeshGroup {
             this.setCapacity(newCapacityInteger);
 
         } else if (
-            currentCapacity * this.shrinkFactor > size
-            && currentCapacity - this.shrinkConstant > size
+            min2(
+                currentCapacity * this.shrinkFactor,
+                currentCapacity - this.shrinkConstant
+            ) > size
         ) {
             // shrink
             this.setCapacity(size);

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -102,13 +102,14 @@ export class MicronRenderPlugin extends EnginePlugin {
      * @param {THREE.WebGLRenderer} renderer
      * @param {THREE.Camera} camera
      * @param {THREE.Object3D[]} elements
+     * @param element_count
      */
-    render(renderer, camera, elements) {
+    render(renderer, camera, elements, element_count = elements.length) {
         const vgtr = this.__vgtr;
 
         vgtr.clear();
 
-        vgtr.attachMany(elements);
+        vgtr.attachMany(elements, element_count);
 
         vgtr.update(renderer, camera);
         vgtr.render();
@@ -123,7 +124,7 @@ export class MicronRenderPlugin extends EnginePlugin {
         const observer = () => {
             const ge = this.engine.graphics;
 
-            this.render(ge.renderer, view.camera, view.visible_objects.elements);
+            this.render(ge.renderer, view.camera, view.visible_objects.elements, view.visible_objects.size);
         };
 
         this.__view_observers.set(view, observer);

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -50,7 +50,7 @@ export class VGThreeRenderer {
         this.ctx.builder.appendToScene([scene]);
     }
 
-    attachMany(objects) {
+    attachMany(objects, object_count = objects.length) {
         array_copy(objects, 0, this.__inputs, this.__inputs.length, objects.length);
         this.ctx.builder.appendToScene(objects);
     }

package/engine/graphics/particles/ecs/ParticleEmitterSystem.js

@@ -144,9 +144,9 @@ export class ParticleEmitterSystem extends System {
             self.particleEngine.shaderManager.update();
 
             const visibleSet = renderLayer.visibleSet;
-            const visibleEmitters = visibleSet.size;
+            const visible_emitter_count = visibleSet.size;
 
-            if (visibleEmitters > 0) {
+            if (visible_emitter_count > 0) {
                 depthBuffer.referenceCount++;
                 self.graphicsEngine.on.postRender.addOne(function () {
                     depthBuffer.referenceCount--;
@@ -154,7 +154,7 @@ export class ParticleEmitterSystem extends System {
             }
 
 
-            for (let i = 0; i < visibleEmitters; i++) {
+            for (let i = 0; i < visible_emitter_count; i++) {
                 /**
                  *
                  * @type {Object3D}

package/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js

@@ -724,7 +724,7 @@ export class ParticleEmitter {
 
     /**
      * PRECONDITION: no dead particles may exist in the pool. Make sure to call {@link ParticlePool#compact} before sorting
-     * @private
+     * @protected
      * @param {Camera} camera THREE.js camera object
      */
     sort(camera) {

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

@@ -548,8 +548,10 @@ export class LightManager {
     __update_visible_bvh() {
         this.__visible_bvh_needs_update = false;
 
-        const lights = this.__visible_lights.elements;
-        const light_count = lights.length;
+        const visibleLights = this.__visible_lights;
+
+        const lights = visibleLights.elements;
+        const light_count = visibleLights.size;
 
 
         const vbvh = this.__visible_bvh;

package/engine/graphics/render/layers/RenderLayer.d.ts

@@ -12,5 +12,8 @@ export class RenderLayer {
 
     extractRenderable(leafData: any): Object3D
 
+    /**
+     * @deprecated
+     */
     visibleSet: IncrementalDeltaSet<Object3D>
 }

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

@@ -8,10 +8,14 @@ import { RenderPassType } from "../RenderPassType.js";
 import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { traverseBinaryNodeUsingVisitor } from "../../../../core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js";
-import { ThreeClippingPlaneComputingBVHVisitor } from "../../../../core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js";
+import {
+    ThreeClippingPlaneComputingBVHVisitor
+} from "../../../../core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js";
 import { RenderLayerState } from "./RenderLayerState.js";
 import { compare_three_objects } from "../../three/compare_three_objects.js";
-import { queryBinaryNode_FrustumIntersections_Data } from "../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import {
+    queryBinaryNode_FrustumIntersections_Data
+} from "../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 
 
 /**
@@ -57,6 +61,7 @@ export class RenderLayer {
         /**
          * @deprecated use CameraView's visible set instead
          * Contains visible elements across all views, if element is in at least one view - it will be here
+         * @deprecated
          * @type {IncrementalDeltaSet<THREE.Object3D>}
          */
         this.visibleSet = new IncrementalDeltaSet(compare_three_objects);

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

@@ -1,7 +1,12 @@
+import Signal from "../../../../core/events/signal/Signal";
+
 export class IncrementalDeltaSet<T> {
-    elements: T[]
-    version: number
-    size: number
+    readonly elements: T[]
+    readonly version: number
+    readonly size: number
+
+    readonly onAdded: Signal<T>
+    readonly onRemoved: Signal<T>
 
     constructor(compare: (a: T, b: T) => number)
 

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

@@ -1,8 +1,8 @@
-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 { binarySearchHighIndex } from "../../../../core/collection/array/binarySearchHighIndex.js";
+import { array_shrink_to_size } from "../../../../core/collection/array/array_shrink_to_size.js";
 
 /**
  * @readonly
@@ -34,6 +34,26 @@ export class IncrementalDeltaSet {
          */
         this.__elements = [];
 
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__elements_cursor = 0;
+
+        /**
+         *
+         * @type {V[]}
+         * @private
+         */
+        this.__swap_elements = [];
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__swap_elements_count = 0;
+
         /**
          *
          * @type {function(V, V): number}
@@ -47,13 +67,6 @@ export class IncrementalDeltaSet {
          */
         this.version = 0;
 
-        /**
-         * Dirty flag set, used during the update to keep track of which elements are to be remove
-         * @type {BitSet}
-         */
-        this.flags = new BitSet();
-        this.flags.preventShrink();
-
         /**
          * Number of currently held elements
          * @type {number}
@@ -185,9 +198,7 @@ export class IncrementalDeltaSet {
             return;
         }
 
-        this.__elements.splice(0, this.size);
         this.size = 0;
-        this.flags.reset();
 
         this.state = IncrementalDeltaSetState.Clear;
 
@@ -195,18 +206,20 @@ export class IncrementalDeltaSet {
     }
 
     includeAll() {
-        if (this.size > 0) {
-            this.flags.clearRange(0, this.size - 1);
-        }
+        throw new Error('deprecated #includeAll');
     }
 
     initializeUpdate() {
-        //mark all elements as dirty
-        const size = this.size;
+        // perform swap
+        const swp_els = this.__elements;
+        this.__elements = this.__swap_elements
+        this.__swap_elements = swp_els;
 
-        if (size > 0) {
-            this.flags.setRange(0, size - 1);
-        }
+        const swp_count = this.size;
+        this.size = this.__swap_elements_count;
+        this.__swap_elements_count = swp_count;
+
+        this.__elements_cursor = 0;
 
         this.state = IncrementalDeltaSetState.Building;
 
@@ -216,30 +229,41 @@ export class IncrementalDeltaSet {
     finalizeUpdate() {
         assert.equal(this.state, IncrementalDeltaSetState.Building, `Expected BUILDING state, instead got '${this.state}'`);
 
-        let deletions = 0;
-
-        //go through all dirty flags and remove corresponding elements
-        const flags = this.flags;
-        const elements = this.__elements;
-
-        for (
-            let i = flags.nextSetBit(0);
-            i !== -1;
-            i = flags.nextSetBit(i + 1)
-        ) {
-            const index = i - deletions;
-
-            const removed = elements.splice(index, 1);
-
-            this.onRemoved.send1(removed[0]);
-
-            deletions++;
+        this.size = this.__elements_cursor;
+
+        // sort newly populated elements array
+        array_shrink_to_size(this.__elements, this.size);
+        this.__elements.sort(this.__compare);
+
+        let i0 = 0, i1 = 0;
+        while (i0 < this.size && i1 < this.__swap_elements_count) {
+            const el_0 = this.__elements[i0];
+            const el_1 = this.__swap_elements[i1];
+
+            const diff = this.__compare(el_0, el_1);
+
+            if (diff === 0) {
+                i0++;
+                i1++;
+                // found match
+            } else if (diff < 0) {
+                i0++;
+                // addition
+                this.onAdded.send1(el_0);
+            } else {
+                i1++;
+                // removal
+                this.onRemoved.send1(el_1);
+            }
         }
 
-        //update size
-        this.size -= deletions;
-
-        flags.reset();
+        // process remainders
+        for (; i0 < this.size; i0++) {
+            this.onAdded.send1(this.__elements[i0]);
+        }
+        for (; i1 < this.__swap_elements_count; i1++) {
+            this.onRemoved.send1(this.__swap_elements[i1]);
+        }
 
         this.state = IncrementalDeltaSetState.Ready;
 
@@ -254,30 +278,7 @@ export class IncrementalDeltaSet {
     push(element) {
         const elements = this.__elements;
 
-        //check if element is already in the set
-        const existing_size = this.size;
-        const index = binarySearchHighIndex(elements, element, this.__compare, 0, existing_size - 1);
-
-
-        const flags = this.flags;
-
-        if (elements[index] !== element) {
-            // element is not in the set
-
-            // shift flags to make space for it
-            flags.shift_right(1, index, existing_size);
-
-            // insert
-            elements.splice(index, 0, element);
-
-            this.size = existing_size + 1;
-
-            this.onAdded.send1(element);
-        }
-
-        // clear flag for inserted element
-        flags.clear(index);
-
+        elements[this.__elements_cursor++] = element;
     }
 
     /**

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

@@ -44,3 +44,42 @@ test('set is sorted after insert, push 3,2,1', () => {
     expect(set.elements[1]).toBe(2);
     expect(set.elements[2]).toBe(3);
 });
+
+
+test('add/remove callbacks', () => {
+    const set = new IncrementalDeltaSet(compareNumbersAscending);
+
+    const add_listener = jest.fn();
+    const remove_listener = jest.fn();
+
+    set.onAdded.add(add_listener);
+    set.onRemoved.add(remove_listener);
+
+    set.initializeUpdate();
+
+    set.push(1);
+    set.push(2);
+    set.push(3);
+
+    set.finalizeUpdate();
+
+    expect(add_listener).toHaveBeenCalledWith(1);
+    expect(add_listener).toHaveBeenCalledWith(2);
+    expect(add_listener).toHaveBeenCalledWith(3);
+
+    expect(add_listener).toHaveBeenCalledTimes(3);
+
+    expect(remove_listener).not.toHaveBeenCalled();
+
+    set.initializeUpdate();
+
+    set.push(1);
+    set.push(3);
+
+    set.finalizeUpdate();
+
+    expect(add_listener).toHaveBeenCalledTimes(3);
+
+    expect(remove_listener).toHaveBeenCalledWith(2);
+    expect(remove_listener).toHaveBeenCalledTimes(1);
+});

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -78,6 +78,7 @@ export class ShadowMapRenderer {
         const __autoClearColor = renderer.autoClearColor;
         const __autoClearDepth = renderer.autoClearDepth;
         const __autoClearStencil = renderer.autoClearStencil;
+        const __sortObjects = renderer.sortObjects;
 
         const target = shadow.map;
 
@@ -89,6 +90,9 @@ export class ShadowMapRenderer {
         renderer.autoClearDepth = false;
         renderer.autoClearStencil = false;
 
+        // disable sorting, unnecessary since fragment cost is very low and sorting is expensive for large number of objects
+        renderer.sortObjects = false;
+
         renderer.clear(true, true, false);
 
         shadow.updateMatrices(light, 0);
@@ -115,6 +119,7 @@ export class ShadowMapRenderer {
         renderer.autoClearColor = __autoClearColor;
         renderer.autoClearDepth = __autoClearDepth;
         renderer.autoClearStencil = __autoClearStencil;
+        renderer.sortObjects = __sortObjects;
 
         // increment frame index to signal to the renderer that geometries might need to be updated
         renderer.info.render.frame++;

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.36.22",
+  "version": "2.36.23",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",