@woosh/meep-engine 3.14.5 → 3.14.6

package/editor/tools/engine/Tool.d.ts

@@ -0,0 +1,88 @@
+export default Tool;
+declare class Tool {
+    name: any;
+    mode: ObservedValue;
+    settings: {};
+    modifiers: {
+        shift: boolean;
+        alternative: boolean;
+    };
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine: Engine | null;
+    /**
+     *
+     * @type {Editor|null}
+     */
+    editor: Editor | null;
+    /**
+     *
+     * @type {ObservedString}
+     */
+    icon: ObservedString;
+    /**
+     *
+     * @param {Editor} editor
+     */
+    updateIcon(editor: Editor): void;
+    /**
+     * Optional bespoke section rendered below the reflected settings rows, for controls a
+     * plain value row cannot express (e.g. a layer swatch picker).
+     *
+     * @param {Editor} editor
+     * @returns {View|null} null when the tool has no custom section
+     */
+    buildCustomSettingsView(editor: Editor): View | null;
+    /**
+     *
+     * @returns {ToolState|number}
+     */
+    getState(): ToolState | number;
+    isRunning(): boolean;
+    /**
+     * Activate the tool and prepare it for usage
+     */
+    initialize(): void;
+    /**
+     * Deactivate the tool and remove and influence it may have
+     */
+    finalize(): void;
+    /**
+     * Update loop
+     */
+    update(): void;
+    /**
+     * Start usage of the tool. Called by {@link ToolEngine} when a gesture is handed over.
+     * Subclasses put their own work in {@link Tool#handleStart} instead of overriding this,
+     * so the running state cannot be left behind.
+     *
+     * @example Start painting with a brush
+     */
+    start(): void;
+    /**
+     * Finish usage of the tool. As with {@link Tool#start}, subclasses override
+     * {@link Tool#handleStop} rather than this.
+     *
+     * @example Finish brush stroke
+     */
+    stop(): void;
+    /**
+     * Open a gesture. The tool is already {@link ToolState.Running} here, so work kicked off
+     * from this hook — an immediate first brush dab, say — observes the same state a later
+     * {@link Tool#update} would.
+     */
+    handleStart(): void;
+    /**
+     * Close the gesture {@link Tool#handleStart} opened and commit whatever it accumulated.
+     * Still {@link ToolState.Running} here; the tool is Ready once this returns.
+     */
+    handleStop(): void;
+    handleKeyboardEvent(e: any): void;
+    #private;
+}
+import ObservedValue from '../../../src/core/model/ObservedValue.js';
+import ObservedString from "../../../src/core/model/ObservedString.js";
+import { ToolState } from "./ToolState.js";
+//# sourceMappingURL=Tool.d.ts.map

package/editor/tools/engine/Tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/Tool.js"],"names":[],"mappings":";AAIA;IAGI,UAAY;IACZ,oBAA2B;IAC3B,aAAc;IACd;;;MAGE;IAEF;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,MAFU,cAAc,CAEM;IAS9B;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,yCAFa,OAAK,IAAI,CAIrB;IAED;;;OAGG;IACH,YAFa,SAAS,GAAC,MAAM,CAI5B;IAED,qBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,iBAEC;IAED;;OAEG;IACH,eAEC;IAED;;;;;;OAMG;IACH,cAIC;IAED;;;;;OAKG;IACH,aASC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;OAGG;IACH,mBAEC;IAED,kCAEC;;CACJ;0BA7IyB,0CAA0C;2BADzC,2CAA2C;0BAE5C,gBAAgB"}

package/editor/tools/engine/ToolEngine.d.ts

@@ -0,0 +1,22 @@
+export default ToolEngine;
+declare class ToolEngine {
+    tools: List<any>;
+    active: ObservedValue;
+    engine: any;
+    isRunning: boolean;
+    shutdownCallbacks: any[];
+    pointer: any;
+    activate(toolName: any): void;
+    initialize(): void;
+    /**
+     *
+     * @param {Engine} engine
+     * @param {Editor} editor
+     */
+    startup(engine: Engine, editor: Editor): void;
+    editor: Editor;
+    shutdown(): void;
+}
+import List from '../../../src/core/collection/list/List.js';
+import ObservedValue from '../../../src/core/model/ObservedValue.js';
+//# sourceMappingURL=ToolEngine.d.ts.map

