@vived/app 2.45.0 → 2.46.0

package/lib/UseCases/SceneModel/setupSceneModelFromData.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetupSceneModelFromData = void 0;
+const Entities_1 = require("../../Entities");
+const ValueObjects_1 = require("../../ValueObjects");
+function makeSetupSceneModelFromData(sceneObjectRepo) {
+    return function setupSceneModelFromData(sceneModel, data) {
+        if (data.version === 1) {
+            applyDataV1(sceneModel, data, sceneObjectRepo);
+        }
+        else if (data.version === 0) {
+            const mappedData = mapV0DataToV1(data);
+            applyDataV1(sceneModel, mappedData, sceneObjectRepo);
+        }
+        else {
+            console.warn("[setupSceneModelFromData] Unsupported version number");
+        }
+    };
+}
+exports.makeSetupSceneModelFromData = makeSetupSceneModelFromData;
+function mapV0DataToV1(dataV0) {
+    const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects: objectsV0, } = dataV0;
+    const objects = objectsV0.map((objV0) => {
+        return Object.assign(Object.assign({}, objV0), { version: 1 });
+    });
+    return {
+        bounds_max,
+        bounds_min,
+        defaultPosition,
+        defaultRotation,
+        defaultScale,
+        name,
+        version: 1,
+        objects,
+    };
+}
+function applyDataV1(sceneModel, data, sceneObjectRepo) {
+    sceneModel.name = data.name;
+    sceneModel.bounds_min = ValueObjects_1.Vector3.FromDTO(data.bounds_min);
+    sceneModel.bounds_max = ValueObjects_1.Vector3.FromDTO(data.bounds_max);
+    sceneModel.defaultPosition = ValueObjects_1.Vector3.FromDTO(data.defaultPosition);
+    sceneModel.defaultScale = data.defaultScale;
+    sceneModel.defaultRotation = ValueObjects_1.Quaternion.FromDTO(data.defaultRotation);
+    const objectsToKeep = [];
+    data.objects.forEach((objectDTO) => {
+        const existingObj = sceneModel.getObjectById(objectDTO.id);
+        if (existingObj) {
+            console.log("EXISTING");
+            existingObj.applyData(objectDTO);
+        }
+        else {
+            console.log("NEW");
+            let so = sceneObjectRepo.get(objectDTO.id);
+            if (!so) {
+                so = Entities_1.makeSceneObject(objectDTO.id);
+                sceneObjectRepo.add(objectDTO.id, so);
+            }
+            const newObj = Entities_1.makeModelMesh(objectDTO, so);
+            sceneModel.addObject(newObj);
+        }
+        objectsToKeep.push(objectDTO.id);
+    });
+    const allObjects = sceneModel.getAllObjects().map((modelMesh) => {
+        return modelMesh.id;
+    });
+    allObjects.forEach((obj) => {
+        if (!objectsToKeep.includes(obj)) {
+            sceneModel.removeObject(obj);
+            sceneObjectRepo.remove(obj);
+        }
+    });
+}

package/lib/UseCases/SceneObjects/PeelSceneObject.d.ts

@@ -0,0 +1,18 @@
+import { Babylon, SceneObject, SceneObjectsRepo } from "../../Entities";
+import { ParametricLine } from "../../ValueObjects";
+export declare class PeelSceneObject {
+    private babylon;
+    private sceneObjectRepo;
+    private _didPeel;
+    get didPeel(): boolean;
+    private _peelingSceneObject;
+    get peelingSceneObject(): SceneObject | undefined;
+    private _peelPlane;
+    private _rootPos;
+    private _allowPeel;
+    private _pickOffset;
+    tryInitializePeel: (pickRay: ParametricLine) => void;
+    updatePeel: (pickRay: ParametricLine) => void;
+    stopPeel: () => void;
+    constructor(babylon: Babylon, sceneObjectRepo: SceneObjectsRepo);
+}

