@vived/app 2.45.0 → 2.46.0

package/lib/Entities/SceneRoot.js

@@ -1,37 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneRoot = void 0;
+exports.makeSceneRoot = exports.SceneRoot = exports.SCENE_ROOT_ID = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const ObserverList_1 = require("./ObserverList");
-const TransformNode_1 = require("./TransformNode");
+const ObservableEntity_1 = require("./ObservableEntity");
+exports.SCENE_ROOT_ID = "scene-root";
+class SceneRoot extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneRoot = SceneRoot;
 function makeSceneRoot() {
     return new SceneRootImp();
 }
 exports.makeSceneRoot = makeSceneRoot;
-class SceneRootImp {
+class SceneRootImp extends SceneRoot {
     constructor() {
-        this.observers = new ObserverList_1.ObserverList();
+        super(...arguments);
         this._defaultPosition = ValueObjects_1.Vector3.Zero();
         this._defaultRoation = ValueObjects_1.Quaternion.Identity();
-        this._defaultScale = ValueObjects_1.Vector3.One();
+        this._defaultScale = 1;
         this._minScale = 0.01;
         this._maxScale = 10;
-        this._id = "scene_root";
         this.applyDefaultData = (data) => {
             this._defaultPosition = ValueObjects_1.Vector3.FromArray(data.position);
             this._defaultRoation = ValueObjects_1.Quaternion.FromArray(data.rotation);
-            this._defaultScale = new ValueObjects_1.Vector3(data.scale, data.scale, data.scale);
+            this._defaultScale = data.scale;
             this._maxScale = data.maxScale;
             this._minScale = data.minScale;
-            this._id = data.id;
         };
         this.centerOnPoint = (point, durationMS, easeFn, onCompleted) => {
-            const finalPosition = ValueObjects_1.Vector3.Subtract(this.transform.worldPosition, point);
-            this.transform.lerp(durationMS, easeFn, finalPosition, undefined, undefined, onCompleted);
+            if (!this.sceneObject) {
+                console.warn("SceneRoot does not have a scene object");
+                return;
+            }
+            const finalPosition = ValueObjects_1.Vector3.Subtract(this.sceneObject.transform.worldPosition, point);
+            this.sceneObject.transform.lerp(durationMS, easeFn, finalPosition, undefined, undefined, onCompleted);
         };
         this.bumpScaleAboutPoint = (amount, worldPoint) => {
-            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
-            const currentScale = this.transform.worldScale.x;
+            if (!this.sceneObject) {
+                console.warn("SceneRoot does not have a scene object");
+                return;
+            }
+            const localPickOffset = this.sceneObject.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.sceneObject.transform.worldScale.x;
             let newScale = currentScale + amount;
             if (newScale < this.minScale) {
                 newScale = this.minScale;
@@ -39,22 +48,81 @@ class SceneRootImp {
             else if (newScale > this.maxScale) {
                 newScale = this.maxScale;
             }
-            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
-            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            this.sceneObject.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.sceneObject.transform.localPointToWorld(localPickOffset);
             const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
-            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+            this.sceneObject.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.sceneObject.transform.worldPosition);
         };
         this.lerpToDefault = (durationMS, easeFn, onCompleted) => {
-            this.transform.lerp(durationMS, easeFn, this.defaultPosition, this.defaultRoation, this.defaultScale, onCompleted);
-        };
-        this.addObserver = (observer) => {
-            this.observers.add(observer);
-        };
-        this.removeObserver = (observer) => {
-            this.observers.remove(observer);
+            if (!this.sceneObject) {
+                console.warn("SceneRoot does not have a scene object");
+                return;
+            }
+            this.sceneObject.transform.lerp(durationMS, easeFn, this.defaultPosition, this.defaultRoation, new ValueObjects_1.Vector3(this.defaultScale, this.defaultScale, this.defaultScale), onCompleted);
         };
-        this.transform = TransformNode_1.makeTransformNode();
-        this.transform.addObserver(this.observers.notify);
+    }
+    get position() {
+        if (this.sceneObject) {
+            return this.sceneObject.transform.localPosition;
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+            return ValueObjects_1.Vector3.Zero();
+        }
+    }
+    set position(p) {
+        if (this.sceneObject) {
+            this.sceneObject.transform.localPosition = p;
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+        }
+    }
+    get rotation() {
+        if (this.sceneObject) {
+            return this.sceneObject.transform.localRotation;
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+            return ValueObjects_1.Quaternion.Identity();
+        }
+    }
+    set rotation(r) {
+        if (this.sceneObject) {
+            this.sceneObject.transform.localRotation = r;
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+        }
+    }
+    get scale() {
+        if (this.sceneObject) {
+            return this.sceneObject.transform.localScale.x;
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+            return 1;
+        }
+    }
+    set scale(s) {
+        if (this.sceneObject) {
+            this.sceneObject.transform.localScale = new ValueObjects_1.Vector3(s, s, s);
+        }
+        else {
+            console.warn("SceneRoot does not have a scene object");
+        }
+    }
+    get sceneObject() {
+        return this._sceneObject;
+    }
+    set sceneObject(so) {
+        if (this._sceneObject) {
+            this._sceneObject.removeObserver(this.notify);
+        }
+        this._sceneObject = so;
+        if (this._sceneObject) {
+            this._sceneObject.addObserver(this.notify);
+        }
     }
     get defaultPosition() {
         return this._defaultPosition;
@@ -72,6 +140,6 @@ class SceneRootImp {
         return this._maxScale;
     }
     get id() {
-        return this._id;
+        return exports.SCENE_ROOT_ID;
     }
 }

package/lib/Entities/index.d.ts

@@ -22,7 +22,7 @@ export * from "./ObserverList";
 export * from "./QuestionChallenge";
 export * from "./QuestionChallengeAnswer";
 export * from "./SceneModel";
-export * from "./SceneModelObject";
+export * from "./SceneModelMesh";
 export * from "./SceneModelRepo";
 export * from "./SceneObject";
 export * from "./SceneObjectsRepo";

package/lib/Entities/index.js

@@ -34,7 +34,7 @@ __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./SceneModel"), exports);
-__exportStar(require("./SceneModelObject"), exports);
+__exportStar(require("./SceneModelMesh"), exports);
 __exportStar(require("./SceneModelRepo"), exports);
 __exportStar(require("./SceneObject"), exports);
 __exportStar(require("./SceneObjectsRepo"), exports);

package/lib/PresentationManagers/SceneObject/SceneObjectPM.d.ts

@@ -0,0 +1,17 @@
+import { SceneObject } from "../../Entities";
+import { Quaternion, Vector3 } from "../../ValueObjects";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneObjectVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    enabled: boolean;
+}
+export declare class SceneObjectPM extends PresentionManager {
+    private sceneObject;
+    private updateView;
+    private lastVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneObject: SceneObject, updateView: (vm: SceneObjectVM) => void);
+}

package/lib/PresentationManagers/SceneObject/SceneObjectPM.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneObjectPM = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+const PresentationManager_1 = require("../PresentationManager");
+class SceneObjectPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneObject, updateView) {
+        super(sceneObject);
+        this.sceneObject = sceneObject;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const enabled = this.sceneObject.shown && this.sceneObject.enabled;
+            const vm = {
+                position: this.sceneObject.transform.localPosition,
+                rotation: this.sceneObject.transform.localRotation,
+                scale: this.sceneObject.transform.localScale,
+                enabled,
+            };
+            if (this.vmHasChanged(vm)) {
+                this.updateView(vm);
+                this.lastVM = vm;
+            }
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(newVM) {
+        if (this.lastVM === undefined)
+            return true;
+        if (this.lastVM.enabled !== newVM.enabled)
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.position, newVM.position))
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.scale, newVM.scale))
+            return true;
+        if (!ValueObjects_1.Quaternion.Close(this.lastVM.rotation, newVM.rotation))
+            return true;
+        return false;
+    }
+}
+exports.SceneObjectPM = SceneObjectPM;

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

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

