@woosh/meep-engine 2.49.8 → 2.50.0

package/src/engine/ecs/animation/Animation.js

@@ -4,157 +4,10 @@
 
 
 import List from '../../../core/collection/list/List.js';
-import ObservedString from "../../../core/model/ObservedString.js";
-import ObservedInteger from "../../../core/model/ObservedInteger.js";
-import Vector1 from "../../../core/geom/Vector1.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
-
-/**
- *
- * @enum {number}
- */
-export const AnimationClipFlag = {
-    ClampWhenFinished: 1
-};
-
-class AnimationClip {
-    constructor() {
-        this.name = new ObservedString("");
-        this.repeatCount = new ObservedInteger(1);
-
-        /**
-         *
-         * @type {Vector1}
-         */
-        this.weight = new Vector1(1);
-
-        /**
-         *
-         * @type {Vector1}
-         */
-        this.timeScale = new Vector1(1);
-
-        /**
-         *
-         * @type {number}
-         */
-        this.flags = 0;
-    }
-
-    /**
-     *
-     * @param {AnimationClip} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.name.equals(other.name)
-            && this.repeatCount.equals(other.repeatCount)
-            && this.weight.equals(other.weight)
-            && this.timeScale.equals(other.timeScale)
-            && this.flags === other.flags;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    hash() {
-        return computeHashIntegerArray(
-            this.name.hash(),
-            this.repeatCount.hash(),
-            this.weight.hash(),
-            this.timeScale.hash(),
-            this.flags
-        );
-    }
-
-    /**
-     *
-     * @param {number|AnimationClipFlag} v
-     * @returns {boolean}
-     */
-    getFlag(v) {
-        return (this.flags & v) !== 0;
-    }
-
-    fromJSON(json) {
-        if (typeof json.name === "string") {
-            this.name.fromJSON(json.name);
-        }
-
-        if (typeof json.repeatCount === "number") {
-            this.repeatCount.fromJSON(json.repeatCount);
-        } else {
-            this.repeatCount.set(Number.POSITIVE_INFINITY);
-        }
-
-        if (typeof json.weight === "number") {
-            this.weight.fromJSON(json.weight);
-        } else {
-            this.weight.set(1);
-        }
-
-        if (typeof json.timeScale === "number") {
-            this.timeScale.fromJSON(json.timeScale);
-        } else {
-            this.timeScale.set(1);
-        }
-
-        if (typeof json.flags === "number") {
-            this.flags = json.flags;
-        } else {
-            this.flags = 0;
-        }
-    }
-
-    toJSON() {
-        return {
-            name: this.name.toJSON(),
-            repeatCount: this.repeatCount.toJSON(),
-            weight: this.weight.toJSON(),
-            timeScale: this.timeScale.toJSON(),
-            flags: this.flags
-        };
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        //write flags
-        buffer.writeUint8(this.flags);
-
-        this.name.toBinaryBuffer(buffer);
-        this.repeatCount.toBinaryBuffer(buffer);
-        this.weight.toBinaryBuffer(buffer);
-        this.timeScale.toBinaryBuffer(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        this.flags = buffer.readUint8();
-
-        this.name.fromBinaryBuffer(buffer);
-        this.repeatCount.fromBinaryBuffer(buffer);
-        this.weight.fromBinaryBuffer(buffer);
-        this.timeScale.fromBinaryBuffer(buffer);
-    }
-}
-
-/**
- *
- * @enum {number}
- */
-export const AnimationFlags = {
-    Playing: 1,
-    MeshSizeCulling: 2
-};
+import { AnimationClip } from "./AnimationClip.js";
+import { AnimationFlags } from "./AnimationFlags.js";
 
 /**
  * @class
@@ -308,8 +161,6 @@ export class Animation {
 
 }
 
-Animation.Clip = AnimationClip;
-
 /**
  *
  * @param json
@@ -324,32 +175,3 @@ Animation.fromJSON = function (json) {
 };
 
 Animation.typeName = "Animation";
-
-export class AnimationSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = Animation;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Animation} value
-     */
-    serialize(buffer, value) {
-        value.clips.toBinaryBuffer(buffer);
-        buffer.writeFloat64(value.debtTime);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Animation} value
-     */
-    deserialize(buffer, value) {
-        value.clips.fromBinaryBuffer(buffer, AnimationClip);
-        value.debtTime = buffer.readFloat64();
-    }
-}

package/src/engine/ecs/animation/AnimationClip.js

