@vived/app 3.5.0 → 3.5.2

package/lib/AppObjectComponents/SceneRoot/UC/SerializeSceneRoot.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSerializeSceneRoot = exports.SerializeSceneRoot = void 0;
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const ValueObjects_1 = require("../../../ValueObjects");
+const StoredView_1 = require("../../StoredView");
 const SceneRoot_1 = require("../Entities/SceneRoot");
 class SerializeSceneRoot extends AppObjectUC_1.AppObjectUC {
     constructor() {
@@ -27,6 +28,11 @@ class SerializeSceneRootImp extends SerializeSceneRoot {
             this.dispose();
             return;
         }
+        this.storedView = appObject.getComponent(StoredView_1.StoredView.type);
+        if (!this.storedView) {
+            console.warn("SerializeSceneRoot UC has been added to an App Object that does not have a StoredView Entity. Stored view won't work until one is added to the UC");
+            return;
+        }
         stateMachine.registerSerializedSystem(this);
     }
     getSystemState() {
@@ -34,12 +40,22 @@ class SerializeSceneRootImp extends SerializeSceneRoot {
             console.warn("[SerializeSceneRoot] No scene root entity");
             return {};
         }
-        const data = {
-            position: this.sceneRoot.position.dto,
-            rotation: this.sceneRoot.rotation.dto,
-            scale: this.sceneRoot.scale,
-        };
-        return data;
+        if (this.storedView && this.storedView.hasStoredView) {
+            const data = {
+                position: this.storedView.position.dto,
+                rotation: this.storedView.rotation.dto,
+                scale: this.storedView.scale,
+            };
+            return data;
+        }
+        else {
+            const data = {
+                position: this.sceneRoot.position.dto,
+                rotation: this.sceneRoot.rotation.dto,
+                scale: this.sceneRoot.scale,
+            };
+            return data;
+        }
     }
     applySystemState(serializedState, version, transitionTime) {
         try {

package/lib/AppObjectComponents/StoredView/Entities/StoredView.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export declare abstract class StoredView extends AppObjectEntity {
+    static readonly type = "STORED_VIEW";
+    abstract position: Vector3;
+    abstract rotation: Quaternion;
+    abstract scale: number;
+    abstract hasStoredView: boolean;
+    static get(appObjects: AppObjectRepo): StoredView | undefined;
+}
+export declare function makeStoredView(appObj: AppObject): StoredView;

package/lib/AppObjectComponents/StoredView/Entities/StoredView.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStoredView = exports.StoredView = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+class StoredView extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const repo = appObjects.getAllComponents(StoredView.type);
+        if (repo.length === 0) {
+            console.warn("[StoredView] Unable to find Scene Root Entity. Add one on Mount");
+            return undefined;
+        }
+        else if (repo.length > 1) {
+            console.warn("[StoredView] Multiple Scene Root Entity have been found. There should only be one. Using the first one");
+        }
+        return repo[0];
+    }
+}
+exports.StoredView = StoredView;
+StoredView.type = "STORED_VIEW";
+function makeStoredView(appObj) {
+    return new StoredViewImp(appObj);
+}
+exports.makeStoredView = makeStoredView;
+class StoredViewImp extends StoredView {
+    constructor(appObject) {
+        super(appObject, StoredView.type);
+        this._position = ValueObjects_1.Vector3.Zero();
+        this._rotation = ValueObjects_1.Quaternion.Identity();
+        this._memoizedScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
+        this._memoizedHasStoredView = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    get position() {
+        return this._position;
+    }
+    set position(p) {
+        if (ValueObjects_1.Vector3.Equal(this._position, p))
+            return;
+        this._position = p;
+        this.notifyOnChange();
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    set rotation(r) {
+        if (ValueObjects_1.Quaternion.Equal(this._rotation, r))
+            return;
+        this._rotation = r;
+        this.notifyOnChange();
+    }
+    get scale() {
+        return this._memoizedScale.val;
+    }
+    set scale(s) {
+        this._memoizedScale.val = s;
+    }
+    get hasStoredView() {
+        return this._memoizedHasStoredView.val;
+    }
+    set hasStoredView(hasStoredValue) {
+        this._memoizedHasStoredView.val = hasStoredValue;
+    }
+}

package/lib/AppObjectComponents/StoredView/UC/SerializeStoredView.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem, StateMachine } from "../../../Entities";
+export declare abstract class SerializeStoredView extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeStoredView";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeStoredView(appObject: AppObject, stateMachine: StateMachine): SerializeStoredView;
+export interface StoredViewDataV1 {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: number;
+    hasStoredView: boolean;
+}

package/lib/AppObjectComponents/StoredView/UC/SerializeStoredView.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializeStoredView = exports.SerializeStoredView = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const StoredView_1 = require("../Entities/StoredView");
+class SerializeStoredView extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "storedView";
+    }
+}
+exports.SerializeStoredView = SerializeStoredView;
+SerializeStoredView.type = "SerializeStoredView";
+function makeSerializeStoredView(appObject, stateMachine) {
+    return new SerializeStoredViewImp(appObject, stateMachine);
+}
+exports.makeSerializeStoredView = makeSerializeStoredView;
+class SerializeStoredViewImp extends SerializeStoredView {
+    constructor(appObject, stateMachine) {
+        super(appObject, SerializeStoredView.type);
+        this.seriliziationVersion = 1;
+        this.storedView = appObject.getComponent(StoredView_1.StoredView.type);
+        if (!this.storedView) {
+            console.warn("SerializeStoredView UC has been added to an App Object that does not have a StoredView Entity. Add one before adding the UC");
+            this.dispose();
+            return;
+        }
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return {};
+        }
+        const data = {
+            position: this.storedView.position.dto,
+            rotation: this.storedView.rotation.dto,
+            scale: this.storedView.scale,
+            hasStoredView: this.storedView.hasStoredView,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState);
+            }
+            else {
+                console.warn(`[SerializeStoredView] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState();
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeStoredView] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        this.storedView.position = ValueObjects_1.Vector3.Zero();
+        this.storedView.rotation = ValueObjects_1.Quaternion.Identity();
+        this.storedView.scale = 1;
+        this.storedView.hasStoredView = false;
+    }
+    applyV1Data(data) {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        const pos = ValueObjects_1.Vector3.FromDTO(data.position);
+        const rot = ValueObjects_1.Quaternion.FromDTO(data.rotation);
+        this.storedView.position = pos;
+        this.storedView.rotation = rot;
+        this.storedView.scale = data.scale;
+        this.storedView.hasStoredView = data.hasStoredView;
+    }
+}

package/lib/AppObjectComponents/StoredView/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities/StoredView";
+export * from "./UC/SerializeStoredView";

package/lib/AppObjectComponents/StoredView/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entities/StoredView"), exports);
+__exportStar(require("./UC/SerializeStoredView"), exports);

package/lib/Entities/FocusCamera.d.ts

@@ -0,0 +1,70 @@
+import { Vector3 } from "../ValueObjects";
+export declare type OnFocusCameraChange = () => void;
+export interface FocusCameraLerper {
+    cancelLerp: () => void;
+}
+export interface FocusCameraData {
+    defaultAlpha?: number;
+    defaultBeta?: number;
+    defaultRadius?: number;
+    defaultTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    nearClip?: number;
+    farClip?: number;
+    alphaLimit?: {
+        min: number;
+        max: number;
+    };
+    betaLimit?: {
+        min: number;
+        max: number;
+    };
+    radiusLimit?: {
+        min: number;
+        max: number;
+    };
+    targetLimit?: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface FocusCamera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vector3;
+    direction: Vector3;
+    cameraPosition: Vector3;
+    nearClip: number;
+    farClip: number;
+    defaultAlpha: number;
+    defaultBeta: number;
+    defaultRadius: number;
+    defaultTarget: Vector3;
+    setAlphaLimits: (min: number, max: number) => void;
+    clearAlphaLimits: () => void;
+    setBetaLimits: (min: number, max: number) => void;
+    clearBetaLimits: () => void;
+    setRadiusLimits: (min: number, max: number) => void;
+    clearRadiusLimits: () => void;
+    setTargetLimits: (min: Vector3, max: Vector3) => void;
+    clearTargetLimits: () => void;
+    registerLerp: (lerper: FocusCameraLerper) => void;
+    lerpCompleted: () => void;
+    cancelLerp: () => void;
+    applyData: (data: FocusCameraData) => void;
+    addObserver: (observer: OnFocusCameraChange) => void;
+    removeObserver: (observer: OnFocusCameraChange) => void;
+}
+export declare function makeFocusCamera(): FocusCamera;

package/lib/Entities/FocusCamera.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../ValueObjects");
+function makeFocusCamera() {
+    return new FocusCameraImp();
+}
+exports.makeFocusCamera = makeFocusCamera;
+class FocusCameraImp {
+    constructor() {
+        this.farClip = 100;
+        this.nearClip = 0.01;
+        this.defaultAlpha = 0;
+        this.defaultBeta = 30;
+        this.defaultRadius = 8;
+        this.defaultTarget = ValueObjects_1.Vector3.Zero();
+        this.limitRadius = false;
+        this.minRadius = 0;
+        this.maxRadius = 0;
+        this.limitAlpha = false;
+        this.minAlpha = 0;
+        this.maxAlpha = 0;
+        this.limitBeta = false;
+        this.minBeta = 0;
+        this.maxBeta = 0;
+        this.limitTarget = false;
+        this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.minTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.observers = new _1.ObserverList();
+        this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
+        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
+        this.setRadiusLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < 0) {
+                console.warn("[Orbit Camera Entity] Mininum Radius must be greater >= 0, forcing to 0");
+                minToUse = 0;
+            }
+            if (max < minToUse) {
+                console.warn(`[Orbit Camera] Max radius must be >= min radius. Forcing to ${minToUse}`);
+                maxToUse = minToUse;
+            }
+            this.maxRadius = maxToUse;
+            this.minRadius = minToUse;
+            this.limitRadius = true;
+            this.radius = this.radius;
+        };
+        this.clearRadiusLimits = () => {
+            this.maxRadius = 0;
+            this.minRadius = 0;
+            this.limitRadius = false;
+        };
+        this.setAlphaLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < -180) {
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min alpha must be >= -180. Forcing to -180");
+            }
+            if (max > 180) {
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max alpha must be <= 180. Forcing to 180");
+            }
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max alpha must be <= Min Alpha. Forcing to ${closestToZero}`);
+            }
+            this.maxAlpha = maxToUse;
+            this.minAlpha = minToUse;
+            this.limitAlpha = true;
+            this.alpha = this.alpha;
+        };
+        this.clearAlphaLimits = () => {
+            this.maxAlpha = 0;
+            this.minAlpha = 0;
+            this.limitAlpha = false;
+        };
+        this.setBetaLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < -180) {
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min beta must be >= -180. Forcing to -180");
+            }
+            if (max > 180) {
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max beta must be <= 180. Forcing to 180");
+            }
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max beta must be <= Min beta. Forcing to ${closestToZero}`);
+            }
+            this.maxBeta = maxToUse;
+            this.minBeta = minToUse;
+            this.limitBeta = true;
+            this.beta = this.beta;
+        };
+        this.clearBetaLimits = () => {
+            this.maxBeta = 0;
+            this.minBeta = 0;
+            this.limitBeta = false;
+        };
+        this.setTargetLimits = (min, max) => {
+            const minArray = min.array;
+            const maxArray = max.array;
+            for (let i = 0; i < 3; i++) {
+                if (minArray[i] > maxArray[i]) {
+                    console.warn("[Orbit Camera] Target limit min's components must all be <= the max. Limits not set");
+                    return;
+                }
+            }
+            this.maxTargetPosition = max;
+            this.minTargetPosition = min;
+            this.limitTarget = true;
+            this.target = this.target;
+        };
+        this.clearTargetLimits = () => {
+            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.minTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.limitTarget = false;
+        };
+        this.registerLerp = (lerper) => {
+            if (this.currentLerp) {
+                this.currentLerp.cancelLerp();
+            }
+            this.currentLerp = lerper;
+        };
+        this.lerpCompleted = () => {
+            this.currentLerp = undefined;
+        };
+        this.cancelLerp = () => {
+            var _a;
+            (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
+            this.currentLerp = undefined;
+        };
+        this.applyData = (data) => {
+            if (data.defaultAlpha !== undefined) {
+                this.defaultAlpha = data.defaultAlpha;
+            }
+            if (data.defaultBeta !== undefined) {
+                this.defaultBeta = data.defaultBeta;
+            }
+            if (data.defaultRadius !== undefined) {
+                this.defaultRadius = data.defaultRadius;
+            }
+            if (data.defaultTarget !== undefined) {
+                const { x, y, z } = data.defaultTarget;
+                this.defaultTarget = new ValueObjects_1.Vector3(x, y, z);
+            }
+            if (data.nearClip !== undefined) {
+                this.nearClip = data.nearClip;
+            }
+            if (data.farClip !== undefined) {
+                this.farClip = data.farClip;
+            }
+            if (data.alphaLimit !== undefined) {
+                this.setAlphaLimits(data.alphaLimit.min, data.alphaLimit.max);
+            }
+            if (data.betaLimit !== undefined) {
+                this.setBetaLimits(data.betaLimit.min, data.betaLimit.max);
+            }
+            if (data.radiusLimit !== undefined) {
+                this.setRadiusLimits(data.radiusLimit.min, data.radiusLimit.max);
+            }
+            if (data.targetLimit !== undefined) {
+                const { max, min } = data.targetLimit;
+                this.setTargetLimits(new ValueObjects_1.Vector3(min.x, min.y, min.z), new ValueObjects_1.Vector3(max.x, max.y, max.z));
+            }
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get alpha() {
+        return this.memoizedAlpha.val;
+    }
+    set alpha(val) {
+        let valToUse = val;
+        if (this.limitAlpha) {
+            valToUse = Math.min(valToUse, this.maxAlpha);
+            valToUse = Math.max(valToUse, this.minAlpha);
+        }
+        else {
+            valToUse = this.clampAngle(val);
+        }
+        this.memoizedAlpha.val = valToUse;
+    }
+    get beta() {
+        return this.memoizedBeta.val;
+    }
+    set beta(val) {
+        let valToUse = val;
+        if (this.limitBeta) {
+            valToUse = Math.min(valToUse, this.maxBeta);
+            valToUse = Math.max(valToUse, this.minBeta);
+        }
+        else {
+            valToUse = this.clampAngle(val);
+        }
+        this.memoizedBeta.val = valToUse;
+    }
+    get radius() {
+        return this.memoizedRadius.val;
+    }
+    set radius(val) {
+        let clampedVal = Math.max(val, 0);
+        if (this.limitRadius) {
+            clampedVal = Math.min(clampedVal, this.maxRadius);
+            clampedVal = Math.max(clampedVal, this.minRadius);
+        }
+        this.memoizedRadius.val = clampedVal;
+    }
+    get target() {
+        return this.memoizedTarget.val;
+    }
+    set target(val) {
+        const targetVals = val.array;
+        if (this.limitTarget) {
+            const maxVals = this.maxTargetPosition.array;
+            const minVals = this.minTargetPosition.array;
+            for (let i = 0; i < 3; i++) {
+                let v = targetVals[i];
+                v = Math.min(v, maxVals[i]);
+                v = Math.max(v, minVals[i]);
+                targetVals[i] = v;
+            }
+        }
+        this.memoizedTarget.val = ValueObjects_1.Vector3.FromArray(targetVals);
+    }
+    get direction() {
+        const yLength = -Math.sin(this.degToRad(this.beta));
+        const horizontalLenght = Math.cos(this.degToRad(this.beta));
+        const alphaRadians = this.degToRad(this.alpha);
+        const xLength = horizontalLenght * Math.sin(alphaRadians);
+        const zLength = horizontalLenght * Math.cos(alphaRadians);
+        return new ValueObjects_1.Vector3(xLength, yLength, zLength);
+    }
+    get cameraPosition() {
+        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
+        return ValueObjects_1.Vector3.Add(this.target, localOffset);
+    }
+    degToRad(degrees) {
+        return (degrees * Math.PI) / 180;
+    }
+    clampAngle(angle) {
+        const isNegative = angle < 0 ? true : false;
+        const absAngle = Math.abs(angle);
+        const revolutions = Math.floor(absAngle / 360);
+        let angleWithoutRevolutions = absAngle - revolutions * 360;
+        if (angleWithoutRevolutions > 180) {
+            angleWithoutRevolutions = angleWithoutRevolutions - 360;
+        }
+        if (isNegative) {
+            angleWithoutRevolutions *= -1;
+        }
+        return angleWithoutRevolutions;
+    }
+}

package/lib/Entities/MemoizedBoolean.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedBoolean {
+    private _val;
+    get val(): boolean;
+    set val(b: boolean);
+    setValQuietly(val: boolean): void;
+    private onChangeCallback;
+    constructor(initialValue: boolean, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedBoolean.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedBoolean = void 0;
+class MemoizedBoolean {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/MemoizedNumber.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedNumber {
+    private _val;
+    get val(): number;
+    set val(b: number);
+    setValQuietly(val: number): void;
+    private onChangeCallback;
+    constructor(initialValue: number, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedNumber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedNumber = void 0;
+class MemoizedNumber {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedQuaternion.d.ts

@@ -0,0 +1,9 @@
+import { Quaternion } from "../ValueObjects";
+export declare class MemoizedQuaternion {
+    private _val;
+    get val(): Quaternion;
+    set val(v: Quaternion);
+    setValQuietly(val: Quaternion): void;
+    private onChangeCallback;
+    constructor(initialValue: Quaternion, onChangeCallback: () => void);
+}