@woosh/meep-engine 3.14.5 → 3.14.6

package/README.md

@@ -8,6 +8,12 @@
 npm install @woosh/meep-engine
 ```
 
+**Start here:** [`samples/engine/README.md`](samples/engine/README.md) — the first thirty minutes,
+with the Vite stanza you need, why your scene should be authored in metres, photometric reference
+values, and how input reaches the engine. The worked example beside it,
+[`samples/engine/first-scene`](samples/engine/first-scene), boots the engine, lights a scene and
+reads the keyboard in about eighty lines.
+
 **Proprietary and source-available.** You get all ~6,200 fine-grained ES modules, unobfuscated,
 under a licence that lets you ship. Need a lerp function? Import the module that holds it and pay
 for those four lines.

package/editor/Editor.d.ts

@@ -0,0 +1,162 @@
+export class Editor {
+    /**
+     * @type {ProcessEngine}
+     */
+    processEngine: ProcessEngine;
+    /**
+     * @type {ToolEngine}
+     */
+    toolEngine: ToolEngine;
+    /**
+     * currently selected entity ids
+     * @type {List<number>}
+     */
+    selection: List<number>;
+    /**
+     * @type {ActionProcessor<Editor, string>}
+     */
+    actions: ActionProcessor<Editor, string>;
+    /**
+     * @type {SelectionVisualizer}
+     */
+    selectionVisualizer: SelectionVisualizer;
+    /**
+     * @type {MeshLibrary}
+     */
+    meshLibrary: MeshLibrary;
+    /**
+     * @type {Map<any, TypeEditor>}
+     */
+    type_editor_registry: Map<any, TypeEditor>;
+    /**
+     * dedicated editor camera (Camera + TopDownCameraController + Transform + EditorEntity)
+     * @type {Entity}
+     */
+    cameraEntity: Entity;
+    /**
+     * @type {EditorEntitySystem}
+     */
+    editorEntitySystem: EditorEntitySystem;
+    /**
+     * @type {EditorCameraNavigation}
+     */
+    cameraNavigation: EditorCameraNavigation;
+    /**
+     * @type {EditorKeyMap}
+     */
+    keyMap: EditorKeyMap;
+    /**
+     * @type {EditorShellView|null}
+     */
+    view: EditorShellView | null;
+    /**
+     * cloned component arrays captured by copy, consumed by paste
+     * @type {Array[]}
+     */
+    copyBuffer: any[][];
+    /**
+     * @type {Engine|null}
+     */
+    engine: Engine | null;
+    /**
+     * @type {{name:string, originalState:boolean, system:System}[]}
+     */
+    disabledSystems: {
+        name: string;
+        originalState: boolean;
+        system: System;
+    }[];
+    /**
+     * @type {string}
+     */
+    lastTool: string;
+    /**
+     * restoration steps recorded during attach, executed on detach
+     * @type {function[]}
+     */
+    cleanupTasks: Function[];
+    /**
+     * @returns {boolean}
+     */
+    get isAttached(): boolean;
+    /**
+     * Named scene slots over the engine's storage backend
+     * @returns {SceneSlotManager}
+     */
+    get sceneSlots(): SceneSlotManager;
+    initialize(): void;
+    /**
+     * Frame the entity: the orbit pivot moves to the middle of what the editor draws for it
+     * and the orbit distance is set so that fits the camera's field of view. The per-tick
+     * camera update applies both.
+     *
+     * An entity with no spatial presence is not framed — there is nothing to look at, and
+     * throwing the camera at the world origin would lose the author's place.
+     *
+     * @param {number} entity
+     */
+    focusEntity(entity: number): void;
+    /**
+     * Focus the camera on the most recently selected entity
+     */
+    focusSelection(): void;
+    /**
+     * Serialize the current scene (minus editor entities, with cameras re-activated) and
+     * download it as a level file.
+     */
+    saveScene(): void;
+    /**
+     * Open a serialized scene, replacing the current one.
+     *
+     * @param {ArrayBuffer} arrayBuffer
+     * @returns {Promise}
+     */
+    openSceneFromBuffer(arrayBuffer: ArrayBuffer): Promise<any>;
+    /**
+     * Start a fresh scene: camera, sun, ambient light.
+     *
+     * @returns {Promise}
+     */
+    newScene(): Promise<any>;
+    /**
+     * Merge a serialized scene into the current one as one undoable group; entity ids
+     * are remapped onto fresh ids.
+     *
+     * @param {ArrayBuffer} arrayBuffer
+     * @returns {Promise<number[]>} created entities
+     */
+    mergeSceneFromBuffer(arrayBuffer: ArrayBuffer): Promise<number[]>;
+    /**
+     *
+     * @param {Engine} engine
+     */
+    attach(engine: Engine): Promise<void>;
+    /**
+     *
+     * @param {Class} systemClass
+     */
+    disableSystem(systemClass: Class): void;
+    restoreDisableSystem(): void;
+    detach(): void;
+    /**
+     *
+     * @param {number} entity
+     * @returns {boolean}
+     */
+    isEditorEntity(entity: number): boolean;
+    #private;
+}
+export default Editor;
+import { ProcessEngine } from "./process/ProcessEngine.js";
+import ToolEngine from './tools/engine/ToolEngine.js';
+import List from '../src/core/collection/list/List.js';
+import { ActionProcessor } from '../src/core/process/undo/ActionProcessor.js';
+import { SelectionVisualizer } from "./SelectionVisualizer.js";
+import { MeshLibrary } from "./library/MeshLibrary.js";
+import Entity from "../src/engine/ecs/Entity.js";
+import EditorEntitySystem from "./ecs/EditorEntitySystem.js";
+import { EditorCameraNavigation } from "./EditorCameraNavigation.js";
+import { EditorKeyMap } from "./EditorKeyMap.js";
+import { EditorShellView } from "./view/shell/EditorShellView.js";
+import { SceneSlotManager } from "./persistence/SceneSlotManager.js";
+//# sourceMappingURL=Editor.d.ts.map

package/editor/Editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["../../editor/Editor.js"],"names":[],"mappings":"AAyIA;IACI;;OAEG;IACH,eAFU,aAAa,CAEa;IAEpC;;OAEG;IACH,YAFU,UAAU,CAEU;IAE9B;;;OAGG;IACH,WAFU,KAAK,MAAM,CAAC,CAEC;IAEvB;;OAEG;IACH,SAFU,gBAAgB,MAAM,EAAE,MAAM,CAAC,CAEL;IAEpC;;OAEG;IACH,qBAFU,mBAAmB,CAEuB;IAEpD;;OAEG;IACH,aAFU,WAAW,CAEW;IAEhC;;OAEG;IACH,sBAFU,IAAI,GAAG,aAAa,CAEG;IAEjC;;;OAGG;IACH,cAFU,MAAM,CAEmB;IAEnC;;OAEG;IACH,oBAFU,kBAAkB,CAEkB;IAE9C;;OAEG;IACH,kBAFU,sBAAsB,CAEgB;IAEhD;;OAEG;IACH,QAFU,YAAY,CAEU;IAEhC;;OAEG;IACH,MAFU,eAAe,GAAC,IAAI,CAElB;IAEZ;;;OAGG;IACH,YAFU,OAAO,CAED;IAEhB;;OAEG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;OAEG;IACH,iBAFU;QAAC,MAAK,MAAM,CAAC;QAAC,aAAa,EAAC,OAAO,CAAC;QAAC,MAAM,SAAO;KAAC,EAAE,CAE1C;IAErB;;OAEG;IACH,UAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,cAFU,UAAU,CAEF;IAiBlB;;OAEG;IACH,0BAEC;IAED;;;OAGG;IACH,mCAMC;IAED,mBA0CC;IAED;;;;;;;;;OASG;IACH,oBAFW,MAAM,QA4BhB;IAED;;OAEG;IACH,uBAQC;IAED;;;OAGG;IACH,kBAIC;IA6BD;;;;;OAKG;IACH,iCAHW,WAAW,gBAYrB;IAED;;;;OAIG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,kCAHW,WAAW,GACT,QAAQ,MAAM,EAAE,CAAC,CAI7B;IAED;;;OAGG;IACH,sCAgEC;IAED;;;OAGG;IACH,wCAmBC;IAED,6BAMC;IAED,eA2CC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,OAAO,CAInB;;CACJ;;8BA3iB6B,4BAA4B;uBAInC,8BAA8B;iBAjCpC,qCAAqC;gCAGtB,6CAA6C;oCA6BzC,0BAA0B;4BAXlC,0BAA0B;mBAjBnC,6BAA6B;+BAajB,6BAA6B;uCACrB,6BAA6B;6BACvC,mBAAmB;gCAehB,iCAAiC;iCAThC,mCAAmC"}

package/editor/EditorCameraNavigation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Always-on viewport camera navigation for the editor: right-drag orbits, middle-drag pans,
+ * wheel zooms. Editing tools keep the primary button to themselves.
+ *
+ * The editor camera is driven here, per engine tick, straight from its controller state —
+ * the TopDownCameraControllerSystem stays disabled while editing so controller-bearing
+ * game entities are left alone.
+ */
+export class EditorCameraNavigation {
+    /**
+     *
+     * @param {Engine} engine
+     * @param {TopDownCameraController} controller the editor camera's controller
+     * @param {Transform} camera_transform the editor camera's transform
+     * @param {Camera} camera the editor camera, read for its field of view
+     */
+    attach(engine: Engine, controller: TopDownCameraController, camera_transform: Transform, camera: Camera): void;
+    detach(): void;
+    #private;
+}
+import TopDownCameraController from "../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+//# sourceMappingURL=EditorCameraNavigation.d.ts.map

package/editor/EditorCameraNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorCameraNavigation.d.ts","sourceRoot":"","sources":["../../editor/EditorCameraNavigation.js"],"names":[],"mappings":"AAuCA;;;;;;;GAOG;AACH;IA2CI;;;;;;OAMG;IACH,mCAJW,uBAAuB,qDAqCjC;IAED,eAmBC;;CAqDJ;oCAxMmC,sEAAsE"}

package/editor/EditorKeyMap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The editor's keyboard bindings.
+ *
+ * | Keys            | Action                                  |
+ * |-----------------|-----------------------------------------|
+ * | Ctrl+Z / Ctrl+Y | undo / redo                             |
+ * | Ctrl+C / Ctrl+V | copy / paste selected entities          |
+ * | Ctrl+S          | save scene                              |
+ * | X, Delete       | delete selected entities                |
+ * | Shift+D         | duplicate selected entities             |
+ * | 1               | marquee selection tool                  |
+ * | 2               | transform tool                          |
+ * | W / E / R       | transform tool: translate/rotate/scale  |
+ * | F               | frame selection                         |
+ *
+ * Unhandled keys are forwarded to the active tool (Q space toggle, [ ] brush size, …).
+ */
+export class EditorKeyMap {
+    /**
+     *
+     * @param {Editor} editor
+     */
+    constructor(editor: Editor);
+    attach(): void;
+    detach(): void;
+    #private;
+}
+//# sourceMappingURL=EditorKeyMap.d.ts.map

package/editor/EditorKeyMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorKeyMap.d.ts","sourceRoot":"","sources":["../../editor/EditorKeyMap.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;GAgBG;AACH;IAWI;;;OAGG;IACH,4BAGC;IAED,eAEC;IAED,eAEC;;CA0GJ"}

package/editor/SelectionVisualizer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Draws a box around every selected entity.
+ *
+ * **It holds nothing per selection, and that is the whole of the rewrite.** The three version built
+ * a `BoxHelper` per selected entity, kept it in a `Map`, subscribed to the entity's mesh events to
+ * re-fit it and added it to `graphics.scene` — a lifetime to get right for something that is only
+ * ever a picture of the current selection. On an immediate-mode surface there is nothing to get
+ * right: each frame asks where the selection is and records a box, and a selection whose entity has
+ * gone answers nothing and draws nothing. That is also why an entity removed under a live selection
+ * cannot leave a box behind — there is no box to leave.
+ *
+ * **What draws it is whichever backend the engine has registered** — `DebugDrawSystem` under
+ * Shade, `GizmoRenderingPlugin` under three — because {@link Gizmo} is renderer-neutral by
+ * construction (V3). The one thing this does have to resolve per renderer is where an entity's
+ * bounds live; see {@link entity_world_bounds_reader}.
+ *
+ * **A box is drawn on the entity's bounds, so it is occluded by what stands in front of it** the
+ * same way the debug-draw pass's other shapes are. It survives an occluder wherever the bounds
+ * exceed what covers them, which is more than the highlight outline can do — that one can only mark
+ * pixels the entity itself wrote (D27), so an entity that is hidden has no outline at all. Whether
+ * a selection should instead sit on top of everything is the same question the gizmo handles ask,
+ * and V6 answers it for both.
+ */
+export class SelectionVisualizer {
+    /**
+     * @param {Editor} editor
+     */
+    constructor(editor: Editor);
+    /**
+     * @type {Editor}
+     */
+    editor: Editor;
+    startup(): void;
+    shutdown(): void;
+    #private;
+}
+//# sourceMappingURL=SelectionVisualizer.d.ts.map

package/editor/SelectionVisualizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionVisualizer.d.ts","sourceRoot":"","sources":["../../editor/SelectionVisualizer.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAmBI;;OAEG;IACH,4BAMC;IA3BD;;OAEG;IACH,eAAO;IAuDP,gBAQC;IAED,iBAMC;;CACJ"}

package/editor/actions/concrete/ActionInvalidateSampler.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Says that the pixels of a sampler changed without its dimensions changing, so whoever holds a copy
+ * of them — a renderer's uploaded texture — has to take them again.
+ *
+ * Both directions invalidate, because an undo moves the pixels just as an apply does.
+ */
+export class ActionInvalidateSampler extends Action<any> {
+    /**
+     *
+     * @param {Sampler2DArray} sampler
+     */
+    constructor(sampler: Sampler2DArray);
+    __sampler: Sampler2DArray;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ActionInvalidateSampler.d.ts.map

package/editor/actions/concrete/ActionInvalidateSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionInvalidateSampler.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ActionInvalidateSampler.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IACI;;;OAGG;IACH,qCAIC;IADG,0BAAwB;IAG5B,mCAEC;IAED,oCAEC;CACJ;uBA1BsB,0CAA0C"}

package/editor/actions/concrete/ActionUpdateTexture.d.ts

@@ -0,0 +1,12 @@
+export class ActionUpdateTexture extends Action<any> {
+    /**
+     *
+     * @param {*} texture
+     */
+    constructor(texture: any);
+    __texture: any;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ActionUpdateTexture.d.ts.map

package/editor/actions/concrete/ActionUpdateTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionUpdateTexture.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ActionUpdateTexture.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,0BAIC;IADG,eAAwB;IAG5B,mCAEC;IAED,oCAEC;CACJ;uBApBsB,0CAA0C"}

package/editor/actions/concrete/ActionUpdateTexture.js

@@ -3,7 +3,7 @@ import { Action } from "../../../src/core/process/undo/Action.js";
 export class ActionUpdateTexture extends Action {
     /**
      *
-     * @param {THREE.Texture} texture
+     * @param {*} texture
      */
     constructor(texture) {
         super();

package/editor/actions/concrete/ArrayCopyAction.d.ts

@@ -0,0 +1,20 @@
+export class ArrayCopyAction extends Action<any> {
+    /**
+     * @template T
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} source
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} destination
+     */
+    constructor(source: Uint8Array | Float32Array | ArrayLike<T> | T[], destination: Uint8Array | Float32Array | ArrayLike<T> | T[]);
+    /**
+     *
+     * @type {ArrayLike<T>|null}
+     * @private
+     */
+    private __restore_value;
+    __source: Uint8Array | Float32Array | ArrayLike<T> | T[];
+    __destination: Uint8Array | Float32Array | ArrayLike<T> | T[];
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ArrayCopyAction.d.ts.map

package/editor/actions/concrete/ArrayCopyAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayCopyAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ArrayCopyAction.js"],"names":[],"mappings":"AAGA;IAQI;;;;OAIG;IACH,iIAKC;IAjBD;;;;OAIG;IACH,wBAAuB;IAUnB,yDAAsB;IACtB,8DAAgC;IAGpC,mCAUC;IAED,oCAEC;CACJ;uBAtCsB,0CAA0C"}

package/editor/actions/concrete/ComponentAddAction.d.ts

@@ -0,0 +1,15 @@
+export default ComponentAddAction;
+declare class ComponentAddAction extends Action<any> {
+    constructor(entity: any, component: any);
+    /**
+     *
+     * @type {EntityComponentDataset}
+     */
+    dataset: EntityComponentDataset;
+    entity: any;
+    component: any;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ComponentAddAction.d.ts.map

package/editor/actions/concrete/ComponentAddAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentAddAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ComponentAddAction.js"],"names":[],"mappings":";AAEA;IAOI,yCAIC;IAVD;;;OAGG;IACH,gCAAe;IAIX,YAAoB;IACpB,eAA0B;IAG9B,kCAqBC;IAED,mCAGC;CACJ;uBA1CsB,0CAA0C"}

package/editor/actions/concrete/ComponentRemoveAction.d.ts

@@ -0,0 +1,11 @@
+export default ComponentRemoveAction;
+declare class ComponentRemoveAction extends Action<any> {
+    constructor(entity: any, componentType: any);
+    component: any;
+    entity: any;
+    componentType: any;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ComponentRemoveAction.d.ts.map

package/editor/actions/concrete/ComponentRemoveAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentRemoveAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ComponentRemoveAction.js"],"names":[],"mappings":";AAEA;IAGI,6CAKC;IAPD,eAAiB;IAKb,YAAoB;IACpB,mBAAkC;IAGtC,kCAUC;IAED,mCAIC;CACJ;uBA7BsB,0CAA0C"}

package/editor/actions/concrete/EntityCreateAction.d.ts

@@ -0,0 +1,18 @@
+export default EntityCreateAction;
+declare class EntityCreateAction extends Action<any> {
+    constructor();
+    /**
+     *
+     * @type {number|null}
+     */
+    entity: number | null;
+    /**
+     *
+     * @type {EntityComponentDataset}
+     */
+    ecd: EntityComponentDataset;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=EntityCreateAction.d.ts.map

package/editor/actions/concrete/EntityCreateAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityCreateAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/EntityCreateAction.js"],"names":[],"mappings":";AAEA;;IACI;;;OAGG;IACH,QAFU,MAAM,GAAC,IAAI,CAEP;IAEd;;;OAGG;IACH,4BAAW;IAEX,kCAkBC;IAED,mCAEC;CACJ;uBAtCsB,0CAA0C"}

package/editor/actions/concrete/EntityRemoveAction.d.ts

@@ -0,0 +1,11 @@
+export default EntityRemoveAction;
+/**
+ * @extends {Action<Editor>}
+ */
+declare class EntityRemoveAction extends Action<Editor> {
+    constructor(entity: any);
+    components: any[];
+    entity: any;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=EntityRemoveAction.d.ts.map

package/editor/actions/concrete/EntityRemoveAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityRemoveAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/EntityRemoveAction.js"],"names":[],"mappings":";AAEA;;GAEG;AACH;IAGI,yBAGC;IALD,kBAAgB;IAIZ,YAAoB;CAmC3B;uBA7CsB,0CAA0C"}

package/editor/actions/concrete/ModifyPatchSampler2DAction.d.ts

@@ -0,0 +1,47 @@
+export class ModifyPatchSampler2DAction extends Action<any> {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number[]} bounds
+     */
+    constructor(sampler: Sampler2D, bounds: number[]);
+    /**
+     *
+     * @type {Sampler2D}
+     * @private
+     */
+    private __sampler;
+    /**
+     *
+     * @type {number[]}
+     * @private
+     */
+    private __bounds;
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    __patch_new: Sampler2D;
+    /**
+     *
+     * @type {Sampler2D}
+     * @private
+     */
+    private __patch_old;
+    get patch(): Sampler2D;
+    get x(): number;
+    get y(): number;
+    /**
+     *
+     * @param {number} x coordinate in global space
+     * @param {number} y coordinate in global space
+     * @param {number} [channel]
+     * @returns {number} delta between original value and the new one after the change
+     */
+    computeDelta(x: number, y: number, channel?: number): number;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+//# sourceMappingURL=ModifyPatchSampler2DAction.d.ts.map

package/editor/actions/concrete/ModifyPatchSampler2DAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModifyPatchSampler2DAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ModifyPatchSampler2DAction.js"],"names":[],"mappings":"AAMA;IACI;;;;OAIG;IACH,qBAHW,SAAS,UACT,MAAM,EAAE,EAkClB;IA7BG;;;;OAIG;IACH,kBAAwB;IAExB;;;;OAIG;IACH,iBAAsB;IAKtB;;;OAGG;IACH,aAFU,SAAS,CAEkD;IAErE;;;;OAIG;IACH,oBAAqE;IAGzE,uBAEC;IAED,gBAEC;IAED,gBAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,MAAM,CAmBlB;IAOD,mCAiBC;IAED,oCAWC;CACJ;uBAxHsB,0CAA0C;0BACvC,2DAA2D"}

package/editor/actions/concrete/ModifyPatchTextureArray2DAction.d.ts

@@ -0,0 +1,38 @@
+export class ModifyPatchTextureArray2DAction extends Action<any> {
+    /**
+     *
+     * @param {number[]|Uint8Array|Uint32Array|Float32Array} data
+     * @param {number[]} data_resolution
+     * @param {number[]} bounds
+     */
+    constructor(data: number[] | Uint8Array | Uint32Array | Float32Array, data_resolution: number[], bounds: number[]);
+    __data: Uint8Array | Float32Array | Uint32Array | number[];
+    __data_resolution: number[];
+    __bounds: number[];
+    /**
+     * @type {ArrayLike<number>}
+     * @private
+     */
+    private __patch_new;
+    /**
+     * @type {ArrayLike<number>}
+     * @private
+     */
+    private __patch_old;
+    /**
+     *
+     * @param {number} center_x
+     * @param {number} center_y
+     * @param {Sampler2D} stamp
+     * @param {number} layer_index
+     * @param {number} weight
+     * @param {number} clamp_min
+     * @param {number} clamp_max
+     */
+    applyWeightStampToLayer(center_x: number, center_y: number, stamp: Sampler2D, layer_index: number, weight: number, clamp_min?: number, clamp_max?: number): void;
+    get patch_data(): ArrayLike<number>;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ModifyPatchTextureArray2DAction.d.ts.map

package/editor/actions/concrete/ModifyPatchTextureArray2DAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModifyPatchTextureArray2DAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/ModifyPatchTextureArray2DAction.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,kBAJW,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,YAAY,mBAC5C,MAAM,EAAE,UACR,MAAM,EAAE,EA6BlB;IAtBG,2DAAkB;IAClB,4BAAwC;IACxC,mBAAsB;IAUtB;;;OAGG;IACH,oBAAmD;IACnD;;;OAGG;IACH,oBAAmD;IAGvD;;;;;;;;;OASG;IACH,kCARW,MAAM,YACN,MAAM,iCAEN,MAAM,UACN,MAAM,cACN,MAAM,cACN,MAAM,QAmEhB;IAED,oCAEC;IAOD,mCA8BC;IAED,oCAuBC;CACJ;uBAvLsB,0CAA0C"}

package/editor/actions/concrete/PaintTerrainOverlayAction.d.ts

@@ -0,0 +1,23 @@
+export default PaintTerrainOverlayAction;
+declare class PaintTerrainOverlayAction extends Action<any> {
+    /**
+     *
+     * @param {number} entity
+     * @param {number} x
+     * @param {number} y
+     * @param {Vector4} color
+     * @constructor
+     */
+    constructor(entity: number, x: number, y: number, color: Vector4);
+    overlay: any;
+    oldColor: Vector4;
+    entity: number;
+    x: number;
+    y: number;
+    color: Vector4;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+import Vector4 from "../../../src/core/geom/Vector4.js";
+//# sourceMappingURL=PaintTerrainOverlayAction.d.ts.map

package/editor/actions/concrete/PaintTerrainOverlayAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PaintTerrainOverlayAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/PaintTerrainOverlayAction.js"],"names":[],"mappings":";AAIA;IAII;;;;;;;OAOG;IACH,oBANW,MAAM,KACN,MAAM,KACN,MAAM,SACN,OAAO,EASjB;IAjBD,aAAe;IACf,kBAAyB;IAYrB,eAAoB;IACpB,UAAU;IACV,UAAU;IACV,eAAkB;IAGtB,kCASC;IAED,mCAKC;CACJ;uBAxCsB,0CAA0C;oBAD7C,mCAAmC"}

package/editor/actions/concrete/PatchTerrainHeightAction.d.ts

@@ -0,0 +1,32 @@
+/**
+ * UV rectangle covered by a texel-space patch of a sampler. Standalone so the
+ * region math is testable without live terrain tile machinery.
+ *
+ * @param {number[]} result [u0, v0, u1, v1]
+ * @param {number} x patch origin in texels
+ * @param {number} y
+ * @param {number} patch_width in texels
+ * @param {number} patch_height
+ * @param {number} map_width sampler dimensions in texels
+ * @param {number} map_height
+ */
+export function compute_patch_uv_rect(result: number[], x: number, y: number, patch_width: number, patch_height: number, map_width: number, map_height: number): void;
+export class PatchTerrainHeightAction extends ModifyPatchSampler2DAction {
+    /**
+     *
+     * @param {Terrain} terrain
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(terrain: Terrain, x: number, y: number, width: number, height: number);
+    /**
+     *
+     * @type {Terrain}
+     */
+    terrain: Terrain;
+    updateTerrain(): Promise<void>;
+}
+import { ModifyPatchSampler2DAction } from "./ModifyPatchSampler2DAction.js";
+//# sourceMappingURL=PatchTerrainHeightAction.d.ts.map

package/editor/actions/concrete/PatchTerrainHeightAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatchTerrainHeightAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/PatchTerrainHeightAction.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,8CARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,eACN,MAAM,gBACN,MAAM,aACN,MAAM,cACN,MAAM,QAOhB;AAID;IACI;;;;;;;OAOG;IACH,iCALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,EAUhB;IALG;;;OAGG;IACH,iBAAsB;IAG1B,+BA6BC;CAaJ;2CApF0C,iCAAiC"}

package/editor/actions/concrete/SelectionAddAction.d.ts

@@ -0,0 +1,19 @@
+export default SelectionAddAction;
+declare class SelectionAddAction extends Action<any> {
+    /**
+     *
+     * @param {int[]} entities
+     * @constructor
+     */
+    constructor(entities: int[]);
+    oldState: any;
+    /**
+     *
+     * @type {int[]}
+     */
+    entities: int[];
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=SelectionAddAction.d.ts.map

package/editor/actions/concrete/SelectionAddAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionAddAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/SelectionAddAction.js"],"names":[],"mappings":";AAGA;IAGI;;;;OAIG;IACH,sBAHW,KAAK,EAUf;IAdD,cAAgB;IASZ;;;OAGG;IACH,UAFU,KAAK,CAES;IAG5B,kCAMC;IAED,mCAEC;CACJ;uBA/BsB,0CAA0C"}

package/editor/actions/concrete/SelectionClearAction.d.ts

@@ -0,0 +1,9 @@
+export default SelectionClearAction;
+declare class SelectionClearAction extends Action<any> {
+    constructor();
+    oldState: any;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=SelectionClearAction.d.ts.map

package/editor/actions/concrete/SelectionClearAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionClearAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/SelectionClearAction.js"],"names":[],"mappings":";AAEA;;IACI,cAAgB;IAEhB,kCAGC;IAED,mCAEC;CACJ;uBAbsB,0CAA0C"}

package/editor/actions/concrete/SelectionRemoveAction.d.ts

@@ -0,0 +1,10 @@
+export default SelectionRemoveAction;
+declare class SelectionRemoveAction extends Action<any> {
+    constructor(entities: any);
+    oldState: any;
+    entities: any;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=SelectionRemoveAction.d.ts.map

package/editor/actions/concrete/SelectionRemoveAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionRemoveAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/SelectionRemoveAction.js"],"names":[],"mappings":";AAEA;IAGI,2BAGC;IALD,cAAgB;IAIZ,cAAwB;IAG5B,kCAUC;IAED,mCAEC;CACJ;uBAzBsB,0CAA0C"}