package/editor/tools/engine/ToolEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEngine.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolEngine.js"],"names":[],"mappings":";AAWA;IACI,iBAAmB;IACnB,sBAAiC;IACjC,YAAc;IACd,mBAAkB;IAClB,yBAAuB;IACvB,aAAe;IAUf,8BAOC;IAED,mBA8BC;IAED;;;;OAIG;IACH,8CA4FC;IA1FG,eAAoB;IA4FxB,iBAgBC;CACJ;iBAxLgB,2CAA2C;0BAClC,0CAA0C"}

package/editor/tools/engine/ToolState.d.ts

@@ -0,0 +1,7 @@
+export type ToolState = number;
+export namespace ToolState {
+    let Initial: number;
+    let Ready: number;
+    let Running: number;
+}
+//# sourceMappingURL=ToolState.d.ts.map

package/editor/tools/engine/ToolState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolState.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolState.js"],"names":[],"mappings":"wBAEU,MAAM"}

package/editor/tools/paint/TerrainHeightPaintTool.d.ts

@@ -0,0 +1,18 @@
+export class TerrainHeightPaintTool extends TerrainPaintTool {
+    /**
+     *
+     * @type {QuadTreeNode<number>}
+     */
+    transform_index: QuadTreeNode<number>;
+    buildTransformIndex(): void;
+    /**
+     *
+     * @param {PatchTerrainHeightAction} action
+     * @returns {Action[]}
+     */
+    createObjectMoveActions(action: PatchTerrainHeightAction): Action[];
+}
+import { TerrainPaintTool } from "./TerrainPaintTool.js";
+import { QuadTreeNode } from "../../../src/core/geom/2d/quad-tree/QuadTreeNode.js";
+import { PatchTerrainHeightAction } from "../../actions/concrete/PatchTerrainHeightAction.js";
+//# sourceMappingURL=TerrainHeightPaintTool.d.ts.map

package/editor/tools/paint/TerrainHeightPaintTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainHeightPaintTool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/paint/TerrainHeightPaintTool.js"],"names":[],"mappings":"AA8FA;IAQQ;;;OAGG;IACH,iBAFU,aAAa,MAAM,CAAC,CAEW;IAG7C,4BAiDC;IA8CD;;;;OAIG;IACH,gCAHW,wBAAwB,GACtB,QAAQ,CAwEpB;CAaJ;iCA3RgC,uBAAuB;6BAR3B,qDAAqD;yCAKzC,oDAAoD"}

package/editor/tools/paint/TerrainPaintTool.d.ts