@@ -0,0 +1,132 @@
+import ObservedString from "../../../core/model/ObservedString.js";
+import ObservedInteger from "../../../core/model/ObservedInteger.js";
+import Vector1 from "../../../core/geom/Vector1.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+
+export class AnimationClip {
+    constructor() {
+        this.name = new ObservedString("");
+        this.repeatCount = new ObservedInteger(1);
+
+        /**
+         *
+         * @type {Vector1}
+         */
+        this.weight = new Vector1(1);
+
+        /**
+         *
+         * @type {Vector1}
+         */
+        this.timeScale = new Vector1(1);
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = 0;
+    }
+
+    /**
+     *
+     * @param {AnimationClip} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.name.equals(other.name)
+            && this.repeatCount.equals(other.repeatCount)
+            && this.weight.equals(other.weight)
+            && this.timeScale.equals(other.timeScale)
+            && this.flags === other.flags;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        return computeHashIntegerArray(
+            this.name.hash(),
+            this.repeatCount.hash(),
+            this.weight.hash(),
+            this.timeScale.hash(),
+            this.flags
+        );
+    }
+
+    /**
+     *
+     * @param {number|AnimationClipFlag} v
+     * @returns {boolean}
+     */
+    getFlag(v) {
+        return (this.flags & v) !== 0;
+    }
+
+    fromJSON(json) {
+        if (typeof json.name === "string") {
+            this.name.fromJSON(json.name);
+        }
+
+        if (typeof json.repeatCount === "number") {
+            this.repeatCount.fromJSON(json.repeatCount);
+        } else {
+            this.repeatCount.set(Number.POSITIVE_INFINITY);
+        }
+
+        if (typeof json.weight === "number") {
+            this.weight.fromJSON(json.weight);
+        } else {
+            this.weight.set(1);
+        }
+
+        if (typeof json.timeScale === "number") {
+            this.timeScale.fromJSON(json.timeScale);
+        } else {
+            this.timeScale.set(1);
+        }
+
+        if (typeof json.flags === "number") {
+            this.flags = json.flags;
+        } else {
+            this.flags = 0;
+        }
+    }
+
+    toJSON() {
+        return {
+            name: this.name.toJSON(),
+            repeatCount: this.repeatCount.toJSON(),
+            weight: this.weight.toJSON(),
+            timeScale: this.timeScale.toJSON(),
+            flags: this.flags
+        };
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        //write flags
+        buffer.writeUint8(this.flags);
+
+        this.name.toBinaryBuffer(buffer);
+        this.repeatCount.toBinaryBuffer(buffer);
+        this.weight.toBinaryBuffer(buffer);
+        this.timeScale.toBinaryBuffer(buffer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.flags = buffer.readUint8();
+
+        this.name.fromBinaryBuffer(buffer);
+        this.repeatCount.fromBinaryBuffer(buffer);
+        this.weight.fromBinaryBuffer(buffer);
+        this.timeScale.fromBinaryBuffer(buffer);
+    }
+}

package/src/engine/ecs/animation/AnimationClip.spec.js

@@ -0,0 +1,5 @@
+import { AnimationClip } from "./AnimationClip.js";
+
+test("constructor does not throw", () => {
+    expect(() => new AnimationClip()).not.toThrow();
+});

package/src/engine/ecs/animation/AnimationClipFlag.js

@@ -0,0 +1,7 @@
+/**
+ *
+ * @enum {number}
+ */
+export const AnimationClipFlag = {
+    ClampWhenFinished: 1
+};

package/src/engine/ecs/animation/AnimationFlags.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @enum {number}
+ */
+export const AnimationFlags = {
+    Playing: 1,
+    MeshSizeCulling: 2
+};

package/src/engine/ecs/animation/AnimationSerializationAdapter.js

@@ -0,0 +1,32 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import { AnimationClip } from "./AnimationClip.js";
+import { Animation } from "./Animation.js";
+
+export class AnimationSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = Animation;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Animation} value
+     */
+    serialize(buffer, value) {
+        value.clips.toBinaryBuffer(buffer);
+        buffer.writeFloat64(value.debtTime);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Animation} value
+     */
+    deserialize(buffer, value) {
+        value.clips.fromBinaryBuffer(buffer, AnimationClip);
+        value.debtTime = buffer.readFloat64();
+    }
+}

package/src/engine/ecs/fow/FogOfWar.js

