@vived/app 2.20.0 → 2.21.1

package/lib/Entities/index.d.ts

@@ -10,8 +10,11 @@ export * from "./MemoizedVector3";
 export * from "./ObserverList";
 export * from "./FocusCamera";
 export * from "./StateMachine";
+export * from "./TransformNode";
 export * from "./UndoRedo";
 export * from "./MouseInput";
 export * from "./TouchInput";
 export * from "./QuestionChallengeAnswer";
 export * from "./QuestionChallenge";
+export * from "./SceneRoot";
+export * from "./WorkPlane";

package/lib/Entities/index.js

@@ -22,8 +22,11 @@ __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./StateMachine"), exports);
+__exportStar(require("./TransformNode"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./TouchInput"), exports);
 __exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./WorkPlane"), exports);

package/lib/PresentationManagers/TransformNodePM.d.ts

@@ -0,0 +1,14 @@
+import { TransformNode } from "../Entities";
+import { Quaternion, Vector3 } from "../ValueObjects";
+export interface TransformNodeVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export declare class TransformNodePM {
+    private transformNode;
+    private updateView;
+    dispose: () => void;
+    doUpdateView: () => void;
+    constructor(transformNode: TransformNode, updateView: (vm: TransformNodeVM) => void);
+}

package/lib/PresentationManagers/TransformNodePM.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformNodePM = void 0;
+class TransformNodePM {
+    constructor(transformNode, updateView) {
+        this.transformNode = transformNode;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.transformNode.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const vm = {
+                position: this.transformNode.localPosition,
+                rotation: this.transformNode.localRotation,
+                scale: this.transformNode.localScale,
+            };
+            this.updateView(vm);
+        };
+        transformNode.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+}
+exports.TransformNodePM = TransformNodePM;

package/lib/PresentationManagers/index.d.ts

@@ -6,3 +6,4 @@ export * from "./HasUndoPM";
 export * from "./FocusCameraPM";
 export * from "./QuestionChallenge";
 export * from "./FocusCameraPosRotPM";
+export * from "./TransformNodePM";

package/lib/PresentationManagers/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./FocusCameraPM"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./FocusCameraPosRotPM"), exports);
+__exportStar(require("./TransformNodePM"), exports);

package/lib/UseCases/SceneRoot/SerializeSceneRoot.d.ts

@@ -0,0 +1,18 @@
+import { SerializedSystem, StateMachine } from "../../Entities";
+import { SceneRoot } from "../../Entities/SceneRoot";
+export declare class SerializeSceneRoot implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private sceneRoot;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    constructor(sceneRoot: SceneRoot, stateMachine: StateMachine);
+}
+export interface SceneRootDataV1 {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: [number, number, number];
+}

package/lib/UseCases/SceneRoot/SerializeSceneRoot.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeSceneRoot = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeSceneRoot {
+    constructor(sceneRoot, stateMachine) {
+        this.name = "sceneRoot";
+        this.seriliziationVersion = 1;
+        this.sceneRoot = sceneRoot;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const rootTransform = this.sceneRoot.transform;
+        const data = {
+            position: rootTransform.localPosition.array,
+            rotation: rootTransform.localRotation.toArray(),
+            scale: rootTransform.localScale.array,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializeSceneRoot] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeSceneRoot] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        this.sceneRoot.transform.lerp(transitionDuration * 1000, this.stateMachine.transitionEaseFunction, this.sceneRoot.defaultPosition, this.sceneRoot.defaultRoation, this.sceneRoot.defaultScale);
+    }
+    applyV1Data(data, transitionTime) {
+        const pos = ValueObjects_1.Vector3.FromArray(data.position);
+        const rot = ValueObjects_1.Quaternion.FromArray(data.rotation);
+        const scale = ValueObjects_1.Vector3.FromArray(data.scale);
+        this.sceneRoot.transform.lerp(transitionTime * 1000, this.stateMachine.transitionEaseFunction, pos, rot, scale);
+    }
+}
+exports.SerializeSceneRoot = SerializeSceneRoot;

package/lib/UseCases/SceneRoot/index.d.ts

@@ -0,0 +1 @@
+export * from "./SerializeSceneRoot";

package/lib/UseCases/SceneRoot/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SerializeSceneRoot"), exports);

package/lib/UseCases/index.d.ts

@@ -2,3 +2,4 @@ export * from "./setDevicePreview";
 export * from "./FocusCamera";
 export * from "./QuestionChallenge";
 export * from "./LerpVector3";
+export * from "./SceneRoot";

package/lib/UseCases/index.js

@@ -14,3 +14,4 @@ __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./LerpVector3"), exports);
+__exportStar(require("./SceneRoot"), exports);

package/lib/ValueObjects/Angle.d.ts