@@ -0,0 +1,82 @@
+export class TerrainPaintTool extends Tool {
+    /**
+     * Scale a UV rect into the continuous texel space of a sampler of the given dimensions.
+     *
+     * Kept separate from {@link TerrainPaintTool#computeBrushUVRect} because the terrain's
+     * heightmap, splat map and overlay all have different resolutions, and each one converts the
+     * same UV footprint into its own domain.
+     *
+     * `result` may be the same array as `uv_rect`.
+     *
+     * @param {Float64Array|number[]} result `[x0, y0, x1, y1]` in texels
+     * @param {Float64Array|number[]} uv_rect `[x0, y0, x1, y1]` in UV
+     * @param {number} width sampler width in texels
+     * @param {number} height sampler height in texels
+     */
+    static uvRectToTexelRect(result: Float64Array | number[], uv_rect: Float64Array | number[], width: number, height: number): void;
+    /**
+     * Snap a continuous texel rect to the integer texel range that lies fully inside it: low bounds
+     * round up, high bounds round down. Written out once because the two paint tools iterate the
+     * resulting range with `for (x = x0; x < x1; x++)` and must agree on which texels a brush
+     * covers.
+     *
+     * `result` may be the same array as `texel_rect`.
+     *
+     * @param {Float64Array|number[]} result `[x0, y0, x1, y1]`, x1/y1 exclusive
+     * @param {Float64Array|number[]} texel_rect `[x0, y0, x1, y1]`
+     */
+    static texelRectToIntegerRect(result: Float64Array | number[], texel_rect: Float64Array | number[]): void;
+    name: string;
+    __paint_debt: number;
+    __paint_pending: boolean;
+    /**
+     * whether the last terrain pick hit; painting is gated on it
+     * @type {boolean}
+     */
+    __brush_valid: boolean;
+    /**
+     * @type {Terrain|null}
+     */
+    terrain: Terrain | null;
+    __brushPosition: Vector2;
+    __brushImage: HTMLCanvasElement;
+    /**
+     *
+     * @param {number} timeDelta
+     */
+    paint(timeDelta: number): Promise<void>;
+    /**
+     *
+     * @param {number} timeDelta
+     */
+    update(timeDelta: number): void;
+    updateBrushImage(): void;
+    updateBrushPosition(): void;
+    /**
+     * Footprint of the brush in terrain UV space (`[0,1]` across the terrain extent), written as
+     * `[x0, y0, x1, y1]`.
+     *
+     * Every consumer of the brush — the on-screen overlay preview and each subclass's `paint` —
+     * must derive its rect from this one definition, otherwise the preview stops matching what is
+     * actually painted.
+     *
+     * @param {Float64Array|number[]} result
+     */
+    computeBrushUVRect(result: Float64Array | number[]): void;
+    updateOverlay(): void;
+    /**
+     * Grow or shrink the brush footprint
+     * @param {number} delta size change, world units
+     * @private
+     */
+    private __adjustBrushSize;
+    /**
+     *
+     * @param {KeyboardEvent} event
+     */
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    terrainEntity: number;
+}
+import Tool from "../engine/Tool.js";
+import Vector2 from "../../../src/core/geom/Vector2.js";
+//# sourceMappingURL=TerrainPaintTool.d.ts.map

package/editor/tools/paint/TerrainPaintTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainPaintTool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/paint/TerrainPaintTool.js"],"names":[],"mappings":"AAqBA;IAgKI;;;;;;;;;;;;;OAaG;IACH,iCALW,YAAY,GAAC,MAAM,EAAE,WACrB,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,UACN,MAAM,QAOhB;IAED;;;;;;;;;;OAUG;IACH,sCAHW,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,QAO/B;IApMD,aAAuB;IACvB,qBAAiB;IACjB,yBAAwB;IAExB;;;OAGG;IACH,eAFU,OAAO,CAEK;IAEtB;;OAEG;IACH,SAFU,UAAQ,IAAI,CAEP;IAiBX,yBAAoC;IAEpC,gCAAoD;IAGxD;;;OAGG;IACH,iBAFW,MAAM,iBAIhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QA6BhB;IAED,yBAiCC;IAED,4BAkBC;IAED;;;;;;;;;OASG;IACH,2BAFW,YAAY,GAAC,MAAM,EAAE,QAkB/B;IAyCD,sBAoBC;IAED;;;;OAIG;IACH,0BAMC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAUvB;IAYO,sBAA2B;CAwCtC;iBApTgB,mBAAmB;oBAThB,mCAAmC"}

package/editor/tools/paint/TerrainTexturePaintTool.d.ts

@@ -0,0 +1,19 @@
+export class TerrainTexturePaintTool extends TerrainPaintTool {
+    __iconLayer: any;
+    /**
+     *
+     * @type {Float32Array}
+     * @private
+     */
+    private __splatMapScratch;
+    updateIcon(editor: any): void;
+    /**
+     *
+     * @param {Terrain} terrain
+     */
+    buildIcon(terrain: Terrain): void;
+    __handleLayerChanged(): void;
+    paint(timeDelta: any): Promise<void>;
+}
+import { TerrainPaintTool } from "./TerrainPaintTool.js";
+//# sourceMappingURL=TerrainTexturePaintTool.d.ts.map

