@woosh/meep-engine 3.14.5 → 3.14.6

package/editor/ecs/component/registerBasicTypeEditors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Registers the type editors every other registration is layered over: the language's own types,
+ * the observed-value wrappers, and the math and sampler types components are built out of.
+ *
+ * Separate from the {@link Editor} that calls it so that a registry can be built — and asserted
+ * against — without one.
+ *
+ * @param {Map<any, TypeEditor>} registry
+ */
+export function registerBasicTypeEditors(registry: Map<any, TypeEditor>): void;
+//# sourceMappingURL=registerBasicTypeEditors.d.ts.map

package/editor/ecs/component/registerBasicTypeEditors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerBasicTypeEditors.d.ts","sourceRoot":"","sources":["../../../../editor/ecs/component/registerBasicTypeEditors.js"],"names":[],"mappings":"AAyCA;;;;;;;;GAQG;AACH,mDAFW,IAAI,GAAG,aAAa,QAmD9B"}

package/editor/ecs/component/registerEngineComponentEditors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Registers the type editors for engine-side component classes and their nested value
+ * types. Hosts layer editors for their own component classes on top.
+ *
+ * @param {Map<any, TypeEditor>} registry
+ */
+export function registerEngineComponentEditors(registry: Map<any, TypeEditor>): void;
+//# sourceMappingURL=registerEngineComponentEditors.d.ts.map

package/editor/ecs/component/registerEngineComponentEditors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerEngineComponentEditors.d.ts","sourceRoot":"","sources":["../../../../editor/ecs/component/registerEngineComponentEditors.js"],"names":[],"mappings":"AAqDA;;;;;GAKG;AACH,yDAFW,IAAI,GAAG,aAAa,QAqC9B"}

package/editor/enableEditor.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {Engine} engine
+ * @param {function(Editor):*} [initialization]
+ * @returns {{enable:function, disable: function, toggle: function, editor: Editor}}
+ */
+export function enableEditor(engine: Engine, initialization?: (arg0: Editor) => any): {
+    enable: Function;
+    disable: Function;
+    toggle: Function;
+    editor: Editor;
+};
+import Editor from "./Editor.js";
+//# sourceMappingURL=enableEditor.d.ts.map

package/editor/enableEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableEditor.d.ts","sourceRoot":"","sources":["../../editor/enableEditor.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qEAHoB,MAAM;;;;YACkD,MAAM;EAgFjF;mBAtFkB,aAAa"}

package/editor/entity_world_bounds.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where an entity's model is, in world space.
+ *
+ * The renderer refreshes a world box per scene node as part of placing it, so the answer is the
+ * renderer's rather than the component's — which is why this is a reader built from an engine rather
+ * than a function over a component.
+ *
+ * **Precondition:** the engine has a {@link MeshSystem}. It is what puts anything on a screen at
+ * all, so an editor running without one has nothing to select.
+ *
+ * @param {Engine} engine
+ * @returns {function(ArrayLike<number>, number): boolean} writes an aabb3 in the order
+ * `x0,y0,z0,x1,y1,z1` and answers whether the entity had one — an entity with no model, or one
+ * whose model has not loaded, has no bounds and that is not an error
+ */
+export function entity_world_bounds_reader(engine: Engine): (arg0: ArrayLike<number>, arg1: number) => boolean;
+//# sourceMappingURL=entity_world_bounds.d.ts.map

package/editor/entity_world_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity_world_bounds.d.ts","sourceRoot":"","sources":["../../editor/entity_world_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,mEAJsB,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,CAYxD"}

package/editor/library/MeshLibrary.d.ts

@@ -0,0 +1,13 @@
+export class MeshLibrary {
+    /**
+     * @type {List.<string>}
+     */
+    assets: List<string>;
+    /**
+     *
+     * @param {string} url
+     */
+    add(url: string): void;
+}
+import List from "../../src/core/collection/list/List.js";
+//# sourceMappingURL=MeshLibrary.d.ts.map

