@vived/app 3.7.0 → 3.9.0

package/lib/Entities/MeshModel.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMeshModel = exports.MeshModel = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const MemoizedNumber_1 = require("./MemoizedNumber");
-const MemoizedString_1 = require("./MemoizedString");
-const MemoizedVector3_1 = require("./MemoizedVector3");
-const ModelObject_1 = require("./ModelObject");
-const ObservableEntity_1 = require("./ObservableEntity");
-class MeshModel extends ObservableEntity_1.ObservableEntity {
-}
-exports.MeshModel = MeshModel;
-function makeMeshModel() {
-    return new MeshModelImp();
-}
-exports.makeMeshModel = makeMeshModel;
-class MeshModelImp extends MeshModel {
-    constructor() {
-        super(...arguments);
-        this.objects = [];
-        this._modelFile = undefined;
-        this._memoizedVersion = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
-        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
-        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
-        this._image = undefined;
-        this._memoizedBoundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._memoizedBoundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._memoizedDefaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
-        this._memoizedDefaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
-        this._imageURL = undefined;
-    }
-    hasObject(id) {
-        return !!this.objects.find((obj) => obj.id === id);
-    }
-    getObjectById(id) {
-        return this.objects.find((obj) => obj.id === id);
-    }
-    getObjectByPath(path) {
-        let rVal;
-        this.objects.forEach((obj) => {
-            if (obj.meshPaths.includes(path)) {
-                rVal = obj;
-            }
-        });
-        return rVal;
-    }
-    addObject(object) {
-        object.addObserver(this.notify);
-        this.objects.push(object);
-        this.notify();
-    }
-    deleteObject(id) {
-        this.objects = this.objects.filter((obj) => {
-            if (obj.id === id) {
-                obj.removeObserver(this.notify);
-                return false;
-            }
-            return true;
-        });
-        this.notify();
-    }
-    get modelFile() {
-        return this._modelFile;
-    }
-    set modelFile(file) {
-        this._modelFile = file;
-        this.notify();
-    }
-    get version() {
-        return this._memoizedVersion.val;
-    }
-    set version(version) {
-        this._memoizedVersion.val = version;
-    }
-    get name() {
-        return this._memoizedName.val;
-    }
-    set name(name) {
-        this._memoizedName.val = name;
-    }
-    get description() {
-        return this._memoizedDescription.val;
-    }
-    set description(description) {
-        this._memoizedDescription.val = description;
-    }
-    get image() {
-        return this._image;
-    }
-    set image(image) {
-        if (!this._image && !image)
-            return;
-        if (this._image && image && this._image.size === image.size)
-            return;
-        this._image = image;
-        if (image === undefined) {
-            this._imageURL = undefined;
-        }
-        else {
-            this._imageURL = URL.createObjectURL(image);
-        }
-        this.notify();
-    }
-    get imageURL() {
-        return this._imageURL;
-    }
-    get bounds_min() {
-        return this._memoizedBoundsMin.val;
-    }
-    set bounds_min(bounds_min) {
-        this._memoizedBoundsMin.val = bounds_min;
-    }
-    get bounds_max() {
-        return this._memoizedBoundsMax.val;
-    }
-    set bounds_max(bounds_max) {
-        this._memoizedBoundsMax.val = bounds_max;
-    }
-    get defaultPosition() {
-        return this._memoizedDefaultPosition.val;
-    }
-    set defaultPosition(position) {
-        this._memoizedDefaultPosition.val = position;
-    }
-    get defaultRotation() {
-        return this._defaultRotation;
-    }
-    set defaultRotation(rotation) {
-        if (ValueObjects_1.Quaternion.Equal(this._defaultRotation, rotation))
-            return;
-        this._defaultRotation = rotation;
-        this.notify();
-    }
-    get defaultScale() {
-        return this._memoizedDefaultScale.val;
-    }
-    set defaultScale(scale) {
-        this._memoizedDefaultScale.val = scale;
-    }
-    getData() {
-        return {
-            version: this.version,
-            objects: this.objects.map((obj) => ({
-                id: obj.id,
-                label: obj.label,
-                meshPaths: [...obj.meshPaths],
-            })),
-            name: this.name,
-            description: this.description,
-            bounds_min: this.bounds_min,
-            bounds_max: this.bounds_max,
-            defaultPosition: this.defaultPosition,
-            defaultRotation: this.defaultRotation,
-            defaultScale: this.defaultScale,
-        };
-    }
-    setData(data) {
-        this.version = data.version;
-        data.objects.forEach((obj) => {
-            const modelObject = ModelObject_1.makeModelObject(obj.id);
-            modelObject.label = obj.label;
-            obj.meshPaths.forEach((path) => modelObject.addMeshPath(path));
-            this.addObject(modelObject);
-        });
-        this.name = data.name;
-        this.description = data.description;
-        this.bounds_min = data.bounds_min;
-        this.bounds_max = data.bounds_max;
-        this.defaultPosition = data.defaultPosition;
-        this.defaultRotation = data.defaultRotation;
-        this.defaultScale = data.defaultScale;
-    }
-}