package/lib/PresentationManagers/SceneObject/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("./SceneObjectPM"), exports);

package/lib/PresentationManagers/index.d.ts

@@ -6,6 +6,7 @@ export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
 export * from "./QuestionChallenge";
+export * from "./SceneObject";
 export * from "./ToolPM";
 export * from "./TransformNodePM";
 export * from "./HoverLabels";

package/lib/PresentationManagers/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneObject"), exports);
 __exportStar(require("./ToolPM"), exports);
 __exportStar(require("./TransformNodePM"), exports);
 __exportStar(require("./HoverLabels"), exports);

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

@@ -0,0 +1,20 @@
+import { Babylon, SceneModelRepo, TransformNode } from "../../Entities";
+import { ParametricLine } from "../../ValueObjects";
+export declare class PeelSceneMeshBase {
+    private babylon;
+    private sceneModelRepo;
+    get peeledSceneObjectID(): string | undefined;
+    private _sceneObject;
+    private _didPeel;
+    get didPeel(): boolean;
+    private _doPeel;
+    private _transformToPeel;
+    get peelingTransform(): TransformNode | undefined;
+    private _rootPos;
+    private _peelPlane;
+    private _pickOffset;
+    tryInitializePeel: (pickRay: ParametricLine) => void;
+    updatePeel: (pickRay: ParametricLine) => void;
+    stopPeel: () => void;
+    constructor(babylon: Babylon, sceneModelRepo: SceneModelRepo);
+}