package/editor/tools/paint/TerrainTexturePaintTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainTexturePaintTool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/paint/TerrainTexturePaintTool.js"],"names":[],"mappings":"AAkBA;IAEI,iBAAmB;IAWf;;;;OAIG;IACH,0BAA4C;IAIhD,8BA0BC;IAED;;;OAGG;IACH,kCAoBC;IAcD,6BAEC;IAoDD,qCAgEC;CAyBJ;iCAjPgC,uBAAuB"}

package/editor/tools/v2/BlenderCameraOrientationGizmo.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Modelled on https://github.com/jrj2211/three-orientation-gizmo/blob/master/src/OrientationGizmo.js
+ */
+export class BlenderCameraOrientationGizmo extends CanvasView {
+    /**
+     *
+     */
+    constructor(options?: {});
+    /**
+     *
+     * @type {Quaternion}
+     */
+    orientation: Quaternion;
+    /**
+     *
+     * @type {Vector3|null}
+     */
+    input_pointer_position: Vector3 | null;
+    selectedAxis: any;
+    options: {
+        size: number;
+        padding: number;
+        bubbleSizePrimary: number;
+        bubbleSizeSecondary: number;
+        showSecondary: boolean;
+        lineWidth: number;
+        fontSize: string;
+        fontFamily: string;
+        fontWeight: string;
+        fontColor: string;
+        fontYAdjust: number;
+        selectionFontColor: string;
+        invertOrientation: boolean;
+        axisStyles: {
+            px: DirectionStyle;
+            py: DirectionStyle;
+            pz: DirectionStyle;
+            nx: DirectionStyle;
+            ny: DirectionStyle;
+            nz: DirectionStyle;
+        };
+    };
+    bubbles: ({
+        axis: string;
+        direction: Vector3;
+        size: number;
+        style: DirectionStyle;
+        line: number;
+        label: string;
+        primary: boolean;
+        labelHideUnselected?: undefined;
+    } | {
+        axis: string;
+        direction: Vector3;
+        size: number;
+        style: DirectionStyle;
+        label: string;
+        labelHideUnselected: boolean;
+        primary: boolean;
+        line?: undefined;
+    })[];
+    center: Vector3;
+    /**
+     *
+     * @param {MouseEvent} evt
+     */
+    onMouseMove(evt: MouseEvent): void;
+    /**
+     *
+     * @param {MouseEvent} evt
+     */
+    onMouseOut(evt: MouseEvent): void;
+    /**
+     *
+     * @param {MouseEvent} evt
+     */
+    onMouseClick(evt: MouseEvent): void;
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    private __needs_update;
+    /**
+     *
+     * @param {MouseEvent} evt
+     * @private
+     */
+    private _setPointerPositionFromEvent;
+    drawCircle(p: any, radius?: number, fill_color?: string, stroke_width?: number, stroke_color?: string): void;
+    drawLine(p1: any, p2: any, width?: number, color?: string): void;
+    __try_update(): void;
+    update(): void;
+    /**
+     *
+     * @param {{style:DirectionStyle, position:Vector3, size:number,line:boolean, label?:string,labelHideUnselected?:boolean}[]} layers
+     */
+    drawLayers(layers: {
+        style: DirectionStyle;
+        position: Vector3;
+        size: number;
+        line: boolean;
+        label?: string;
+        labelHideUnselected?: boolean;
+    }[]): void;
+    /**
+     *
+     * @param {Vector3} position
+     * @returns {Vector3}
+     */
+    getBubblePosition(position: Vector3): Vector3;
+}
+import { CanvasView } from "../../../src/view/elements/CanvasView.js";
+import Quaternion from "../../../src/core/geom/Quaternion.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+declare class DirectionStyle {
+    static fromJSON(j: any): DirectionStyle;
+    near: {
+        fill: Color;
+        stroke_width: number;
+        stroke_color: Color;
+    };
+    far: {
+        fill: Color;
+        stroke_width: number;
+        stroke_color: Color;
+    };
+    fromJSON({ near_fill, near_stroke_width, near_stroke_color, far_fill, far_stroke_width, far_stroke_color }: {
+        near_fill?: string;
+        near_stroke_width?: number;
+        near_stroke_color?: string;
+        far_fill?: string;
+        far_stroke_width?: number;
+        far_stroke_color?: string;
+    }): void;
+}
+import { Color } from "../../../src/core/color/Color.js";
+export {};
+//# sourceMappingURL=BlenderCameraOrientationGizmo.d.ts.map

