@vived/app 2.48.0 → 2.49.0

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

package/lib/UseCases/SceneObject/PeelSceneObjectBase.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeelSceneObjectBase = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PeelSceneObjectBase {
+    constructor(babylon, sceneObjectRepo) {
+        this.babylon = babylon;
+        this.sceneObjectRepo = sceneObjectRepo;
+        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;
+            this._doPeel = false;
+            this._didPeel = false;
+            this._transformToPeel = undefined;
+            const sceneObjectID = this.babylon.sceneObjectRayPick(pickRay);
+            if (!sceneObjectID)
+                return;
+            const sceneObject = this.sceneObjectRepo.get(sceneObjectID);
+            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 = (_a = scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_b = this._peelPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this._rootPos = this._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.PeelSceneObjectBase = PeelSceneObjectBase;

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

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

package/lib/UseCases/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("./PeelSceneObjectBase"), exports);

package/lib/UseCases/SceneRoot/initializeSceneRoot.d.ts

@@ -0,0 +1,2 @@
+import { DefaultSceneRootData, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function initializeSceneRoot(defaultData: DefaultSceneRootData, sceneRoot: SceneRoot, sceneObjectRepo: SceneObjectsRepo): void;

package/lib/UseCases/SceneRoot/initializeSceneRoot.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeSceneRoot = void 0;
+const Entities_1 = require("../../Entities");
+function initializeSceneRoot(defaultData, sceneRoot, sceneObjectRepo) {
+    sceneRoot.applyDefaultData(defaultData);
+    sceneObjectRepo.add(Entities_1.SCENE_ROOT_ID, sceneRoot.sceneObject);
+}
+exports.initializeSceneRoot = initializeSceneRoot;

package/lib/ValueObjects/Color.d.ts

@@ -1,4 +1,10 @@
 export declare type BasicColor = "";
+export interface ColorDTO {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
 export declare class Color {
     /**
      * Creates a Color from RGBA values
@@ -17,6 +23,12 @@ export declare class Color {
      * @returns The Color
      */
     static RGB(r: number, g: number, b: number): Color;
+    /**
+     *
+     * @returns Creates a Color from a DTO
+     * @param data Data Transfer Object
+     */
+    static FromDTO(data: ColorDTO): Color;
     /**
      * Creates a color from a Hex value
      * @param hex The Hex string. Example '808080'
@@ -60,6 +72,11 @@ export declare class Color {
      * Returns the Color values as an array [r,g,b,a]
      */
     get array(): [number, number, number, number];
+    /**
+     * Returns the Color values as a hex
+     */
+    get hex(): string;
+    get dto(): ColorDTO;
     private clampVal;
     private constructor();
 }

package/lib/ValueObjects/Color.js

@@ -29,6 +29,14 @@ class Color {
     static RGB(r, g, b) {
         return new Color(r, g, b, 255);
     }
+    /**
+     *
+     * @returns Creates a Color from a DTO
+     * @param data Data Transfer Object
+     */
+    static FromDTO(data) {
+        return new Color(data.r, data.g, data.b, data.a);
+    }
     /**
      * Creates a color from a Hex value
      * @param hex The Hex string. Example '808080'
@@ -114,6 +122,29 @@ class Color {
     get array() {
         return [this.r, this.g, this.b, this.a];
     }
+    /**
+     * Returns the Color values as a hex
+     */
+    get hex() {
+        let r = this.r.toString(16);
+        let g = this.g.toString(16);
+        let b = this.b.toString(16);
+        if (r.length === 1)
+            r = "0" + r;
+        if (g.length === 1)
+            g = "0" + g;
+        if (b.length === 1)
+            b = "0" + b;
+        return "#" + r + g + b;
+    }
+    get dto() {
+        return {
+            a: this.a,
+            b: this.b,
+            g: this.g,
+            r: this.r,
+        };
+    }
     clampVal(val) {
         if (val > 255)
             return 255;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.48.0",
+  "version": "2.49.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/Entities/FocusCamera.d.ts

@@ -1,70 +0,0 @@
-import { Vector3 } from "../ValueObjects";
-export declare type OnFocusCameraChange = () => void;
-export interface FocusCameraLerper {
-    cancelLerp: () => void;
-}
-export interface FocusCameraData {
-    defaultAlpha?: number;
-    defaultBeta?: number;
-    defaultRadius?: number;
-    defaultTarget?: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    nearClip?: number;
-    farClip?: number;
-    alphaLimit?: {
-        min: number;
-        max: number;
-    };
-    betaLimit?: {
-        min: number;
-        max: number;
-    };
-    radiusLimit?: {
-        min: number;
-        max: number;
-    };
-    targetLimit?: {
-        min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-}
-export interface FocusCamera {
-    alpha: number;
-    beta: number;
-    radius: number;
-    target: Vector3;
-    direction: Vector3;
-    cameraPosition: Vector3;
-    nearClip: number;
-    farClip: number;
-    defaultAlpha: number;
-    defaultBeta: number;
-    defaultRadius: number;
-    defaultTarget: Vector3;
-    setAlphaLimits: (min: number, max: number) => void;
-    clearAlphaLimits: () => void;
-    setBetaLimits: (min: number, max: number) => void;
-    clearBetaLimits: () => void;
-    setRadiusLimits: (min: number, max: number) => void;
-    clearRadiusLimits: () => void;
-    setTargetLimits: (min: Vector3, max: Vector3) => void;
-    clearTargetLimits: () => void;
-    registerLerp: (lerper: FocusCameraLerper) => void;
-    lerpCompleted: () => void;
-    cancelLerp: () => void;
-    applyData: (data: FocusCameraData) => void;
-    addObserver: (observer: OnFocusCameraChange) => void;
-    removeObserver: (observer: OnFocusCameraChange) => void;
-}
-export declare function makeFocusCamera(): FocusCamera;

package/lib/Entities/FocusCamera.js

@@ -1,272 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeFocusCamera = void 0;
-const _1 = require(".");
-const ValueObjects_1 = require("../ValueObjects");
-function makeFocusCamera() {
-    return new FocusCameraImp();
-}
-exports.makeFocusCamera = makeFocusCamera;
-class FocusCameraImp {
-    constructor() {
-        this.farClip = 100;
-        this.nearClip = 0.01;
-        this.defaultAlpha = 0;
-        this.defaultBeta = 30;
-        this.defaultRadius = 8;
-        this.defaultTarget = ValueObjects_1.Vector3.Zero();
-        this.limitRadius = false;
-        this.minRadius = 0;
-        this.maxRadius = 0;
-        this.limitAlpha = false;
-        this.minAlpha = 0;
-        this.maxAlpha = 0;
-        this.limitBeta = false;
-        this.minBeta = 0;
-        this.maxBeta = 0;
-        this.limitTarget = false;
-        this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
-        this.minTargetPosition = ValueObjects_1.Vector3.Zero();
-        this.observers = new _1.ObserverList();
-        this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
-        this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
-        this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
-        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
-        this.setRadiusLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < 0) {
-                console.warn("[Orbit Camera Entity] Mininum Radius must be greater >= 0, forcing to 0");
-                minToUse = 0;
-            }
-            if (max < minToUse) {
-                console.warn(`[Orbit Camera] Max radius must be >= min radius. Forcing to ${minToUse}`);
-                maxToUse = minToUse;
-            }
-            this.maxRadius = maxToUse;
-            this.minRadius = minToUse;
-            this.limitRadius = true;
-            this.radius = this.radius;
-        };
-        this.clearRadiusLimits = () => {
-            this.maxRadius = 0;
-            this.minRadius = 0;
-            this.limitRadius = false;
-        };
-        this.setAlphaLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < -180) {
-                minToUse = -180;
-                console.warn("[Orbit Camera] Min alpha must be >= -180. Forcing to -180");
-            }
-            if (max > 180) {
-                maxToUse = 180;
-                console.warn("[Orbit Camera] Max alpha must be <= 180. Forcing to 180");
-            }
-            if (minToUse > maxToUse) {
-                const absMin = Math.abs(minToUse);
-                const absMax = Math.abs(maxToUse);
-                const closestToZero = absMin < absMax ? minToUse : maxToUse;
-                minToUse = closestToZero;
-                maxToUse = closestToZero;
-                console.warn(`[Orbit Camera] Max alpha must be <= Min Alpha. Forcing to ${closestToZero}`);
-            }
-            this.maxAlpha = maxToUse;
-            this.minAlpha = minToUse;
-            this.limitAlpha = true;
-            this.alpha = this.alpha;
-        };
-        this.clearAlphaLimits = () => {
-            this.maxAlpha = 0;
-            this.minAlpha = 0;
-            this.limitAlpha = false;
-        };
-        this.setBetaLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < -180) {
-                minToUse = -180;
-                console.warn("[Orbit Camera] Min beta must be >= -180. Forcing to -180");
-            }
-            if (max > 180) {
-                maxToUse = 180;
-                console.warn("[Orbit Camera] Max beta must be <= 180. Forcing to 180");
-            }
-            if (minToUse > maxToUse) {
-                const absMin = Math.abs(minToUse);
-                const absMax = Math.abs(maxToUse);
-                const closestToZero = absMin < absMax ? minToUse : maxToUse;
-                minToUse = closestToZero;
-                maxToUse = closestToZero;
-                console.warn(`[Orbit Camera] Max beta must be <= Min beta. Forcing to ${closestToZero}`);
-            }
-            this.maxBeta = maxToUse;
-            this.minBeta = minToUse;
-            this.limitBeta = true;
-            this.beta = this.beta;
-        };
-        this.clearBetaLimits = () => {
-            this.maxBeta = 0;
-            this.minBeta = 0;
-            this.limitBeta = false;
-        };
-        this.setTargetLimits = (min, max) => {
-            const minArray = min.array;
-            const maxArray = max.array;
-            for (let i = 0; i < 3; i++) {
-                if (minArray[i] > maxArray[i]) {
-                    console.warn("[Orbit Camera] Target limit min's components must all be <= the max. Limits not set");
-                    return;
-                }
-            }
-            this.maxTargetPosition = max;
-            this.minTargetPosition = min;
-            this.limitTarget = true;
-            this.target = this.target;
-        };
-        this.clearTargetLimits = () => {
-            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
-            this.minTargetPosition = ValueObjects_1.Vector3.Zero();
-            this.limitTarget = false;
-        };
-        this.registerLerp = (lerper) => {
-            if (this.currentLerp) {
-                this.currentLerp.cancelLerp();
-            }
-            this.currentLerp = lerper;
-        };
-        this.lerpCompleted = () => {
-            this.currentLerp = undefined;
-        };
-        this.cancelLerp = () => {
-            var _a;
-            (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
-            this.currentLerp = undefined;
-        };
-        this.applyData = (data) => {
-            if (data.defaultAlpha !== undefined) {
-                this.defaultAlpha = data.defaultAlpha;
-            }
-            if (data.defaultBeta !== undefined) {
-                this.defaultBeta = data.defaultBeta;
-            }
-            if (data.defaultRadius !== undefined) {
-                this.defaultRadius = data.defaultRadius;
-            }
-            if (data.defaultTarget !== undefined) {
-                const { x, y, z } = data.defaultTarget;
-                this.defaultTarget = new ValueObjects_1.Vector3(x, y, z);
-            }
-            if (data.nearClip !== undefined) {
-                this.nearClip = data.nearClip;
-            }
-            if (data.farClip !== undefined) {
-                this.farClip = data.farClip;
-            }
-            if (data.alphaLimit !== undefined) {
-                this.setAlphaLimits(data.alphaLimit.min, data.alphaLimit.max);
-            }
-            if (data.betaLimit !== undefined) {
-                this.setBetaLimits(data.betaLimit.min, data.betaLimit.max);
-            }
-            if (data.radiusLimit !== undefined) {
-                this.setRadiusLimits(data.radiusLimit.min, data.radiusLimit.max);
-            }
-            if (data.targetLimit !== undefined) {
-                const { max, min } = data.targetLimit;
-                this.setTargetLimits(new ValueObjects_1.Vector3(min.x, min.y, min.z), new ValueObjects_1.Vector3(max.x, max.y, max.z));
-            }
-        };
-        this.addObserver = (observer) => {
-            this.observers.add(observer);
-        };
-        this.removeObserver = (observer) => {
-            this.observers.remove(observer);
-        };
-    }
-    get alpha() {
-        return this.memoizedAlpha.val;
-    }
-    set alpha(val) {
-        let valToUse = val;
-        if (this.limitAlpha) {
-            valToUse = Math.min(valToUse, this.maxAlpha);
-            valToUse = Math.max(valToUse, this.minAlpha);
-        }
-        else {
-            valToUse = this.clampAngle(val);
-        }
-        this.memoizedAlpha.val = valToUse;
-    }
-    get beta() {
-        return this.memoizedBeta.val;
-    }
-    set beta(val) {
-        let valToUse = val;
-        if (this.limitBeta) {
-            valToUse = Math.min(valToUse, this.maxBeta);
-            valToUse = Math.max(valToUse, this.minBeta);
-        }
-        else {
-            valToUse = this.clampAngle(val);
-        }
-        this.memoizedBeta.val = valToUse;
-    }
-    get radius() {
-        return this.memoizedRadius.val;
-    }
-    set radius(val) {
-        let clampedVal = Math.max(val, 0);
-        if (this.limitRadius) {
-            clampedVal = Math.min(clampedVal, this.maxRadius);
-            clampedVal = Math.max(clampedVal, this.minRadius);
-        }
-        this.memoizedRadius.val = clampedVal;
-    }
-    get target() {
-        return this.memoizedTarget.val;
-    }
-    set target(val) {
-        const targetVals = val.array;
-        if (this.limitTarget) {
-            const maxVals = this.maxTargetPosition.array;
-            const minVals = this.minTargetPosition.array;
-            for (let i = 0; i < 3; i++) {
-                let v = targetVals[i];
-                v = Math.min(v, maxVals[i]);
-                v = Math.max(v, minVals[i]);
-                targetVals[i] = v;
-            }
-        }
-        this.memoizedTarget.val = ValueObjects_1.Vector3.FromArray(targetVals);
-    }
-    get direction() {
-        const yLength = -Math.sin(this.degToRad(this.beta));
-        const horizontalLenght = Math.cos(this.degToRad(this.beta));
-        const alphaRadians = this.degToRad(this.alpha);
-        const xLength = horizontalLenght * Math.sin(alphaRadians);
-        const zLength = horizontalLenght * Math.cos(alphaRadians);
-        return new ValueObjects_1.Vector3(xLength, yLength, zLength);
-    }
-    get cameraPosition() {
-        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
-        return ValueObjects_1.Vector3.Add(this.target, localOffset);
-    }
-    degToRad(degrees) {
-        return (degrees * Math.PI) / 180;
-    }
-    clampAngle(angle) {
-        const isNegative = angle < 0 ? true : false;
-        const absAngle = Math.abs(angle);
-        const revolutions = Math.floor(absAngle / 360);
-        let angleWithoutRevolutions = absAngle - revolutions * 360;
-        if (angleWithoutRevolutions > 180) {
-            angleWithoutRevolutions = angleWithoutRevolutions - 360;
-        }
-        if (isNegative) {
-            angleWithoutRevolutions *= -1;
-        }
-        return angleWithoutRevolutions;
-    }
-}

package/lib/Entities/MeshModel.d.ts

@@ -1,68 +0,0 @@
-import { Quaternion, Vector3 } from "../ValueObjects";
-import { ModelObject } from "./ModelObject";
-import { ObservableEntity } from "./ObservableEntity";
-export interface MeshModelData {
-    version: number;
-    objects: ObjectData[];
-    name: string;
-    description: string;
-    bounds_min: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    bounds_max: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    defaultPosition: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    defaultRotation: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    };
-    defaultScale: number;
-}
-export interface ObjectData {
-    id: string;
-    meshPaths: string[];
-    label: string;
-}
-export declare abstract class MeshModel extends ObservableEntity {
-    abstract readonly objects: ModelObject[];
-    abstract hasObject(id: string): boolean;
-    abstract getObjectById(id: string): ModelObject | undefined;
-    abstract getObjectByPath(path: string): ModelObject | undefined;
-    abstract addObject(object: ModelObject): void;
-    abstract deleteObject(id: string): void;
-    abstract get modelFile(): File | undefined;
-    abstract set modelFile(file: File | undefined);
-    abstract get version(): number;
-    abstract set version(scale: number);
-    abstract get name(): string;
-    abstract set name(name: string);
-    abstract get description(): string;
-    abstract set description(name: string);
-    abstract get image(): Blob | undefined;
-    abstract set image(image: Blob | undefined);
-    abstract get imageURL(): string | undefined;
-    abstract get bounds_min(): Vector3;
-    abstract set bounds_min(position: Vector3);
-    abstract get bounds_max(): Vector3;
-    abstract set bounds_max(position: Vector3);
-    abstract get defaultPosition(): Vector3;
-    abstract set defaultPosition(position: Vector3);
-    abstract get defaultRotation(): Quaternion;
-    abstract set defaultRotation(rotation: Quaternion);
-    abstract get defaultScale(): number;
-    abstract set defaultScale(scale: number);
-    abstract getData(): MeshModelData;
-    abstract setData(data: MeshModelData): void;
-}
-export declare function makeMeshModel(): MeshModel;