package/lib/Entities/ModelObject.d.ts

@@ -1,10 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-export declare abstract class ModelObject extends ObservableEntity {
-    abstract readonly id: string;
-    abstract get label(): string;
-    abstract set label(label: string);
-    abstract get meshPaths(): string[];
-    abstract addMeshPath(path: string): void;
-    abstract removeMeshPath(path: string): void;
-}
-export declare function makeModelObject(id: string): ModelObject;

package/lib/Entities/ModelObject.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeModelObject = exports.ModelObject = void 0;
-const MemoizedString_1 = require("./MemoizedString");
-const ObservableEntity_1 = require("./ObservableEntity");
-class ModelObject extends ObservableEntity_1.ObservableEntity {
-}
-exports.ModelObject = ModelObject;
-function makeModelObject(id) {
-    return new ModelObjectImp(id);
-}
-exports.makeModelObject = makeModelObject;
-class ModelObjectImp extends ModelObject {
-    constructor(id) {
-        super();
-        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this._meshPaths = new Set([]);
-        this.id = id;
-    }
-    get label() {
-        return this.memoizedLabel.val;
-    }
-    set label(label) {
-        this.memoizedLabel.val = label;
-    }
-    get meshPaths() {
-        return Array.from(this._meshPaths);
-    }
-    addMeshPath(path) {
-        if (this._meshPaths.has(path)) {
-            return;
-        }
-        this._meshPaths.add(path);
-        this.notify();
-    }
-    removeMeshPath(path) {
-        if (this._meshPaths.has(path)) {
-            this._meshPaths.delete(path);
-            this.notify();
-        }
-    }
-}

package/lib/Entities/SceneRoot.d.ts

@@ -1,29 +0,0 @@
-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;

package/lib/Entities/SceneRoot.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneRoot = exports.SceneRoot = exports.SCENE_ROOT_ID = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const ObservableEntity_1 = require("./ObservableEntity");
-exports.SCENE_ROOT_ID = "scene-root";
-class SceneRoot extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneRoot = SceneRoot;
-function makeSceneRoot() {
-    return new SceneRootImp();
-}
-exports.makeSceneRoot = makeSceneRoot;
-class SceneRootImp extends SceneRoot {
-    constructor() {
-        super(...arguments);
-        this._defaultPosition = ValueObjects_1.Vector3.Zero();
-        this._defaultRoation = ValueObjects_1.Quaternion.Identity();
-        this._defaultScale = 1;
-        this._minScale = 0.01;
-        this._maxScale = 10;
-        this.applyDefaultData = (data) => {
-            this._defaultPosition = ValueObjects_1.Vector3.FromArray(data.position);
-            this._defaultRoation = ValueObjects_1.Quaternion.FromArray(data.rotation);
-            this._defaultScale = data.scale;
-            this._maxScale = data.maxScale;
-            this._minScale = data.minScale;
-        };
-        this.centerOnPoint = (point, durationMS, easeFn, onCompleted) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            const finalPosition = ValueObjects_1.Vector3.Subtract(this.sceneObject.transform.worldPosition, point);
-            this.sceneObject.transform.lerp(durationMS, easeFn, finalPosition, undefined, undefined, onCompleted);
-        };
-        this.bumpScaleAboutPoint = (amount, worldPoint) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            const localPickOffset = this.sceneObject.transform.worldPointToLocal(worldPoint);
-            const currentScale = this.sceneObject.transform.worldScale.x;
-            let newScale = currentScale + amount;
-            if (newScale < this.minScale) {
-                newScale = this.minScale;
-            }
-            else if (newScale > this.maxScale) {
-                newScale = this.maxScale;
-            }
-            this.sceneObject.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
-            const worldPickOffset = this.sceneObject.transform.localPointToWorld(localPickOffset);
-            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
-            this.sceneObject.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.sceneObject.transform.worldPosition);
-        };
-        this.lerpToDefault = (durationMS, easeFn, onCompleted) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            this.sceneObject.transform.lerp(durationMS, easeFn, this.defaultPosition, this.defaultRoation, new ValueObjects_1.Vector3(this.defaultScale, this.defaultScale, this.defaultScale), onCompleted);
-        };
-    }
-    get position() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localPosition;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return ValueObjects_1.Vector3.Zero();
-        }
-    }
-    set position(p) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localPosition = p;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    get rotation() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localRotation;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return ValueObjects_1.Quaternion.Identity();
-        }
-    }
-    set rotation(r) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localRotation = r;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    get scale() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localScale.x;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return 1;
-        }
-    }
-    set scale(s) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localScale = new ValueObjects_1.Vector3(s, s, s);
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    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 defaultPosition() {
-        return this._defaultPosition;
-    }
-    get defaultRoation() {
-        return this._defaultRoation;
-    }
-    get defaultScale() {
-        return this._defaultScale;
-    }
-    get minScale() {
-        return this._minScale;
-    }
-    get maxScale() {
-        return this._maxScale;
-    }
-    get id() {
-        return exports.SCENE_ROOT_ID;
-    }
-}

