@woosh/meep-engine 2.33.57 → 2.33.61

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/GUIElement.js

@@ -3,7 +3,6 @@
  */
 import Vector2 from '../../../core/geom/Vector2.js';
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { assert } from "../../../core/assert.js";
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
@@ -238,108 +237,3 @@ GUIElement.serializable = true;
 export default GUIElement;
 
 
-export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GUIElement;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    serialize(buffer, value) {
-
-        if (!value.getFlag(GUIElementFlag.Managed)) {
-            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
-        }
-
-        value.anchor.toBinaryBufferFloat32(buffer);
-        buffer.writeUTF8String(value.group);
-
-        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
-
-        buffer.writeUTF8String(value.klass);
-        //write parameters
-
-        const paramKeys = Object.keys(value.parameters);
-
-        const numParamKeys = paramKeys.length;
-        buffer.writeUintVar(numParamKeys);
-
-        for (let i = 0; i < numParamKeys; i++) {
-            const paramKey = paramKeys[i];
-
-            buffer.writeUTF8String(paramKey);
-
-            const parameter = value.parameters[paramKey];
-
-            const paramType = typeof parameter;
-
-            if (paramType === "number") {
-                buffer.writeUint8(1);
-
-                buffer.writeFloat64(parameter);
-            } else if (paramType === "boolean") {
-                buffer.writeUint8(2);
-
-                buffer.writeUint8(parameter ? 1 : 0);
-            } else if (paramType === "string") {
-                buffer.writeUint8(3);
-
-                buffer.writeUTF8String(parameter);
-            } else {
-                throw new TypeError(`Unsupported parameter type ${paramType}`);
-            }
-
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    deserialize(buffer, value) {
-        value.anchor.fromBinaryBufferFloat32(buffer);
-
-        value.group = buffer.readUTF8String();
-
-        value.visible.set(buffer.readUint8() !== 0);
-
-        value.klass = buffer.readUTF8String();
-
-        const numParamKeys = buffer.readUintVar();
-
-        const params = {};
-
-        for (let i = 0; i < numParamKeys; i++) {
-            //read key
-            const paramKey = buffer.readUTF8String();
-
-            //read type flag
-            const paramTypeHeader = buffer.readUint8();
-
-            let paramValue;
-            if (paramTypeHeader === 1) {
-                //number
-                paramValue = buffer.readFloat64();
-            } else if (paramTypeHeader === 2) {
-                //boolean
-                paramValue = buffer.readUint8() !== 0;
-            } else if (paramTypeHeader === 3) {
-                //string
-                paramValue = buffer.readUTF8String();
-            } else {
-                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
-            }
-
-            params[paramKey] = paramValue;
-        }
-
-        value.parameters = params;
-    }
-}

package/engine/ecs/gui/GUIElementSerializationAdapter.js

@@ -0,0 +1,108 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import GUIElement, { GUIElementFlag } from "./GUIElement.js";
+
+export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GUIElement;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    serialize(buffer, value) {
+
+        if (!value.getFlag(GUIElementFlag.Managed)) {
+            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
+        }
+
+        value.anchor.toBinaryBufferFloat32(buffer);
+        buffer.writeUTF8String(value.group);
+
+        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
+
+        buffer.writeUTF8String(value.klass);
+        //write parameters
+
+        const paramKeys = Object.keys(value.parameters);
+
+        const numParamKeys = paramKeys.length;
+        buffer.writeUintVar(numParamKeys);
+
+        for (let i = 0; i < numParamKeys; i++) {
+            const paramKey = paramKeys[i];
+
+            buffer.writeUTF8String(paramKey);
+
+            const parameter = value.parameters[paramKey];
+
+            const paramType = typeof parameter;
+
+            if (paramType === "number") {
+                buffer.writeUint8(1);
+
+                buffer.writeFloat64(parameter);
+            } else if (paramType === "boolean") {
+                buffer.writeUint8(2);
+
+                buffer.writeUint8(parameter ? 1 : 0);
+            } else if (paramType === "string") {
+                buffer.writeUint8(3);
+
+                buffer.writeUTF8String(parameter);
+            } else {
+                throw new TypeError(`Unsupported parameter type ${paramType}`);
+            }
+
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    deserialize(buffer, value) {
+        value.anchor.fromBinaryBufferFloat32(buffer);
+
+        value.group = buffer.readUTF8String();
+
+        value.visible.set(buffer.readUint8() !== 0);
+
+        value.klass = buffer.readUTF8String();
+
+        const numParamKeys = buffer.readUintVar();
+
+        const params = {};
+
+        for (let i = 0; i < numParamKeys; i++) {
+            //read key
+            const paramKey = buffer.readUTF8String();
+
+            //read type flag
+            const paramTypeHeader = buffer.readUint8();
+
+            let paramValue;
+            if (paramTypeHeader === 1) {
+                //number
+                paramValue = buffer.readFloat64();
+            } else if (paramTypeHeader === 2) {
+                //boolean
+                paramValue = buffer.readUint8() !== 0;
+            } else if (paramTypeHeader === 3) {
+                //string
+                paramValue = buffer.readUTF8String();
+            } else {
+                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
+            }
+
+            params[paramKey] = paramValue;
+        }
+
+        value.parameters = params;
+    }
+}

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