@vived/app 4.27.0 → 4.27.1

package/lib/Entities/SceneModel.d.ts

@@ -0,0 +1,85 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneModelMesh, SceneModelObjectDTOv1, SceneModelObjectDTOv0 } from "./SceneModelMesh";
+export declare enum SceneModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+export declare abstract class SceneModel extends ObservableEntity {
+    abstract readonly id: string;
+    abstract name: string;
+    abstract state: SceneModelState;
+    abstract error: Error | undefined;
+    abstract bounds_min: Vector3;
+    abstract bounds_max: Vector3;
+    abstract defaultPosition: Vector3;
+    abstract defaultRotation: Quaternion;
+    abstract defaultScale: number;
+    abstract hasMesh(id: string): boolean;
+    abstract getMeshById(id: string): SceneModelMesh | undefined;
+    abstract getMeshByPath(path: string): SceneModelMesh | undefined;
+    abstract addMesh(object: SceneModelMesh): void;
+    abstract removeMesh(id: string): void;
+    abstract getAllMeshes(): SceneModelMesh[];
+    abstract applyData(data: SceneModelDTO): void;
+    abstract toData(): SceneModelDTO;
+}
+export declare function makeSceneModel(id: string): SceneModel;
+export declare type SceneModelDTO = SceneModelDTOV0 | SceneModelDTOv1;
+export interface SceneModelDTOV0 {
+    version: number;
+    objects: SceneModelObjectDTOv0[];
+    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 SceneModelDTOv1 {
+    version: number;
+    objects: SceneModelObjectDTOv1[];
+    name: 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;
+}

package/lib/Entities/SceneModel.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedNumber_1 = require("./Memoized/MemoizedNumber");
+const MemoizedQuaternion_1 = require("./Memoized/MemoizedQuaternion");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const MemoizedVector3_1 = require("./Memoized/MemoizedVector3");
+const ObservableEntity_1 = require("./ObservableEntity");
+const SceneModelMesh_1 = require("./SceneModelMesh");
+var SceneModelState;
+(function (SceneModelState) {
+    SceneModelState["INIT"] = "Initialized";
+    SceneModelState["LOADING"] = "Loading";
+    SceneModelState["READY"] = "Ready";
+    SceneModelState["ERROR"] = "Error";
+})(SceneModelState = exports.SceneModelState || (exports.SceneModelState = {}));
+class SceneModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModel = SceneModel;
+function makeSceneModel(id) {
+    return new SceneModelImp(id);
+}
+exports.makeSceneModel = makeSceneModel;
+class SceneModelImp extends SceneModel {
+    constructor(id) {
+        super();
+        this._name = new MemoizedString_1.MemoizedString("", this.notify);
+        this._boundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._boundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = new MemoizedQuaternion_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notify);
+        this._defaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._state = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
+        this.sceneModelObjectLookup = new Map();
+        this.hasMesh = (id) => {
+            return this.sceneModelObjectLookup.has(id);
+        };
+        this.getMeshById = (id) => {
+            return this.sceneModelObjectLookup.get(id);
+        };
+        this.getMeshByPath = (path) => {
+            let rVal;
+            this.sceneModelObjectLookup.forEach((sceneModelObject) => {
+                if (sceneModelObject.hasMeshPath(path)) {
+                    rVal = sceneModelObject;
+                }
+            });
+            return rVal;
+        };
+        this.addMesh = (object) => {
+            if (this.sceneModelObjectLookup.has(object.id)) {
+                const orig = this.sceneModelObjectLookup.get(object.id);
+                orig === null || orig === void 0 ? void 0 : orig.removeObserver(this.notify);
+            }
+            this.sceneModelObjectLookup.set(object.id, object);
+            object.addObserver(this.notify);
+            this.notify();
+        };
+        this.removeMesh = (id) => {
+            const orig = this.sceneModelObjectLookup.get(id);
+            if (orig) {
+                this.sceneModelObjectLookup.delete(id);
+                orig.removeObserver(this.notify);
+                this.notify();
+            }
+        };
+        this.getAllMeshes = () => {
+            return Array.from(this.sceneModelObjectLookup.values());
+        };
+        this.applyData = (data) => {
+            if (data.version === 0) {
+                this.applyDataV0(data);
+            }
+            else if (data.version === 1) {
+                this.applyDataV1(data);
+            }
+            else {
+                throw new Error(`applyData unsupported version number: ${data.version}`);
+            }
+        };
+        this.toData = () => {
+            const data = {
+                version: 1,
+                bounds_max: this.bounds_max.dto,
+                bounds_min: this.bounds_min.dto,
+                defaultPosition: this.defaultPosition.dto,
+                defaultRotation: this.defaultRotation.dto,
+                defaultScale: this.defaultScale,
+                name: this.name,
+                objects: this.getAllMeshes().map((obj) => obj.toData()),
+            };
+            return data;
+        };
+        this.id = id;
+    }
+    get name() {
+        return this._name.val;
+    }
+    set name(name) {
+        this._name.val = name;
+    }
+    get bounds_min() {
+        return this._boundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._boundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._defaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._defaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation.val;
+    }
+    set defaultRotation(rotation) {
+        this._defaultRotation.val = rotation;
+    }
+    get defaultScale() {
+        return this._defaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._defaultScale.val = scale;
+    }
+    get state() {
+        return this._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        this._state.val = SceneModelState.ERROR;
+    }
+    applyDataV0(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
+                newObj.applyData(objectDTO);
+                this.addMesh(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeMesh(obj);
+            }
+        });
+        this.notify();
+    }
+    applyDataV1(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
+                newObj.applyData(objectDTO);
+                this.addMesh(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeMesh(obj);
+            }
+        });
+        this.notify();
+    }
+}