package/lib/UseCases/SceneModel/PeelSceneMeshBase.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeelSceneMeshBase = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PeelSceneMeshBase {
+    constructor(babylon, sceneModelRepo) {
+        this.babylon = babylon;
+        this.sceneModelRepo = sceneModelRepo;
+        this._didPeel = false;
+        this._doPeel = false;
+        this._transformToPeel = undefined;
+        this._peelPlane = ValueObjects_1.ParametricPlane.XY();
+        this._pickOffset = ValueObjects_1.Vector3.Zero();
+        this.tryInitializePeel = (pickRay) => {
+            var _a, _b, _c, _d;
+            this._doPeel = false;
+            this._didPeel = false;
+            this._transformToPeel = undefined;
+            const sceneObjectID = this.babylon.sceneObjectRayPick(pickRay);
+            if (!sceneObjectID)
+                return;
+            const sceneObject = (_b = (_a = this.sceneModelRepo.activeModel) === null || _a === void 0 ? void 0 : _a.getMeshById(sceneObjectID)) === null || _b === void 0 ? void 0 : _b.sceneObject;
+            if (!sceneObject)
+                return;
+            this._sceneObject = sceneObject;
+            this._transformToPeel = sceneObject.transform;
+            const scenePick = this.babylon.sceneRayPick(pickRay);
+            if (!scenePick)
+                return;
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            const planePickPos = (_c = scenePick.worldPickPoint) !== null && _c !== void 0 ? _c : ValueObjects_1.Vector3.Zero();
+            this._peelPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_d = this._peelPlane.intersectLine(pickRay)) !== null && _d !== void 0 ? _d : ValueObjects_1.Vector3.Zero();
+            this._rootPos = this._transformToPeel.worldPosition;
+            this._pickOffset = ValueObjects_1.Vector3.Subtract(this._rootPos, pick);
+            this._doPeel = true;
+        };
+        this.updatePeel = (pickRay) => {
+            var _a;
+            if (!this._doPeel)
+                return;
+            if (!this._transformToPeel)
+                return;
+            const pick = (_a = this._peelPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._transformToPeel.worldPosition = ValueObjects_1.Vector3.Add(pick, this._pickOffset);
+            this._didPeel = true;
+        };
+        this.stopPeel = () => {
+            this._doPeel = false;
+            this._didPeel = false;
+            this._transformToPeel = undefined;
+            this._rootPos = undefined;
+        };
+    }
+    get peeledSceneObjectID() {
+        var _a;
+        return (_a = this._sceneObject) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    get didPeel() {
+        return this._didPeel;
+    }
+    get peelingTransform() {
+        return this._transformToPeel;
+    }
+}
+exports.PeelSceneMeshBase = PeelSceneMeshBase;

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

@@ -1,2 +1,4 @@
-export * from './modelDataLoader';
-export * from './setActiveSceneModel';
+export * from "./modelDataLoader";
+export * from "./loadNewModel";
+export * from "./SerializeActiveModel";
+export * from "./SetMeshesEnabledHook";

package/lib/UseCases/SceneModel/index.js

@@ -11,4 +11,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./modelDataLoader"), exports);
-__exportStar(require("./setActiveSceneModel"), exports);
+__exportStar(require("./loadNewModel"), exports);
+__exportStar(require("./SerializeActiveModel"), exports);
+__exportStar(require("./SetMeshesEnabledHook"), 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/setActiveSceneModel.js

@@ -38,14 +38,15 @@ function makeSetActiveModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispa
             try {
                 const dataDTO = yield sceneModelRepo.dataLoader(modelID);
                 sceneModel.applyData(dataDTO);
-                sceneModel.getAllObjects().forEach((meshObject) => {
+                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.label = meshObject.label;
-                    so.transform.parent = sceneRoot.transform;
+                    so.transform.parent = (_a = sceneRoot.sceneObject) === null || _a === void 0 ? void 0 : _a.transform;
                     so.notify();
                 });
                 yield sceneModelRepo.modelLoader(modelID);
@@ -79,7 +80,7 @@ exports.makeSetActiveModel = makeSetActiveModel;
 function setSceneObjectsEnabled(sceneObjectRepo, activeModel) {
     const allSOs = sceneObjectRepo.getAll();
     allSOs.forEach(so => {
-        if (activeModel.hasObject(so.id)) {
+        if (activeModel.hasMesh(so.id)) {
             so.enabled = true;
         }
         else {

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

@@ -0,0 +1,2 @@
+import { SceneModel, SceneModelDTO, SceneObjectsRepo } from "../../Entities";
+export declare function makeSetupSceneModelFromData(sceneObjectRepo: SceneObjectsRepo): (sceneModel: SceneModel, data: SceneModelDTO) => void;