@vived/app 2.15.7 → 2.18.0

package/lib/Entities/Babylon.d.ts

@@ -1,4 +1,4 @@
-import { ParametricLine, Vector2, Vector3 } from "../ValueObjects";
+import { ParametricLine, Result, Vector2, Vector3 } from "../ValueObjects";
 export declare type OnBabylonChange = () => void;
 export interface ScenePick {
     mouseRay: ParametricLine;
@@ -16,6 +16,8 @@ export interface Babylon {
     renderCanvas?: HTMLCanvasElement;
     scenePick: (pixelPos: Vector2) => ScenePick;
     sceneRay: (pixelPos: Vector2) => ParametricLine;
+    sceneObjectPick: (pixelPos: Vector2) => Result<string, SceneObjectPickErrors>;
+    makeSceneObjectMeta: (id: string) => object;
     updateCanvasSize: () => void;
     submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
     clearRenderCanvas: () => void;
@@ -28,3 +30,13 @@ export interface Babylon {
     removeObserver: (observer: OnBabylonChange) => void;
 }
 export declare function makeBabylon(): Babylon;
+export declare class SceneObjectPickErrorNoPicker extends Error {
+    constructor();
+}
+export declare class SceneObjectPickErrorNoPick extends Error {
+    constructor();
+}
+export declare class SceneObjectPickErrorNoID extends Error {
+    constructor();
+}
+export declare type SceneObjectPickErrors = SceneObjectPickErrorNoPicker | SceneObjectPickErrorNoPick | SceneObjectPickErrorNoID;

package/lib/Entities/Babylon.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeBabylon = void 0;
+exports.SceneObjectPickErrorNoID = exports.SceneObjectPickErrorNoPick = exports.SceneObjectPickErrorNoPicker = exports.makeBabylon = void 0;
 const ValueObjects_1 = require("../ValueObjects");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedVector2_1 = require("./MemoizedVector2");
@@ -11,6 +11,7 @@ function makeBabylon() {
 exports.makeBabylon = makeBabylon;
 class BabylonImp {
     constructor() {
+        this._scenePickerHasBeenSet = false;
         this.scenePick = () => {
             console.warn("orignal scene picker");
             return {
@@ -73,10 +74,32 @@ class BabylonImp {
         };
         this.registerScenePicker = (picker) => {
             this.scenePick = picker;
+            this._scenePickerHasBeenSet = true;
         };
         this.registerSceneRayer = (rayer) => {
             this.sceneRay = rayer;
         };
+        this.sceneObjectPick = (pixelPos) => {
+            var _a;
+            if (!this._scenePickerHasBeenSet) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoPicker());
+            }
+            const scenePick = this.scenePick(pixelPos);
+            if (!scenePick.hit) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoPick());
+            }
+            if (!((_a = scenePick.objectPickMeta) === null || _a === void 0 ? void 0 : _a.hasOwnProperty("sceneObjectID"))) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+            }
+            const sceneObjectId = scenePick.objectPickMeta.sceneObjectID;
+            if (!sceneObjectId) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+            }
+            return ValueObjects_1.resolve(sceneObjectId);
+        };
+        this.makeSceneObjectMeta = (id) => {
+            return { sceneObjectID: id };
+        };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
         this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
     }
@@ -96,3 +119,24 @@ class BabylonImp {
         this.memoizedCanvasSize.val = val;
     }
 }
+class SceneObjectPickErrorNoPicker extends Error {
+    constructor() {
+        super();
+        this.message = "No picker has been registered";
+    }
+}
+exports.SceneObjectPickErrorNoPicker = SceneObjectPickErrorNoPicker;
+class SceneObjectPickErrorNoPick extends Error {
+    constructor() {
+        super();
+        this.message = "Nothing was picked on";
+    }
+}
+exports.SceneObjectPickErrorNoPick = SceneObjectPickErrorNoPick;
+class SceneObjectPickErrorNoID extends Error {
+    constructor() {
+        super();
+        this.message = "Picked object does not have a scene ID";
+    }
+}
+exports.SceneObjectPickErrorNoID = SceneObjectPickErrorNoID;

