@woosh/meep-engine 3.14.4 → 3.14.6

package/editor/process/SymbolicDisplayProcess.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Draws a symbol for everything in a level that has no picture of its own.
+ *
+ * **Immediate mode, and that is the whole of what this process now is.** Every display used to
+ * build a helper entity per subject — a `Renderable` around a three `Object3D` (I-6's retirement
+ * list), kept in step through signal bindings and torn down again by an observer when the component
+ * went — which is why this process had to spawn a `RenderSystem` to draw at all and had to check
+ * whether each display's component types were even registered before starting it. None of that
+ * survives: the displays are asked once a frame what the scene looks like and answer with shapes
+ * in {@link Gizmo}, and `DebugDrawSystem` turns them into pixels.
+ */
+export class SymbolicDisplayProcess extends EditorProcess {
+    /**
+     * @type {SymbolicDisplay[]}
+     */
+    displays: SymbolicDisplay[];
+    #private;
+}
+export namespace SymbolicDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=SymbolicDisplayProcess.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolicDisplayProcess.d.ts","sourceRoot":"","sources":["../../../editor/process/SymbolicDisplayProcess.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH;IAGI;;OAEG;IACH,UAFU,iBAAiB,CAEb;;CAgEjB;;;;8BA9F6B,oBAAoB"}

