@vived/app 2.33.0 → 2.35.0

package/lib/Entities/FramedScreen.d.ts

@@ -0,0 +1,15 @@
+import { FramedScreenContainer } from "./FramedScreenContainer";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class FramedScreen extends ObservableEntity {
+    abstract get containers(): FramedScreenContainer[];
+    abstract addContainer(container: FramedScreenContainer): void;
+    abstract addContainerByID(id: string): FramedScreenContainer;
+    abstract removeContainer(id: string): void;
+    abstract hasContainer(id: string): boolean;
+    abstract getContainerByID(id: string): FramedScreenContainer | undefined;
+    abstract get screenWidth(): number;
+    abstract set screenWidth(width: number);
+    abstract get screenHeight(): number;
+    abstract set screenHeight(height: number);
+}
+export declare function makeFramedScreen(): FramedScreen;

package/lib/Entities/FramedScreen.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFramedScreen = exports.FramedScreen = void 0;
+const FramedScreenContainer_1 = require("./FramedScreenContainer");
+const MemoizedNumber_1 = require("./MemoizedNumber");
+const ObservableEntity_1 = require("./ObservableEntity");
+class FramedScreen extends ObservableEntity_1.ObservableEntity {
+}
+exports.FramedScreen = FramedScreen;
+function makeFramedScreen() {
+    return new FramedScreenImp();
+}
+exports.makeFramedScreen = makeFramedScreen;
+class FramedScreenImp extends FramedScreen {
+    constructor() {
+        super(...arguments);
+        this.memoizeWidth = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this.memoizeHeight = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this._containerLookup = new Map();
+    }
+    get screenWidth() {
+        return this.memoizeWidth.val;
+    }
+    set screenWidth(val) {
+        this.memoizeWidth.val = val;
+    }
+    get screenHeight() {
+        return this.memoizeHeight.val;
+    }
+    set screenHeight(val) {
+        this.memoizeHeight.val = val;
+    }
+    get containers() {
+        return Array.from(this._containerLookup.values());
+    }
+    addContainer(container) {
+        this._containerLookup.set(container.id, container);
+        this.notify();
+    }
+    addContainerByID(id) {
+        const newContainer = FramedScreenContainer_1.makeFramedScreenContainer(id);
+        this.addContainer(newContainer);
+        return newContainer;
+    }
+    removeContainer(id) {
+        const container = this._containerLookup.get(id);
+        if (container) {
+            this._containerLookup.delete(id);
+            this.notify();
+        }
+    }
+    hasContainer(id) {
+        return this._containerLookup.has(id);
+    }
+    getContainerByID(id) {
+        return this._containerLookup.get(id);
+    }
+}

package/lib/Entities/FramedScreenContainer.d.ts

@@ -0,0 +1,12 @@
+import { Vector2 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class FramedScreenContainer extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get position(): Vector2;
+    abstract set position(p: Vector2);
+    abstract get size(): Vector2;
+    abstract set size(s: Vector2);
+    abstract get show(): boolean;
+    abstract set show(s: boolean);
+}
+export declare function makeFramedScreenContainer(id: string): FramedScreenContainer;

package/lib/Entities/FramedScreenContainer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFramedScreenContainer = exports.FramedScreenContainer = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedVector2_1 = require("./MemoizedVector2");
+const ObservableEntity_1 = require("./ObservableEntity");
+class FramedScreenContainer extends ObservableEntity_1.ObservableEntity {
+}
+exports.FramedScreenContainer = FramedScreenContainer;
+function makeFramedScreenContainer(id) {
+    return new FramedScreenContainerImp(id);
+}
+exports.makeFramedScreenContainer = makeFramedScreenContainer;
+class FramedScreenContainerImp extends FramedScreenContainer {
+    constructor(id) {
+        super();
+        this.memozedPos = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.Zero(), this.notify);
+        this.memozedSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.Zero(), this.notify);
+        this.memoizedShow = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.id = id;
+    }
+    get position() {
+        return this.memozedPos.val;
+    }
+    set position(p) {
+        this.memozedPos.val = p;
+    }
+    get size() {
+        return this.memozedSize.val;
+    }
+    set size(s) {
+        this.memozedSize.val = s;
+    }
+    get show() {
+        return this.memoizedShow.val;
+    }
+    set show(s) {
+        this.memoizedShow.val = s;
+    }
+}

