@vived/app 2.8.0 → 2.10.0

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;
+}

package/lib/UseCases/OrbitCamera/SerializeOrbitCamera.js

@@ -0,0 +1,81 @@
+"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) {
+        this.name = "orbitCamera";
+        this.seriliziationVersion = 1;
+        this.orbitCamera = orbitCamera;
+        this.stateMachine = stateMachine;
+        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) {
+        const alpha = this.orbitCamera.defaultAlpha;
+        const beta = this.orbitCamera.defaultBeta;
+        const radius = this.orbitCamera.defaultRadius;
+        const target = this.orbitCamera.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 Entities_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.orbitCamera.cancelLerp();
+        this.orbitCamera.alpha = alpha;
+        this.orbitCamera.beta = beta;
+        this.orbitCamera.radius = radius;
+        this.orbitCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpOrbitCamera(this.orbitCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializedOrbitCamera = SerializedOrbitCamera;

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

@@ -0,0 +1,4 @@
+export * from "./PixelPlanePan_OrbitCamera";
+export * from "./LerpOrbitCamera";
+export * from "./SerializeOrbitCamera";
+export * from "./PixelDolly_OrbitCamera";

package/lib/UseCases/OrbitCamera/index.js

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

package/lib/UseCases/index.d.ts

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

package/lib/UseCases/index.js

@@ -11,5 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
-__exportStar(require("./LerpOrbitCamera"), exports);
-__exportStar(require("./SerializeOrbitCamera"), exports);
+__exportStar(require("./FocusCamera"), exports);

package/package.json

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