@woosh/meep-engine 2.33.60 → 2.33.61

package/core/geom/3d/SurfacePoint3.js

@@ -1,5 +1,6 @@
 import Quaternion from "../Quaternion.js";
 import Vector3 from "../Vector3.js";
+import { v3_length } from "../v3_length.js";
 
 const q = new Quaternion();
 
@@ -14,14 +15,52 @@ export class SurfacePoint3 {
 
     /**
      *
-     * @param {THREE.Matrix4} matrix4
+     * @param {number[]|mat4|Float32Array} m4
      */
-    applyMatrix4_three(matrix4) {
-        this.position.applyMatrix4_three(matrix4);
+    applyMatrix4(m4) {
+        // transform position
+        const p = this.position;
+
+        const p_x = p.x;
+        const p_y = p.y;
+        const p_z = p.z;
+
+        const result_p_x = m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12];
+        const result_p_y = m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13];
+        const result_p_z = m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14];
+
+        this.position.set(
+            result_p_x,
+            result_p_y,
+            result_p_z
+        );
+
+        // transform normal
+        const n = this.normal;
+
+        const n_x = n.x;
+        const n_y = n.y;
+        const n_z = n.z;
+
+        const result_n_x = m4[0] * n_x + m4[4] * n_y + m4[8] * n_z;
+        const result_n_y = m4[1] * n_x + m4[5] * n_y + m4[9] * n_z;
+        const result_n_z = m4[2] * n_x + m4[6] * n_y + m4[10] * n_z;
 
-        q.setFromRotationMatrix(matrix4);
+        const normal_multiplier = 1 / v3_length(result_n_x, result_n_y, result_n_z);
 