package/editor/process/symbolic/AudioEmitterSymbolicDisplay.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The two distances a native audio emitter rolls off between.
+ *
+ * The same pair of spheres and the same two colours the three version drew, because what they mean is
+ * the attenuation model rather than anything about a component or a renderer: inside the near one there
+ * is no attenuation, past the far one there is no sound.
+ *
+ * Only drawn for a 3D event. A 2D one is position-independent — it sounds the same wherever the
+ * entity is — so its distance pair is inert data and drawing it would claim a rolloff that is not
+ * there.
+ *
+ * @see SymbolicDisplay
+ */
+export class AudioEmitterSymbolicDisplay extends SymbolicDisplay {
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=AudioEmitterSymbolicDisplay.d.ts.map

package/editor/process/symbolic/AudioEmitterSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioEmitterSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/AudioEmitterSymbolicDisplay.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH;CA6BC;gCA/DuD,sBAAsB"}

package/editor/process/symbolic/CameraSymbolicDisplay.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The volume a camera entity can see.
+ *
+ * **Built from the component rather than from a renderer's camera object.** A camera entity has no
+ * renderer object of its own, which is why the three `CameraHelper` this replaces could not survive
+ * the port; everything the frustum needs — field of view, the two clip planes — is on the component,
+ * and where the camera is and which way it faces is its `Transform`.
+ * The one thing that is not is the aspect ratio, which belongs to the frame rather than to the
+ * camera: it is the viewport's, exactly as the renderer's own is.
+ *
+ * **Perspective always, because that is what gets drawn.** `Camera.projectionType` carries an
+ * orthographic option and no renderer in the program reads it — `CameraSystem` copies the field of
+ * view and the clip planes and nothing else — so a symbol that branched on it would be drawing a
+ * projection the game cannot render.
+ *
+ * The transform's scale is deliberately not applied. A camera has no size, and a scaled entity
+ * carrying one still sees exactly as far as its clip planes say.
+ *
+ * @see SymbolicDisplay
+ */
+export class CameraSymbolicDisplay extends SymbolicDisplay {
+    #private;
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=CameraSymbolicDisplay.d.ts.map

package/editor/process/symbolic/CameraSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CameraSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/CameraSymbolicDisplay.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;CA8EC;gCA5IuD,sBAAsB"}

package/editor/process/symbolic/GridPositionSymbolicDisplay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A tether from an entity to the ground of the grid cell it claims to be standing on.
+ *
+ * The two are separate facts — a `Transform` is where the entity is drawn and a `GridPosition` is
+ * which cell the game's rules place it in — and the whole use of the symbol is seeing where they
+ * disagree.
+ *
+ * **The ground is asked for every frame and a miss is simply not drawn.** The three version could
+ * not do that: it built a line geometry once, and a cell whose terrain had not been built yet went
+ * onto a retry queue driven by a background task, which then had to be started and stopped with the
+ * display and purged when it stopped. A frame that finds no ground under a cell contributes
+ * nothing, and the frame after the tile is built draws the line — no queue, no task, no lifetime.
+ *
+ * @see SymbolicDisplay
+ */
+export class GridPositionSymbolicDisplay extends SymbolicDisplay {
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=GridPositionSymbolicDisplay.d.ts.map

package/editor/process/symbolic/GridPositionSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridPositionSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/GridPositionSymbolicDisplay.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;GAcG;AACH;CAgDC;gCAlGuD,sBAAsB"}

package/editor/process/symbolic/LightSymbolicDisplay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What a light reaches, drawn as the shape of its own type.
+ *
+ * **Range rather than a fixed-size badge.** three's `PointLightHelper` drew a unit sphere whatever
+ * the light's distance was, so the symbol said where the light was and nothing about what it lit;
+ * the useful question in an editor is the second one, and the component already answers it. Where
+ * the light *is* stays answered too — the positioned marker draws that, on the same entity.
+ *
+ * **A light shines along its forward**, which is `LightSystem`'s stated convention and puts it on
+ * the transform's local +Z. The spot cone and the directional arrow are both built from that, so a
+ * light that is turned in the editor turns its symbol with it.
+ *
+ * @see SymbolicDisplay
+ */
+export class LightSymbolicDisplay extends SymbolicDisplay {
+    #private;
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=LightSymbolicDisplay.d.ts.map

package/editor/process/symbolic/LightSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/LightSymbolicDisplay.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;GAaG;AACH;;CA4FC;gCArKuD,sBAAsB"}

package/editor/process/symbolic/ParticleEmitterSymbolicDisplay.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where a particle emitter's layers are and what volume each of them emits from.
+ *
+ * One marker per layer wherever the layer sits, and the emission volume around it: a sphere for a
+ * spherical emission shape, a box for a box one, and for a point shape the marker alone, because a
+ * point has no volume to draw.
+ *
+ * **The box is twelve segments rather than the recording's own wire cube.** A layer's box is in the
+ * emitter's frame and turns with the entity; `draw_wire_cube` takes a centre and a size and is
+ * therefore axis-aligned. See {@link gizmo_draw_wire_box_oriented}.
+ *
+ * @see SymbolicDisplay
+ */
+export class ParticleEmitterSymbolicDisplay extends SymbolicDisplay {
+    #private;
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=ParticleEmitterSymbolicDisplay.d.ts.map

package/editor/process/symbolic/ParticleEmitterSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEmitterSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/ParticleEmitterSymbolicDisplay.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;GAYG;AACH;;CAqDC;gCA3HuD,sBAAsB"}

package/editor/process/symbolic/PathSymbolicDisplay.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The line a `Path` describes.
+ *
+ * **Subdivided per span rather than per world unit.** The three version stepped along the path
+ * every hundredth of a world unit and rebuilt a `BufferGeometry` whenever a point moved, which was
+ * affordable because the geometry was built once and kept. Recording is per frame, so the density
+ * has to be worth paying for every frame: a linear path is exactly its own points and is drawn as
+ * them, and a curved one gets a fixed number of samples per authored span, which is where its
+ * curvature actually lives.
+ *
+ * A `Path` has no `Transform` and is not given one here — its points are world-space, which is what
+ * the navigation code that reads them expects.
+ *
+ * @see SymbolicDisplay
+ */
+export class PathSymbolicDisplay extends SymbolicDisplay {
+    #private;
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=PathSymbolicDisplay.d.ts.map

package/editor/process/symbolic/PathSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/PathSymbolicDisplay.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;GAcG;AACH;;CAmEC;gCAjHuD,sBAAsB"}

package/editor/process/symbolic/PositionedMarkerSymbolicDisplay.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A blob on every entity carrying one kind of component, so that a thing with nothing to see —
+ * a light, a camera, a sound — can still be seen and clicked.
+ *
+ * **It is a coloured shape rather than an icon, and the reason is the draw path.** The three
+ * version was a textured `Sprite`; the dynamic-mesh path every piece of generated content in this
+ * phase draws on has one vertex layout, position and colour (D5/D11), and no texture at any point
+ * along it. Widening it for four editor icons is the trade that decision refuses, so what carries
+ * the identity is the colour the registration site picks — which is the same thing the icon URL
+ * used to be, said in the vocabulary the recording has.
+ *
+ * The marker is world-sized and so shrinks with distance, which the sprite did too: three's
+ * `SpriteMaterial` attenuates by default.
+ */
+export class PositionedMarkerSymbolicDisplay extends SymbolicDisplay {
+    /**
+     * @param {Engine} engine
+     * @param {Function} component the component type an entity must carry to be marked
+     * @param {number[]} color RGBA
+     */
+    constructor(engine: Engine, component: Function, color: number[]);
+    #private;
+}
+import { SymbolicDisplay } from "./SymbolicDisplay.js";
+//# sourceMappingURL=PositionedMarkerSymbolicDisplay.d.ts.map

package/editor/process/symbolic/PositionedMarkerSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PositionedMarkerSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/PositionedMarkerSymbolicDisplay.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AACH;IAWI;;;;OAIG;IACH,wDAFW,MAAM,EAAE,EAUlB;;CAsBJ;gCA3EuD,sBAAsB"}

package/editor/process/symbolic/SymbolicDisplay.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Whether an entity is one the editor made rather than one it is editing.
+ *
+ * The editor's own camera carries a {@link Camera} like any other entity, and drawing a symbol for
+ * the thing the view is being drawn from is a symbol in the middle of the screen forever. The three
+ * displays skipped these too, and for the same reason.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {boolean}
+ */
+export function entity_is_editor_owned(dataset: EntityComponentDataset, entity: number): boolean;
+/**
+ * One kind of symbol the editor draws for the entities carrying one kind of component.
+ *
+ * **A display records, it does not build anything.** The three version of these hung a helper
+ * *entity* off every entity it watched — a `Renderable` wrapping a three `Object3D`, kept in step
+ * with its subject through a fistful of signal bindings and torn down again when the component
+ * went. That machinery existed because the picture was an object with a lifetime. On an
+ * immediate-mode surface it is not: {@link record} is asked once a frame what the scene looks like
+ * and answers with shapes, so a component that has gone contributes nothing for the same reason it
+ * contributes nothing to the traversal — there is no object to unwind, and nothing that can be
+ * left behind.
+ *
+ * That is also why a display holds no per-entity state. Anything it did hold would be a second
+ * answer to "what is in the scene", and the dataset is already the first one.
+ */
+export class SymbolicDisplay {
+    /**
+     * @param {Engine} engine
+     */
+    constructor(engine: Engine);
+    /**
+     * @type {Engine}
+     */
+    engine: Engine;
+    /**
+     * Record this frame's symbols into {@link Gizmo}.
+     *
+     * Called once per frame with the dataset the editor is attached to. A component type this
+     * dataset does not carry costs a returned traversal and nothing else, so a display never has to
+     * ask whether it applies.
+     *
+     * @param {EntityComponentDataset} dataset
+     */
+    record(dataset: EntityComponentDataset): void;
+}
+//# sourceMappingURL=SymbolicDisplay.d.ts.map

package/editor/process/symbolic/SymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/SymbolicDisplay.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;GAUG;AACH,gFAHW,MAAM,GACJ,OAAO,CAInB;AA1DD;;;;;;;;;;;;;;GAcG;AACH;IAMI;;OAEG;IACH,4BAKC;IAbD;;OAEG;IACH,eAAO;IAYP;;;;;;;;OAQG;IACH,8CAEC;CACJ"}

package/editor/process/symbolic/gizmo_draw_wire_box_oriented.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A box that is turned, as twelve segments in {@link Gizmo}'s current colour.
+ *
+ * {@link GizmoShapeRenderingInterface.draw_wire_cube} takes a centre and a size and is therefore
+ * axis-aligned — which is right for what it is for, a box around some bounds, and wrong for a box
+ * that belongs to an entity's own frame. Rather than widen the recording with a second box layout
+ * that only one caller wants, the corners are transformed here and the edges drawn as what they
+ * are.
+ *
+ * @param {ArrayLike<number>} matrix column-major 4x4 placing the unit cube
+ */
+export function gizmo_draw_wire_box_oriented(matrix: ArrayLike<number>): void;
+//# sourceMappingURL=gizmo_draw_wire_box_oriented.d.ts.map

package/editor/process/symbolic/gizmo_draw_wire_box_oriented.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_draw_wire_box_oriented.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/gizmo_draw_wire_box_oriented.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;GAUG;AACH,qDAFW,UAAU,MAAM,CAAC,QA6B3B"}

package/editor/process/symbolic/gizmo_draw_wire_circle.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A circle, as a closed run of straight segments in {@link Gizmo}'s current colour.
+ *
+ * The recording API has no curve and should not grow one — a circle is a symbol's vocabulary rather
+ * than a debug primitive, and the two backends that read the recording would each need a way to
+ * draw it. Segments they both already have.
+ *
+ * The plane is given as its two in-plane axes, which is what the callers have: a cone's rim and a
+ * directional light's disc both know where their circle faces before they know how big it is.
+ *
+ * @param {ArrayLike<number>} center
+ * @param {ArrayLike<number>} axis_u unit vector in the circle's plane
+ * @param {ArrayLike<number>} axis_v unit vector in the circle's plane, perpendicular to `axis_u`
+ * @param {number} radius
+ * @param {number} segments how many straight pieces the circle is made of
+ */
+export function gizmo_draw_wire_circle(center: ArrayLike<number>, axis_u: ArrayLike<number>, axis_v: ArrayLike<number>, radius: number, segments: number): void;
+//# sourceMappingURL=gizmo_draw_wire_circle.d.ts.map

package/editor/process/symbolic/gizmo_draw_wire_circle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_draw_wire_circle.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/gizmo_draw_wire_circle.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AACH,+CANW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,UACjB,MAAM,YACN,MAAM,QAyBhB"}

package/editor/prototypeEditorShell.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The shell, booting. Exported as the promise it is so that a probe driving this page has something
+ * to await — the module boots when it is loaded either way, which is what makes it an entry.
+ *
+ * @type {Promise<{engine: Engine, editor: Editor, editorControl: object, terrain: Terrain}>}
+ */
+export const editor_shell: Promise<{
+    engine: Engine;
+    editor: Editor;
+    editorControl: object;
+    terrain: Terrain;
+}>;
+//# sourceMappingURL=prototypeEditorShell.d.ts.map

package/editor/prototypeEditorShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototypeEditorShell.d.ts","sourceRoot":"","sources":["../../editor/prototypeEditorShell.js"],"names":[],"mappings":"AAmLA;;;;;GAKG;AACH,2BAFU,QAAQ;IAAC,MAAM,SAAS;IAAC,MAAM,SAAS;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,UAAS;CAAC,CAAC,CAEzD"}

package/editor/selection/editor_pick.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What the editor's pointer and marquee search, and why it is not the game's picking index.
+ *
+ * `PickingSystem` indexes entities that carry a `Pickable`, which is an opt-in the game spends on
+ * fourteen tooltip sites — and deliberately so: the per-entity duplication that index costs is the
+ * thing the component exists to bound (I-9). **An editor has to be able to select a thing nobody
+ * thought to make pickable**, so widening that opt-in to everything would spend exactly what it was
+ * written to save, on a tool that is second-class by decision (D7).
+ *
+ * So the editor asks instead of indexing: every entity placed in the world is offered its bounds,
+ * and the ones that have any are tested. A click happens once, a level holds thousands of entities
+ * rather than millions, and nothing is kept between clicks that could be stale.
+ *
+ * **Bounds arrive through a reader** — `entity_world_bounds_reader` on a real editor — because where
+ * a world box lives is the one thing that genuinely differs per renderer, and it is resolved once,
+ * there.
+ */
+/**
+ * The entity a ray reaches first.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {function(ArrayLike<number>, number): boolean} read_bounds
+ * @param {Vector3} origin
+ * @param {Vector3} direction unit length
+ * @param {number} max_distance
+ * @returns {number} the entity, or `-1` when the ray reaches nothing
+ */
+export function editor_pick_ray(dataset: EntityComponentDataset, read_bounds: (arg0: ArrayLike<number>, arg1: number) => boolean, origin: Vector3, direction: Vector3, max_distance: number): number;
+/**
+ * Every entity a volume overlaps.
+ *
+ * Overlap rather than containment: half a thing inside a marquee is inside it, which is what a
+ * marquee has always meant.
+ *
+ * @param {number[]} result appended to
+ * @param {EntityComponentDataset} dataset
+ * @param {function(ArrayLike<number>, number): boolean} read_bounds
+ * @param {ArrayLike<number>|Float64Array} planes `nx, ny, nz, w` each, interior positive
+ * @param {number} plane_count
+ * @returns {number} how many were written
+ */
+export function editor_pick_frustum(result: number[], dataset: EntityComponentDataset, read_bounds: (arg0: ArrayLike<number>, arg1: number) => boolean, planes: ArrayLike<number> | Float64Array, plane_count: number): number;
+//# sourceMappingURL=editor_pick.d.ts.map

package/editor/selection/editor_pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor_pick.d.ts","sourceRoot":"","sources":["../../../editor/selection/editor_pick.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;GASG;AACH,qFANoB,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,qDAG5C,MAAM,GACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;GAYG;AACH,4CAPW,MAAM,EAAE,uDAEC,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,UAC5C,UAAU,MAAM,CAAC,GAAC,YAAY,eAC9B,MAAM,GACJ,MAAM,CA6BlB"}

package/editor/selection/screen_rect_frustum.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The volume a rectangle drawn on the screen means.
+ *
+ * **Built from the facade's own projection rays rather than from a camera object**, which is what
+ * makes it renderer-neutral: `viewportProjectionRay` is on both engines, answers in world space, and
+ * takes its origin from the eye — so the four corners of the rectangle give four directions from one
+ * point, and four side planes follow. The three version of this unprojected eight corners through a
+ * `THREE.Camera` and could only ever run on one renderer.
+ *
+ * **Each side plane's orientation is decided against the rectangle's own middle**, not against a
+ * winding convention. Which way a cross product points depends on the order the corners come in and
+ * on the handedness of the projection, and neither is a thing this should have an opinion about; the
+ * direction through the centre of the rectangle is inside the volume by construction, so it settles
+ * every sign in one step.
+ *
+ * Planes are written `nx, ny, nz, w` with the interior **positive**, which is what
+ * `aabb3_intersects_clipping_volume_array` tests for.
+ *
+ * @param {ArrayLike<number>|Float64Array} result at least `SCREEN_RECT_FRUSTUM_PLANES * 4` long
+ * @param {GraphicsEngine|GraphicsEngine} graphics
+ * @param {AABB2} rect clip space, −1…1, +Y up
+ * @param {number} near world units from the eye
+ * @param {number} far world units from the eye
+ */
+export function screen_rect_frustum(result: ArrayLike<number> | Float64Array, graphics: GraphicsEngine | GraphicsEngine, rect: AABB2, near: number, far: number): void;
+/**
+ * Planes the volume is made of: four sides, a near and a far.
+ *
+ * @type {number}
+ */
+export const SCREEN_RECT_FRUSTUM_PLANES: number;
+//# sourceMappingURL=screen_rect_frustum.d.ts.map

package/editor/selection/screen_rect_frustum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen_rect_frustum.d.ts","sourceRoot":"","sources":["../../../editor/selection/screen_rect_frustum.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,4CANW,UAAU,MAAM,CAAC,GAAC,YAAY,YAC9B,+BAA6B,qBAE7B,MAAM,OACN,MAAM,QAiDhB;AApGD;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}

package/editor/templates/entity_templates.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Create an entity from a list of components as one undoable group, select it.
+ *
+ * @param {Editor} editor
+ * @param {string} name template name, used for the undo mark and the Name component
+ * @param {[]} components
+ * @returns {Promise<number>} the created entity
+ */
+export function spawnEntityFromTemplate(editor: Editor, name: string, components: []): Promise<number>;
+/**
+ * The entity creation menu. Every template attaches a Transform and a Name.
+ *
+ * @type {ReadonlyArray<{name: string, build: function(Editor): Promise<number>}>}
+ */
+export const ENTITY_TEMPLATES: ReadonlyArray<{
+    name: string;
+    build: (arg0: Editor) => Promise<number>;
+}>;
+//# sourceMappingURL=entity_templates.d.ts.map

package/editor/templates/entity_templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity_templates.d.ts","sourceRoot":"","sources":["../../../editor/templates/entity_templates.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,8DAJW,MAAM,cACN,EAAE,GACA,QAAQ,MAAM,CAAC,CA4B3B;AAED;;;;GAIG;AACH,+BAFU,cAAc;IAAC,MAAM,MAAM,CAAC;IAAC,KAAK,oBAAoB,QAAQ,MAAM,CAAC,CAAA;CAAC,CAAC,CA6G/E"}

package/editor/tools/GridPaintTool.d.ts

@@ -0,0 +1,18 @@
+export default GridPaintTool;
+declare class GridPaintTool extends Tool {
+    name: string;
+    terrain: import("../../src/engine/ecs/terrain/ecs/Terrain.js").default;
+    terrainEntity: number;
+    cameraController: {
+        start: Function;
+        stop: Function;
+    };
+    buildColor(): Vector4;
+    paint(): void;
+    traverse(callback: any): void;
+    affectTile(_x: any, _y: any): void;
+    affectTileByMousePosition(position: any): void;
+}
+import Tool from "./engine/Tool.js";
+import Vector4 from "../../src/core/geom/Vector4.js";
+//# sourceMappingURL=GridPaintTool.d.ts.map

package/editor/tools/GridPaintTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridPaintTool.d.ts","sourceRoot":"","sources":["../../../editor/tools/GridPaintTool.js"],"names":[],"mappings":";AAkBA;IACI,aAAoB;IAgBhB,uEAEE;IADE,sBAA2B;IAe/B;;;MAA2E;IAI/E,sBAQC;IAED,cAyBC;IAED,8BAyBC;IAiBD,mCAuCC;IAED,+CAQC;CAcJ;iBArLgB,kBAAkB;oBAbf,gCAAgC"}

package/editor/tools/SelectionTool.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a click at a point on the viewport selects.
+ *
+ * @param {Vector2} point viewport pixels
+ * @param {Engine} engine
+ * @param {number} reach world units — the camera's own far distance, since nothing further is drawn
+ * @returns {number[]} entities
+ */
+export function pickingEntitySelection(point: Vector2, engine: Engine, reach: number): number[];
+export default SelectionTool;
+import Vector2 from '../../src/core/geom/Vector2.js';
+declare class SelectionTool extends Tool {
+    name: string;
+    anchorPoint: Vector2;
+    targetPoint: Vector2;
+    box: AABB2;
+    selectionMarker: SelectionView;
+    /**
+     * Where the pointer is, in the viewport's own pixels.
+     *
+     * **Converted, not offset.** `View.position` is a layout property nothing sets when a view is
+     * placed by CSS, so subtracting it leaves page coordinates — and the editor shell docks its
+     * viewport inside panels, so every click was picked at the pointer's position *plus* the
+     * viewport's offset. Measured in the shell: a click at viewport 640, 400 was picked at 946, 464
+     * and selected nothing. `positionGlobalToLocal` reads the element's own box, which is what
+     * `GridPaintTool` and `TerrainPaintTool` already did.
+     *
+     * @param {Vector2} target
+     */
+    readPosition(target: Vector2): void;
+}
+import Tool from './engine/Tool.js';
+import AABB2 from '../../src/core/geom/2d/aabb/AABB2.js';
+declare class SelectionView extends View {
+    el: HTMLDivElement;
+}
+import View from '../../src/view/View.js';
+//# sourceMappingURL=SelectionTool.d.ts.map

package/editor/tools/SelectionTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionTool.d.ts","sourceRoot":"","sources":["../../../editor/tools/SelectionTool.js"],"names":[],"mappings":"AA8NA;;;;;;;GAOG;AACH,8CALW,OAAO,yBAEP,MAAM,GACJ,MAAM,EAAE,CA4BpB;;oBA/PmB,gCAAgC;AAmCpD;IACI,aAA2B;IAE3B,qBAA4B;IAC5B,qBAA4B;IAC5B,WAAkB;IAClB,+BAAsC;IAEtC;;;;;;;;;;;OAWG;IACH,qBAFW,OAAO,QAIjB;CA4GJ;iBAvJgB,kBAAkB;kBAfjB,sCAAsC;AAiBxD;IAGQ,mBAAuC;CAa9C;iBA7BgB,wBAAwB"}

package/editor/tools/SelectionTool.js

@@ -177,9 +177,9 @@ const scratch_marker_position = new Vector2();
 
 /**
  *
- * @param {int} entity
+ * @param {number} entity
  * @param {EntityComponentDataset} dataset
- * @returns {int}
+ * @returns {number}
  */
 function dereferenceEntity(entity, dataset) {
     if (dataset.componentTypeMap.indexOf(EditorEntity) === -1) {

package/editor/tools/TransformToolV2.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Selection transform gizmo on the engine-native TransformControls.
+ *
+ * The gizmo attaches to the primary (most recent) selection. During a drag the primary's
+ * delta is applied uniformly to every selected entity: translation as a shared world
+ * offset, rotation as the same world-frame delta about each entity's own pivot, scale as
+ * the same per-axis ratio. A drag commits as one undo mark of per-entity
+ * TransformModifyActions.
+ *
+ * Keys (via the editor keymap forwarding): W/E/R switch mode, Q toggles world/local
+ * space, Escape cancels a drag in flight.
+ */
+export class TransformToolV2 extends Tool {
+    name: string;
+    /**
+     * @type {ObservedValue<string>} one of {@link TransformMode}
+     */
+    mode: any;
+    /**
+     * @type {TransformControls|null}
+     */
+    __controls: TransformControls | null;
+    /**
+     * dragging state at the previous update tick
+     * @type {boolean}
+     */
+    __was_dragging: boolean;
+    /**
+     * Transform state per selected entity at drag start
+     * @type {Map<number, Transform>}
+     */
+    __drag_snapshots: Map<number, Transform>;
+    /**
+     * The underlying gizmo; exposed so hosts and specs can drive or configure it
+     * @returns {TransformControls|null}
+     */
+    get controls(): TransformControls;
+    /**
+     * @returns {EntityComponentDataset}
+     */
+    get __dataset(): EntityComponentDataset;
+    /**
+     * Most recent selection entry carrying a Transform, -1 when none
+     * @returns {number}
+     */
+    __primaryEntity(): number;
+    __handleSelectionChanged(): void;
+    __handleDragStart(): void;
+    /**
+     * Mirror the primary's in-flight delta onto the rest of the selection.
+     */
+    __handleObjectChange(): void;
+    /**
+     * Commit the finished drag as one undo group.
+     */
+    __handleDragEnd(): void;
+    update(timeDelta: any): void;
+    __handleModeChanged(): void;
+    __handleSpaceChanged(): void;
+    __applySnapSettings(): void;
+    /**
+     *
+     * @param {KeyboardEvent} event
+     */
+    handleKeyboardEvent(event: KeyboardEvent): void;
+}
+import Tool from "./engine/Tool.js";
+import { TransformControls } from "./v2/TransformControls.js";
+import { Transform } from "../../src/engine/ecs/transform/Transform.js";
+//# sourceMappingURL=TransformToolV2.d.ts.map

package/editor/tools/TransformToolV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,UAAkD;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,SAAS,CAAC,CAEC;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAiCC;IAED;;OAEG;IACH,6BAiDC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAkBvB;CACJ;iBAlXgB,kBAAkB;kCACD,2BAA2B;0BAJnC,6CAA6C"}