@vived/app 4.12.0 → 4.14.0

package/lib/Components/Stylus/Entity/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("./StylusEntity"), exports);

package/lib/Components/Stylus/Mocks/MockEmulateStylusUC.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { EmulateStylusUC } from "../UCs/EmulateStylusUC";
+export declare class MockEmulateStylusUC extends EmulateStylusUC {
+    get isEmulating(): boolean;
+    startEmulating: jest.Mock<any, any>;
+    stopEmulating: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeMockEmulateStylusUC(appObjects: AppObjectRepo): MockEmulateStylusUC;

package/lib/Components/Stylus/Mocks/MockEmulateStylusUC.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockEmulateStylusUC = exports.MockEmulateStylusUC = void 0;
+const EmulateStylusUC_1 = require("../UCs/EmulateStylusUC");
+class MockEmulateStylusUC extends EmulateStylusUC_1.EmulateStylusUC {
+    constructor(appObject) {
+        super(appObject, EmulateStylusUC_1.EmulateStylusUC.type);
+        this.startEmulating = jest.fn();
+        this.stopEmulating = jest.fn();
+    }
+    get isEmulating() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockEmulateStylusUC = MockEmulateStylusUC;
+function makeMockEmulateStylusUC(appObjects) {
+    return new MockEmulateStylusUC(appObjects.getOrCreate("MockEmulateStylusUC"));
+}
+exports.makeMockEmulateStylusUC = makeMockEmulateStylusUC;

package/lib/Components/Stylus/Mocks/index.d.ts

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

package/lib/Components/Stylus/Mocks/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("./MockEmulateStylusUC"), exports);

package/lib/Components/Stylus/PMs/StylusColorLengthPM.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+import { Color } from "../../../ValueObjects";
+export interface StylusColorLengthVM {
+    color: Color;
+    length: number;
+}
+export declare abstract class StylusColorLengthPM extends AppObjectPM<StylusColorLengthVM> {
+    static readonly type = "StylusColorLengthPM";
+    abstract rayColorNoPick: Color;
+    abstract rayColorPick: Color;
+    abstract defaultLength: number;
+    static get(appObjects: AppObjectRepo): StylusColorLengthPM | undefined;
+}
+export declare function makeStylusColorLengthPM(appObject: AppObject): StylusColorLengthPM;

package/lib/Components/Stylus/PMs/StylusColorLengthPM.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusColorLengthPM = exports.StylusColorLengthPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const StylusEntity_1 = require("../Entity/StylusEntity");
+class StylusColorLengthPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(StylusColorLengthPM.type, appObjects);
+    }
+}
+exports.StylusColorLengthPM = StylusColorLengthPM;
+StylusColorLengthPM.type = "StylusColorLengthPM";
+function makeStylusColorLengthPM(appObject) {
+    return new StylusColorLengthPMImp(appObject);
+}
+exports.makeStylusColorLengthPM = makeStylusColorLengthPM;
+class StylusColorLengthPMImp extends StylusColorLengthPM {
+    constructor(appObject) {
+        super(appObject, StylusColorLengthPM.type);
+        this.defaultLength = 1;
+        this.rayColorNoPick = ValueObjects_1.Color.RGB(128, 128, 128);
+        this.rayColorPick = ValueObjects_1.Color.RGB(0, 255, 0);
+        this.onEntityChange = () => {
+            if (!this.stylus || !this.stylus.isInUse) {
+                this.setDefaultVM();
+                return;
+            }
+            const pickRay = this.stylus.pickRay;
+            const scenePickUC = Babylon_1.SceneRayPickUC.get(this.appObject.appObjectRepo);
+            if (!scenePickUC) {
+                this.setDefaultVM();
+                return;
+            }
+            const scenePick = scenePickUC.sceneRayPick(pickRay);
+            let color = this.rayColorNoPick;
+            let length = this.defaultLength;
+            if (scenePick && (scenePick === null || scenePick === void 0 ? void 0 : scenePick.hit) && scenePick.worldPickPoint) {
+                color = this.rayColorPick;
+                length = Math.abs(ValueObjects_1.Vector3.Subtract(this.stylus.transform.worldPosition, scenePick.worldPickPoint).magnitude);
+            }
+            const vm = {
+                color,
+                length
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.stylus) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.stylus = appObject.getComponent(StylusEntity_1.StylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onEntityChange);
+            this.stylus.addOnDisposeObserver(() => {
+                this.dispose();
+            });
+            this.onEntityChange();
+        }
+        else {
+            this.warn("App Object does not have a Stylus Entity");
+        }
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        if (ValueObjects_1.Color.Equal(a.color, b.color) && a.length === b.length) {
+            return true;
+        }
+        return false;
+    }
+    setDefaultVM() {
+        const vm = {
+            color: this.rayColorNoPick,
+            length: 0
+        };
+        this.doUpdateView(vm);
+    }
+}

