@vived/app 2.50.1 → 2.51.0

package/lib/Entities/Babylon.d.ts

@@ -5,6 +5,7 @@ export interface ScenePick {
     hit: boolean;
     worldPickPoint?: Vector3;
     objectPickMeta?: object;
+    normal?: Vector3;
 }
 export interface IScreenshotSize {
     /**

package/lib/Entities/MemoizedColor.d.ts

@@ -0,0 +1,9 @@
+import { Color } from "../ValueObjects";
+export declare class MemoizedColor {
+    private _val;
+    get val(): Color;
+    set val(v: Color);
+    setValQuietly(val: Color): void;
+    private onChangeCallback;
+    constructor(initialValue: Color, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedColor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedColor = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class MemoizedColor {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Color.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedColor = MemoizedColor;

package/lib/Entities/ModelMesh.d.ts

@@ -0,0 +1,53 @@
+import { Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneObject } from "./SceneObject";
+export declare abstract class ModelMesh extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract position: Vector3;
+    abstract get canBeStuck(): boolean;
+    abstract stick(durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
+    abstract shown: boolean;
+    abstract meshPaths: string[];
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): ModelMeshDTO;
+    abstract applyData(data: ModelMeshDTO): void;
+    abstract readonly sceneObject: SceneObject;
+}
+export declare function makeModelMesh(dto: ModelMeshDTO, sceneObject: SceneObject): ModelMeshImp;
+declare class ModelMeshImp extends ModelMesh {
+    readonly id: string;
+    readonly sceneObject: SceneObject;
+    get label(): string;
+    set label(l: string);
+    get position(): Vector3;
+    set position(p: Vector3);
+    get shown(): boolean;
+    set shown(show: boolean);
+    get canBeStuck(): boolean;
+    stick: (durationMS: number, easeFn: (val: number) => number, onStickComplete?: (() => void) | undefined) => void;
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => ModelMeshDTO;
+    applyData: (data: ModelMeshDTO) => void;
+    constructor(dto: ModelMeshDTO, sceneObject: SceneObject);
+}
+export declare type ModelMeshDTO = ModelMeshDTOv0 | ModelMeshDTOv1;
+export interface ModelMeshDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface ModelMeshDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export {};

package/lib/Entities/ModelMesh.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelMesh = exports.ModelMesh = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const ObservableEntity_1 = require("./ObservableEntity");
+class ModelMesh extends ObservableEntity_1.ObservableEntity {
+}
+exports.ModelMesh = ModelMesh;
+function makeModelMesh(dto, sceneObject) {
+    return new ModelMeshImp(dto, sceneObject);
+}
+exports.makeModelMesh = makeModelMesh;
+class ModelMeshImp extends ModelMesh {
+    constructor(dto, sceneObject) {
+        super();
+        this.stick = (durationMS, easeFn, onStickComplete) => {
+            if (!this.canBeStuck) {
+                if (onStickComplete)
+                    onStickComplete();
+                return;
+            }
+            this.sceneObject.transform.lerp(durationMS, easeFn, ValueObjects_1.Vector3.Zero(), undefined, undefined, onStickComplete);
+        };
+        this._meshPaths = [];
+        this.addMeshPath = (path) => {
+            if (this._meshPaths.includes(path))
+                return;
+            this._meshPaths.push(path);
+            this.notify();
+        };
+        this.hasMeshPath = (path) => {
+            return this._meshPaths.includes(path);
+        };
+        this.removeMeshPath = (path) => {
+            const index = this._meshPaths.indexOf(path);
+            if (index >= 0) {
+                this._meshPaths.splice(index, 1);
+                this.notify();
+            }
+        };
+        this.toData = () => {
+            const dto = {
+                version: 1,
+                id: this.id,
+                label: this.sceneObject.name,
+                meshPaths: [...this._meshPaths],
+            };
+            return dto;
+        };
+        this.applyData = (data) => {
+            this.sceneObject.name = data.label;
+            this.meshPaths = data.meshPaths;
+        };
+        this.id = dto.id;
+        this.sceneObject = sceneObject;
+        this.sceneObject.name = dto.label;
+        this.sceneObject.addObserver(this.notify);
+        this._meshPaths = [...dto.meshPaths];
+    }
+    get label() {
+        return this.sceneObject.name;
+    }
+    set label(l) {
+        this.sceneObject.name = l;
+    }
+    get position() {
+        return this.sceneObject.position;
+    }
+    set position(p) {
+        this.sceneObject.position = p;
+    }
+    get shown() {
+        return this.sceneObject.shown;
+    }
+    set shown(show) {
+        this.sceneObject.shown = show;
+    }
+    get canBeStuck() {
+        if (ValueObjects_1.Vector3.Equal(this.sceneObject.position, ValueObjects_1.Vector3.Zero())) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    get meshPaths() {
+        return [...this._meshPaths];
+    }
+    set meshPaths(paths) {
+        let pathsHaveChanged = false;
+        if (paths.length !== this._meshPaths.length) {
+            pathsHaveChanged = true;
+        }
+        else {
+            paths.forEach((path, i) => {
+                if (path !== this._meshPaths[i]) {
+                    pathsHaveChanged = true;
+                }
+            });
+        }
+        if (!pathsHaveChanged)
+            return;
+        this._meshPaths = paths;
+        this.notify();
+    }
+}

package/lib/Entities/SceneModelObject.d.ts

@@ -0,0 +1,40 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class SceneModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract meshPaths: string[];
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): SceneModelObjectDTO;
+    abstract applyData(data: SceneModelObjectDTO): void;
+}
+export declare function makeSceneModelObject(dto: SceneModelObjectDTO): SceneObjectImp;
+declare class SceneObjectImp extends SceneModelObject {
+    readonly id: string;
+    private _label;
+    get label(): string;
+    set label(label: string);
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => SceneModelObjectDTO;
+    applyData: (data: SceneModelObjectDTO) => void;
+    constructor(dto: SceneModelObjectDTO);
+}
+export declare type SceneModelObjectDTO = SceneModelObjectDTOv0 | SceneModelObjectDTOv1;
+export interface SceneModelObjectDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface SceneModelObjectDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export {};

package/lib/Entities/SceneModelObject.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelObject = exports.SceneModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class SceneModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModelObject = SceneModelObject;
+function makeSceneModelObject(dto) {
+    return new SceneObjectImp(dto);
+}
+exports.makeSceneModelObject = makeSceneModelObject;
+class SceneObjectImp extends SceneModelObject {
+    constructor(dto) {
+        super();
+        this._label = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = [];
+        this.addMeshPath = (path) => {
+            if (this._meshPaths.includes(path))
+                return;
+            this._meshPaths.push(path);
+            this.notify();
+        };
+        this.hasMeshPath = (path) => {
+            return this._meshPaths.includes(path);
+        };
+        this.removeMeshPath = (path) => {
+            const index = this._meshPaths.indexOf(path);
+            if (index >= 0) {
+                this._meshPaths.splice(index, 1);
+                this.notify();
+            }
+        };
+        this.toData = () => {
+            const dto = {
+                version: 1,
+                id: this.id,
+                label: this.label,
+                meshPaths: [...this._meshPaths],
+            };
+            return dto;
+        };
+        this.applyData = (data) => {
+            this.label = data.label;
+            this.meshPaths = data.meshPaths;
+        };
+        this.id = dto.id;
+        this._label.setValQuietly(dto.label);
+        this._meshPaths = [...dto.meshPaths];
+    }
+    get label() {
+        return this._label.val;
+    }
+    set label(label) {
+        this._label.val = label;
+    }
+    get meshPaths() {
+        return [...this._meshPaths];
+    }
+    set meshPaths(paths) {
+        let pathsHaveChanged = false;
+        if (paths.length !== this._meshPaths.length) {
+            pathsHaveChanged = true;
+        }
+        else {
+            paths.forEach((path, i) => {
+                if (path !== this._meshPaths[i]) {
+                    pathsHaveChanged = true;
+                }
+            });
+        }
+        if (!pathsHaveChanged)
+            return;
+        this._meshPaths = paths;
+        this.notify();
+    }
+}

package/lib/PresentationManagers/SceneModel/SceneMeshOverlayPM.d.ts

@@ -12,4 +12,4 @@ export declare class SceneMeshOverlayPM extends PresentionManager {
     private vmHasChanged;
     constructor(sceneModel: SceneModel, id: string, updateView: (vm: SceneMeshOverlayColorVM) => void);
 }
-export declare const defaultSceneModelVM: SceneMeshOverlayColorVM;
+export declare const defaultSceneMeshOverlayColorVM: SceneMeshOverlayColorVM;

package/lib/PresentationManagers/SceneModel/SceneMeshOverlayPM.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultSceneModelVM = exports.SceneMeshOverlayPM = void 0;
+exports.defaultSceneMeshOverlayColorVM = exports.SceneMeshOverlayPM = void 0;
 const PresentationManager_1 = require("../PresentationManager");
 class SceneMeshOverlayPM extends PresentationManager_1.PresentionManager {
     constructor(sceneModel, id, updateView) {
@@ -29,6 +29,6 @@ class SceneMeshOverlayPM extends PresentationManager_1.PresentionManager {
     }
 }
 exports.SceneMeshOverlayPM = SceneMeshOverlayPM;
-exports.defaultSceneModelVM = {
+exports.defaultSceneMeshOverlayColorVM = {
     overlayColor: undefined,
 };

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

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

package/lib/UseCases/SceneModel/setActiveSceneModel.js

@@ -0,0 +1,90 @@
+"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.makeSetActiveModel = void 0;
+const Entities_1 = require("../../Entities");
+function makeSetActiveModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatcher) {
+    return function setActiveSceneModel(modelID) {
+        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) {
+                setSceneObjectsEnabled(sceneObjectRepo, sceneModel);
+                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.label = meshObject.label;
+                    so.transform.parent = (_a = sceneRoot.sceneObject) === null || _a === void 0 ? void 0 : _a.transform;
+                    so.notify();
+                });
+                yield sceneModelRepo.modelLoader(modelID);
+                setSceneObjectsEnabled(sceneObjectRepo, sceneModel);
+                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.makeSetActiveModel = makeSetActiveModel;
+function setSceneObjectsEnabled(sceneObjectRepo, activeModel) {
+    const allSOs = sceneObjectRepo.getAll();
+    allSOs.forEach(so => {
+        if (activeModel.hasMesh(so.id)) {
+            so.enabled = true;
+        }
+        else {
+            so.enabled = false;
+        }
+    });
+}

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;

package/lib/UseCases/SceneModel/setupSceneModelFromData.js

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

package/lib/UseCases/SceneObject/PeelSceneObjectBase.d.ts

@@ -0,0 +1,20 @@
+import { Babylon, SceneObjectsRepo, TransformNode } from "../../Entities";
+import { ParametricLine } from "../../ValueObjects";
+export declare class PeelSceneObjectBase {
+    private babylon;
+    private sceneObjectRepo;
+    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, sceneObjectRepo: SceneObjectsRepo);
+}