@vived/app 2.8.0 → 2.8.1

package/lib/Entities/Babylon.d.ts

@@ -1,16 +1,30 @@
+import { ParametricLine, Vector3 } from ".";
+import { Vector2 } from "./Vector2";
 export declare type OnBabylonChange = () => void;
+export interface ScenePick {
+    mouseRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+}
+export declare type ScenePicker = (pixelPos: Vector2) => ScenePick;
+export declare type SceneRayer = (pixelPos: Vector2) => ParametricLine;
 export interface Babylon {
     engine: unknown;
     scene: unknown;
     workingCanvas?: HTMLCanvasElement;
     showInspector: boolean;
     renderCanvas?: HTMLCanvasElement;
+    scenePick: (pixelPos: Vector2) => ScenePick;
+    sceneRay: (pixelPos: Vector2) => ParametricLine;
     updateCanvasSize: () => void;
     submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
     clearRenderCanvas: () => void;
     registerResizeEnging: (resizeEngine: () => void) => void;
     registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
     registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerScenePicker: (picker: ScenePicker) => void;
+    registerSceneRayer: (rayer: SceneRayer) => void;
     addObserver: (observer: OnBabylonChange) => void;
     removeObserver: (observer: OnBabylonChange) => void;
 }

package/lib/Entities/Babylon.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBabylon = void 0;
+const _1 = require(".");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedVector2_1 = require("./MemoizedVector2");
 const ObserverList_1 = require("./ObserverList");
@@ -11,6 +12,17 @@ function makeBabylon() {
 exports.makeBabylon = makeBabylon;
 class BabylonImp {
     constructor() {
+        this.scenePick = () => {
+            console.warn("orignal scene picker");
+            return {
+                mouseRay: _1.ParametricLine.Forward(),
+                hit: false,
+            };
+        };
+        this.sceneRay = () => {
+            console.warn("orignal scene ray");
+            return _1.ParametricLine.Forward();
+        };
         this.observers = new ObserverList_1.ObserverList();
         this.updateCanvasSize = () => {
             if (!this.workingCanvas)
@@ -60,6 +72,12 @@ class BabylonImp {
         this.removeObserver = (observer) => {
             this.observers.remove(observer);
         };
+        this.registerScenePicker = (picker) => {
+            this.scenePick = picker;
+        };
+        this.registerSceneRayer = (rayer) => {
+            this.sceneRay = rayer;
+        };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
         this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(Vector2_1.Vector2.One(), this.observers.notify);
     }

package/lib/Entities/MouseInput.d.ts

@@ -0,0 +1,15 @@
+export interface MouseController {
+    onClick?: (e: MouseEvent) => void;
+    onDown?: (e: MouseEvent) => void;
+    onUp?: (e: MouseEvent) => void;
+    onMove?: (e: MouseEvent) => void;
+    onWheel?: (e: WheelEvent) => void;
+}
+export interface MouseInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: MouseController) => void;
+    removeController: (controller: MouseController) => void;
+}
+export declare function makeMouseSceneInput(): MouseInput;

package/lib/Entities/MouseInput.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseSceneInput = void 0;
+const _1 = require(".");
+function makeMouseSceneInput() {
+    return new MouseInputImp();
+}
+exports.makeMouseSceneInput = makeMouseSceneInput;
+class MouseInputImp {
+    constructor() {
+        this.controllers = [];
+        this.maxClickMovement = 5; // pixels
+        this._eventElement = undefined;
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("mousedown", this.onMouseDown);
+            eventElement.addEventListener("mouseup", this.onMouseUp);
+            eventElement.addEventListener("mousemove", this.onMouseMove);
+            eventElement.addEventListener("mouseout", this.onMouseOut);
+            eventElement.addEventListener("wheel", this.onWheel);
+            this._eventElement = eventElement;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
+            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
+            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
+            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
+            this._eventElement.removeEventListener("wheel", this.onWheel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.onMouseDown = (e) => {
+            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
+            this.controllers.forEach((c) => {
+                if (c.onDown) {
+                    c.onDown(e);
+                }
+            });
+            this.pressEvent = e;
+        };
+        this.onMouseUp = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued < this.maxClickMovement) {
+                this.controllers.forEach((c) => {
+                    if (c.onClick) {
+                        c.onClick(e);
+                    }
+                });
+            }
+            this.pressEvent = undefined;
+        };
+        this.onMouseMove = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onMove) {
+                    c.onMove(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued > this.maxClickMovement) {
+                this.pressEvent = undefined;
+            }
+        };
+        this.onMouseOut = (e) => {
+            if (!this.pressEvent)
+                return;
+            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            this.pressEvent = undefined;
+        };
+        this.onWheel = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onWheel) {
+                    c.onWheel(e);
+                }
+            });
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/MouseSceneInput.d.ts

