@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/zSpace/UseCases/StylusRootMovementUC.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDefaultStylusRootMovementUC = exports.StylusRootMovementUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const SceneRoot_1 = require("../../SceneRoot");
+const Transform3D_1 = require("../../Transform3D");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class StylusRootMovementUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const uc = appObjects.getAllComponents(StylusRootMovementUC.type);
+        if (uc.length === 0) {
+            console.warn("Unable to find a StylusRootMovementUC. Add one on Mount");
+            return undefined;
+        }
+        else if (uc.length > 1) {
+            console.warn("Multiple StylusRootMovementUC have been found. There should only be one. Using the first one");
+        }
+        return uc[0];
+    }
+}
+exports.StylusRootMovementUC = StylusRootMovementUC;
+StylusRootMovementUC.type = "StylusRootMovementUC";
+function makeDefaultStylusRootMovementUC(appObject) {
+    return new DefaultStylusRootMovementUC(appObject);
+}
+exports.makeDefaultStylusRootMovementUC = makeDefaultStylusRootMovementUC;
+class DefaultStylusRootMovementUC extends StylusRootMovementUC {
+    constructor(appObject) {
+        super(appObject, StylusRootMovementUC.type);
+        this.sceneRootTransform = undefined;
+        this.isTranslating = false;
+        this.move = (pickRay) => {
+            if (!this.isTranslating)
+                return;
+            if (!this.zSpaceEntity)
+                return;
+            if (!this.sceneRootTransform)
+                return;
+            this.sceneRootTransform.worldPosition =
+                this.zSpaceEntity.stylus.helperTransform.worldPosition;
+            this.sceneRootTransform.worldRotation =
+                this.zSpaceEntity.stylus.helperTransform.worldRotation;
+        };
+        this.stop = () => {
+            this.sceneRootTransform = undefined;
+            this.isTranslating = false;
+        };
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(appObject.appObjectRepo);
+        this.sceneRoot = appObject.appObjectRepo.get(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            console.error("SceneRoot app object has not been found in the app object repo");
+        }
+    }
+    initialize(pickRay) {
+        if (!this.sceneRoot)
+            return false;
+        if (!this.zSpaceEntity)
+            return false;
+        this.sceneRootTransform = Transform3D_1.Transform3D.get(this.sceneRoot);
+        if (!this.sceneRootTransform)
+            return false;
+        this.zSpaceEntity.stylus.helperTransform.worldPosition =
+            this.sceneRootTransform.worldPosition;
+        this.zSpaceEntity.stylus.helperTransform.worldRotation =
+            this.sceneRootTransform.worldRotation;
+        this.isTranslating = true;
+        return true;
+    }
+}

