@vived/app 4.26.1 → 4.27.0

package/lib/Components/Transform3D/Controllers/Mouse/TryMousePanTransformMC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryMousePanTransformMC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const MouseInput_1 = require("../../../MouseInput");
+const TryPanTransformUC_1 = require("../../UC/TryPanTransformUC");
+class TryMousePanTransformMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        var _a;
+        super(appObject, TryMousePanTransformMC.type);
+        this.allow = (e) => {
+            if (e.button !== 0)
+                return false;
+            return true;
+        };
+        this.isDragging = false;
+        this.onDown = (e) => {
+            var _a, _b, _c;
+            if (this.isDragging) {
+                (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.cancel();
+                this.isDragging = false;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            this.isDragging = (_c = (_b = this.tryScreenDragUC) === null || _b === void 0 ? void 0 : _b.tryWithPixel(e.position)) !== null && _c !== void 0 ? _c : false;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.isDragging)
+                return;
+            (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.moveWithPixel(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            if (!this.isDragging)
+                return;
+            (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.stop();
+            this.isDragging = false;
+        };
+        (_a = this.mouseInput) === null || _a === void 0 ? void 0 : _a.registerController(this);
+    }
+    get mouseInput() {
+        return this.getCachedSingleton(MouseInput_1.MouseInputEntity.type);
+    }
+    get tryScreenDragUC() {
+        return this.getCachedLocalComponent(TryPanTransformUC_1.TryPanTransformUC.type);
+    }
+}
+exports.TryMousePanTransformMC = TryMousePanTransformMC;
+TryMousePanTransformMC.type = "TryMousePanTransformMC";

package/lib/Components/Transform3D/Controllers/Touch/TryTouchPanTransformTC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+export declare class TryTouchPanTransformTC extends AppObjectController implements TouchController {
+    static readonly type = "TryTouchPanTransformTC";
+    allow: (e: TouchInputEvent) => boolean;
+    private get tryScreenDragUC();
+    private isDragging;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Controllers/Touch/TryTouchPanTransformTC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryTouchPanTransformTC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const TouchController_1 = require("../../../TouchController");
+const TryPanTransformUC_1 = require("../../UC/TryPanTransformUC");
+class TryTouchPanTransformTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TryTouchPanTransformTC.type);
+        this.allow = (e) => {
+            if (e.touches.length !== 1)
+                return false;
+            return true;
+        };
+        this.isDragging = false;
+        this.onTouchStart = (e) => {
+            var _a;
+            if (this.isDragging) {
+                (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.cancel();
+                this.isDragging = false;
+            }
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.allow(e))
+                return;
+            const position = e.touches[0].position;
+            this.isDragging = this.tryScreenDragUC.tryWithPixel(position);
+        };
+        this.onTouchMove = (e) => {
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.isDragging)
+                return;
+            const position = e.touches[0].position;
+            this.tryScreenDragUC.moveWithPixel(position);
+        };
+        this.onTouchEnd = () => {
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.isDragging)
+                return;
+            this.tryScreenDragUC.stop();
+            this.isDragging = false;
+        };
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        touchInput === null || touchInput === void 0 ? void 0 : touchInput.registerController(this);
+    }
+    get tryScreenDragUC() {
+        return this.getCachedLocalComponent(TryPanTransformUC_1.TryPanTransformUC.type);
+    }
+}
+exports.TryTouchPanTransformTC = TryTouchPanTransformTC;
+TryTouchPanTransformTC.type = "TryTouchPanTransformTC";

