@vived/app 4.12.0 → 4.14.0

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

@@ -0,0 +1,17 @@
+"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("./MockBumpTransformScaleAboutPixelPoint"), exports);
+__exportStar(require("./MockPanTransformUC"), exports);
+__exportStar(require("./MockPinchTransformUC"), exports);
+__exportStar(require("./MockRayPanScaleTransformUC"), exports);
+__exportStar(require("./MockRayScaleTransform"), exports);

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

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class BumpTransformScaleAboutPixelPointUC extends AppObjectUC {
+    static readonly type = "BumpTransformScaleAboutPixelPointUC";
+    abstract sensitivity: number;
+    abstract minScale?: number | undefined;
+    abstract maxScale?: number | undefined;
+    abstract enabled: boolean;
+    abstract allow(): boolean;
+    abstract bump(direction: "IN" | "OUT", pixelPosition: Vector2): void;
+}
+export declare function makeBumpTransformScaleAboutPixelPointUC(appObject: AppObject): BumpTransformScaleAboutPixelPointUC;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBumpTransformScaleAboutPixelPointUC = exports.BumpTransformScaleAboutPixelPointUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class BumpTransformScaleAboutPixelPointUC extends AppObject_1.AppObjectUC {
+}
+exports.BumpTransformScaleAboutPixelPointUC = BumpTransformScaleAboutPixelPointUC;
+BumpTransformScaleAboutPixelPointUC.type = "BumpTransformScaleAboutPixelPointUC";
+function makeBumpTransformScaleAboutPixelPointUC(appObject) {
+    return new BumpTransformScaleAboutPixelPointUCImp(appObject);
+}
+exports.makeBumpTransformScaleAboutPixelPointUC = makeBumpTransformScaleAboutPixelPointUC;
+class BumpTransformScaleAboutPixelPointUCImp extends BumpTransformScaleAboutPixelPointUC {
+    constructor(appObject) {
+        super(appObject, BumpTransformScaleAboutPixelPointUC.type);
+        this.enabled = true;
+        this.sensitivity = 0.1;
+        this.allow = () => {
+            return true;
+        };
+        this.bump = (direction, pixelPosition) => {
+            var _a;
+            if (!this.enabled)
+                return;
+            if (!this.transform)
+                return;
+            if (!this.allow())
+                return;
+            let bumpDirection = -1;
+            if (direction === "IN") {
+                bumpDirection = 1;
+            }
+            const currentScale = this.transform.worldScale.x;
+            const scaleDelta = bumpDirection * this.sensitivity * currentScale;
+            const pick = Babylon_1.scenePixelPick(pixelPosition, this.appObjects);
+            const pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.bumpScaleAboutPoint(scaleDelta, pickPoint);
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.bumpScaleAboutPoint = (amount, worldPoint) => {
+            if (!this.transform)
+                return;
+            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.transform.worldScale.x;
+            let newScale = currentScale + amount;
+            if (this.minScale !== undefined && newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            if (this.maxScale !== undefined && newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        };
+        this.transform = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transform) {
+            this.error("BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a Transform");
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class PanTransformUC extends AppObjectUC {
+    static readonly type = "PanTransformUC";
+    abstract minX?: number;
+    abstract maxX?: number;
+    abstract minY?: number;
+    abstract maxY?: number;
+    abstract dispatchStateChangeOnComplete: boolean;
+    abstract enabled: boolean;
+    abstract updatePixel: (pixel: Vector2) => void;
+    abstract initializePixel: (pixel: Vector2) => void;
+    abstract updateRay: (ray: ParametricLine) => void;
+    abstract initializeRay: (ray: ParametricLine) => void;
+    abstract finish: () => void;
+    abstract cancelPan: () => void;
+}
+export declare function makePanTransformUC(appObject: AppObject): PanTransformUC;

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePanTransformUC = exports.PanTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class PanTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.PanTransformUC = PanTransformUC;
+PanTransformUC.type = "PanTransformUC";
+function makePanTransformUC(appObject) {
+    return new PanTransformUCImp(appObject);
+}
+exports.makePanTransformUC = makePanTransformUC;
+class PanTransformUCImp extends PanTransformUC {
+    constructor(appObject) {
+        super(appObject, PanTransformUC.type);
+        this.enabled = true;
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.dispatchStateChangeOnComplete = true;
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialPosition = ValueObjects_1.Vector3.Zero();
+        this.hasBeenInitialized = false;
+        this.initializePixel = (initialPixelPos) => {
+            const ray = Babylon_1.pixelToSceneRay(initialPixelPos, this.appObjects);
+            this.initializeRay(ray);
+        };
+        this.updatePixel = (pixelPosition) => {
+            if (!this.enabled)
+                return;
+            const pickRay = Babylon_1.pixelToSceneRay(pixelPosition, this.appObjects);
+            this.updateRay(pickRay);
+        };
+        this.initializeRay = (ray) => {
+            var _a;
+            if (!this.transformNode)
+                return;
+            const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const rootPos = this.transformNode.worldPosition;
+            this.pickOffset = ValueObjects_1.Vector3.Subtract(rootPos, pick);
+            this.hasBeenInitialized = true;
+            this.initialPosition = this.transformNode.worldPosition;
+        };
+        this.updateRay = (ray) => {
+            var _a;
+            if (!this.transformNode)
+                return;
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.enabled)
+                return;
+            const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            let wPos = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
+            if (this.minX !== undefined && wPos.x < this.minX) {
+                wPos = new ValueObjects_1.Vector3(this.minX, wPos.y, wPos.z);
+            }
+            if (this.maxX !== undefined && wPos.x > this.maxX) {
+                wPos = new ValueObjects_1.Vector3(this.maxX, wPos.y, wPos.z);
+            }
+            if (this.minY !== undefined && wPos.y < this.minY) {
+                wPos = new ValueObjects_1.Vector3(wPos.x, this.minY, wPos.z);
+            }
+            if (this.maxY !== undefined && wPos.y > this.maxY) {
+                wPos = new ValueObjects_1.Vector3(wPos.x, this.maxY, wPos.z);
+            }
+            this.transformNode.worldPosition = wPos;
+        };
+        this.finish = () => {
+            var _a;
+            if (!this.transformNode)
+                return;
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.enabled)
+                return;
+            this.hasBeenInitialized = false;
+            if (ValueObjects_1.Vector3.Equal(this.initialPosition, (_a = this.transformNode) === null || _a === void 0 ? void 0 : _a.worldPosition))
+                return;
+            if (this.dispatchStateChangeOnComplete) {
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+            }
+        };
+        this.cancelPan = () => {
+            this.hasBeenInitialized = false;
+        };
+        this.transformNode = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transformNode) {
+            this.error("App Object does not have a Transform3D");
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class PinchTransformUC extends AppObjectUC {
+    static readonly type = "PinchTransformUC";
+    abstract sensitivity: number;
+    abstract enabled: boolean;
+    abstract minScale?: number;
+    abstract maxScale?: number;
+    abstract doPinch: (touchPos1: Vector2, touchPos2: Vector2) => void;
+    abstract initializePinch: (touchPos1: Vector2, touchPos2: Vector2) => void;
+    abstract finishPinch: () => void;
+}
+export declare function makePinchTransformUC(appObject: AppObject): PinchTransformUC;

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePinchTransformUC = exports.PinchTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class PinchTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.PinchTransformUC = PinchTransformUC;
+PinchTransformUC.type = "PinchTransformUC";
+function makePinchTransformUC(appObject) {
+    return new PinchTransformUCImp(appObject);
+}
+exports.makePinchTransformUC = makePinchTransformUC;
+class PinchTransformUCImp extends PinchTransformUC {
+    constructor(appObject) {
+        super(appObject, PinchTransformUC.type);
+        this.sensitivity = 0.01;
+        this.enabled = true;
+        this.previousDistanceBetweenTouches = 0;
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialScale = 0;
+        this.initializePinch = (touchPos1, touchPos2) => {
+            var _a, _b;
+            if (!this.transform)
+                return;
+            this.previousDistanceBetweenTouches = this.getTouchDistance(touchPos1, touchPos2);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const scenePick = Babylon_1.scenePixelPick(touchCenter, this.appObjects);
+            const pickPoint = (_a = scenePick === null || scenePick === void 0 ? void 0 : scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            this.panPlane = ValueObjects_1.ParametricPlane.FromPointNormal(pickPoint, pickPlaneDirection);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_b = this.panPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this.pickOffset = this.transform.worldPointToLocal(planePick);
+            this.initialScale = this.transform.worldScale.x;
+        };
+        this.doPinch = (touchPos1, touchPos2) => {
+            var _a;
+            if (!this.enabled)
+                return;
+            if (!this.transform)
+                return;
+            const currentTouchDist = this.getTouchDistance(touchPos1, touchPos2);
+            const touchDelta = currentTouchDist - this.previousDistanceBetweenTouches;
+            const currentScale = this.transform.worldScale.x;
+            const scaleDelta = touchDelta * this.sensitivity * currentScale;
+            let newScale = currentScale + scaleDelta;
+            if (this.minScale !== undefined && newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            if (this.maxScale !== undefined && newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_a = this.panPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const globalOffset = this.transform.localPointToWorld(this.pickOffset);
+            const delta = ValueObjects_1.Vector3.Subtract(planePick, globalOffset);
+            const currentWorldPos = this.transform.worldPosition;
+            const newWorldPos = ValueObjects_1.Vector3.Add(currentWorldPos, delta);
+            this.transform.worldPosition = newWorldPos;
+            this.previousDistanceBetweenTouches = currentTouchDist;
+        };
+        this.finishPinch = () => {
+            var _a;
+            if (this.initialScale === ((_a = this.transform) === null || _a === void 0 ? void 0 : _a.worldScale.x))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.transform = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transform) {
+            this.warn("PinchSceneRootUC UC has been added to an App Object that does not have a Transform3D");
+            return;
+        }
+    }
+    getTouchCenter(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        const halfDelta = ValueObjects_1.Vector2.NewVectorOfLength(delta.unit, 0.5 * delta.magnitued);
+        return ValueObjects_1.Vector2.Add(t1, halfDelta);
+    }
+    getTouchDistance(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        return delta.magnitued;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+export declare abstract class RayPanScaleTransformUC extends AppObjectUC {
+    static readonly type = "RayPanScaleTransformUC";
+    abstract sensitivity: number;
+    abstract enabled: boolean;
+    abstract minScale?: number;
+    abstract maxScale?: number;
+    abstract minX?: number;
+    abstract maxX?: number;
+    abstract minY?: number;
+    abstract maxY?: number;
+    abstract update: (ray: ParametricLine) => void;
+    abstract initialize: (ray: ParametricLine) => void;
+    abstract finish: () => void;
+}
+export declare function makeRayPanScaleTransformUC(appObject: AppObject): RayPanScaleTransformUC;

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRayPanScaleTransformUC = exports.RayPanScaleTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class RayPanScaleTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.RayPanScaleTransformUC = RayPanScaleTransformUC;
+RayPanScaleTransformUC.type = "RayPanScaleTransformUC";
+function makeRayPanScaleTransformUC(appObject) {
+    return new RayPanScaleTransformUCImp(appObject);
+}
+exports.makeRayPanScaleTransformUC = makeRayPanScaleTransformUC;
+class RayPanScaleTransformUCImp extends RayPanScaleTransformUC {
+    constructor(appObject) {
+        super(appObject, RayPanScaleTransformUC.type);
+        this.enabled = true;
+        this.sensitivity = 1;
+        this.allowUpdate = false;
+        this.initialScale = 1;
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.lastRayLength = 0;
+        this.initialize = (ray) => {
+            var _a, _b;
+            this.allowUpdate = false;
+            if (!this.transform)
+                return;
+            const pick = Babylon_1.sceneRayPick(ray, this.appObjects);
+            this.panPlane = ValueObjects_1.ParametricPlane.FromPointNormal((_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Backward());
+            const pickPoint = (_b = this.panPlane.intersectLine(ray)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this.lastRayLength = ValueObjects_1.ParametricLine.GetDistanceToPoint(ray, pickPoint);
+            this.pickOffset = this.transform.worldPointToLocal(pickPoint);
+            this.initialScale = this.transform.worldScale.x;
+            this.allowUpdate = true;
+        };
+        this.update = (ray) => {
+            var _a;
+            if (!this.enabled)
+                return;
+            if (!this.allowUpdate)
+                return;
+            if (!this.transform)
+                return;
+            const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.updateScale(ray, pick);
+            this.updatePosition(pick);
+        };
+        this.finish = () => {
+            if (!this.transform)
+                return;
+            if (!this.allowUpdate)
+                return;
+            if (this.initialScale !== this.transform.worldScale.x) {
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+            }
+            this.allowUpdate = false;
+        };
+        this.transform = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transform) {
+            this.error("App Object does not have a Transform3D Entity");
+        }
+    }
+    updatePosition(pick) {
+        if (!this.transform)
+            return;
+        const originalPickOffset = this.transform.localPointToWorld(this.pickOffset);
+        const movement = ValueObjects_1.Vector3.Subtract(pick, originalPickOffset);
+        let wPos = ValueObjects_1.Vector3.Add(movement, this.transform.worldPosition);
+        if (this.minX !== undefined && wPos.x < this.minX) {
+            wPos = new ValueObjects_1.Vector3(this.minX, wPos.y, wPos.z);
+        }
+        if (this.maxX !== undefined && wPos.x > this.maxX) {
+            wPos = new ValueObjects_1.Vector3(this.maxX, wPos.y, wPos.z);
+        }
+        if (this.minY !== undefined && wPos.y < this.minY) {
+            wPos = new ValueObjects_1.Vector3(wPos.x, this.minY, wPos.z);
+        }
+        if (this.maxY !== undefined && wPos.y > this.maxY) {
+            wPos = new ValueObjects_1.Vector3(wPos.x, this.maxY, wPos.z);
+        }
+        this.transform.worldPosition = wPos;
+    }
+    updateScale(ray, pick) {
+        if (!this.transform)
+            return;
+        const rayLength = ValueObjects_1.ParametricLine.GetDistanceToPoint(ray, pick);
+        const rayDelta = rayLength - this.lastRayLength;
+        const localPickOffset = this.transform.worldPointToLocal(pick);
+        const currentScale = this.transform.worldScale.x;
+        const scaleDelta = rayDelta * this.sensitivity * currentScale;
+        let newScale = currentScale + scaleDelta;
+        if (this.minScale !== undefined && newScale < this.minScale) {
+            newScale = this.minScale;
+        }
+        if (this.maxScale !== undefined && newScale > this.maxScale) {
+            newScale = this.maxScale;
+        }
+        this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+        const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+        const bump = ValueObjects_1.Vector3.Subtract(pick, worldPickOffset);
+        this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        this.lastRayLength = rayLength;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class ScaleTransformUC extends AppObjectUC {
+    static readonly type = "ScaleTransformUC";
+    abstract raySensitivity: number;
+    abstract pixelSensitivity: number;
+    abstract enabled: boolean;
+    abstract minScale?: number;
+    abstract maxScale?: number;
+    abstract initializeRay: (ray: ParametricLine) => void;
+    abstract updateRay: (ray: ParametricLine) => void;
+    abstract initializePixel: (pixel: Vector2) => void;
+    abstract updatePixel: (pixel: Vector2) => void;
+    abstract finish: () => void;
+}
+export declare function makeScaleTransformUC(appObject: AppObject): ScaleTransformUC;

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeScaleTransformUC = exports.ScaleTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class ScaleTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.ScaleTransformUC = ScaleTransformUC;
+ScaleTransformUC.type = "ScaleTransformUC";
+function makeScaleTransformUC(appObject) {
+    return new ScaleTransformUCImp(appObject);
+}
+exports.makeScaleTransformUC = makeScaleTransformUC;
+class ScaleTransformUCImp extends ScaleTransformUC {
+    constructor(appObject) {
+        super(appObject, ScaleTransformUC.type);
+        this.raySensitivity = 1;
+        this.pixelSensitivity = 0.1;
+        this.enabled = true;
+        this.lastPosition = 0;
+        this.pickPoint = ValueObjects_1.Vector3.Zero();
+        this.initialScale = 1;
+        this.isScaling = false;
+        this.initializeRay = (ray) => {
+            this.lastPosition = ray.origin.z;
+            this.doInitialize(ray);
+        };
+        this.updateRay = (ray) => {
+            if (!this.isScaling)
+                return;
+            if (!this.transform)
+                return;
+            if (!this.enabled)
+                return;
+            const movement = this.lastPosition - ray.origin.z;
+            const currentScale = this.transform.worldScale.x;
+            const scaleDelta = movement * this.raySensitivity * currentScale;
+            this.bumpScaleAboutPoint(scaleDelta, this.pickPoint);
+            this.lastPosition = ray.origin.z;
+        };
+        this.initializePixel = (initialPixelPos) => {
+            this.lastPosition = initialPixelPos.y;
+            const ray = Babylon_1.pixelToSceneRay(initialPixelPos, this.appObjects);
+            this.doInitialize(ray);
+        };
+        this.updatePixel = (pixelPosition) => {
+            if (!this.enabled)
+                return;
+            if (!this.transform)
+                return;
+            if (!this.isScaling)
+                return;
+            const pixelChange = pixelPosition.y - this.lastPosition;
+            this.lastPosition = pixelPosition.y;
+            const currentScale = this.transform.worldScale.x;
+            const scaleDelta = pixelChange * this.pixelSensitivity * currentScale;
+            this.bumpScaleAboutPoint(scaleDelta, this.pickPoint);
+        };
+        this.finish = () => {
+            if (!this.transform)
+                return;
+            if (!this.isScaling)
+                return;
+            if (this.initialScale !== this.transform.worldScale.x) {
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+            }
+            this.isScaling = false;
+        };
+        this.bumpScaleAboutPoint = (amount, worldPoint) => {
+            if (!this.transform)
+                return;
+            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.transform.worldScale.x;
+            let newScale = currentScale + amount;
+            if (this.minScale !== undefined && newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            if (this.maxScale !== undefined && newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        };
+        this.transform = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transform) {
+            this.error("App Object does not have a Transform3D Entity");
+        }
+    }
+    doInitialize(ray) {
+        var _a;
+        this.isScaling = false;
+        if (!this.transform)
+            return;
+        const pick = Babylon_1.sceneRayPick(ray, this.appObjects);
+        this.pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+        this.initialScale = this.transform.worldScale.x;
+        this.isScaling = true;
+    }
+}

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

@@ -5,8 +5,9 @@ const __1 = require("..");
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const ValueObjects_1 = require("../../../ValueObjects");
 const Dispatcher_1 = require("../../Dispatcher");
+const Stylus_1 = require("../../Stylus");
 const UndoRedo_1 = require("../../UndoRedo");
-const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const Entities_1 = require("../Entities");
 const MoveTransformUndoRedo_1 = require("./MoveTransformUndoRedo");
 class StylusMoveTransformUC extends AppObjectUC_1.AppObjectUC {
     static get(appObject) {
@@ -33,8 +34,8 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
                 return;
             if (!this.stylus)
                 return;
-            this.transform.worldPosition = this.stylus.helperTransform.worldPosition;
-            this.transform.worldRotation = this.stylus.helperTransform.worldRotation;
+            this.transform.worldPosition = this.helperTransform.worldPosition;
+            this.transform.worldRotation = this.helperTransform.worldRotation;
             this.didMove = true;
         };
         this.stop = (registerUndo = false) => {
@@ -54,43 +55,21 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
             this.isMoving = false;
             this.didMove = false;
         };
-        const appObjects = appObject.appObjectRepo;
-        this.transform = appObject.getComponent(__1.Transform3D.type);
-        if (!this.transform) {
-            this.warn("StylusMoveTransformUCImp has been added to an app object that does not have a Transform3D. Add one first");
-            return;
+        this.transform = __1.Transform3D.addIfMissing(this.appObject);
+        const helperAO = this.appObjects.getOrCreate(this.appObject.id + "_helper");
+        this.helperTransform = Entities_1.makeTransform3D(helperAO);
+        if (this.stylus) {
+            this.helperTransform.parent = this.stylus.transform;
         }
     }
     get dispatchStateChange() {
-        if (!this._cachedDispatchStateChange) {
-            this._cachedDispatchStateChange = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo);
-            if (!this._cachedDispatchStateChange) {
-                this.warn("Unable to find DispatchStateChangeUC");
-                return;
-            }
-        }
-        return this._cachedDispatchStateChange;
+        return this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type);
     }
     get undoRedoEntity() {
-        if (!this._cachedUndoRedo) {
-            this._cachedUndoRedo = UndoRedo_1.UndoRedoEntity.get(this.appObject.appObjectRepo);
-            if (!this._cachedUndoRedo) {
-                this.warn("Unable to find UndoRedoEntity");
-                return;
-            }
-        }
-        return this._cachedUndoRedo;
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
     }
     get stylus() {
-        if (!this._cachedStylus) {
-            const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObject.appObjectRepo);
-            if (!zSpaceEntity) {
-                this.warn("Unable to find ZSpaceEntity");
-                return;
-            }
-            this._cachedStylus = zSpaceEntity.stylus;
-        }
-        return this._cachedStylus;
+        return this.getCachedSingleton(Stylus_1.StylusEntity.type);
     }
     initialize() {
         if (!this.transform)
@@ -99,8 +78,8 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
             return false;
         this.initialPosition = this.transform.localPosition;
         this.initialRotation = this.transform.localRotation;
-        this.stylus.helperTransform.worldPosition = this.transform.worldPosition;
-        this.stylus.helperTransform.worldRotation = this.transform.worldRotation;
+        this.helperTransform.worldPosition = this.transform.worldPosition;
+        this.helperTransform.worldRotation = this.transform.worldRotation;
         this.isMoving = true;
         return;
     }

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

@@ -1,3 +1,9 @@
+export * from "./BumpTransformScaleAboutPixelPoint";
 export * from "./DragTransformUC";
+export * from "./MoveTransformUndoRedo";
+export * from "./PanTransformUC";
+export * from "./PinchTransform";
+export * from "./RayPanScaleTransform";
+export * from "./ScaleTransform";
 export * from "./StickTransformUC";
 export * from "./StylusMoveTransformUC";