@vived/app 3.5.0 → 3.5.1

package/lib/UseCases/FocusCamera/LerpFocusCamera.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class LerpFocusCamera {
+    constructor(focusCamera, easeFn, parameters) {
+        var _a, _b, _c;
+        this._isLerping = false;
+        this.chrono = 0;
+        this.delta = 10;
+        this.cancelLerp = () => {
+            if (!this._isLerping)
+                return;
+            clearInterval(this.interval);
+            if (this.onAbort) {
+                this.onAbort();
+            }
+            this._isLerping = false;
+        };
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta / 1000;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.easeFn(nomralizedTime);
+            this.focusCamera.radius = this.lerpRadius(percent);
+            this.focusCamera.beta = this.lerpBeta(percent);
+            this.focusCamera.alpha = this.lerpAlpha(percent);
+            const x = this.lerpX(percent);
+            const y = this.lerpY(percent);
+            const z = this.lerpZ(percent);
+            this.focusCamera.target = new ValueObjects_1.Vector3(x, y, z);
+            if (nomralizedTime >= 1) {
+                clearInterval(this.interval);
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+                this._isLerping = false;
+                this.focusCamera.lerpCompleted();
+            }
+        };
+        this.focusCamera = focusCamera;
+        this.easeFn = easeFn;
+        this.lerpDuration = parameters.duration;
+        this.onComplete = parameters.onComplete;
+        this.onAbort = parameters.onAbort;
+        this.lerpRadius = this.makeLerpNumber(this.focusCamera.radius, parameters.finalRadius);
+        this.lerpBeta = this.makeLerpNumber(this.focusCamera.beta, parameters.finalBeta);
+        this.lerpAlpha = this.makeLerpNumber(this.focusCamera.alpha, parameters.finalAlpha);
+        this.lerpX = this.makeLerpNumber(this.focusCamera.target.x, (_a = parameters.finalTarget) === null || _a === void 0 ? void 0 : _a.x);
+        this.lerpY = this.makeLerpNumber(this.focusCamera.target.y, (_b = parameters.finalTarget) === null || _b === void 0 ? void 0 : _b.y);
+        this.lerpZ = this.makeLerpNumber(this.focusCamera.target.z, (_c = parameters.finalTarget) === null || _c === void 0 ? void 0 : _c.z);
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, this.delta);
+        this.focusCamera.registerLerp(this);
+        this._isLerping = true;
+    }
+    get isLerping() {
+        return this._isLerping;
+    }
+    makeLerpNumber(initial, final) {
+        const actualFinal = final !== null && final !== void 0 ? final : initial;
+        return function Lerp(percent) {
+            const range = actualFinal - initial;
+            return initial + range * percent;
+        };
+    }
+}
+exports.LerpFocusCamera = LerpFocusCamera;

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class PinchDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousDistanceBetweenTouches;
+    private pickPoint?;
+    doDolly: (distanceBetweenTouches: number) => void;
+    initializeDolly: (distanceBetweenTouches: number, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinchDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PinchDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousDistanceBetweenTouches = 0;
+        this.doDolly = (distanceBetweenTouches) => {
+            const pinchDelta = distanceBetweenTouches - this.previousDistanceBetweenTouches;
+            const deltaRadius = pinchDelta * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+        };
+        this.initializeDolly = (distanceBetweenTouches, pickPoint) => {
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PinchDollyFocusCamera = PinchDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPosition;
+    private pickPoint?;
+    doDolly: (pixelPosition: Vector2) => void;
+    initializeDolly: (pixelPosition: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousPixelPosition = ValueObjects_1.Vector2.Zero();
+        this.doDolly = (pixelPosition) => {
+            const pixelDeltaY = pixelPosition.y - this.previousPixelPosition.y;
+            const deltaRadius = pixelDeltaY * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousPixelPosition = pixelPosition;
+        };
+        this.initializeDolly = (pixelPosition, pickPoint) => {
+            this.previousPixelPosition = pixelPosition;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PixelDollyFocusCamera = PixelDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelOrbitFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPos?;
+    private pickPoint?;
+    doOrbit: (pixelPosition: Vector2) => void;
+    initializeOrbit: (initialPixelPos: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelOrbitFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelOrbitFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.5;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.previousPixelPos) {
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
+            }
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
+            this.focusCamera.alpha += pixelChange.x * this.sensitivity;
+            this.focusCamera.beta += pixelChange.y * this.sensitivity;
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos, pickPoint) => {
+            this.previousPixelPos = initialPixelPos;
+            this.pickPoint = pickPoint;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelOrbitFocusCamera = PixelOrbitFocusCamera;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { Babylon, FocusCamera } from "../../Entities";
+import { ParametricPlane, Vector2 } from "../../ValueObjects";
+export declare class PixelPlanePanFocusCamera {
+    private focusCamera;
+    private babylon;
+    private plane?;
+    private previousPixelPos?;
+    doPan: (pixelPosition: Vector2) => void;
+    initializePan: (initialPixelPos: Vector2, panPlane: ParametricPlane) => void;
+    constructor(focusCamera: FocusCamera, babylon: Babylon);
+}

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPlanePanFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelPlanePanFocusCamera {
+    constructor(focusCamera, babylon) {
+        this.focusCamera = focusCamera;
+        this.babylon = babylon;
+        this.doPan = (pixelPosition) => {
+            if (!this.plane || !this.previousPixelPos) {
+                console.error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                return;
+            }
+            const initialRay = this.babylon.sceneRay(this.previousPixelPos);
+            const finalRay = this.babylon.sceneRay(pixelPosition);
+            const p1 = this.plane.intersectLine(initialRay);
+            const p2 = this.plane.intersectLine(finalRay);
+            if (!p1 || !p2)
+                return;
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
+            const currentTarget = this.focusCamera.target;
+            const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
+            this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializePan = (initialPixelPos, panPlane) => {
+            this.plane = panPlane;
+            this.previousPixelPos = initialPixelPos;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelPlanePanFocusCamera = PixelPlanePanFocusCamera;

package/lib/UseCases/FocusCamera/SerializeFocusCamera.d.ts

@@ -0,0 +1,22 @@
+import { FocusCamera, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeFocusCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private focusCamera;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    private applyImmediate;
+    private applyLerp;
+    constructor(focusCamera: FocusCamera, stateMachine: StateMachine);
+}
+export interface FocusCameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/FocusCamera/SerializeFocusCamera.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeFocusCamera {
+    constructor(focusCamera, stateMachine) {
+        this.name = "focusCamera";
+        this.seriliziationVersion = 1;
+        this.focusCamera = focusCamera;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.focusCamera.alpha,
+            beta: this.focusCamera.beta,
+            radius: this.focusCamera.radius,
+            target_x: this.focusCamera.target.x,
+            target_y: this.focusCamera.target.y,
+            target_z: this.focusCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializeFocusCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeFocusCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        const alpha = this.focusCamera.defaultAlpha;
+        const beta = this.focusCamera.defaultBeta;
+        const radius = this.focusCamera.defaultRadius;
+        const target = this.focusCamera.defaultTarget;
+        if (transitionDuration === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const target = new ValueObjects_1.Vector3(target_x, target_y, target_z);
+        if (transitionTime === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionTime);
+        }
+    }
+    applyImmediate(alpha, beta, radius, target) {
+        this.focusCamera.cancelLerp();
+        this.focusCamera.alpha = alpha;
+        this.focusCamera.beta = beta;
+        this.focusCamera.radius = radius;
+        this.focusCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpFocusCamera(this.focusCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializeFocusCamera = SerializeFocusCamera;

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

@@ -0,0 +1,7 @@
+export * from "./PixelPlanePanFocusCamera";
+export * from "./LerpFocusCamera";
+export * from "./SerializeFocusCamera";
+export * from "./PixelDollyFocusCamera";
+export * from "./BumpDollyFocusCamera";
+export * from "./PinchDollyFocusCamera";
+export * from "./PixelOrbitFocusCamera";

package/lib/UseCases/FocusCamera/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("./PixelPlanePanFocusCamera"), exports);
+__exportStar(require("./LerpFocusCamera"), exports);
+__exportStar(require("./SerializeFocusCamera"), exports);
+__exportStar(require("./PixelDollyFocusCamera"), exports);
+__exportStar(require("./BumpDollyFocusCamera"), exports);
+__exportStar(require("./PinchDollyFocusCamera"), exports);
+__exportStar(require("./PixelOrbitFocusCamera"), exports);

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

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

package/lib/UseCases/SceneModel/index.js

@@ -12,3 +12,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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

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

@@ -11,8 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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) {
+    return function loadNewModel(modelID, initialStateLookup) {
         return __awaiter(this, void 0, void 0, function* () {
             let sceneModel = sceneModelRepo.get(modelID);
             if (sceneModel === undefined) {
@@ -38,20 +39,21 @@ function makeLoadNewModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatc
                 const dataDTO = yield sceneModelRepo.dataLoader(modelID);
                 sceneModel.applyData(dataDTO);
                 sceneModel.getAllMeshes().forEach((meshObject) => {
-                    // let so = sceneObjectRepo.get(meshObject.id);
-                    // if (!so) {
-                    //   so = makeSceneObject(meshObject.id);
-                    //   sceneObjectRepo.add(meshObject.id, so);
-                    // }
-                    // so.transform.parent = sceneRoot.sceneObject?.transform;
-                    // meshObject.sceneObject = so;
-                    // const initialState = initialStateLookup.get(meshObject.id);
-                    // meshObject.position = initialState
-                    //   ? Vector3.FromDTO(initialState.position)
-                    //   : Vector3.Zero();
-                    // meshObject.shown = initialState ? initialState.shown : true;
-                    // so.transform.localRotation = Quaternion.Identity();
-                    // so.transform.localScale = Vector3.One();
+                    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;

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