package/editor/library/MeshLibrary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshLibrary.d.ts","sourceRoot":"","sources":["../../../editor/library/MeshLibrary.js"],"names":[],"mappings":"AAGA;IAEI;;OAEG;IACH,QAFU,KAAM,MAAM,CAAC,CAEH;IAEpB;;;OAGG;IACH,SAFW,MAAM,QAahB;CACJ;iBA1BgB,wCAAwC"}

package/editor/particles/lut_ops.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Number of keys in the table
+ * @param {ParameterLookupTable} lut
+ * @returns {number}
+ */
+export function lut_key_count(lut: ParameterLookupTable): number;
+/**
+ * Insert a key; its value is the table's current sample at that position unless given.
+ *
+ * @param {ParameterLookupTable} lut
+ * @param {number} position 0..1
+ * @param {number[]} [values] itemSize-long
+ * @returns {number} index of the inserted key after sorting
+ */
+export function lut_add_key(lut: ParameterLookupTable, position: number, values?: number[]): number;
+/**
+ * Move a key and/or replace its value.
+ *
+ * @param {ParameterLookupTable} lut
+ * @param {number} index
+ * @param {number} position 0..1
+ * @param {number[]} [values] itemSize-long; keeps the current value when omitted
+ * @returns {number} the key's index after re-sorting
+ */
+export function lut_set_key(lut: ParameterLookupTable, index: number, position: number, values?: number[]): number;
+/**
+ * Remove a key. A table must keep at least one key to stay sampleable.
+ *
+ * @param {ParameterLookupTable} lut
+ * @param {number} index
+ * @returns {boolean} false when the removal would empty the table
+ */
+export function lut_remove_key(lut: ParameterLookupTable, index: number): boolean;
+//# sourceMappingURL=lut_ops.d.ts.map

package/editor/particles/lut_ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lut_ops.d.ts","sourceRoot":"","sources":["../../../editor/particles/lut_ops.js"],"names":[],"mappings":"AA2DA;;;;GAIG;AACH,0DAFa,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,iEAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,CAqBlB;AAED;;;;;;;;GAQG;AACH,8DALW,MAAM,YACN,MAAM,WACN,MAAM,EAAE,GACN,MAAM,CAmBlB;AAED;;;;;;GAMG;AACH,iEAHW,MAAM,GACJ,OAAO,CAiBnB"}

package/editor/particles/particleEditEvents.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fired by the particle parameter editors after mutating a {@link ParameterLookupTable};
+ * carries the table. The rebuild process maps the table back to its owning emitter and
+ * schedules a rebuild, so live emitters reflect curve/gradient edits.
+ *
+ * Module-static: lookup tables are plain data and carry no signals of their own.
+ *
+ * @type {Signal<ParameterLookupTable>}
+ */
+export const onParameterLutEdited: any;
+//# sourceMappingURL=particleEditEvents.d.ts.map

package/editor/particles/particleEditEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleEditEvents.d.ts","sourceRoot":"","sources":["../../../editor/particles/particleEditEvents.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,uCAAiD"}

package/editor/particles/rebuildParticleEmitter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rebuild a live particle emitter after structural edits (layers, sprites, parameter
+ * tracks): the system pulls it out of the particle engine, runs the full build sequence and puts
+ * it back. Sleep state is preserved.
+ *
+ * @param {EntityManager} entityManager
+ * @param {number} entity
+ * @returns {boolean} false when the entity has no emitter or no emitter system runs
+ */
+export function rebuildParticleEmitter(entityManager: EntityManager, entity: number): boolean;
+//# sourceMappingURL=rebuildParticleEmitter.d.ts.map

package/editor/particles/rebuildParticleEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildParticleEmitter.d.ts","sourceRoot":"","sources":["../../../editor/particles/rebuildParticleEmitter.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,6EAHW,MAAM,GACJ,OAAO,CAkBnB"}

