@vived/app 2.38.0 → 2.39.0

package/lib/Entities/AppDispatcher.d.ts

@@ -53,6 +53,6 @@ export declare abstract class AppDispatcher {
     abstract showAlert: (data: ShowAlertDTO) => void;
     abstract showConfirm: (data: ShowConfirmDTO) => void;
     abstract showMarkDownEditor: (data: ShowMarkDownEditorDTO) => void;
-    abstract showSelectModel(callback: (modelId: string) => void): void;
+    abstract showSelectModel(callback: (modelId: string, dataId: string) => void): void;
 }
 export declare function makeAppDispatcher(): AppDispatcher;

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/PresentationManagers/FocusCameraPM.d.ts

@@ -0,0 +1,15 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraVM {
+    alphaEuler: Vector3;
+    betaEuler: Vector3;
+    cameraLocalPosition: Vector3;
+    target: Vector3;
+}
+export declare class FocusCameraPM {
+    private orbitCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta, radius, target } = this.orbitCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const alphaEuler = new ValueObjects_1.Vector3(0, alphaRadians, 0);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const betaEuler = new ValueObjects_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new ValueObjects_1.Vector3(0, 0, -radius);
+            this.view({
+                alphaEuler,
+                betaEuler,
+                cameraLocalPosition,
+                target,
+            });
+        };
+        this.orbitCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.orbitCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.orbitCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPM = FocusCameraPM;

package/lib/PresentationManagers/FocusCameraPosRotPM.d.ts

@@ -0,0 +1,13 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraPosRotVM {
+    position: Vector3;
+    rotation: Vector3;
+}
+export declare class FocusCameraPosRotPM {
+    private focusCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraPosRotVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPosRotPM.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPosRotPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPosRotPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta } = this.focusCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const position = this.focusCam.cameraPosition;
+            const rotation = new ValueObjects_1.Vector3(betaRadians, alphaRadians, 0);
+            this.view({
+                position,
+                rotation,
+            });
+        };
+        this.focusCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.focusCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.focusCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPosRotPM = FocusCameraPosRotPM;

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.d.ts

@@ -0,0 +1,17 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class BumpDollyFocusCamera {
+    private focusCamera;
+    bumpDurationMS: number;
+    bumpLerp: (percent: number) => number;
+    bumpAmount: number;
+    private interval?;
+    private chrono;
+    private delta;
+    private initialRadius;
+    private finalRadius;
+    private pickPoint?;
+    private onTick;
+    bump(direction: "IN" | "OUT", target?: Vector3): void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BumpDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class BumpDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.bumpDurationMS = 500;
+        this.bumpLerp = (p) => {
+            return p;
+        }; // Linear
+        this.bumpAmount = 0.1;
+        this.chrono = 0;
+        this.delta = 10;
+        this.initialRadius = 0;
+        this.finalRadius = 0;
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta;
+            let nomralizedTime = this.chrono / this.bumpDurationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.bumpLerp(nomralizedTime);
+            const range = this.finalRadius - this.initialRadius;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = this.initialRadius + range * percent;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            if (nomralizedTime >= 1 && this.interval) {
+                this.focusCamera.radius = this.finalRadius;
+                clearInterval(this.interval);
+                this.interval = undefined;
+                this.pickPoint = undefined;
+            }
+        };
+    }
+    bump(direction, target) {
+        let delta = this.bumpAmount;
+        if (direction === "IN") {
+            delta *= -1;
+        }
+        this.initialRadius = this.focusCamera.radius;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+            this.finalRadius = this.finalRadius + delta;
+        }
+        else {
+            this.finalRadius = this.initialRadius + delta;
+        }
+        this.chrono = 0;
+        this.pickPoint = target;
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, 10);
+    }
+}
+exports.BumpDollyFocusCamera = BumpDollyFocusCamera;

package/lib/UseCases/FocusCamera/LerpFocusCamera.d.ts