@@ -1,23 +1,14 @@
-import { ParametricLine, Vector2, Vector3 } from ".";
 export interface MouseController {
-    onClick?: (e: MouseEvent, scenePick: ScenePick) => void;
-    onDown?: (e: MouseEvent, scenePick: ScenePick) => void;
-    onUp?: (e: MouseEvent, scenePick: ScenePick) => void;
-    onMove?: (e: MouseEvent, scenePick: ScenePick) => void;
-    onWheel?: (e: WheelEvent, scenePick: ScenePick) => void;
+    onClick?: (e: MouseEvent) => void;
+    onDown?: (e: MouseEvent) => void;
+    onUp?: (e: MouseEvent) => void;
+    onMove?: (e: MouseEvent) => void;
+    onWheel?: (e: WheelEvent) => void;
 }
-export interface ScenePick {
-    mouseRay: ParametricLine;
-    hit: boolean;
-    worldPickPoint?: Vector3;
-    objectPickMeta?: object;
-}
-export declare type ScenePicker = (mousePos: Vector2) => ScenePick;
 export interface MouseSceneInput {
     eventElement: HTMLElement | undefined;
     setEventElement: (eventElement: HTMLElement) => void;
     clearInputElement: () => void;
-    registerScenePicker: (picker: ScenePicker) => void;
     registerController: (controller: MouseController) => void;
     removeController: (controller: MouseController) => void;
 }

package/lib/Entities/MouseSceneInput.js

@@ -9,13 +9,6 @@ exports.makeMouseSceneInput = makeMouseSceneInput;
 class MouseSceneInputImp {
     constructor() {
         this.controllers = [];
-        this.scenePicker = (mousePos) => {
-            console.log("orignal scene picker");
-            return {
-                mouseRay: _1.ParametricLine.Forward(),
-                hit: false,
-            };
-        };
         this.maxClickMovement = 5; // pixels
         this._eventElement = undefined;
         this.setEventElement = (eventElement) => {
@@ -47,25 +40,19 @@ class MouseSceneInputImp {
                 this.controllers.splice(index, 1);
             }
         };
-        this.registerScenePicker = (picker) => {
-            this.scenePicker = picker;
-        };
         this.onMouseDown = (e) => {
             const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            const pick = this.scenePicker(mousePos);
             this.controllers.forEach((c) => {
                 if (c.onDown) {
-                    c.onDown(e, pick);
+                    c.onDown(e);
                 }
             });
             this.pressEvent = e;
         };
         this.onMouseUp = (e) => {
-            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            const pick = this.scenePicker(mousePos);
             this.controllers.forEach((c) => {
                 if (c.onUp) {
-                    c.onUp(e, pick);
+                    c.onUp(e);
                 }
             });
             if (!this.pressEvent)
@@ -76,18 +63,16 @@ class MouseSceneInputImp {
             if (delta.magnitued < this.maxClickMovement) {
                 this.controllers.forEach((c) => {
                     if (c.onClick) {
-                        c.onClick(e, pick);
+                        c.onClick(e);
                     }
                 });
             }
             this.pressEvent = undefined;
         };
         this.onMouseMove = (e) => {
-            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            const pick = this.scenePicker(mousePos);
             this.controllers.forEach((c) => {
                 if (c.onMove) {
-                    c.onMove(e, pick);
+                    c.onMove(e);
                 }
             });
             if (!this.pressEvent)
@@ -103,20 +88,17 @@ class MouseSceneInputImp {
             if (!this.pressEvent)
                 return;
             const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            const pick = this.scenePicker(mousePos);
             this.controllers.forEach((c) => {
                 if (c.onUp) {
-                    c.onUp(e, pick);
+                    c.onUp(e);
                 }
             });
             this.pressEvent = undefined;
         };
         this.onWheel = (e) => {
-            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
-            const pick = this.scenePicker(mousePos);
             this.controllers.forEach((c) => {
                 if (c.onWheel) {
-                    c.onWheel(e, pick);
+                    c.onWheel(e);
                 }
             });
         };

package/lib/Entities/index.d.ts

@@ -17,4 +17,4 @@ export * from "./StateMachine";
 export * from "./UndoRedo";
 export * from "./Vector2";
 export * from "./Vector3";
-export * from "./MouseSceneInput";
+export * from "./MouseInput";

package/lib/Entities/index.js

@@ -29,4 +29,4 @@ __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./Vector2"), exports);
 __exportStar(require("./Vector3"), exports);
-__exportStar(require("./MouseSceneInput"), exports);
+__exportStar(require("./MouseInput"), exports);

package/package.json

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