package/lib/AppObjectComponents/zSpace/UseCases/ViewFromPoseHook.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { UpdateDTO } from "../Entities/ZSpaceViewEntity";
+export declare abstract class ViewFromPoseHook extends AppObjectUC {
+    static readonly type = "ViewFromPoseHook";
+    abstract onNewXRFrame(frame: XRFrame): void;
+}
+export declare function makeViewFromPoseHook(appObj: AppObject): ViewFromPoseImp;
+declare class ViewFromPoseImp extends ViewFromPoseHook {
+    private zSpace;
+    private xrEntity;
+    onNewXRFrame: () => void;
+    formViewDTO: (view: XRView) => UpdateDTO;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/AppObjectComponents/zSpace/UseCases/ViewFromPoseHook.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeViewFromPoseHook = exports.ViewFromPoseHook = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const XR_1 = require("../../XR");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ViewFromPoseHook extends AppObjectUC_1.AppObjectUC {
+}
+exports.ViewFromPoseHook = ViewFromPoseHook;
+ViewFromPoseHook.type = "ViewFromPoseHook";
+function makeViewFromPoseHook(appObj) {
+    return new ViewFromPoseImp(appObj);
+}
+exports.makeViewFromPoseHook = makeViewFromPoseHook;
+class ViewFromPoseImp extends ViewFromPoseHook {
+    constructor(appObject) {
+        super(appObject, ViewFromPoseHook.type);
+        this.onNewXRFrame = () => {
+            const frame = this.xrEntity.lastXRFrame;
+            if (!frame)
+                return;
+            if (!this.xrEntity.xrReferenceSpace) {
+                console.log("No reference space");
+                return;
+            }
+            const pose = frame.getViewerPose(this.xrEntity.xrReferenceSpace);
+            if (!pose) {
+                console.log("No pose");
+                return;
+            }
+            if (!pose.transform) {
+                console.log("No Pose transform ");
+                return;
+            }
+            const orientation = pose.transform.orientation;
+            if (pose.transform.orientation.x === undefined) {
+                console.log("Pose Orientation in undefined");
+                return;
+            }
+            const pos = pose.transform.position;
+            const headPos = new ValueObjects_1.Vector3(pos.x, pos.y, -pos.z);
+            const headRotation = new ValueObjects_1.Quaternion(orientation.x, orientation.y, -orientation.z, -orientation.w);
+            pose.views.forEach((view, i) => {
+                const viewDTO = this.formViewDTO(view);
+                if (view.eye === "right") {
+                    this.zSpace.rightEyeView.update(viewDTO);
+                }
+                else {
+                    this.zSpace.leftEyeView.update(viewDTO);
+                    const headDTO = Object.assign({}, viewDTO);
+                    headDTO.position = headPos;
+                    headDTO.rotation = headRotation;
+                    this.zSpace.headView.update(headDTO);
+                }
+            });
+        };
+        this.formViewDTO = (view) => {
+            const xrProjMatrix = ValueObjects_1.Matrix.FromFloat32Array(view.projectionMatrix);
+            const projectionMatrix = ValueObjects_1.Matrix.FlipProjectionMatrixHand(xrProjMatrix);
+            const xrPosition = view.transform.position;
+            const xrOrientation = view.transform.orientation;
+            const position = new ValueObjects_1.Vector3(xrPosition.x, xrPosition.y, -xrPosition.z);
+            const rotation = new ValueObjects_1.Quaternion(xrOrientation.x, xrOrientation.y, -xrOrientation.z, -xrOrientation.w);
+            return {
+                position,
+                rotation,
+                projectionMatrix,
+                view
+            };
+        };
+        const zSpaceEntity = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (!zSpaceEntity) {
+            throw new Error("No ZSpace Entity");
+        }
+        this.zSpace = zSpaceEntity;
+        const xrEntity = zSpaceEntity.appObject.getComponent(XR_1.XREntity.type);
+        if (!xrEntity) {
+            throw new Error("No XR Entity");
+        }
+        this.xrEntity = xrEntity;
+        this.xrEntity.addChangeObserver(this.onNewXRFrame);
+    }
+}

package/lib/AppObjectComponents/zSpace/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./Entities/ZSpaceDisplayEntity";
+export * from "./Entities/ZSpaceEntity";
+export * from "./Entities/ZSpaceStylusEntity";
+export * from "./Entities/ZSpaceViewEntity";
+export * from "./PM/ZSpaceDisplayPM";
+export * from "./PM/ZSpaceIsEnabledPM";
+export * from "./UseCases/StylusFromGamepadHook";
+export * from "./UseCases/StylusRootMovementUC";
+export * from "./UseCases/ViewFromPoseHook";
+export * from "./Controllers/ZSpaceScaleRoot";
+export * from "./Controllers/ZSpaceStylusRootMovement";
+export * from "./Factories/makeZSpace";

package/lib/AppObjectComponents/zSpace/index.js

@@ -0,0 +1,24 @@
+"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("./Entities/ZSpaceDisplayEntity"), exports);
+__exportStar(require("./Entities/ZSpaceEntity"), exports);
+__exportStar(require("./Entities/ZSpaceStylusEntity"), exports);
+__exportStar(require("./Entities/ZSpaceViewEntity"), exports);
+__exportStar(require("./PM/ZSpaceDisplayPM"), exports);
+__exportStar(require("./PM/ZSpaceIsEnabledPM"), exports);
+__exportStar(require("./UseCases/StylusFromGamepadHook"), exports);
+__exportStar(require("./UseCases/StylusRootMovementUC"), exports);
+__exportStar(require("./UseCases/ViewFromPoseHook"), exports);
+__exportStar(require("./Controllers/ZSpaceScaleRoot"), exports);
+__exportStar(require("./Controllers/ZSpaceStylusRootMovement"), exports);
+__exportStar(require("./Factories/makeZSpace"), exports);

package/lib/Entities/QuestionChallenge.js

@@ -29,6 +29,7 @@ class QuestionChallengeImp {
                 console.warn(`Answer with ID ${answer.id} already exists. Overwriting`);
             }
             this.answerLookup.set(answer.id, answer);
+            answer.addObserver(this.observers.notify);
             this.reset();
         };
         this.removeAnswer = (id) => {
@@ -36,6 +37,7 @@ class QuestionChallengeImp {
             if (!answer)
                 return;
             this.answerLookup.delete(id);
+            answer.removeObserver(this.observers.notify);
             this.reset();
         };
         this.getAnswer = (id) => {

package/lib/Types/AppBoundary.d.ts

@@ -0,0 +1,6 @@
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}

package/lib/Types/AppBoundary.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/AssetMetaDTO.d.ts

@@ -0,0 +1,5 @@
+export interface AssetMetaDTO {
+    id: string;
+    name: string;
+    description: string;
+}

package/lib/Types/AssetMetaDTO.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/UseCases/Handlers/SetThemeColorsBase.d.ts

@@ -0,0 +1,13 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export interface SetThemeColorsDTO {
+    colors: object;
+}
+export declare type SetThemeColorsAction = (colors: SetThemeColorsDTO) => void;
+export declare class SetThemeColorsBase extends RequestHandler {
+    readonly requestType = "SET_THEME_COLORS";
+    readonly payloadVersion = 1;
+    action: SetThemeColorsAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetThemeColorsBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetThemeColorsBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetThemeColorsBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_THEME_COLORS";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.colors === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetThemeColorsBase = SetThemeColorsBase;

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

@@ -7,3 +7,4 @@ export * from "./ShowBabylonInspectorBase";
 export * from "./StartAppBase";
 export * from "./StopAppBase";
 export * from "./StopZSpaceBase";
+export * from "./SetThemeColorsBase";

package/lib/UseCases/Handlers/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./ShowBabylonInspectorBase"), exports);
 __exportStar(require("./StartAppBase"), exports);
 __exportStar(require("./StopAppBase"), exports);
 __exportStar(require("./StopZSpaceBase"), exports);
+__exportStar(require("./SetThemeColorsBase"), exports);

package/lib/Utilities/generateUniqueID.d.ts

@@ -0,0 +1 @@
+export declare function generateUniqueID(): string;

package/lib/Utilities/generateUniqueID.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUniqueID = void 0;
+const uuid_1 = require("uuid");
+function generateUniqueID() {
+    return uuid_1.v4();
+}
+exports.generateUniqueID = generateUniqueID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "3.8.0",
+  "version": "3.9.1",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/Entities/FocusCamera.d.ts

@@ -1,70 +0,0 @@
-import { Vector3 } from "../ValueObjects";
-export declare type OnFocusCameraChange = () => void;
-export interface FocusCameraLerper {
-    cancelLerp: () => void;
-}
-export interface FocusCameraData {
-    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;
-        };
-    };
-}
-export interface FocusCamera {
-    alpha: number;
-    beta: number;
-    radius: number;
-    target: Vector3;
-    direction: Vector3;
-    cameraPosition: Vector3;
-    nearClip: number;
-    farClip: number;
-    defaultAlpha: number;
-    defaultBeta: number;
-    defaultRadius: number;
-    defaultTarget: Vector3;
-    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: FocusCameraLerper) => void;
-    lerpCompleted: () => void;
-    cancelLerp: () => void;
-    applyData: (data: FocusCameraData) => void;
-    addObserver: (observer: OnFocusCameraChange) => void;
-    removeObserver: (observer: OnFocusCameraChange) => void;
-}
-export declare function makeFocusCamera(): FocusCamera;

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