package/editor/tools/v2/BlenderCameraOrientationGizmo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlenderCameraOrientationGizmo.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/BlenderCameraOrientationGizmo.js"],"names":[],"mappings":"AAqFA;;GAEG;AACH;IAeI;;OAEG;IACH,0BA0IC;IA3JD;;;OAGG;IACH,aAFU,UAAU,CAED;IAEnB;;;OAGG;IACH,wBAFU,OAAO,GAAC,IAAI,CAEQ;IAE9B,kBAAoB;IAQhB;;;;;;;;;;;;;;;;;;;;;;MAoDC;IAMD;;;;;;;;;;;;;;;;;;SAuDC;IAED,gBAA0E;IA0C9E;;;OAGG;IACH,iBAFW,UAAU,QAKpB;IAwBD;;;OAGG;IACH,gBAFW,UAAU,QAMpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAoBpB;IA3FG;;;;OAIG;IACH,uBAA0B;IAgC9B;;;;OAIG;IACH,qCAeC;IAoCD,6GAeC;IAED,iEAUC;IAED,qBAKC;IAED,eA2EC;IAED;;;OAGG;IACH,mBAFW;QAAC,KAAK,EAAC,cAAc,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,OAAO,CAAC;QAAC,KAAK,CAAC,EAAC,MAAM,CAAC;QAAA,mBAAmB,CAAC,EAAC,OAAO,CAAA;KAAC,EAAE,QAwC1H;IAED;;;;OAIG;IACH,4BAHW,OAAO,GACL,OAAO,CAQnB;CACJ;2BAre0B,0CAA0C;uBAX9C,sCAAsC;oBAGzC,mCAAmC;AAcvD;IA8BI,wCAMC;IAnCD;;;;MAIE;IACF;;;;MAIE;IAEF;;;;;;;aAgBC;CASJ;sBA1DqB,kCAAkC"}

package/editor/tools/v2/GizmoNode.d.ts

@@ -0,0 +1,21 @@
+export class GizmoNode extends EntityNode {
+    constructor();
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    private _visible;
+    /**
+     *
+     * @type {EntityComponentDataset|null}
+     * @private
+     */
+    private __ecd;
+    build(ecd: any): void;
+    set visible(arg: boolean);
+    get visible(): boolean;
+    update(): void;
+}
+import { EntityNode } from "../../../src/engine/ecs/parent/EntityNode.js";
+//# sourceMappingURL=GizmoNode.d.ts.map

package/editor/tools/v2/GizmoNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GizmoNode.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/GizmoNode.js"],"names":[],"mappings":"AAGA;IAeI,cAIC;IAlBD;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,cAAa;IAQb,sBAMC;IAED,0BAgBC;IAED,uBAEC;IAED,eAgBC;CACJ;2BAvE0B,8CAA8C"}

package/editor/tools/v2/TransformControls.d.ts

