@vived/app 2.20.1 → 2.21.0

package/lib/Entities/SceneRoot.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneRoot = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const ObserverList_1 = require("./ObserverList");
+const TransformNode_1 = require("./TransformNode");
+function makeSceneRoot() {
+    return new SceneRootImp();
+}
+exports.makeSceneRoot = makeSceneRoot;
+class SceneRootImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this._defaultPosition = ValueObjects_1.Vector3.Zero();
+        this._defaultRoation = ValueObjects_1.Quaternion.Identity();
+        this._defaultScale = ValueObjects_1.Vector3.One();
+        this._minScale = 0.01;
+        this._maxScale = 10;
+        this._id = "scene_root";
+        this.applyDefaultData = (data) => {
+            this._defaultPosition = ValueObjects_1.Vector3.FromArray(data.position);
+            this._defaultRoation = ValueObjects_1.Quaternion.FromArray(data.rotation);
+            this._defaultScale = new ValueObjects_1.Vector3(data.scale, data.scale, data.scale);
+            this._maxScale = data.maxScale;
+            this._minScale = data.minScale;
+            this._id = data.id;
+        };
+        this.centerOnPoint = (point, durationMS, easeFn, onCompleted) => {
+            const finalPosition = ValueObjects_1.Vector3.Subtract(this.transform.worldPosition, point);
+            this.transform.lerp(durationMS, easeFn, finalPosition, undefined, undefined, onCompleted);
+        };
+        this.bumpScaleAboutPoint = (amount, worldPoint) => {
+            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.transform.worldScale.x;
+            let newScale = currentScale + amount;
+            if (newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            else if (newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        };
+        this.lerpToDefault = (durationMS, easeFn, onCompleted) => {
+            this.transform.lerp(durationMS, easeFn, this.defaultPosition, this.defaultRoation, this.defaultScale, onCompleted);
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+        this.transform = TransformNode_1.makeTransformNode();
+        this.transform.addObserver(this.observers.notify);
+    }
+    get defaultPosition() {
+        return this._defaultPosition;
+    }
+    get defaultRoation() {
+        return this._defaultRoation;
+    }
+    get defaultScale() {
+        return this._defaultScale;
+    }
+    get minScale() {
+        return this._minScale;
+    }
+    get maxScale() {
+        return this._maxScale;
+    }
+    get id() {
+        return this._id;
+    }
+}

package/lib/Entities/TransformNode.d.ts

@@ -0,0 +1,78 @@
+import { Matrix, Quaternion, Vector3 } from "../ValueObjects";
+export declare type OnTransformNodeChange = () => void;
+export declare type EaseFn = (p: number) => number;
+export interface TransformNode {
+    /**
+     * Local position of the transform
+     */
+    localPosition: Vector3;
+    /**
+     * The world position of the transform
+     */
+    worldPosition: Vector3;
+    /**
+     * Local roation of the transform
+     */
+    localRotation: Quaternion;
+    /**
+     * World roation of the transform
+     */
+    worldRotation: Quaternion;
+    /**
+     * Local scale of the transform
+     */
+    localScale: Vector3;
+    /**
+     * World scale of the transform
+     */
+    worldScale: Vector3;
+    /**
+     * Local transformation matrix
+     */
+    localMatrix: Matrix;
+    /**
+     * The global transformation matrix
+     */
+    worldMatrix: Matrix;
+    /**
+     * The transform's parent. Optional
+     */
+    parent?: TransformNode;
+    /**
+     * Transforms a point from local to world space coordinates
+     * @param point point to transform in local coordinates
+     */
+    localPointToWorld: (point: Vector3) => Vector3;
+    /**
+     * Transforms a point from world to local space coordinates
+     * @param point point to transform in world coordinates
+     */
+    worldPointToLocal: (point: Vector3) => Vector3;
+    /**
+     * Transforms a local direction vector to world coordinates.
+     * @param direction direction to transform in local coordinates
+     */
+    localDirectionToWorld: (direction: Vector3) => Vector3;
+    /**
+     * Transforms a world direction vector to local coordinates
+     * @param direction direction to transform in world coordinates
+     */
+    worldDirectionToLocal: (direction: Vector3) => Vector3;
+    /**
+     * Lerps this transform node
+     * @param duration Lerp duration in MS
+     * @param ease Lerp ease function
+     * @param desiredPosition: Desired position. Optional.
+     * @param desiredRotation: Desired rotation. Optional.
+     * @param desiredScale: Desired scale. Optional.
+     * @param onCompletedCallback: Optional function to call when the lerp has completed
+     */
+    lerp: (duration: number, ease: EaseFn, desiredPosition?: Vector3, desiredRotation?: Quaternion, desiredScale?: Vector3, onCompletedCallback?: () => void) => void;
+    /**
+     * Cancels any currently running lerp
+     */
+    cancelLerp: () => void;
+    addObserver: (observer: OnTransformNodeChange) => void;
+    removeObserver: (observer: OnTransformNodeChange) => void;
+}
+export declare function makeTransformNode(): TransformNode;

package/lib/Entities/TransformNode.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransformNode = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const ObserverList_1 = require("./ObserverList");
+function makeTransformNode() {
+    return new TransformNodeImp();
+}
+exports.makeTransformNode = makeTransformNode;
+class TransformNodeImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this._transformationMatrix = ValueObjects_1.Matrix.Identity();
+        this.localPointToWorld = (point) => {
+            return ValueObjects_1.Vector3.Transform(point, this.worldMatrix);
+        };
+        this.worldPointToLocal = (point) => {
+            const worldInverse = ValueObjects_1.Matrix.Invert(this.worldMatrix);
+            return ValueObjects_1.Vector3.Transform(point, worldInverse);
+        };
+        this.localDirectionToWorld = (point) => {
+            const rotationMatrix = ValueObjects_1.Quaternion.ToRotationMatrix(this.worldRotation);
+            return ValueObjects_1.Vector3.Transform(point, rotationMatrix).unit;
+        };
+        this.worldDirectionToLocal = (point) => {
+            const worldInverse = ValueObjects_1.Matrix.Invert(this.worldMatrix);
+            const rotationMatrix = ValueObjects_1.Quaternion.ToRotationMatrix(worldInverse.rotation);
+            return ValueObjects_1.Vector3.Transform(point, rotationMatrix).unit;
+        };
+        this.chrono = 0;
+        this.lerpDuration = 1;
+        this.lerpEase = (p) => p;
+        this.tickInterval = 10;
+        this.lerp = (duration, ease, desiredPosition, desiredRotation, desiredScale, onCompletedCallback) => {
+            this.cancelLerp();
+            this.chrono = 0;
+            this.lerpDuration = duration;
+            this.lerpEase = ease;
+            if (duration <= 0) {
+                this.localMatrix = ValueObjects_1.Matrix.Compose(desiredScale !== null && desiredScale !== void 0 ? desiredScale : this.localScale, desiredRotation !== null && desiredRotation !== void 0 ? desiredRotation : this.localRotation, desiredPosition !== null && desiredPosition !== void 0 ? desiredPosition : this.localPosition);
+                return;
+            }
+            if (desiredPosition) {
+                this.lerpPos = [this.localPosition, desiredPosition];
+            }
+            else {
+                this.lerpPos = undefined;
+            }
+            if (desiredRotation) {
+                this.lerpQuat = [this.localRotation, desiredRotation];
+            }
+            else {
+                this.lerpQuat = undefined;
+            }
+            if (desiredScale) {
+                this.lerpScale = [this.localScale, desiredScale];
+            }
+            else {
+                this.lerpScale = undefined;
+            }
+            this.onLerpCompletedCallback = onCompletedCallback;
+            this.interval = setInterval(() => {
+                this.tickLerp();
+            }, this.tickInterval);
+        };
+        this.tickLerp = () => {
+            this.chrono = this.chrono + this.tickInterval;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.lerpEase(nomralizedTime);
+            let pos = this.localPosition;
+            if (this.lerpPos) {
+                pos = ValueObjects_1.Vector3.Lerp(this.lerpPos[0], this.lerpPos[1], percent);
+            }
+            let rotation = this.localRotation;
+            if (this.lerpQuat) {
+                rotation = ValueObjects_1.Quaternion.Slerp(this.lerpQuat[0], this.lerpQuat[1], percent);
+            }
+            let scale = this.localScale;
+            if (this.lerpScale) {
+                scale = ValueObjects_1.Vector3.Lerp(this.lerpScale[0], this.lerpScale[1], percent);
+            }
+            this._transformationMatrix = ValueObjects_1.Matrix.Compose(scale, rotation, pos);
+            this.observers.notify();
+            if (nomralizedTime >= 1 && this.interval) {
+                if (this.onLerpCompletedCallback) {
+                    this.onLerpCompletedCallback();
+                }
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+        };
+        this.cancelLerp = () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get localMatrix() {
+        return this._transformationMatrix;
+    }
+    set localMatrix(val) {
+        if (ValueObjects_1.Matrix.Close(this._transformationMatrix, val))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = val;
+        this.observers.notify();
+    }
+    get worldMatrix() {
+        if (!this._parent) {
+            return this._transformationMatrix;
+        }
+        else {
+            return ValueObjects_1.Matrix.Multiply(this._parent.worldMatrix, this._transformationMatrix);
+        }
+    }
+    get localPosition() {
+        return this._transformationMatrix.translation;
+    }
+    set localPosition(val) {
+        const currentPos = this._transformationMatrix.translation;
+        if (ValueObjects_1.Vector3.Close(val, currentPos, 0.00001))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixTranslation(this._transformationMatrix, val);
+        this.observers.notify();
+    }
+    get worldPosition() {
+        return this.worldMatrix.translation;
+    }
+    set worldPosition(val) {
+        if (!this._parent) {
+            this.localPosition = val;
+        }
+        else {
+            const local = this._parent.worldPointToLocal(val);
+            this.localPosition = local;
+        }
+    }
+    get localRotation() {
+        return this._transformationMatrix.rotation;
+    }
+    set localRotation(val) {
+        const currentRot = this._transformationMatrix.rotation;
+        if (ValueObjects_1.Quaternion.Close(val, currentRot))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixRotation(this._transformationMatrix, val);
+        this.observers.notify();
+    }
+    get worldRotation() {
+        return this.worldMatrix.rotation;
+    }
+    set worldRotation(val) {
+        if (!this._parent) {
+            this.localRotation = val;
+        }
+        else {
+            const parentRotation = this._parent.worldRotation;
+            const parentRotationInverse = ValueObjects_1.Quaternion.Inverse(parentRotation);
+            this.localRotation = ValueObjects_1.Quaternion.Multiply(parentRotationInverse, val);
+        }
+    }
+    get localScale() {
+        return this._transformationMatrix.scale;
+    }
+    set localScale(val) {
+        const currentScale = this._transformationMatrix.scale;
+        if (ValueObjects_1.Vector3.Close(val, currentScale, 0.00001))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixScale(this._transformationMatrix, val);
+        this.observers.notify();
+    }
+    get worldScale() {
+        return this.worldMatrix.scale;
+    }
+    set worldScale(val) {
+        if (!this._parent) {
+            this.localScale = val;
+        }
+        else {
+            const parentScale = this._parent.worldScale;
+            const x = val.x / parentScale.x;
+            const y = val.y / parentScale.y;
+            const z = val.z / parentScale.z;
+            this.localScale = new ValueObjects_1.Vector3(x, y, z);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(val) {
+        if (this._parent === val)
+            return;
+        const wMatrix = this.worldMatrix;
+        this._parent = val;
+        if (this._parent) {
+            const parentMatrix = this._parent.worldMatrix;
+            const parentMatrixInverse = ValueObjects_1.Matrix.Invert(parentMatrix);
+            this.localMatrix = ValueObjects_1.Matrix.Multiply(parentMatrixInverse, wMatrix);
+        }
+        else {
+            this.localMatrix = wMatrix;
+        }
+        this.observers.notify();
+    }
+}

package/lib/Entities/Vector2.d.ts

@@ -0,0 +1,21 @@
+export declare class Vector2 {
+    static Zero(): Vector2;
+    static One(): Vector2;
+    x: number;
+    y: number;
+    get magnitued(): number;
+    get unit(): Vector2;
+    get theta(): number;
+    setLength: (length: number) => void;
+    add: (vector2: Vector2) => Vector2;
+    subtract: (vector2: Vector2) => Vector2;
+    equal: (a: Vector2) => boolean;
+    close: (vec: Vector2) => boolean;
+    copy: () => Vector2;
+    asArray: () => [number, number];
+    rotate: (theta: number) => Vector2;
+    dot: (vec: Vector2) => number;
+    angleTo: (vec: Vector2) => number;
+    cross: (vec: Vector2) => number;
+    constructor(x: number, y: number);
+}

package/lib/Entities/Vector2.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector2 = void 0;
+class Vector2 {
+    constructor(x, y) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+        };
+        this.add = (vector2) => {
+            return new Vector2(this.x + vector2.x, this.y + vector2.y);
+        };
+        this.subtract = (vector2) => {
+            return new Vector2(this.x - vector2.x, this.y - vector2.y);
+        };
+        this.equal = (a) => {
+            if (a.x === this.x && a.y === this.y)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.copy = () => {
+            return new Vector2(this.x, this.y);
+        };
+        this.asArray = () => {
+            return [this.x, this.y];
+        };
+        this.rotate = (theta) => {
+            const thetaRadians = theta * Math.PI / 180;
+            const x = this.x * Math.cos(thetaRadians) - this.y * Math.sin(thetaRadians);
+            const y = this.x * Math.sin(thetaRadians) + this.y * Math.cos(thetaRadians);
+            return new Vector2(x, y);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y;
+        };
+        this.angleTo = (vec) => {
+            const dot = this.dot(vec);
+            const magnitues = vec.magnitued * this.magnitued;
+            const angRadians = Math.acos(dot / magnitues);
+            return angRadians * 180 / Math.PI;
+        };
+        this.cross = (vec) => {
+            return (this.x * vec.y) - (this.y * vec.x);
+        };
+        this.x = x;
+        this.y = y;
+    }
+    static Zero() {
+        return new Vector2(0, 0);
+    }
+    static One() {
+        return new Vector2(1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const magnitude = Math.sqrt(xSqr + ySqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector2.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        return new Vector2(unitX, unitY);
+    }
+    get theta() {
+        return (Math.atan2(this.y, this.x) * 180) / Math.PI;
+    }
+}
+exports.Vector2 = Vector2;

package/lib/Entities/Vector3.d.ts

@@ -0,0 +1,19 @@
+export declare class Vector3 {
+    static Zero(): Vector3;
+    static One(): Vector3;
+    x: number;
+    y: number;
+    z: number;
+    get magnitued(): number;
+    get unit(): Vector3;
+    setLength: (length: number) => void;
+    add: (a: Vector3) => Vector3;
+    subtract: (vector2: Vector3) => Vector3;
+    copy: () => Vector3;
+    equals: (vec: Vector3) => boolean;
+    close: (vec: Vector3) => boolean;
+    cross: (vec: Vector3) => Vector3;
+    dot: (vec: Vector3) => number;
+    asArray: () => [number, number, number];
+    constructor(x: number, y: number, z: number);
+}

package/lib/Entities/Vector3.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+class Vector3 {
+    constructor(x, y, z) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+            this.z = length * unit.z;
+        };
+        this.add = (a) => {
+            return new Vector3(this.x + a.x, this.y + a.y, this.z + a.z);
+        };
+        this.subtract = (vector2) => {
+            return new Vector3(this.x - vector2.x, this.y - vector2.y, this.z - vector2.z);
+        };
+        this.copy = () => {
+            return new Vector3(this.x, this.y, this.z);
+        };
+        this.equals = (vec) => {
+            if (vec.x === this.x && vec.y === this.y && vec.z === this.z)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.cross = (vec) => {
+            const x = this.y * vec.z - this.z * vec.y;
+            const y = this.z * vec.x - this.x * vec.z;
+            const z = this.x * vec.y - this.y * vec.x;
+            return new Vector3(x, y, z);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y + this.z * vec.z;
+        };
+        this.asArray = () => {
+            return [this.x, this.y, this.z];
+        };
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    static Zero() {
+        return new Vector3(0, 0, 0);
+    }
+    static One() {
+        return new Vector3(1, 1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const zSqr = this.z * this.z;
+        const magnitude = Math.sqrt(xSqr + ySqr + zSqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector3.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        const unitZ = this.z / mag;
+        return new Vector3(unitX, unitY, unitZ);
+    }
+}
+exports.Vector3 = Vector3;

package/lib/Entities/WorkPlane.d.ts

@@ -0,0 +1,49 @@
+import { ParametricLine, Vector2 } from "../ValueObjects";
+import { TransformNode } from "./TransformNode";
+export declare type OnWorkPlaneChange = () => void;
+export declare enum WorkPlaneUnits {
+    INCHES = 0,
+    METERS = 1,
+    FEET = 2
+}
+export declare enum WorkplaneShape {
+    RECTANGE = 0,
+    CIRCLE = 1,
+    UNKNOWN = 2
+}
+export interface WorkPlane {
+    transform: TransformNode;
+    id: string;
+    units: WorkPlaneUnits;
+    /**
+     * The conversion rate from world units (meters) to workspace units
+     */
+    conversionFactor: number;
+    workplaneShape: WorkplaneShape;
+    showWorkPlane: boolean;
+    workPlaneRadius?: number;
+    workPlaneSize?: Vector2;
+    /**
+     * Sets the radius of the work plane. Call this if your workplane is a circle and it will limits the picks accordingly
+     * Note this will not notify observers of a change so this should be set
+     * when the app starts.
+     * @param radius The radius of the work plane in work plane units
+     */
+    setWorkplaneSize: (size: Vector2) => void;
+    /**
+     * Sets the radius of the work plane. Call this if your workplane is a circle and it will limits the picks accordingly
+     * Note this will not notify observers of a change so this should be set
+     * when the app starts.
+     * @param radius The radius of the work plane in work plane units
+     */
+    setWorkplaneRadius: (radius: number) => void;
+    /**
+     * Tries to intersect a world ray with the work plane. If the work plane size or radius has been set
+     * it will limit the intersection appropriately, otherwise it will use an infinate plane.
+     * @param ray A ray in world coordinates
+     * @param unconstrained Optional. If set to true it will not limit the pick to the workplane size or radius. Instead it will pick on an infinate plane in the X-Z plane of the work plane. Defaults to false.
+     * @returns Where that ray intersects the work plane in work plane units. If the ray does not intersect, it returns undefined
+     */
+    pickOnWorkplane: (ray: ParametricLine, unconstrained?: boolean) => Vector2 | undefined;
+}
+export declare function makeWorkPlane(): WorkPlane;