@vived/app 2.6.0 → 2.6.4

package/lib/PresentationManagers/DevicePreviewPM.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePreviewPM = void 0;
+class DevicePreviewPM {
+    constructor(devicePreview, updateView) {
+        this.doUpdateView = () => {
+            const useDevicePreview = this.devicePreview.useDevicePreview;
+            const x = this.devicePreview.previewSize.x;
+            const y = this.devicePreview.previewSize.y;
+            this.updateView({
+                x,
+                y,
+                useDevicePreview,
+            });
+        };
+        this.devicePreview = devicePreview;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.devicePreview.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.devicePreview.removeObserver(this.doUpdateView);
+    }
+}
+exports.DevicePreviewPM = DevicePreviewPM;

package/lib/PresentationManagers/HasRedoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasRedoPM {
+    updateView: (hasRedo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasRedo: boolean) => void);
+}

package/lib/PresentationManagers/HasRedoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasRedoPM = void 0;
+class HasRedoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasRedo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasRedoPM = HasRedoPM;

package/lib/PresentationManagers/HasUndoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasUndoPM {
+    updateView: (hasUndo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasUndo: boolean) => void);
+}

package/lib/PresentationManagers/HasUndoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasUndoPM = void 0;
+class HasUndoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasUndo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasUndoPM = HasUndoPM;

package/lib/PresentationManagers/IsAuthoringPM.d.ts

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

package/lib/PresentationManagers/IsAuthoringPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+class IsAuthoringPM {
+    constructor(baseApp, updateView) {
+        this.doUpdateView = () => {
+            const isAuthoring = this.baseApp.isAuthoring;
+            if (isAuthoring === this.lastSetState)
+                return;
+            this.updateView(isAuthoring);
+            this.lastSetState = isAuthoring;
+        };
+        this.baseApp = baseApp;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.baseApp.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.baseApp.removeObserver(this.doUpdateView);
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;

package/lib/PresentationManagers/OrbitCameraPM.d.ts

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

package/lib/PresentationManagers/OrbitCameraPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrbitCameraPM = void 0;
+const Entities_1 = require("../Entities");
+const Utilities_1 = require("../Utilities");
+class OrbitCameraPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta, radius, target } = this.orbitCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const alphaEuler = new Entities_1.Vector3(0, alphaRadians, 0);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const betaEuler = new Entities_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new Entities_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.OrbitCameraPM = OrbitCameraPM;

package/lib/PresentationManagers/ShowBabylonInspectorPM.d.ts

@@ -0,0 +1,9 @@
+import { Babylon } from "../Entities";
+export declare class ShowBabylonInspectorPM {
+    private babylon;
+    private updateView;
+    private lastSetState?;
+    private doUpdateView;
+    dispose(): void;
+    constructor(babylon: Babylon, updateView: (showInspector: boolean) => void);
+}

package/lib/PresentationManagers/ShowBabylonInspectorPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorPM = void 0;
+class ShowBabylonInspectorPM {
+    constructor(babylon, updateView) {
+        this.doUpdateView = () => {
+            const showInspector = this.babylon.showInspector;
+            if (showInspector === this.lastSetState)
+                return;
+            this.updateView(showInspector);
+            this.lastSetState = showInspector;
+        };
+        this.babylon = babylon;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.babylon.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.babylon.removeObserver(this.doUpdateView);
+    }
+}
+exports.ShowBabylonInspectorPM = ShowBabylonInspectorPM;

package/lib/PresentationManagers/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./DevicePreviewPM";
+export * from "./IsAuthoringPM";
+export * from "./ShowBabylonInspectorPM";
+export * from "./HasRedoPM";
+export * from "./HasUndoPM";
+export * from "./OrbitCameraPM";

package/lib/PresentationManagers/index.js

@@ -0,0 +1,18 @@
+"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("./DevicePreviewPM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./ShowBabylonInspectorPM"), exports);
+__exportStar(require("./HasRedoPM"), exports);
+__exportStar(require("./HasUndoPM"), exports);
+__exportStar(require("./OrbitCameraPM"), exports);

package/lib/UseCases/LerpOrbitCamera.d.ts

@@ -0,0 +1,36 @@
+import { OrbitCamera } from "../Entities";
+export interface LerpOrbitCameraParameters {
+    duration: number;
+    finalRadius?: number;
+    finalBeta?: number;
+    finalAlpha?: number;
+    finalTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    onComplete?: () => void;
+    onAbort?: () => void;
+}
+export declare class LerpOrbitCamera {
+    get isLerping(): boolean;
+    private _isLerping;
+    private orbitCamera;
+    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(orbitCamera: OrbitCamera, easeFn: (normalizedTime: number) => number, parameters: LerpOrbitCameraParameters);
+    private makeLerpNumber;
+}

package/lib/UseCases/LerpOrbitCamera.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpOrbitCamera = void 0;
+const Entities_1 = require("../Entities");
+class LerpOrbitCamera {
+    constructor(orbitCamera, 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.orbitCamera.radius = this.lerpRadius(percent);
+            this.orbitCamera.beta = this.lerpBeta(percent);
+            this.orbitCamera.alpha = this.lerpAlpha(percent);
+            const x = this.lerpX(percent);
+            const y = this.lerpY(percent);
+            const z = this.lerpZ(percent);
+            this.orbitCamera.target = new Entities_1.Vector3(x, y, z);
+            if (nomralizedTime >= 1) {
+                clearInterval(this.interval);
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+                this._isLerping = false;
+                this.orbitCamera.lerpCompleted();
+            }
+        };
+        this.orbitCamera = orbitCamera;
+        this.easeFn = easeFn;
+        this.lerpDuration = parameters.duration;
+        this.onComplete = parameters.onComplete;
+        this.onAbort = parameters.onAbort;
+        this.lerpRadius = this.makeLerpNumber(this.orbitCamera.radius, parameters.finalRadius);
+        this.lerpBeta = this.makeLerpNumber(this.orbitCamera.beta, parameters.finalBeta);
+        this.lerpAlpha = this.makeLerpNumber(this.orbitCamera.alpha, parameters.finalAlpha);
+        this.lerpX = this.makeLerpNumber(this.orbitCamera.target.x, (_a = parameters.finalTarget) === null || _a === void 0 ? void 0 : _a.x);
+        this.lerpY = this.makeLerpNumber(this.orbitCamera.target.y, (_b = parameters.finalTarget) === null || _b === void 0 ? void 0 : _b.y);
+        this.lerpZ = this.makeLerpNumber(this.orbitCamera.target.z, (_c = parameters.finalTarget) === null || _c === void 0 ? void 0 : _c.z);
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, this.delta);
+        this.orbitCamera.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.LerpOrbitCamera = LerpOrbitCamera;

package/lib/UseCases/SerializeCamera.d.ts

@@ -0,0 +1,21 @@
+import { OrbitCamera, SerializedSystem, StateMachine } from "../Entities";
+export declare class SerializedCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private orbitCamera;
+    private stateMachine;
+    private defaultState?;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    constructor(orbitCamera: OrbitCamera, stateMachine: StateMachine, defaultState?: CameraDataV1);
+}
+export interface CameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/SerializeCamera.js

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

