@woosh/meep-engine 2.34.45 → 2.34.46

package/core/bvh2/BinaryNode.js

@@ -211,44 +211,60 @@ export class BinaryNode extends Node {
      */
     __insertion_findSiblingFor(box) {
 
-        const open_set = [this];
-        let cursor = 1;
+        let node = this;
+        let cost_left = 0;
+        let cost_right = 0;
 
-        let best_cost = Infinity;
-        let best_node = this;
+        while (node.isBinaryNode) {
+            const left = node.left;
+            const right = node.right;
 
-        while (cursor > 0) {
-            const node = open_set[--cursor];
+            const area = aabb3_box_surface_area_2(node);
 
-            const cost = inclusion_surface_area_heuristic(node, box);
+            const combined_area = combined_surface_area(node, box);
 
-            if (cost < best_cost) {
-                best_cost = cost;
-                best_node = node;
-            }
+            //cost of creating a new parent for this node and the new leaf
+            const cost = combined_area;
 
-            if (node.isBinaryNode) {
+            // minimum cost of pushing the leaf further down the tree
+            const inheritance_cost = combined_area - area;
 
-                // consider pushing children into the queue
+            // cost of descending left
+            if (left !== null) {
+                if (left.isLeafNode) {
+                    cost_left = combined_surface_area(left, box) + inheritance_cost;
+                } else {
+                    cost_left = combined_surface_area(left, box) - aabb3_box_surface_area_2(left) + inheritance_cost;
+                }
+            } else {
+                cost_left = Infinity;
+            }
 
-                // compute lower bound for cost
-                const c_low = inclusion_cost_lower_bound(node, box);
+            // cost of descending right
+            if (right !== null) {
 
-                if (c_low < best_cost) {
-                    // worth-while to explore children
-                    if (node.left !== null) {
-                        open_set[cursor++] = node.left;
-                    }
-                    if (node.right !== null) {
-                        open_set[cursor++] = node.right
-                    }
+                if (right.isLeafNode) {
+                    cost_right = combined_surface_area(right, box) + inheritance_cost;
+                } else {
+                    cost_right = combined_surface_area(right, box) - aabb3_box_surface_area_2(right) + inheritance_cost;
                 }
+            } else {
+                cost_right = Infinity;
             }
 
+            if (cost < cost_left && cost < cost_right) {
+                // descending either branch is too expensive
+                break;
+            }
 
+            if (cost_left < cost_right) {
+                node = left;
+            } else {
+                node = right;
+            }
         }
 
-        return best_node;
+        return node;
     }
 
     /**
@@ -1134,6 +1150,16 @@ BinaryNode.prototype.isBinaryNode = true;
  * @returns {number}
  */
 function inclusion_surface_area_heuristic(node, addition) {
+    return combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
+}
+
+/**
+ *
+ * @param {AABB3} node
+ * @param {AABB3} addition
+ * @returns {number}
+ */
+function combined_surface_area(node, addition) {
     const x0 = min2(node.x0, addition.x0);
     const y0 = min2(node.y0, addition.y0);
     const z0 = min2(node.z0, addition.z0);
@@ -1142,7 +1168,7 @@ function inclusion_surface_area_heuristic(node, addition) {
     const y1 = max2(node.y1, addition.y1);
     const z1 = max2(node.z1, addition.z1);
 
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) - aabb3_box_surface_area_2(node);
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
 }
 
 /**

package/core/bvh2/traversal/bvh_traverse_pre_order_using_stack.js

@@ -0,0 +1,43 @@
+const stack = [];
+let stackPointer = 0;
+
+/**
+ *
+ * @param {BinaryNode} root
+ * @param {function(BinaryNode|LeafNode):*} visitor
+ * @param {*} [thisArg]
+ * @return {number}
+ */
+export function bvh_traverse_pre_order_using_stack(root, visitor, thisArg) {
+    let visitCount = 0;
+
+    const stackOffset = stackPointer;
+
+    stack[stackPointer++] = root;
+
+    let n;
+
+    while (stackPointer-- > stackOffset) {
+
+        visitCount++;
+
+        n = stack[stackPointer];
+
+        visitor.call(thisArg, n);
+
+        if (!n.isLeafNode) {
+            //a binary node
+            if (n.right !== null) {
+                stack[stackPointer++] = n.right;
+            }
+            if (n.left !== null) {
+                stack[stackPointer++] = n.left;
+            }
+        }
+    }
+
+    // drop stack frame
+    stackPointer = stackOffset;
+
+    return visitCount;
+}

package/core/bvh2/visual/convert_bvh_to_dot_format_string.js

@@ -0,0 +1,50 @@
+import { convertGraphToDotString } from "../../graph/convertGraphToDotString.js";
+import { bvh_traverse_pre_order_using_stack } from "../traversal/bvh_traverse_pre_order_using_stack.js";
+import { Graph } from "../../graph/v2/Graph.js";
+import { Edge, EdgeDirectionType } from "../../graph/Edge.js";
+
+/**
+ *
+ * @param {BinaryNode} bvh
+ * @returns {Graph}
+ */
+export function bvh_to_graph(bvh) {
+    //traverse twice, first collect all nodes, second time introduce edges
+    const graph = new Graph();
+
+    bvh_traverse_pre_order_using_stack(bvh, node => {
+        graph.addNode(node);
+    });
+
+    bvh_traverse_pre_order_using_stack(bvh, node => {
+        if (node.isBinaryNode) {
+
+            if (node.left !== null) {
+                const edge = new Edge(node, node.left);
+
+                edge.direction = EdgeDirectionType.Forward;
+
+                graph.addEdge(edge);
+            }
+            if (node.right !== null) {
+                const edge = new Edge(node, node.right);
+
+                edge.direction = EdgeDirectionType.Forward;
+
+                graph.addEdge(edge);
+            }
+        }
+    });
+
+    return graph;
+}
+
+/**
+ * Build a Graphviz DOT representation of the graph
+ * @param {BinaryNode} bvh
+ * @returns {string}
+ */
+export function convert_bvh_to_dot_format_string(bvh) {
+    const graph = bvh_to_graph(bvh);
+    return convertGraphToDotString(graph);
+}

package/core/graph/convertGraphToDotString.js

@@ -2,7 +2,7 @@ import LineBuilder from "../codegen/LineBuilder.js";
 import { EdgeDirectionType } from "./Edge.js";
 
 /**
- * Build a DOT representation of the graph
+ * Build a Graphviz DOT representation of the graph
  * @param {Graph} graph
  * @returns {string}
  */
@@ -13,7 +13,7 @@ export function convertGraphToDotString(graph) {
 
     lb.indent();
 
-    const nodes = graph.nodes;
+    const nodes = Array.from(graph.getNodes());
     const nodeCount = nodes.length;
 
     function nodeId(index) {
@@ -33,9 +33,9 @@ export function convertGraphToDotString(graph) {
 
         const node = nodes[i];
 
-        const attachedEdges = graph.getAttachedEdges(node);
+        const attachedEdges = [];
 
-        const nAttachedEdges = attachedEdges.length;
+        const nAttachedEdges = graph.getAttachedEdges(attachedEdges, node);
 
         for (let j = 0; j < nAttachedEdges; j++) {
             const edge = attachedEdges[j];

package/core/graph/v2/Graph.js

@@ -335,6 +335,10 @@ export class Graph {
      * @returns {number}
      */
     getAttachedEdges(result, node) {
+        assert.defined(result, 'result');
+        assert.isArray(result, 'result');
+        assert.defined(node, 'node');
+
         const context = this.__nodes.get(node);
 
         if (context === undefined) {

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -116,8 +116,9 @@ export class Foliage2System extends System {
         graphics.views.elements.on.added.add(this.__handle_view_added, this);
         graphics.views.elements.on.removed.add(this.__handle_view_removed, this);
 
-        this.renderLayer.buildVisibleSet = (view, visitObject, thisArg) => {
+        this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
             const data = this.data;
+            let additions = 0;
 
             for (let entity in data) {
 
@@ -147,11 +148,14 @@ export class Foliage2System extends System {
                         }
 
                         const mesh = group.mesh;
-                        visitObject.call(thisArg, mesh);
+
+                        destination[additions + destination_offset] = mesh;
                     }
 
                 }
             }
+
+            return additions;
         };
 
         readyCallback();

package/engine/graphics/compute_geometry_polycount.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {number}
+ */
+export function compute_geometry_polycount(geometry) {
+    const index = geometry.getIndex();
+
+    if (index !== null) {
+        return index.count / 3;
+    }
+
+    const position_attribute = geometry.getAttribute('position');
+
+    if (position_attribute !== undefined) {
+        return position_attribute.count / 3;
+    }
+
+    // no valid way to discern polycount, assume 0
+    return 0;
+}

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

@@ -4,6 +4,15 @@ import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
 
 const eh = new EngineHarness();
 
@@ -26,22 +35,68 @@ async function main(engine) {
         color: 0xFFFFFF
     });
 
-    material.visible = false;
+    // material.visible = false;
 
     window.material = material;
 
-    const g = ShadedGeometry.from(new BoxBufferGeometry(), material);
+    const geometry = new BoxBufferGeometry();
 
+    const random = seededRandom(0);
+
+    for (let i = 0; i < 100000; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, -50, 50),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, -50, 50)
+                },
+                scale: 0.01
+            }))
+            .add(ShadedGeometry.from(geometry, material))
+            .build(ecd);
+    }
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
 
     new EntityBuilder()
-        .add(Transform.fromJSON({
-            position: {
-                x: 10,
-                y: 1,
-                z: 10
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
             }
-        }))
-        .add(g)
+        })))
         .build(ecd);
 }
 

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

