@woosh/meep-engine 3.11.3 → 3.12.0

package/editor/prototypeEditorShell.js

@@ -1,156 +1,156 @@
-import './style/editor.scss';
-
-import Vector2 from "../src/core/geom/Vector2.js";
-import { GameAssetType } from "../src/engine/asset/GameAssetType.js";
-import { ArrayBufferLoader } from "../src/engine/asset/loaders/ArrayBufferLoader.js";
-import {
-    GLTFSceneBundleAssetLoader
-} from "../src/engine/asset/loaders/GLTFSceneBundleAssetLoader.js";
-import { ImageBitmapAssetLoader } from "../src/engine/asset/loaders/image/ImageBitmapAssetLoader.js";
-import { ImageRGBADataLoader } from "../src/engine/asset/loaders/image/ImageRGBADataLoader.js";
-import { load_model_scene_bundle } from "../src/engine/asset/load_model_scene_bundle.js";
-import { ParentEntitySystem } from "../src/engine/ecs/parent/ParentEntitySystem.js";
-import { obtainTerrain } from "../src/engine/ecs/terrain/util/obtainTerrain.js";
-import { populateEngineSerializationRegistry } from "../src/engine/ecs/storage/populateEngineSerializationRegistry.js";
-import { TransformAttachmentSystem } from "../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js";
-import { EngineHarness } from "../src/engine/EngineHarness.js";
-import TopDownCameraController from "../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
-import { DebugDrawSystem3 } from "../src/engine/graphics3/DebugDrawSystem3.js";
-import { MeshSystem3 } from "../src/engine/graphics3/MeshSystem3.js";
-import {
-    ShadedGeometrySystem3
-} from "../src/engine/graphics3/ShadedGeometrySystem3.js";
-import { ParticleEmitterSystem3 } from "../src/engine/graphics3/ParticleEmitterSystem3.js";
-import { enableEditor } from "./enableEditor.js";
-
-/**
- * Point the camera at the middle of the terrain, standing off by its own extent.
- *
- * The harness anchors terrain at the world origin and aims the camera at the origin too,
- * so the default view sits on the terrain's corner with three quadrants of empty space —
- * and every orbit pivots on that corner. The editor camera inherits this state when it
- * takes over the scene's active camera.
- *
- * Standing off by the terrain's extent frames most of it while keeping the far corners
- * inside the camera's clip range; the rest is a wheel away.
- *
- * @param {Engine} engine
- * @param {Terrain} terrain
- */
-function frameTerrain(engine, terrain) {
-    const world_x = terrain.size.x * terrain.gridScale;
-    const world_y = terrain.size.y * terrain.gridScale;
-
-    engine.entityManager.dataset.traverseComponents(TopDownCameraController, controller => {
-        controller.target.set(world_x / 2, 0, world_y / 2);
-        controller.distance = Math.max(world_x, world_y);
-    });
-}
-
-/**
- * The model loaders — the same split the game's graphics profile makes, and for the same reason: a
- * model is the one asset whose loaded form *is* the renderer's own representation.
- *
- * @param {EngineConfiguration} config
- */
-function addModelLoaders(config) {
-    const loader = new GLTFSceneBundleAssetLoader();
-
-    config.addLoader(GameAssetType.ModelGLTF, loader);
-    config.addLoader(GameAssetType.ModelGLTF_JSON, loader);
-
-    // `load_gltf` asks the asset manager for each of a model's images rather than fetching them
-    // itself (D34), so a shell without this loader loads geometry and no textures
-    config.addLoader(GameAssetType.ImageBitmap, new ImageBitmapAssetLoader());
-}
-
-/**
- * The systems that talk to the renderer.
- *
- * @param {Engine} engine
- * @returns {Promise}
- */
-async function addGraphicsSystems(engine) {
-    const em = engine.entityManager;
-
-    await em.addSystem(new MeshSystem3(
-        engine.graphics,
-        EngineHarness.shadeScene(engine),
-        url => load_model_scene_bundle(engine.assetManager, url)
-    ));
-
-    // a model with neither skin nor clip becomes entities, and its primitives are drawn by the
-    // system that owns primitives (D47)
-    await em.addSystem(new ShadedGeometrySystem3(engine.graphics, EngineHarness.shadeScene(engine)));
-
-    await em.addSystem(new ParticleEmitterSystem3(engine.graphics, engine.assetManager));
-
-    // the editor's selection box is the debug-draw pass's first consumer (V5)
-    await em.addSystem(new DebugDrawSystem3(engine.graphics));
-}
-
-/**
- * Standalone editor shell harness: engine + terrain + lights + camera, the systems the
- * editor tooling relies on, a seeded mesh library, and the editor enabled from the start.
- *
- * @returns {Promise<{engine: Engine, editor: Editor, editorControl: object, terrain: Terrain}>}
- */
-async function main() {
-    const harness = new EngineHarness();
-
-    const engine = await harness.initialize({
-        configuration(config) {
-            addModelLoaders(config);
-
-            config.addLoader(GameAssetType.ArrayBuffer, new ArrayBufferLoader());
-            config.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
-        }
-    });
-
-    populateEngineSerializationRegistry(engine.binarySerializationRegistry);
-
-    const em = engine.entityManager;
-
-    await addGraphicsSystems(engine);
-
-    await em.addSystem(new TransformAttachmentSystem(engine));
-    await em.addSystem(new ParentEntitySystem());
-
-    await EngineHarness.buildBasics({
-        engine,
-        terrainSize: new Vector2(32, 32),
-        enableWater: false,
-        cameraController: false,
-        pitch: 0.9
-    });
-
-    // the default terrain has a 1x1 height sampler; height painting needs real resolution
-    const terrain = obtainTerrain(engine.entityManager.dataset);
-    terrain.samplerHeight.resize(256, 256);
-    terrain.updateHeights();
-
-    frameTerrain(engine, terrain);
-
-    const editorControl = enableEditor(engine);
-
-    const editor = editorControl.editor;
-
-    // console access for debugging, mirrors the window.engine convention
-    window.editor = editor;
-
-    editor.meshLibrary.add('data/models/samples/susanne.glb');
-    editor.meshLibrary.add('data/models/samples/teapot.gltf');
-    editor.meshLibrary.add('data/models/samples/textured_unit_cube.gltf');
-
-    editorControl.enable();
-
-    return { engine, editor, editorControl, terrain };
-}
-
-/**
- * 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 = main();
+import './style/editor.scss';
+
+import Vector2 from "../src/core/geom/Vector2.js";
+import { GameAssetType } from "../src/engine/asset/GameAssetType.js";
+import { ArrayBufferLoader } from "../src/engine/asset/loaders/ArrayBufferLoader.js";
+import {
+    GLTFSceneBundleAssetLoader
+} from "../src/engine/asset/loaders/GLTFSceneBundleAssetLoader.js";
+import { ImageBitmapAssetLoader } from "../src/engine/asset/loaders/image/ImageBitmapAssetLoader.js";
+import { ImageRGBADataLoader } from "../src/engine/asset/loaders/image/ImageRGBADataLoader.js";
+import { load_model_scene_bundle } from "../src/engine/asset/load_model_scene_bundle.js";
+import { ParentEntitySystem } from "../src/engine/ecs/parent/ParentEntitySystem.js";
+import { obtainTerrain } from "../src/engine/ecs/terrain/util/obtainTerrain.js";
+import { populateEngineSerializationRegistry } from "../src/engine/ecs/storage/populateEngineSerializationRegistry.js";
+import { TransformAttachmentSystem } from "../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js";
+import { EngineHarness } from "../src/engine/EngineHarness.js";
+import TopDownCameraController from "../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+import { DebugDrawSystem } from "../src/engine/graphics3/DebugDrawSystem.js";
+import { MeshSystem } from "../src/engine/graphics3/MeshSystem.js";
+import {
+    ShadedGeometrySystem
+} from "../src/engine/graphics3/ShadedGeometrySystem.js";
+import { ParticleEmitterSystem } from "../src/engine/graphics3/ParticleEmitterSystem.js";
+import { enableEditor } from "./enableEditor.js";
+
+/**
+ * Point the camera at the middle of the terrain, standing off by its own extent.
+ *
+ * The harness anchors terrain at the world origin and aims the camera at the origin too,
+ * so the default view sits on the terrain's corner with three quadrants of empty space —
+ * and every orbit pivots on that corner. The editor camera inherits this state when it
+ * takes over the scene's active camera.
+ *
+ * Standing off by the terrain's extent frames most of it while keeping the far corners
+ * inside the camera's clip range; the rest is a wheel away.
+ *
+ * @param {Engine} engine
+ * @param {Terrain} terrain
+ */
+function frameTerrain(engine, terrain) {
+    const world_x = terrain.size.x * terrain.gridScale;
+    const world_y = terrain.size.y * terrain.gridScale;
+
+    engine.entityManager.dataset.traverseComponents(TopDownCameraController, controller => {
+        controller.target.set(world_x / 2, 0, world_y / 2);
+        controller.distance = Math.max(world_x, world_y);
+    });
+}
+
+/**
+ * The model loaders — the same split the game's graphics profile makes, and for the same reason: a
+ * model is the one asset whose loaded form *is* the renderer's own representation.
+ *
+ * @param {EngineConfiguration} config
+ */
+function addModelLoaders(config) {
+    const loader = new GLTFSceneBundleAssetLoader();
+
+    config.addLoader(GameAssetType.ModelGLTF, loader);
+    config.addLoader(GameAssetType.ModelGLTF_JSON, loader);
+
+    // `load_gltf` asks the asset manager for each of a model's images rather than fetching them
+    // itself (D34), so a shell without this loader loads geometry and no textures
+    config.addLoader(GameAssetType.ImageBitmap, new ImageBitmapAssetLoader());
+}
+
+/**
+ * The systems that talk to the renderer.
+ *
+ * @param {Engine} engine
+ * @returns {Promise}
+ */
+async function addGraphicsSystems(engine) {
+    const em = engine.entityManager;
+
+    await em.addSystem(new MeshSystem(
+        engine.graphics,
+        EngineHarness.shadeScene(engine),
+        url => load_model_scene_bundle(engine.assetManager, url)
+    ));
+
+    // a model with neither skin nor clip becomes entities, and its primitives are drawn by the
+    // system that owns primitives (D47)
+    await em.addSystem(new ShadedGeometrySystem(engine.graphics, EngineHarness.shadeScene(engine)));
+
+    await em.addSystem(new ParticleEmitterSystem(engine.graphics, engine.assetManager));
+
+    // the editor's selection box is the debug-draw pass's first consumer (V5)
+    await em.addSystem(new DebugDrawSystem(engine.graphics));
+}
+
+/**
+ * Standalone editor shell harness: engine + terrain + lights + camera, the systems the
+ * editor tooling relies on, a seeded mesh library, and the editor enabled from the start.
+ *
+ * @returns {Promise<{engine: Engine, editor: Editor, editorControl: object, terrain: Terrain}>}
+ */
+async function main() {
+    const harness = new EngineHarness();
+
+    const engine = await harness.initialize({
+        configuration(config) {
+            addModelLoaders(config);
+
+            config.addLoader(GameAssetType.ArrayBuffer, new ArrayBufferLoader());
+            config.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
+        }
+    });
+
+    populateEngineSerializationRegistry(engine.binarySerializationRegistry);
+
+    const em = engine.entityManager;
+
+    await addGraphicsSystems(engine);
+
+    await em.addSystem(new TransformAttachmentSystem(engine));
+    await em.addSystem(new ParentEntitySystem());
+
+    await EngineHarness.buildBasics({
+        engine,
+        terrainSize: new Vector2(32, 32),
+        enableWater: false,
+        cameraController: false,
+        pitch: 0.9
+    });
+
+    // the default terrain has a 1x1 height sampler; height painting needs real resolution
+    const terrain = obtainTerrain(engine.entityManager.dataset);
+    terrain.samplerHeight.resize(256, 256);
+    terrain.updateHeights();
+
+    frameTerrain(engine, terrain);
+
+    const editorControl = enableEditor(engine);
+
+    const editor = editorControl.editor;
+
+    // console access for debugging, mirrors the window.engine convention
+    window.editor = editor;
+
+    editor.meshLibrary.add('data/models/samples/susanne.glb');
+    editor.meshLibrary.add('data/models/samples/teapot.gltf');
+    editor.meshLibrary.add('data/models/samples/textured_unit_cube.gltf');
+
+    editorControl.enable();
+
+    return { engine, editor, editorControl, terrain };
+}
+
+/**
+ * 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 = main();

package/editor/selection/editor_pick.js

@@ -1,130 +1,130 @@
-import { assert } from "../../src/core/assert.js";
-import {
-    aabb3_array_intersects_clipping_volume_array
-} from "../../src/core/geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
-import {
-    aabb3_ray_segment_entry_distance
-} from "../../src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
-import { Transform } from "../../src/engine/ecs/transform/Transform.js";
-import EditorEntity from "../ecs/EditorEntity.js";
-
-/**
- * @type {Float64Array}
- */
-const bounds = new Float64Array(6);
-
-/**
- * What the editor's pointer and marquee search, and why it is not the game's picking index.
- *
- * `PickingSystem3` 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, read_bounds, origin, direction, max_distance) {
-    assert.defined(dataset, 'dataset');
-    assert.isFunction(read_bounds, 'read_bounds');
-    assert.isNumber(max_distance, 'max_distance');
-
-    const origin_x = origin.x;
-    const origin_y = origin.y;
-    const origin_z = origin.z;
-
-    // a zero component produces an infinity the entry-distance test handles, which is why this is
-    // computed rather than guarded
-    const inv_x = 1 / direction.x;
-    const inv_y = 1 / direction.y;
-    const inv_z = 1 / direction.z;
-
-    let best_distance = max_distance;
-    let best_entity = -1;
-
-    dataset.traverseEntities([Transform], (transform, entity) => {
-        if (dataset.hasComponent(entity, EditorEntity)) {
-            return;
-        }
-
-        if (!read_bounds(bounds, entity)) {
-            return;
-        }
-
-        const distance = aabb3_ray_segment_entry_distance(
-            bounds[0], bounds[1], bounds[2],
-            bounds[3], bounds[4], bounds[5],
-            origin_x, origin_y, origin_z,
-            inv_x, inv_y, inv_z,
-            0, max_distance
-        );
-
-        if (distance >= best_distance) {
-            return;
-        }
-
-        best_distance = distance;
-        best_entity = entity;
-    });
-
-    return best_entity;
-}
-
-/**
- * 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, dataset, read_bounds, planes, plane_count) {
-    assert.defined(result, 'result');
-    assert.defined(dataset, 'dataset');
-    assert.isFunction(read_bounds, 'read_bounds');
-    assert.isNonNegativeInteger(plane_count, 'plane_count');
-
-    let count = 0;
-
-    dataset.traverseEntities([Transform], (transform, entity) => {
-        if (dataset.hasComponent(entity, EditorEntity)) {
-            return;
-        }
-
-        if (!read_bounds(bounds, entity)) {
-            return;
-        }
-
-        if (!aabb3_array_intersects_clipping_volume_array(bounds, 0, planes, 0, plane_count)) {
-            return;
-        }
-
-        result[count] = entity;
-
-        count++;
-    });
-
-    return count;
-}
+import { assert } from "../../src/core/assert.js";
+import {
+    aabb3_array_intersects_clipping_volume_array
+} from "../../src/core/geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
+import {
+    aabb3_ray_segment_entry_distance
+} from "../../src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
+import { Transform } from "../../src/engine/ecs/transform/Transform.js";
+import EditorEntity from "../ecs/EditorEntity.js";
+
+/**
+ * @type {Float64Array}
+ */
+const bounds = new Float64Array(6);
+
+/**
+ * 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, read_bounds, origin, direction, max_distance) {
+    assert.defined(dataset, 'dataset');
+    assert.isFunction(read_bounds, 'read_bounds');
+    assert.isNumber(max_distance, 'max_distance');
+
+    const origin_x = origin.x;
+    const origin_y = origin.y;
+    const origin_z = origin.z;
+
+    // a zero component produces an infinity the entry-distance test handles, which is why this is
+    // computed rather than guarded
+    const inv_x = 1 / direction.x;
+    const inv_y = 1 / direction.y;
+    const inv_z = 1 / direction.z;
+
+    let best_distance = max_distance;
+    let best_entity = -1;
+
+    dataset.traverseEntities([Transform], (transform, entity) => {
+        if (dataset.hasComponent(entity, EditorEntity)) {
+            return;
+        }
+
+        if (!read_bounds(bounds, entity)) {
+            return;
+        }
+
+        const distance = aabb3_ray_segment_entry_distance(
+            bounds[0], bounds[1], bounds[2],
+            bounds[3], bounds[4], bounds[5],
+            origin_x, origin_y, origin_z,
+            inv_x, inv_y, inv_z,
+            0, max_distance
+        );
+
+        if (distance >= best_distance) {
+            return;
+        }
+
+        best_distance = distance;
+        best_entity = entity;
+    });
+
+    return best_entity;
+}
+
+/**
+ * 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, dataset, read_bounds, planes, plane_count) {
+    assert.defined(result, 'result');
+    assert.defined(dataset, 'dataset');
+    assert.isFunction(read_bounds, 'read_bounds');
+    assert.isNonNegativeInteger(plane_count, 'plane_count');
+
+    let count = 0;
+
+    dataset.traverseEntities([Transform], (transform, entity) => {
+        if (dataset.hasComponent(entity, EditorEntity)) {
+            return;
+        }
+
+        if (!read_bounds(bounds, entity)) {
+            return;
+        }
+
+        if (!aabb3_array_intersects_clipping_volume_array(bounds, 0, planes, 0, plane_count)) {
+            return;
+        }
+
+        result[count] = entity;
+
+        count++;
+    });
+
+    return count;
+}