package/editor/persistence/EditorLayoutStore.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A saved dock arrangement, over an engine {@link Storage} backend (IndexedDB in the
+ * browser, {@link InMemoryStorage} in specs) rather than raw localStorage — the editor
+ * has no business knowing which backend the host runs.
+ */
+export class EditorLayoutStore {
+    /**
+     *
+     * @param {Storage} storage
+     * @param {string} [host_key] distinguishes arrangements belonging to different hosts
+     */
+    constructor(storage: Storage, host_key?: string);
+    /**
+     *
+     * @param {Object} layout as produced by {@link DockLayoutView#toJSON}
+     * @returns {Promise<void>}
+     */
+    save(layout: any): Promise<void>;
+    /**
+     * @returns {Promise<Object|null>} null when this host has never saved a layout
+     */
+    load(): Promise<any | null>;
+    /**
+     * Forget the saved arrangement, so the next session opens on the host's defaults.
+     * @returns {Promise<void>}
+     */
+    clear(): Promise<void>;
+    #private;
+}
+//# sourceMappingURL=EditorLayoutStore.d.ts.map

package/editor/persistence/EditorLayoutStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorLayoutStore.d.ts","sourceRoot":"","sources":["../../../editor/persistence/EditorLayoutStore.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH;IAWI;;;;OAIG;IACH,qBAHW,OAAO,aACP,MAAM,EAKhB;IAED;;;;OAIG;IACH,mBAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;OAEG;IACH,QAFa,QAAQ,MAAO,IAAI,CAAC,CAYhC;IAED;;;OAGG;IACH,SAFa,QAAQ,IAAI,CAAC,CAIzB;;CACJ"}

package/editor/persistence/SceneMetadata.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Descriptive record stored beside each scene slot.
+ */
+export class SceneMetadata {
+    /**
+     *
+     * @param {string} name
+     * @param {number} timestamp
+     * @param {number} byte_size
+     * @returns {SceneMetadata}
+     */
+    static from({ name, timestamp, byte_size }: string): SceneMetadata;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Unix time of the save, ms
+     * @type {number}
+     */
+    timestamp: number;
+    /**
+     * Size of the scene payload, bytes
+     * @type {number}
+     */
+    byte_size: number;
+    toJSON(): {
+        name: string;
+        timestamp: number;
+        byte_size: number;
+    };
+    fromJSON({ name, timestamp, byte_size }: {
+        name: any;
+        timestamp: any;
+        byte_size: any;
+    }): void;
+}
+//# sourceMappingURL=SceneMetadata.d.ts.map

package/editor/persistence/SceneMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneMetadata.d.ts","sourceRoot":"","sources":["../../../editor/persistence/SceneMetadata.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAkBI;;;;;;OAMG;IACH,4CALW,MAAM,GAGJ,aAAa,CAUzB;IAhCD;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAmBd;;;;MAMC;IAED;;;;aAIC;CACJ"}

package/editor/persistence/SceneSlotManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Named scene slots over an engine {@link Storage} backend (IndexedDB in the browser,
+ * InMemoryStorage in tests). Each slot is a scene payload plus a {@link SceneMetadata}
+ * record; a slot list is maintained under a fixed key.
+ */
+export class SceneSlotManager {
+    /**
+     *
+     * @param {Storage} storage
+     */
+    constructor(storage: Storage);
+    /**
+     *
+     * @returns {Promise<SceneMetadata[]>}
+     */
+    list(): Promise<SceneMetadata[]>;
+    /**
+     *
+     * @param {string} name
+     * @param {ArrayBuffer} payload serialized scene
+     * @param {number} timestamp Unix time, ms
+     * @returns {Promise}
+     */
+    save(name: string, payload: ArrayBuffer, timestamp: number): Promise<any>;
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise<ArrayBuffer>}
+     */
+    load(name: string): Promise<ArrayBuffer>;
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise}
+     */
+    remove(name: string): Promise<any>;
+    #private;
+}
+import { SceneMetadata } from "./SceneMetadata.js";
+//# sourceMappingURL=SceneSlotManager.d.ts.map

