@vived/app 2.6.1 → 2.6.2

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

package/lib/Entities/Color.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+class Color {
+    constructor(r, g, b, a = 255) {
+        this.equal = (otherColor) => {
+            if (otherColor.r === this.r &&
+                otherColor.g === this.g &&
+                otherColor.b === this.b &&
+                otherColor.a === this.a) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.copy = () => {
+            return new Color(this.r, this.g, this.b, this.a);
+        };
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+    static White() {
+        return new Color(255, 255, 255, 255);
+    }
+    static Black() {
+        return new Color(0, 0, 0, 255);
+    }
+    static Red() {
+        return new Color(255, 0, 0, 255);
+    }
+    static Green() {
+        return new Color(0, 255, 0, 255);
+    }
+    static Blue() {
+        return new Color(0, 0, 255, 255);
+    }
+    static Yellow() {
+        return new Color(255, 0, 255, 255);
+    }
+    static Gray() {
+        return new Color(192, 192, 192, 255);
+    }
+    get rPercent() {
+        return this.r / 255;
+    }
+    get gPercent() {
+        return this.g / 255;
+    }
+    get bPercent() {
+        return this.b / 255;
+    }
+    get aPercent() {
+        return this.a / 255;
+    }
+}
+exports.Color = Color;

package/lib/Entities/DevicePreview.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from ".";
+export declare type OnDevicePreviewChange = () => void;
+export interface DevicePreview {
+    useDevicePreview: boolean;
+    previewSize: Vector2;
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+}
+export declare function makeDevicePreview(): DevicePreview;

package/lib/Entities/DevicePreview.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDevicePreview = void 0;
+const _1 = require(".");
+function makeDevicePreview() {
+    return new DevicePreviewImp();
+}
+exports.makeDevicePreview = makeDevicePreview;
+class DevicePreviewImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this._usePreview = false;
+        this._previewSize = _1.Vector2.Zero();
+        this.setDevicePreview = (x, y) => {
+            if (this._usePreview &&
+                this._previewSize.x === x &&
+                this._previewSize.y === y)
+                return;
+            this._usePreview = true;
+            this._previewSize.x = x;
+            this._previewSize.y = y;
+            this.observers.notify();
+        };
+        this.clearDevicePreview = () => {
+            if (!this._usePreview)
+                return;
+            this._previewSize = _1.Vector2.Zero();
+            this._usePreview = false;
+            this.observers.notify();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get useDevicePreview() {
+        return this._usePreview;
+    }
+    get previewSize() {
+        return this._previewSize.copy();
+    }
+}

package/lib/Entities/KeyboardInput.d.ts

@@ -0,0 +1,14 @@
+export declare type OnKeyDown = (key: string) => void;
+export declare type OnKeyUp = (key: string) => void;
+export interface KeyboardInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    removeEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    isKeyPressed: (key: string) => boolean;
+    addKeyDownObserver: (observer: OnKeyDown) => void;
+    removeKeyDownObserver: (observer: OnKeyDown) => void;
+    addKeyUpObserver: (observer: OnKeyUp) => void;
+    removeKeyUpObserver: (observer: OnKeyUp) => void;
+}
+export declare function makeKeyboardInput(): KeyboardInput;

package/lib/Entities/KeyboardInput.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyboardInput = void 0;
+const _1 = require(".");
+function makeKeyboardInput() {
+    return new KeyboardInputImp();
+}
+exports.makeKeyboardInput = makeKeyboardInput;
+class KeyboardInputImp {
+    constructor() {
+        this._eventElement = undefined;
+        this.setEventElement = (element) => {
+            if (this._eventElement) {
+                this._eventElement.onkeydown = null;
+                this._eventElement.onkeyup = null;
+            }
+            element.onkeydown = (e) => {
+                this.submitKeyDown(e.code);
+            };
+            element.onkeyup = (e) => {
+                this.submitKeyUp(e.code);
+            };
+            this._eventElement = element;
+        };
+        this.removeEventElement = (eventElement) => {
+            if (this._eventElement !== eventElement)
+                return;
+            this._eventElement.onkeydown = null;
+            this._eventElement.onkeyup = null;
+            this._eventElement = undefined;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.onkeydown = null;
+            this._eventElement.onkeyup = null;
+            this._eventElement = undefined;
+        };
+        this.downObservers = new _1.ObserverList();
+        this.upObservers = new _1.ObserverList();
+        this.pressedKeys = [];
+        this.submitKeyDown = (key) => {
+            if (this.pressedKeys.includes(key))
+                return;
+            this.pressedKeys.push(key);
+            this.downObservers.notify(key);
+        };
+        this.submitKeyUp = (key) => {
+            if (!this.pressedKeys.includes(key))
+                return;
+            const index = this.pressedKeys.indexOf(key);
+            if (index >= 0) {
+                this.pressedKeys.splice(index, 1);
+            }
+            this.upObservers.notify(key);
+        };
+        this.isKeyPressed = (key) => {
+            return this.pressedKeys.includes(key);
+        };
+        this.addKeyDownObserver = (observer) => {
+            this.downObservers.add(observer);
+        };
+        this.removeKeyDownObserver = (observer) => {
+            this.downObservers.remove(observer);
+        };
+        this.addKeyUpObserver = (observer) => {
+            this.upObservers.add(observer);
+        };
+        this.removeKeyUpObserver = (observer) => {
+            this.upObservers.remove(observer);
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/LineSegment2D.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from "./Vector2";
+export declare class LineSegment2D {
+    start: Vector2;
+    end: Vector2;
+    get length(): number;
+    get direction(): Vector2;
+    getPositionAtPercent(percent: number): Vector2;
+    closestPointOnLine(point: Vector2): Vector2;
+    intersect(otherLine: LineSegment2D, tolerance?: number): Vector2 | undefined;
+    constructor(start: Vector2, end: Vector2);
+}

package/lib/Entities/LineSegment2D.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineSegment2D = void 0;
+const Vector2_1 = require("./Vector2");
+class LineSegment2D {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    get length() {
+        return this.end.subtract(this.start).magnitued;
+    }
+    get direction() {
+        return this.end.subtract(this.start).unit;
+    }
+    getPositionAtPercent(percent) {
+        const dir = this.direction;
+        const length = percent * this.length;
+        dir.setLength(length);
+        return this.start.add(dir);
+    }
+    closestPointOnLine(point) {
+        // see https://monkeyproofsolutions.nl/wordpress/how-to-calculate-the-shortest-distance-between-a-point-and-a-line/
+        const direction = this.end.subtract(this.start);
+        const tNumerator = direction.dot(point.subtract(this.start));
+        const tDenominator = direction.dot(direction);
+        const t = tNumerator / tDenominator;
+        if (t < 0) {
+            return this.start.copy();
+        }
+        else if (t > 1) {
+            return this.end.copy();
+        }
+        else {
+            const length = t * direction.magnitued;
+            direction.setLength(length);
+            return this.start.add(direction);
+        }
+    }
+    intersect(otherLine, tolerance = 0) {
+        // See https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+        const x1 = this.start.x;
+        const y1 = this.start.y;
+        const x2 = this.end.x;
+        const y2 = this.end.y;
+        const x3 = otherLine.start.x;
+        const y3 = otherLine.start.y;
+        const x4 = otherLine.end.x;
+        const y4 = otherLine.end.y;
+        const denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+        if (denominator === 0) {
+            return undefined;
+        }
+        const tNumerator = (x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4);
+        const t = tNumerator / denominator;
+        const tTolearnce = tolerance / this.length;
+        if (t < -tTolearnce || t > 1 + tTolearnce) {
+            return undefined;
+        }
+        const uNumerator = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+        const u = uNumerator / denominator;
+        const uTolearnce = tolerance / otherLine.length;
+        if (u < -uTolearnce || u > 1 + uTolearnce)
+            return undefined;
+        const px = x1 + t * (x2 - x1);
+        const py = y1 + t * (y2 - y1);
+        return new Vector2_1.Vector2(px, py);
+    }
+}
+exports.LineSegment2D = LineSegment2D;

package/lib/Entities/MemoizedBoolean.d.ts

@@ -0,0 +1,7 @@
+export declare class MemoizedBoolean {
+    private _val;
+    get val(): boolean;
+    set val(b: boolean);
+    private onChangeCallback;
+    constructor(initialValue: boolean, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedBoolean.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedBoolean = void 0;
+class MemoizedBoolean {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/MemoizedNumber.d.ts

@@ -0,0 +1,7 @@
+export declare class MemoizedNumber {
+    private _val;
+    get val(): number;
+    set val(b: number);
+    private onChangeCallback;
+    constructor(initialValue: number, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedNumber.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedNumber = void 0;
+class MemoizedNumber {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedString.d.ts

@@ -0,0 +1,7 @@
+export declare class MemoizedString {
+    private _val;
+    get val(): string;
+    set val(b: string);
+    private onChangeCallback;
+    constructor(initialValue: string, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedString.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedString = void 0;
+class MemoizedString {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedString = MemoizedString;

package/lib/Entities/MemoizedVector2.d.ts

@@ -0,0 +1,12 @@
+import { Vector2 } from "./Vector2";
+export declare class MemoizedVector2 {
+    private _val;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    getVector(): Vector2;
+    setVector(vec: Vector2): void;
+    private onChangeCallback;
+    constructor(initialValue: Vector2, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedVector2.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedVector2 = void 0;
+class MemoizedVector2 {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue.copy();
+        this.onChangeCallback = onChangeCallback;
+    }
+    get x() {
+        return this._val.x;
+    }
+    set x(x) {
+        if (this._val.x === x)
+            return;
+        this._val.x = x;
+        this.onChangeCallback();
+    }
+    get y() {
+        return this._val.y;
+    }
+    set y(y) {
+        if (this._val.y === y)
+            return;
+        this._val.y = y;
+        this.onChangeCallback();
+    }
+    getVector() {
+        return this._val.copy();
+    }
+    setVector(vec) {
+        if (vec.x === this._val.x && vec.y === this._val.y)
+            return;
+        this._val = vec.copy();
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedVector2 = MemoizedVector2;

package/lib/Entities/MemoizedVector3.d.ts

@@ -0,0 +1,14 @@
+import { Vector3 } from "./Vector3";
+export declare class MemoizedVector3 {
+    private _val;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    get z(): number;
+    set z(z: number);
+    getVector(): Vector3;
+    setVector(vec: Vector3): void;
+    private onChangeCallback;
+    constructor(initialValue: Vector3, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedVector3.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedVector3 = void 0;
+class MemoizedVector3 {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue.copy();
+        this.onChangeCallback = onChangeCallback;
+    }
+    get x() {
+        return this._val.x;
+    }
+    set x(x) {
+        if (this._val.x === x)
+            return;
+        this._val.x = x;
+        this.onChangeCallback();
+    }
+    get y() {
+        return this._val.y;
+    }
+    set y(y) {
+        if (this._val.y === y)
+            return;
+        this._val.y = y;
+        this.onChangeCallback();
+    }
+    get z() {
+        return this._val.z;
+    }
+    set z(z) {
+        if (this._val.z === z)
+            return;
+        this._val.z = z;
+        this.onChangeCallback();
+    }
+    getVector() {
+        return this._val.copy();
+    }
+    setVector(vec) {
+        if (vec.x === this._val.x && vec.y === this._val.y && vec.z === this._val.z)
+            return;
+        this._val = vec.copy();
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedVector3 = MemoizedVector3;