package/lib/PresentationManagers/FocusCameraPM.d.ts

@@ -1,15 +0,0 @@
-import { FocusCamera } from "../Entities";
-import { Vector3 } from "../ValueObjects";
-export interface FocusCameraVM {
-    alphaEuler: Vector3;
-    betaEuler: Vector3;
-    cameraLocalPosition: Vector3;
-    target: Vector3;
-}
-export declare class FocusCameraPM {
-    private orbitCam;
-    private view;
-    dispose(): void;
-    private doUpdateView;
-    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraVM) => void);
-}

package/lib/PresentationManagers/FocusCameraPM.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FocusCameraPM = void 0;
-const Utilities_1 = require("../Utilities");
-const ValueObjects_1 = require("../ValueObjects");
-class FocusCameraPM {
-    constructor(orbitCamera, view) {
-        this.doUpdateView = () => {
-            const { alpha, beta, radius, target } = this.orbitCam;
-            const alphaRadians = Utilities_1.degreesToRadians(alpha);
-            const alphaEuler = new ValueObjects_1.Vector3(0, alphaRadians, 0);
-            const betaRadians = Utilities_1.degreesToRadians(beta);
-            const betaEuler = new ValueObjects_1.Vector3(betaRadians, 0, 0);
-            const cameraLocalPosition = new ValueObjects_1.Vector3(0, 0, -radius);
-            this.view({
-                alphaEuler,
-                betaEuler,
-                cameraLocalPosition,
-                target,
-            });
-        };
-        this.orbitCam = orbitCamera;
-        this.view = view;
-        this.doUpdateView();
-        this.orbitCam.addObserver(this.doUpdateView);
-    }
-    dispose() {
-        this.orbitCam.removeObserver(this.doUpdateView);
-    }
-}
-exports.FocusCameraPM = FocusCameraPM;

package/lib/PresentationManagers/FocusCameraPosRotPM.d.ts

@@ -1,13 +0,0 @@
-import { FocusCamera } from "../Entities";
-import { Vector3 } from "../ValueObjects";
-export interface FocusCameraPosRotVM {
-    position: Vector3;
-    rotation: Vector3;
-}
-export declare class FocusCameraPosRotPM {
-    private focusCam;
-    private view;
-    dispose(): void;
-    private doUpdateView;
-    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraPosRotVM) => void);
-}

package/lib/PresentationManagers/FocusCameraPosRotPM.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FocusCameraPosRotPM = void 0;
-const Utilities_1 = require("../Utilities");
-const ValueObjects_1 = require("../ValueObjects");
-class FocusCameraPosRotPM {
-    constructor(orbitCamera, view) {
-        this.doUpdateView = () => {
-            const { alpha, beta } = this.focusCam;
-            const alphaRadians = Utilities_1.degreesToRadians(alpha);
-            const betaRadians = Utilities_1.degreesToRadians(beta);
-            const position = this.focusCam.cameraPosition;
-            const rotation = new ValueObjects_1.Vector3(betaRadians, alphaRadians, 0);
-            this.view({
-                position,
-                rotation,
-            });
-        };
-        this.focusCam = orbitCamera;
-        this.view = view;
-        this.doUpdateView();
-        this.focusCam.addObserver(this.doUpdateView);
-    }
-    dispose() {
-        this.focusCam.removeObserver(this.doUpdateView);
-    }
-}
-exports.FocusCameraPosRotPM = FocusCameraPosRotPM;

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

@@ -1,15 +0,0 @@
-import { Color, SceneModel } from "../../Entities";
-import { PresentionManager } from "../PresentationManager";
-export interface SceneMeshOverlayColorVM {
-    overlayColor: Color | undefined;
-}
-export declare class SceneMeshOverlayPM extends PresentionManager {
-    private sceneModel;
-    private id;
-    private updateView;
-    private previousVM?;
-    doUpdateView: () => void;
-    private vmHasChanged;
-    constructor(sceneModel: SceneModel, id: string, updateView: (vm: SceneMeshOverlayColorVM) => void);
-}
-export declare const defaultSceneModelVM: SceneMeshOverlayColorVM;