package/editor/persistence/SceneSlotManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSlotManager.d.ts","sourceRoot":"","sources":["../../../editor/persistence/SceneSlotManager.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH;IAMI;;;OAGG;IACH,qBAFW,OAAO,EAIjB;IA2BD;;;OAGG;IACH,QAFa,QAAQ,aAAa,EAAE,CAAC,CAkBpC;IAED;;;;;;OAMG;IACH,WALW,MAAM,WACN,WAAW,aACX,MAAM,gBAoBhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,QAAQ,WAAW,CAAC,CAIhC;IAED;;;;OAIG;IACH,aAHW,MAAM,gBAgBhB;;CACJ;8BA/I6B,oBAAoB"}

package/editor/persistence/buildNewSceneDataset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A minimal usable scene: an active camera, a sun and an ambient light. A completely
+ * empty dataset would export a scene without a camera, which no host could present.
+ *
+ * @param {Engine} engine supplies the component type map
+ * @returns {EntityComponentDataset}
+ */
+export function buildNewSceneDataset(engine: Engine): EntityComponentDataset;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+//# sourceMappingURL=buildNewSceneDataset.d.ts.map

package/editor/persistence/buildNewSceneDataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildNewSceneDataset.d.ts","sourceRoot":"","sources":["../../../editor/persistence/buildNewSceneDataset.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,sDAFa,sBAAsB,CAoDlC;uCAhEsC,gDAAgD"}

package/editor/persistence/files.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Prompt the user for a scene file and read it.
+ *
+ * @returns {Promise<ArrayBuffer|null>} null when the picker is dismissed
+ */
+export function pickSceneFile(): Promise<ArrayBuffer | null>;
+/**
+ * Fetch a scene file, bypassing every cache — the same URL may just have been written by
+ * {@link putSceneToUrl}.
+ *
+ * @param {string} url
+ * @returns {Promise<ArrayBuffer>}
+ */
+export function fetchSceneFromUrl(url: string): Promise<ArrayBuffer>;
+/**
+ * Write a scene file back to its source over HTTP PUT. Requires a server that accepts
+ * writes (the dev server exposes one for `data/levels/**`).
+ *
+ * @param {string} url
+ * @param {ArrayBuffer|Uint8Array} payload
+ * @returns {Promise}
+ */
+export function putSceneToUrl(url: string, payload: ArrayBuffer | Uint8Array): Promise<any>;
+//# sourceMappingURL=files.d.ts.map

package/editor/persistence/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../editor/persistence/files.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iCAFa,QAAQ,WAAW,GAAC,IAAI,CAAC,CA2BrC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,GACJ,QAAQ,WAAW,CAAC,CAUhC;AAED;;;;;;;GAOG;AACH,mCAJW,MAAM,WACN,WAAW,GAAC,UAAU,gBAahC"}

package/editor/persistence/scene_import.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Deserialize a level-file buffer into the given dataset.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function deserializeSceneBuffer(engine: Engine, arrayBuffer: ArrayBuffer, ecd: EntityComponentDataset): Promise<any>;
+/**
+ * Replace the active scene with one holding the given dataset. The scene is recreated
+ * under its own name, which is the manager's only wholesale-content-swap path.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ */
+export function swapSceneDataset(engine: Engine, ecd: EntityComponentDataset): void;
+/**
+ * Replace the current scene's content with the deserialized buffer. Entity ids from the
+ * file apply onto a clean slate.
+ *
+ * The caller is responsible for detaching the editor before and re-attaching it after —
+ * see Editor#openSceneFromBuffer.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Promise}
+ */
+export function importSceneFromBuffer(engine: Engine, arrayBuffer: ArrayBuffer): Promise<any>;
+/**
+ * Merge the deserialized buffer into the live scene ("compose"): every entity from the
+ * file is recreated under a fresh id, as one undoable group.
+ *
+ * Entity ids are remapped wholesale; serialized engine components carry no entity
+ * references, so their data transfers verbatim. Cameras arrive deactivated — the live
+ * scene already has an active one.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {Editor} editor undo/selection context
+ * @returns {Promise<number[]>} created entities
+ */
+export function importSceneAdditive(engine: Engine, arrayBuffer: ArrayBuffer, editor: Editor): Promise<number[]>;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+//# sourceMappingURL=scene_import.d.ts.map