package/lib/Entities/MeshModel.d.ts

@@ -0,0 +1,68 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { ModelObject } from "./ModelObject";
+import { ObservableEntity } from "./ObservableEntity";
+export interface MeshModelData {
+    version: number;
+    objects: ObjectData[];
+    name: string;
+    description: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}
+export interface ObjectData {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export declare abstract class MeshModel extends ObservableEntity {
+    abstract readonly objects: ModelObject[];
+    abstract hasObject(id: string): boolean;
+    abstract getObjectById(id: string): ModelObject | undefined;
+    abstract getObjectByPath(path: string): ModelObject | undefined;
+    abstract addObject(object: ModelObject): void;
+    abstract deleteObject(id: string): void;
+    abstract get modelFile(): File | undefined;
+    abstract set modelFile(file: File | undefined);
+    abstract get version(): number;
+    abstract set version(scale: number);
+    abstract get name(): string;
+    abstract set name(name: string);
+    abstract get description(): string;
+    abstract set description(name: string);
+    abstract get image(): Blob | undefined;
+    abstract set image(image: Blob | undefined);
+    abstract get imageURL(): string | undefined;
+    abstract get bounds_min(): Vector3;
+    abstract set bounds_min(position: Vector3);
+    abstract get bounds_max(): Vector3;
+    abstract set bounds_max(position: Vector3);
+    abstract get defaultPosition(): Vector3;
+    abstract set defaultPosition(position: Vector3);
+    abstract get defaultRotation(): Quaternion;
+    abstract set defaultRotation(rotation: Quaternion);
+    abstract get defaultScale(): number;
+    abstract set defaultScale(scale: number);
+    abstract getData(): MeshModelData;
+    abstract setData(data: MeshModelData): void;
+}
+export declare function makeMeshModel(): MeshModel;

package/lib/Entities/MeshModel.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMeshModel = exports.MeshModel = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedString_1 = require("./MemoizedString");
+const MemoizedVector3_1 = require("./MemoizedVector3");
+const ModelObject_1 = require("./ModelObject");
+const ObservableEntity_1 = require("./ObservableEntity");
+class MeshModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.MeshModel = MeshModel;
+function makeMeshModel() {
+    return new MeshModelImp();
+}
+exports.makeMeshModel = makeMeshModel;
+class MeshModelImp extends MeshModel {
+    constructor() {
+        super(...arguments);
+        this.objects = [];
+        this._modelFile = undefined;
+        this._memoizedVersion = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
+        this._image = undefined;
+        this._memoizedBoundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedBoundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedDefaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
+        this._memoizedDefaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._imageURL = undefined;
+    }
+    hasObject(id) {
+        return !!this.objects.find((obj) => obj.id === id);
+    }
+    getObjectById(id) {
+        return this.objects.find((obj) => obj.id === id);
+    }
+    getObjectByPath(path) {
+        let rVal;
+        this.objects.forEach((obj) => {
+            if (obj.meshPaths.includes(path)) {
+                rVal = obj;
+            }
+        });
+        return rVal;
+    }
+    addObject(object) {
+        object.addObserver(this.notify);
+        this.objects.push(object);
+        this.notify();
+    }
+    deleteObject(id) {
+        this.objects = this.objects.filter((obj) => {
+            if (obj.id === id) {
+                obj.removeObserver(this.notify);
+                return false;
+            }
+            return true;
+        });
+        this.notify();
+    }
+    get modelFile() {
+        return this._modelFile;
+    }
+    set modelFile(file) {
+        this._modelFile = file;
+        this.notify();
+    }
+    get version() {
+        return this._memoizedVersion.val;
+    }
+    set version(version) {
+        this._memoizedVersion.val = version;
+    }
+    get name() {
+        return this._memoizedName.val;
+    }
+    set name(name) {
+        this._memoizedName.val = name;
+    }
+    get description() {
+        return this._memoizedDescription.val;
+    }
+    set description(description) {
+        this._memoizedDescription.val = description;
+    }
+    get image() {
+        return this._image;
+    }
+    set image(image) {
+        if (!this._image && !image)
+            return;
+        if (this._image && image && this._image.size === image.size)
+            return;
+        this._image = image;
+        if (image === undefined) {
+            this._imageURL = undefined;
+        }
+        else {
+            this._imageURL = URL.createObjectURL(image);
+        }
+        this.notify();
+    }
+    get imageURL() {
+        return this._imageURL;
+    }
+    get bounds_min() {
+        return this._memoizedBoundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._memoizedBoundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._memoizedBoundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._memoizedBoundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._memoizedDefaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._memoizedDefaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation;
+    }
+    set defaultRotation(rotation) {
+        if (ValueObjects_1.Quaternion.Equal(this._defaultRotation, rotation))
+            return;
+        this._defaultRotation = rotation;
+        this.notify();
+    }
+    get defaultScale() {
+        return this._memoizedDefaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._memoizedDefaultScale.val = scale;
+    }
+    getData() {
+        return {
+            version: this.version,
+            objects: this.objects.map((obj) => ({
+                id: obj.id,
+                label: obj.label,
+                meshPaths: [...obj.meshPaths],
+            })),
+            name: this.name,
+            description: this.description,
+            bounds_min: this.bounds_min,
+            bounds_max: this.bounds_max,
+            defaultPosition: this.defaultPosition,
+            defaultRotation: this.defaultRotation,
+            defaultScale: this.defaultScale,
+        };
+    }
+    setData(data) {
+        this.version = data.version;
+        data.objects.forEach((obj) => {
+            const modelObject = ModelObject_1.makeModelObject(obj.id);
+            modelObject.label = obj.label;
+            obj.meshPaths.forEach((path) => modelObject.addMeshPath(path));
+            this.addObject(modelObject);
+        });
+        this.name = data.name;
+        this.description = data.description;
+        this.bounds_min = data.bounds_min;
+        this.bounds_max = data.bounds_max;
+        this.defaultPosition = data.defaultPosition;
+        this.defaultRotation = data.defaultRotation;
+        this.defaultScale = data.defaultScale;
+    }
+}

package/lib/Entities/ModelObject.d.ts

@@ -0,0 +1,10 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class ModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get label(): string;
+    abstract set label(label: string);
+    abstract get meshPaths(): string[];
+    abstract addMeshPath(path: string): void;
+    abstract removeMeshPath(path: string): void;
+}
+export declare function makeModelObject(id: string): ModelObject;

