@vived/app 2.5.0 → 2.6.3

package/lib/Core/BaseApp/Boundary.d.ts

@@ -6,9 +6,14 @@ export interface BaseAppUC {
     setShowBabylonInspector(showInspector: boolean): void;
     addObserver(observer: BaseAppStateObserver): void;
     removeObserver(observer: BaseAppStateObserver): void;
+    setVerbose(verbose: boolean): void;
     getSerializedState(): SerializedStates;
-    setSerializedState(state: SerializedStates): void;
+    setSerializedState(state: SerializedStates, transitionTime: number): void;
+    setDefaultState(transitionTime: number): void;
     registerSerializableSystem(serializedSystem: SerializableSystem): void;
+    getIsTransitioning(): boolean;
+    abortTransition(): void;
+    setTransitionEaseFn: (easeFn: (normalizedTime: number) => number) => void;
     setHostHandler(handler: Handler): void;
     hasHostHandler(): boolean;
     dispatchOnStateChange(stateObject: object): void;
@@ -39,5 +44,6 @@ export interface SerializableSystem {
     name: string;
     seriliziationVersion: number;
     getSerializedObject(): object;
-    applySerailizedObject(state: object, version: number): void;
+    intializeStateForTransition(serializedState: object | null, version: number): void;
+    applyTransition(percent: number): void;
 }

package/lib/Core/BaseApp/Entity.d.ts

@@ -6,4 +6,6 @@ export interface BaseAppState {
     useDevicePreview: boolean;
     x: number;
     y: number;
+    isTransitioning: boolean;
+    verbose: boolean;
 }

package/lib/Core/BaseApp/UseCase.d.ts

@@ -5,29 +5,39 @@ export declare class BaseAppUCImp implements BaseAppUC {
     private observers;
     private systems;
     private serilizationVersion;
+    private currentInterval?;
+    private easeFunction;
     constructor();
-    setDevicePreview(x: number, y: number): void;
-    clearDevicePreview(): void;
-    getUseDevicePreview(): boolean;
-    getDevicePreviewSize(): {
+    setVerbose(verbose: boolean): void;
+    abortTransition: () => void;
+    setTransitionEaseFn: (easeFn: (normalizedTime: number) => number) => void;
+    getIsTransitioning: () => boolean;
+    setDevicePreview: (x: number, y: number) => void;
+    clearDevicePreview: () => void;
+    getUseDevicePreview: () => boolean;
+    getDevicePreviewSize: () => {
         x: number;
         y: number;
     };
-    setHostHandler(handler: Handler): void;
-    hasHostHandler(): boolean;
-    dispatchOnStateChange(stateObject: object): void;
-    dispatchOnStateComplete(): void;
-    dispatchSubmitResults(results: object): void;
-    dispatchGetAppAssetsURL(): string;
-    registerSerializableSystem(serializedSystem: SerializableSystem): void;
-    getSerializedState(): SerializedStates;
-    setSerializedState(state: SerializedStates): void;
-    getShowBabylonInspector(): boolean;
-    setShowBabylonInspector(showInspector: boolean): void;
-    getIsAuthoring(): boolean;
-    setIsAuthoring(isAuthoring: boolean): void;
-    addObserver(observer: BaseAppStateObserver): void;
-    removeObserver(observer: BaseAppStateObserver): void;
+    setHostHandler: (handler: Handler) => void;
+    hasHostHandler: () => boolean;
+    dispatchOnStateChange: (stateObject: object) => void;
+    dispatchOnStateComplete: () => void;
+    dispatchSubmitResults: (results: object) => void;
+    dispatchGetAppAssetsURL: () => string;
+    registerSerializableSystem: (serializedSystem: SerializableSystem) => void;
+    getSerializedState: () => SerializedStates;
+    setSerializedState: (state: SerializedStates, duration: number) => void;
+    setDefaultState: (duration: number) => void;
+    getShowBabylonInspector: () => boolean;
+    setShowBabylonInspector: (showInspector: boolean) => void;
+    getIsAuthoring: () => boolean;
+    setIsAuthoring: (isAuthoring: boolean) => void;
+    addObserver: (observer: BaseAppStateObserver) => void;
+    removeObserver: (observer: BaseAppStateObserver) => void;
+    private logToConsole;
+    private startTransition;
+    private applyTransitionToSystems;
     private notify;
     private dispatch;
 }

package/lib/Core/BaseApp/UseCase.js

@@ -8,157 +8,232 @@ class BaseAppUCImp {
         this.observers = [];
         this.systems = new Map();
         this.serilizationVersion = 2;
+        this.easeFunction = (normalizedTime) => {
+            return normalizedTime; // default to a linear function
+        };
+        this.abortTransition = () => {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+            }
+            this.appState.isTransitioning = false;
+        };
+        this.setTransitionEaseFn = (easeFn) => {
+            this.easeFunction = easeFn;
+        };
+        this.getIsTransitioning = () => {
+            return this.appState.isTransitioning;
+        };
+        this.setDevicePreview = (x, y) => {
+            if (this.appState.useDevicePreview &&
+                x === this.appState.x &&
+                y === this.appState.y) {
+                return;
+            }
+            this.appState.useDevicePreview = true;
+            this.appState.x = x;
+            this.appState.y = y;
+            this.notify();
+            this.logToConsole(`Device Preview set to ${x}, ${y}`);
+        };
+        this.clearDevicePreview = () => {
+            if (!this.appState.useDevicePreview)
+                return;
+            this.appState.useDevicePreview = false;
+            this.appState.x = -1;
+            this.appState.y = -1;
+            this.notify();
+            this.logToConsole(`Device Preview cleared`);
+        };
+        this.getUseDevicePreview = () => {
+            return this.appState.useDevicePreview;
+        };
+        this.getDevicePreviewSize = () => {
+            const { x, y } = this.appState;
+            return { x, y };
+        };
+        this.setHostHandler = (handler) => {
+            this.appState.handler = handler;
+            this.logToConsole("Handler set");
+        };
+        this.hasHostHandler = () => {
+            if (this.appState.handler) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.dispatchOnStateChange = (stateObject) => {
+            const request = {
+                type: app_host_boundary_1.ON_STATE_CHANGE,
+                version: 1,
+                payload: {
+                    stateObject,
+                },
+            };
+            this.dispatch(request);
+        };
+        this.dispatchOnStateComplete = () => {
+            const request = {
+                type: app_host_boundary_1.ON_STATE_COMPLETED,
+                version: 1,
+            };
+            this.dispatch(request);
+        };
+        this.dispatchSubmitResults = (results) => {
+            const request = {
+                type: app_host_boundary_1.SUBMIT_RESULTS,
+                version: 1,
+                payload: {
+                    results,
+                },
+            };
+            this.dispatch(request);
+        };
+        this.dispatchGetAppAssetsURL = () => {
+            var _a;
+            const callback = (url) => {
+                this.appState.appAssetsURL = url;
+            };
+            const request = {
+                type: app_host_boundary_1.GET_APP_ASSET_URL,
+                version: 1,
+                payload: {
+                    callback,
+                },
+            };
+            this.dispatch(request);
+            return (_a = this.appState.appAssetsURL) !== null && _a !== void 0 ? _a : "";
+        };
+        this.registerSerializableSystem = (serializedSystem) => {
+            if (this.systems.has(serializedSystem.name)) {
+                throw new Errors_1.DuplicateSystemNameError(serializedSystem.name);
+            }
+            this.systems.set(serializedSystem.name, serializedSystem);
+        };
+        this.getSerializedState = () => {
+            const systems = Array.from(this.systems.values());
+            const serializedStates = systems.map((system) => {
+                const state = system.getSerializedObject();
+                return {
+                    seriliziationVersion: system.seriliziationVersion,
+                    name: system.name,
+                    state,
+                };
+            });
+            return {
+                version: this.serilizationVersion,
+                systems: serializedStates,
+            };
+        };
+        this.setSerializedState = (state, duration) => {
+            if (state.version === 2) {
+                state.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.systems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.intializeStateForTransition(systemState.state, systemState.seriliziationVersion);
+                    }
+                    else {
+                        console.warn("Unable to find seriarializedSystem " + systemState.name);
+                    }
+                });
+            }
+            // Here is where we will add support for future versions
+            else {
+                throw new Errors_1.UnsupportedVersionNumber(state.version);
+            }
+            this.startTransition(duration);
+            this.logToConsole(`State set to ${JSON.stringify(state)} with a ${duration} second duration`);
+        };
+        this.setDefaultState = (duration) => {
+            this.systems.forEach((system) => {
+                system.intializeStateForTransition(null, -1);
+            });
+            this.startTransition(duration);
+            this.logToConsole(`State has been set to transition to default over ${duration} seconds`);
+        };
+        this.getShowBabylonInspector = () => {
+            return this.appState.showBabyonInspector;
+        };
+        this.setShowBabylonInspector = (showInspector) => {
+            if (this.appState.showBabyonInspector === showInspector)
+                return;
+            this.appState.showBabyonInspector = showInspector;
+            this.notify();
+            this.logToConsole(`Show Babylon Inspector set to ${showInspector}`);
+        };
+        this.getIsAuthoring = () => {
+            return this.appState.isAuthoring;
+        };
+        this.setIsAuthoring = (isAuthoring) => {
+            if (isAuthoring === this.appState.isAuthoring)
+                return;
+            this.appState.isAuthoring = isAuthoring;
+            this.notify();
+            this.logToConsole(`Is Authoring set to ${isAuthoring}`);
+        };
+        this.addObserver = (observer) => {
+            this.observers.push(observer);
+        };
+        this.removeObserver = (observer) => {
+            const index = this.observers.indexOf(observer);
+            if (index >= 0) {
+                this.observers.splice(index, 1);
+            }
+        };
         this.appState = {
             isAuthoring: false,
             showBabyonInspector: false,
             useDevicePreview: false,
             x: -1,
             y: -1,
+            isTransitioning: false,
+            verbose: false,
         };
     }
