@woosh/meep-engine 2.54.0 → 2.55.0

package/src/engine/ecs/team/TeamSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSe
 import Team from "./Team.js";
 
 export class TeamSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = Team;
-        this.version = 0;
-    }
+    klass = Team;
+    version = 0;
 
     /**
      *

package/src/engine/ecs/terrain/ecs/Terrain.spec.js

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

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrain.js

@@ -5,28 +5,30 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
 
 class ClingToTerrain {
-    constructor({ normalAlign = false } = {}) {
-        /**
-         * @type {boolean}
-         */
-        this.normalAlign = normalAlign;
-
-        /**
-         * Used internally for caching updates
-         * @type {Vector3}
-         */
-        this.__lastPosition = new Vector3(0, 0, 0);
-        /**
-         *
-         * @type {Quaternion}
-         */
-        this.__lastRotation = new Quaternion(0, 0, 0, 1);
+    /**
+     * @type {boolean}
+     */
+    normalAlign = false;
+    /**
+     * Used internally for caching updates
+     * @type {Vector3}
+     */
+    __lastPosition=new Vector3(0, 0, 0);
+    /**
+     *
+     * @type {Quaternion}
+     */
+    __lastRotation=new Quaternion(0, 0, 0, 1);
+    /**
+     * Speed in Rad/s (Radians/second) by which rotation can change
+     * @type {number}
+     */
+    rotationSpeed = 3;
 