@@ -6,13 +6,13 @@ import { ClampToEdgeWrapping, DataTexture, LinearFilter, RedFormat, UnsignedByte
 import Vector1 from "../../../core/geom/Vector1.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { assert } from "../../../core/assert.js";
-import { computeUnsignedDistanceField } from "../../graphics/texture/sampler/distanceField.js";
 import Vector4 from "../../../core/geom/Vector4.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { writeSample2DDataToDataTexture } from "../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
+import { computeUnsignedDistanceField } from "../../graphics/texture/sampler/distance/computeUnsignedDistanceField.js";
 
 const samplePosition = [];
 

package/src/engine/ecs/guid/GUID.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { randomUint8 } from "../../../core/math/random/randomUint8.js";
 import { dec2hex } from "../../../core/binary/dec2hex.js";
-import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
 import { randomBytes } from "../../../core/math/random/randomBytes.js";
 import { assert } from "../../../core/assert.js";
 

package/src/engine/ecs/systems/AnimationSystem.js

@@ -7,7 +7,7 @@
 
 import { max3 } from "../../../core/math/max3.js";
 import { System } from '../System.js';
-import { Animation, AnimationClipFlag, AnimationFlags } from '../animation/Animation.js';
+import { Animation } from '../animation/Animation.js';
 import Mesh from '../../graphics/ecs/mesh/Mesh.js';
 import Future, { FutureStates } from '../../../core/process/Future.js';
 
@@ -25,6 +25,8 @@ import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
 import { projectSphere } from "../../graphics/util/projectSphere.js";
 import { threeUpdateTransform } from "../../graphics/util/threeUpdateTransform.js";
 import { MeshEvents } from "../../graphics/ecs/mesh/MeshEvents.js";
+import { AnimationClipFlag } from "../animation/AnimationClipFlag.js";
+import { AnimationFlags } from "../animation/AnimationFlags.js";
 
 /**
  *

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -5,7 +5,7 @@ import { min2 } from "../../../../../core/math/min2.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../../core/assert.js";
 import { scaleSampler2D } from "../../../../graphics/texture/sampler/scaleSampler2D.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../../core/collection/array/array_copy.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { Base64 } from "../../../../../core/binary/Base64.js";
 import { countTask } from "../../../../../core/process/task/util/countTask.js";

package/src/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -15,7 +15,7 @@ import { scaleSampler2D } from "../../../graphics/texture/sampler/scaleSampler2D
 import { uint82float } from "../../../../core/binary/uint82float.js";
 import { float2uint8 } from "../../../../core/binary/float2uint8.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
 
 class Context {

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -26,7 +26,7 @@ import Signal from "../../../../core/events/signal/Signal.js";
 import { mat4 } from "gl-matrix";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 
 /**

package/src/engine/ecs/transform/Transform.d.ts

@@ -6,6 +6,8 @@ export class Transform {
     public readonly rotation: Quaternion
     public readonly scale: Vector3
 
+    flags: number
+
     public readonly matrix: ArrayLike<number>
 
     public lookAt(target: Vector3): void

package/src/engine/ecs/transform/Transform.spec.js

@@ -86,3 +86,66 @@ test("toString produces a valid string", () => {
 
     expect(typeof t.toString()).toBe("string");
 });
+
+
+test("setFlag", () => {
+    const ut = new Transform();
+
+    ut.flags = 0;
+
+    ut.setFlag(0b101);
+
+    expect(ut.flags).toBe(5);
+
+    ut.setFlag(0b010);
+
+    expect(ut.flags).toBe(7);
+
+    ut.setFlag(0b1);
+
+    expect(ut.flags).toBe(7);
+});
+
+test("clearFlag", () => {
+    const ut = new Transform();
+    ut.flags = 0b101;
+
+    ut.clearFlag(0b1);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b10);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b100);
+
+    expect(ut.flags).toBe(0);
+});
+
+test("getFlag", () => {
+
+    const ut = new Transform();
+
+    ut.flags = 0b101;
+
+    expect(ut.getFlag(0b1)).toBe(true);
+    expect(ut.getFlag(0b10)).toBe(false);
+    expect(ut.getFlag(0b100)).toBe(true);
+    expect(ut.getFlag(0b1000)).toBe(false);
+    expect(ut.getFlag(0b101)).toBe(true);
+    expect(ut.getFlag(0b011)).toBe(false);
+});
+
+test("writeFlag", () => {
+    const ut = new Transform();
+
+    ut.flags = 0;
+
+    ut.writeFlag(0b101, true);
+    expect(ut.flags).toBe(5);
+
+    ut.writeFlag(0b100, false);
+
+    expect(ut.flags).toBe(1);
+});

package/src/engine/ecs/transform-attachment/TransformAttachment.d.ts

@@ -1,3 +1,19 @@
+import {Transform} from "../transform/Transform";
+
 export class TransformAttachment {
-    
+    readonly transform: Transform
+    parent: number
+    flags: number
+
+    setFlag(flags: number): void
+
+    clearFlag(flags: number): void
+
+    getFlag(flags: number): boolean
+
+    writeFlag(flags: number, value: boolean): void
+
+    toJSON(): any
+
+    fromJSON(json: any): void
 }

package/src/engine/ecs/transform-attachment/TransformAttachment.js

@@ -1,5 +1,5 @@
 import { Transform } from "../transform/Transform.js";
-import { int32_to_binary_string } from "../../../core/binary/int32_to_binary_string.js";
+import { assert } from "../../../core/assert.js";
 
 export const TransformAttachmentFlags = {
     /**
@@ -40,10 +40,20 @@ export class TransformAttachment {
         return {
             transform: this.transform.toJSON(),
             parent: this.parent,
-            flags: int32_to_binary_string(this.flags)
+            flags: this.flags
         };
     }
 
+    fromJSON({ transform, parent = -1, flags = DEFAULT_FLAGS }) {
+        assert.defined(transform, 'transform');
+        assert.isInteger(parent, 'parent');
+        assert.isNonNegativeInteger(flags, 'flags');
+
+        this.transform.fromJSON(transform);
+        this.parent = parent;
+        this.flags = flags;
+    }
+
     get immediate() {
         return this.getFlag(TransformAttachmentFlags.Immediate);
     }

package/src/engine/ecs/transform-attachment/TransformAttachment.spec.js

@@ -0,0 +1,103 @@
+import { TransformAttachment } from "./TransformAttachment.js";
+
+test("newly created object has valid state", () => {
+
+    const ut = new TransformAttachment();
+
+    expect(ut.transform).toBeDefined();
+    expect(ut.transform).not.toBeNull();
+
+    expect(ut.parent).toBe(-1);
+    expect(typeof ut.flags).toBe("number");
+    expect(Number.isInteger(ut.flags)).toBe(true);
+    expect(ut.flags).toBeGreaterThanOrEqual(0);
+
+});
+
+test("to/from JSON", () => {
+
+    const expected = new TransformAttachment();
+    expected.flags = 123457;
+
+    expected.parent = 13;
+
+    // just position is enough. don't need to check the entire transform as that's not the point
+    expected.transform.position.set(1, 3, -5);
+
+    const actual = new TransformAttachment();
+
+    actual.fromJSON(expected.toJSON());
+
+    expect(actual.parent).toBe(13);
+    expect(actual.flags).toBe(123457);
+    expect(actual.transform.position.x).toBe(1);
+    expect(actual.transform.position.y).toBe(3);
+    expect(actual.transform.position.z).toBe(-5);
+});
+
+test("toString produces a non-empty string", () => {
+    const ut = new TransformAttachment();
+
+    const string = ut.toString();
+
+    expect(typeof string).toBe('string');
+    expect(string.trim().length).toBeGreaterThan(0);
+});
+
+test("setFlag", () => {
+    const ut = new TransformAttachment();
+
+    ut.setFlag(0b101);
+
+    expect(ut.flags).toBe(5);
+
+    ut.setFlag(0b010);
+
+    expect(ut.flags).toBe(7);
+
+    ut.setFlag(0b1);
+
+    expect(ut.flags).toBe(7);
+});
+
+test("clearFlag", () => {
+    const ut = new TransformAttachment();
+    ut.flags = 0b101;
+
+    ut.clearFlag(0b1);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b10);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b100);
+
+    expect(ut.flags).toBe(0);
+});
+
+test("getFlag", () => {
+
+    const ut = new TransformAttachment();
+
+    ut.flags = 0b101;
+
+    expect(ut.getFlag(0b1)).toBe(true);
+    expect(ut.getFlag(0b10)).toBe(false);
+    expect(ut.getFlag(0b100)).toBe(true);
+    expect(ut.getFlag(0b1000)).toBe(false);
+    expect(ut.getFlag(0b101)).toBe(true);
+    expect(ut.getFlag(0b011)).toBe(false);
+});
+
+test("writeFlag", () => {
+    const ut = new TransformAttachment();
+
+    ut.writeFlag(0b101, true);
+    expect(ut.flags).toBe(5);
+
+    ut.writeFlag(0b100, false);
+
+    expect(ut.flags).toBe(1);
+});