@vived/app 2.20.1 → 2.21.0

package/lib/Interface/PresentationManagers/ShowBabylonInspectorPM.js

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

package/lib/Interface/PresentationManagers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DevicePreviewPM";
+export * from "./IsAuthoringPM";
+export * from "./ShowBabylonInspectorPM";

package/lib/Interface/PresentationManagers/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("./DevicePreviewPM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./ShowBabylonInspectorPM"), exports);

package/lib/Interface/appHandler.d.ts

@@ -0,0 +1,12 @@
+import { AppPayloadVersions, Handler } from "@vived/app-host-boundary";
+export declare const appPayloadVersions: AppPayloadVersions;
+export interface AppHandlerFunctions {
+    showBabylonInspector: (show: boolean) => void;
+    setIsAuthoring: (isAuthoring: boolean) => void;
+    disposeApp: () => void;
+    stopApp: () => void;
+    startApp: (container: HTMLElement) => void;
+    setState: (finalState: string, duration?: number) => void;
+    setDevicePreview: (x: number, y: number) => void;
+}
+export declare function makeAppHandler(functions: AppHandlerFunctions): Handler;

package/lib/Interface/appHandler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppHandler = exports.appPayloadVersions = void 0;
+const app_host_boundary_1 = require("@vived/app-host-boundary");
+const verbose = false;
+exports.appPayloadVersions = {
+    disposeApp: 1,
+    setDevicePreview: 1,
+    setIsAuthoring: 1,
+    showBabylonInspector: 1,
+    startApp: 2,
+    stopApp: 1,
+    setState: 2,
+};
+function makeAppHandler(functions) {
+    const handler = (request) => {
+        switch (request.type) {
+            case app_host_boundary_1.SHOW_BABYLON_INSPECTOR:
+                if (request.version === exports.appPayloadVersions.showBabylonInspector) {
+                    const payload = request.payload;
+                    functions.showBabylonInspector(payload.showBabylonInspector);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_IS_AUTHORING:
+                if (request.version === exports.appPayloadVersions.setIsAuthoring) {
+                    const payload = request.payload;
+                    functions.setIsAuthoring(payload.isAuthoring);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.DISPOSE_APP:
+                if (request.version === exports.appPayloadVersions.disposeApp) {
+                    functions.disposeApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.STOP_APP:
+                if (request.version === exports.appPayloadVersions.stopApp) {
+                    functions.stopApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_DEVICE_PREVIEW:
+                if (request.version === exports.appPayloadVersions.setDevicePreview) {
+                    const payload = request.payload;
+                    functions.setDevicePreview(payload.x, payload.y);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.START_APP:
+                if (request.version === exports.appPayloadVersions.startApp) {
+                    const payload = request.payload;
+                    functions.startApp(payload.container);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_APP_STATE:
+                if (request.version === exports.appPayloadVersions.setState) {
+                    const payload = request.payload;
+                    functions.setState(payload.finalState, payload.duration);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.GET_APP_PAYLOAD_VERSIONS:
+                if (request.version === 1) {
+                    const payload = request.payload;
+                    payload.callback(exports.appPayloadVersions);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            default:
+                throw new app_host_boundary_1.UnsupportedRequestTypeError(request.type);
+        }
+    };
+    return handler;
+}
+exports.makeAppHandler = makeAppHandler;

package/lib/Interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Controllers";
+export * from "./PresentationManagers";

package/lib/Interface/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("./Controllers"), exports);
+__exportStar(require("./PresentationManagers"), exports);

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

@@ -0,0 +1,14 @@
+import { TransformNode } from "../Entities";
+import { Quaternion, Vector3 } from "../ValueObjects";
+export interface TransformNodeVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export declare class TransformNodePM {
+    private transformNode;
+    private updateView;
+    dispose: () => void;
+    doUpdateView: () => void;
+    constructor(transformNode: TransformNode, updateView: (vm: TransformNodeVM) => void);
+}

package/lib/PresentationManagers/TransformNodePM.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformNodePM = void 0;
+class TransformNodePM {
+    constructor(transformNode, updateView) {
+        this.transformNode = transformNode;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.transformNode.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const vm = {
+                position: this.transformNode.localPosition,
+                rotation: this.transformNode.localRotation,
+                scale: this.transformNode.localScale,
+            };
+            this.updateView(vm);
+        };
+        transformNode.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+}
+exports.TransformNodePM = TransformNodePM;

package/lib/PresentationManagers/index.d.ts

@@ -6,3 +6,4 @@ export * from "./HasUndoPM";
 export * from "./FocusCameraPM";
 export * from "./QuestionChallenge";
 export * from "./FocusCameraPosRotPM";
+export * from "./TransformNodePM";

package/lib/PresentationManagers/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./FocusCameraPM"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./FocusCameraPosRotPM"), exports);
+__exportStar(require("./TransformNodePM"), 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/OrbitCamera/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/OrbitCamera/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/OrbitCamera/PixelDolly_OrbitCamera.d.ts

@@ -0,0 +1,9 @@
+import { OrbitCamera, Vector2, Vector3 } from "../../Entities";
+export declare class PixelDolly_OrbitCamera {
+    private orbitCamera;
+    private previousPixelPosition;
+    private pickPoint?;
+    doDolly(pixelPosition: Vector2): void;
+    initializeDolly(pixelPosition: Vector2, pickPoint?: Vector3): void;
+    constructor(orbitCamera: OrbitCamera);
+}

package/lib/UseCases/OrbitCamera/PixelDolly_OrbitCamera.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelDolly_OrbitCamera = void 0;
+const Entities_1 = require("../../Entities");
+class PixelDolly_OrbitCamera {
+    constructor(orbitCamera) {
+        this.orbitCamera = orbitCamera;
+        this.previousPixelPosition = Entities_1.Vector2.Zero();
+    }
+    doDolly(pixelPosition) {
+        const pixelDeltaY = pixelPosition.y - this.previousPixelPosition.y;
+        const deltaRadius = pixelDeltaY * this.orbitCamera.dollyPixelSensitivity;
+        const currentRadius = this.orbitCamera.radius;
+        const newRadius = currentRadius + deltaRadius;
+        this.orbitCamera.radius = newRadius;
+        if (this.pickPoint !== undefined) {
+            const percentChange = newRadius / currentRadius;
+            const pickToTarget = this.orbitCamera.target.subtract(this.pickPoint);
+            const newLength = pickToTarget.magnitued * percentChange;
+            pickToTarget.setLength(newLength);
+            const newTargetPos = this.pickPoint.add(pickToTarget);
+            this.orbitCamera.target = newTargetPos;
+        }
+        this.previousPixelPosition = pixelPosition;
+    }
+    initializeDolly(pixelPosition, pickPoint) {
+        this.previousPixelPosition = pixelPosition;
+        this.pickPoint = pickPoint;
+    }
+}
+exports.PixelDolly_OrbitCamera = PixelDolly_OrbitCamera;

package/lib/UseCases/OrbitCamera/PixelPlanePan_OrbitCamera.d.ts

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

package/lib/UseCases/OrbitCamera/PixelPlanePan_OrbitCamera.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPlanePan_OrbitCamera = void 0;
+const Entities_1 = require("../../Entities");
+class PixelPlanePan_OrbitCamera {
+    constructor(orbitCamera, babylon) {
+        this.orbitCamera = orbitCamera;
+        this.babylon = babylon;
+        this.doPan = (pixelPosition) => {
+            if (!this.plane || !this.previousPixelPos) {
+                throw new Error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+            }
+            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 = p2.subtract(p1);
+            const currentTarget = this.orbitCamera.target;
+            const newTarget = new Entities_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
+            this.orbitCamera.target = new Entities_1.Vector3(newTarget.x, newTarget.y, newTarget.z);
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializePan = (initialPixelPos, panPlane) => {
+            this.plane = panPlane;
+            this.previousPixelPos = initialPixelPos;
+        };
+    }
+}
+exports.PixelPlanePan_OrbitCamera = PixelPlanePan_OrbitCamera;

package/lib/UseCases/OrbitCamera/SerializeOrbitCamera.d.ts

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