@vived/app 2.16.0 → 2.18.1

package/lib/Entities/Color.js

@@ -1,59 +0,0 @@
-"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/LineSegment2D.d.ts

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

@@ -1,70 +0,0 @@
-"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/MouseSceneInput.d.ts

@@ -1,15 +0,0 @@
-export interface MouseController {
-    onClick?: (e: MouseEvent) => void;
-    onDown?: (e: MouseEvent) => void;
-    onUp?: (e: MouseEvent) => void;
-    onMove?: (e: MouseEvent) => void;
-    onWheel?: (e: WheelEvent) => void;
-}
-export interface MouseSceneInput {
-    eventElement: HTMLElement | undefined;
-    setEventElement: (eventElement: HTMLElement) => void;
-    clearInputElement: () => void;
-    registerController: (controller: MouseController) => void;
-    removeController: (controller: MouseController) => void;
-}
-export declare function makeMouseSceneInput(): MouseSceneInput;

package/lib/Entities/MouseSceneInput.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMouseSceneInput = void 0;
-const _1 = require(".");
-function makeMouseSceneInput() {
-    return new MouseSceneInputImp();
-}
-exports.makeMouseSceneInput = makeMouseSceneInput;
-class MouseSceneInputImp {
-    constructor() {
-        this.controllers = [];
-        this.maxClickMovement = 5; // pixels
-        this._eventElement = undefined;
-        this.setEventElement = (eventElement) => {
-            if (this._eventElement)
-                this.clearInputElement();
-            eventElement.addEventListener("mousedown", this.onMouseDown);
-            eventElement.addEventListener("mouseup", this.onMouseUp);
-            eventElement.addEventListener("mousemove", this.onMouseMove);
-            eventElement.addEventListener("mouseout", this.onMouseOut);
-            eventElement.addEventListener("wheel", this.onWheel);
-            this._eventElement = eventElement;
-        };
-        this.clearInputElement = () => {
-            if (!this._eventElement)
-                return;
-            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
-            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
-            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
-            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
-            this._eventElement.removeEventListener("wheel", this.onWheel);
-            this._eventElement = undefined;
-        };
-        this.registerController = (controller) => {
-            this.controllers.push(controller);
-        };
-        this.removeController = (controller) => {
-            const index = this.controllers.indexOf(controller);
-            if (index >= 0) {
-                this.controllers.splice(index, 1);
-            }
-        };
-        this.onMouseDown = (e) => {
-            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            this.controllers.forEach((c) => {
-                if (c.onDown) {
-                    c.onDown(e);
-                }
-            });
-            this.pressEvent = e;
-        };
-        this.onMouseUp = (e) => {
-            this.controllers.forEach((c) => {
-                if (c.onUp) {
-                    c.onUp(e);
-                }
-            });
-            if (!this.pressEvent)
-                return;
-            const deltaX = this.pressEvent.screenX - e.screenX;
-            const deltaY = this.pressEvent.screenY - e.screenY;
-            const delta = new _1.Vector2(deltaX, deltaY);
-            if (delta.magnitued < this.maxClickMovement) {
-                this.controllers.forEach((c) => {
-                    if (c.onClick) {
-                        c.onClick(e);
-                    }
-                });
-            }
-            this.pressEvent = undefined;
-        };
-        this.onMouseMove = (e) => {
-            this.controllers.forEach((c) => {
-                if (c.onMove) {
-                    c.onMove(e);
-                }
-            });
-            if (!this.pressEvent)
-                return;
-            const deltaX = this.pressEvent.screenX - e.screenX;
-            const deltaY = this.pressEvent.screenY - e.screenY;
-            const delta = new _1.Vector2(deltaX, deltaY);
-            if (delta.magnitued > this.maxClickMovement) {
-                this.pressEvent = undefined;
-            }
-        };
-        this.onMouseOut = (e) => {
-            if (!this.pressEvent)
-                return;
-            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            this.controllers.forEach((c) => {
-                if (c.onUp) {
-                    c.onUp(e);
-                }
-            });
-            this.pressEvent = undefined;
-        };
-        this.onWheel = (e) => {
-            this.controllers.forEach((c) => {
-                if (c.onWheel) {
-                    c.onWheel(e);
-                }
-            });
-        };
-    }
-    get eventElement() {
-        return this._eventElement;
-    }
-}

package/lib/Entities/OrbitCamera.d.ts

