@woosh/meep-engine 3.11.2 → 3.12.0

package/editor/SelectionVisualizer.js

@@ -1,127 +1,127 @@
-import { assert } from "../src/core/assert.js";
-import { Gizmo } from "../src/engine/graphics/render/gizmo/Gizmo.js";
-import { entity_world_bounds_reader } from "./entity_world_bounds.js";
-
-/**
- * The colour a selection is drawn in, RGBA. Yellow, which is what the three `BoxHelper` this
- * replaces defaulted to — the editor is not asking for a new language, only for a new backend.
- *
- * @type {number[]}
- */
-const SELECTION_COLOR = [1, 1, 0, 1];
-
-/**
- * @type {Float32Array}
- */
-const scratch_bounds = new Float32Array(6);
-
-/**
- * @type {Float32Array}
- */
-const scratch_center = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const scratch_size = new Float32Array(3);
-
-/**
- * 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** — `DebugDrawSystem3` 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 {
-    /**
-     * @type {Editor}
-     */
-    editor;
-
-    /**
-     * Where an entity is, on the renderer this editor attached to. Resolved on {@link startup},
-     * because the engine is not known when the editor is built.
-     *
-     * @type {function(ArrayLike<number>, number): boolean|null}
-     */
-    #bounds = null;
-
-    /**
-     * @type {function}
-     */
-    #draw;
-
-    /**
-     * @param {Editor} editor
-     */
-    constructor(editor) {
-        assert.defined(editor, 'editor');
-
-        this.editor = editor;
-
-        this.#draw = () => this.#record();
-    }
-
-    /**
-     * Record this frame's selection.
-     */
-    #record() {
-        const selection = this.editor.selection;
-        const bounds = this.#bounds;
-
-        Gizmo.color = SELECTION_COLOR;
-
-        for (let i = 0; i < selection.length; i++) {
-            const entity = selection.get(i);
-
-            if (!bounds(scratch_bounds, entity)) {
-                // no model, or one that has not loaded — there is nothing to put a box around
-                continue;
-            }
-
-            scratch_center[0] = (scratch_bounds[0] + scratch_bounds[3]) / 2;
-            scratch_center[1] = (scratch_bounds[1] + scratch_bounds[4]) / 2;
-            scratch_center[2] = (scratch_bounds[2] + scratch_bounds[5]) / 2;
-
-            scratch_size[0] = scratch_bounds[3] - scratch_bounds[0];
-            scratch_size[1] = scratch_bounds[4] - scratch_bounds[1];
-            scratch_size[2] = scratch_bounds[5] - scratch_bounds[2];
-
-            Gizmo.draw_wire_cube(scratch_center, scratch_size);
-        }
-    }
-
-    startup() {
-        const engine = this.editor.engine;
-
-        this.#bounds = entity_world_bounds_reader(engine);
-
-        // per frame rather than per tick: the recording is cleared once the frame that consumed it
-        // has been submitted, and a frame can be drawn more than once between two ticks
-        engine.graphics.on.preRender.add(this.#draw);
-    }
-
-    shutdown() {
-        const engine = this.editor.engine;
-
-        engine.graphics.on.preRender.remove(this.#draw);
-
-        this.#bounds = null;
-    }
-}
+import { assert } from "../src/core/assert.js";
+import { Gizmo } from "../src/engine/graphics/render/gizmo/Gizmo.js";
+import { entity_world_bounds_reader } from "./entity_world_bounds.js";
+
+/**
+ * The colour a selection is drawn in, RGBA. Yellow, which is what the three `BoxHelper` this
+ * replaces defaulted to — the editor is not asking for a new language, only for a new backend.
+ *
+ * @type {number[]}
+ */
+const SELECTION_COLOR = [1, 1, 0, 1];
+
+/**
+ * @type {Float32Array}
+ */
+const scratch_bounds = new Float32Array(6);
+
+/**
+ * @type {Float32Array}
+ */
+const scratch_center = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const scratch_size = new Float32Array(3);
+
+/**
+ * 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 {
+    /**
+     * @type {Editor}
+     */
+    editor;
+
+    /**
+     * Where an entity is, on the renderer this editor attached to. Resolved on {@link startup},
+     * because the engine is not known when the editor is built.
+     *
+     * @type {function(ArrayLike<number>, number): boolean|null}
+     */
+    #bounds = null;
+
+    /**
+     * @type {function}
+     */
+    #draw;
+
+    /**
+     * @param {Editor} editor
+     */
+    constructor(editor) {
+        assert.defined(editor, 'editor');
+
+        this.editor = editor;
+
+        this.#draw = () => this.#record();
+    }
+
+    /**
+     * Record this frame's selection.
+     */
+    #record() {
+        const selection = this.editor.selection;
+        const bounds = this.#bounds;
+
+        Gizmo.color = SELECTION_COLOR;
+
+        for (let i = 0; i < selection.length; i++) {
+            const entity = selection.get(i);
+
+            if (!bounds(scratch_bounds, entity)) {
+                // no model, or one that has not loaded — there is nothing to put a box around
+                continue;
+            }
+
+            scratch_center[0] = (scratch_bounds[0] + scratch_bounds[3]) / 2;
+            scratch_center[1] = (scratch_bounds[1] + scratch_bounds[4]) / 2;
+            scratch_center[2] = (scratch_bounds[2] + scratch_bounds[5]) / 2;
+
+            scratch_size[0] = scratch_bounds[3] - scratch_bounds[0];
+            scratch_size[1] = scratch_bounds[4] - scratch_bounds[1];
+            scratch_size[2] = scratch_bounds[5] - scratch_bounds[2];
+
+            Gizmo.draw_wire_cube(scratch_center, scratch_size);
+        }
+    }
+
+    startup() {
+        const engine = this.editor.engine;
+
+        this.#bounds = entity_world_bounds_reader(engine);
+
+        // per frame rather than per tick: the recording is cleared once the frame that consumed it
+        // has been submitted, and a frame can be drawn more than once between two ticks
+        engine.graphics.on.preRender.add(this.#draw);
+    }
+
+    shutdown() {
+        const engine = this.editor.engine;
+
+        engine.graphics.on.preRender.remove(this.#draw);
+
+        this.#bounds = null;
+    }
+}

package/editor/entity_world_bounds.js

@@ -1,27 +1,27 @@
-import { assert } from "../src/core/assert.js";
-import { MeshSystem3 } from "../src/engine/graphics3/MeshSystem3.js";
-
-/**
- * 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 MeshSystem3}. 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) {
-    assert.defined(engine, 'engine');
-
-    const meshes = engine.entityManager.getSystem(MeshSystem3);
-
-    assert.notNull(meshes, 'MeshSystem3');
-
-    return (target, entity) => meshes.compute_world_bounds(target, entity);
-}
+import { assert } from "../src/core/assert.js";
+import { MeshSystem } from "../src/engine/graphics3/MeshSystem.js";
+
+/**
+ * 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) {
+    assert.defined(engine, 'engine');
+
+    const meshes = engine.entityManager.getSystem(MeshSystem);
+
+    assert.notNull(meshes, 'MeshSystem');
+
+    return (target, entity) => meshes.compute_world_bounds(target, entity);
+}

package/editor/particles/rebuildParticleEmitter.js

@@ -1,31 +1,31 @@
-import {
-    ParticleEmitter
-} from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleEmitterSystem3 } from "../../src/engine/graphics3/ParticleEmitterSystem3.js";
-
-/**
- * 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, entity) {
-    const system = entityManager.getSystem(ParticleEmitterSystem3);
-
-    if (system === null) {
-        return false;
-    }
-
-    const emitter = entityManager.dataset.getComponent(entity, ParticleEmitter);
-
-    if (emitter === undefined) {
-        return false;
-    }
-
-    system.rebuild(emitter);
-
-    return true;
-}
+import {
+    ParticleEmitter
+} from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { ParticleEmitterSystem } from "../../src/engine/graphics3/ParticleEmitterSystem.js";
+
+/**
+ * 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, entity) {
+    const system = entityManager.getSystem(ParticleEmitterSystem);
+
+    if (system === null) {
+        return false;
+    }
+
+    const emitter = entityManager.dataset.getComponent(entity, ParticleEmitter);
+
+    if (emitter === undefined) {
+        return false;
+    }
+
+    system.rebuild(emitter);
+
+    return true;
+}

package/editor/process/SymbolicDisplayProcess.js

@@ -27,7 +27,7 @@ import {
  * 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 `DebugDrawSystem3` turns them into pixels.
+ * in {@link Gizmo}, and `DebugDrawSystem` turns them into pixels.
  */
 class SymbolicDisplayProcess extends EditorProcess {
     name = SymbolicDisplayProcess.Id;