package/lib/Components/Transform3D/Mocks/TryPanTransformUcMock.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { TryPanTransformUC } from "../UC/TryPanTransformUC";
+export declare class TryPanTransformUcMock extends TryPanTransformUC {
+    allow: jest.Mock<any, any>;
+    tryWithRay: jest.Mock<any, any>;
+    moveWithRay: jest.Mock<any, any>;
+    tryWithPixel: jest.Mock<any, any>;
+    moveWithPixel: jest.Mock<any, any>;
+    stop: jest.Mock<any, any>;
+    cancel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Mocks/TryPanTransformUcMock.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryPanTransformUcMock = void 0;
+const TryPanTransformUC_1 = require("../UC/TryPanTransformUC");
+class TryPanTransformUcMock extends TryPanTransformUC_1.TryPanTransformUC {
+    constructor(appObject) {
+        super(appObject, TryPanTransformUC_1.TryPanTransformUC.type);
+        this.allow = jest.fn();
+        this.tryWithRay = jest.fn();
+        this.moveWithRay = jest.fn();
+        this.tryWithPixel = jest.fn();
+        this.moveWithPixel = jest.fn();
+        this.stop = jest.fn();
+        this.cancel = jest.fn();
+    }
+}
+exports.TryPanTransformUcMock = TryPanTransformUcMock;

package/lib/Components/Transform3D/UC/TryPanTransformUC.d.ts

@@ -0,0 +1,27 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+import { PanTransformUC } from "./PanTransformUC";
+export declare abstract class TryPanTransformUC extends AppObjectUC {
+    static readonly type = "TryPanTransformUC";
+    abstract allow(): boolean;
+    abstract tryWithRay(ray: ParametricLine): boolean;
+    abstract moveWithRay(ray: ParametricLine): void;
+    abstract tryWithPixel(pixel: Vector2): boolean;
+    abstract moveWithPixel(pixel: Vector2): void;
+    abstract stop(): void;
+    abstract cancel(): void;
+}
+export declare function makeTryPanTransformUC(appObject: AppObject): TryPanTransformUC;
+export declare class TryPanTransformUCImp extends TryPanTransformUC {
+    protected panUC?: PanTransformUC;
+    private get pixelToRay();
+    private get rayPickUC();
+    allow: () => boolean;
+    tryWithPixel: (pixel: Vector2) => boolean;
+    moveWithPixel: (pixel: Vector2) => void;
+    tryWithRay: (pickRay: ParametricLine) => boolean;
+    moveWithRay: (pickRay: ParametricLine) => void;
+    stop: () => void;
+    cancel: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/UC/TryPanTransformUC.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryPanTransformUCImp = exports.makeTryPanTransformUC = exports.TryPanTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Babylon_1 = require("../../Babylon");
+const PanTransformUC_1 = require("./PanTransformUC");
+class TryPanTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.TryPanTransformUC = TryPanTransformUC;
+TryPanTransformUC.type = "TryPanTransformUC";
+function makeTryPanTransformUC(appObject) {
+    return new TryPanTransformUCImp(appObject);
+}
+exports.makeTryPanTransformUC = makeTryPanTransformUC;
+class TryPanTransformUCImp extends TryPanTransformUC {
+    constructor(appObject) {
+        super(appObject, TryPanTransformUC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.tryWithPixel = (pixel) => {
+            if (!this.pixelToRay) {
+                return false;
+            }
+            const ray = this.pixelToRay(pixel);
+            return this.tryWithRay(ray);
+        };
+        this.moveWithPixel = (pixel) => {
+            if (!this.pixelToRay) {
+                return;
+            }
+            const ray = this.pixelToRay(pixel);
+            return this.moveWithRay(ray);
+        };
+        this.tryWithRay = (pickRay) => {
+            var _a;
+            this.panUC = undefined;
+            if (!this.allow())
+                return false;
+            const scenePick = (_a = this.rayPickUC) === null || _a === void 0 ? void 0 : _a.sceneRayPick(pickRay);
+            if (!scenePick || !scenePick.worldPickPoint)
+                return false;
+            const appObjectID = scenePick.appObjectID;
+            if (!appObjectID)
+                return false;
+            this.panUC = PanTransformUC_1.PanTransformUC.get(appObjectID, this.appObjects);
+            if (this.panUC === undefined) {
+                return false;
+            }
+            this.panUC.initializeRay(pickRay);
+            return true;
+        };
+        this.moveWithRay = (pickRay) => {
+            if (!this.panUC)
+                return;
+            this.panUC.updateRay(pickRay);
+        };
+        this.stop = () => {
+            if (!this.panUC)
+                return;
+            this.panUC.finish();
+            this.panUC = undefined;
+        };
+        this.cancel = () => {
+            if (!this.panUC)
+                return;
+            this.panUC.cancelPan();
+            this.panUC = undefined;
+        };
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(Babylon_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+    get rayPickUC() {
+        return this.getCachedSingleton(Babylon_1.SceneRayPickUC.type);
+    }
+}
+exports.TryPanTransformUCImp = TryPanTransformUCImp;

package/package.json

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