package/editor/persistence/scene_import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene_import.d.ts","sourceRoot":"","sources":["../../../editor/persistence/scene_import.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,oEAJW,WAAW,OACX,sBAAsB,gBAgBhC;AAED;;;;;;GAMG;AACH,sDAFW,sBAAsB,QAoBhC;AAED;;;;;;;;;;GAUG;AACH,mEAHW,WAAW,gBAYrB;AAED;;;;;;;;;;;;GAYG;AACH,iEAJW,WAAW,mBAET,QAAQ,MAAM,EAAE,CAAC,CAiD7B;uCA5IsC,gDAAgD"}

package/editor/persistence/scene_serialization.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Editing-state dataset reduced to what a scene file should contain: editor-owned
+ * entities are stripped and every camera is replaced by an activated clone (the clone
+ * keeps the live scene's component instances untouched — the editing session continues
+ * with its own camera state).
+ *
+ * The copy shares component instances with the live dataset; callers must not mutate
+ * components of the returned dataset.
+ *
+ * @param {Engine} engine
+ * @returns {EntityComponentDataset}
+ */
+export function buildExportDataset(engine: Engine): EntityComponentDataset;
+/**
+ * Serialize a dataset into a level-file buffer (big-endian, string-interned).
+ * Throws when serialization itself fails — a truncated file is never produced silently.
+ * Component types without a registered adapter are skipped with a logged error
+ * (engine serializer behavior); register adapters for every type the scene must keep.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} dataset
+ * @returns {EncodingBinaryBuffer}
+ */
+export function serializeDataset(engine: Engine, dataset: EntityComponentDataset): EncodingBinaryBuffer;
+/**
+ * The standard scene export: {@link buildExportDataset} followed by
+ * {@link serializeDataset}. Hosts wanting extra scrubbing call the two primitives
+ * around their own step.
+ *
+ * @param {Engine} engine
+ * @returns {EncodingBinaryBuffer}
+ */
+export function exportSceneToBuffer(engine: Engine): EncodingBinaryBuffer;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+import { EncodingBinaryBuffer } from "../../src/core/binary/EncodingBinaryBuffer.js";
+//# sourceMappingURL=scene_serialization.d.ts.map

package/editor/persistence/scene_serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene_serialization.d.ts","sourceRoot":"","sources":["../../../editor/persistence/scene_serialization.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,oDAFa,sBAAsB,CAwBlC;AAED;;;;;;;;;GASG;AACH,0DAHW,sBAAsB,GACpB,oBAAoB,CAehC;AAED;;;;;;;GAOG;AACH,qDAFa,oBAAoB,CAIhC;uCA5EsC,gDAAgD;qCAFlD,+CAA+C"}

package/editor/persistence/string_buffer_codec.d.ts

@@ -0,0 +1,20 @@
+/**
+ * URI-escaped ASCII string↔buffer codec, for the small JSON blobs the editor parks in
+ * {@link Storage} beside its binary scenes.
+ *
+ * Environment-free on purpose: TextEncoder/TextDecoder are absent in some DOM test
+ * environments, and percent-escaping keeps non-ASCII intact without them.
+ */
+/**
+ *
+ * @param {string} text
+ * @returns {ArrayBuffer}
+ */
+export function encode_string(text: string): ArrayBuffer;
+/**
+ *
+ * @param {ArrayBuffer} buffer
+ * @returns {string}
+ */
+export function decode_string(buffer: ArrayBuffer): string;
+//# sourceMappingURL=string_buffer_codec.d.ts.map