@@ -1,6 +1,24 @@
 export declare class Angle {
+    /**
+     * Creates an angle from degrees
+     * @param degrees Angle in degrees
+     * @returns The angle
+     */
     static FromDegrees(degrees: number): Angle;
+    /**
+     * Creates an angle from radians
+     * @param radians Angle in radians
+     * @returns The angle
+     */
     static FromRadians(radians: number): Angle;
+    /**
+     * Check to see if two angles are close
+     * @param a Angle A
+     * @param b Angle B
+     * @param tolerance Tolerance for "Close" in degrees. Defaults to 0.001;
+     * @returns True if the difference between A and B (in degress) is less than the tolerance
+     */
+    static Close(a: Angle, b: Angle, tolerance?: number): boolean;
     private _degrees;
     get degrees(): number;
     get radians(): number;

package/lib/ValueObjects/Angle.js

@@ -6,17 +6,41 @@ class Angle {
         this._degrees = 0;
         this._degrees = degrees;
     }
+    /**
+     * Creates an angle from degrees
+     * @param degrees Angle in degrees
+     * @returns The angle
+     */
     static FromDegrees(degrees) {
         return new Angle(degrees);
     }
+    /**
+     * Creates an angle from radians
+     * @param radians Angle in radians
+     * @returns The angle
+     */
     static FromRadians(radians) {
-        return new Angle(radians * 180 / Math.PI);
+        return new Angle((radians * 180) / Math.PI);
+    }
+    /**
+     * Check to see if two angles are close
+     * @param a Angle A
+     * @param b Angle B
+     * @param tolerance Tolerance for "Close" in degrees. Defaults to 0.001;
+     * @returns True if the difference between A and B (in degress) is less than the tolerance
+     */
+    static Close(a, b, tolerance = 0.001) {
+        let diff = a.degrees - b.degrees;
+        if (diff < 0) {
+            diff = -diff;
+        }
+        return diff < tolerance;
     }
     get degrees() {
         return this._degrees;
     }
     get radians() {
-        return this._degrees * Math.PI / 180;
+        return (this._degrees * Math.PI) / 180;
     }
 }
 exports.Angle = Angle;

package/lib/ValueObjects/Color.d.ts

