@woosh/meep-engine 2.34.35 → 2.34.39

package/engine/ecs/foliage/ViewState.js

@@ -0,0 +1,165 @@
+import { BitSet } from "../../../core/binary/BitSet.js";
+import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
+import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_array = [];
+
+export class ViewState {
+    constructor() {
+        /**
+         *
+         * @type {CameraView|null}
+         * @private
+         */
+        this.__view = null;
+
+        this.__visible_set = new BitSet();
+
+        //prevent re-allocation
+        this.__visible_set.preventShrink();
+
+        /**
+         *
+         * @type {InstancedMeshGroup}
+         */
+        this.instances = new InstancedMeshGroup();
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__garbage = [];
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__garbagePointer = 0;
+    }
+
+    dispose() {
+        this.instances.dispose();
+    }
+
+    __compute_visibility_update() {
+        const instances = this.instances;
+
+        const indices = instances.indices;
+
+        const index_count = indices.length;
+
+        /**
+         *
+         * @type {BitSet}
+         */
+        const visible_set = this.__visible_set;
+
+        const garbage = this.__garbage;
+
+        for (let ref = 0; ref < index_count; ref++) {
+            const index = indices[ref];
+
+            if (index === undefined) {
+                // unoccupied
+                continue;
+            }
+
+            if (!visible_set.get(ref)) {
+                //no longer visible
+                garbage[this.__garbagePointer++] = ref;
+            } else {
+                //visible, and is already in the group, update the set
+                visible_set.set(ref, false);
+            }
+        }
+    }
+
+    __removeGarbage() {
+
+        const garbagePointer = this.__garbagePointer;
+        const instances = this.instances;
+
+
+        const garbage = this.__garbage;
+
+        for (let i = 0; i < garbagePointer; i++) {
+            const ref = garbage[i];
+            instances.remove(ref);
+        }
+
+    }
+
+    /**
+     *
+     * @param {BinaryNode<number>} bvh
+     * @param {RowFirstTable} data
+     */
+    update(bvh, data) {
+
+        const visible_instance_set = this.__visible_set;
+
+        const instances = this.instances;
+
+        // reset visible set
+        visible_instance_set.reset();
+
+        //reset garbage pointer
+        this.__garbagePointer = 0;
+
+
+        // collect visible instances
+        const collected_nodes = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, bvh, this.__view.frustum);
+
+        for (let i = 0; i < collected_nodes; i++) {
+            const instance_id = scratch_array[i];
+
+            // mark them as visible
+            visible_instance_set.set(instance_id, true);
+        }
+
+        //remove those that are no longer visible
+        this.__compute_visibility_update();
+
+        //cull instances that are no longer visible
+        this.__removeGarbage();
+
+        //process entities that have become newly visible
+        for (
+            let index = visible_instance_set.nextSetBit(0);
+            index !== -1;
+            index = visible_instance_set.nextSetBit(index + 1)
+        ) {
+            //read transform data for instance
+            data.getRow(index, rowData);
+
+            const positionX = rowData[0];
+            const positionY = rowData[1];
+            const positionZ = rowData[2];
+
+            const encodedRotation = rowData[3];
+
+
+            const scaleX = rowData[4];
+            const scaleY = rowData[5];
+            const scaleZ = rowData[6];
+
+            const i = instances.add(index);
+
+            tempQuaternion.decodeFromUint32(encodedRotation);
+
+            //apply instance transforms
+            instances.setPositionAt(i, positionX, positionY, positionZ);
+            instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
+            instances.setScaleAt(i, scaleX, scaleY, scaleZ);
+        }
+    }
+}
+
+const tempQuaternion = new Quaternion();
+const rowData = [];

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

