@vived/app 2.29.0 → 2.30.0

package/lib/Entities/FocusCamera.js

@@ -1,272 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeFocusCamera = void 0;
-const _1 = require(".");
-const ValueObjects_1 = require("../ValueObjects");
-function makeFocusCamera() {
-    return new FocusCameraImp();
-}
-exports.makeFocusCamera = makeFocusCamera;
-class FocusCameraImp {
-    constructor() {
-        this.farClip = 100;
-        this.nearClip = 0.01;
-        this.defaultAlpha = 0;
-        this.defaultBeta = 30;
-        this.defaultRadius = 8;
-        this.defaultTarget = ValueObjects_1.Vector3.Zero();
-        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 = ValueObjects_1.Vector3.Zero();
-        this.minTargetPosition = ValueObjects_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(ValueObjects_1.Vector3.Zero(), this.observers.notify);
-        this.setRadiusLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < 0) {
-                console.warn("[Orbit Camera Entity] Mininum Radius must be greater >= 0, forcing to 0");
-                minToUse = 0;
-            }
-            if (max < minToUse) {
-                console.warn(`[Orbit Camera] Max radius must be >= min radius. Forcing to ${minToUse}`);
-                maxToUse = minToUse;
-            }
-            this.maxRadius = maxToUse;
-            this.minRadius = minToUse;
-            this.limitRadius = true;
-            this.radius = this.radius;
-        };
-        this.clearRadiusLimits = () => {
-            this.maxRadius = 0;
-            this.minRadius = 0;
-            this.limitRadius = false;
-        };
-        this.setAlphaLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < -180) {
-                minToUse = -180;
-                console.warn("[Orbit Camera] Min alpha must be >= -180. Forcing to -180");
-            }
-            if (max > 180) {
-                maxToUse = 180;
-                console.warn("[Orbit Camera] Max alpha must be <= 180. Forcing to 180");
-            }
-            if (minToUse > maxToUse) {
-                const absMin = Math.abs(minToUse);
-                const absMax = Math.abs(maxToUse);
-                const closestToZero = absMin < absMax ? minToUse : maxToUse;
-                minToUse = closestToZero;
-                maxToUse = closestToZero;
-                console.warn(`[Orbit Camera] Max alpha must be <= Min Alpha. Forcing to ${closestToZero}`);
-            }
-            this.maxAlpha = maxToUse;
-            this.minAlpha = minToUse;
-            this.limitAlpha = true;
-            this.alpha = this.alpha;
-        };
-        this.clearAlphaLimits = () => {
-            this.maxAlpha = 0;
-            this.minAlpha = 0;
-            this.limitAlpha = false;
-        };
-        this.setBetaLimits = (min, max) => {
-            let minToUse = min;
-            let maxToUse = max;
-            if (min < -180) {
-                minToUse = -180;
-                console.warn("[Orbit Camera] Min beta must be >= -180. Forcing to -180");
-            }
-            if (max > 180) {
-                maxToUse = 180;
-                console.warn("[Orbit Camera] Max beta must be <= 180. Forcing to 180");
-            }
-            if (minToUse > maxToUse) {
-                const absMin = Math.abs(minToUse);
-                const absMax = Math.abs(maxToUse);
-                const closestToZero = absMin < absMax ? minToUse : maxToUse;
-                minToUse = closestToZero;
-                maxToUse = closestToZero;
-                console.warn(`[Orbit Camera] Max beta must be <= Min beta. Forcing to ${closestToZero}`);
-            }
-            this.maxBeta = maxToUse;
-            this.minBeta = minToUse;
-            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.array;
-            const maxArray = max.array;
-            for (let i = 0; i < 3; i++) {
-                if (minArray[i] > maxArray[i]) {
-                    console.warn("[Orbit Camera] Target limit min's components must all be <= the max. Limits not set");
-                    return;
-                }
-            }
-            this.maxTargetPosition = max;
-            this.minTargetPosition = min;
-            this.limitTarget = true;
-            this.target = this.target;
-        };
-        this.clearTargetLimits = () => {
-            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
-            this.minTargetPosition = ValueObjects_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 ValueObjects_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 ValueObjects_1.Vector3(min.x, min.y, min.z), new ValueObjects_1.Vector3(max.x, max.y, max.z));
-            }
-        };
-        this.addObserver = (observer) => {
-            this.observers.add(observer);
-        };
-        this.removeObserver = (observer) => {
-            this.observers.remove(observer);
-        };
-    }
-    get alpha() {
-        return this.memoizedAlpha.val;
-    }
-    set alpha(val) {
-        let valToUse = val;
-        if (this.limitAlpha) {
-            valToUse = Math.min(valToUse, this.maxAlpha);
-            valToUse = Math.max(valToUse, this.minAlpha);
-        }
-        else {
-            valToUse = this.clampAngle(val);
-        }
-        this.memoizedAlpha.val = valToUse;
-    }
-    get beta() {
-        return this.memoizedBeta.val;
-    }
-    set beta(val) {
-        let valToUse = val;
-        if (this.limitBeta) {
-            valToUse = Math.min(valToUse, this.maxBeta);
-            valToUse = Math.max(valToUse, this.minBeta);
-        }
-        else {
-            valToUse = this.clampAngle(val);
-        }
-        this.memoizedBeta.val = valToUse;
-    }
-    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.val;
-    }
-    set target(val) {
-        const targetVals = val.array;
-        if (this.limitTarget) {
-            const maxVals = this.maxTargetPosition.array;
-            const minVals = this.minTargetPosition.array;
-            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.val = ValueObjects_1.Vector3.FromArray(targetVals);
-    }
-    get direction() {
-        const yLength = -Math.sin(this.degToRad(this.beta));
-        const horizontalLenght = Math.cos(this.degToRad(this.beta));
-        const alphaRadians = this.degToRad(this.alpha);
-        const xLength = horizontalLenght * Math.sin(alphaRadians);
-        const zLength = horizontalLenght * Math.cos(alphaRadians);
-        return new ValueObjects_1.Vector3(xLength, yLength, zLength);
-    }
-    get cameraPosition() {
-        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
-        return ValueObjects_1.Vector3.Add(this.target, localOffset);
-    }
-    degToRad(degrees) {
-        return (degrees * Math.PI) / 180;
-    }
-    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/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;