@@ -1,76 +0,0 @@
-import { Vector3 } from ".";
-export declare type OnOrbitCameraChange = () => void;
-export interface CameraLerper {
-    cancelLerp: () => void;
-}
-export interface CameraData {
-    defaultAlpha?: number;
-    defaultBeta?: number;
-    defaultRadius?: number;
-    defaultTarget?: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    nearClip?: number;
-    farClip?: number;
-    alphaLimit?: {
-        min: number;
-        max: number;
-    };
-    betaLimit?: {
-        min: number;
-        max: number;
-    };
-    radiusLimit?: {
-        min: number;
-        max: number;
-    };
-    targetLimit?: {
-        min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-    dollyRollSensitivity?: number;
-    dollyPixelSensitivity?: number;
-    orbitPixelSensitivity?: number;
-    dollyPinchSensitivity?: number;
-}
-export interface OrbitCamera {
-    alpha: number;
-    beta: number;
-    radius: number;
-    target: Vector3;
-    nearClip: number;
-    farClip: number;
-    defaultAlpha: number;
-    defaultBeta: number;
-    defaultRadius: number;
-    defaultTarget: Vector3;
-    dollyRollSensitivity: number;
-    dollyPixelSensitivity: number;
-    dollyPinchSensitivity: number;
-    orbitPixelSensitivity: number;
-    setAlphaLimits: (min: number, max: number) => void;
-    clearAlphaLimits: () => void;
-    setBetaLimits: (min: number, max: number) => void;
-    clearBetaLimits: () => void;
-    setRadiusLimits: (min: number, max: number) => void;
-    clearRadiusLimits: () => void;
-    setTargetLimits: (min: Vector3, max: Vector3) => void;
-    clearTargetLimits: () => void;
-    registerLerp: (lerper: CameraLerper) => void;
-    lerpCompleted: () => void;
-    cancelLerp: () => void;
-    applyData: (data: CameraData) => void;
-    addObserver: (observer: OnOrbitCameraChange) => void;
-    removeObserver: (observer: OnOrbitCameraChange) => void;
-}
-export declare function makeOrbitCamera(): OrbitCamera;

package/lib/Entities/OrbitCamera.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeOrbitCamera = void 0;
-const _1 = require(".");
-function makeOrbitCamera() {
-    return new OrbitCameraImp();
-}
-exports.makeOrbitCamera = makeOrbitCamera;
-class OrbitCameraImp {
-    constructor() {
-        this.farClip = 100;
-        this.nearClip = 0.01;
-        this.defaultAlpha = 0;
-        this.defaultBeta = 30;
-        this.defaultRadius = 8;
-        this.defaultTarget = _1.Vector3.Zero();
-        this.orbitPixelSensitivity = 0.5;
-        this.dollyPixelSensitivity = 0.01;
-        this.dollyRollSensitivity = 0.001;
-        this.dollyPinchSensitivity = 0.005;
-        this.limitRadius = false;
-        this.minRadius = 0;
-        this.maxRadius = 0;
-        this.limitAlpha = false;
-        this.minAlpha = 0;
-        this.maxAlpha = 0;
-        this.limitBeta = false;
-        this.minBeta = 0;
-        this.maxBeta = 0;
-        this.limitTarget = false;
-        this.maxTargetPosition = _1.Vector3.Zero();
-        this.minTargetPosition = _1.Vector3.Zero();
-        this.observers = new _1.ObserverList();
-        this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
-        this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
-        this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
-        this.memoizedTarget = new _1.MemoizedVector3(_1.Vector3.Zero(), this.observers.notify);
-        this.setRadiusLimits = (min, max) => {
-            if (min < 0) {
-                throw new Error("[Orbit Camera] Mininum Radius must be greater >= 0");
-            }
-            if (max < min) {
-                throw new Error("[Orbit Camera] Max radius must be >= min radius");
-            }
-            this.maxRadius = max;
-            this.minRadius = min;
-            this.limitRadius = true;
-            this.radius = this.radius;
-        };
-        this.clearRadiusLimits = () => {
-            this.maxRadius = 0;
-            this.minRadius = 0;
-            this.limitRadius = false;
-        };
-        this.setAlphaLimits = (min, max) => {
-            if (min > max) {
-                throw new Error("[Orbit Camera] Max alpha must be >= min alpha");
-            }
-            if (min < -180) {
-                throw new Error("[Orbit Camera] Min alpha must be >= -180");
-            }
-            if (max > 180) {
-                throw new Error("[Orbit Camera] Max alpha must be <= 180");
-            }
-            this.maxAlpha = max;
-            this.minAlpha = min;
-            this.limitAlpha = true;
-            this.alpha = this.alpha;
-        };
-        this.clearAlphaLimits = () => {
-            this.maxAlpha = 0;
-            this.minAlpha = 0;
-            this.limitAlpha = false;
-        };
-        this.setBetaLimits = (min, max) => {
-            if (min > max) {
-                throw new Error("[Orbit Camera] Max beta must be >= min beta");
-            }
-            if (min < -180) {
-                throw new Error("[Orbit Camera] Min beta must be >= -180");
-            }
-            if (max > 180) {
-                throw new Error("[Orbit Camera] Max beta must be <= 180");
-            }
-            this.maxBeta = max;
-            this.minBeta = min;
-            this.limitBeta = true;
-            this.beta = this.beta;
-        };
-        this.clearBetaLimits = () => {
-            this.maxBeta = 0;
-            this.minBeta = 0;
-            this.limitBeta = false;
-        };
-        this.setTargetLimits = (min, max) => {
-            const minArray = min.asArray();
-            const maxArray = max.asArray();
-            for (let i = 0; i < 3; i++) {
-                if (minArray[i] > maxArray[i]) {
-                    throw new Error("[Orbit Camera] Min target must be less than the max target");
-                }
-            }
-            this.maxTargetPosition = max;
-            this.minTargetPosition = min;
-            this.limitTarget = true;
-            this.target = this.target;
-        };
-        this.clearTargetLimits = () => {
-            this.maxTargetPosition = _1.Vector3.Zero();
-            this.minTargetPosition = _1.Vector3.Zero();
-            this.limitTarget = false;
-        };
-        this.registerLerp = (lerper) => {
-            if (this.currentLerp) {
-                this.currentLerp.cancelLerp();
-            }
-            this.currentLerp = lerper;
-        };
-        this.lerpCompleted = () => {
-            this.currentLerp = undefined;
-        };
-        this.cancelLerp = () => {
-            var _a;
-            (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
-            this.currentLerp = undefined;
-        };
-        this.applyData = (data) => {
-            if (data.defaultAlpha !== undefined) {
-                this.defaultAlpha = data.defaultAlpha;
-            }
-            if (data.defaultBeta !== undefined) {
-                this.defaultBeta = data.defaultBeta;
-            }
-            if (data.defaultRadius !== undefined) {
-                this.defaultRadius = data.defaultRadius;
-            }
-            if (data.defaultTarget !== undefined) {
-                const { x, y, z } = data.defaultTarget;
-                this.defaultTarget = new _1.Vector3(x, y, z);
-            }
-            if (data.nearClip !== undefined) {
-                this.nearClip = data.nearClip;
-            }
-            if (data.farClip !== undefined) {
-                this.farClip = data.farClip;
-            }
-            if (data.alphaLimit !== undefined) {
-                this.setAlphaLimits(data.alphaLimit.min, data.alphaLimit.max);
-            }
-            if (data.betaLimit !== undefined) {
-                this.setBetaLimits(data.betaLimit.min, data.betaLimit.max);
-            }
-            if (data.radiusLimit !== undefined) {
-                this.setRadiusLimits(data.radiusLimit.min, data.radiusLimit.max);
-            }
-            if (data.targetLimit !== undefined) {
-                const { max, min } = data.targetLimit;
-                this.setTargetLimits(new _1.Vector3(min.x, min.y, min.z), new _1.Vector3(max.x, max.y, max.z));
-            }
-            if (data.dollyRollSensitivity !== undefined) {
-                this.dollyRollSensitivity = data.dollyRollSensitivity;
-            }
-            if (data.dollyPixelSensitivity !== undefined) {
-                this.dollyPixelSensitivity = data.dollyPixelSensitivity;
-            }
-            if (data.dollyPinchSensitivity !== undefined) {
-                this.dollyPinchSensitivity = data.dollyPinchSensitivity;
-            }
-            if (data.orbitPixelSensitivity !== undefined) {
-                this.orbitPixelSensitivity = data.orbitPixelSensitivity;
-            }
-        };
-        this.addObserver = (observer) => {
-            this.observers.add(observer);
-        };
-        this.removeObserver = (observer) => {
-            this.observers.remove(observer);
-        };
-    }
-    get alpha() {
-        return this.memoizedAlpha.val;
-    }
-    set alpha(val) {
-        let clampedVal = this.clampAngle(val);
-        if (this.limitAlpha) {
-            clampedVal = Math.min(clampedVal, this.maxAlpha);
-            clampedVal = Math.max(clampedVal, this.minAlpha);
-        }
-        this.memoizedAlpha.val = clampedVal;
-    }
-    get beta() {
-        return this.memoizedBeta.val;
-    }
-    set beta(val) {
-        let clampedVal = this.clampAngle(val);
-        if (this.limitBeta) {
-            clampedVal = Math.min(clampedVal, this.maxBeta);
-            clampedVal = Math.max(clampedVal, this.minBeta);
-        }
-        this.memoizedBeta.val = clampedVal;
-    }
-    get radius() {
-        return this.memoizedRadius.val;
-    }
-    set radius(val) {
-        let clampedVal = Math.max(val, 0);
-        if (this.limitRadius) {
-            clampedVal = Math.min(clampedVal, this.maxRadius);
-            clampedVal = Math.max(clampedVal, this.minRadius);
-        }
-        this.memoizedRadius.val = clampedVal;
-    }
-    get target() {
-        return this.memoizedTarget.getVector();
-    }
-    set target(val) {
-        const targetVals = val.asArray();
-        if (this.limitTarget) {
-            const maxVals = this.maxTargetPosition.asArray();
-            const minVals = this.minTargetPosition.asArray();
-            for (let i = 0; i < 3; i++) {
-                let v = targetVals[i];
-                v = Math.min(v, maxVals[i]);
-                v = Math.max(v, minVals[i]);
-                targetVals[i] = v;
-            }
-        }
-        this.memoizedTarget.setVector(new _1.Vector3(targetVals[0], targetVals[1], targetVals[2]));
-    }
-    clampAngle(angle) {
-        const isNegative = angle < 0 ? true : false;
-        const absAngle = Math.abs(angle);
-        const revolutions = Math.floor(absAngle / 360);
-        let angleWithoutRevolutions = absAngle - revolutions * 360;
-        if (angleWithoutRevolutions > 180) {
-            angleWithoutRevolutions = angleWithoutRevolutions - 360;
-        }
-        if (isNegative) {
-            angleWithoutRevolutions *= -1;
-        }
-        return angleWithoutRevolutions;
-    }
-}

package/lib/Entities/ParametricLine.d.ts

@@ -1,29 +0,0 @@
-import { Vector3 } from "../ValueObjects/Vector3";
-export interface LineParameters {
-    x0: number;
-    y0: number;
-    z0: number;
-    a: number;
-    b: number;
-    c: number;
-}
-export declare class ParametricLine {
-    private x0;
-    private y0;
-    private z0;
-    private a;
-    private b;
-    private c;
-    static FromTwoPoint(p1: Vector3, p2: Vector3): ParametricLine;
-    static FromPointDirection(point: Vector3, direction: Vector3): ParametricLine;
-    static Forward(): ParametricLine;
-    static Backward(): ParametricLine;
-    static Up(): ParametricLine;
-    static Down(): ParametricLine;
-    static Left(): ParametricLine;
-    static Right(): ParametricLine;
-    getPointAtDistance(distance: number): Vector3;
-    getParameters(): LineParameters;
-    copy(): ParametricLine;
-    constructor(parameters: LineParameters);
-}

package/lib/Entities/ParametricLine.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParametricLine = void 0;
-const Vector3_1 = require("../ValueObjects/Vector3");
-class ParametricLine {
-    constructor(parameters) {
-        this.x0 = parameters.x0;
-        this.y0 = parameters.y0;
-        this.z0 = parameters.z0;
-        this.a = parameters.a;
-        this.b = parameters.b;
-        this.c = parameters.c;
-    }
-    static FromTwoPoint(p1, p2) {
-        const dir = Vector3_1.Vector3.subtract(p2, p1).unit;
-        return this.FromPointDirection(p1, dir);
-    }
-    static FromPointDirection(point, direction) {
-        return new ParametricLine({
-            x0: point.x,
-            y0: point.y,
-            z0: point.z,
-            a: direction.x,
-            b: direction.y,
-            c: direction.z,
-        });
-    }
-    static Forward() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(0, 0, 1);
-        return this.FromPointDirection(p, d);
-    }
-    static Backward() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(0, 0, -1);
-        return this.FromPointDirection(p, d);
-    }
-    static Up() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(0, 1, 0);
-        return this.FromPointDirection(p, d);
-    }
-    static Down() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(0, -1, 0);
-        return this.FromPointDirection(p, d);
-    }
-    static Left() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(-1, 0, 0);
-        return this.FromPointDirection(p, d);
-    }
-    static Right() {
-        const p = Vector3_1.Vector3.zero();
-        const d = new Vector3_1.Vector3(1, 0, 0);
-        return this.FromPointDirection(p, d);
-    }
-    getPointAtDistance(distance) {
-        const x = this.x0 + this.a * distance;
-        const y = this.y0 + this.b * distance;
-        const z = this.z0 + this.c * distance;
-        return new Vector3_1.Vector3(x, y, z);
-    }
-    getParameters() {
-        return {
-            x0: this.x0,
-            y0: this.y0,
-            z0: this.z0,
-            a: this.a,
-            b: this.b,
-            c: this.c,
-        };
-    }
-    copy() {
-        const parameters = this.getParameters();
-        return new ParametricLine(parameters);
-    }
-}
-exports.ParametricLine = ParametricLine;