@@ -0,0 +1,36 @@
+import { FocusCamera } from "../../Entities";
+export interface LerpFocusCameraParameters {
+    duration: number;
+    finalRadius?: number;
+    finalBeta?: number;
+    finalAlpha?: number;
+    finalTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    onComplete?: () => void;
+    onAbort?: () => void;
+}
+export declare class LerpFocusCamera {
+    get isLerping(): boolean;
+    private _isLerping;
+    private focusCamera;
+    private easeFn;
+    private lerpDuration;
+    private lerpRadius;
+    private lerpBeta;
+    private lerpAlpha;
+    private lerpX;
+    private lerpY;
+    private lerpZ;
+    private onComplete?;
+    private onAbort?;
+    private interval;
+    private chrono;
+    private delta;
+    cancelLerp: () => void;
+    private onTick;
+    constructor(focusCamera: FocusCamera, easeFn: (normalizedTime: number) => number, parameters: LerpFocusCameraParameters);
+    private makeLerpNumber;
+}

package/lib/UseCases/FocusCamera/LerpFocusCamera.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class LerpFocusCamera {
+    constructor(focusCamera, easeFn, parameters) {
+        var _a, _b, _c;
+        this._isLerping = false;
+        this.chrono = 0;
+        this.delta = 10;
+        this.cancelLerp = () => {
+            if (!this._isLerping)
+                return;
+            clearInterval(this.interval);
+            if (this.onAbort) {
+                this.onAbort();
+            }
+            this._isLerping = false;
+        };
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta / 1000;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.easeFn(nomralizedTime);
+            this.focusCamera.radius = this.lerpRadius(percent);
+            this.focusCamera.beta = this.lerpBeta(percent);
+            this.focusCamera.alpha = this.lerpAlpha(percent);
+            const x = this.lerpX(percent);
+            const y = this.lerpY(percent);
+            const z = this.lerpZ(percent);
+            this.focusCamera.target = new ValueObjects_1.Vector3(x, y, z);
+            if (nomralizedTime >= 1) {
+                clearInterval(this.interval);
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+                this._isLerping = false;
+                this.focusCamera.lerpCompleted();
+            }
+        };
+        this.focusCamera = focusCamera;
+        this.easeFn = easeFn;
+        this.lerpDuration = parameters.duration;
+        this.onComplete = parameters.onComplete;
+        this.onAbort = parameters.onAbort;
+        this.lerpRadius = this.makeLerpNumber(this.focusCamera.radius, parameters.finalRadius);
+        this.lerpBeta = this.makeLerpNumber(this.focusCamera.beta, parameters.finalBeta);
+        this.lerpAlpha = this.makeLerpNumber(this.focusCamera.alpha, parameters.finalAlpha);
+        this.lerpX = this.makeLerpNumber(this.focusCamera.target.x, (_a = parameters.finalTarget) === null || _a === void 0 ? void 0 : _a.x);
+        this.lerpY = this.makeLerpNumber(this.focusCamera.target.y, (_b = parameters.finalTarget) === null || _b === void 0 ? void 0 : _b.y);
+        this.lerpZ = this.makeLerpNumber(this.focusCamera.target.z, (_c = parameters.finalTarget) === null || _c === void 0 ? void 0 : _c.z);
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, this.delta);
+        this.focusCamera.registerLerp(this);
+        this._isLerping = true;
+    }
+    get isLerping() {
+        return this._isLerping;
+    }
+    makeLerpNumber(initial, final) {
+        const actualFinal = final !== null && final !== void 0 ? final : initial;
+        return function Lerp(percent) {
+            const range = actualFinal - initial;
+            return initial + range * percent;
+        };
+    }
+}
+exports.LerpFocusCamera = LerpFocusCamera;

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class PinchDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousDistanceBetweenTouches;
+    private pickPoint?;
+    doDolly: (distanceBetweenTouches: number) => void;
+    initializeDolly: (distanceBetweenTouches: number, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinchDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PinchDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousDistanceBetweenTouches = 0;
+        this.doDolly = (distanceBetweenTouches) => {
+            const pinchDelta = distanceBetweenTouches - this.previousDistanceBetweenTouches;
+            const deltaRadius = pinchDelta * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+        };
+        this.initializeDolly = (distanceBetweenTouches, pickPoint) => {
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PinchDollyFocusCamera = PinchDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPosition;
+    private pickPoint?;
+    doDolly: (pixelPosition: Vector2) => void;
+    initializeDolly: (pixelPosition: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousPixelPosition = ValueObjects_1.Vector2.Zero();
+        this.doDolly = (pixelPosition) => {
+            const pixelDeltaY = pixelPosition.y - this.previousPixelPosition.y;
+            const deltaRadius = pixelDeltaY * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousPixelPosition = pixelPosition;
+        };
+        this.initializeDolly = (pixelPosition, pickPoint) => {
+            this.previousPixelPosition = pixelPosition;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PixelDollyFocusCamera = PixelDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelOrbitFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPos?;
+    private pickPoint?;
+    doOrbit: (pixelPosition: Vector2) => void;
+    initializeOrbit: (initialPixelPos: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelOrbitFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelOrbitFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.5;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.previousPixelPos) {
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
+            }
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
+            this.focusCamera.alpha += pixelChange.x * this.sensitivity;
+            this.focusCamera.beta += pixelChange.y * this.sensitivity;
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos, pickPoint) => {
+            this.previousPixelPos = initialPixelPos;
+            this.pickPoint = pickPoint;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelOrbitFocusCamera = PixelOrbitFocusCamera;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { Babylon, FocusCamera } from "../../Entities";
+import { ParametricPlane, Vector2 } from "../../ValueObjects";
+export declare class PixelPlanePanFocusCamera {
+    private focusCamera;
+    private babylon;
+    private plane?;
+    private previousPixelPos?;
+    doPan: (pixelPosition: Vector2) => void;
+    initializePan: (initialPixelPos: Vector2, panPlane: ParametricPlane) => void;
+    constructor(focusCamera: FocusCamera, babylon: Babylon);
+}

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPlanePanFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelPlanePanFocusCamera {
+    constructor(focusCamera, babylon) {
+        this.focusCamera = focusCamera;
+        this.babylon = babylon;
+        this.doPan = (pixelPosition) => {
+            if (!this.plane || !this.previousPixelPos) {
+                console.error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                return;
+            }
+            const initialRay = this.babylon.sceneRay(this.previousPixelPos);
+            const finalRay = this.babylon.sceneRay(pixelPosition);
+            const p1 = this.plane.intersectLine(initialRay);
+            const p2 = this.plane.intersectLine(finalRay);
+            if (!p1 || !p2)
+                return;
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
+            const currentTarget = this.focusCamera.target;
+            const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
+            this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializePan = (initialPixelPos, panPlane) => {
+            this.plane = panPlane;
+            this.previousPixelPos = initialPixelPos;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelPlanePanFocusCamera = PixelPlanePanFocusCamera;

package/lib/UseCases/FocusCamera/SerializeFocusCamera.d.ts

@@ -0,0 +1,22 @@
+import { FocusCamera, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeFocusCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private focusCamera;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    private applyImmediate;
+    private applyLerp;
+    constructor(focusCamera: FocusCamera, stateMachine: StateMachine);
+}
+export interface FocusCameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/FocusCamera/SerializeFocusCamera.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeFocusCamera {
+    constructor(focusCamera, stateMachine) {
+        this.name = "focusCamera";
+        this.seriliziationVersion = 1;
+        this.focusCamera = focusCamera;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.focusCamera.alpha,
+            beta: this.focusCamera.beta,
+            radius: this.focusCamera.radius,
+            target_x: this.focusCamera.target.x,
+            target_y: this.focusCamera.target.y,
+            target_z: this.focusCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializeFocusCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeFocusCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        const alpha = this.focusCamera.defaultAlpha;
+        const beta = this.focusCamera.defaultBeta;
+        const radius = this.focusCamera.defaultRadius;
+        const target = this.focusCamera.defaultTarget;
+        if (transitionDuration === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const target = new ValueObjects_1.Vector3(target_x, target_y, target_z);
+        if (transitionTime === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionTime);
+        }
+    }
+    applyImmediate(alpha, beta, radius, target) {
+        this.focusCamera.cancelLerp();
+        this.focusCamera.alpha = alpha;
+        this.focusCamera.beta = beta;
+        this.focusCamera.radius = radius;
+        this.focusCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpFocusCamera(this.focusCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializeFocusCamera = SerializeFocusCamera;

package/lib/UseCases/FocusCamera/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./PixelPlanePanFocusCamera";
+export * from "./LerpFocusCamera";
+export * from "./SerializeFocusCamera";
+export * from "./PixelDollyFocusCamera";
+export * from "./BumpDollyFocusCamera";
+export * from "./PinchDollyFocusCamera";
+export * from "./PixelOrbitFocusCamera";

package/lib/UseCases/FocusCamera/index.js

@@ -0,0 +1,19 @@
+"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("./PixelPlanePanFocusCamera"), exports);
+__exportStar(require("./LerpFocusCamera"), exports);
+__exportStar(require("./SerializeFocusCamera"), exports);
+__exportStar(require("./PixelDollyFocusCamera"), exports);
+__exportStar(require("./BumpDollyFocusCamera"), exports);
+__exportStar(require("./PinchDollyFocusCamera"), exports);
+__exportStar(require("./PixelOrbitFocusCamera"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.38.0",
+  "version": "2.39.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/PresentationManagers/IsRenderingPM.d.ts

@@ -1,9 +0,0 @@
-import { BaseApp } from "../Entities";
-import { PresentionManager } from "./PresentationManager";
-export declare class IsRenderingPM extends PresentionManager {
-    private baseApp;
-    private updateView;
-    private lastSetState?;
-    doUpdateView: () => void;
-    constructor(baseApp: BaseApp, updateView: (isAuthoring: boolean) => void);
-}

package/lib/PresentationManagers/IsRenderingPM.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsRenderingPM = void 0;
-const PresentationManager_1 = require("./PresentationManager");
-class IsRenderingPM extends PresentationManager_1.PresentionManager {
-    constructor(baseApp, updateView) {
-        super(baseApp);
-        this.baseApp = baseApp;
-        this.updateView = updateView;
-        this.doUpdateView = () => {
-            const isRendering = this.baseApp.isRendering;
-            if (isRendering === this.lastSetState)
-                return;
-            this.updateView(isRendering);
-            this.lastSetState = isRendering;
-        };
-        this.doUpdateView();
-    }
-}
-exports.IsRenderingPM = IsRenderingPM;

package/lib/UseCases/Handlers/SetZSpaceEnabledBase.d.ts

@@ -1,10 +0,0 @@
-import { AppHandler, RequestHandler } from "../../Entities";
-export declare type SetZSpaceEnabledAction = (isEnabled: boolean) => void;
-export declare class SetZSpaceEnabledBase extends RequestHandler {
-    readonly requestType = "SET_ZSPACE_ENABLED";
-    readonly payloadVersion = 1;
-    action: SetZSpaceEnabledAction;
-    handleRequest: (version: number, payload: unknown) => void;
-    private castPayloadV1;
-    constructor(handler: AppHandler);
-}

package/lib/UseCases/Handlers/SetZSpaceEnabledBase.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetZSpaceEnabledBase = void 0;
-const Entities_1 = require("../../Entities");
-class SetZSpaceEnabledBase extends Entities_1.RequestHandler {
-    constructor(handler) {
-        super();
-        this.requestType = "SET_ZSPACE_ENABLED";
-        this.payloadVersion = 1;
-        this.action = () => {
-            throw new Entities_1.ActionNotImplemented(this.requestType);
-        };
-        this.handleRequest = (version, payload) => {
-            if (version === this.payloadVersion) {
-                const { isEnabled } = this.castPayloadV1(payload);
-                this.action(isEnabled);
-            }
-            else {
-                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
-            }
-        };
-        handler.registerRequestHandler(this);
-    }
-    castPayloadV1(payload) {
-        const castPayload = payload;
-        if (castPayload.isEnabled === undefined) {
-            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
-        }
-        return castPayload;
-    }
-}
-exports.SetZSpaceEnabledBase = SetZSpaceEnabledBase;