package/lib/PresentationManagers/SceneModel/SceneMeshOverlayPM.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultSceneModelVM = exports.SceneMeshOverlayPM = void 0;
-const PresentationManager_1 = require("../PresentationManager");
-class SceneMeshOverlayPM extends PresentationManager_1.PresentionManager {
-    constructor(sceneModel, id, updateView) {
-        super(sceneModel);
-        this.sceneModel = sceneModel;
-        this.id = id;
-        this.updateView = updateView;
-        this.doUpdateView = () => {
-            const sceneModelMesh = this.sceneModel.getMeshById(this.id);
-            const vm = {
-                overlayColor: sceneModelMesh === null || sceneModelMesh === void 0 ? void 0 : sceneModelMesh.overlayColor,
-            };
-            if (!this.vmHasChanged(vm))
-                return;
-            this.updateView(vm);
-            this.previousVM = vm;
-        };
-        this.doUpdateView();
-    }
-    vmHasChanged(vm) {
-        if (this.previousVM === undefined)
-            return true;
-        if (this.previousVM.overlayColor !== vm.overlayColor)
-            return true;
-        return false;
-    }
-}
-exports.SceneMeshOverlayPM = SceneMeshOverlayPM;
-exports.defaultSceneModelVM = {
-    overlayColor: undefined,
-};

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

@@ -1,17 +0,0 @@
-import { FocusCamera } from "../../Entities";
-import { Vector3 } from "../../ValueObjects";
-export declare class BumpDollyFocusCamera {
-    private focusCamera;
-    bumpDurationMS: number;
-    bumpLerp: (percent: number) => number;
-    bumpAmount: number;
-    private interval?;
-    private chrono;
-    private delta;
-    private initialRadius;
-    private finalRadius;
-    private pickPoint?;
-    private onTick;
-    bump(direction: "IN" | "OUT", target?: Vector3): void;
-    constructor(focusCamera: FocusCamera);
-}

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BumpDollyFocusCamera = void 0;
-const ValueObjects_1 = require("../../ValueObjects");
-class BumpDollyFocusCamera {
-    constructor(focusCamera) {
-        this.focusCamera = focusCamera;
-        this.bumpDurationMS = 500;
-        this.bumpLerp = (p) => {
-            return p;
-        }; // Linear
-        this.bumpAmount = 0.1;
-        this.chrono = 0;
-        this.delta = 10;
-        this.initialRadius = 0;
-        this.finalRadius = 0;
-        this.onTick = () => {
-            this.chrono = this.chrono + this.delta;
-            let nomralizedTime = this.chrono / this.bumpDurationMS;
-            if (nomralizedTime > 1) {
-                nomralizedTime = 1;
-            }
-            const percent = this.bumpLerp(nomralizedTime);
-            const range = this.finalRadius - this.initialRadius;
-            const currentRadius = this.focusCamera.radius;
-            this.focusCamera.radius = this.initialRadius + range * percent;
-            if (this.pickPoint !== undefined) {
-                const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
-                const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
-                this.focusCamera.target = newTargetPos;
-            }
-            if (nomralizedTime >= 1 && this.interval) {
-                this.focusCamera.radius = this.finalRadius;
-                clearInterval(this.interval);
-                this.interval = undefined;
-                this.pickPoint = undefined;
-            }
-        };
-    }
-    bump(direction, target) {
-        let delta = this.bumpAmount;
-        if (direction === "IN") {
-            delta *= -1;
-        }
-        this.initialRadius = this.focusCamera.radius;
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = undefined;
-            this.finalRadius = this.finalRadius + delta;
-        }
-        else {
-            this.finalRadius = this.initialRadius + delta;
-        }
-        this.chrono = 0;
-        this.pickPoint = target;
-        this.interval = setInterval(() => {
-            this.onTick();
-        }, 10);
-    }
-}
-exports.BumpDollyFocusCamera = BumpDollyFocusCamera;

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

@@ -1,36 +0,0 @@
-import { FocusCamera } from "../../Entities";
-export interface LerpFocusCameraParameters {
-    duration: number;
-    finalRadius?: number;
-    finalBeta?: number;
-    finalAlpha?: number;
-    finalTarget?: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    onComplete?: () => void;
-    onAbort?: () => void;
-}
-export declare class LerpFocusCamera {
-    get isLerping(): boolean;
-    private _isLerping;
-    private focusCamera;
-    private easeFn;
-    private lerpDuration;
-    private lerpRadius;
-    private lerpBeta;
-    private lerpAlpha;
-    private lerpX;
-    private lerpY;
-    private lerpZ;
-    private onComplete?;
-    private onAbort?;
-    private interval;
-    private chrono;
-    private delta;
-    cancelLerp: () => void;
-    private onTick;
-    constructor(focusCamera: FocusCamera, easeFn: (normalizedTime: number) => number, parameters: LerpFocusCameraParameters);
-    private makeLerpNumber;
-}