package/lib/Components/Stylus/PMs/StylusIsInUsePM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class StylusIsInUsePM extends AppObjectPM<boolean> {
+    static readonly type = "StylusIsInUsePM";
+    static get: (appObjects: AppObjectRepo) => StylusIsInUsePM | undefined;
+}
+export declare function makeStylusIsInUsePM(appObject: AppObject): StylusIsInUsePM;

package/lib/Components/Stylus/PMs/StylusIsInUsePM.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusIsInUsePM = exports.StylusIsInUsePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StylusEntity_1 = require("../Entity/StylusEntity");
+class StylusIsInUsePM extends AppObject_1.AppObjectPM {
+}
+exports.StylusIsInUsePM = StylusIsInUsePM;
+StylusIsInUsePM.type = "StylusIsInUsePM";
+StylusIsInUsePM.get = (appObjects) => AppObject_1.getSingletonComponent(StylusIsInUsePM.type, appObjects);
+function makeStylusIsInUsePM(appObject) {
+    return new StylusIsInUsePMImp(appObject);
+}
+exports.makeStylusIsInUsePM = makeStylusIsInUsePM;
+class StylusIsInUsePMImp extends StylusIsInUsePM {
+    constructor(appObject) {
+        super(appObject, StylusIsInUsePM.type);
+        this.onStylusChange = () => {
+            if (!this.stylus)
+                return;
+            this.doUpdateView(this.stylus.isInUse);
+        };
+        this.stylus = appObject.getComponent(StylusEntity_1.StylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onStylusChange);
+            this.onStylusChange();
+        }
+        else {
+            this.warn("App Object does not have a Stylus Entity");
+        }
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/Stylus/PMs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StylusColorLengthPM";
+export * from "./StylusIsInUsePM";

package/lib/Components/Stylus/PMs/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("./StylusColorLengthPM"), exports);
+__exportStar(require("./StylusIsInUsePM"), exports);

package/lib/Components/Stylus/UCs/EmulateStylusUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class EmulateStylusUC extends AppObjectUC {
+    static type: string;
+    abstract get isEmulating(): boolean;
+    abstract startEmulating(): void;
+    abstract stopEmulating(): void;
+    static get(appObjects: AppObjectRepo): EmulateStylusUC | undefined;
+}
+export declare function makeEmulateStylusUC(appObject: AppObject): EmulateStylusUC;