@@ -0,0 +1,176 @@
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { compute_geometry_polycount } from "../../compute_geometry_polycount.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
+
+const DEFAULT_THRESHOLD_POLYCOUNT = 1024;
+
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @return {number}
+ */
+function max_polycount(object) {
+    let r = 0;
+
+    traverseThreeObject(object, (m) => {
+        if (m.isMesh) {
+            const geo = m.geometry;
+            if (geo !== null) {
+                r = max2(r, compute_geometry_polycount(geo))
+            }
+        }
+    });
+
+    return r;
+}
+
+export class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         * Minimum number of polygons required for micron to be used
+         * @type {number}
+         * @private
+         */
+        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
+    }
+
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        let micron_data;
+
+        const micron_path = `${base}/${micron_uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
+        } catch (e) {
+            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
+            return;
+        }
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {Asset} source
+     * @param {AssetDescription} asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
+        const animationClips = source.animations;
+
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // animations might cause trouble
+            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
+        }
+
+        /**
+         * @type {THREE.Object3D}
+         */
+        const root = source.create();
+
+        const gltf_max_polycount = max_polycount(root);
+
+        if (gltf_max_polycount < this.__threshold_polycount) {
+            // no change, geometries are too small
+            return source;
+        }
+
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}

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

@@ -2,8 +2,6 @@ import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
@@ -12,13 +10,9 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
-import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
-import { computePathDirectory } from "../../../../core/FilePath.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
-import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
-import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
+import { ASSET_TYPE_ARRAY_BUFFER, GLTFAssetTransformer } from "./GLTFAssetTransformer.js";
 
 /**
  *
@@ -26,134 +20,6 @@ import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
-const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
-
-class GLTFAssetTransformer extends AssetTransformer {
-    /**
-     *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
-     */
-    constructor(cache) {
-        super();
-
-        /**
-         *
-         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
-         * @private
-         */
-        this.__cache = cache;
-
-        /**
-         *
-         * @type {AssetManager|null}
-         * @private
-         */
-        this.__am = null;
-
-        /**
-         *
-         * @type {MicronGeometryBinarySerializationAdapter}
-         * @private
-         */
-        this.__serde = new MicronGeometryBinarySerializationAdapter();
-    }
-
-    /**
-     *
-     * @param {AssetManager|null} am
-     */
-    set assetManager(am) {
-        this.__am = am;
-    }
-
-
-    /**
-     * @param {THREE.Object3D} object
-     * @param {{asset:AssetDescription}} ctx
-     * @return {Promise<void>}
-     * @private
-     */
-    async __visitObjectToLoadMicron(object, ctx) {
-        if (!object.isMesh) {
-            return;
-        }
-
-        /**
-         * @type {THREE.BufferGeometry}
-         */
-        const geometry = object.geometry;
-
-        const micron_uri = geometry.userData[MICRON_URI_FIELD];
-
-        if (typeof micron_uri !== "string") {
-            return;
-        }
-
-
-        /**
-         * @type {AssetDescription}
-         */
-        const ad = ctx.asset;
-
-        const base = computePathDirectory(ad.path);
-
-        let micron_data;
-
-        const micron_path = `${base}/${micron_uri}`;
-
-        try {
-            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
-        } catch (e) {
-            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
-            return;
-        }
-
-        // deserialize micron data
-        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
-        const micron_geometry = new MicronGeometry();
-
-        this.__serde.deserialize(buffer, micron_geometry);
-
-        // set proxy for raycasting
-        micron_geometry.proxy = geometry;
-
-        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
-    }
-
-
-    /**
-     *
-     * @param {Asset} source
-     * @param {AssetDescription} asset_description
-     * @return {Promise<Asset>}
-     */
-    async transform(source, asset_description) {
-        const animationClips = source.animations;
-
-        if (animationClips !== undefined && animationClips.length > 0) {
-            // animations might cause trouble
-            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
-        }
-
-        /**
-         * @type {THREE.Object3D}
-         */
-        const root = source.create();
-
-        // attempt to load existing micron geometries
-        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
-            asset: asset_description
-        });
-
-        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
-        micron_root.boundingSphere = root.boundingSphere;
-
-        source.override_mesh = micron_root;
-
-        return source;
-    }
-}
-
 export class MicronRenderPlugin extends EnginePlugin {
     constructor() {
         super();

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

@@ -188,8 +188,8 @@ heatmap_lut_pink_to_blue.write([
 ]);
 heatmap_lut_pink_to_blue.computeUniformPositions();
 
-const heatmap_lut_3 = new ParameterLookupTable(4);
-heatmap_lut_3.write(
+const heatmap_lut_discrete = new ParameterLookupTable(4);
+heatmap_lut_discrete.write(
     [
         196, 196, 196, 255,
         196, 196, 196, 255,
@@ -303,8 +303,8 @@ async function sample_scene_0(engine) {
     }
 
     // load_model('moicon/06_04_hapro/00-environment/model.gltf', -0.1);
-    // load_model_s('moicon/06_04_hapro/05-ground-floor/model.gltf');
-    // load_model_s('C:/git/moh/app/moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
+    load_model_s('moicon/06_04_hapro/05-ground-floor/model.gltf');
+    load_model_s('C:/git/moh/app/moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
     // load_model('moicon/06_04_hapro/02-bearers/model.gltf');
     // load_model('moicon/06_04_hapro/04-1st-floor/model.gltf');
 
@@ -360,7 +360,7 @@ async function sample_scene_0(engine) {
     // large open room, dense particles
     await make_demo_volume({
         ecd: ecd,
-        lut: heatmap_lut_3,
+        lut: heatmap_lut_discrete,
         shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [20.977896627021547, 0, 0, 0, 0, 2.956899734575006, 0, 0, 0, 0, 36.201589869571954, 0, 99.2120028317975, 1.5919924971428276, 49.21655402009093, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [24.455615450514458, 0, 0, 0, 0, 2.956899734575006, 0, 0, 0, 0, 28.081536987027807, 0, 80.11618755300161, 1.5919924971428276, 45.13808745329574, 1]),
@@ -534,7 +534,7 @@ async function sample_scene_nam(engine) {
 
     await make_demo_volume({
         ecd: ecd,
-        lut: heatmap_lut_3,
+        lut: heatmap_lut_discrete,
         shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.260857135913424, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 24.82865688356064, 1.4169994923726943, 2.4066558057134095, 1]),
         particle_size: P_SIZE_SMALL,
         density: 3,
@@ -545,7 +545,7 @@ async function sample_scene_nam(engine) {
 
     await make_demo_volume({
         ecd: ecd,
-        lut: heatmap_lut_3,
+        lut: heatmap_lut_discrete,
         shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.870266350649175, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 20.022408905267525, 1.4169994923726943, 2.4066558057134095, 1]),
         particle_size: P_SIZE_SMALL,
         density: 3,
@@ -585,6 +585,309 @@ async function sample_scene_nam(engine) {
     // }));
 }
 
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function sample_scene_moicon_0(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    ecd.getAnyComponent(TopDownCameraController).component.fromJSON({
+        "target": {
+            "x": 21.09522080045099,
+            "y": -0.6327784109623013,
+            "z": 6.138907038731565
+        },
+        "pitch": 1.1099999999999923,
+        "yaw": -3.143185307179591,
+        "roll": 0,
+        "distance": 29,
+        "distanceMin": 0,
+        "distanceMax": 1000
+    });
+
+    load_model('moicon/10_Feb_22_Demo/1/model.gltf', ecd);
+    load_model('moicon/10_Feb_22_Demo/2/model.gltf', ecd);
+    // load_model('moicon/10_Feb_22_Demo/3/model.gltf', ecd); // volume markers - main floor
+    // load_model('moicon/10_Feb_22_Demo/4/model.gltf', ecd); // volume markers - small corner room
+    load_model('moicon/10_Feb_22_Demo/5/model.gltf', ecd);
+    // load_model('moicon/10_Feb_22_Demo/6/model.gltf', ecd); // roof
+    load_model('moicon/10_Feb_22_Demo/7/model.gltf', ecd);
+    load_model('moicon/10_Feb_22_Demo/assets/model.gltf', ecd);
+
+    const P_SIZE_SMALL = 0.15;
+    const P_SIZE_MEDIUM = 0.6;
+    const P_SIZE_LARGE = 2;
+
+    const random = seededRandom(42);
+
+    const PERIOD_LONG = 13;
+
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_pink_to_blue,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.267098043281134, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 2.8037239954452864, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Hexagon_01.png'
+    // });
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_orange_to_red,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.7577406314060395, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 8.075207307031247, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_pink_to_blue,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.956797095914032, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 14.17733466985805, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/travnik/plus_2.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_pink_to_blue,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.733772190018377, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 20.284613387782148, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_pink_to_blue,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.924905976332568, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 31.662442543335885, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_0,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.7305058801925, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 6.606365126660234, 0, 37.70942297505848, 1.4169994923726943, 11.460158766988037, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 8,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_0,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.575632395877399, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 37.272800538855826, 1.4169994923726943, 2.4066558057134095, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 8,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_0,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.410614101275306, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 30.458756650580582, 1.4169994923726943, 2.4066558057134095, 1]),
+    //     particle_size: P_SIZE_MEDIUM,
+    //     density: 8,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_3,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.260857135913424, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 24.82865688356064, 1.4169994923726943, 2.4066558057134095, 1]),
+    //     particle_size: P_SIZE_SMALL,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_01.png'
+    // });
+    //
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_3,
+    //     shape: TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.870266350649175, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 4.51714948412602, 0, 20.022408905267525, 1.4169994923726943, 2.4066558057134095, 1]),
+    //     particle_size: P_SIZE_SMALL,
+    //     density: 3,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Cross_04.png'
+    // });
+    // await make_demo_volume({
+    //     ecd: ecd,
+    //     lut: heatmap_lut_pink_to_blue,
+    //     shape: UnionShape3D.from([
+    //         TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.985827128973811, 0, 0, 0, 0, 2.435269776236539, 0, 0, 0, 0, 4.669621139110231, 0, 11.08356834576874, 1.2643565739307023, 2.4360416869081885, 1]),
+    //         TransformedShape3D.from_m4(new UnitCubeShape3D(), [8.413758403821523, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 7.775469675813772, 0, 4.313201108449287, 1.4169994923726943, 4.011630095541064, 1]),
+    //         TransformedShape3D.from_m4(new UnitCubeShape3D(), [8.413758403821523, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 2.925065210015915, 0, 12.417224289491141, 1.4169994923726943, 6.432483110925785, 1])
+    //     ]),
+    //     particle_size: P_SIZE_LARGE,
+    //     density: 4,
+    //     period: PERIOD_LONG,
+    //     period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+    //     sprite: 'data/textures/particle/UETools/Circle_04.png'
+    // });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_pink_to_blue,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [24.84144698268643, 0, 0, 0, 0, 5, 0, 0, 0, 0, 10.014132199037626, 0, 17.535114352814745, 2.5767637841580786, 15.087856547232908, 1]),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [3.119746486000208, 0, 0, 0, 0, 5, 0, 0, 0, 0, 5.08916554361867, 0, 6.026351574317095, 2.5767637841580786, 17.554804169904074, 1])
+        ]),
+        particle_size: P_SIZE_LARGE,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_orange_to_red,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.23148852648068, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 4.843722925544828, 0, 2.178004397277256, 1.4442400806689264, 17.49419453432575, 1])
+        ]),
+        particle_size: P_SIZE_MEDIUM,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_pink_to_blue,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.23148852648068, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 4.843722925544828, 0, -2.3684201443478874, 1.4819864080894103, 17.435101092023466, 1])
+        ]),
+        particle_size: P_SIZE_LARGE,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_orange_to_red,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.827875822302671, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 7.195620725226215, 0, -7.134776782683499, 1.4819864080894103, 16.41960212963852, 1])
+        ]),
+        particle_size: P_SIZE_MEDIUM,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_pink_to_blue,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.827875822302671, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 7.142815034586885, 0, -12.122694984141244, 1.4819864080894103, 16.39260186069935, 1]),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [2.0910380492069933, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 5.042906378175556, 0, -13.835348677127275, 1.4819864080894103, 17.348732325334534, 1])
+        ]),
+        particle_size: P_SIZE_LARGE,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_orange_to_red,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.630054702949254, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 5.132455640292213, 0, -17.444335306984925, 1.4819864080894103, 17.416555162219638, 1])
+        ]),
+        particle_size: P_SIZE_MEDIUM,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_pink_to_blue,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [3.9334060066229277, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 4.909748196656206, 0, -2.993297445749089, 1.4819864080894103, -6.9614900068054615, 1])
+        ]),
+        particle_size: P_SIZE_LARGE,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_orange_to_red,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.693637284485993, 0, 0, 0, 0, 2.8688316144733066, 0, 0, 0, 0, 9.774881301181045, 0, -26.90124286380605, 4.656150234283974, 14.984350120152822, 1])
+        ]),
+        particle_size: P_SIZE_MEDIUM,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: randomFloatBetween(random, 0, PERIOD_LONG),
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_discrete,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.331512511030024, 0, 0, 0, 0, 2.329600948715924, 0, 0, 0, 0, 9.610682816430089, 0, -21.021354476323573, 1.3409243433436, -1.345765978128314, 1])]),
+        particle_size: P_SIZE_SMALL,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: 0,
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_discrete,
+        shape: UnionShape3D.from([
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [13.623136537846888, 0, 0, 0, 0, 2.193382560214131, 0, 0, 0, 0, 4.880453458023407, 0, 8.339521865997591, 1.1217848106509791, -1.5586407794900627, 1]),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.162666210784313, 0, 0, 0, 0, 1.7455477622575266, 0, 0, 0, 0, 4.880453458023407, 0, 2.0126515547811556, 0.9110827940157051, -1.5586407794900627, 1]),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), [4.162666210784313, 0, 0, 0, 0, 1.1232395183163202, 0, 0, 0, 0, 3.565672994277359, 0, 2.0440383546262932, 1.8620329637166853, -2.1963940023653703, 1])
+        ]),
+        particle_size: P_SIZE_SMALL,
+        density: 4,
+        period: PERIOD_LONG,
+        period_offset: PERIOD_LONG * 0.5,
+        sprite: 'data/textures/particle/UETools/Circle_04.png'
+    });
+
+    make_shape_vis_toggle(engine).toggle(); // turn off shape vis initially
+
+    // editing box
+    // make_box_editor(engine, Transform.fromJSON({
+    //     position: {
+    //         x: -2,
+    //         y: 0,
+    //         z: 0
+    //     },
+    //     scale: {
+    //         x: 5,
+    //         y: 5,
+    //         z: 5
+    //     }
+    // }));
+}
+
 /**
  *
  * @param {Engine} engine
@@ -608,8 +911,9 @@ async function main(engine) {
 
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
-    await sample_scene_nam(engine);
+    // await sample_scene_nam(engine);
     // await sample_scene_0(engine);
+    await sample_scene_moicon_0(engine);
 }
 
 /**
@@ -788,7 +1092,7 @@ function make_symbol_view({
     };
 
     const symbol_view = new EmptyView();
-    symbol_view.size.set(128, 20);
+    symbol_view.size.set(64, 20);
 
     symbol_view.css({
         position: 'absolute',
@@ -798,7 +1102,7 @@ function make_symbol_view({
     });
 
     const view_lut = new CanvasView();
-    view_lut.size.set(128, 10);
+    view_lut.size.set(64, 4);
     view_lut.css({
         position: 'absolute',
         border: '1px solid white',
@@ -817,10 +1121,11 @@ function make_symbol_view({
 
     view_cursor.css({
         position: 'absolute',
-        left: 0,
-        top: "-1px",
+        left: "-6px",
+        top: "-4px",
         height: "10px",
-        width: "4px",
+        width: "10px",
+        borderRadius: "10px",
         border: '2px solid white',
         zIndex: 2,
         boxShadow: '0 0 4px black'

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

@@ -55,6 +55,7 @@ export class RenderLayer {
         this.extractRenderable = passThrough;
 
         /**
+         * @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
          * @type {IncrementalDeltaSet<THREE.Object3D>}
          */
@@ -112,35 +113,42 @@ export class RenderLayer {
 
     /**
      *
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
      * @param {CameraView} view
-     * @param {function(THREE.Object3D)} callback
-     * @param {*} [callbackContext]
+     * @returns {number} Number of records added to destination
      */
-    buildVisibleSet(view, callback, callbackContext) {
+    buildVisibleSet(destination, destination_offset, view) {
         const frustum = view.frustum;
 
         const reader = this.extractRenderable;
 
+        if (typeof reader !== "function") {
+            // no reader method
+            return 0;
+        }
 
-        if (typeof reader === "function") {
-
-            const hits = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, this.bvh, frustum);
+        const intersection_count = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, this.bvh, frustum);
 
-            for (let i = 0; i < hits; i++) {
-                const datum = scratch_array[i];
+        let additions = 0;
+        let i = 0;
 
-                const object3D = reader(datum);
+        for (; i < intersection_count; i++) {
+            const datum = scratch_array[i];
 
-                if (!object3D) {
-                    // null or undefined
-                    continue;
-                }
+            const object3D = reader(datum);
 
-                callback.call(callbackContext, object3D);
+            if (!object3D) {
+                // null or undefined
+                continue;
             }
 
+            destination[additions + destination_offset] = object3D;
+
+            additions++;
         }
 
+        return additions;
     }
 }
 

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

@@ -251,26 +251,31 @@ export class IncrementalDeltaSet {
      * @param {V} element
      */
     push(element) {
+        const elements = this.__elements;
+
         //check if element is already in the set
-        const index = this.__indexExpected(element);
+        const existing_size = this.size;
+        const index = binarySearchHighIndex(elements, element, this.__compare, 0, existing_size - 1);
 
-        const elements = this.__elements;
+
+        const flags = this.flags;
 
         if (elements[index] !== element) {
             // element is not in the set
 
             // shift flags to make space for it
-            this.flags.shift(1, index, this.size);
+            flags.shift(1, index, existing_size);
 
             // insert
             elements.splice(index, 0, element);
-            this.size++;
+
+            this.size = existing_size + 1;
 
             this.onAdded.send1(element);
         }
 
         // clear flag for inserted element
-        this.flags.clear(index);
+        flags.clear(index);
 
     }
 
@@ -281,6 +286,7 @@ export class IncrementalDeltaSet {
     pushOther(other) {
         const elements = other.__elements;
         const n = other.size;
+
         for (let i = 0; i < n; i++) {
             const el = elements[i];
 
@@ -288,3 +294,10 @@ export class IncrementalDeltaSet {
         }
     }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+IncrementalDeltaSet.prototype.isIncrementalDeltaSet = true;

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

@@ -1,4 +1,4 @@
-import { assert } from "../../../../core/assert.js";
+const scratch_array = [];
 
 export class VisibilityComputer {
     constructor() {
@@ -67,19 +67,6 @@ export class VisibilityComputer {
         this.__view = view;
     }
 
-    /**
-     * @private
-     * @param {Object3D} object3d
-     */
-    __includeObject(object3d) {
-        assert.equal(object3d.isObject3D, true, 'object3d.isObject3D !== true');
-
-        //object passed all filters, add it to visible set
-        this.__output.push(object3d);
-
-        this.__activeLayer.visibleSet.push(object3d);
-    }
-
     /**
      * @private
      * @param {RenderLayer} layer
@@ -101,7 +88,16 @@ export class VisibilityComputer {
             return;
         }
 
-        layer.buildVisibleSet(this.__view, this.__includeObject, this);
+        const added_objects = layer.buildVisibleSet(scratch_array, 0, this.__view);
+
+        for (let i = 0; i < added_objects; i++) {
+            const object3d = scratch_array[i];
+
+            //object passed all filters, add it to visible set
+            this.__output.push(object3d);
+
+            this.__activeLayer.visibleSet.push(object3d);
+        }
     }
 
 

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