-    setDevicePreview(x, y) {
-        if (this.appState.useDevicePreview &&
-            x === this.appState.x &&
-            y === this.appState.y) {
-            return;
-        }
-        this.appState.useDevicePreview = true;
-        this.appState.x = x;
-        this.appState.y = y;
-        this.notify();
+    setVerbose(verbose) {
+        this.appState.verbose = verbose;
     }
-    clearDevicePreview() {
-        if (!this.appState.useDevicePreview)
+    logToConsole(message) {
+        if (!this.appState.verbose)
             return;
-        this.appState.useDevicePreview = false;
-        this.appState.x = -1;
-        this.appState.y = -1;
-        this.notify();
-    }
-    getUseDevicePreview() {
-        return this.appState.useDevicePreview;
-    }
-    getDevicePreviewSize() {
-        const { x, y } = this.appState;
-        return { x, y };
-    }
-    setHostHandler(handler) {
-        this.appState.handler = handler;
-    }
-    hasHostHandler() {
-        if (this.appState.handler) {
-            return true;
+        console.log("[Base App UC] " + message);
+    }
+    startTransition(duration) {
+        if (duration === 0) {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+                this.appState.isTransitioning = false;
+            }
+            this.applyTransitionToSystems(1);
         }
         else {
-            return false;
-        }
-    }
-    dispatchOnStateChange(stateObject) {
-        const request = {
-            type: app_host_boundary_1.ON_STATE_CHANGE,
-            version: 1,
-            payload: {
-                stateObject,
-            },
-        };
-        this.dispatch(request);
-    }
-    dispatchOnStateComplete() {
-        const request = {
-            type: app_host_boundary_1.ON_STATE_COMPLETED,
-            version: 1,
-        };
-        this.dispatch(request);
-    }
-    dispatchSubmitResults(results) {
-        const request = {
-            type: app_host_boundary_1.SUBMIT_RESULTS,
-            version: 1,
-            payload: {
-                results,
-            },
-        };
-        this.dispatch(request);
-    }
-    dispatchGetAppAssetsURL() {
-        var _a;
-        const callback = (url) => {
-            this.appState.appAssetsURL = url;
-        };
-        const request = {
-            type: app_host_boundary_1.GET_APP_ASSET_URL,
-            version: 1,
-            payload: {
-                callback,
-            },
-        };
-        this.dispatch(request);
-        return (_a = this.appState.appAssetsURL) !== null && _a !== void 0 ? _a : "";
-    }
-    registerSerializableSystem(serializedSystem) {
-        if (this.systems.has(serializedSystem.name)) {
-            throw new Errors_1.DuplicateSystemNameError(serializedSystem.name);
-        }
-        this.systems.set(serializedSystem.name, serializedSystem);
-    }
-    getSerializedState() {
-        const systems = Array.from(this.systems.values());
-        const serializedStates = systems.map((system) => {
-            const state = system.getSerializedObject();
-            return {
-                seriliziationVersion: system.seriliziationVersion,
-                name: system.name,
-                state,
-            };
-        });
-        return {
-            version: this.serilizationVersion,
-            systems: serializedStates,
-        };
-    }
-    setSerializedState(state) {
-        if (state.version === 2) {
-            state.systems.forEach((systemState) => {
-                const seriliazableSystem = this.systems.get(systemState.name);
-                if (seriliazableSystem) {
-                    seriliazableSystem.applySerailizedObject(systemState.state, systemState.seriliziationVersion);
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+            }
+            this.appState.isTransitioning = true;
+            const durationInMS = duration * 1000;
+            let chrono = 0;
+            const transitionDelta = 10;
+            this.currentInterval = setInterval(() => {
+                chrono = chrono + transitionDelta;
+                let normalizedTime = chrono / durationInMS;
+                if (normalizedTime > 1) {
+                    normalizedTime = 1;
                 }
-                else {
-                    console.warn("Unable to find seriarializedSystem " + systemState.name);
+                const percent = this.easeFunction(normalizedTime);
+                this.applyTransitionToSystems(percent);
+                if (normalizedTime >= 1 && this.currentInterval) {
+                    clearInterval(this.currentInterval);
+                    this.appState.isTransitioning = false;
                 }
-            });
-        }
-        // Here is where we will add support for future versions
-        else {
-            throw new Errors_1.UnsupportedVersionNumber(state.version);
+            }, transitionDelta);
         }
     }
-    getShowBabylonInspector() {
-        return this.appState.showBabyonInspector;
-    }
-    setShowBabylonInspector(showInspector) {
-        if (this.appState.showBabyonInspector === showInspector)
-            return;
-        this.appState.showBabyonInspector = showInspector;
-        this.notify();
-    }
-    getIsAuthoring() {
-        return this.appState.isAuthoring;
-    }
-    setIsAuthoring(isAuthoring) {
-        if (isAuthoring === this.appState.isAuthoring)
-            return;
-        this.appState.isAuthoring = isAuthoring;
-        this.notify();
-    }
-    addObserver(observer) {
-        this.observers.push(observer);
-    }
-    removeObserver(observer) {
-        const index = this.observers.indexOf(observer);
-        if (index >= 0) {
-            this.observers.splice(index, 1);
-        }
+    applyTransitionToSystems(percent) {
+        this.systems.forEach((system) => {
+            system.applyTransition(percent);
+        });
     }
     notify() {
         this.observers.forEach((observer) => observer.onBaseAppChange());
@@ -169,6 +244,7 @@ class BaseAppUCImp {
         }
         const handler = this.appState.handler;
         handler(request);
+        this.logToConsole(`Dispatched request: ${JSON.stringify(request)}`);
     }
 }
 exports.BaseAppUCImp = BaseAppUCImp;

package/lib/Entities/Babylon.d.ts

@@ -0,0 +1,31 @@
+import { ParametricLine, Vector3 } from ".";
+import { Vector2 } from "./Vector2";
+export declare type OnBabylonChange = () => void;
+export interface ScenePick {
+    mouseRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+}
+export declare type ScenePicker = (pixelPos: Vector2) => ScenePick;
+export declare type SceneRayer = (pixelPos: Vector2) => ParametricLine;
+export interface Babylon {
+    engine: unknown;
+    scene: unknown;
+    workingCanvas?: HTMLCanvasElement;
+    showInspector: boolean;
+    renderCanvas?: HTMLCanvasElement;
+    scenePick: (pixelPos: Vector2) => ScenePick;
+    sceneRay: (pixelPos: Vector2) => ParametricLine;
+    updateCanvasSize: () => void;
+    submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    clearRenderCanvas: () => void;
+    registerResizeEnging: (resizeEngine: () => void) => void;
+    registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerScenePicker: (picker: ScenePicker) => void;
+    registerSceneRayer: (rayer: SceneRayer) => void;
+    addObserver: (observer: OnBabylonChange) => void;
+    removeObserver: (observer: OnBabylonChange) => void;
+}
+export declare function makeBabylon(): Babylon;

package/lib/Entities/Babylon.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylon = void 0;
+const _1 = require(".");
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedVector2_1 = require("./MemoizedVector2");
+const ObserverList_1 = require("./ObserverList");
+const Vector2_1 = require("./Vector2");
+function makeBabylon() {
+    return new BabylonImp();
+}
+exports.makeBabylon = makeBabylon;
+class BabylonImp {
+    constructor() {
+        this.scenePick = () => {
+            console.warn("orignal scene picker");
+            return {
+                mouseRay: _1.ParametricLine.Forward(),
+                hit: false,
+            };
+        };
+        this.sceneRay = () => {
+            console.warn("orignal scene ray");
+            return _1.ParametricLine.Forward();
+        };
+        this.observers = new ObserverList_1.ObserverList();
+        this.updateCanvasSize = () => {
+            if (!this.workingCanvas)
+                return;
+            if (!this._renderCanvas)
+                return;
+            if (this.resizeEngine) {
+                this.resizeEngine();
+            }
+            this.workingCanvas.height = this._renderCanvas.height;
+            this.workingCanvas.width = this._renderCanvas.width;
+        };
+        this.submitRenderCanvas = (canvas) => {
+            if (canvas === this._renderCanvas)
+                return;
+            if (this._renderCanvas && this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = canvas;
+            this.updateCanvasSize();
+            if (this.startRendering) {
+                this.startRendering(canvas);
+            }
+            this.observers.notify();
+        };
+        this.clearRenderCanvas = () => {
+            if (!this._renderCanvas)
+                return;
+            if (this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = undefined;
+            this.observers.notify();
+        };
+        this.registerResizeEnging = (resizeEngine) => {
+            this.resizeEngine = resizeEngine;
+        };
+        this.registerStartRendering = (startRendering) => {
+            this.startRendering = startRendering;
+        };
+        this.registerStopRendering = (stopRendering) => {
+            this.stopRendering = stopRendering;
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+        this.registerScenePicker = (picker) => {
+            this.scenePick = picker;
+        };
+        this.registerSceneRayer = (rayer) => {
+            this.sceneRay = rayer;
+        };
+        this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(Vector2_1.Vector2.One(), this.observers.notify);
+    }
+    get showInspector() {
+        return this.memoizedShowInspector.val;
+    }
+    set showInspector(val) {
+        this.memoizedShowInspector.val = val;
+    }
+    get renderCanvas() {
+        return this._renderCanvas;
+    }
+    get canvasSize() {
+        return this.memoizedCanvasSize.getVector();
+    }
+    set canvasSize(val) {
+        this.memoizedCanvasSize.setVector(val);
+    }
+}

package/lib/Entities/BaseApp.d.ts

@@ -0,0 +1,7 @@
+export declare type OnBaseAppChange = () => void;
+export interface BaseApp {
+    isAuthoring: boolean;
+    addObserver(observer: OnBaseAppChange): void;
+    removeObserver(observer: OnBaseAppChange): void;
+}
+export declare function makeBaseApp(): BaseApp;

package/lib/Entities/BaseApp.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseApp = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const ObserverList_1 = require("./ObserverList");
+function makeBaseApp() {
+    return new BaseAppImp();
+}
+exports.makeBaseApp = makeBaseApp;
+class BaseAppImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this.memoizedIsAuthoring = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get isAuthoring() {
+        return this.memoizedIsAuthoring.val;
+    }
+    set isAuthoring(val) {
+        this.memoizedIsAuthoring.val = val;
+    }
+}

package/lib/Entities/Color.d.ts

@@ -0,0 +1,20 @@
+export declare class Color {
+    static White(): Color;
+    static Black(): Color;
+    static Red(): Color;
+    static Green(): Color;
+    static Blue(): Color;
+    static Yellow(): Color;
+    static Gray(): Color;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    get rPercent(): number;
+    get gPercent(): number;
+    get bPercent(): number;
+    get aPercent(): number;
+    equal: (otherColor: Color) => boolean;
+    copy: () => Color;
+    constructor(r: number, g: number, b: number, a?: number);
+}