package/editor/persistence/string_buffer_codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_buffer_codec.d.ts","sourceRoot":"","sources":["../../../editor/persistence/string_buffer_codec.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,oCAHW,MAAM,GACJ,WAAW,CAYvB;AAED;;;;GAIG;AACH,sCAHW,WAAW,GACT,MAAM,CAYlB"}

package/editor/process/DisableGameUIProcess.d.ts

@@ -0,0 +1,8 @@
+export class DisableGameUIProcess extends EditorProcess {
+    initialize(editor: any): void;
+}
+export namespace DisableGameUIProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=DisableGameUIProcess.d.ts.map

package/editor/process/DisableGameUIProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisableGameUIProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/DisableGameUIProcess.js"],"names":[],"mappings":"AAGA;IAII,8BAEC;CAyBJ;;;;8BAlC6B,oBAAoB"}

package/editor/process/EditorProcess.d.ts

@@ -0,0 +1,19 @@
+export class EditorProcess extends BaseProcess {
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {Editor|null}
+     */
+    editor: Editor | null;
+    /**
+     *
+     * @param {Editor} editor
+     */
+    initialize(editor: Editor): void;
+}
+import { BaseProcess } from "../../src/core/process/BaseProcess.js";
+//# sourceMappingURL=EditorProcess.d.ts.map

package/editor/process/EditorProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/EditorProcess.js"],"names":[],"mappings":"AAIA;IAEI;;;OAGG;IACH,MAFU,MAAM,CAEC;IACjB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,iCAMC;CACJ;4BA3B2B,uCAAuC"}

package/editor/process/GridDisplayProcess.d.ts

@@ -0,0 +1,35 @@
+/**
+ * How far the grid reaches from the origin along each axis, in world units.
+ *
+ * @type {number}
+ */
+export const GRID_DISPLAY_HALF_EXTENT: number;
+/**
+ * Distance between two neighbouring lines, in world units — one cell of the game's own grid at the
+ * default grid scale.
+ *
+ * @type {number}
+ */
+export const GRID_DISPLAY_SPACING: number;
+/**
+ * Ground reference grid at y=0. Gives empty scenes a spatial anchor for navigation and
+ * mesh placement.
+ *
+ * **A construction plane rather than a mark on the ground, which is what decides where it draws.**
+ * The editor's other grid is the obstacle map, and that one is painted into the terrain's overlay
+ * because it describes cells of a terrain that exists. This one describes space, is at its most
+ * useful in a level with no terrain in it at all, and so goes onto the debug-draw pass (V3) with
+ * everything else the editor draws — recorded once a frame, occluded by whatever the scene has put
+ * in front of it, and gone the moment this process stops.
+ *
+ * The extent is fixed rather than following the camera or the terrain: a grid whose lines moved
+ * with the view would be a poor thing to judge a placement against.
+ */
+export class GridDisplayProcess extends EditorProcess {
+    #private;
+}
+export namespace GridDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=GridDisplayProcess.d.ts.map

package/editor/process/GridDisplayProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridDisplayProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/GridDisplayProcess.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,mCAFU,MAAM,CAEsB;AAyCtC;;;;;;;;;;;;;GAaG;AACH;;CAiDC;;;;8BAvH6B,oBAAoB"}

package/editor/process/ObstacleGridDisplayProcess.d.ts

@@ -0,0 +1,13 @@
+export class ObstacleGridDisplayProcess extends EditorProcess {
+    /**
+     *
+     * @type {TerrainOverlay|null}
+     */
+    overlay: TerrainOverlay | null;
+    draw(): void;
+}
+export namespace ObstacleGridDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=ObstacleGridDisplayProcess.d.ts.map

package/editor/process/ObstacleGridDisplayProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObstacleGridDisplayProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/ObstacleGridDisplayProcess.js"],"names":[],"mappings":"AAMA;IAEI;;;OAGG;IACH,SAFU,iBAAe,IAAI,CAEd;IA4Bf,aAgEC;CASJ;;;;8BA7G6B,oBAAoB"}

