@tolokoban/tgd 2.0.1 → 2.0.3

package/lib/dist/camera/camera.js

@@ -0,0 +1,368 @@
+import { TgdQuat, TgdVec3, TgdMat4 } from "./../math/index.js";
+import { TgdMat3 } from "./../math/mat3.js";
+import { TgdEvent } from "../event/index.js";
+export class TgdCamera {
+    static incrementalId = 1;
+    /**
+     * A change in the position/orientation/size of the camera.
+     */
+    eventTransformChange = new TgdEvent();
+    name;
+    _screenWidth = 1920;
+    _screenHeight = 1080;
+    _screenAspectRatio = 1920 / 1080;
+    /** Do we need recalculation? */
+    _dirtyModelView = true;
+    dirtyModelViewInverse = true;
+    _dirtyAxis = true;
+    _dirtyProjection = true;
+    dirtyProjectionInverse = true;
+    _near = 1e-3;
+    _far = Infinity;
+    _axisX = new TgdVec3();
+    _axisY = new TgdVec3();
+    _axisZ = new TgdVec3();
+    // transformation
+    _matrixModelView = new TgdMat4();
+    _matrixModelViewInverse = new TgdMat4();
+    _matrixProjectionInverse = new TgdMat4();
+    _orientation = new TgdQuat(0, 0, 0, 1);
+    _shift = new TgdVec3(0, 0, 0);
+    _target = new TgdVec3(0, 0, 0);
+    _position = new TgdVec3(0, 0, 0);
+    _distance = 10;
+    _zoom = 1;
+    // For fast calculations (we don't want to recreate them).
+    tmpMat3 = new TgdMat3();
+    tmpVec3 = new TgdVec3();
+    constructor(options = {}) {
+        this.name = options.name ?? `TgdCamera#${TgdCamera.incrementalId++}`;
+        this._near = options.near ?? 1e-3;
+        this._far = options.far ?? 1e6;
+        this._distance = options.distance ?? 10;
+        this._zoom = options.zoom ?? 1;
+        const [tx, ty, tz] = options.target ?? [0, 0, 0];
+        this.target.reset(tx, ty, tz);
+        const [qx, qy, qz, qw] = options.orientation ?? [0, 0, 0, 1];
+        this.orientation.reset(qx, qy, qz, qw);
+    }
+    get near() {
+        return this._near;
+    }
+    set near(v) {
+        if (v === this._near)
+            return;
+        this._near = v;
+        this.dirtyProjection = true;
+    }
+    get far() {
+        return this._far;
+    }
+    set far(v) {
+        if (v === this._far)
+            return;
+        this._far = v;
+        this.dirtyProjection = true;
+    }
+    get screenAspectRatio() {
+        return this._screenAspectRatio;
+    }
+    get screenWidth() {
+        return this._screenWidth;
+    }
+    set screenWidth(v) {
+        if (v === this._screenWidth)
+            return;
+        this._screenWidth = v;
+        this.dirtyProjection = true;
+        this._screenAspectRatio = this._screenWidth / this._screenHeight;
+    }
+    get screenHeight() {
+        return this._screenHeight;
+    }
+    set screenHeight(v) {
+        if (v === this._screenHeight)
+            return;
+        this._screenHeight = v;
+        this.dirtyProjection = true;
+        this._screenAspectRatio = this._screenWidth / this._screenHeight;
+    }
+    get spaceHeightAtTarget() {
+        return this.getSpaceHeightAtTarget();
+    }
+    set spaceHeightAtTarget(v) {
+        this.setSpaceHeightAtTarget(v);
+    }
+    get spaceWidthAtTarget() {
+        return (this.screenWidth * this.spaceHeightAtTarget) / this.screenHeight;
+    }
+    set spaceWidthAtTarget(v) {
+        this.setSpaceHeightAtTarget((v * this.screenHeight) / this.screenWidth);
+    }
+    face(face) {
+        this._orientation.face(face);
+        this.dirtyModelView = true;
+        this.dirtyAxis = true;
+    }
+    from(camera) {
+        const { _orientation: orientation, _target: target, distance, zoom, screenWidth, screenHeight, } = camera;
+        this._orientation.from(orientation);
+        this._target.from(target);
+        this.distance = distance;
+        this.zoom = zoom;
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        this.dirtyModelView = true;
+        this.dirtyAxis = true;
+        this.copyProjectionFrom(camera);
+        return this;
+    }
+    get axisX() {
+        this.updateAxisIfNeeded();
+        return this._axisX;
+    }
+    get axisY() {
+        this.updateAxisIfNeeded();
+        return this._axisY;
+    }
+    get axisZ() {
+        this.updateAxisIfNeeded();
+        return this._axisZ;
+    }
+    get matrixModelView() {
+        this.updateIfNeeded();
+        return this._matrixModelView;
+    }
+    get matrixModelViewInverse() {
+        if (this.dirtyModelViewInverse) {
+            this._matrixModelViewInverse.invert(this.matrixModelView);
+            this.dirtyModelViewInverse = false;
+        }
+        return this._matrixModelViewInverse;
+    }
+    get matrixProjectionInverse() {
+        if (this.dirtyProjectionInverse) {
+            this._matrixProjectionInverse.invert(this.matrixProjection);
+            this.dirtyProjectionInverse = false;
+        }
+        return this._matrixProjectionInverse;
+    }
+    get orientation() {
+        return this._orientation;
+    }
+    set orientation(quat) {
+        const { _orientation } = this;
+        if (quat.isEqual(_orientation))
+            return;
+        const [x, y, z, w] = quat;
+        _orientation.x = x;
+        _orientation.y = y;
+        _orientation.z = z;
+        _orientation.w = w;
+        this.dirtyModelView = true;
+        this.dirtyAxis = true;
+    }
+    setOrientation(x, y, z, w) {
+        const { _orientation } = this;
+        _orientation.x = x;
+        _orientation.y = y;
+        _orientation.z = z;
+        _orientation.w = w;
+        this.dirtyModelView = true;
+        this.dirtyAxis = true;
+        return this;
+    }
+    get position() {
+        this.updateIfNeeded();
+        return this._position;
+    }
+    get target() {
+        return this._target;
+    }
+    set target(v) {
+        this._target.from(v);
+        this.dirtyModelView = true;
+    }
+    setTarget(x, y, z) {
+        const { _target } = this;
+        _target.x = x;
+        _target.y = y;
+        _target.z = z;
+        this.dirtyModelView = true;
+        return this;
+    }
+    get shift() {
+        return this._shift;
+    }
+    set shift(v) {
+        this._shift.from(v);
+        this.dirtyModelView = true;
+    }
+    setShift(x, y, z) {
+        const { _shift } = this;
+        _shift.x = x;
+        _shift.y = y;
+        _shift.z = z;
+        this.dirtyModelView = true;
+        return this;
+    }
+    get x() {
+        return this._target.x;
+    }
+    set x(v) {
+        const { _target: target } = this;
+        if (v === target.x)
+            return;
+        target.x = v;
+        this.dirtyModelView = true;
+    }
+    get y() {
+        return this._target.y;
+    }
+    set y(v) {
+        const { _target: target } = this;
+        if (v === target.y)
+            return;
+        target.y = v;
+        this.dirtyModelView = true;
+    }
+    get z() {
+        return this._target.z;
+    }
+    set z(v) {
+        const { _target: target } = this;
+        if (v === target.z)
+            return;
+        target.z = v;
+        this.dirtyModelView = true;
+    }
+    get distance() {
+        return this._distance;
+    }
+    set distance(v) {
+        if (this._distance === v)
+            return;
+        this._distance = v;
+        this.dirtyModelView = true;
+    }
+    get zoom() {
+        return this._zoom;
+    }
+    set zoom(v) {
+        if (this._zoom === v)
+            return;
+        this._zoom = v;
+        this.dirtyModelView = true;
+    }
+    /**
+     * Add (x,y,z) to the target coords in Camera space.
+     * That means we are moving along the camera axis.
+     */
+    moveTarget(x, y, z) {
+        const { _target: target } = this;
+        this.updateAxisIfNeeded();
+        const { _axisX: axisX, _axisY: axisY, _axisZ: axisZ, tmpVec3 } = this;
+        tmpVec3
+            .from(axisX)
+            .scale(x)
+            .addWithScale(axisY, y)
+            .addWithScale(axisZ, z);
+        target.x += tmpVec3.x;
+        target.y += tmpVec3.y;
+        target.z += tmpVec3.z;
+        this.dirtyModelView = true;
+    }
+    moveShift(x, y, z) {
+        const [sx, sy, sz] = this._shift;
+        this._shift.reset(x + sx, y + sy, z + sz);
+        this._dirtyModelView = true;
+    }
+    orbitAroundX(angleInRadians) {
+        this.updateAxisIfNeeded();
+        const { _axisX: axisX, _axisY: axisY, _axisZ: axisZ, _orientation: orientation, } = this;
+        axisY.rotateAround(axisX, angleInRadians);
+        axisZ.rotateAround(axisX, angleInRadians);
+        orientation.fromAxis(axisX, axisY, axisZ);
+        this.dirtyModelView = true;
+        return this;
+    }
+    orbitAroundY(angleInRadians) {
+        this.updateAxisIfNeeded();
+        const { _axisX: axisX, _axisY: axisY, _axisZ: axisZ, _orientation: orientation, } = this;
+        axisX.rotateAround(axisY, angleInRadians);
+        axisZ.rotateAround(axisY, angleInRadians);
+        orientation.fromAxis(axisX, axisY, axisZ);
+        this.dirtyModelView = true;
+        return this;
+    }
+    orbitAroundZ(angleInRadians) {
+        this.updateAxisIfNeeded();
+        const { _axisX: axisX, _axisY: axisY, _axisZ: axisZ, _orientation: orientation, } = this;
+        axisX.rotateAround(axisZ, angleInRadians);
+        axisY.rotateAround(axisZ, angleInRadians);
+        orientation.fromAxis(axisX, axisY, axisZ);
+        this.dirtyModelView = true;
+        return this;
+    }
+    debug(caption) {
+        this._orientation.debug(`${caption ?? this.name} quaternion:`);
+    }
+    updateAxisIfNeeded() {
+        if (this.dirtyAxis)
+            this.updateAxis();
+    }
+    updateAxis() {
+        const { tmpMat3 } = this;
+        tmpMat3.fromQuat(this._orientation);
+        tmpMat3.toAxis(this._axisX, this._axisY, this._axisZ);
+        this.dirtyAxis = false;
+    }
+    updateIfNeeded() {
+        if (!this.dirtyModelView)
+            return;
+        const { tmpMat3, tmpVec3, _position } = this;
+        const mat = this._matrixModelView;
+        this.updateAxis();
+        const d = this._distance;
+        const { x: sx, y: sy, z: sz } = this._shift;
+        const { x: tx, y: ty, z: tz } = this._target;
+        const { x: ax, y: ay, z: az } = this._axisZ;
+        _position.x = tx + d * ax;
+        _position.y = ty + d * ay;
+        _position.z = tz + d * az;
+        _position.addWithScale(this._axisX, sx);
+        _position.addWithScale(this._axisY, sy);
+        _position.addWithScale(this._axisZ, sz);
+        tmpVec3.from(_position).applyMatrix(tmpMat3.transpose()).scale(-1);
+        mat.m30 = tmpVec3.x;
+        mat.m31 = tmpVec3.y;
+        mat.m32 = tmpVec3.z;
+        mat.fromMat3(tmpMat3);
+        this.dirtyModelView = false;
+    }
+    get dirtyModelView() {
+        return this._dirtyModelView;
+    }
+    set dirtyModelView(v) {
+        this._dirtyModelView = v;
+        if (v) {
+            this.dirtyModelViewInverse = true;
+            this.eventTransformChange.dispatch(this);
+        }
+    }
+    get dirtyAxis() {
+        return this._dirtyAxis;
+    }
+    set dirtyAxis(v) {
+        this._dirtyAxis = v;
+    }
+    get dirtyProjection() {
+        return this._dirtyProjection;
+    }
+    set dirtyProjection(v) {
+        this._dirtyProjection = v;
+        if (v)
+            this.dirtyProjectionInverse = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"camera.js","sourceRoot":"","sources":["../../src/camera/camera.ts"],"names":[],"mappings":"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"}

package/lib/dist/camera/index.d.ts

@@ -1,4 +1,4 @@
-export { TgdCamera } from "./camera";
-export { TgdCameraOrthographic } from "./camera-orthographic";
-export { TgdCameraPerspective } from "./camera-perspective";
+export * from "./camera";
+export * from "./camera-orthographic";
+export * from "./camera-perspective";
 //# sourceMappingURL=index.d.ts.map

package/lib/dist/camera/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/camera/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/camera/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA"}

package/lib/dist/camera/index.js

@@ -0,0 +1,4 @@
+export * from "./camera.js";
+export * from "./camera-orthographic.js";
+export * from "./camera-perspective.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2FtZXJhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFBO0FBQ3hCLGNBQWMsdUJBQXVCLENBQUE7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQSJ9

package/lib/dist/canvas/gizmo/gizmo.d.ts

@@ -0,0 +1,42 @@
+import { TgdCamera } from "../../camera";
+import { TgdContextOptions } from "../../context";
+import { TgdEvent } from "../../event";
+import { TgdQuat } from "../../math";
+export interface TgdCanvasGizmoOptions extends TgdContextOptions {
+    canvas?: HTMLCanvasElement;
+}
+/**
+ * The Gizmo displays the orientation of an attached camera.
+ * You can click one of the axis to force the camera to face it.
+ */
+export declare class TgdCanvasGizmo {
+    private readonly options;
+    /**
+     * The user clicked a tip, so we dispatch the target orientation.
+     */
+    eventTipClick: TgdEvent<{
+        from: Readonly<TgdQuat>;
+        to: Readonly<TgdQuat>;
+    }>;
+    private _canvas;
+    private context;
+    private cameraExternal;
+    private readonly cameraInternal;
+    private orbiter;
+    private tipsPainter;
+    constructor(options?: TgdCanvasGizmoOptions);
+    /**
+     * Attach the camera we want to track and control.
+     */
+    attachCamera(camera: TgdCamera): void;
+    detach(): void;
+    private attach;
+    private readonly handleExternalToInternal;
+    private readonly handleInternalToExternal;
+    get canvas(): HTMLCanvasElement | null;
+    set canvas(canvas: HTMLCanvasElement | null);
+    private readonly handleTap;
+    private findAxisX;
+    private findAxisY;
+}
+//# sourceMappingURL=gizmo.d.ts.map

package/lib/dist/canvas/gizmo/gizmo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo.d.ts","sourceRoot":"","sources":["../../../src/canvas/gizmo/gizmo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAwB,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAc,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAE5D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,OAAO,EAAoB,MAAM,WAAW,CAAA;AAKrD,MAAM,WAAW,qBAAsB,SAAQ,iBAAiB;IAC5D,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAC7B;AAED;;;GAGG;AACH,qBAAa,cAAc;IAqBX,OAAO,CAAC,QAAQ,CAAC,OAAO;IApBpC;;OAEG;IACI,aAAa;cACV,SAAS,OAAO,CAAC;YACnB,SAAS,OAAO,CAAC;OACrB;IAEJ,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAK7B;IACF,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,WAAW,CAA2B;gBAEjB,OAAO,GAAE,qBAA0B;IAIhE;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,SAAS;IAM9B,MAAM;IAUN,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAExC;IAED,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAKxC;IAED,IAAI,MAAM,IAGS,iBAAiB,GAAG,IAAI,CAD1C;IACD,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,EA6C1C;IAED,OAAO,CAAC,QAAQ,CAAC,SAAS,CAmCzB;IAED,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,SAAS;CAepB"}

package/lib/dist/canvas/gizmo/gizmo.js

@@ -0,0 +1,183 @@
+import { TgdCameraPerspective } from "./../../camera/index.js";
+import { TgdContext } from "./../../context/index.js";
+import { TgdControllerCameraOrbit } from "./../../controller/index.js";
+import { TgdEvent } from "./../../event/index.js";
+import { TgdQuat, TgdMat3, TgdVec3 } from "./../../math/index.js";
+import { TgdPainterClear, TgdPainterDepth } from "./../../painter/index.js";
+import { TipsPainter } from "./painter/tips.js";
+/**
+ * The Gizmo displays the orientation of an attached camera.
+ * You can click one of the axis to force the camera to face it.
+ */
+export class TgdCanvasGizmo {
+    options;
+    /**
+     * The user clicked a tip, so we dispatch the target orientation.
+     */
+    eventTipClick = new TgdEvent();
+    _canvas = null;
+    context = null;
+    cameraExternal = null;
+    cameraInternal = new TgdCameraPerspective({
+        fovy: Math.PI / 3,
+        distance: 2.7,
+        near: 0.01,
+        far: 10,
+    });
+    orbiter = null;
+    tipsPainter = null;
+    constructor(options = {}) {
+        this.options = options;
+        if (options.canvas)
+            this.canvas = options.canvas;
+    }
+    /**
+     * Attach the camera we want to track and control.
+     */
+    attachCamera(camera) {
+        this.detach();
+        this.cameraExternal = camera;
+        this.attach();
+    }
+    detach() {
+        const camera = this.cameraExternal;
+        if (camera) {
+            camera.eventTransformChange.removeListener(this.handleExternalToInternal);
+            this.cameraExternal = null;
+        }
+    }
+    attach() {
+        const camera = this.cameraExternal;
+        if (camera)
+            camera.eventTransformChange.addListener(this.handleExternalToInternal);
+        this.context?.paint();
+    }
+    handleExternalToInternal = (externalCamera) => {
+        this.cameraInternal.orientation = externalCamera.orientation;
+    };
+    handleInternalToExternal = (internalCamera) => {
+        const { cameraExternal } = this;
+        if (cameraExternal) {
+            cameraExternal.orientation = internalCamera.orientation;
+        }
+    };
+    get canvas() {
+        return this._canvas;
+    }
+    set canvas(canvas) {
+        if (canvas === this._canvas)
+            return;
+        this._canvas = canvas;
+        if (this.context) {
+            this.context.inputs.pointer.eventTap.removeListener(this.handleTap);
+            this.context.destroy();
+            this.context = null;
+            const { orbiter } = this;
+            if (orbiter) {
+                orbiter.detach();
+                orbiter.eventChange.removeListener(this.handleInternalToExternal);
+            }
+        }
+        this.tipsPainter?.delete();
+        if (!canvas)
+            return;
+        const context = new TgdContext(canvas, {
+            alpha: true,
+            depth: true,
+            antialias: true,
+            name: "GizmoCanvas",
+            ...this.options,
+        });
+        context.inputs.pointer.eventTap.addListener(this.handleTap);
+        this.context = context;
+        context.camera = this.cameraInternal;
+        this.orbiter = new TgdControllerCameraOrbit(context, {
+            speedPanning: 0,
+            speedZoom: 0,
+        });
+        this.orbiter.eventChange.addListener(this.handleInternalToExternal);
+        const painter = new TipsPainter(context);
+        this.tipsPainter = painter;
+        context.add(new TgdPainterClear(context, {
+            color: [0, 0, 0, 0],
+            depth: 1,
+        }), new TgdPainterDepth(context, { enabled: true }), painter);
+        context.paint();
+    }
+    handleTap = (evt) => {
+        const camera = this.context?.camera;
+        if (!camera)
+            return;
+        const { origin, direction } = camera.castRay(evt.x, evt.y);
+        const maxDist = 1;
+        let bestDist = maxDist;
+        let bestTip = TIPS[0];
+        for (const tip of TIPS) {
+            const dist = tip.distanceToLineSquared(origin, direction);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestTip = tip;
+            }
+        }
+        if (bestDist < maxDist) {
+            const axisX = new TgdVec3();
+            const axisY = new TgdVec3();
+            const axisZ = bestTip;
+            axisX.from(this.findAxisX());
+            if (axisX.isClose(axisZ)) {
+                axisY.from(this.findAxisY());
+                axisX.from(axisY).cross(axisZ);
+            }
+            else {
+                axisY.from(axisZ).cross(axisX);
+            }
+            const quat = new TgdQuat().fromAxis(axisX, axisY, axisZ);
+            if (quat.isEqual(camera.orientation)) {
+                quat.rotateAroundY(Math.PI);
+            }
+            this.eventTipClick.dispatch({
+                from: new TgdQuat(camera.orientation),
+                to: quat,
+            });
+        }
+    };
+    findAxisX() {
+        let bestScore = 0;
+        let bestTip = TIPS[0];
+        const vec = new TgdVec3();
+        const mat = new TgdMat3();
+        mat.fromQuat(this.cameraInternal.orientation).transpose();
+        for (const tip of TIPS) {
+            vec.from(tip).applyMatrix(mat);
+            if (vec.x > bestScore) {
+                bestScore = vec.x;
+                bestTip = tip;
+            }
+        }
+        return bestTip;
+    }
+    findAxisY() {
+        let bestScore = 0;
+        let bestTip = TIPS[0];
+        const vec = new TgdVec3();
+        const mat = new TgdMat3();
+        mat.fromQuat(this.cameraInternal.orientation).transpose();
+        for (const tip of TIPS) {
+            vec.from(tip).applyMatrix(mat);
+            if (vec.y > bestScore) {
+                bestScore = vec.y;
+                bestTip = tip;
+            }
+        }
+        return bestTip;
+    }
+}
+const TIPS = [
+    new TgdVec3(1, 0, 0),
+    new TgdVec3(0, 1, 0),
+    new TgdVec3(0, 0, 1),
+    new TgdVec3(-1, 0, 0),
+    new TgdVec3(0, -1, 0),
+    new TgdVec3(0, 0, -1),
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo.js","sourceRoot":"","sources":["../../../src/canvas/gizmo/gizmo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAqB,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAM5C;;;GAGG;AACH,MAAM,OAAO,cAAc;IAqBM;IApB7B;;OAEG;IACI,aAAa,GAAG,IAAI,QAAQ,EAG/B,CAAA;IAEI,OAAO,GAA6B,IAAI,CAAA;IACxC,OAAO,GAAsB,IAAI,CAAA;IACjC,cAAc,GAAqB,IAAI,CAAA;IAC9B,cAAc,GAAG,IAAI,oBAAoB,CAAC;QACvD,IAAI,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC;QACjB,QAAQ,EAAE,GAAG;QACb,IAAI,EAAE,IAAI;QACV,GAAG,EAAE,EAAE;KACV,CAAC,CAAA;IACM,OAAO,GAAoC,IAAI,CAAA;IAC/C,WAAW,GAAuB,IAAI,CAAA;IAE9C,YAA6B,UAAiC,EAAE;QAAnC,YAAO,GAAP,OAAO,CAA4B;QAC5D,IAAI,OAAO,CAAC,MAAM;YAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAA;IACpD,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,MAAiB;QAC1B,IAAI,CAAC,MAAM,EAAE,CAAA;QACb,IAAI,CAAC,cAAc,GAAG,MAAM,CAAA;QAC5B,IAAI,CAAC,MAAM,EAAE,CAAA;IACjB,CAAC;IAED,MAAM;QACF,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAA;QAClC,IAAI,MAAM,EAAE,CAAC;YACT,MAAM,CAAC,oBAAoB,CAAC,cAAc,CACtC,IAAI,CAAC,wBAAwB,CAChC,CAAA;YACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;QAC9B,CAAC;IACL,CAAC;IAEO,MAAM;QACV,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAA;QAClC,IAAI,MAAM;YACN,MAAM,CAAC,oBAAoB,CAAC,WAAW,CACnC,IAAI,CAAC,wBAAwB,CAChC,CAAA;QACL,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAA;IACzB,CAAC;IAEgB,wBAAwB,GAAG,CAAC,cAAyB,EAAE,EAAE;QACtE,IAAI,CAAC,cAAc,CAAC,WAAW,GAAG,cAAc,CAAC,WAAW,CAAA;IAChE,CAAC,CAAA;IAEgB,wBAAwB,GAAG,CAAC,cAAyB,EAAE,EAAE;QACtE,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CAAA;QAC/B,IAAI,cAAc,EAAE,CAAC;YACjB,cAAc,CAAC,WAAW,GAAG,cAAc,CAAC,WAAW,CAAA;QAC3D,CAAC;IACL,CAAC,CAAA;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAA;IACvB,CAAC;IACD,IAAI,MAAM,CAAC,MAAgC;QACvC,IAAI,MAAM,KAAK,IAAI,CAAC,OAAO;YAAE,OAAM;QAEnC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YACnE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;YACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;YACnB,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;YACxB,IAAI,OAAO,EAAE,CAAC;gBACV,OAAO,CAAC,MAAM,EAAE,CAAA;gBAChB,OAAO,CAAC,WAAW,CAAC,cAAc,CAC9B,IAAI,CAAC,wBAAwB,CAChC,CAAA;YACL,CAAC;QACL,CAAC;QACD,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,CAAA;QAC1B,IAAI,CAAC,MAAM;YAAE,OAAM;QAEnB,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,MAAM,EAAE;YACnC,KAAK,EAAE,IAAI;YACX,KAAK,EAAE,IAAI;YACX,SAAS,EAAE,IAAI;YACf,IAAI,EAAE,aAAa;YACnB,GAAG,IAAI,CAAC,OAAO;SAClB,CAAC,CAAA;QACF,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC3D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAA;QACpC,IAAI,CAAC,OAAO,GAAG,IAAI,wBAAwB,CAAC,OAAO,EAAE;YACjD,YAAY,EAAE,CAAC;YACf,SAAS,EAAE,CAAC;SACf,CAAC,CAAA;QACF,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAA;QACnE,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAA;QACxC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAA;QAC1B,OAAO,CAAC,GAAG,CACP,IAAI,eAAe,CAAC,OAAO,EAAE;YACzB,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YACnB,KAAK,EAAE,CAAC;SACX,CAAC,EACF,IAAI,eAAe,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAC/C,OAAO,CACV,CAAA;QACD,OAAO,CAAC,KAAK,EAAE,CAAA;IACnB,CAAC;IAEgB,SAAS,GAAG,CAAC,GAA4B,EAAE,EAAE;QAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAA;QACnC,IAAI,CAAC,MAAM;YAAE,OAAM;QAEnB,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;QAC1D,MAAM,OAAO,GAAG,CAAC,CAAA;QACjB,IAAI,QAAQ,GAAG,OAAO,CAAA;QACtB,IAAI,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QACrB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACrB,MAAM,IAAI,GAAG,GAAG,CAAC,qBAAqB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;YACzD,IAAI,IAAI,GAAG,QAAQ,EAAE,CAAC;gBAClB,QAAQ,GAAG,IAAI,CAAA;gBACf,OAAO,GAAG,GAAG,CAAA;YACjB,CAAC;QACL,CAAC;QACD,IAAI,QAAQ,GAAG,OAAO,EAAE,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,OAAO,EAAE,CAAA;YAC3B,MAAM,KAAK,GAAG,IAAI,OAAO,EAAE,CAAA;YAC3B,MAAM,KAAK,GAAG,OAAO,CAAA;YACrB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAA;YAC5B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAA;gBAC5B,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC;iBAAM,CAAC;gBACJ,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;YACxD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;YAC/B,CAAC;YACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;gBACxB,IAAI,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC;gBACrC,EAAE,EAAE,IAAI;aACX,CAAC,CAAA;QACN,CAAC;IACL,CAAC,CAAA;IAEO,SAAS;QACb,IAAI,SAAS,GAAG,CAAC,CAAA;QACjB,IAAI,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QACrB,MAAM,GAAG,GAAG,IAAI,OAAO,EAAE,CAAA;QACzB,MAAM,GAAG,GAAG,IAAI,OAAO,EAAE,CAAA;QACzB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,EAAE,CAAA;QACzD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACrB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;YAC9B,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;gBACpB,SAAS,GAAG,GAAG,CAAC,CAAC,CAAA;gBACjB,OAAO,GAAG,GAAG,CAAA;YACjB,CAAC;QACL,CAAC;QACD,OAAO,OAAO,CAAA;IAClB,CAAC;IAEO,SAAS;QACb,IAAI,SAAS,GAAG,CAAC,CAAA;QACjB,IAAI,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QACrB,MAAM,GAAG,GAAG,IAAI,OAAO,EAAE,CAAA;QACzB,MAAM,GAAG,GAAG,IAAI,OAAO,EAAE,CAAA;QACzB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,EAAE,CAAA;QACzD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACrB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;YAC9B,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;gBACpB,SAAS,GAAG,GAAG,CAAC,CAAC,CAAA;gBACjB,OAAO,GAAG,GAAG,CAAA;YACjB,CAAC;QACL,CAAC;QACD,OAAO,OAAO,CAAA;IAClB,CAAC;CACJ;AAED,MAAM,IAAI,GAAc;IACpB,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACpB,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACpB,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACpB,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACrB,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACrB,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CACxB,CAAA"}

package/lib/dist/canvas/gizmo/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./gizmo";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/canvas/gizmo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/gizmo/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/lib/dist/canvas/gizmo/index.js

@@ -0,0 +1,2 @@
+export * from "./gizmo.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2FudmFzL2dpem1vL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFBIn0=