@vived/app 3.9.1 → 4.0.0

package/lib/Components/Babylon/Entities/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("./BabylonEntity"), exports);

package/lib/Components/Babylon/Mocks/MockBabylonRenderingUC.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { BabylonRenderingUC } from "../UC/BabylonRenderingUC";
+export declare class MockBabylonRenderingUC extends BabylonRenderingUC {
+    submitRenderCanvas: jest.Mock<any, any>;
+    clearRenderCanvas: jest.Mock<any, any>;
+    resize: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Babylon/Mocks/MockBabylonRenderingUC.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBabylonRenderingUC = void 0;
+const BabylonRenderingUC_1 = require("../UC/BabylonRenderingUC");
+class MockBabylonRenderingUC extends BabylonRenderingUC_1.BabylonRenderingUC {
+    constructor(appObject) {
+        super(appObject, BabylonRenderingUC_1.BabylonRenderingUC.type);
+        this.submitRenderCanvas = jest.fn();
+        this.clearRenderCanvas = jest.fn();
+        this.resize = jest.fn();
+    }
+}
+exports.MockBabylonRenderingUC = MockBabylonRenderingUC;

package/lib/Components/Babylon/PM/ShowBabylonInspectorPM.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const BabylonEntity_1 = require("../Entities/BabylonEntity");
+class ShowBabylonInspectorPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, ShowBabylonInspectorPM.type);
+        this.onBabylonChange = () => {
+            if (!this.babylon)
+                return;
+            this.doUpdateView(this.babylon.showInspector);
+        };
+        this.babylon = appObject.getComponent(BabylonEntity_1.BabylonEntity.type);
+        if (!this.babylon) {
+            this.warn("ShowBabylonInspectorPM has been added to something without a BabylonEntity");
+            return;
+        }
+        this.babylon.addChangeObserver(this.onBabylonChange);
+        this.onBabylonChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.ShowBabylonInspectorPM = ShowBabylonInspectorPM;
+ShowBabylonInspectorPM.type = "ShowBabylonInspectorPM";

package/lib/Components/Babylon/PM/index.d.ts

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

package/lib/Components/Babylon/PM/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("./ShowBabylonInspectorPM"), exports);

package/lib/Components/Babylon/UC/BabylonRenderingUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class BabylonRenderingUC extends AppObjectUC {
+    static readonly type = "BabylonRenderingUC";
+    static get: (appObjects: AppObjectRepo) => BabylonRenderingUC | undefined;
+    abstract submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    abstract clearRenderCanvas: () => void;
+    abstract resize: () => void;
+}

package/lib/Components/Babylon/UC/BabylonRenderingUC.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabylonRenderingUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class BabylonRenderingUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.BabylonRenderingUC = BabylonRenderingUC;
+BabylonRenderingUC.type = "BabylonRenderingUC";
+BabylonRenderingUC.get = (appObjects) => AppObject_1.getSingletonComponent(BabylonRenderingUC.type, appObjects);

package/lib/Components/Babylon/UC/PixelToSceneRayUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class PixelToSceneRayUC extends AppObjectUC {
+    static readonly type = "PixelToSceneRayUC";
+    static get: (appObjects: AppObjectRepo) => PixelToSceneRayUC | undefined;
+    abstract pixelToSceneRay: (pixelPos: Vector2) => ParametricLine;
+}
+export declare function pixelToSceneRay(pixelPos: Vector2, appObjects: AppObjectRepo): ParametricLine;

package/lib/Components/Babylon/UC/PixelToSceneRayUC.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pixelToSceneRay = exports.PixelToSceneRayUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+class PixelToSceneRayUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.PixelToSceneRayUC = PixelToSceneRayUC;
+PixelToSceneRayUC.type = "PixelToSceneRayUC";
+PixelToSceneRayUC.get = (appObjects) => AppObject_1.getSingletonComponent(PixelToSceneRayUC.type, appObjects);
+function pixelToSceneRay(pixelPos, appObjects) {
+    const uc = PixelToSceneRayUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("pixelToSceneRay", "Unable to find PixelToSceneRayUC");
+        return ValueObjects_1.ParametricLine.Forward();
+    }
+    return uc.pixelToSceneRay(pixelPos);
+}
+exports.pixelToSceneRay = pixelToSceneRay;

package/lib/Components/Babylon/UC/ScenePixelPickUC.d.ts

@@ -0,0 +1,17 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector2, Vector3 } from "../../../ValueObjects";
+export interface ScenePixelPick {
+    sceneRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    appObjectID?: string;
+    normal?: Vector3;
+}
+export declare abstract class ScenePixelPickUC extends AppObjectUC {
+    static readonly type = "ScenePixelPickUC";
+    static get: (appObjects: AppObjectRepo) => ScenePixelPickUC | undefined;
+    abstract scenePixelPick: (pixelPos: Vector2) => ScenePixelPick | undefined;
+}
+export declare function scenePixelPick(pixelPos: Vector2, appObjects: AppObjectRepo): ScenePixelPick | undefined;