package/lib/Entities/SceneModelMesh.d.ts

@@ -0,0 +1,40 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class SceneModelMesh 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 makeSceneModelMesh(id: string): SceneModelMeshImp;
+declare class SceneModelMeshImp extends SceneModelMesh {
+    readonly id: string;
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    private memoizedLabel;
+    get label(): string;
+    set label(val: string);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => SceneModelObjectDTO;
+    applyData: (data: SceneModelObjectDTO) => void;
+    constructor(id: string);
+}
+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/SceneModelMesh.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelMesh = exports.SceneModelMesh = void 0;
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class SceneModelMesh extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModelMesh = SceneModelMesh;
+function makeSceneModelMesh(id) {
+    return new SceneModelMeshImp(id);
+}
+exports.makeSceneModelMesh = makeSceneModelMesh;
+class SceneModelMeshImp extends SceneModelMesh {
+    constructor(id) {
+        super();
+        this._meshPaths = [];
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        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 = id;
+    }
+    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();
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(val) {
+        this.memoizedLabel.val = val;
+    }
+}

package/lib/Entities/SceneModelRepo.d.ts

@@ -0,0 +1,11 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneModel, SceneModelDTO } from "./SceneModel";
+export declare abstract class SceneModelRepo extends ObservableEntityRepo<SceneModel> {
+    abstract get activeModel(): SceneModel | undefined;
+    abstract activeModelID: string;
+    abstract isLoadingSceneModel: boolean;
+    abstract modelLoader(modelID: string): Promise<void>;
+    abstract dataLoader(dataID: string): Promise<SceneModelDTO>;
+    abstract clearActiveModel(): void;
+}
+export declare function makeSceneModelRepo(): SceneModelRepo;