@@ -26,13 +26,8 @@ function cleanupLayer(layerData, renderLayer) {
 export function loadFoliageLayer(layer, assetManager) {
     const instancedFoliage = layer.data;
 
-    /**
-     * @type {THREE.Mesh}
-     */
-    const threeMesh = instancedFoliage.instances.mesh;
-
-    threeMesh.castShadow = layer.castShadow.getValue();
-    threeMesh.receiveShadow = layer.receiveShadow.getValue();
+    instancedFoliage.castShadow = layer.castShadow.getValue();
+    instancedFoliage.receiveShadow = layer.receiveShadow.getValue();
 
     const modelURL = layer.modelURL.getValue();
 
@@ -112,15 +107,24 @@ export class Foliage2System extends System {
     startup(entityManager, readyCallback, errorCallback) {
         this.entityManager = entityManager;
 
-        this.renderLayer = this.graphics.layers.create('instanced-mesh-system');
-        this.renderLayer.buildVisibleSet = (frustums, filters, visitObject, thisArg) => {
+        const graphics = this.graphics;
+
+        this.renderLayer = graphics.layers.create('instanced-mesh-system');
+
+        graphics.views.elements.forEach(this.__handle_view_added, this);
+
+        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) => {
             const data = this.data;
 
             for (let entity in data) {
 
                 const layers = data[entity];
+                const layer_count = layers.length;
 
-                for (let i = 0, numLayers = layers.length; i < numLayers; i++) {
+                for (let i = 0; i < layer_count; i++) {
                     /**
                      * @type {{instances:InstancedFoliage}}
                      */
@@ -133,9 +137,9 @@ export class Foliage2System extends System {
                          */
                         const instances = layerData.instances;
 
-                        instances.update(frustums, filters);
+                        const view_state = instances.update(view);
 
-                        const group = instances.instances;
+                        const group = view_state.instances;
 
                         if (group.getCount() <= 0) {
                             //no visible instances, skip
@@ -153,9 +157,61 @@ export class Foliage2System extends System {
         readyCallback();
     }
 
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_added(view) {
+        const em = this.entityManager;
+
+        if (em === null) {
+            return;
+        }
+
+        const ecd = em.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseComponents(InstancedMeshComponent, im => {
+            im.add_view(view);
+        });
+    }
+
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_removed(view) {
+
+        const em = this.entityManager;
+
+        if (em === null) {
+            return;
+        }
+
+        const ecd = em.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseComponents(InstancedMeshComponent, im => {
+            im.remove_view(view);
+        });
+    }
+
     shutdown(entityManager, readyCallback, errorCallback) {
         this.graphics.layers.remove(this.renderLayer);
 
+        this.graphics.views.elements.forEach(this.__handle_view_removed, this);
+        this.graphics.views.elements.on.added.remove(this.__handle_view_added, this);
+        this.graphics.views.elements.on.removed.remove(this.__handle_view_removed, this);
+
         readyCallback();
     }
 
@@ -166,16 +222,16 @@ export class Foliage2System extends System {
 
     /**
      *
-     * @param {InstancedMeshComponent} foliage
+     * @param {InstancedMeshComponent} instances
      * @param entity
      */
-    link(foliage, entity) {
+    link(instances, entity) {
         const layers = [];
         const data = this.data;
 
         data[entity] = layers;
 
-        const layerList = foliage.layers;
+        const layerList = instances.layers;
         const layer_count = layerList.length;
 
         for (let i = 0; i < layer_count; i++) {
@@ -215,11 +271,16 @@ export class Foliage2System extends System {
             }
         }
 
-        //TODO need to expose InstancedMesh BVH to let camera frustum calculation work correctly
-
+        //
+        this.graphics.views.elements.forEach(instances.add_view, instances);
     }
 
-    unlink(foliage, entity) {
+    /**
+     *
+     * @param {InstancedMeshComponent} instances
+     * @param {number} entity
+     */
+    unlink(instances, entity) {
         const renderLayer = this.renderLayer;
         const layers = this.data[entity];
 
@@ -230,7 +291,9 @@ export class Foliage2System extends System {
             cleanupLayer(layerData, renderLayer);
         }
 
-        foliage.dispose();
+        this.graphics.views.elements.forEach(instances.remove_view, instances);
+
+        instances.dispose();
 
         delete this.data[entity];
     }

package/engine/ecs/foliage/ecs/InstancedMeshComponent.js

@@ -12,6 +12,36 @@ export class InstancedMeshComponent {
         this.layers = new List();
     }
 
+    /**
+     *
+     * @param {CameraView} view
+     */
+    add_view(view) {
+        const layers = this.layers;
+        const layer_count = layers.length;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers.get(i);
+
+            layer.add_view(view);
+        }
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     */
+    remove_view(view) {
+        const layers = this.layers;
+        const layer_count = layers.length;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers.get(i);
+
+            layer.remove_view(view);
+        }
+    }
+
     toJSON() {
         return this.layers.toJSON();
     }

package/engine/ecs/foliage/ecs/InstancedMeshLayer.js

@@ -36,6 +36,22 @@ export class InstancedMeshLayer {
         this.receiveShadow = new ObservedBoolean(false);
     }
 
+    /**
+     *
+     * @param {CameraView} view
+     */
+    add_view(view) {
+        this.data.add_view(view);
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     */
+    remove_view(view) {
+        this.data.remove_view(view);
+    }
+
     dispose() {
         this.data.dispose();
     }

package/engine/ecs/foliage/ecs/InstancedMeshUtils.js

@@ -223,8 +223,8 @@ export function optimizeIndividualMeshesEntitiesToInstances(dataset, threshold =
                 layer.castShadow.set(true);
                 layer.receiveShadow.set(true);
 
-                instancedFoliage.instances.mesh.castShadow = layer.castShadow.getValue();
-                instancedFoliage.instances.mesh.receiveShadow = layer.receiveShadow.getValue();
+                instancedFoliage.castShadow = layer.castShadow.getValue();
+                instancedFoliage.receiveShadow = layer.receiveShadow.getValue();
 
                 foliage2.layers.add(layer);
 

package/engine/ecs/parent/EntityNode.js

@@ -3,10 +3,8 @@ import EntityBuilder from "../EntityBuilder.js";
 import { array_remove_first } from "../../../core/collection/array/array_remove_first.js";
 import { assert } from "../../../core/assert.js";
 import { array_push_if_unique } from "../../../core/collection/array/array_push_if_unique.js";
-import { Attachment } from "../attachment/Attachment.js";
-import { AttachmentSockets } from "../sockets/AttachmentSockets.js";
-import { AttachmentSocket } from "../sockets/AttachmentSocket.js";
 import { Transform } from "../transform/Transform.js";
+import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
 
 export class EntityNode {
     /**
@@ -81,14 +79,15 @@ export class EntityNode {
      * @private
      */
     __safe_get_attachment() {
-        let attachment = this.__entity.getComponent(Attachment);
+        const entity = this.__entity;
+
+        let attachment = entity.getComponent(TransformAttachment);
 
         if (attachment === null) {
-            attachment = new Attachment();
-            attachment.socket = "root";
+            attachment = new TransformAttachment();
             attachment.immediate = true;
 
-            this.__entity.add(attachment);
+            entity.add(attachment);
         }
 
         return attachment;
@@ -114,43 +113,44 @@ export class EntityNode {
      * @param {EntityNode|null} node
      */
     set parent(node) {
+        this.__parent = node;
+
         // check if entity is built
-        if (this.__entity.isBuilt) {
-            // live re-wiring
-            let parent_entity = this.__entity.removeComponent(ParentEntity);
-            let attachment = this.__entity.removeComponent(Attachment);
+        if (!this.__entity.isBuilt) {
+            return;
+        }
 
-            if (node !== null) {
+        let parent_entity = this.__entity.removeComponent(ParentEntity);
+        let attachment = this.__entity.removeComponent(TransformAttachment);
 
-                // handle component ParentEntity
+        if (node !== null) {
 
-                if (parent_entity === null) {
-                    parent_entity = new ParentEntity();
-                }
+            // handle component ParentEntity
 
-                const parent_entity_builder = node.entity;
+            if (parent_entity === null) {
+                parent_entity = new ParentEntity();
+            }
 
-                if (!parent_entity_builder.isBuilt) {
-                    throw new Error('Parent entity is not built');
-                }
+            const parent_entity_builder = node.entity;
 
-                const parent_entity_id = parent_entity_builder.entity;
-                parent_entity.entity = parent_entity_id;
+            if (!parent_entity_builder.isBuilt) {
+                throw new Error('Parent entity is not built');
+            }
 
-                // add component back
-                this.__entity.add(parent_entity);
+            const parent_entity_id = parent_entity_builder.entity;
+            parent_entity.entity = parent_entity_id;
 
+            // add component back
+            this.__entity.add(parent_entity);
 
-                // handle component Attachment
-                if (attachment === null) {
-                    attachment = this.__safe_get_attachment();
-                }
 
-                attachment.parent = parent_entity_id;
+            // handle component Attachment
+            if (attachment === null) {
+                attachment = this.__safe_get_attachment();
             }
-        }
 
-        this.__parent = node;
+            attachment.parent = parent_entity_id;
+        }
     }
 
     get entity() {
@@ -229,24 +229,6 @@ export class EntityNode {
             attachment.parent = parent_entity_id;
         }
 
-        // ensure "root" socket exists for transform parenting
-        /**
-         *
-         * @type {AttachmentSockets}
-         */
-        let sockets = this.__entity.getComponent(AttachmentSockets);
-        if (sockets === null) {
-            sockets = new AttachmentSockets();
-            this.__entity.add(sockets);
-        }
-
-        if (sockets.get("root") === undefined) {
-            const socket = new AttachmentSocket();
-            socket.id = "root";
-
-            sockets.add(socket);
-        }
-
         this.__transform_sync_down();
         this.__transform.position.onChanged.add(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.add(this.__transform_sync_down, this);

package/engine/ecs/transform-attachment/TransformAttachment.js

@@ -0,0 +1,88 @@
+import { Transform } from "../transform/Transform.js";
+
+export const TransformAttachmentFlags = {
+    /**
+     * Update will be performed when component is attached.
+     * It's used to turn this flag off when you know that the child's transform is already correct to save some computations
+     */
+    Immediate: 1
+};
+
+const DEFAULT_FLAGS = TransformAttachmentFlags.Immediate;
+
+export class TransformAttachment {
+    constructor() {
+        /**
+         * transform relative to the attachment target
+         * @type {Transform}
+         */
+        this.transform = new Transform();
+
+        /**
+         * Which entity to attach to
+         * @type {number}
+         */
+        this.parent = -1;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = DEFAULT_FLAGS;
+    }
+
+    get immediate() {
+        return this.getFlag(TransformAttachmentFlags.Immediate);
+    }
+
+    /**
+     *
+     * @param {boolean} v
+     */
+    set immediate(v) {
+        this.writeFlag(TransformAttachmentFlags.Immediate, v);
+    }
+
+    /**
+     *
+     * @param {number|TransformAttachmentFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|TransformAttachmentFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|TransformAttachmentFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|TransformAttachmentFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+}
+
+TransformAttachment.typeName = "TransformAttachment"

package/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -0,0 +1,59 @@
+import { System } from "../System.js";
+import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
+import { Transform } from "../transform/Transform.js";
+
+/**
+ *
+ * @param {Transform} parent_transform
+ * @param {Transform} attachment_transform
+ * @param {Transform} child_transform
+ */
+function update(parent_transform, attachment_transform, child_transform) {
+    child_transform.multiplyTransforms(parent_transform, attachment_transform);
+}
+
+export class TransformAttachmentSystem extends System {
+    constructor() {
+        super();
+
+        this.dependencies = [TransformAttachment, Transform];
+    }
+
+    /**
+     *
+     * @param {TransformAttachment} attachment
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    __update_one(attachment, transform, entity) {
+
+        const em = this.entityManager;
+        const ecd = em.dataset;
+
+        const parent_transform = ecd.getComponent(attachment.parent, Transform);
+
+        update(parent_transform, attachment.transform, transform);
+    }
+
+    /**
+     *
+     * @param {TransformAttachment} attachment
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(attachment, transform, entity) {
+        if ((attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
+            this.__update_one(attachment, transform, entity);
+        }
+    }
+
+    /**
+     *
+     * @param {TransformAttachment} attachment
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(attachment, transform, entity) {
+
+    }
+}