@@ -0,0 +1,219 @@
+/**
+ * The transform gizmo.
+ *
+ * **What it controls is an entity, and what it needs from a renderer is one ray.** Both of those are
+ * why this can be renderer-neutral at all: `Transform` is world-space by contract, so there is no
+ * scene graph to walk, and `viewportProjectionRay` is on both graphics engines and answers in world
+ * space. Everything else — which handle the pointer is on, what surface a drag is measured on, where
+ * the handles are drawn — is arithmetic, and lives in `handle/`.
+ *
+ * The three version answered the first two questions by building meshes and raycasting them: an
+ * invisible cone per arm, an invisible 100000-unit `PlaneGeometry` per drag. That is why it needed
+ * a three camera object on the component. It needs none now:
+ * the ray through the middle of the viewport starts at the eye and points where the camera looks,
+ * and the ray through the top edge gives the field of view the gizmo is sized against.
+ *
+ * The **drag maths is the three version's**, ported to meep `Vector3`/`Quaternion` — this is the
+ * feel of a tool people have used, not something to redesign. Two things did change:
+ *
+ * - the parent transform is gone. It was set to the identity on every update and multiplied through
+ *   the whole of `pointerMove`, because `Transform` is world-space and there is no parent to
+ *   compose with.
+ * - a drag no longer starts when the drag plane is edge-on to the pointer. three started one anyway,
+ *   from whatever `pointStart` the previous drag left behind.
+ *
+ * The three gizmo's `showX`/`showY`/`showZ` are gone with the meshes they hid; nothing in the tree
+ * set them.
+ */
+export class TransformControls extends GizmoNode {
+    /**
+     * @param {GraphicsEngine|GraphicsEngine} graphics the only thing a renderer is asked for is
+     * {@link GraphicsEngine#viewportProjectionRay} and the `preRender` signal to draw on
+     * @param {HTMLElement} domElement
+     * @param {boolean} [autoUpdate] update on a frame loop of its own, rather than being driven
+     */
+    constructor(graphics: GraphicsEngine | GraphicsEngine, domElement: HTMLElement, autoUpdate?: boolean);
+    /**
+     * Entity ID that we are controlling. -1 indicates no entity
+     * @type {number}
+     */
+    object: number;
+    isTransformControls: boolean;
+    /**
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /**
+     * The handle under the pointer, or the one being dragged. One of the names in
+     * {@link gizmo_handles_of_mode}, or `null`.
+     *
+     * @type {string|null}
+     */
+    axis: string | null;
+    /**
+     * @type {string} one of {@link TransformMode}
+     */
+    mode: string;
+    /**
+     * @type {string} `'world'` or `'local'`
+     */
+    space: string;
+    /**
+     * How big the gizmo is drawn, as a multiple of its default screen size.
+     *
+     * @type {number}
+     */
+    size: number;
+    /**
+     * @type {boolean}
+     */
+    dragging: boolean;
+    /**
+     * World units per step, or `null` for none.
+     *
+     * @type {number|null}
+     */
+    translationSnap: number | null;
+    /**
+     * Radians per step, or `null` for none.
+     *
+     * @type {number|null}
+     */
+    rotationSnap: number | null;
+    /**
+     * @type {number|null}
+     */
+    scaleSnap: number | null;
+    /**
+     * @type {Vector3}
+     */
+    worldPosition: Vector3;
+    /**
+     * @type {Quaternion}
+     */
+    worldQuaternion: Quaternion;
+    /**
+     * Where the controlled entity was when the drag started. The tool reads these to build its undo
+     * state, because by the time it looks the entity has already moved.
+     *
+     * @type {Vector3}
+     */
+    worldPositionStart: Vector3;
+    /**
+     * @type {Quaternion}
+     */
+    worldQuaternionStart: Quaternion;
+    /**
+     * @type {Vector3}
+     */
+    _worldScaleStart: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    _worldScale: Vector3;
+    /**
+     * @type {Quaternion}
+     */
+    _worldQuaternionInv: Quaternion;
+    /**
+     * @type {Vector3}
+     */
+    _positionStart: Vector3;
+    /**
+     * @type {Quaternion}
+     */
+    _quaternionStart: Quaternion;
+    /**
+     * @type {Vector3}
+     */
+    _scaleStart: Vector3;
+    /**
+     * Where the pointer met the drag plane when the drag started, relative to the gizmo.
+     *
+     * @type {Vector3}
+     */
+    pointStart: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    pointEnd: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    _offset: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    _startNorm: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    _endNorm: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    rotationAxis: Vector3;
+    /**
+     * @type {number}
+     */
+    rotationAngle: number;
+    /**
+     * Where the camera is, and a unit vector from the gizmo towards it.
+     *
+     * @type {Vector3}
+     */
+    cameraPosition: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    eye: Vector3;
+    graphics: any;
+    domElement: HTMLElement;
+    _getPointer: any;
+    _onPointerDown: any;
+    _onPointerHover: any;
+    _onPointerMove: any;
+    _onPointerUp: any;
+    /**
+     * @param {EntityComponentDataset} ecd
+     */
+    build(ecd: EntityComponentDataset): void;
+    pointerHover(pointer: any): void;
+    pointerDown(pointer: any): void;
+    /**
+     *
+     * @param {{type:string}} event
+     */
+    dispatchEvent(event: {
+        type: string;
+    }): void;
+    pointerMove(pointer: any): void;
+    pointerUp(pointer: any): void;
+    dispose(): void;
+    /**
+     * Set current object
+     * @param {number} entity
+     * @returns {TransformControls}
+     */
+    attach(entity: number): TransformControls;
+    /**
+     *
+     * @returns {Transform|undefined}
+     */
+    get object_transform(): Transform;
+    detach(): this;
+    reset(): void;
+    getMode(): string;
+    setMode(mode: any): void;
+    setTranslationSnap(translationSnap: any): void;
+    setRotationSnap(rotationSnap: any): void;
+    setScaleSnap(scaleSnap: any): void;
+    setSize(size: any): void;
+    setSpace(space: any): void;
+    #private;
+}
+import { GizmoNode } from "./GizmoNode.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+import Quaternion from "../../../src/core/geom/Quaternion.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+//# sourceMappingURL=TransformControls.d.ts.map