package/lib/Components/Babylon/UC/ScenePixelPickUC.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scenePixelPick = exports.ScenePixelPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class ScenePixelPickUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.ScenePixelPickUC = ScenePixelPickUC;
+ScenePixelPickUC.type = "ScenePixelPickUC";
+ScenePixelPickUC.get = (appObjects) => AppObject_1.getSingletonComponent(ScenePixelPickUC.type, appObjects);
+function scenePixelPick(pixelPos, appObjects) {
+    const uc = ScenePixelPickUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("scenePixelPick", "Unable to find ScenePixelPickUC");
+        return;
+    }
+    return uc.scenePixelPick(pixelPos);
+}
+exports.scenePixelPick = scenePixelPick;

package/lib/Components/Babylon/UC/SceneRayPickUC.d.ts

@@ -0,0 +1,16 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector3 } from "../../../ValueObjects";
+export interface SceneRayPick {
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    appObjectID?: string;
+    normal?: Vector3;
+}
+export declare abstract class SceneRayPickUC extends AppObjectUC {
+    static readonly type = "SceneRayPickUC";
+    static get: (appObjects: AppObjectRepo) => SceneRayPickUC | undefined;
+    abstract sceneRayPick: (ray: ParametricLine) => SceneRayPick | undefined;
+}
+export declare function sceneRayPick(ray: ParametricLine, appObjects: AppObjectRepo): SceneRayPick | undefined;

package/lib/Components/Babylon/UC/SceneRayPickUC.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sceneRayPick = exports.SceneRayPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class SceneRayPickUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SceneRayPickUC = SceneRayPickUC;
+SceneRayPickUC.type = "SceneRayPickUC";
+SceneRayPickUC.get = (appObjects) => AppObject_1.getSingletonComponent(SceneRayPickUC.type, appObjects);
+function sceneRayPick(ray, appObjects) {
+    const uc = SceneRayPickUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("sceneRayPick", "Unable to find SceneRayPickUC");
+        return;
+    }
+    return uc.sceneRayPick(ray);
+}
+exports.sceneRayPick = sceneRayPick;

package/lib/Components/Babylon/UC/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BabylonRenderingUC";
+export * from "./PixelToSceneRayUC";
+export * from "./ScenePixelPickUC";
+export * from "./SceneRayPickUC";

package/lib/Components/Babylon/UC/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("./BabylonRenderingUC"), exports);
+__exportStar(require("./PixelToSceneRayUC"), exports);
+__exportStar(require("./ScenePixelPickUC"), exports);
+__exportStar(require("./SceneRayPickUC"), exports);

package/lib/Components/Babylon/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Entities";
+export * from "./UC";
+export * from "./PM";

package/lib/Components/Babylon/index.js

@@ -0,0 +1,15 @@
+"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"), exports);
+__exportStar(require("./UC"), exports);
+__exportStar(require("./PM"), exports);

package/lib/Components/Camera/Entities/CameraEntity.d.ts

@@ -0,0 +1,29 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { Angle } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare abstract class CameraEntity extends AppObjectEntity {
+    static type: string;
+    static get: (appObjects: AppObjectRepo) => CameraEntity | undefined;
+    abstract get nearClip(): number;
+    abstract set nearClip(val: number);
+    abstract get farClip(): number;
+    abstract set farClip(val: number);
+    abstract get fov(): Angle;
+    abstract set fov(val: Angle);
+    abstract readonly transform: Transform3D;
+}
+export declare function makeCameraEntity(appObject: AppObject): CameraEntityImp;
+declare class CameraEntityImp extends CameraEntity {
+    transform: Transform3D;
+    private memoizedNearClip;
+    get nearClip(): number;
+    set nearClip(val: number);
+    private memoizedFarClip;
+    get farClip(): number;
+    set farClip(val: number);
+    private memoizedFOV;
+    get fov(): Angle;
+    set fov(val: Angle);
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Camera/Entities/CameraEntity.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCameraEntity = exports.CameraEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+class CameraEntity extends AppObject_1.AppObjectEntity {
+}
+exports.CameraEntity = CameraEntity;
+CameraEntity.type = "CAMERA_ENTITY";
+CameraEntity.get = (appObjects) => AppObject_1.getSingletonComponent(CameraEntity.type, appObjects);
+function makeCameraEntity(appObject) {
+    return new CameraEntityImp(appObject);
+}
+exports.makeCameraEntity = makeCameraEntity;
+class CameraEntityImp extends CameraEntity {
+    constructor(appObject) {
+        super(appObject, CameraEntity.type);
+        this.memoizedNearClip = new Entities_1.MemoizedNumber(0.01, this.notifyOnChange);
+        this.memoizedFarClip = new Entities_1.MemoizedNumber(10, this.notifyOnChange);
+        this.memoizedFOV = new Entities_1.MemoizedAngle(ValueObjects_1.Angle.FromRadians(0.26), this.notifyOnChange);
+        this.transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+        this.transform.addChangeObserver(this.notifyOnChange);
+    }
+    get nearClip() {
+        return this.memoizedNearClip.val;
+    }
+    set nearClip(val) {
+        this.memoizedNearClip.val = val;
+    }
+    get farClip() {
+        return this.memoizedFarClip.val;
+    }
+    set farClip(val) {
+        this.memoizedFarClip.val = val;
+    }
+    get fov() {
+        return this.memoizedFOV.val;
+    }
+    set fov(val) {
+        this.memoizedFOV.val = val;
+    }
+}

package/lib/Components/Camera/Entities/index.d.ts

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

package/lib/Components/Camera/Entities/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("./CameraEntity"), exports);

