@woosh/meep-engine 2.34.35 → 2.34.36

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) {
+
+    }
+}

package/engine/graphics/GraphicsEngine.js

@@ -26,7 +26,6 @@ import EmptyView from "../../view/elements/EmptyView.js";
 import { assert } from "../../core/assert.js";
 import { RenderLayerManager } from "./render/layers/RenderLayerManager.js";
 import { FrameBufferManager } from "./render/buffer/FrameBufferManager.js";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "./render/visibility/VisibilityComputer.js";
 import { ColorAndDepthFrameBuffer } from "./render/buffer/buffers/ColorAndDepthFrameBuffer.js";
 import { RenderPassType } from "./render/RenderPassType.js";
 import { renderTextureToScreenQuad } from "./render/utils/renderTextureToScreenQuad.js";
@@ -527,6 +526,26 @@ GraphicsEngine.prototype.clearVisibleGroup = function () {
     this.visibleGroup.children.length = 0;
 };
 
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @returns {RenderPassType}
+ */
+function classifyPassTypeFromObject(object) {
+    if (object.isMesh || object.isPoints) {
+
+        /**
+         * @type {THREE.Material}
+         */
+        const material = object.material;
+        if (material.transparent) {
+            return RenderPassType.Transparent;
+        }
+    }
+
+    return RenderPassType.Opaque;
+}
+
 /**
  *
  * @param {RenderPassType} passType
@@ -545,7 +564,9 @@ GraphicsEngine.prototype.prepareRenderPass = function (passType) {
     for (let i = 0; i < element_count; i++) {
         const object3D = visible_objects.elements[i];
 
-        if (object3D[SOURCE_RENDER_LAYER_PROPERTY].renderPass === passType) {
+        const object_pass = classifyPassTypeFromObject(object3D);
+
+        if (object_pass === passType) {
 
             //insert object, bypassing Object#add for speed
             //visibleGroup.add(object3D);

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -6,8 +6,6 @@ import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
 import { ShadowMap } from "../../shadow/ShadowMap.js";
 import { CameraView } from "../../../../render/view/CameraView.js";
 import { DoubleSide, Mesh, MeshDepthMaterial, RGBADepthPacking, Scene } from "three";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "../../../../render/visibility/VisibilityComputer.js";
-import { RenderPassType } from "../../../../render/RenderPassType.js";
 import { ThreeBypassRenderer } from "../../../../render/utils/ThreeBypassRenderer.js";
 
 const shadow_scene = new Scene();
@@ -27,7 +25,8 @@ const __depth_material = new MeshDepthMaterial({
  * @private
  */
 function __getDepthMaterial(object) {
-    let result = null;
+    let result;
+
     const customDepthMaterial = object.customDepthMaterial;
 
     if (customDepthMaterial !== undefined) {
@@ -39,21 +38,6 @@ function __getDepthMaterial(object) {
     return result;
 }
 
-/**
- *
- * @param {THREE.Object3D} object3D
- * @return {boolean}
- */
-function scene_input_filter(object3D) {
-    const layer = object3D[SOURCE_RENDER_LAYER_PROPERTY];
-
-    if (layer === undefined) {
-        return false;
-    }
-
-    return layer.renderPass === RenderPassType.Opaque
-}
-
 /**
  *
  * @param {THREE.Object3D} object3D
@@ -261,7 +245,6 @@ export class ThreeLightBinding extends LightBinding {
             input: visible_objects.elements,
             input_size: visible_object_count,
             material_extractor: __getDepthMaterial,
-            input_filter: scene_input_filter,
             object_filter: scene_object_filter
         })
 

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

@@ -1,21 +1,28 @@
-import { Matrix4 as ThreeMatrix4 } from "three";
-import { aabb3_matrix4_project_by_corners } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js";
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 
+/**
+ * Common buffer for scratch objects for better cache locality
+ * @type {ArrayBuffer}
+ */
+const scratch_buffer = new ArrayBuffer(28 * 4);
 
-const matrix4 = new ThreeMatrix4();
+/**
+ *
+ * @type {Float32Array}
+ */
+const scratch_matrix4 = new Float32Array(scratch_buffer, 0, 16);
 
 /**
- * Used to store AABB3 corners during bounding box calculation
- * @readonly
- * @type {Float64Array}
+ *
+ * @type {Float32Array}
  */
-const corners = new Float64Array(24);
+const scratch_aabb_0 = new Float32Array(scratch_buffer, 64, 6);
 
 /**
  *
  * @type {Float32Array}
  */
-const scratch_aabb = new Float32Array(6);
+const scratch_aabb_1 = new Float32Array(scratch_buffer, 88, 6);
 
 /**
  *
@@ -24,30 +31,23 @@ const scratch_aabb = new Float32Array(6);
  * @param {Transform} transform
  */
 export function updateNodeByTransformAndBBB(bvh, boundingBox, transform) {
-    transform.toThreeMatrix(matrix4);
+    transform.toMatrix4(scratch_matrix4);
 
-    /**
-     * Shortcut elements for faster access
-     * @type {number[]}
-     */
-    const e = matrix4.elements;
-
-    updateNodeByMatrix4AndBBB(bvh, boundingBox, e);
+    updateNodeByMatrix4AndBBB(bvh, boundingBox, scratch_matrix4);
 }
 
 /**
  *
  * @param {LeafNode} bvh
  * @param {AABB3} boundingBox
- * @param {number[]} matrix4
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix4
  */
 export function updateNodeByMatrix4AndBBB(bvh, boundingBox, matrix4) {
-    boundingBox.getCorners(corners);
-
+    boundingBox.writeToArray(scratch_aabb_1, 0);
 
-    aabb3_matrix4_project_by_corners(scratch_aabb, corners, matrix4);
+    aabb3_matrix4_project(scratch_aabb_0, scratch_aabb_1, matrix4);
 
-    bvh.readFromArray(scratch_aabb, 0);
+    bvh.readFromArray(scratch_aabb_0, 0);
 
     bvh.bubbleRefit();
 }

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

@@ -4,9 +4,14 @@ import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
 import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
+import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 
 const _aabb3 = new AABB3();
 
+const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
+    | ShadedGeometryFlags.ReceiveShadow
+;
+
 export class ShadedGeometry {
     constructor() {
         /**
@@ -58,7 +63,7 @@ export class ShadedGeometry {
          *
          * @type {number}
          */
-        this.flags = 0;
+        this.flags = DEFAULT_FLAGS;
     }
 
     /**
@@ -147,6 +152,9 @@ export class ShadedGeometry {
         object.matrixAutoUpdate = false;
         object.frustumCulled = false;
 
+        object.castShadow = this.getFlag(ShadedGeometryFlags.CastShadow);
+        object.receiveShadow = this.getFlag(ShadedGeometryFlags.ReceiveShadow);
+
         this.__cached_object = object;
     }
 

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

@@ -3,5 +3,8 @@
  * @enum {number}
  */
 export const ShadedGeometryFlags = {
-    InView: 1
+    InView: 1,
+
+    CastShadow: 2,
+    ReceiveShadow: 4,
 };

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

@@ -5,6 +5,7 @@ import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 
 const eh = new EngineHarness();
 
@@ -20,6 +21,7 @@ async function init(harness) {
 
     config.addSystem(new ShadedGeometrySystem(engine));
     config.addSystem(new AttachmentSystem());
+    config.addSystem(new TransformAttachmentSystem());
     config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
 
     await config.apply(engine);
@@ -29,20 +31,15 @@ async function init(harness) {
 
 /**
  *
+ * @param {string} path
  * @param {Engine} engine
  */
-async function main(engine) {
-
+async function load_gltf(path, engine) {
     const em = engine.entityManager;
 
-    EngineHarness.buildBasics({
-        engine,
-        enableWater: false
-    })
-
     const ecd = em.dataset;
 
-    const asset = await engine.assetManager.promise('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', GameAssetType.ModelGLTF_JSON);
+    const asset = await engine.assetManager.promise(path, GameAssetType.ModelGLTF_JSON);
 
     const three_object = asset.create();
 
@@ -57,4 +54,31 @@ async function main(engine) {
     console.timeEnd('composition build');
 }
 
+async function timeout(t = 1) {
+    await new Promise((resolve, reject) => setTimeout(resolve, t));
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: false
+    });
+
+    // a small delay to let background tasks finish, so we can get better performance reading later on
+    timeout(20);
+
+    load_gltf('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/07-1st-basement/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/06-lower-ground/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/05-ground-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/04-1st-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/03-2nd-floor/model.gltf', engine);
+}
+
 init(eh);

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

@@ -320,11 +320,13 @@ export class InstancedMeshGroup {
 
         const lastIndex = this.count - 1;
 
+        const references = this.references;
+
         if (index === lastIndex) {
             //easy case, reference is placed at the end, no swap needed, we can just forget about it
-            delete this.references[index];
+            delete references[index];
         } else {
-            //not at the end, move end reference to this place
+            //not at the end, move the very last reference to this place, effectively shrinking the set
             const index3 = index * 3;
             const start3 = lastIndex * 3;
             const end3 = start3 + 3;
@@ -333,26 +335,30 @@ export class InstancedMeshGroup {
             const start4 = lastIndex * 4;
             const end4 = start4 + 4;
 
-            this.__attributePosition.array.copyWithin(index3, start3, end3);
-            this.__attributeRotation.array.copyWithin(index4, start4, end4);
-            this.__attributeScale.array.copyWithin(index3, start3, end3);
+            const a_position = this.__attributePosition;
+            const a_rotation = this.__attributeRotation;
+            const a_scale = this.__attributeScale;
+
+            a_position.array.copyWithin(index3, start3, end3);
+            a_rotation.array.copyWithin(index4, start4, end4);
+            a_scale.array.copyWithin(index3, start3, end3);
 
-            this.__attributePosition.needsUpdate = true;
-            this.__attributeRotation.needsUpdate = true;
-            this.__attributeScale.needsUpdate = true;
+            a_position.needsUpdate = true;
+            a_rotation.needsUpdate = true;
+            a_scale.needsUpdate = true;
 
             //update moved reference index
-            const movedReference = this.references[lastIndex];
+            const movedReference = references[lastIndex];
 
             if (movedReference === undefined) {
                 //moved reference not found
                 throw new Error(`Moved reference was not found`);
             }
 
-            delete this.references[lastIndex];
+            delete references[lastIndex];
 
             //assume the place of removed reference
-            this.references[index] = movedReference;
+            references[index] = movedReference;
             this.indices[movedReference] = index;
         }