package/lib/Entities/ModelObject.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelObject = exports.ModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class ModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.ModelObject = ModelObject;
+function makeModelObject(id) {
+    return new ModelObjectImp(id);
+}
+exports.makeModelObject = makeModelObject;
+class ModelObjectImp extends ModelObject {
+    constructor(id) {
+        super();
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = new Set([]);
+        this.id = id;
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(label) {
+        this.memoizedLabel.val = label;
+    }
+    get meshPaths() {
+        return Array.from(this._meshPaths);
+    }
+    addMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            return;
+        }
+        this._meshPaths.add(path);
+        this.notify();
+    }
+    removeMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            this._meshPaths.delete(path);
+            this.notify();
+        }
+    }
+}

package/lib/Entities/index.d.ts

@@ -4,6 +4,8 @@ export * from "./AppHandler";
 export * from "./Babylon";
 export * from "./BaseApp";
 export * from "./DevicePreview";
+export * from "./FramedScreenContainer";
+export * from "./FramedScreen";
 export * from "./HoverLabels";
 export * from "./KeyboardInput";
 export * from "./MemoizedBoolean";
@@ -11,7 +13,9 @@ export * from "./MemoizedNumber";
 export * from "./MemoizedString";
 export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
+export * from "./MeshModel";
 export * from "./MessageSystem";
