@woosh/meep-engine 2.33.59 → 2.33.63

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -19,7 +19,6 @@ import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 import { computeObjectBoundingSphere } from "./gltf/computeObjectBoundingSphere.js";
 import { isMesh } from "./gltf/isMesh.js";
 import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { convert_three_object_to_micron } from "../../graphics/micron/convert_three_object_to_micron.js";
 import { HashSet } from "../../../core/collection/HashSet.js";
 import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
@@ -173,11 +172,20 @@ export class GLTFAssetLoader extends AssetLoader {
         this.loader = loader;
 
         /**
-         *
+         * Asset optimization flag
+         * Whether or not geometry de-duping should be done
          * @type {boolean}
          * @private
          */
-        this.__enable_micron = true;
+        this.__enable_geometry_cache = false;
+
+        /**
+         * Asset optimization flag
+         * Whether or not texture de-duping should be done
+         * @type {boolean}
+         * @private
+         */
+        this.__enable_texture_cache = false;
 
         /**
          *
@@ -216,7 +224,7 @@ export class GLTFAssetLoader extends AssetLoader {
      * @param {boolean} v
      */
     set is_micron_enabled(v) {
-        this.__enable_micron = v;
+        console.warn('Deprecated. Handled by the MicronRenderPlugin. Remove usage, no further action required');
     }
 
     /**
@@ -224,7 +232,7 @@ export class GLTFAssetLoader extends AssetLoader {
      * @returns {boolean}
      */
     get is_micron_enabled() {
-        return this.__enable_micron;
+        throw new Error('Deprecated. Handled by the MicronRenderPlugin. Remove usage, no further action required. To check for presence of micron, check plugins instead.');
     }
 
     async link(assetManager, engine) {
@@ -275,14 +283,15 @@ export class GLTFAssetLoader extends AssetLoader {
                 alphaTest: object.material.alphaTest
             });
 
-            object.customDepthMaterial = materialCache.acquire(depthMaterial);
+            if (this.__enable_texture_cache) {
+                object.customDepthMaterial = materialCache.acquire(depthMaterial);
+            }
         }
     }
 
 
     load(path, success, failure, progress) {
         const loader = this.loader;
-        const geometry_cache = this.__geometry_cache;
         const texture_cache = this.__texture_cache;
 
 
@@ -290,19 +299,24 @@ export class GLTFAssetLoader extends AssetLoader {
          *
          * @param {THREE.Mesh|THREE.SkinnedMesh} mesh
          */
-        async function processMesh(mesh) {
+        const processMesh = async (mesh) => {
             let geometry = mesh.geometry;
 
             if (geometry === undefined) {
                 throw new Error(`No geometry found`);
             }
 
-            // replace geometry
-            geometry = geometry_cache.ensure(geometry);
-            mesh.geometry = geometry;
+            if (this.__enable_geometry_cache) {
+                // replace geometry
+                geometry = this.__geometry_cache.ensure(geometry);
+                mesh.geometry = geometry;
+            }
+
 
-            // replace textures from cache
-            replace_material_textures_from_cache(mesh.material, texture_cache);
+            if (this.__enable_texture_cache) {
+                // replace textures from cache
+                replace_material_textures_from_cache(mesh.material, texture_cache);
+            }
 
             const isSkinned = mesh.isSkinnedMesh === true;
 
@@ -431,18 +445,6 @@ export class GLTFAssetLoader extends AssetLoader {
                 asset.animations = animations;
             }
 
-            // build micron mesh
-            if (
-                this.__enable_micron
-                && (asset.animations === undefined || asset.animations.length === 0)
-            ) {
-                // TODO deal with animations
-                const micron_root = await convert_three_object_to_micron(root.clone());
-                micron_root.boundingSphere = root.boundingSphere;
-
-                asset.micron = micron_root;
-            }
-
             success(asset);
         }, function (xhr) {
             //dispatch progress callback

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

@@ -1,7 +1,7 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../core/assert.js";
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 import { bitmap2sampler_gl } from "./bitmap2sampler_gl.js";
+import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
 
 /**
  *
@@ -114,5 +114,5 @@ export function computeImageBitmapEquality(a, b) {
 
     const b_s = obtainSampler(b, ctx);
 
-    return isArrayEqualStrict(a_s.data, b_s.data);
+    return fastArrayEquals(a_s.data, b_s.data);
 }

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

@@ -1,5 +1,5 @@
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
+import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
 
 //
 
@@ -184,5 +184,5 @@ function textureMipmapEqual(a, b) {
         return true;
     }
 
-    return isArrayEqualStrict(aData, bData);
+    return fastArrayEquals(aData, bData);
 }

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/animation/InverseKinematicsSystem.js

@@ -3,9 +3,9 @@ import { InverseKinematics } from "./InverseKinematics.js";
 import Mesh, { MeshFlags } from "../../graphics/ecs/mesh/Mesh.js";
 import { TwoBoneInverseKinematicsSolver } from "./TwoBoneInverseKinematicsSolver.js";
 import { extractSkeletonFromMeshComponent } from "../../graphics/ecs/mesh/SkeletonUtils.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import { OneBoneSurfaceAlignmentSolver } from "./OneBoneSurfaceAlignmentSolver.js";
 import { IKProblem } from "./IKProblem.js";
+import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 
 
 export class InverseKinematicsSystem extends System {

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/evaluation/world/ReadTerrainLayerWeightPointFitness.js

@@ -1,8 +1,8 @@
 import { PointFitnessFunction } from "../PointFitnessFunction.js";
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import { assert } from "../../../../core/assert.js";
+import { obtainTerrain } from "../../terrain/util/obtainTerrain.js";
 
 
 const v3 = new Vector3();

package/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -2,10 +2,10 @@ import { System } from "../System.js";
 import { FogOfWarRevealer } from "./FogOfWarRevealer.js";
 import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
 import { FogOfWar } from "./FogOfWar.js";
-import Team from "../../../../model/game/ecs/component/Team.js";
+import Team from "../team/Team.js";
 import { Transform } from "../transform/Transform.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import Vector2 from "../../../core/geom/Vector2.js";
+import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 
 const v2 = new Vector2();
 

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/hud/HeadsUpDisplaySystem.js

@@ -6,23 +6,15 @@
 import { System } from '../../System.js';
 import HeadsUpDisplay from './HeadsUpDisplay.js';
 import { Transform } from '../../transform/Transform.js';
-
-import { Matrix4 } from 'three';
 import { GraphicsEngine } from "../../../graphics/GraphicsEngine.js";
 import { FogOfWarVisibilityPredicate } from "../../fow/FogOfWarVisibilityPredicate.js";
-import Vector4 from "../../../../core/geom/Vector4.js";
 import ViewportPosition from "../position/ViewportPosition.js";
 import GUIElement from "../GUIElement.js";
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
+import { mat4 } from "gl-matrix";
 
-/**
- *
- * @type {Vector4}
- */
-const v4 = new Vector4();
-const projectionMatrix = new Matrix4();
+const projection = new Float32Array(16);
 
-const up = new Vector4();
 
 /**
  *
@@ -77,7 +69,7 @@ class HeadsUpDisplaySystem extends System {
     }
 
     /**
-     *
+     * NOTE: for the sake of speed all of the matrix and vector multiplications have been inlined, readability of this method is pretty bad
      * @param {HeadsUpDisplay} hud
      * @param {Transform} transform
      * @param {ViewportPosition} vp
@@ -87,48 +79,69 @@ class HeadsUpDisplaySystem extends System {
     __apply_entity_transformation(hud, transform, vp, element) {
         const worldOffset = hud.worldOffset;
 
-        let worldOffsetX = worldOffset.x;
-        let worldOffsetY = worldOffset.y;
-        let worldOffsetZ = worldOffset.z;
-
-        v4.set(
-            worldOffsetX,
-            worldOffsetY,
-            worldOffsetZ,
-            1
-        );
+        let x = worldOffset.x;
+        let y = worldOffset.y;
+        let z = worldOffset.z;
 
         if (hud.getFlag(HeadsUpDisplayFlag.TransformWorldOffset)) {
             //apply scale and rotation
+            const transform_scale = transform.scale;
+
+            x *= transform_scale.x;
+            y *= transform_scale.y;
+            z *= transform_scale.y;
 
-            v4.multiplyVector3(transform.scale);
+            const q = transform.rotation;
+
+            const qx = q.x;
+            const qy = q.y;
+            const qz = q.z;
+            const qw = q.w;
+
+            // calculate quat * vec
+            const ix = qw * x + qy * z - qz * y;
+            const iy = qw * y + qz * x - qx * z;
+            const iz = qw * z + qx * y - qy * x;
+            const iw = -qx * x - qy * y - qz * z;
+
+            // calculate result * inverse quat
+            x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+            y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+            z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
 
-            v4.applyQuaternion(transform.rotation);
         }
 
+        // add transform position to get final world position
         const position = transform.position;
 
-        v4.add3(position);
-
-        const worldPositionX = v4.x;
-        const worldPositionY = v4.y;
-        const worldPositionZ = v4.z;
+        x += position.x;
+        y += position.y;
+        z += position.z;
 
+        const worldPositionX = x;
+        const worldPositionY = y;
+        const worldPositionZ = z;
 
         // Convert the [-1, 1] screen coordinate into a world coordinate on the near plane
-        v4.threeApplyMatrix4(projectionMatrix);
 
-        const d = 1 / Math.abs(v4.w);
-        v4.x *= d;
-        v4.y *= d;
-        v4.z *= d;
+        // apply projection matrix
+        const _x = projection[0] * x + projection[4] * y + projection[8] * z + projection[12];
+        const _y = projection[1] * x + projection[5] * y + projection[9] * z + projection[13];
+        const _z = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
+        const _w = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
+
+        // apply perspective transform
+        const d = 1 / Math.abs(_w);
+        x = _x * d;
+        y = _y * d;
+        z = _z * d;
 
-        const ndcX = (v4.x + 1) / 2;
-        const ndcY = (1 - v4.y) / 2;
+        const ndcX = (x + 1) / 2;
+        const ndcY = (1 - y) / 2;
 
         vp.position.set(ndcX, ndcY);
 
-        const trackedPositionOutOfBounds = v4.z > 1 || v4.z < -1;
+        const trackedPositionOutOfBounds = z > 1 || z < -1;
 
         const visible = (!trackedPositionOutOfBounds || vp.stickToScreenEdge) && this.__visibility_predicate.test(worldPositionX, worldPositionY, worldPositionZ);
 
@@ -141,18 +154,20 @@ class HeadsUpDisplaySystem extends System {
             if (hud.getFlag(HeadsUpDisplayFlag.PerspectiveRotation)) {
                 //compute rotation in screen-space
 
-                up.set(worldPositionX, worldPositionY + 1, worldPositionZ, 1);
-                up.threeApplyMatrix4(projectionMatrix);
+                const w_y_1 = worldPositionY + 1;
+
+                const _up_x = projection[0] * worldPositionX + projection[4] * w_y_1 + projection[8] * worldPositionZ + projection[12];
+                const _up_y = projection[1] * worldPositionX + projection[5] * w_y_1 + projection[9] * worldPositionZ + projection[13];
+                const _up_w = projection[3] * worldPositionX + projection[7] * w_y_1 + projection[11] * worldPositionZ + projection[15];
 
                 // compute perspective divide
-                const d = 1 / Math.abs(up.w);
+                const d = 1 / Math.abs(_up_w);
 
-                up.x *= d;
-                up.y *= d;
-                up.z *= d;
+                const up_x = _up_x * d;
+                const up_y = _up_y * d;
 
-                const up_ndcX = (up.x + 1) / 2;
-                const up_ndcY = (1 - up.y) / 2;
+                const up_ndcX = (up_x + 1) / 2;
+                const up_ndcY = (1 - up_y) / 2;
 
                 const angle = Math.atan2(up_ndcY - ndcY, up_ndcX - ndcX);
 
@@ -176,7 +191,7 @@ class HeadsUpDisplaySystem extends System {
          */
         const camera = this.graphics.camera;
 
-        projectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+        mat4.multiply(projection, camera.projectionMatrix.elements, camera.matrixWorldInverse.elements);
 
         const visibilityPredicate = this.__visibility_predicate;
 

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