package/lib/Components/Camera/Factory/CameraFactoryImp.d.ts

@@ -0,0 +1,4 @@
+import { AppObject } from "@vived/app";
+import { EntityContext } from "Entities/EntityContext";
+import { CameraFactory } from "../Entities/CameraFactory";
+export declare function makeCameraFactory(appObject: AppObject, entities: EntityContext): CameraFactory;

package/lib/Components/Camera/Factory/CameraFactoryImp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCameraFactory = void 0;
+const AppObjectComponents_1 = require("@vived/app/lib/AppObjectComponents");
+const CameraEntity_1 = require("../Entities/CameraEntity");
+const CameraFactory_1 = require("../Entities/CameraFactory");
+const CameraPM_1 = require("../PM/CameraPM");
+function makeCameraFactory(appObject, entities) {
+    return new CameraFactoryImp(appObject, entities);
+}
+exports.makeCameraFactory = makeCameraFactory;
+class CameraFactoryImp extends CameraFactory_1.CameraFactory {
+    constructor(appObject, entities) {
+        super(appObject, CameraFactory_1.CameraFactory.type);
+        this.entities = entities;
+        this.setupCamera = () => {
+            const appObjects = this.entities.appObjects;
+            const cameraEntityAo = appObjects.getOrCreate(CameraFactory_1.CameraFactory.entityAppObjectId);
+            new AppObjectComponents_1.Transform3D(cameraEntityAo);
+            const cameraEntity = CameraEntity_1.makeCameraEntity(cameraEntityAo);
+            CameraPM_1.makeCameraPM(cameraEntityAo);
+            return cameraEntity;
+        };
+    }
+}

package/lib/Components/Camera/PM/CameraPM.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+import { Angle, Vector3 } from "../../../ValueObjects";
+export interface CameraVM {
+    target: Vector3;
+    position: Vector3;
+    nearClip: number;
+    farClip: number;
+    fov: Angle;
+}
+export declare abstract class CameraPM extends AppObjectPM<CameraVM> {
+    static readonly type = "CameraPM";
+    static get: (appObjects: AppObjectRepo) => CameraPM | undefined;
+}
+export declare function makeCameraPM(appObject: AppObject): CameraPMImp;
+declare class CameraPMImp extends CameraPM {
+    private cameraEntity?;
+    onCameraChange: () => void;
+    vmsAreEqual: (a: CameraVM, b: CameraVM) => boolean;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Camera/PM/CameraPM.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCameraPM = exports.CameraPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const CameraEntity_1 = require("../Entities/CameraEntity");
+class CameraPM extends AppObject_1.AppObjectPM {
+}
+exports.CameraPM = CameraPM;
+CameraPM.type = "CameraPM";
+CameraPM.get = (appObjects) => AppObject_1.getSingletonComponent(CameraPM.type, appObjects);
+function makeCameraPM(appObject) {
+    return new CameraPMImp(appObject);
+}
+exports.makeCameraPM = makeCameraPM;
+class CameraPMImp extends CameraPM {
+    constructor(appObject) {
+        super(appObject, CameraPM.type);
+        this.onCameraChange = () => {
+            if (!this.cameraEntity) {
+                return;
+            }
+            const worldDirection = this.cameraEntity.transform.localDirectionToWorld(ValueObjects_1.Vector3.Forward());
+            const target = ValueObjects_1.Vector3.Add(worldDirection, this.cameraEntity.transform.worldPosition);
+            const vm = {
+                position: this.cameraEntity.transform.worldPosition,
+                nearClip: this.cameraEntity.nearClip,
+                farClip: this.cameraEntity.farClip,
+                fov: this.cameraEntity.fov,
+                target,
+            };
+            this.doUpdateView(vm);
+        };
+        this.vmsAreEqual = (a, b) => {
+            if (a.nearClip === b.nearClip &&
+                a.farClip === b.farClip &&
+                ValueObjects_1.Vector3.Equal(a.position, b.position) &&
+                ValueObjects_1.Vector3.Equal(a.target, b.target) &&
+                a.fov.radians === b.fov.radians) {
+                return true;
+            }
+            return false;
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.cameraEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onCameraChange);
+            (_b = this.cameraEntity) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.cameraEntity = appObject.getComponent(CameraEntity_1.CameraEntity.type);
+        if (this.cameraEntity) {
+            this.cameraEntity.addChangeObserver(this.onCameraChange);
+            this.cameraEntity.addOnDisposeObserver(this.dispose);
+            this.onCameraChange();
+        }
+        else {
+            this.warn("App Object does not have a Camera Entity");
+        }
+    }
+}

package/lib/Components/Camera/PM/index.d.ts

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

package/lib/Components/Camera/PM/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("./CameraPM"), exports);