-        this.normal.applyQuaternion(q);
+        this.normal.set(
+            result_n_x * normal_multiplier,
+            result_n_y * normal_multiplier,
+            result_n_z * normal_multiplier,
+        );
+    }
+
+    /**
+     *
+     * @param {THREE.Matrix4} matrix4
+     */
+    applyMatrix4_three(matrix4) {
+        this.applyMatrix4(matrix4.elements);
     }
 
     /**

package/core/geom/Vector2.d.ts

@@ -30,6 +30,8 @@ export default class Vector2 {
 
     copy(other: Vector2): void
 
+    clone(): Vector2
+
     distanceTo(other: Vector2): number
 
     isZero(): boolean

package/core/geom/packing/MaxRectangles.js

@@ -12,9 +12,10 @@ import Vector2 from "../Vector2.js";
  * @param {AABB2[]} boxes
  */
 function removeRedundantBoxesArray(boxes) {
+    let i, j;
     let numBoxes = boxes.length;
 
-    loop_a: for (let i = 0; i < numBoxes; i++) {
+    loop_a: for (i = 0; i < numBoxes; i++) {
         const a = boxes[i];
 
         const ax0 = a.x0;
@@ -22,7 +23,7 @@ function removeRedundantBoxesArray(boxes) {
         const ax1 = a.x1;
         const ay1 = a.y1;
 
-        for (let j = i + 1; j < numBoxes; j++) {
+        for (j = i + 1; j < numBoxes; j++) {
             const b = boxes[j];
 
             const bx0 = b.x0;
@@ -157,7 +158,7 @@ function findBestContainer(width, height, boxes, costFunction) {
     let best = null;
     let bestScore = Number.POSITIVE_INFINITY;
 
-    boxes.traversePreOrder(node => {
+    const visitor = (node) => {
 
         if (node.getWidth() < width) {
             //too small, don't traverse deeper
@@ -195,7 +196,11 @@ function findBestContainer(width, height, boxes, costFunction) {
                 best = box;
             }
         }
-    });
+
+        return true;
+    };
+
+    boxes.traversePreOrder(visitor);
 
     return best;
 }
@@ -337,6 +342,10 @@ export class MaxRectanglesPacker {
         this.free = new QuadTreeNode(0, 0, width, height);
         this.free.add(null, 0, 0, width, height);
 
+        /**
+         *
+         * @type {AABB2[]}
+         */
         this.boxes = [];
     }
 

package/core/math/hash/murmur3_32.js

@@ -9,9 +9,9 @@ export function murmur3_32(key, seed) {
     let k1;
     let i = 0;
 
-    const bytes = key.length;
+    const key_length = key.length;
 
-    while (i < bytes) {
+    while (i < key_length) {
         k1 = key[i];
         ++i;
 
@@ -26,7 +26,7 @@ export function murmur3_32(key, seed) {
     }
 
     // mix in array length
-    h1 ^= bytes;
+    h1 ^= key_length;
 
     h1 ^= h1 >>> 16;
     h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16));

package/engine/asset/loaders/material/computeTextureHash.js

@@ -1,7 +1,7 @@
-import { max2 } from "../../../../core/math/max2.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { murmur3_32 } from "../../../../core/math/hash/murmur3_32.js";
 
 /**
  *
@@ -59,6 +59,7 @@ export function computeImageDataHash(image) {
  */
 function computeSpecificHash(texture) {
     let dataHash = 0;
+    let i;
 
     if (texture.image !== null && texture.image !== undefined) {
 
@@ -73,25 +74,18 @@ function computeSpecificHash(texture) {
     if (Array.isArray(mipmaps)) {
         const nMipmaps = mipmaps.length;
 
-        for (let i = 0; i < nMipmaps; i++) {
+        for (i = 0; i < nMipmaps; i++) {
             const mipmap = mipmaps[i];
 
-            if (mipmap.width > 16) {
-                continue;
-            }
-
             const data = mipmap.data;
-
             const dataSize = data.length;
 
-            const dataStride = max2(1, Math.floor(dataSize / 31));
-
-            for (let i = 0; i < dataSize; i += dataStride) {
-                const datum = data[i];
-
-                dataHash = ((dataHash << 5) - dataHash) + datum;
+            if (dataSize > 1024) {
+                continue;
             }
 
+            dataHash = ((dataHash << 5) - dataHash) + murmur3_32(data, 1337);
+
             break;
         }
 

package/engine/ecs/attachment/AttachmentSystem.js

@@ -6,7 +6,6 @@ import { assert } from "../../../core/assert.js";
 import Mesh from "../../graphics/ecs/mesh/Mesh.js";
 import { BoneAttachmentBinding } from "./BoneAttachmentBinding.js";
 import { TransformAttachmentBinding } from "./TransformAttachmentBinding.js";
-import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
 
 /**
  * @readonly
@@ -318,10 +317,10 @@ export class AttachmentSystem extends System {
 
     /**
      *
-     * @param {Mesh} mesh
      * @param {number} entity
+     * @private
      */
-    visitVisibleMesh(mesh, entity) {
+    __update_entity(entity) {
         const bindings = this.parentBindingIndex.get(entity);
 
         if (bindings !== undefined) {
@@ -335,25 +334,27 @@ export class AttachmentSystem extends System {
         }
     }
 
+    /**
+     *
+     * @param {Mesh} mesh
+     * @param {number} entity
+     */
+    visitComponent(mesh, entity) {
+        this.__update_entity(entity);
+    }
+
     update(timeDelta) {
         //process wait queue
         this.processWaiting();
 
-        /**
-         *
-         * @type {MeshSystem}
-         */
-        const meshSystem = this.entityManager.getSystem(MeshSystem);
+        const em = this.entityManager;
 
-        meshSystem.traverseVisible(this.visitVisibleMesh, this);
+        const ecd = em.dataset;
 
-    }
-}
+        if (ecd === null) {
+            return;
+        }
 
-/**
- *
- * @param {AttachmentBinding} binding
- */
-function updateBinding(binding) {
-    binding.update();
+        ecd.traverseComponents(Attachment, this.visitComponent, this);
+    }
 }

package/engine/ecs/grid/HeightMap2NormalMap.js

@@ -5,7 +5,7 @@
 import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
 import NormalMapShader from '../../graphics/shaders/NormalMapShader2.js';
 import ImageFilter from '../../graphics/filter/ImageFilter.js';
-import { sampler2DtoFloat32Texture } from "./sampler2DToFloat32Texture.js";
+import { sampler2DtoFloat32Texture } from "../../graphics/texture/sampler/sampler2DToFloat32Texture.js";
 
 
 function convertChannel(v) {

package/engine/ecs/grid/NormalMap2AOMap.js

@@ -9,7 +9,7 @@ import sampler2D2Texture from '../../graphics/texture/sampler/Sampler2D2Texture.
 import AmbientOcclusionShader from '../../graphics/shaders/AmbientOcclusionShader.js';
 import GaussianBlurShader from '../../graphics/shaders/GaussianBlurShader.js';
 import ImageFilter from '../../graphics/filter/ImageFilter.js';
-import { sampler2DtoFloat32Texture } from "./sampler2DToFloat32Texture.js";
+import { sampler2DtoFloat32Texture } from "../../graphics/texture/sampler/sampler2DToFloat32Texture.js";
 
 function filterResult2Texture(data, width, height) {
     const result = new DataTexture();

package/engine/ecs/gui/position/ViewportPositionSystem.js

@@ -5,7 +5,6 @@ import { System } from '../../System.js';
 import ViewportPosition from './ViewportPosition.js';
 import GUIElement from "../GUIElement.js";
 import { assert } from "../../../../core/assert.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
 import { SignalBinding } from "../../../../core/events/signal/SignalBinding.js";
 import { EPSILON } from "../../../../core/math/MathUtils.js";
 import AABB2 from "../../../../core/geom/AABB2.js";
@@ -202,8 +201,9 @@ function setElementPosition(view, bounds, viewportSize, vp) {
     if (vp.stickToScreenEdge) {
 
 
-        const clipEdgeX = vp.screenEdgeWidth / viewportSize.x;
-        const clipEdgeY = vp.screenEdgeWidth / viewportSize.y;
+        const screenEdgeWidth = vp.screenEdgeWidth;
+        const clipEdgeX = screenEdgeWidth / viewportSize.x;
+        const clipEdgeY = screenEdgeWidth / viewportSize.y;
 
 
         stickyBounds.set(clipEdgeX, clipEdgeY, 1 - clipEdgeX, 1 - clipEdgeY);
@@ -241,8 +241,8 @@ function setElementPosition(view, bounds, viewportSize, vp) {
     }
 
 
-    const targetX = (x) * (viewportSize.x);
-    const targetY = (y) * (viewportSize.y);
+    const targetX = x * (viewportSize.x);
+    const targetY = y * (viewportSize.y);
 
     const viewPosition = view.position;
 

package/engine/ecs/parent/EntityNode.d.ts

@@ -0,0 +1,20 @@
+import EntityBuilder from "../EntityBuilder";
+import {EntityComponentDataset} from "../EntityComponentDataset";
+import {Transform} from "../transform/Transform";
+
+export class EntityNode {
+    constructor(entity?: EntityBuilder)
+
+    parent: EntityNode | null
+    entity: EntityBuilder
+
+    transform: Transform
+
+    addChild(node: EntityNode): boolean
+
+    removeChild(node: EntityNode): boolean
+
+    build(ecd: EntityComponentDataset): void
+
+    destroy(): void
+}

package/engine/ecs/parent/EntityNode.js

@@ -0,0 +1,284 @@
+import { ParentEntity } from "./ParentEntity.js";
+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";
+
+export class EntityNode {
+    /**
+     *
+     * @param {EntityBuilder} [entity] optional entity to be wrapped
+     */
+    constructor(entity = new EntityBuilder()) {
+        /**
+         *
+         * @type {EntityNode|null}
+         * @private
+         */
+        this.__parent = null;
+        /**
+         *
+         * @type {EntityBuilder}
+         * @private
+         */
+        this.__entity = entity;
+        /**
+         *
+         * @type {EntityNode[]}
+         * @private
+         */
+        this.__children = [];
+
+        /**
+         *
+         * @type {Transform}
+         * @private
+         */
+        this.__transform = new Transform();
+    }
+
+    /**
+     *
+     * @private
+     */
+    __transform_sync_down() {
+
+        if (this.__parent === null) {
+            const t = this.__entity.getComponent(Transform);
+            if (t !== null) {
+                t.copy(this.__transform);
+            }
+        } else {
+            this.__safe_get_attachment().transform.copy(this.__transform);
+        }
+
+    }
+
+    /**
+     *
+     * @param {*} components
+     * @return {EntityNode}
+     */
+    static fromComponents(...components) {
+        const node = new EntityNode();
+
+        for (let i = 0; i < components.length; i++) {
+            const component = components[i];
+
+            node.entity.add(component);
+        }
+
+        return node;
+    }
+
+    /**
+     *
+     * @return {Attachment}
+     * @private
+     */
+    __safe_get_attachment() {
+        let attachment = this.__entity.getComponent(Attachment);
+
+        if (attachment === null) {
+            attachment = new Attachment();
+            attachment.socket = "root";
+            attachment.immediate = true;
+
+            this.__entity.add(attachment);
+        }
+
+        return attachment;
+    }
+
+    /**
+     * @returns {Transform}
+     */
+    get transform() {
+        return this.__transform;
+    }
+
+    /**
+     *
+     * @return {EntityNode|null}
+     */
+    get parent() {
+        return this.__parent;
+    }
+
+    /**
+     *
+     * @param {EntityNode|null} node
+     */
+    set 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 (node !== null) {
+
+                // handle component ParentEntity
+
+                if (parent_entity === null) {
+                    parent_entity = new ParentEntity();
+                }
+
+                const parent_entity_builder = node.entity;
+
+                if (!parent_entity_builder.isBuilt) {
+                    throw new Error('Parent entity is not built');
+                }
+
+                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;
+            }
+        }
+
+        this.__parent = node;
+    }
+
+    get entity() {
+        return this.__entity;
+    }
+
+    /**
+     *
+     * @param {EntityNode} node
+     * @returns {boolean}
+     */
+    addChild(node) {
+        const added = array_push_if_unique(this.__children, node);
+
+        if (added) {
+            if (node.parent !== null) {
+                // has a parent already, detach
+                node.parent.removeChild(node);
+            }
+
+            node.parent = this;
+        }
+
+        return added;
+    }
+
+    /**
+     *
+     * @param {EntityNode} node
+     * @returns {boolean}
+     */
+    removeChild(node) {
+        const removed = array_remove_first(this.__children, node);
+
+        if (removed) {
+            assert.equal(node.parent, this, 'node is a child, but parent property points to something else instead of this node');
+
+            node.parent = null;
+        }
+
+        return removed;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     */
+    build(ecd) {
+
+        // assume that parent is built
+        const parent = this.__parent;
+
+        if (parent !== null) {
+            /**
+             *
+             * @type {ParentEntity}
+             */
+            let parent_entity = this.__entity.getComponent(ParentEntity);
+            if (parent_entity === null) {
+                parent_entity = new ParentEntity();
+                this.__entity.add(parent_entity);
+            }
+
+            const parent_entity_builder = parent.__entity;
+
+            if (!parent_entity_builder.isBuilt) {
+                throw new Error('Parent entity is not built');
+            }
+
+            const parent_entity_id = parent_entity_builder.entity;
+            parent_entity.entity = parent_entity_id;
+
+
+            const attachment = this.__safe_get_attachment();
+
+            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);
+        this.__transform.rotation.onChanged.add(this.__transform_sync_down, this);
+
+        this.__entity.build(ecd);
+
+        // build children
+        const children = this.__children;
+        const child_count = children.length;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            child.build(ecd);
+        }
+    }
+
+    destroy() {
+        this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
+        this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);
+        this.__transform.rotation.onChanged.remove(this.__transform_sync_down, this);
+
+        // destroy children first
+        const children = this.__children;
+        const child_count = children.length;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            child.destroy();
+        }
+
+        // then main entity
+        this.__entity.destroy();
+    }
+}