-        /**
-         * Speed in Rad/s (Radians/second) by which rotation can change
-         * @type {number}
-         */
-        this.rotationSpeed = 3;
+    constructor(opt) {
+        if(opt !== undefined){
+            throw new Error("constructor options deprecated");
+        }
     }
 
     toJSON() {

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../../../storage/binary/BinaryC
 import ClingToTerrain from "./ClingToTerrain.js";
 
 export class ClingToTerrainSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = ClingToTerrain;
-        this.version = 0;
-    }
+    klass = ClingToTerrain;
+    version = 0;
 
     /**
      *

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -19,18 +19,15 @@ import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
 import { sampler2d_scale } from "../../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 import List from "../../../../../core/collection/list/List.js";
 import { Cache } from "../../../../../core/cache/Cache.js";
-import { BinaryClassSerializationAdapter } from "../../../storage/binary/BinaryClassSerializationAdapter.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 
 class ScaledTextureKey {
-    constructor() {
-        this.uri = '';
+    uri = '';
 
-        this.size = new Vector2();
-    }
+    size = new Vector2();
 
     /**
      *
@@ -58,41 +55,6 @@ class ScaledTextureKey {
     }
 }
 
-class ScaledTextureKeySerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-        this.klass = ScaledTextureKey;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {ScaledTextureKey} value
-     */
-    serialize(buffer, value) {
-        // serialize uri
-        buffer.writeUTF8String(value.uri);
-        // serialize size
-        buffer.writeFloat64(value.size.x);
-        buffer.writeFloat64(value.size.y);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {ScaledTextureKey} value
-     */
-    deserialize(buffer, value) {
-        value.uri = buffer.readUTF8String();
-
-        const size_x = buffer.readFloat64();
-        const size_y = buffer.readFloat64();
-
-        value.size.set(size_x, size_y);
-    }
-}
-
 /**
  *
  * @type {Cache<ScaledTextureKey,Sampler2D>}

package/src/engine/ecs/terrain/serialization/TerrainSerializationAdapter.js

@@ -7,18 +7,15 @@ import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue
 import { TerrainFlags } from "../ecs/TerrainFlags.js";
 
 export class TerrainSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = Terrain;
-        this.version = 2;
+    klass = Terrain;
+    version = 2;
 
-        /**
-         *
-         * @type {TerrainSystem}
-         */
-        this.system = null;
-    }
+    /**
+     *
+     * @type {TerrainSystem}
+     */
+    system = null;
 
     initialize(system) {
         this.system = system;

package/src/engine/ecs/tooltip/TooltipComponent.spec.js

@@ -0,0 +1,47 @@
+import { TooltipComponent } from "./TooltipComponent.js";
+
+test("constructor does not throw", () => {
+    new TooltipComponent()
+});
+
+test("to/from JSON", () => {
+
+    const source = new TooltipComponent();
+
+    source.key = "x";
+
+    const destination = new TooltipComponent();
+
+    destination.fromJSON(source.toJSON());
+
+    expect(destination.equals(source)).toBe(true);
+});
+
+test("equals", () => {
+
+    const a = new TooltipComponent();
+
+    a.key = "x";
+
+    const b = new TooltipComponent();
+
+    b.key = "a";
+
+    expect(a.equals(b)).toBe(false);
+
+    b.key = "x";
+
+    expect(a.equals(b)).toBe(true);
+});
+
+test("hash", () => {
+    const tip = new TooltipComponent();
+
+    tip.key = "x";
+
+    const hash = tip.hash();
+
+    expect(tip.hash()).toEqual(hash);
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});

package/src/engine/ecs/tooltip/TooltipComponentSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSe
 import { TooltipComponent } from "./TooltipComponent.js";
 
 export class TooltipComponentSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = TooltipComponent;
-        this.version = 0;
-    }
+    klass = TooltipComponent;
+    version = 0;
 
     /**
      *

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

@@ -173,3 +173,55 @@ test("hash", () => {
     expect(t.hash()).toEqual(hash);
 
 });
+
+test("multiplyTransforms with identities", () => {
+
+    const result = new Transform();
+
+    const a = new Transform();
+    a.makeIdentity();
+
+    const b = new Transform();
+    b.makeIdentity();
+
+    result.multiplyTransforms(a, b);
+
+    expect(result.position.equals(Vector3.zero)).toBe(true);
+    expect(result.scale.equals(Vector3.one)).toBe(true);
+    expect(result.rotation.equals(Quaternion.identity)).toBe(true);
+});
+
+test("copy", () => {
+    const source = new Transform();
+
+    source.position.set(1, 3, 7);
+    source.scale.set(11, 13, 17);
+    source.rotation.set(23, 27, 31, 37);
+
+    const destination = new Transform();
+
+    destination.copy(source);
+
+    expect(destination.equals(source)).toBe(true);
+});
+
+test("lookAt", () => {
+    const t = new Transform();
+    const original = t.clone();
+
+    const target = new Vector3(7, 13, -17);
+
+    t.lookAt(target);
+
+    expect(t.position.equals(original.position)).toBe(true);
+    expect(t.scale.equals(original.scale)).toBe(true);
+
+    const direction = new Vector3(0, 0, 1);
+
+    direction.applyQuaternion(t.rotation);
+
+    const expected_direction = target.clone();
+    expected_direction.normalize();
+
+    expect(direction.roughlyEquals(expected_direction)).toBe(true);
+});

package/src/engine/ecs/transform/TransformSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSe
 import { Transform } from "./Transform.js";
 
 export class TransformSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = Transform;
-        this.version = 1;
-    }
+    klass = Transform;
+    version = 1;
 
     /**
      *

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

@@ -12,25 +12,24 @@ export const TransformAttachmentFlags = {
 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;
-    }
+
+    /**
+     * transform relative to the attachment target
+     * @type {Transform}
+     */
+    transform = new Transform();
+
+    /**
+     * Which entity to attach to
+     * @type {number}
+     */
+    parent = -1;
+
+    /**
+     *
+     * @type {number}
+     */
+    flags = DEFAULT_FLAGS;
 
     toString() {
         return JSON.stringify(this.toJSON());

package/src/engine/graphics/ecs/animation/AnimationController.js

@@ -4,149 +4,40 @@
 
 
 import List from '../../../../core/collection/list/List.js';
-import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AnimationRule } from "./AnimationRule.js";
 
