@vived/app 2.42.1 → 2.43.0

package/lib/Entities/SceneObject.d.ts

@@ -4,8 +4,10 @@ export declare abstract class SceneObject extends ObservableEntity {
     abstract readonly id: string;
     abstract get label(): string;
     abstract set label(label: string);
-    abstract get enabled(): boolean;
-    abstract set enabled(enabled: boolean);
+    abstract get shown(): boolean;
+    abstract set shown(shown: boolean);
+    abstract get canBeStuck(): boolean;
+    abstract stick(durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
     abstract transform: TransformNode;
 }
 export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/SceneObject.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSceneObject = exports.SceneObject = void 0;
+const ValueObjects_1 = require("../ValueObjects");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedString_1 = require("./MemoizedString");
 const ObservableEntity_1 = require("./ObservableEntity");
@@ -16,8 +17,16 @@ class SceneObjectImp extends SceneObject {
     constructor(id) {
         super();
         this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.memoizedShown = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
         this.transform = TransformNode_1.makeTransformNode();
+        this.stick = (durationMS, easeFn, onStickComplete) => {
+            if (!this.canBeStuck) {
+                if (onStickComplete)
+                    onStickComplete();
+                return;
+            }
+            this.transform.lerp(durationMS, easeFn, ValueObjects_1.Vector3.Zero(), undefined, undefined, onStickComplete);
+        };
         this.id = id;
         this.transform.addObserver(this.notify);
     }
@@ -27,10 +36,18 @@ class SceneObjectImp extends SceneObject {
     set label(label) {
         this.memoizedLabel.val = label;
     }
-    get enabled() {
-        return this.memoizedEnabled.val;
+    get shown() {
+        return this.memoizedShown.val;
     }
-    set enabled(enabled) {
-        this.memoizedEnabled.val = enabled;
+    set shown(enabled) {
+        this.memoizedShown.val = enabled;
+    }
+    get canBeStuck() {
+        if (ValueObjects_1.Vector3.Equal(this.transform.localPosition, ValueObjects_1.Vector3.Zero())) {
+            return false;
+        }
+        else {
+            return true;
+        }
     }
 }

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

@@ -0,0 +1,2 @@
+export * from './modelDataLoader';
+export * from './setActiveSceneModel';

package/lib/UseCases/SceneModel/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("./modelDataLoader"), exports);
+__exportStar(require("./setActiveSceneModel"), exports);

package/lib/UseCases/SceneModel/modelDataLoader.d.ts

@@ -0,0 +1,3 @@
+import { AppDispatcher, SceneModelDTO } from "../../Entities";
+export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+export declare function makeModelDataLoader(appDispatcher: AppDispatcher): (modelID: string) => Promise<SceneModelDTO>;

package/lib/UseCases/SceneModel/modelDataLoader.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelDataLoader = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+function makeModelDataLoader(appDispatcher) {
+    return function modelDataLoader(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataAssets = yield appDispatcher.getLinkedAssets(modelID, exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE);
+                if (dataAssets.length === 0) {
+                    return Promise.reject(new Error("Model asset does not have data"));
+                }
+                const dataFileBlobURL = yield appDispatcher.getAssetBlobURL(dataAssets[0].id);
+                const fetchDataResp = yield fetch(dataFileBlobURL);
+                const modelJSONData = yield fetchDataResp.json();
+                return Promise.resolve(modelJSONData);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    };
+}
+exports.makeModelDataLoader = makeModelDataLoader;

package/lib/UseCases/SceneModel/setActiveSceneModel.d.ts

@@ -0,0 +1,2 @@
+import { AppDispatcher, SceneModel, SceneModelRepo, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function makeSetActiveModel(sceneModelRepo: SceneModelRepo, sceneObjectRepo: SceneObjectsRepo, sceneRoot: SceneRoot, appDispatcher: AppDispatcher): (modelID: string) => Promise<SceneModel>;

package/lib/UseCases/SceneModel/setActiveSceneModel.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetActiveModel = void 0;
+const Entities_1 = require("../../Entities");
+function makeSetActiveModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatcher) {
+    return function setActiveSceneModel(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sceneModel = sceneModelRepo.get(modelID);
+            if (sceneModel === undefined) {
+                sceneModel = Entities_1.makeSceneModel(modelID);
+                sceneModelRepo.add(modelID, sceneModel);
+            }
+            sceneModelRepo.activeModelID = modelID;
+            if (sceneModel.state === Entities_1.SceneModelState.LOADING) {
+                return Promise.resolve(sceneModel);
+            }
+            if (sceneModel.state === Entities_1.SceneModelState.READY) {
+                sceneModelRepo.activeModelID = modelID;
+                return Promise.resolve(sceneModel);
+            }
+            sceneModel.error = undefined;
+            sceneModel.state = Entities_1.SceneModelState.LOADING;
+            sceneModelRepo.isLoadingSceneModel = true;
+            const dto = {
+                title: "Loading active model and data",
+                message: "Loading...",
+            };
+            const closeSpinner = yield appDispatcher.showSpinner(dto);
+            try {
+                const dataDTO = yield sceneModelRepo.dataLoader(modelID);
+                sceneModel.applyData(dataDTO);
+                sceneModel.getAllObjects().forEach((meshObject) => {
+                    let so = sceneObjectRepo.get(meshObject.id);
+                    if (!so) {
+                        so = Entities_1.makeSceneObject(meshObject.id);
+                        sceneObjectRepo.add(meshObject.id, so);
+                    }
+                    so.label = meshObject.label;
+                    so.transform.parent = sceneRoot.transform;
+                    so.notify();
+                });
+                yield sceneModelRepo.modelLoader(modelID);
+                sceneModel.state = Entities_1.SceneModelState.READY;
+                sceneModelRepo.isLoadingSceneModel = false;
+                closeSpinner();
+                return Promise.resolve(sceneModel);
+            }
+            catch (e) {
+                const error = e;
+                sceneModelRepo.isLoadingSceneModel = false;
+                sceneModelRepo.clearActiveModel();
+                sceneModel.error = error;
+                closeSpinner();
+                const alertDTO = {
+                    title: "Load Error",
+                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
+                    closeButtonLabel: "OK",
+                    closeCallback: () => {
+                        // nada
+                    },
+                };
+                appDispatcher.showAlert(alertDTO);
+                return Promise.reject(error);
+            }
+        });
+    };
+}
+exports.makeSetActiveModel = makeSetActiveModel;

package/lib/UseCases/SceneObject/PeelSceneObjectBase.d.ts

@@ -0,0 +1,20 @@
+import { Babylon, SceneObjectsRepo, TransformNode } from "../../Entities";
+import { ParametricLine } from "../../ValueObjects";
+export declare class PeelSceneObjectBase {
+    private babylon;
+    private sceneObjectRepo;
+    get peeledSceneObjectID(): string | undefined;
+    private _sceneObject;
+    private _didPeel;
+    get didPeel(): boolean;
+    private _doPeel;
+    private _transformToPeel;
+    get peelingTransform(): TransformNode | undefined;
+    private _rootPos;
+    private _peelPlane;
+    private _pickOffset;
+    tryInitializePeel: (pickRay: ParametricLine) => void;
+    updatePeel: (pickRay: ParametricLine) => void;
+    stopPeel: () => void;
+    constructor(babylon: Babylon, sceneObjectRepo: SceneObjectsRepo);
+}

package/lib/UseCases/SceneObject/PeelSceneObjectBase.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeelSceneObjectBase = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PeelSceneObjectBase {
+    constructor(babylon, sceneObjectRepo) {
+        this.babylon = babylon;
+        this.sceneObjectRepo = sceneObjectRepo;
+        this._didPeel = false;
+        this._doPeel = false;
+        this._transformToPeel = undefined;
+        this._peelPlane = ValueObjects_1.ParametricPlane.XY();
+        this._pickOffset = ValueObjects_1.Vector3.Zero();
+        this.tryInitializePeel = (pickRay) => {
+            var _a, _b;
+            this._doPeel = false;
+            this._didPeel = false;
+            this._transformToPeel = undefined;
+            const sceneObjectID = this.babylon.sceneObjectRayPick(pickRay);
+            if (!sceneObjectID)
+                return;
+            const sceneObject = this.sceneObjectRepo.get(sceneObjectID);
+            if (!sceneObject)
+                return;
+            this._sceneObject = sceneObject;
+            this._transformToPeel = sceneObject.transform;
+            const scenePick = this.babylon.sceneRayPick(pickRay);
+            if (!scenePick)
+                return;
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            const planePickPos = (_a = scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_b = this._peelPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this._rootPos = this._transformToPeel.worldPosition;
+            this._pickOffset = ValueObjects_1.Vector3.Subtract(this._rootPos, pick);
+            this._doPeel = true;
+        };
+        this.updatePeel = (pickRay) => {
+            var _a;
+            if (!this._doPeel)
+                return;
+            if (!this._transformToPeel)
+                return;
+            const pick = (_a = this._peelPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._transformToPeel.worldPosition = ValueObjects_1.Vector3.Add(pick, this._pickOffset);
+            this._didPeel = true;
+        };
+        this.stopPeel = () => {
+            this._doPeel = false;
+            this._didPeel = false;
+            this._transformToPeel = undefined;
+            this._rootPos = undefined;
+        };
+    }
+    get peeledSceneObjectID() {
+        var _a;
+        return (_a = this._sceneObject) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    get didPeel() {
+        return this._didPeel;
+    }
+    get peelingTransform() {
+        return this._transformToPeel;
+    }
+}
+exports.PeelSceneObjectBase = PeelSceneObjectBase;

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

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

package/lib/UseCases/SceneObject/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("./PeelSceneObjectBase"), exports);

package/lib/UseCases/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./setDevicePreview";
 export * from "./Handlers";
 export * from "./QuestionChallenge";
+export * from "./SceneModel";
+export * from "./SceneObject";
 export * from "./LerpVector3";
 export * from "./SceneRoot";
 export * from "./HoverLabels/trySetHoverLabel";

package/lib/UseCases/index.js

@@ -13,6 +13,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./Handlers"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneModel"), exports);
+__exportStar(require("./SceneObject"), exports);
 __exportStar(require("./LerpVector3"), exports);
 __exportStar(require("./SceneRoot"), exports);
 __exportStar(require("./HoverLabels/trySetHoverLabel"), exports);

package/package.json

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