@@ -1,18 +1,64 @@
 export declare type BasicColor = "";
 export declare class Color {
+    /**
+     * Creates a Color from RGBA values
+     * @param r Red value, between 0-255
+     * @param g Green value, between 0-255
+     * @param b Blue value, between 0-255
+     * @param a Alpha value, between 0-255
+     * @returns The Color
+     */
     static RGBA(r: number, g: number, b: number, a: number): Color;
+    /**
+     * Creates a Color from RGB values. Alpha is set to 255
+     * @param r Red value, between 0-255
+     * @param g Green value, between 0-255
+     * @param b Blue value, between 0-255
+     * @returns The Color
+     */
     static RGB(r: number, g: number, b: number): Color;
+    /**
+     * Creates a color from a Hex value
+     * @param hex The Hex string. Example '808080'
+     * @returns The Color
+     */
     static Hex(hex: string): Color;
+    /**
+     * Creates a color from the X11 standard.
+     * @param name X11 name
+     * @returns The Color. If the color name is not found, it will return Black.
+     */
     static X11(name: string): Color;
+    /**
+     * Checks to see if Color A equals Color B
+     * @param a Color A
+     * @param b Color B
+     * @returns True if Color A === Color B
+     */
     static Equal(a: Color, b: Color): boolean;
     readonly r: number;
     readonly g: number;
     readonly b: number;
     readonly a: number;
+    /**
+     * Return the r value as a percent
+     */
     get rPercent(): number;
+    /**
+     * Return the g value as a percent
+     */
     get gPercent(): number;
+    /**
+     * Return the b value as a percent
+     */
     get bPercent(): number;
+    /**
+     * Return the a value as a percent
+     */
     get aPercent(): number;
+    /**
+     * Returns the Color values as an array [r,g,b,a]
+     */
     get array(): [number, number, number, number];
     private clampVal;
     private constructor();

package/lib/ValueObjects/Color.js

@@ -8,12 +8,32 @@ class Color {
         this.b = this.clampVal(b);
         this.a = this.clampVal(a);
     }
+    /**
+     * Creates a Color from RGBA values
+     * @param r Red value, between 0-255
+     * @param g Green value, between 0-255
+     * @param b Blue value, between 0-255
+     * @param a Alpha value, between 0-255
+     * @returns The Color
+     */
     static RGBA(r, g, b, a) {
         return new Color(r, g, b, a);
     }
+    /**
+     * Creates a Color from RGB values. Alpha is set to 255
+     * @param r Red value, between 0-255
+     * @param g Green value, between 0-255
+     * @param b Blue value, between 0-255
+     * @returns The Color
+     */
     static RGB(r, g, b) {
         return new Color(r, g, b, 255);
     }
+    /**
+     * Creates a color from a Hex value
+     * @param hex The Hex string. Example '808080'
+     * @returns The Color
+     */
     static Hex(hex) {
         // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
         const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
@@ -35,6 +55,11 @@ class Color {
         }
         return Color.RGB(r, g, b);
     }
+    /**
+     * Creates a color from the X11 standard.
+     * @param name X11 name
+     * @returns The Color. If the color name is not found, it will return Black.
+     */
     static X11(name) {
         for (const c of x11Colors) {
             if (c.name === name) {
@@ -44,6 +69,12 @@ class Color {
         console.warn("Unable to find X11 color by name: " + name);
         return Color.RGB(0, 0, 0);
     }
+    /**
+     * Checks to see if Color A equals Color B
+     * @param a Color A
+     * @param b Color B
+     * @returns True if Color A === Color B
+     */
     static Equal(a, b) {
         if (a.a !== b.a)
             return false;
@@ -51,18 +82,33 @@ class Color {
             return false;
         return true;
     }
+    /**
+     * Return the r value as a percent
+     */
     get rPercent() {
         return this.r / 255;
     }
+    /**
+     * Return the g value as a percent
+     */
     get gPercent() {
         return this.g / 255;
     }
+    /**
+     * Return the b value as a percent
+     */
     get bPercent() {
         return this.b / 255;
     }
+    /**
+     * Return the a value as a percent
+     */
     get aPercent() {
         return this.a / 255;
     }
+    /**
+     * Returns the Color values as an array [r,g,b,a]
+     */
     get array() {
         return [this.r, this.g, this.b, this.a];
     }

package/lib/ValueObjects/Matrix.d.ts

@@ -0,0 +1,120 @@
+import { Angle } from "./Angle";
+import { Quaternion } from "./Quaternion";
+import { Vector3 } from "./Vector3";
+export declare type MatrixArray = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare class Matrix {
+    /**
+     * Consructs an identity matrix
+     * @returns An identity matrix
+     */
+    static Identity(): Matrix;
+    /**
+     * Constructs an matrix of zeros
+     * @returns A matrix of zeros
+     */
+    static Zero(): Matrix;
+    /**
+     * Compares two matricies
+     * @param a Matrix A
+     * @param b Matrix B
+     * @returns True if all the elements in matrix A are equal to all the elements of matrix B
+     */
+    static Equal(a: Matrix, b: Matrix): boolean;
+    /**
+     * Checks to see if Matrix A is close to Matrix B by comparing elements
+     * @param a Matrix A
+     * @param b Matrix B
+     * @param threshold "Close" thershold. Defaults to 0.001
+     * @returns True if all the difference between the elements in each array is less than the threshold
+     */
+    static Close(a: Matrix, b: Matrix, threshold?: number): boolean;
+    /**
+     * Multiplies Matrix A and B (AxB)
+     * @param a Matrix A
+     * @param b Matrix B
+     * @returns The result of AxB
+     */
+    static Multiply(a: Matrix, b: Matrix): Matrix;
+    /**
+     * Composes a matrix from a scale vector, rotation quaterion, and translation vector
+     * @param scale The scale of the transformation matrix
+     * @param rotation The rotation of the transformation matrix
+     * @param translation The translation of the transformation matrix
+     * @returns The composed matrix
+     */
+    static Compose(scale: Vector3, rotation: Quaternion, translation: Vector3): Matrix;
+    /**
+     * Inverts a matrix into a new matrix.
+     * @param matrix The matrix to invert
+     * @returns The inverted matrix unless the matrix cannot be inverted, then the identity is returned
+     */
+    static Invert(matrix: Matrix): Matrix;
+    /**
+     * Creates a rotation matrix for a given axes and angle
+     * @param axis The axes of rotation
+     * @param angle The angle of rotation
+     * @returns A new rotation matrix
+     */
+    static FromRotationAxisAngle(axis: Vector3, angle: Angle): Matrix;
+    /**
+     * Make a new transformation matrix that has the same scale and rotation as the original but the translation is set
+     * @param original The original matrix
+     * @param translation The new translation value
+     * @returns A new matrix that is the same as the original but the translation has been changed
+     */
+    static SetMatrixTranslation(original: Matrix, translation: Vector3): Matrix;
+    /**
+     * Make a new transformation matrix that has the same scale and translation as the original but the rotation is set
+     * @param original The original matrix
+     * @param rotation The new rotation value
+     * @returns A new matrix that is the same as the original but the rotation has been changed
+     */
+    static SetMatrixRotation(original: Matrix, rotation: Quaternion): Matrix;
+    /**
+     * Make a new transformation matrix that has the same rotation and translation as the original but the scale is set
+     * @param original The original matrix
+     * @param scale The new scale value
+     * @returns A new matrix that is the same as the original but the scale has been changed
+     */
+    static SetMatrixScale(original: Matrix, scale: Vector3): Matrix;
+    /**
+     * Returns the determinate of the matrix
+     */
+    get determinate(): number;
+    /**
+     * Returns the translation component of the transformation matrix as a Vector
+     */
+    get translation(): Vector3;
+    /**
+     * Returns the scale of the transformation matrix as a vector
+     */
+    get scale(): Vector3;
+    /**
+     * Returns the rotation components of the transformation matrix as a Quaternion
+     */
+    get rotation(): Quaternion;
+    /**
+     * Returns just the rotation matrix of the transformation matrix
+     */
+    get rotationMatrix(): Matrix;
+    private readonly _m;
+    get m(): MatrixArray;
+    constructor(m: MatrixArray);
+}