-function AnimationRule(startEvent, animationName, speed, transitionTime, loop = false) {
-    this.startEvent = startEvent;
-    this.stopEvent = null;
-    this.animation = animationName;
-    this.speed = speed;
-    this.transition = transitionTime;
-    this.weight = 1;
-    this.loop = loop;
-}
-
-AnimationRule.prototype.toJSON = function () {
-    return {
-        startEvent: this.startEvent,
-        stopEvent: this.stopEvent,
-        animation: this.animation,
-        speed: this.speed,
-        transition: this.transition,
-        loop: this.loop,
-        weight: this.weight
-    };
-};
-
-AnimationRule.prototype.fromJSON = function (json) {
-
-    this.startEvent = json.startEvent;
-    this.stopEvent = json.stopEvent;
-
-    this.animation = json.animation;
-
-    if (typeof json.speed === "number") {
-        this.speed = json.speed;
-    } else {
-        this.speed = 1;
-    }
+class AnimationController {
 
-    this.transition = json.transition;
+    /**
+     *
+     * @type {List<AnimationRule>}
+     */
+    rules = new List();
 
-    if (typeof json.loop === "boolean") {
-        this.loop = json.loop;
-    } else {
-        this.loop = false;
+    fromJSON(json) {
+        this.rules.fromJSON(json, AnimationRule);
     }
 
-    if (typeof json.weight === "number") {
-        this.weight = json.weight;
-    } else {
-        this.weight = 1;
+    toJSON() {
+        return this.rules.toJSON();
     }
-};
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-AnimationRule.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeUTF8String(this.animation);
-    buffer.writeUTF8String(this.startEvent);
-    buffer.writeUTF8String(this.stopEvent);
-
-    buffer.writeUint8(this.loop ? 1 : 0);
-    buffer.writeFloat64(this.weight);
-    buffer.writeFloat64(this.transition);
-    buffer.writeFloat64(this.speed);
-
-};
-
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-AnimationRule.prototype.fromBinaryBuffer = function (buffer) {
-    this.animation = buffer.readUTF8String();
-    this.startEvent = buffer.readUTF8String();
-    this.stopEvent = buffer.readUTF8String();
-
-    this.loop = buffer.readUint8() !== 0;
-    this.weight = buffer.readFloat64();
-    this.transition = buffer.readFloat64();
-    this.speed = buffer.readFloat64();
-};
-
-/**
- *
- * @constructor
- */
-function AnimationController() {
     /**
      *
-     * @type {List<AnimationRule>}
+     * @param json
+     * @returns {AnimationController}
      */
-    this.rules = new List();
-}
-
-AnimationController.typeName = "AnimationController";
-
-/**
- *
- * @param json
- * @returns {AnimationController}
- */
-AnimationController.fromJSON = function (json) {
-    const r = new AnimationController();
+    static fromJSON(json) {
+        const r = new AnimationController();
 
-    r.fromJSON(json);
+        r.fromJSON(json);
 
-    return r;
-};
+        return r;
+    }
+}
 
-AnimationController.prototype.fromJSON = function (json) {
-    this.rules.fromJSON(json, AnimationRule);
-};
-AnimationController.prototype.toJSON = function () {
-    return this.rules.toJSON();
-};
+AnimationController.typeName = "AnimationController";
 
 export default AnimationController;
 
 
-export class AnimationControllerSerializationAdapter extends BinaryClassSerializationAdapter{
-    constructor(){
-        super();
-
-        this.klass = AnimationController;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {AnimationController} value
-     */
-    serialize(buffer, value) {
-        value.rules.toBinaryBuffer(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {AnimationController} value
-     */
-    deserialize(buffer, value) {
-        value.rules.fromBinaryBuffer(buffer, AnimationRule);
-    }
-}

package/src/engine/graphics/ecs/animation/AnimationControllerSerializationAdapter.js

@@ -0,0 +1,27 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AnimationRule } from "./AnimationRule.js";
+import AnimationController from "./AnimationController.js";
+
+export class AnimationControllerSerializationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = AnimationController;
+    version = 0;
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {AnimationController} value
+     */
+    serialize(buffer, value) {
+        value.rules.toBinaryBuffer(buffer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {AnimationController} value
+     */
+    deserialize(buffer, value) {
+        value.rules.fromBinaryBuffer(buffer, AnimationRule);
+    }
+}

package/src/engine/graphics/ecs/animation/AnimationRule.js

@@ -0,0 +1,79 @@
+export function AnimationRule(startEvent, animationName, speed, transitionTime, loop = false) {
+    this.startEvent = startEvent;
+    this.stopEvent = null;
+    this.animation = animationName;
+    this.speed = speed;
+    this.transition = transitionTime;
+    this.weight = 1;
+    this.loop = loop;
+}
+AnimationRule.prototype.toJSON = function () {
+    return {
+        startEvent: this.startEvent,
+        stopEvent: this.stopEvent,
+        animation: this.animation,
+        speed: this.speed,
+        transition: this.transition,
+        loop: this.loop,
+        weight: this.weight
+    };
+};
+
+AnimationRule.prototype.fromJSON = function (json) {
+
+    this.startEvent = json.startEvent;
+    this.stopEvent = json.stopEvent;
+
+    this.animation = json.animation;
+
+    if (typeof json.speed === "number") {
+        this.speed = json.speed;
+    } else {
+        this.speed = 1;
+    }
+
+    this.transition = json.transition;
+
+    if (typeof json.loop === "boolean") {
+        this.loop = json.loop;
+    } else {
+        this.loop = false;
+    }
+
+    if (typeof json.weight === "number") {
+        this.weight = json.weight;
+    } else {
+        this.weight = 1;
+    }
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+AnimationRule.prototype.toBinaryBuffer = function (buffer) {
+    buffer.writeUTF8String(this.animation);
+    buffer.writeUTF8String(this.startEvent);
+    buffer.writeUTF8String(this.stopEvent);
+
+    buffer.writeUint8(this.loop ? 1 : 0);
+    buffer.writeFloat64(this.weight);
+    buffer.writeFloat64(this.transition);
+    buffer.writeFloat64(this.speed);
+
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+AnimationRule.prototype.fromBinaryBuffer = function (buffer) {
+    this.animation = buffer.readUTF8String();
+    this.startEvent = buffer.readUTF8String();
+    this.stopEvent = buffer.readUTF8String();
+
+    this.loop = buffer.readUint8() !== 0;
+    this.weight = buffer.readFloat64();
+    this.transition = buffer.readFloat64();
+    this.speed = buffer.readFloat64();
+};

package/src/engine/graphics/ecs/animation/animator/graph/AnimationGraphSerializationAdapter.js

@@ -6,19 +6,17 @@ import {
 import { AnimationGraphDefinition } from "./definition/AnimationGraphDefinition.js";
 
 export class AnimationGraphSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = AnimationGraph;
-        this.version = 0;
+    klass = AnimationGraph;
+    version = 0;
+
+    /**
+     *
+     * @type {AnimationGraphDefinitionSerializationAdapter}
+     * @private
+     */
+    __definitionAdapter = new AnimationGraphDefinitionSerializationAdapter();
 
-        /**
-         *
-         * @type {AnimationGraphDefinitionSerializationAdapter}
-         * @private
-         */
-        this.__definitionAdapter = new AnimationGraphDefinitionSerializationAdapter();
-    }
 
     /**
      *

package/src/engine/graphics/ecs/animation/animator/graph/definition/serialization/AnimationGraphDefinitionSerializationAdapter.js

@@ -10,12 +10,10 @@ import { AnimationStateDefinition } from "../AnimationStateDefinition.js";
 import { AnimationTransitionDefinition } from "../AnimationTransitionDefinition.js";
 
 export class AnimationGraphDefinitionSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = AnimationGraphDefinition;
-        this.version = 0;
-    }
+    klass = AnimationGraphDefinition;
+    version = 0;
+
 
     /**
      *