@vived/app 2.20.1 → 2.21.0

package/lib/UseCases/OrbitCamera/SerializeOrbitCamera.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedOrbitCamera = void 0;
+const _1 = require(".");
+const Entities_1 = require("../../Entities");
+class SerializedOrbitCamera {
+    constructor(orbitCamera, stateMachine) {
+        this.name = "orbitCamera";
+        this.seriliziationVersion = 1;
+        this.orbitCamera = orbitCamera;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.orbitCamera.alpha,
+            beta: this.orbitCamera.beta,
+            radius: this.orbitCamera.radius,
+            target_x: this.orbitCamera.target.x,
+            target_y: this.orbitCamera.target.y,
+            target_z: this.orbitCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializedCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializedCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        const alpha = this.orbitCamera.defaultAlpha;
+        const beta = this.orbitCamera.defaultBeta;
+        const radius = this.orbitCamera.defaultRadius;
+        const target = this.orbitCamera.defaultTarget;
+        if (transitionDuration === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const target = new Entities_1.Vector3(target_x, target_y, target_z);
+        if (transitionTime === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionTime);
+        }
+    }
+    applyImmediate(alpha, beta, radius, target) {
+        this.orbitCamera.cancelLerp();
+        this.orbitCamera.alpha = alpha;
+        this.orbitCamera.beta = beta;
+        this.orbitCamera.radius = radius;
+        this.orbitCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpOrbitCamera(this.orbitCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializedOrbitCamera = SerializedOrbitCamera;

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

@@ -0,0 +1,4 @@
+export * from "./PixelPlanePan_OrbitCamera";
+export * from "./LerpOrbitCamera";
+export * from "./SerializeOrbitCamera";
+export * from "./PixelDolly_OrbitCamera";

package/lib/UseCases/OrbitCamera/index.js

@@ -0,0 +1,16 @@
+"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("./PixelPlanePan_OrbitCamera"), exports);
+__exportStar(require("./LerpOrbitCamera"), exports);
+__exportStar(require("./SerializeOrbitCamera"), exports);
+__exportStar(require("./PixelDolly_OrbitCamera"), 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/SerializeCamera.d.ts

@@ -0,0 +1,21 @@
+import { OrbitCamera, SerializedSystem, StateMachine } from "../Entities";
+export declare class SerializedCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private orbitCamera;
+    private stateMachine;
+    private defaultState?;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    constructor(orbitCamera: OrbitCamera, stateMachine: StateMachine, defaultState?: CameraDataV1);
+}
+export interface CameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/SerializeCamera.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedCamera = void 0;
+const _1 = require(".");
+const Entities_1 = require("../Entities");
+class SerializedCamera {
+    constructor(orbitCamera, stateMachine, defaultState) {
+        this.name = "orbitCamera";
+        this.seriliziationVersion = 1;
+        this.orbitCamera = orbitCamera;
+        this.stateMachine = stateMachine;
+        this.defaultState = defaultState;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.orbitCamera.alpha,
+            beta: this.orbitCamera.beta,
+            radius: this.orbitCamera.radius,
+            target_x: this.orbitCamera.target.x,
+            target_y: this.orbitCamera.target.y,
+            target_z: this.orbitCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializedCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializedCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        if (this.defaultState) {
+            this.applyV1Data(this.defaultState, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: new Entities_1.Vector3(target_x, target_y, target_z),
+        };
+        new _1.LerpOrbitCamera(this.orbitCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializedCamera = SerializedCamera;

package/lib/UseCases/SerializeOrbitCamera.d.ts

@@ -0,0 +1,21 @@
+import { OrbitCamera, SerializedSystem, StateMachine } from "../Entities";
+export declare class SerializedOrbitCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private orbitCamera;
+    private stateMachine;
+    private defaultState?;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    constructor(orbitCamera: OrbitCamera, stateMachine: StateMachine, defaultState?: CameraDataV1);
+}
+export interface CameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/SerializeOrbitCamera.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedOrbitCamera = void 0;
+const _1 = require(".");
+const Entities_1 = require("../Entities");
+class SerializedOrbitCamera {
+    constructor(orbitCamera, stateMachine, defaultState) {
+        this.name = "orbitCamera";
+        this.seriliziationVersion = 1;
+        this.orbitCamera = orbitCamera;
+        this.stateMachine = stateMachine;
+        this.defaultState = defaultState;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.orbitCamera.alpha,
+            beta: this.orbitCamera.beta,
+            radius: this.orbitCamera.radius,
+            target_x: this.orbitCamera.target.x,
+            target_y: this.orbitCamera.target.y,
+            target_z: this.orbitCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializedCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializedCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        if (this.defaultState) {
+            this.applyV1Data(this.defaultState, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: new Entities_1.Vector3(target_x, target_y, target_z),
+        };
+        new _1.LerpOrbitCamera(this.orbitCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializedOrbitCamera = SerializedOrbitCamera;

package/lib/UseCases/SerializedCamDemo.js

@@ -0,0 +1 @@
+"use strict";

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];
     }