@vived/app 2.44.0 → 2.46.0

package/lib/Entities/SceneRoot.d.ts

@@ -1,69 +1,29 @@
 import { Quaternion, Vector3 } from "../ValueObjects";
-import { EaseFn, TransformNode } from "./TransformNode";
-export declare type OnSceneRootChange = () => void;
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneObject } from "./SceneObject";
+import { EaseFn } from "./TransformNode";
+export declare const SCENE_ROOT_ID = "scene-root";
 export interface DefaultSceneRootData {
     position: [number, number, number];
     rotation: [number, number, number, number];
     scale: number;
-    id: string;
     minScale: number;
     maxScale: number;
 }
-export interface SceneRoot {
-    /**
-     * The default position of the scene root in local coordinates
-     */
-    defaultPosition: Vector3;
-    /**
-     * The default rotation of the scene root in local coordinates
-     */
-    defaultRoation: Quaternion;
-    /**
-     * The default scale of the scene root in local coordinates
-     */
-    defaultScale: Vector3;
-    /**
-     * The minimum scale allowed for the scene root
-     */
-    minScale: number;
-    /**
-     * The maximum scale allowed for the scene root
-     */
-    maxScale: number;
-    /**
-     * The identifier for the scene root
-     */
-    id: string;
-    /**
-     * Transform node for the scene root
-     */
-    transform: TransformNode;
-    /**
-     * Applies the default data to this entity. This will not trigger a notification
-     */
-    applyDefaultData: (data: DefaultSceneRootData) => void;
-    /**
-     * Smoothly moves the transform so that the point is a the world origin
-     * @param point The point to center on in world coordinates
-     * @param durationMS The duration of the transition in milliseconds
-     * @param easeFn The easing funciton
-     * @param onCompleted An optional callback function when the ease is completed
-     */
-    centerOnPoint: (point: Vector3, durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
-    /**
-     * Smoothly moves the transform so that it is back in the default pose
-     * @param durationMS The duration of the transition in milliseconds
-     * @param easeFn The easing funciton
-     * @param onCompleted An optional callback function when the ease is completed
-     */
-    lerpToDefault: (durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
-    /**
-     * Bumps the scale of the root by a specific amount. Note this will enforce the min and max limits
-     * @param amount The world amount to bump the scale by. It will be applied uniformly
-     * @param worldPoint The world position about which to apply the scaling
-     */
-    bumpScaleAboutPoint: (amount: number, worldPoint: Vector3) => void;
-    addObserver: (observer: OnSceneRootChange) => void;
-    removeObserver: (observer: OnSceneRootChange) => void;
+export declare abstract class SceneRoot extends ObservableEntity {
+    abstract defaultPosition: Vector3;
+    abstract defaultRoation: Quaternion;
+    abstract defaultScale: number;
+    abstract minScale: number;
+    abstract maxScale: number;
+    abstract id: string;
+    abstract sceneObject: SceneObject | undefined;
+    abstract position: Vector3;
+    abstract rotation: Quaternion;
+    abstract scale: number;
+    abstract applyDefaultData: (data: DefaultSceneRootData) => void;
+    abstract centerOnPoint: (point: Vector3, durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    abstract lerpToDefault: (durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    abstract bumpScaleAboutPoint: (amount: number, worldPoint: Vector3) => void;
 }
 export declare function makeSceneRoot(): SceneRoot;

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