package/lib/UseCases/LerpVector3.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from "../ValueObjects";
+export interface LerpVector3DTO {
+    initial: Vector3;
+    final: Vector3;
+    durationMS: number;
+    tickInterval?: number;
+    ease?: (percent: number) => number;
+    onTick?: (v: Vector3) => void;
+    onComplete?: () => void;
+    onCanceled?: () => void;
+}
+export declare class LerpVector3 {
+    private initial;
+    private final;
+    private durationMS;
+    private tickInterval;
+    private ease;
+    private onTick;
+    private onComplete;
+    private onCanceled;
+    private interval?;
+    private chrono;
+    cancel: () => void;
+    private tick;
+    constructor(lerpParams: LerpVector3DTO);
+}

package/lib/UseCases/LerpVector3.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpVector3 = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class LerpVector3 {
+    constructor(lerpParams) {
+        this.tickInterval = 10;
+        this.ease = (p) => p;
+        this.onTick = () => {
+            // Override as needed
+        };
+        this.onComplete = () => {
+            // Override as needed
+        };
+        this.onCanceled = () => {
+            // Override as needed
+        };
+        this.chrono = 0;
+        this.cancel = () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.onCanceled();
+                this.interval = undefined;
+            }
+        };
+        this.tick = () => {
+            this.chrono = this.chrono + this.tickInterval;
+            let nomralizedTime = this.chrono / this.durationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.ease(nomralizedTime);
+            const lerpedVec = ValueObjects_1.Vector3.Lerp(this.initial, this.final, percent);
+            this.onTick(lerpedVec);
+            if (nomralizedTime >= 1 && this.interval) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+            }
+        };
+        this.initial = lerpParams.initial;
+        this.final = lerpParams.final;
+        this.durationMS = lerpParams.durationMS;
+        if (lerpParams.onTick) {
+            this.onTick = lerpParams.onTick;
+        }
+        if (lerpParams.tickInterval) {
+            this.tickInterval = lerpParams.tickInterval;
+        }
+        if (lerpParams.onComplete) {
+            this.onComplete = lerpParams.onComplete;
+        }
+        if (lerpParams.ease) {
+            this.ease = lerpParams.ease;
+        }
+        if (lerpParams.onCanceled) {
+            this.onCanceled = lerpParams.onCanceled;
+        }
+        this.interval = setInterval(() => {
+            this.tick();
+        }, this.tickInterval);
+    }
+}
+exports.LerpVector3 = LerpVector3;

package/lib/UseCases/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./setDevicePreview";
 export * from "./FocusCamera";
 export * from "./QuestionChallenge";
+export * from "./LerpVector3";

package/lib/UseCases/index.js

@@ -13,3 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./LerpVector3"), exports);

package/lib/Utilities/lerpNumber.d.ts

@@ -0,0 +1 @@
+export declare function lerpNumber(start: number, end: number, percent: number, clamp?: boolean): number;

package/lib/Utilities/lerpNumber.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerpNumber = void 0;
+function lerpNumber(start, end, percent, clamp = false) {
+    const range = end - start;
+    if (!clamp) {
+        return percent * range + start;
+    }
+    let clampedP = percent;
+    if (clampedP < 0) {
+        clampedP = 0;
+    }
+    else if (clampedP > 1) {
+        clampedP = 1;
+    }
+    return clampedP * range + start;
+}
+exports.lerpNumber = lerpNumber;

package/lib/ValueObjects/Vector3.d.ts

@@ -15,6 +15,7 @@ export declare class Vector3 {
     static Cross: (a: Vector3, b: Vector3) => Vector3;
     static Dot: (a: Vector3, b: Vector3) => number;
     static NewVectorOfLength: (vec: Vector3, length: number) => Vector3;
+    static Lerp: (initial: Vector3, final: Vector3, percent: number) => Vector3;
     readonly x: number;
     readonly y: number;
     readonly z: number;

package/lib/ValueObjects/Vector3.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector3 = void 0;
+const lerpNumber_1 = require("../Utilities/lerpNumber");
 class Vector3 {
     constructor(x, y, z) {
         this.x = x;
@@ -89,3 +90,9 @@ Vector3.NewVectorOfLength = (vec, length) => {
     const unit = vec.unit;
     return new Vector3(length * unit.x, length * unit.y, length * unit.z);
 };
+Vector3.Lerp = (initial, final, percent) => {
+    const x = lerpNumber_1.lerpNumber(initial.x, final.x, percent);
+    const y = lerpNumber_1.lerpNumber(initial.y, final.y, percent);
+    const z = lerpNumber_1.lerpNumber(initial.z, final.z, percent);
+    return new Vector3(x, y, z);
+};

package/package.json

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