package/lib/UseCases/SerializeOrbitCamera.d.ts

@@ -0,0 +1,21 @@
+import { OrbitCamera, SerializedSystem, StateMachine } from "../Entities";
+export declare class SerializedOrbitCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private orbitCamera;
+    private stateMachine;
+    private defaultState?;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    constructor(orbitCamera: OrbitCamera, stateMachine: StateMachine, defaultState?: CameraDataV1);
+}
+export interface CameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/SerializeOrbitCamera.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedOrbitCamera = void 0;
+const _1 = require(".");
+const Entities_1 = require("../Entities");
+class SerializedOrbitCamera {
+    constructor(orbitCamera, stateMachine, defaultState) {
+        this.name = "orbitCamera";
+        this.seriliziationVersion = 1;
+        this.orbitCamera = orbitCamera;
+        this.stateMachine = stateMachine;
+        this.defaultState = defaultState;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.orbitCamera.alpha,
+            beta: this.orbitCamera.beta,
+            radius: this.orbitCamera.radius,
+            target_x: this.orbitCamera.target.x,
+            target_y: this.orbitCamera.target.y,
+            target_z: this.orbitCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializedCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializedCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        if (this.defaultState) {
+            this.applyV1Data(this.defaultState, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: new Entities_1.Vector3(target_x, target_y, target_z),
+        };
+        new _1.LerpOrbitCamera(this.orbitCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializedOrbitCamera = SerializedOrbitCamera;

package/lib/UseCases/SerializedCamDemo.js

@@ -0,0 +1 @@
+"use strict";

package/lib/UseCases/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./setDevicePreview";
+export * from "./LerpOrbitCamera";
+export * from "./SerializeOrbitCamera";

package/lib/UseCases/index.js

@@ -0,0 +1,15 @@
+"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("./setDevicePreview"), exports);
+__exportStar(require("./LerpOrbitCamera"), exports);
+__exportStar(require("./SerializeOrbitCamera"), exports);

package/lib/UseCases/setDevicePreview.d.ts

@@ -0,0 +1,2 @@
+import { DevicePreview } from "../Entities";
+export declare function makeSetDevicePreview(devicePreview: DevicePreview): (x: number, y: number) => void;

package/lib/UseCases/setDevicePreview.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetDevicePreview = void 0;
+function makeSetDevicePreview(devicePreview) {
+    return function setDevicePreview(x, y) {
+        if (x <= 0 || y <= 0) {
+            devicePreview.clearDevicePreview();
+        }
+        else {
+            devicePreview.setDevicePreview(x, y);
+        }
+    };
+}
+exports.makeSetDevicePreview = makeSetDevicePreview;

package/lib/Utilities/degreesToRadians.d.ts

@@ -0,0 +1 @@
+export declare function degreesToRadians(deg: number): number;

package/lib/Utilities/degreesToRadians.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.degreesToRadians = void 0;
+function degreesToRadians(deg) {
+    return deg * Math.PI / 180;
+}
+exports.degreesToRadians = degreesToRadians;

package/lib/Utilities/index.d.ts

@@ -0,0 +1 @@
+export * from "./degreesToRadians";

package/lib/Utilities/index.js

@@ -0,0 +1,13 @@
+"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("./degreesToRadians"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.6.0",
+  "version": "2.6.4",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -28,7 +28,6 @@
   "homepage": "https://bitbucket.org/cyberscience3d/vivedlearning_app#readme",
   "devDependencies": {
     "@types/jest": "^26.0.22",
-    "@vived/app-host-boundary": "^3.2.0",
     "jest": "^26.6.3",
     "prettier": "^2.2.1",
     "ts-jest": "^26.5.4",
@@ -41,5 +40,8 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@vived/app-host-boundary": "^3.2.0"
   }
 }