package/lib/Components/Camera/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities";
+export * from "./PM";

package/lib/Components/Camera/index.js

@@ -0,0 +1,14 @@
+"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"), exports);
+__exportStar(require("./PM"), exports);

package/lib/Components/ChannelModel/Entities/ChannelModel.d.ts

@@ -0,0 +1,42 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export declare enum ChannelModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+export declare class ChannelModel extends AppObjectEntity {
+    static readonly type = "CHANNEL_MODEL";
+    static addIfMissing(appObj: AppObject): ChannelModel;
+    static get(appObj: AppObject): ChannelModel | undefined;
+    private _name;
+    get name(): string;
+    set name(name: string);
+    private _boundsMin;
+    get bounds_min(): Vector3;
+    set bounds_min(bounds_min: Vector3);
+    private _boundsMax;
+    get bounds_max(): Vector3;
+    set bounds_max(bounds_max: Vector3);
+    private _defaultPosition;
+    get defaultPosition(): Vector3;
+    set defaultPosition(position: Vector3);
+    private _defaultRotation;
+    get defaultRotation(): Quaternion;
+    set defaultRotation(rotation: Quaternion);
+    private _defaultScale;
+    get defaultScale(): number;
+    set defaultScale(scale: number);
+    private _state;
+    get state(): ChannelModelState;
+    set state(val: ChannelModelState);
+    private _error;
+    get modelError(): Error | undefined;
+    set modelError(val: Error | undefined);
+    private _meshList;
+    get meshList(): string[];
+    set meshList(val: string[]);
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/ChannelModel/Entities/ChannelModel.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModel = exports.ChannelModelState = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+var ChannelModelState;
+(function (ChannelModelState) {
+    ChannelModelState["INIT"] = "Initialized";
+    ChannelModelState["LOADING"] = "Loading";
+    ChannelModelState["READY"] = "Ready";
+    ChannelModelState["ERROR"] = "Error";
+})(ChannelModelState = exports.ChannelModelState || (exports.ChannelModelState = {}));
+class ChannelModel extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, ChannelModel.type);
+        this._name = new Entities_1.MemoizedString("", this.notifyOnChange);
+        this._boundsMin = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
+        this._boundsMax = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
+        this._defaultPosition = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
+        this._defaultRotation = new Entities_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notifyOnChange);
+        this._defaultScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
+        this._state = new Entities_1.MemoizedString(ChannelModelState.INIT, this.notifyOnChange);
+        this._meshList = [];
+        this.dispose = () => {
+            super.dispose();
+        };
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new ChannelModel(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    get name() {
+        return this._name.val;
+    }
+    set name(name) {
+        this._name.val = name;
+    }
+    get bounds_min() {
+        return this._boundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._boundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._defaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._defaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation.val;
+    }
+    set defaultRotation(rotation) {
+        this._defaultRotation.val = rotation;
+    }
+    get defaultScale() {
+        return this._defaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._defaultScale.val = scale;
+    }
+    get state() {
+        return this._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get modelError() {
+        return this._error;
+    }
+    set modelError(val) {
+        this._error = val;
+        this._state.val = ChannelModelState.ERROR;
+    }
+    get meshList() {
+        return [...this._meshList];
+    }
+    set meshList(val) {
+        this._meshList = [...val];
+        this.notifyOnChange();
+    }
+}
+exports.ChannelModel = ChannelModel;
+ChannelModel.type = "CHANNEL_MODEL";