package/lib/Components/Stylus/UCs/EmulateStylusUC.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmulateStylusUC = exports.EmulateStylusUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const TouchController_1 = require("../../TouchController");
+const StylusEntity_1 = require("../Entity/StylusEntity");
+class EmulateStylusUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(EmulateStylusUC.type, appObjects);
+    }
+}
+exports.EmulateStylusUC = EmulateStylusUC;
+EmulateStylusUC.type = "EmulateStylusUC";
+function makeEmulateStylusUC(appObject) {
+    return new EmulateStylusUCImp(appObject);
+}
+exports.makeEmulateStylusUC = makeEmulateStylusUC;
+class EmulateStylusUCImp extends EmulateStylusUC {
+    constructor(appObject) {
+        super(appObject, EmulateStylusUC.type);
+        this._eventElement = undefined;
+        this.lastMousePos = ValueObjects_1.Vector2.Zero();
+        this._isEmulating = false;
+        this.screenPlane = ValueObjects_1.ParametricPlane.FromPointNormal(ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Backward());
+        this.startEmulating = () => {
+            var _a;
+            if (!this.mouseInput)
+                return;
+            if (!this.stylus)
+                return;
+            if (this._isEmulating === true)
+                return;
+            this._eventElement = this.mouseInput.eventElement;
+            if (!this._eventElement) {
+                this.warn("No event element");
+                return;
+            }
+            this.mouseInput.clearInputElement();
+            (_a = this.touchInput) === null || _a === void 0 ? void 0 : _a.clearInputElement();
+            this._eventElement.addEventListener("mousedown", this.onMouseDown, false);
+            this._eventElement.addEventListener("mouseup", this.onMouseUp, false);
+            this._eventElement.addEventListener("mousemove", this.onMouseMove, false);
+            this._eventElement.addEventListener("keydown", this.submitKeyDown, false);
+            this.stylus.transform.localPosition = new ValueObjects_1.Vector3(0.05, -0.05, -0.5);
+            this._isEmulating = true;
+        };
+        this.stopEmulating = () => {
+            var _a;
+            if (!this.mouseInput)
+                return;
+            if (this._isEmulating === false)
+                return;
+            if (this._eventElement) {
+                this._eventElement.removeEventListener("mousedown", this.onMouseDown, false);
+                this._eventElement.removeEventListener("mouseup", this.onMouseUp, false);
+                this._eventElement.removeEventListener("mousemove", this.onMouseMove, false);
+                this._eventElement.removeEventListener("keydown", this.submitKeyDown, false);
+                this.mouseInput.setEventElement(this._eventElement);
+                (_a = this.touchInput) === null || _a === void 0 ? void 0 : _a.setEventElement(this._eventElement);
+            }
+            this._eventElement = undefined;
+            this._isEmulating = false;
+        };
+        this.submitKeyDown = (e) => {
+            const bumpAmount = 0.01;
+            let bump = ValueObjects_1.Vector3.Zero();
+            switch (e.code) {
+                case "KeyA":
+                    bump = new ValueObjects_1.Vector3(-bumpAmount, 0, 0);
+                    break;
+                case "KeyD":
+                    bump = new ValueObjects_1.Vector3(bumpAmount, 0, 0);
+                    break;
+                case "KeyW":
+                    bump = new ValueObjects_1.Vector3(0, 0, bumpAmount);
+                    break;
+                case "KeyS":
+                    bump = new ValueObjects_1.Vector3(0, 0, -bumpAmount);
+                    break;
+            }
+            if (!this.stylus)
+                return;
+            const currentPos = this.stylus.transform.localPosition;
+            this.stylus.transform.localPosition = ValueObjects_1.Vector3.Add(currentPos, bump);
+            this.pointAtMouse(this.lastMousePos);
+        };
+        this.onMouseDown = (e) => {
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, true);
+        };
+        this.onMouseUp = (e) => {
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, false);
+        };
+        this.onMouseMove = (e) => {
+            const px = e.offsetX;
+            const py = e.offsetY;
+            const pos = new ValueObjects_1.Vector2(px, py);
+            this.pointAtMouse(pos);
+            this.lastMousePos = pos;
+        };
+        this.pointAtMouse = (pos) => {
+            if (!this.stylus)
+                return;
+            const ray = Babylon_1.pixelToSceneRay(pos, this.appObjects);
+            const hit = this.screenPlane.intersectLine(ray);
+            if (!hit) {
+                return;
+            }
+            const direction = ValueObjects_1.Vector3.Subtract(hit, this.stylus.transform.localPosition);
+            this.stylus.transform.localRotation = ValueObjects_1.Quaternion.FromDirectionVector(direction);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get mouseInput() {
+        return this.getCachedSingleton(MouseInput_1.MouseInputEntity.type);
+    }
+    get touchInput() {
+        return this.getCachedSingleton(TouchController_1.TouchInputEntity.type);
+    }
+    get stylus() {
+        return this.getCachedSingleton(StylusEntity_1.StylusEntity.type);
+    }
+    get isEmulating() {
+        return this._isEmulating;
+    }
+}

package/lib/Components/Stylus/UCs/index.d.ts

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

package/lib/Components/Stylus/UCs/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("./EmulateStylusUC"), exports);

package/lib/Components/Stylus/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Entity";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/Stylus/index.js