package/editor/tools/v2/TransformControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformControls.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformControls.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAsNI;;;;;OAKG;IACH,sBALW,+BAA6B,cAE7B,WAAW,eACX,OAAO,EAgCjB;IAzPD;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ,6BAA2B;IAE3B;;OAEG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,MAFU,MAAM,GAAC,IAAI,CAET;IAEZ;;OAEG;IACH,MAFU,MAAM,CAEe;IAE/B;;OAEG;IACH,OAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,GAAC,IAAI,CAEE;IAEvB;;;;OAIG;IACH,cAFU,MAAM,GAAC,IAAI,CAED;IAEpB;;OAEG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;OAEG;IACH,eAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,iBAFU,UAAU,CAEe;IAEnC;;;;;OAKG;IACH,oBAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,sBAFU,UAAU,CAEoB;IAExC;;OAEG;IACH,kBAFU,OAAO,CAEuB;IAExC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,qBAFU,UAAU,CAEmB;IAEvC;;OAEG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,kBAFU,UAAU,CAEgB;IAEpC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,SAFU,OAAO,CAEO;IAExB;;OAEG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,cAFU,OAAO,CAEY;IAE7B;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,KAFU,OAAO,CAEU;IA+DvB,cAAwB;IACxB,wBAA4B;IAM5B,iBAAwC;IACxC,oBAA8C;IAC9C,qBAAgD;IAChD,oBAA8C;IAC9C,kBAA0C;IAe9C;;OAEG;IACH,yCAIC;IAmGD,iCAYC;IAED,gCAuCC;IAED;;;OAGG;IACH,qBAFW;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,QAIvB;IAED,gCAwOC;IAED,8BAcC;IAED,gBASC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,iBAAiB,CAW7B;IAED;;;OAGG;IACH,kCAIC;IAGD,eAYC;IAED,cAiBC;IAID,kBAIC;IAED,yBAIC;IAED,+CAIC;IAED,yCAIC;IAED,mCAIC;IAED,yBAIC;IAED,2BAIC;;CAEJ;0BAr3ByB,gBAAgB;oBAHtB,mCAAmC;uBADhC,sCAAsC;0BAEnC,gDAAgD"}

package/editor/tools/v2/TransformMode.d.ts

@@ -0,0 +1,7 @@
+export type TransformMode = string;
+export namespace TransformMode {
+    let Scale: string;
+    let Translate: string;
+    let Rotate: string;
+}
+//# sourceMappingURL=TransformMode.d.ts.map

package/editor/tools/v2/TransformMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformMode.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformMode.js"],"names":[],"mappings":"4BACU,MAAM"}