@vived/app 2.20.0 → 2.21.1

package/lib/Entities/KeyboardInput.js

@@ -23,7 +23,6 @@ class KeyboardInputImp {
             this._eventElement = undefined;
         };
         this.submitKeyDown = (e) => {
-            e.preventDefault();
             this.controllers.forEach((c) => {
                 if (c.onKeyDown) {
                     c.onKeyDown(e);
@@ -31,7 +30,6 @@ class KeyboardInputImp {
             });
         };
         this.submitKeyUp = (e) => {
-            e.preventDefault();
             this.controllers.forEach((c) => {
                 if (c.onKeyUp) {
                     c.onKeyUp(e);

package/lib/Entities/MouseInput.js

@@ -42,7 +42,6 @@ class MouseInputImp {
             }
         };
         this.onMouseDown = (e) => {
-            e.preventDefault();
             const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onDown) {
@@ -53,7 +52,6 @@ class MouseInputImp {
             this.pressEvent = e;
         };
         this.onMouseUp = (e) => {
-            e.preventDefault();
             const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onUp) {
@@ -76,7 +74,6 @@ class MouseInputImp {
             this.pressEvent = undefined;
         };
         this.onMouseMove = (e) => {
-            e.preventDefault();
             const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onMove) {
@@ -93,7 +90,6 @@ class MouseInputImp {
             }
         };
         this.onMouseOut = (e) => {
-            e.preventDefault();
             if (!this.isPressed)
                 return;
             const inputEvt = this.makeMouseInputEvent(e);
@@ -106,7 +102,6 @@ class MouseInputImp {
             this.isPressed = false;
         };
         this.onWheel = (e) => {
-            e.preventDefault();
             const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onWheel) {

package/lib/Entities/SceneRoot.d.ts

@@ -0,0 +1,69 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { EaseFn, TransformNode } from "./TransformNode";
+export declare type OnSceneRootChange = () => void;
+export interface DefaultSceneRootData {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: number;
+    id: string;
+    minScale: number;
+    maxScale: number;
+}
+export interface SceneRoot {
+    /**
+     * The default position of the scene root in local coordinates
+     */
+    defaultPosition: Vector3;
+    /**
+     * The default rotation of the scene root in local coordinates
+     */
+    defaultRoation: Quaternion;
+    /**
+     * The default scale of the scene root in local coordinates
+     */
+    defaultScale: Vector3;
+    /**
+     * The minimum scale allowed for the scene root
+     */
+    minScale: number;
+    /**
+     * The maximum scale allowed for the scene root
+     */
+    maxScale: number;
+    /**
+     * The identifier for the scene root
+     */
+    id: string;
+    /**
+     * Transform node for the scene root
+     */
+    transform: TransformNode;
+    /**
+     * Applies the default data to this entity. This will not trigger a notification
+     */
+    applyDefaultData: (data: DefaultSceneRootData) => void;
+    /**
+     * Smoothly moves the transform so that the point is a the world origin
+     * @param point The point to center on in world coordinates
+     * @param durationMS The duration of the transition in milliseconds
+     * @param easeFn The easing funciton
+     * @param onCompleted An optional callback function when the ease is completed
+     */
+    centerOnPoint: (point: Vector3, durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    /**
+     * Smoothly moves the transform so that it is back in the default pose
+     * @param durationMS The duration of the transition in milliseconds
+     * @param easeFn The easing funciton
+     * @param onCompleted An optional callback function when the ease is completed
+     */
+    lerpToDefault: (durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    /**
+     * Bumps the scale of the root by a specific amount. Note this will enforce the min and max limits
+     * @param amount The world amount to bump the scale by. It will be applied uniformly
+     * @param worldPoint The world position about which to apply the scaling
+     */
+    bumpScaleAboutPoint: (amount: number, worldPoint: Vector3) => void;
+    addObserver: (observer: OnSceneRootChange) => void;
+    removeObserver: (observer: OnSceneRootChange) => void;
+}
+export declare function makeSceneRoot(): SceneRoot;

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/WorkPlane.d.ts

@@ -0,0 +1,69 @@
+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 {
+    /**
+     * The transform node for the work plane
+     */
+    transform: TransformNode;
+    /**
+     * Unique scene identifier for the work plane
+     * Default is "workplane"
+     */
+    id: string;
+    /**
+     * The work plane units
+     */
+    units: WorkPlaneUnits;
+    /**
+     * The conversion rate from world units (meters) to workspace units. This is set by setting the work plane units
+     */
+    conversionFactor: number;
+    /**
+     * The shape of the work plane. This is set by calling either setWorkplaneSize or setWorkplaneRadius
+     */
+    workplaneShape: WorkplaneShape;
+    /**
+     * Should the work plane be shown
+     */
+    showWorkPlane: boolean;
+    /**
+     * Readonly. Set when setWorkplaneRadius is called
+     * If the work plane radius has been set, this will return the radius. Otherwise it is undefined
+     */
+    workPlaneRadius?: number;
+    /**
+     * Readonly. Set when setWorkplaneSize has been called
+     * If the work plane size has been set this will return the size. Otherwise it will return undefined
+     */
+    workPlaneSize?: Vector2;
+    /**
+     * Sets the planer dimensions of the work plane. Call this if your workplane is a rectangle and it will limits the picks accordingly
+     * @param size The size 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
+     * @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;

package/lib/Entities/WorkPlane.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWorkPlane = exports.WorkplaneShape = exports.WorkPlaneUnits = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const TransformNode_1 = require("./TransformNode");
+var WorkPlaneUnits;
+(function (WorkPlaneUnits) {
+    WorkPlaneUnits[WorkPlaneUnits["INCHES"] = 0] = "INCHES";
+    WorkPlaneUnits[WorkPlaneUnits["METERS"] = 1] = "METERS";
+    WorkPlaneUnits[WorkPlaneUnits["FEET"] = 2] = "FEET";
+})(WorkPlaneUnits = exports.WorkPlaneUnits || (exports.WorkPlaneUnits = {}));
+var WorkplaneShape;
+(function (WorkplaneShape) {
+    WorkplaneShape[WorkplaneShape["RECTANGE"] = 0] = "RECTANGE";
+    WorkplaneShape[WorkplaneShape["CIRCLE"] = 1] = "CIRCLE";
+    WorkplaneShape[WorkplaneShape["UNKNOWN"] = 2] = "UNKNOWN";
+})(WorkplaneShape = exports.WorkplaneShape || (exports.WorkplaneShape = {}));
+function makeWorkPlane() {
+    return new WorkPlaneImp();
+}
+exports.makeWorkPlane = makeWorkPlane;
+class WorkPlaneImp {
+    constructor() {
+        this._workPlaneHalfSize = ValueObjects_1.Vector2.One();
+        this.showWorkPlane = true;
+        this.transform = TransformNode_1.makeTransformNode();
+        this.id = "workplane";
+        this._units = WorkPlaneUnits.METERS;
+        this._workplaneShape = WorkplaneShape.UNKNOWN;
+        this.setWorkplaneSize = (size) => {
+            this._workPlaneSize = size;
+            this._workPlaneHalfSize = new ValueObjects_1.Vector2(0.5 * size.x, 0.5 * size.y);
+            this._workplaneShape = WorkplaneShape.RECTANGE;
+        };
+        this.setWorkplaneRadius = (radius) => {
+            this._workPlaneRadius = radius;
+            this._workplaneShape = WorkplaneShape.CIRCLE;
+        };
+        this.pickOnWorkplane = (ray, unconstrained = false) => {
+            const worldPos = this.transform.worldPosition;
+            const worldUp = this.transform.localDirectionToWorld(ValueObjects_1.Vector3.Up());
+            const pickPlane = ValueObjects_1.ParametricPlane.FromPointNormal(worldPos, worldUp);
+            const worldPick = pickPlane.intersectLine(ray);
+            if (worldPick === undefined) {
+                return undefined;
+            }
+            const localPick = this.transform.worldPointToLocal(worldPick);
+            const workPlanePick = new ValueObjects_1.Vector2(localPick.x, localPick.z);
+            if (unconstrained) {
+                return workPlanePick;
+            }
+            if (this._workplaneShape === WorkplaneShape.CIRCLE) {
+                return this.constrainToRadius(workPlanePick);
+            }
+            else if (this._workplaneShape === WorkplaneShape.RECTANGE) {
+                return this.constrainToSize(workPlanePick);
+            }
+            else {
+                return workPlanePick;
+            }
+        };
+    }
+    get workPlaneRadius() {
+        return this._workPlaneRadius;
+    }
+    get workPlaneSize() {
+        return this._workPlaneSize;
+    }
+    get units() {
+        return this._units;
+    }
+    set units(val) {
+        if (val === this._units)
+            return;
+        this._units = val;
+        const scale = 1 / this.conversionFactor;
+        this.transform.localScale = new ValueObjects_1.Vector3(scale, scale, scale);
+    }
+    get workplaneShape() {
+        return this._workplaneShape;
+    }
+    get conversionFactor() {
+        switch (this.units) {
+            case WorkPlaneUnits.FEET:
+                return 3.28084;
+            case WorkPlaneUnits.INCHES:
+                return 39.3701;
+            case WorkPlaneUnits.METERS:
+                return 1;
+            default:
+                console.warn("[WorkPlane] Unknown units " + this.units);
+                return 1;
+        }
+    }
+    constrainToRadius(workPlanePick) {
+        if (!this.workPlaneRadius)
+            return workPlanePick;
+        const pickRadius = workPlanePick.magnitued;
+        if (pickRadius <= this.workPlaneRadius) {
+            return workPlanePick;
+        }
+        else {
+            return undefined;
+        }
+    }
+    constrainToSize(workPlanePick) {
+        if (!this._workPlaneHalfSize)
+            return workPlanePick;
+        const x = workPlanePick.x;
+        const maxX = this._workPlaneHalfSize.x;
+        const minX = -this._workPlaneHalfSize.x;
+        const y = workPlanePick.y;
+        const maxY = this._workPlaneHalfSize.y;
+        const minY = -this._workPlaneHalfSize.y;
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
+            return workPlanePick;
+        }
+        else {
+            return undefined;
+        }
+    }
+}