@vived/app 4.26.2 → 4.27.1

package/lib/UseCases/QuestionChallenge/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("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./setQuesionChallengeAnswerFeedback"), exports);
+__exportStar(require("./setQuesionChallengeAnswerText"), exports);
+__exportStar(require("./toggleQuesionChallengeAnswerIsCorrect"), exports);

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerFeedback(answerID: string, questionChallenge: QuestionChallenge): (feedback: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerFeedback = void 0;
+function makeSetQuestionChallengeAnswerFeedback(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerFeedback(feedback) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.feedbackText = feedback;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerFeedback] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerFeedback = makeSetQuestionChallengeAnswerFeedback;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerText(answerID: string, questionChallenge: QuestionChallenge): (text: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerText = void 0;
+function makeSetQuestionChallengeAnswerText(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerText(text) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.text = text;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerText] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerText = makeSetQuestionChallengeAnswerText;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeToggleQuesionChallengeAnswerIsCorrect(answerID: string, questionChallenge: QuestionChallenge): () => void;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuesionChallengeAnswerIsCorrect = void 0;
+function makeToggleQuesionChallengeAnswerIsCorrect(answerID, questionChallenge) {
+    return function toggleQuesionChallengeAnswerIsCorrect() {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.isCorrect = !answer.isCorrect;
+        }
+        else {
+            console.warn("[toggleQuesionChallengeAnswerIsCorrect] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeToggleQuesionChallengeAnswerIsCorrect = makeToggleQuesionChallengeAnswerIsCorrect;

package/lib/UseCases/SceneModel/SerializeActiveModel.d.ts

@@ -0,0 +1,18 @@
+import { StateMachine, SceneModelMeshStateDTO, SerializedSystem, SceneModelRepo } from "../../Entities";
+export declare class SerializeActiveModel implements SerializedSystem {
+    private sceneModelRepo;
+    private easeFn;
+    name: string;
+    seriliziationVersion: number;
+    loadNewModel: (modelID: string, initialStateLookup: Map<string, SceneModelMeshStateDTO>) => void;
+    selectActiveModel: () => void;
+    getSystemState(): object;
+    applySystemState(state: object, version: number, transitionDurationSec: number): void;
+    private applyStateV1;
+    applyDefaultState: () => void;
+    constructor(sceneModelRepo: SceneModelRepo, easeFn: (normalizedTime: number) => number, stateMachine: StateMachine);
+}
+export interface SerializedActiveModelV1 {
+    modelID: string;
+    meshModelStates: SceneModelMeshStateDTO[];
+}

package/lib/UseCases/SceneModel/SerializeActiveModel.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeActiveModel = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeActiveModel {
+    constructor(sceneModelRepo, easeFn, stateMachine) {
+        this.sceneModelRepo = sceneModelRepo;
+        this.easeFn = easeFn;
+        this.name = "active-model";
+        this.seriliziationVersion = 1;
+        this.loadNewModel = () => {
+            throw new Error("setActiveModel has not been injected into SerializeActiveModel serializer");
+        };
+        this.selectActiveModel = () => {
+            throw new Error("selectActiveModel has not been injected into SerializeActiveModel serializer");
+        };
+        this.applyDefaultState = () => {
+            this.selectActiveModel();
+        };
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const modelStates = [];
+        if (this.sceneModelRepo.activeModel) {
+            this.sceneModelRepo.activeModel.getAllMeshes().forEach((mesh) => {
+                const meshState = mesh.getState();
+                if (meshState !== null) {
+                    modelStates.push(meshState);
+                }
+            });
+        }
+        const state = {
+            modelID: this.sceneModelRepo.activeModelID,
+            meshModelStates: modelStates,
+        };
+        return state;
+    }
+    applySystemState(state, version, transitionDurationSec) {
+        if (version === 1) {
+            this.applyStateV1(state, transitionDurationSec);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state, transitionDurationSec) {
+        const { meshModelStates, modelID } = state;
+        if (meshModelStates === undefined || modelID === undefined) {
+            console.warn("[SerializeActiveModel] Unable to parse state: ", JSON.stringify(state));
+            this.applyDefaultState();
+            return;
+        }
+        const stateLookup = new Map();
+        meshModelStates.forEach((mmState) => {
+            stateLookup.set(mmState.id, mmState);
+        });
+        const existingModel = this.sceneModelRepo.get(modelID);
+        if (existingModel) {
+            this.sceneModelRepo.activeModelID = modelID;
+            existingModel.getAllMeshes().forEach((meshModel) => {
+                const mmState = stateLookup.get(meshModel.id);
+                const pos = mmState
+                    ? ValueObjects_1.Vector3.FromDTO(mmState.position)
+                    : ValueObjects_1.Vector3.Zero();
+                meshModel.moveTo(pos, transitionDurationSec * 1000, this.easeFn);
+                meshModel.shown = mmState ? mmState.shown : true;
+            });
+        }
+        else {
+            this.loadNewModel(modelID, stateLookup);
+        }
+    }
+}
+exports.SerializeActiveModel = SerializeActiveModel;

package/lib/UseCases/SceneModel/SetMeshesEnabledHook.d.ts

@@ -0,0 +1,7 @@
+import { SceneModelRepo } from "../../Entities";
+export declare class SetMeshesEnabledHook {
+    private sceneModelRepo;
+    private lastActiveModelID;
+    onSceneModelRepoChange: () => void;
+    constructor(sceneModelRepo: SceneModelRepo);
+}

package/lib/UseCases/SceneModel/SetMeshesEnabledHook.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMeshesEnabledHook = void 0;
+class SetMeshesEnabledHook {
+    constructor(sceneModelRepo) {
+        this.sceneModelRepo = sceneModelRepo;
+        this.onSceneModelRepoChange = () => {
+            if (this.lastActiveModelID === this.sceneModelRepo.activeModelID)
+                return;
+            this.lastActiveModelID = this.sceneModelRepo.activeModelID;
+            this.sceneModelRepo.getAll().forEach((sceneModel) => {
+                const enabled = sceneModel.id === this.sceneModelRepo.activeModelID;
+                sceneModel.getAllMeshes().forEach((mesh) => {
+                    if (mesh.sceneObject)
+                        mesh.sceneObject.enabled = enabled;
+                });
+            });
+        };
+        sceneModelRepo.addObserver(this.onSceneModelRepoChange);
+    }
+}
+exports.SetMeshesEnabledHook = SetMeshesEnabledHook;

package/lib/UseCases/SceneModel/SetSceneModelMeshOverlayColor.d.ts

@@ -0,0 +1,2 @@
+import { Color, SceneModel } from "../../Entities";
+export declare function makeSetSceneModelMeshOverlayColor(sceneModel: SceneModel): (id: string, color: Color | undefined) => void;

package/lib/UseCases/SceneModel/SetSceneModelMeshOverlayColor.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetSceneModelMeshOverlayColor = void 0;
+function makeSetSceneModelMeshOverlayColor(sceneModel) {
+    return (id, color) => {
+        const sceneModelMesh = sceneModel.getMeshById(id);
+        if (!sceneModelMesh) {
+            return;
+        }
+        sceneModelMesh.overlayColor = color;
+    };
+}
+exports.makeSetSceneModelMeshOverlayColor = makeSetSceneModelMeshOverlayColor;

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

@@ -0,0 +1,5 @@
+export * from "./modelDataLoader";
+export * from "./loadNewModel";
+export * from "./SerializeActiveModel";
+export * from "./SetMeshesEnabledHook";
+export * from "./SetSceneModelMeshOverlayColor";

package/lib/UseCases/SceneModel/index.js

@@ -0,0 +1,17 @@
+"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("./modelDataLoader"), exports);
+__exportStar(require("./loadNewModel"), exports);
+__exportStar(require("./SerializeActiveModel"), exports);
+__exportStar(require("./SetMeshesEnabledHook"), exports);
+__exportStar(require("./SetSceneModelMeshOverlayColor"), exports);

package/lib/UseCases/SceneModel/loadNewModel.d.ts

@@ -0,0 +1,2 @@
+import { AppDispatcher, SceneModel, SceneModelMeshStateDTO, SceneModelRepo, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function makeLoadNewModel(sceneModelRepo: SceneModelRepo, sceneObjectRepo: SceneObjectsRepo, sceneRoot: SceneRoot, appDispatcher: AppDispatcher): (modelID: string, initialStateLookup: Map<string, SceneModelMeshStateDTO>) => Promise<SceneModel>;

package/lib/UseCases/SceneModel/loadNewModel.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLoadNewModel = void 0;
+const Entities_1 = require("../../Entities");
+const ValueObjects_1 = require("../../ValueObjects");
+function makeLoadNewModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatcher) {
+    return function loadNewModel(modelID, initialStateLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sceneModel = sceneModelRepo.get(modelID);
+            if (sceneModel === undefined) {
+                sceneModel = Entities_1.makeSceneModel(modelID);
+                sceneModelRepo.add(modelID, sceneModel);
+            }
+            sceneModelRepo.activeModelID = modelID;
+            if (sceneModel.state === Entities_1.SceneModelState.LOADING) {
+                return Promise.resolve(sceneModel);
+            }
+            if (sceneModel.state === Entities_1.SceneModelState.READY) {
+                return Promise.resolve(sceneModel);
+            }
+            sceneModel.error = undefined;
+            sceneModel.state = Entities_1.SceneModelState.LOADING;
+            sceneModelRepo.isLoadingSceneModel = true;
+            const dto = {
+                title: "Loading active model and data",
+                message: "Loading...",
+            };
+            const closeSpinner = yield appDispatcher.showSpinner(dto);
+            try {
+                const dataDTO = yield sceneModelRepo.dataLoader(modelID);
+                sceneModel.applyData(dataDTO);
+                sceneModel.getAllMeshes().forEach((meshObject) => {
+                    var _a;
+                    let so = sceneObjectRepo.get(meshObject.id);
+                    if (!so) {
+                        so = Entities_1.makeSceneObject(meshObject.id);
+                        sceneObjectRepo.add(meshObject.id, so);
+                    }
+                    so.transform.parent = (_a = sceneRoot.sceneObject) === null || _a === void 0 ? void 0 : _a.transform;
+                    meshObject.sceneObject = so;
+                    const initialState = initialStateLookup.get(meshObject.id);
+                    meshObject.position = initialState
+                        ? ValueObjects_1.Vector3.FromDTO(initialState.position)
+                        : ValueObjects_1.Vector3.Zero();
+                    meshObject.shown = initialState ? initialState.shown : true;
+                    so.transform.localRotation = ValueObjects_1.Quaternion.Identity();
+                    so.transform.localScale = ValueObjects_1.Vector3.One();
+                });
+                yield sceneModelRepo.modelLoader(modelID);
+                sceneModel.state = Entities_1.SceneModelState.READY;
+                sceneModelRepo.isLoadingSceneModel = false;
+                closeSpinner();
+                return Promise.resolve(sceneModel);
+            }
+            catch (e) {
+                const error = e;
+                sceneModelRepo.isLoadingSceneModel = false;
+                sceneModelRepo.clearActiveModel();
+                sceneModel.error = error;
+                closeSpinner();
+                const alertDTO = {
+                    title: "Load Error",
+                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
+                    closeButtonLabel: "OK",
+                    closeCallback: () => {
+                        // nada
+                    },
+                };
+                appDispatcher.showAlert(alertDTO);
+                return Promise.reject(error);
+            }
+        });
+    };
+}
+exports.makeLoadNewModel = makeLoadNewModel;

package/lib/UseCases/SceneModel/modelDataLoader.d.ts

@@ -0,0 +1,3 @@
+import { AppDispatcher, SceneModelDTO } from "../../Entities";
+export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+export declare function makeModelDataLoader(appDispatcher: AppDispatcher): (modelID: string) => Promise<SceneModelDTO>;

package/lib/UseCases/SceneModel/modelDataLoader.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelDataLoader = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+function makeModelDataLoader(appDispatcher) {
+    return function modelDataLoader(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataAssets = yield appDispatcher.getLinkedAssets(modelID, exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE);
+                if (dataAssets.length === 0) {
+                    return Promise.reject(new Error("Model asset does not have data"));
+                }
+                const dataFileBlobURL = yield appDispatcher.getAssetBlobURL(dataAssets[0].id);
+                const fetchDataResp = yield fetch(dataFileBlobURL);
+                const modelJSONData = yield fetchDataResp.json();
+                return Promise.resolve(modelJSONData);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    };
+}
+exports.makeModelDataLoader = makeModelDataLoader;

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

@@ -0,0 +1,33 @@
+import { SerializedSystem, StateMachine } from "../../Entities";
+import { SceneRoot } from "../../Entities/SceneRoot";
+export declare class SerializeSceneRoot implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private sceneRoot;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV2Data;
+    private applyV1Data;
+    constructor(sceneRoot: SceneRoot, stateMachine: StateMachine);
+}
+export interface SceneRootDataV1 {
+    position: [number, number, number];
+    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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeSceneRoot = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeSceneRoot {
+    constructor(sceneRoot, stateMachine) {
+        this.name = "sceneRoot";
+        this.seriliziationVersion = 2;
+        this.sceneRoot = sceneRoot;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            position: this.sceneRoot.position.dto,
+            rotation: this.sceneRoot.rotation.dto,
+            scale: this.sceneRoot.scale,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                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);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeSceneRoot] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        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);
+        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

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

package/lib/UseCases/SceneRoot/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("./SerializeSceneRoot"), exports);
+__exportStar(require("./setupSceneRoot"), exports);

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

@@ -0,0 +1,7 @@
+export * from "./setDevicePreview";
+export * from "./Handlers";
+export * from "./QuestionChallenge";
+export * from "./LerpVector3";
+export * from "./HoverLabels/trySetHoverLabel";
+export * from "./HoverLabels/SerializeAllowHoverLabel";
+export * from "./setupStandardAppObjects";

package/lib/UseCases/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("./setDevicePreview"), exports);
+__exportStar(require("./Handlers"), exports);
+__exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./LerpVector3"), exports);
+__exportStar(require("./HoverLabels/trySetHoverLabel"), exports);
+__exportStar(require("./HoverLabels/SerializeAllowHoverLabel"), exports);
+__exportStar(require("./setupStandardAppObjects"), exports);