package/lib/UseCases/SceneObjects/PeelSceneObject.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeelSceneObject = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PeelSceneObject {
+    constructor(babylon, sceneObjectRepo) {
+        this.babylon = babylon;
+        this.sceneObjectRepo = sceneObjectRepo;
+        this._didPeel = false;
+        this._peelingSceneObject = undefined;
+        this._peelPlane = ValueObjects_1.ParametricPlane.XY();
+        this._allowPeel = false;
+        this._pickOffset = ValueObjects_1.Vector3.Zero();
+        this.tryInitializePeel = (pickRay) => {
+            var _a, _b;
+            this._allowPeel = false;
+            this._didPeel = false;
+            this._peelingSceneObject = undefined;
+            const sceneObjectID = this.babylon.sceneObjectRayPick(pickRay);
+            if (!sceneObjectID)
+                return;
+            const sceneObject = this.sceneObjectRepo.get(sceneObjectID);
+            if (!sceneObject)
+                return;
+            this._peelingSceneObject = sceneObject;
+            const scenePick = this.babylon.sceneRayPick(pickRay);
+            if (!scenePick)
+                return;
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            const planePickPos = (_a = scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_b = this._peelPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this._rootPos = this._peelingSceneObject.transform.worldPosition;
+            this._pickOffset = ValueObjects_1.Vector3.Subtract(this._rootPos, pick);
+            this._allowPeel = true;
+        };
+        this.updatePeel = (pickRay) => {
+            var _a;
+            if (!this._allowPeel)
+                return;
+            if (!this._peelingSceneObject)
+                return;
+            const pick = (_a = this._peelPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelingSceneObject.transform.worldPosition = ValueObjects_1.Vector3.Add(pick, this._pickOffset);
+            this._didPeel = true;
+        };
+        this.stopPeel = () => {
+            this._allowPeel = false;
+            this._didPeel = false;
+            this._peelingSceneObject = undefined;
+            this._rootPos = undefined;
+        };
+    }
+    get didPeel() {
+        return this._didPeel;
+    }
+    get peelingSceneObject() {
+        return this._peelingSceneObject;
+    }
+}
+exports.PeelSceneObject = PeelSceneObject;

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

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

package/lib/UseCases/SceneObjects/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("./PeelSceneObject"), exports);

package/lib/UseCases/SceneRoot/SerializeSceneRoot.d.ts

@@ -8,6 +8,7 @@ export declare class SerializeSceneRoot implements SerializedSystem {
     getSystemState(): object;
     applySystemState(serializedState: object, version: number, transitionTime: number): void;
     applyDefaultState(transitionDuration: number): void;
+    private applyV2Data;
     private applyV1Data;
     constructor(sceneRoot: SceneRoot, stateMachine: StateMachine);
 }
@@ -16,3 +17,17 @@ export interface SceneRootDataV1 {
     rotation: [number, number, number, number];
     scale: [number, number, number];
 }
+export interface SceneRootDataV2 {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: number;
+}

package/lib/UseCases/SceneRoot/SerializeSceneRoot.js

@@ -5,17 +5,16 @@ const ValueObjects_1 = require("../../ValueObjects");
 class SerializeSceneRoot {
     constructor(sceneRoot, stateMachine) {
         this.name = "sceneRoot";
-        this.seriliziationVersion = 1;
+        this.seriliziationVersion = 2;
         this.sceneRoot = sceneRoot;
         this.stateMachine = stateMachine;
         stateMachine.registerSerializedSystem(this);
     }
     getSystemState() {
-        const rootTransform = this.sceneRoot.transform;
         const data = {
-            position: rootTransform.localPosition.array,
-            rotation: rootTransform.localRotation.toArray(),
-            scale: rootTransform.localScale.array,
+            position: this.sceneRoot.position.dto,
+            rotation: this.sceneRoot.rotation.dto,
+            scale: this.sceneRoot.scale,
         };
         return data;
     }
@@ -25,6 +24,10 @@ class SerializeSceneRoot {
                 const castState = serializedState;
                 this.applyV1Data(castState, transitionTime);
             }
+            else if (version === 2) {
+                const castState = serializedState;
+                this.applyV2Data(castState, transitionTime);
+            }
             else {
                 console.warn(`[SerializeSceneRoot] Unsupported version number ${version}. Defaulting`);
                 this.applyDefaultState(transitionTime);
@@ -36,13 +39,29 @@ class SerializeSceneRoot {
         }
     }
     applyDefaultState(transitionDuration) {
-        this.sceneRoot.transform.lerp(transitionDuration * 1000, this.stateMachine.transitionEaseFunction, this.sceneRoot.defaultPosition, this.sceneRoot.defaultRoation, this.sceneRoot.defaultScale);
+        this.sceneRoot.lerpToDefault(transitionDuration * 1000, this.stateMachine.transitionEaseFunction);
+    }
+    applyV2Data(data, transitionTime) {
+        if (!this.sceneRoot.sceneObject) {
+            console.warn("[SerializeSceneRoot] scene root does not have a scene object");
+            return {};
+        }
+        const pos = ValueObjects_1.Vector3.FromDTO(data.position);
+        const rot = ValueObjects_1.Quaternion.FromDTO(data.rotation);
+        const scale = new ValueObjects_1.Vector3(data.scale, data.scale, data.scale);
+        const rootTransform = this.sceneRoot.sceneObject.transform;
+        rootTransform.lerp(transitionTime * 1000, this.stateMachine.transitionEaseFunction, pos, rot, scale);
     }
     applyV1Data(data, transitionTime) {
+        if (!this.sceneRoot.sceneObject) {
+            console.warn("[SerializeSceneRoot] scene root does not have a scene object");
+            return {};
+        }
         const pos = ValueObjects_1.Vector3.FromArray(data.position);
         const rot = ValueObjects_1.Quaternion.FromArray(data.rotation);
         const scale = ValueObjects_1.Vector3.FromArray(data.scale);
-        this.sceneRoot.transform.lerp(transitionTime * 1000, this.stateMachine.transitionEaseFunction, pos, rot, scale);
+        const rootTransform = this.sceneRoot.sceneObject.transform;
+        rootTransform.lerp(transitionTime * 1000, this.stateMachine.transitionEaseFunction, pos, rot, scale);
     }
 }
 exports.SerializeSceneRoot = SerializeSceneRoot;

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

@@ -1 +1,2 @@
 export * from "./SerializeSceneRoot";
+export * from "./setupSceneRoot";

package/lib/UseCases/SceneRoot/index.js

@@ -11,3 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./SerializeSceneRoot"), exports);
+__exportStar(require("./setupSceneRoot"), exports);

package/lib/UseCases/SceneRoot/initializeSceneRoot.d.ts

@@ -0,0 +1,2 @@
+import { DefaultSceneRootData, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function initializeSceneRoot(defaultData: DefaultSceneRootData, sceneRoot: SceneRoot, sceneObjectRepo: SceneObjectsRepo): void;

package/lib/UseCases/SceneRoot/initializeSceneRoot.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeSceneRoot = void 0;
+const Entities_1 = require("../../Entities");
+function initializeSceneRoot(defaultData, sceneRoot, sceneObjectRepo) {
+    sceneRoot.applyDefaultData(defaultData);
+    sceneObjectRepo.add(Entities_1.SCENE_ROOT_ID, sceneRoot.sceneObject);
+}
+exports.initializeSceneRoot = initializeSceneRoot;

package/lib/UseCases/SceneRoot/setupSceneRoot.d.ts

@@ -0,0 +1,2 @@
+import { DefaultSceneRootData, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function setupSceneRoot(defaultData: DefaultSceneRootData, sceneRoot: SceneRoot, sceneObjectRepo: SceneObjectsRepo): void;

package/lib/UseCases/SceneRoot/setupSceneRoot.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSceneRoot = void 0;
+const Entities_1 = require("../../Entities");
+function setupSceneRoot(defaultData, sceneRoot, sceneObjectRepo) {
+    sceneRoot.applyDefaultData(defaultData);
+    const so = Entities_1.makeSceneObject(Entities_1.SCENE_ROOT_ID);
+    sceneRoot.sceneObject = so;
+    sceneObjectRepo.add(Entities_1.SCENE_ROOT_ID, so);
+}
+exports.setupSceneRoot = setupSceneRoot;

package/lib/UseCases/index.d.ts

@@ -2,7 +2,7 @@ export * from "./setDevicePreview";
 export * from "./Handlers";
 export * from "./QuestionChallenge";
 export * from "./SceneModel";
-export * from "./SceneObject";
+export * from "./SceneObjects";
 export * from "./LerpVector3";
 export * from "./SceneRoot";
 export * from "./HoverLabels/trySetHoverLabel";

package/lib/UseCases/index.js

@@ -14,7 +14,7 @@ __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./Handlers"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./SceneModel"), exports);
-__exportStar(require("./SceneObject"), exports);
+__exportStar(require("./SceneObjects"), exports);
 __exportStar(require("./LerpVector3"), exports);
 __exportStar(require("./SceneRoot"), exports);
 __exportStar(require("./HoverLabels/trySetHoverLabel"), exports);

package/lib/ValueObjects/Vector3.d.ts

@@ -1,4 +1,9 @@
 import { Matrix } from "./Matrix";
+export interface Vector3DTO {
+    x: number;
+    y: number;
+    z: number;
+}
 export declare class Vector3 {
     /**
      * Creates a zero vector
@@ -57,11 +62,7 @@ export declare class Vector3 {
      * @param dto The Data Transfer Object
      * @returns The Vector
      */
-    static FromDTO(dto: {
-        x: number;
-        y: number;
-        z: number;
-    }): Vector3;
+    static FromDTO(dto: Vector3DTO): Vector3;
     /**
      * Adds Vector B to Vector A
      * @param a Vector A
@@ -142,10 +143,6 @@ export declare class Vector3 {
     /**
      * Get the vector as a Data Transfer Object
      */
-    get dto(): {
-        x: number;
-        y: number;
-        z: number;
-    };
+    get dto(): Vector3DTO;
     constructor(x: number, y: number, z: number);
 }

package/lib/ValueObjects/Vector3.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector3 = void 0;
 const lerpNumber_1 = require("../Utilities/lerpNumber");
+;
 class Vector3 {
     constructor(x, y, z) {
         this.x = x;

package/package.json

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