@woosh/meep-engine 2.34.33 → 2.34.37

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/sockets/AttachmentSockets.js

@@ -18,7 +18,17 @@ export class AttachmentSockets {
      * @returns {AttachmentSocket|undefined}
      */
     get(id) {
-        return this.elements.find(s => s.id === id);
+        const elements = this.elements;
+        const n = elements.length;
+
+        for (let i = 0; i < n; i++) {
+            const socket = elements.get(i);
+
+            if (socket.id === id) {
+                return socket;
+            }
+        }
+
     }
 
     /**

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.depthWrite === false && material.depthTest === false) {
+            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/camera/Camera.js

@@ -5,11 +5,13 @@
 
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import ObservedEnum from "../../../../core/model/ObservedEnum.js";
-import {Frustum, Vector3 as ThreeVector3} from 'three';
-import {assert} from "../../../../core/assert.js";
+import { Frustum } from 'three';
+import { assert } from "../../../../core/assert.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
-import {frustumFromCamera} from "./CameraSystem.js";
-import {computePointDistanceToPlane} from "../../../../core/geom/Plane.js";
+import { frustumFromCamera } from "./CameraSystem.js";
+import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
+import { unprojectPoint } from "./unprojectPoint.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 
 /**
  *
@@ -116,15 +118,15 @@ export class Camera {
 
     /**
      *
-     * @param {Camera} camera
+     * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
      * @param {number} x
      * @param {number} y
      * @param {Vector3} source
      * @param {Vector3} direction
      */
     static projectRay(camera, x, y, source, direction) {
-        assert.notEqual(camera, undefined, "Camera must be defined");
-        assert.notEqual(camera.position, undefined, "Camera.position must be defined");
+        assert.defined(camera, "camera");
+        assert.defined(camera.position, "Camera.position");
 
 
         assert.isNumber(x, 'x');
@@ -136,18 +138,32 @@ export class Camera {
         // assert.ok(y >= -1, `Y(=${y}) must be greater than or equal to -1.0, not a clip-space coordinate`);
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
-        source.copy(camera.position);
+        if (camera.isPerspectiveCamera) {
+            scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
 
-        v3.set(x, y, 0.5);
+            scratch_v3_0.set(x, y, 0.5);
 
-        // NOTE: projection inverse and world matrices are used in "unproject" operation, we update those to make things work as intended. This is handled by the camera system
+            // NOTE: projection inverse and world matrices are used in "unproject" operation, we update those to make things work as intended. This is handled by the camera system
 
-        v3.unproject(camera);
+            unprojectPoint(
+                scratch_v3_0,
+                scratch_v3_0,
+                camera.projectionMatrixInverse.elements,
+                camera.matrixWorld.elements
+            );
 
-        //get direction
-        v3.sub(source).normalize();
+            //get direction
+            scratch_v3_0.sub(scratch_v3_1);
+            scratch_v3_0.normalize();
 
-        direction.copy(v3);
+            source.copy(scratch_v3_1);
+            direction.copy(scratch_v3_0);
+
+        } else if (camera.isOrthographicCamera) {
+            throw new Error('Unsupported camera type: "Orthographic" ');
+        } else {
+            throw new Error('Unsupported camera type');
+        }
     }
 
     /**
@@ -179,7 +195,7 @@ export class Camera {
 
         const near = scratch_frustum.planes[0];
 
-        v3.set(x, y, z);
+        scratch_v3_0.set(x, y, z);
 
         const normal = near.normal;
 
@@ -199,7 +215,8 @@ Camera.typeName = "Camera";
 
 Camera.ProjectionType = ProjectionType;
 
-const v3 = new ThreeVector3();
+const scratch_v3_0 = new Vector3();
+const scratch_v3_1 = new Vector3();
 const scratch_frustum = new Frustum();
 
 

package/engine/graphics/ecs/camera/unprojectPoint.js

@@ -0,0 +1,14 @@
+//
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {Vector3} input
+ * @param {number[]} projection_matrix_inverse inverse of projection matrix
+ * @param {number[]} world_matrix world transform
+ */
+export function unprojectPoint(result, input, projection_matrix_inverse, world_matrix) {
+    result.copy(input);
+    result.applyMatrix4(projection_matrix_inverse);
+    result.applyMatrix4(world_matrix);
+}

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;
     }