@@ -0,0 +1,16 @@
+"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("./Entity"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Transform3D/Controllers/Mouse/DragScaleTransformMC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare class DragScaleTransformMC extends AppObjectController implements MouseController {
+    static readonly type = "DragScaleTransformMC";
+    private isDragging;
+    private scaleUC?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragScaleTransformMC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const MouseInput_1 = require("../../../MouseInput");
+const UC_1 = require("../../UC");
+class DragScaleTransformMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, DragScaleTransformMC.type);
+        this.isDragging = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            var _a;
+            this.isDragging = false;
+            if (!this.allow(e))
+                return;
+            const pixelPosition = e.position;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.initializePixel(pixelPosition);
+            this.isDragging = true;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.isDragging)
+                return;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.updatePixel(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            this.isDragging = false;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.finish();
+        };
+        this.scaleUC = appObject.getComponent(UC_1.ScaleTransformUC.type);
+        if (!this.scaleUC) {
+            this.error("App Object that does not have ScaleTransformUC");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.DragScaleTransformMC = DragScaleTransformMC;
+DragScaleTransformMC.type = "DragScaleTransformMC";

package/lib/Components/Transform3D/Controllers/Mouse/PanTransformMC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare class PanTransformMC extends AppObjectController implements MouseController {
+    static readonly type = "PanTransformMC";
+    private doPan;
+    allow: (e: MouseInputEvent) => boolean;
+    private panUC?;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PanTransformMC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const MouseInput_1 = require("../../../MouseInput");
+const UC_1 = require("../../UC");
+class PanTransformMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, PanTransformMC.type);
+        this.doPan = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            var _a;
+            this.doPan = false;
+            if (!this.allow(e))
+                return;
+            (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.initializePixel(e.position);
+            this.doPan = true;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.doPan)
+                return;
+            (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.updatePixel(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            this.doPan = false;
+            (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.finish();
+        };
+        this.panUC = appObject.getComponent(UC_1.PanTransformUC.type);
+        if (!this.panUC) {
+            this.error("Controller has been added to an App Object that does not have PanTransformUC. Add one first.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.PanTransformMC = PanTransformMC;
+PanTransformMC.type = "PanTransformMC";

package/lib/Components/Transform3D/Controllers/Mouse/RollScaleTransformMC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseWheelEvent } from "../../../MouseInput";
+export declare class RollScaleTransformMC extends AppObjectController implements MouseController {
+    static readonly type = "RollScaleTransformMC";
+    private bumpScaleUC?;
+    allow: (e: MouseWheelEvent) => boolean;
+    onWheel: (e: MouseWheelEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RollScaleTransformMC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const MouseInput_1 = require("../../../MouseInput");
+const UC_1 = require("../../UC");
+class RollScaleTransformMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, RollScaleTransformMC.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onWheel = (e) => {
+            if (!this.allow(e))
+                return;
+            if (!this.bumpScaleUC) {
+                return;
+            }
+            this.bumpScaleUC.bump(e.event.deltaY > 0 ? "OUT" : "IN", e.position);
+        };
+        this.bumpScaleUC =
+            appObject.getComponent(UC_1.BumpTransformScaleAboutPixelPointUC.type);
+        if (!this.bumpScaleUC) {
+            this.error("Controller has been added to an App Object that does not have BumpTransformScaleAboutPixelPointUC. Add one first.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.error("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.RollScaleTransformMC = RollScaleTransformMC;
+RollScaleTransformMC.type = "RollScaleTransformMC";

package/lib/Components/Transform3D/Controllers/Mouse/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DragScaleTransformMC";
+export * from "./PanTransformMC";
+export * from "./RollScaleTransformMC";

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

@@ -0,0 +1,15 @@
+"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("./DragScaleTransformMC"), exports);
+__exportStar(require("./PanTransformMC"), exports);
+__exportStar(require("./RollScaleTransformMC"), exports);

package/lib/Components/Transform3D/Controllers/Stylus/PanScaleTransformSC.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { StylusController } from "../../../Stylus";
+export declare class PanScaleTransformSC extends AppObjectController implements StylusController {
+    static readonly type = "PanScaleTransformSC";
+    private stylus?;
+    private uc?;
+    private doPan;
+    allow: (button: number) => boolean;
+    onButtonDown: (button: number) => void;
+    onButtonUp: () => void;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}