+export * from "./ModelObject";
 export * from "./ObserverList";
 export * from "./StateMachine";
 export * from "./Tool";

package/lib/Entities/index.js

@@ -16,6 +16,8 @@ __exportStar(require("./AppHandler"), exports);
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./BaseApp"), exports);
 __exportStar(require("./DevicePreview"), exports);
+__exportStar(require("./FramedScreenContainer"), exports);
+__exportStar(require("./FramedScreen"), exports);
 __exportStar(require("./HoverLabels"), exports);
 __exportStar(require("./KeyboardInput"), exports);
 __exportStar(require("./MemoizedBoolean"), exports);
@@ -23,7 +25,9 @@ __exportStar(require("./MemoizedNumber"), exports);
 __exportStar(require("./MemoizedString"), exports);
 __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
+__exportStar(require("./MeshModel"), exports);
 __exportStar(require("./MessageSystem"), exports);
+__exportStar(require("./ModelObject"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./Tool"), exports);

package/lib/PresentationManagers/FramedScreenContainerPM.d.ts

@@ -0,0 +1,18 @@
+import { FramedScreen } from "../Entities";
+export interface FramedContainerVM {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    show: boolean;
+}
+export declare class FramedContainerPM {
+    private updateView;
+    private container?;
+    private lastVM?;
+    doUpdateView: () => void;
+    private vmHadChanged;
+    dispose: () => void;
+    constructor(containerID: string, framedScreen: FramedScreen, updateView: (vm: FramedContainerVM) => void);
+}
+export declare const defaultFramedContainerVM: FramedContainerVM;

package/lib/PresentationManagers/FramedScreenContainerPM.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFramedContainerVM = exports.FramedContainerPM = void 0;
+class FramedContainerPM {
+    constructor(containerID, framedScreen, updateView) {
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = Object.assign({}, exports.defaultFramedContainerVM);
+            if (!this.container) {
+                this.updateView(vm);
+                return;
+            }
+            vm.height = this.container.size.y;
+            vm.width = this.container.size.x;
+            vm.top = this.container.position.y;
+            vm.left = this.container.position.x;
+            vm.show = this.container.show;
+            if (!this.vmHadChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.vmHadChanged = (newVM) => {
+            if (this.lastVM === undefined)
+                return true;
+            if (this.lastVM.height === newVM.height &&
+                this.lastVM.width === newVM.width &&
+                this.lastVM.top === newVM.top &&
+                this.lastVM.left === newVM.left &&
+                this.lastVM.show === newVM.show) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        };
+        this.dispose = () => {
+            var _a;
+            (_a = this.container) === null || _a === void 0 ? void 0 : _a.removeObserver(this.doUpdateView);
+        };
+        this.container = framedScreen.getContainerByID(containerID);
+        if (this.container) {
+            this.container.addObserver(this.doUpdateView);
+        }
+        this.doUpdateView();
+    }
+}
+exports.FramedContainerPM = FramedContainerPM;
+exports.defaultFramedContainerVM = {
+    height: 0,
+    left: 0,
+    top: 0,
+    width: 0,
+    show: false
+};

package/lib/PresentationManagers/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./DevicePreviewPM";
+export * from "./FramedScreenContainerPM";
 export * from "./IsAuthoringPM";
 export * from "./PresentationManager";
 export * from "./ShowBabylonInspectorPM";

package/lib/PresentationManagers/index.js

@@ -11,6 +11,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DevicePreviewPM"), exports);
+__exportStar(require("./FramedScreenContainerPM"), exports);
 __exportStar(require("./IsAuthoringPM"), exports);
 __exportStar(require("./PresentationManager"), exports);
 __exportStar(require("./ShowBabylonInspectorPM"), exports);

package/package.json

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