package/editor/process/ParticleEmitterRebuildProcess.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Keeps live particle emitters in sync with editing: rebuilds an emitter when its layer
+ * list changes or one of its parameter lookup tables is edited (curve/gradient editors
+ * announce those through {@link onParameterLutEdited}). Rebuilds are debounced — drags
+ * produce edit bursts.
+ */
+export class ParticleEmitterRebuildProcess extends EditorProcess {
+    /**
+     * emitter layer-list subscriptions, torn down on shutdown
+     * @type {Map<number, {emitter: ParticleEmitter, handler: function}>}
+     */
+    __watched: Map<number, {
+        emitter: ParticleEmitter;
+        handler: Function;
+    }>;
+    /**
+     * entities with a rebuild pending
+     * @type {Set<number>}
+     */
+    __pending: Set<number>;
+    /**
+     * @type {number|null}
+     */
+    __timer: number | null;
+    /**
+     * @type {boolean}
+     */
+    __running: boolean;
+    /**
+     * Map an edited lookup table back to its owning emitter
+     * @param {ParameterLookupTable} lut
+     */
+    __handleLutEdited(lut: ParameterLookupTable): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityCreated(entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityRemoved(entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __scheduleRebuild(entity: number): void;
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {number} entity
+     */
+    __watch(emitter: ParticleEmitter, entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __unwatch(entity: number): void;
+}
+export namespace ParticleEmitterRebuildProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+import { ParticleEmitter } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+//# sourceMappingURL=ParticleEmitterRebuildProcess.d.ts.map

package/editor/process/ParticleEmitterRebuildProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEmitterRebuildProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/ParticleEmitterRebuildProcess.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IAII;;;OAGG;IACH,WAFU,IAAI,MAAM,EAAE;QAAC,OAAO,EAAE,eAAe,CAAC;QAAC,OAAO,WAAU;KAAC,CAAC,CAE9C;IAEtB;;;OAGG;IACH,WAFU,IAAI,MAAM,CAAC,CAEC;IAEtB;;OAEG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;OAEG;IACH,WAFU,OAAO,CAEC;IAwGlB;;;OAGG;IACH,mDAuBC;IA9DD;;;OAGG;IACH,8BAFW,MAAM,QAsBhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAKhB;IA5FD;;;OAGG;IACH,0BAFW,MAAM,QAoBhB;IAED;;;;OAIG;IACH,iBAHW,eAAe,UACf,MAAM,QAahB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAahB;CA4GJ;;;;8BAjN6B,oBAAoB;gCAHlB,kFAAkF"}

package/editor/process/ProcessEngine.d.ts

@@ -0,0 +1,30 @@
+export class ProcessEngine extends EditorProcess {
+    /**
+     * @type {List.<EditorProcess>}
+     */
+    processes: List<EditorProcess>;
+    __suspendedList: List<any>;
+    /**
+     *
+     * @param {EditorProcess} process
+     */
+    add(process: EditorProcess): void;
+    /**
+     * @private
+     * @param {EditorProcess} process
+     */
+    private startProcess;
+    /**
+     *
+     * @param {string} name
+     */
+    startByName(name: string): void;
+    /**
+     *
+     * @param {string} name
+     */
+    stopByName(name: string): void;
+}
+import { EditorProcess } from "./EditorProcess.js";
+import List from "../../src/core/collection/list/List.js";
+//# sourceMappingURL=ProcessEngine.d.ts.map

package/editor/process/ProcessEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessEngine.d.ts","sourceRoot":"","sources":["../../../editor/process/ProcessEngine.js"],"names":[],"mappings":"AAsBA;IAEI;;OAEG;IACH,WAFU,KAAM,aAAa,CAAC,CAEP;IAEvB,2BAA6B;IAwB7B;;;OAGG;IACH,aAFW,aAAa,QAQvB;IAeD;;;OAGG;IACH,qBAWC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAahB;CACJ;8BA5H6B,oBAAoB;iBAFjC,wCAAwC"}