package/lib/Entities/SceneModelRepo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelRepo = exports.SceneModelRepo = void 0;
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneModelRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneModelRepo = SceneModelRepo;
+function makeSceneModelRepo() {
+    return new SceneModelRepoImp();
+}
+exports.makeSceneModelRepo = makeSceneModelRepo;
+class SceneModelRepoImp extends SceneModelRepo {
+    constructor() {
+        super(...arguments);
+        this.memoizedActiveModelID = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedIsLoading = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+    }
+    modelLoader( /*modelID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function modelLoader has not been injected`));
+    }
+    dataLoader( /*dataID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function dataLoader has not been injected`));
+    }
+    get activeModelID() {
+        return this.memoizedActiveModelID.val;
+    }
+    set activeModelID(id) {
+        if (!this.has(id)) {
+            console.warn("[SceneModelRepo] Unknown Model ID ", id);
+            return;
+        }
+        this.memoizedActiveModelID.val = id;
+    }
+    get isLoadingSceneModel() {
+        return this.memoizedIsLoading.val;
+    }
+    set isLoadingSceneModel(val) {
+        this.memoizedIsLoading.val = val;
+    }
+    clearActiveModel() {
+        this.memoizedActiveModelID.val = "";
+    }
+    get activeModel() {
+        return this.get(this.memoizedActiveModelID.val);
+    }
+}

package/lib/Entities/SceneObject.d.ts

@@ -0,0 +1,23 @@
+import { ObservableEntity } from "./ObservableEntity";
+import { TransformNode } from "./TransformNode";
+export declare abstract class SceneObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get shown(): boolean;
+    abstract set shown(shown: boolean);
+    abstract get enabled(): boolean;
+    abstract set enabled(enabled: boolean);
+    abstract get selected(): boolean;
+    abstract set selected(selected: boolean);
+    abstract get hovered(): boolean;
+    abstract set hovered(hovered: boolean);
+    abstract get pressed(): boolean;
+    abstract set pressed(pressed: boolean);
+    abstract get defaultLabel(): string;
+    abstract set defaultLabel(defaultLabel: string);
+    abstract get customLabel(): string;
+    abstract set customLabel(customLabel: string);
+    abstract get validationMessage(): string | null;
+    abstract transform: TransformNode;
+    abstract sceneTransform: unknown;
+}
+export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/SceneObject.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObject = exports.SceneObject = void 0;
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+const TransformNode_1 = require("./TransformNode");
+class SceneObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneObject = SceneObject;
+function makeSceneObject(id) {
+    return new SceneObjectImp(id);
+}
+exports.makeSceneObject = makeSceneObject;
+class SceneObjectImp extends SceneObject {
+    constructor(id) {
+        super();
+        this.memoizedDefaultLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedCustomLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedShown = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.memoizedSelected = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.memoizedHovered = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.memoizedPressed = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.transform = TransformNode_1.makeTransformNode();
+        this.id = id;
+        this.transform.addObserver(this.notify);
+    }
+    get defaultLabel() {
+        return this.memoizedDefaultLabel.val;
+    }
+    set defaultLabel(defaultLabel) {
+        this.memoizedDefaultLabel.val = defaultLabel;
+    }
+    get customLabel() {
+        return this.memoizedCustomLabel.val;
+    }
+    set customLabel(customLabel) {
+        this.memoizedCustomLabel.val = customLabel;
+    }
+    get validationMessage() {
+        if (this.customLabel.length > 40) {
+            return "Object labels are limited to 40 characters";
+        }
+        else {
+            return null;
+        }
+    }
+    get shown() {
+        return this.memoizedShown.val;
+    }
+    set shown(shown) {
+        this.memoizedShown.val = shown;
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(enabled) {
+        this.memoizedEnabled.val = enabled;
+    }
+    get selected() {
+        return this.memoizedSelected.val;
+    }
+    set selected(selected) {
+        this.memoizedSelected.val = selected;
+    }
+    get hovered() {
+        return this.memoizedHovered.val;
+    }
+    set hovered(hovered) {
+        this.memoizedHovered.val = hovered;
+    }
+    get pressed() {
+        return this.memoizedPressed.val;
+    }
+    set pressed(pressed) {
+        this.memoizedPressed.val = pressed;
+    }
+}

package/lib/Entities/SceneObjectsRepo.d.ts

@@ -0,0 +1,12 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneObject } from "./SceneObject";
+export declare abstract class SceneObjectsRepo extends ObservableEntityRepo<SceneObject> {
+    abstract get pressedSceneObject(): string | null;
+    abstract set pressedSceneObject(sceneObjectId: string | null);
+    abstract get hoveredSceneObject(): string | null;
+    abstract set hoveredSceneObject(sceneObjectId: string | null);
+    abstract unselectAllSceneObjects: () => void;
+    abstract getSelectedSceneObjects: () => SceneObject[];
+    abstract selectSceneObject: (id: string) => void;
+}
+export declare function makeSceneObjectRepo(): SceneObjectsRepo;

package/lib/Entities/SceneObjectsRepo.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObjectRepo = exports.SceneObjectsRepo = void 0;
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneObjectsRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneObjectsRepo = SceneObjectsRepo;
+function makeSceneObjectRepo() {
+    return new SceneObjectsRepoImp();
+}
+exports.makeSceneObjectRepo = makeSceneObjectRepo;
+class SceneObjectsRepoImp extends SceneObjectsRepo {
+    constructor() {
+        super(...arguments);
+        this._pressedSceneObject = null;
+        this._hoveredSceneObject = null;
+        this.unselectAllSceneObjects = () => {
+            this.getAll().forEach(sceneObject => {
+                sceneObject.selected = false;
+            });
+        };
+        this.getSelectedSceneObjects = () => {
+            const selectedObjects = [];
+            this.getAll().forEach(sceneObject => {
+                if (sceneObject.selected) {
+                    selectedObjects.push(sceneObject);
+                }
+            });
+            return selectedObjects;
+        };
+        this.selectSceneObject = (id) => {
+            const sceneObject = this.get(id);
+            if (sceneObject) {
+                sceneObject.selected = true;
+            }
+        };
+    }
+    get pressedSceneObject() {
+        return this._pressedSceneObject;
+    }
+    set pressedSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._pressedSceneObject) {
+            return;
+        }
+        this._pressedSceneObject = sceneObjectId;
+        this.notify();
+    }
+    get hoveredSceneObject() {
+        return this._hoveredSceneObject;
+    }
+    set hoveredSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._hoveredSceneObject) {
+            return;
+        }
+        this._hoveredSceneObject = sceneObjectId;
+        this.notify();
+    }
+}

package/lib/Entities/SceneRoot.d.ts

@@ -0,0 +1,29 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+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;
+    minScale: number;
+    maxScale: number;
+}
+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;