@vived/app 2.45.0 → 2.46.0

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

@@ -1,6 +1,6 @@
 import { Quaternion, Vector3 } from "../ValueObjects";
 import { ObservableEntity } from "./ObservableEntity";
-import { SceneModelObjectDTOv1, SceneModelObjectDTOv0 as SceneModelObjectDTOv0, SceneModelObject } from "./SceneModelObject";
+import { SceneModelObjectDTOv1, SceneModelObjectDTOv0 as SceneModelObjectDTOv0, SceneModelMesh } from "./SceneModelMesh";
 export declare enum SceneModelState {
     INIT = "Initialized",
     LOADING = "Loading",
@@ -17,12 +17,12 @@ export declare abstract class SceneModel extends ObservableEntity {
     abstract defaultPosition: Vector3;
     abstract defaultRotation: Quaternion;
     abstract defaultScale: number;
-    abstract hasObject(id: string): boolean;
-    abstract getObjectById(id: string): SceneModelObject | undefined;
-    abstract getObjectByPath(path: string): SceneModelObject | undefined;
-    abstract addObject(object: SceneModelObject): void;
-    abstract removeObject(id: string): void;
-    abstract getAllObjects(): SceneModelObject[];
+    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;
 }

package/lib/Entities/SceneModel.js

@@ -7,7 +7,7 @@ const MemoizedQuaternion_1 = require("./MemoizedQuaternion");
 const MemoizedString_1 = require("./MemoizedString");
 const MemoizedVector3_1 = require("./MemoizedVector3");
 const ObservableEntity_1 = require("./ObservableEntity");
-const SceneModelObject_1 = require("./SceneModelObject");
+const SceneModelMesh_1 = require("./SceneModelMesh");
 var SceneModelState;
 (function (SceneModelState) {
     SceneModelState["INIT"] = "Initialized";
@@ -33,13 +33,13 @@ class SceneModelImp extends SceneModel {
         this._defaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
         this._state = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
         this.sceneModelObjectLookup = new Map();
-        this.hasObject = (id) => {
+        this.hasMesh = (id) => {
             return this.sceneModelObjectLookup.has(id);
         };
-        this.getObjectById = (id) => {
+        this.getMeshById = (id) => {
             return this.sceneModelObjectLookup.get(id);
         };
-        this.getObjectByPath = (path) => {
+        this.getMeshByPath = (path) => {
             let rVal;
             this.sceneModelObjectLookup.forEach((sceneModelObject) => {
                 if (sceneModelObject.hasMeshPath(path)) {
@@ -48,7 +48,7 @@ class SceneModelImp extends SceneModel {
             });
             return rVal;
         };
-        this.addObject = (object) => {
+        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);
@@ -57,7 +57,7 @@ class SceneModelImp extends SceneModel {
             object.addObserver(this.notify);
             this.notify();
         };
-        this.removeObject = (id) => {
+        this.removeMesh = (id) => {
             const orig = this.sceneModelObjectLookup.get(id);
             if (orig) {
                 this.sceneModelObjectLookup.delete(id);
@@ -65,7 +65,7 @@ class SceneModelImp extends SceneModel {
                 this.notify();
             }
         };
-        this.getAllObjects = () => {
+        this.getAllMeshes = () => {
             return Array.from(this.sceneModelObjectLookup.values());
         };
         this.applyData = (data) => {
@@ -88,7 +88,7 @@ class SceneModelImp extends SceneModel {
                 defaultRotation: this.defaultRotation.dto,
                 defaultScale: this.defaultScale,
                 name: this.name,
-                objects: this.getAllObjects().map((obj) => obj.toData()),
+                objects: this.getAllMeshes().map((obj) => obj.toData()),
             };
             return data;
         };
@@ -157,15 +157,16 @@ class SceneModelImp extends SceneModel {
                 existingObj.applyData(objectDTO);
             }
             else {
-                const newObj = SceneModelObject_1.makeSceneModelObject(objectDTO);
-                this.addObject(newObj);
+                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.removeObject(obj);
+                this.removeMesh(obj);
             }
         });
         this.notify();
@@ -184,15 +185,16 @@ class SceneModelImp extends SceneModel {
                 existingObj.applyData(objectDTO);
             }
             else {
-                const newObj = SceneModelObject_1.makeSceneModelObject(objectDTO);
-                this.addObject(newObj);
+                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.removeObject(obj);
+                this.removeMesh(obj);
             }
         });
         this.notify();

package/lib/Entities/SceneModelMesh.d.ts

@@ -0,0 +1,65 @@
+import { Vector3, Vector3DTO } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneObject } from "./SceneObject";
+export interface SceneModelMeshStateDTO {
+    id: string;
+    shown: boolean;
+    position: Vector3DTO;
+}
+export declare abstract class SceneModelMesh extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract meshPaths: string[];
+    abstract sceneObject: SceneObject | undefined;
+    abstract shown: boolean;
+    abstract position: Vector3;
+    abstract get canBeStuck(): boolean;
+    abstract stick(durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
+    abstract moveTo(position: Vector3, durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): SceneModelObjectDTO;
+    abstract applyData(data: SceneModelObjectDTO): void;
+    abstract getState(): SceneModelMeshStateDTO | null;
+}
+export declare function makeSceneModelMesh(id: string): SceneModelMeshImp;
+declare class SceneModelMeshImp extends SceneModelMesh {
+    readonly id: string;
+    private _sceneObject;
+    get sceneObject(): SceneObject | undefined;
+    set sceneObject(so: SceneObject | undefined);
+    get position(): Vector3;
+    set position(p: Vector3);
+    get canBeStuck(): boolean;
+    moveTo(position: Vector3, durationMS: number, easeFn: (val: number) => number, onMoveComplete?: () => void): void;
+    stick: (durationMS: number, easeFn: (val: number) => number, onStickComplete?: (() => void) | undefined) => void;
+    get shown(): boolean;
+    set shown(s: boolean);
+    private _label;
+    get label(): string;
+    set label(label: string);
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    getState(): SceneModelMeshStateDTO | null;
+    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,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelMesh = exports.SceneModelMesh = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedString_1 = require("./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.stick = (durationMS, easeFn, onStickComplete) => {
+            this.moveTo(ValueObjects_1.Vector3.Zero(), durationMS, easeFn, onStickComplete);
+        };
+        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 = id;
+    }
+    get sceneObject() {
+        return this._sceneObject;
+    }
+    set sceneObject(so) {
+        if (this._sceneObject) {
+            this._sceneObject.removeObserver(this.notify);
+        }
+        this._sceneObject = so;
+        if (this._sceneObject) {
+            this._sceneObject.addObserver(this.notify);
+        }
+    }
+    get position() {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return ValueObjects_1.Vector3.Zero();
+        }
+        else {
+            return this._sceneObject.transform.localPosition;
+        }
+    }
+    set position(p) {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return;
+        }
+        this._sceneObject.transform.localPosition = p;
+    }
+    get canBeStuck() {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return false;
+        }
+        if (ValueObjects_1.Vector3.Equal(this._sceneObject.transform.localPosition, ValueObjects_1.Vector3.Zero())) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    moveTo(position, durationMS, easeFn, onMoveComplete) {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return;
+        }
+        if (ValueObjects_1.Vector3.Equal(position, this.position)) {
+            if (onMoveComplete)
+                onMoveComplete();
+            return;
+        }
+        this._sceneObject.transform.lerp(durationMS, easeFn, position, undefined, undefined, onMoveComplete);
+    }
+    get shown() {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return false;
+        }
+        else {
+            return this._sceneObject.shown;
+        }
+    }
+    set shown(s) {
+        if (!this._sceneObject) {
+            console.warn("Scene Mesh doea not have a scene object");
+            return;
+        }
+        this._sceneObject.shown = s;
+    }
+    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();
+    }
+    getState() {
+        if (ValueObjects_1.Vector3.Equal(this.position, ValueObjects_1.Vector3.Zero()) && this.shown) {
+            return null;
+        }
+        else {
+            return {
+                id: this.id,
+                position: this.position.dto,
+                shown: this.shown,
+            };
+        }
+    }
+}

package/lib/Entities/SceneObject.d.ts

@@ -2,14 +2,11 @@ import { ObservableEntity } from "./ObservableEntity";
 import { TransformNode } from "./TransformNode";
 export declare abstract class SceneObject extends ObservableEntity {
     abstract readonly id: string;
-    abstract get label(): string;
-    abstract set label(label: string);
     abstract get shown(): boolean;
     abstract set shown(shown: boolean);
     abstract get enabled(): boolean;
     abstract set enabled(enabled: boolean);
-    abstract get canBeStuck(): boolean;
-    abstract stick(durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
     abstract transform: TransformNode;
+    abstract sceneTransform: unknown;
 }
 export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/SceneObject.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSceneObject = exports.SceneObject = void 0;
-const ValueObjects_1 = require("../ValueObjects");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedString_1 = require("./MemoizedString");
 const ObservableEntity_1 = require("./ObservableEntity");
@@ -20,14 +19,6 @@ class SceneObjectImp extends SceneObject {
         this.memoizedShown = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
         this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
         this.transform = TransformNode_1.makeTransformNode();
-        this.stick = (durationMS, easeFn, onStickComplete) => {
-            if (!this.canBeStuck) {
-                if (onStickComplete)
-                    onStickComplete();
-                return;
-            }
-            this.transform.lerp(durationMS, easeFn, ValueObjects_1.Vector3.Zero(), undefined, undefined, onStickComplete);
-        };
         this.id = id;
         this.transform.addObserver(this.notify);
     }
@@ -49,12 +40,4 @@ class SceneObjectImp extends SceneObject {
     set enabled(enabled) {
         this.memoizedEnabled.val = enabled;
     }
-    get canBeStuck() {
-        if (ValueObjects_1.Vector3.Equal(this.transform.localPosition, ValueObjects_1.Vector3.Zero())) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    }
 }

package/lib/Entities/SceneRoot.d.ts

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