@woosh/meep-engine 3.23.0 → 3.24.0

package/src/shade/playground/basis_textures/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/basis_textures/main.js"],"names":[],"mappings":"AA4FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA8PzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/basis_textures/main.js"],"names":[],"mappings":"AAmGA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAqQzB"}

package/src/shade/playground/basis_textures/main.js

@@ -5,6 +5,8 @@ import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraCont
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { place_light } from "../../renderer/light/place_light.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
 import { load_gltf } from "../../renderer/loader/gltf/load_gltf.js";
 import { Renderer } from "../../renderer/Renderer.js";
 import { Scene } from "../../renderer/scene/Scene.js";
@@ -12,6 +14,11 @@ import { gpu_texture_compression_support } from "../../renderer/texture/format/g
 import { load_default_environment } from "../load_default_environment.js";
 import { make_playground_asset_manager } from "../make_playground_asset_manager.js";
 import { texture_inventory } from "./texture_inventory.js";
+import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { prefab_compile } from "../../../engine/graphics3/prefab/prefab_compile.js";
+import { prefab_place, prefab_unplace } from "../../../engine/graphics3/prefab/prefab_place.js";
+import { shade_bundle_bounds } from "../../../engine/graphics3/shade_bundle_bounds.js";
 
 /**
  * The same scene, once as JPEG and once as KTX2/Basis, with the VRAM each costs.
@@ -145,8 +152,11 @@ export async function start() {
 
     const scene = new Scene();
 
+    // the sun stands at an entity, so the scene names a dataset for it
+    scene.dataset = new EntityComponentDataset();
+
     // Sponza carries no light of its own, and an unlit scene tells you nothing about a texture.
-    scene.lights.add(make_sunlight({ intensity: 7.2 }));
+    place_light(scene, make_sunlight({ intensity: 7.2 }));
 
     // document.body rather than the canvas: the controller starts a keyboard device, and only a
     // focusable element can receive key events — body carries tabindex for exactly that.
@@ -171,7 +181,8 @@ export async function start() {
      *
      * @type {Node3D[]}
      */
-    let loaded_roots = [];
+    /** @type {ReturnType<typeof prefab_place>|null} the model on the screen */
+    let loaded = null;
 
     /**
      * Load one variant into an emptied scene and record what its textures cost.
@@ -184,8 +195,10 @@ export async function start() {
     async function measure(label, url, texture_support) {
         set_status(`loading ${label}…`);
 
-        scene.remove(loaded_roots);
-        loaded_roots = [];
+        if (loaded !== null) {
+            prefab_unplace(renderer.scenes.obtain(scene), scene.dataset, loaded);
+            loaded = null;
+        }
 
         const started = performance.now();
 
@@ -208,10 +221,11 @@ export async function start() {
 
         const load_ms = performance.now() - started;
 
-        scene.add(bundle.scenes);
-        loaded_roots = bundle.scenes;
+        loaded = prefab_place(renderer.scenes.obtain(scene), scene.dataset, prefab_compile(bundle), new Transform64());
+
+        const bounds = new AABB3();
 
-        const bounds = scene.instances.bounding_box;
+        shade_bundle_bounds(bounds, bundle);
 
         camera_frame_sphere(
             controller,
@@ -221,7 +235,7 @@ export async function start() {
 
         controller.movement_speed_scale = Math.max(bounds.width, bounds.height, bounds.depth) * 0.1;
 
-        const inventory = texture_inventory(bundle.scenes);
+        const inventory = texture_inventory(bundle.nodes);
 
         /*
          Upload every texture explicitly rather than letting the first frame do it.

package/src/shade/playground/basis_textures/texture_inventory.d.ts

@@ -11,13 +11,13 @@
  * silently disagree the moment a mip chain is generated on the device rather than shipped. This says
  * *what* is resident; the manager says what it costs.
  *
- * @param {Node3D[]} roots
+ * @param {SceneNode[]} nodes a bundle's nodes
  * @returns {{count: number, formats: Map<string, {count: number, slots: Set<string>}>, textures: ShadeTexture[]}}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function texture_inventory(roots: Node3D[]): {
+export function texture_inventory(nodes: SceneNode[]): {
     count: number;
     formats: Map<string, {
         count: number;

package/src/shade/playground/basis_textures/texture_inventory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_inventory.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/basis_textures/texture_inventory.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCANW,QAAQ,GACN;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,MAAM,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,IAAI,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAC,CAgEhH"}
+{"version":3,"file":"texture_inventory.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/basis_textures/texture_inventory.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCANW,WAAW,GACT;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,MAAM,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,IAAI,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAC,CA+DhH"}

package/src/shade/playground/basis_textures/texture_inventory.js

@@ -30,24 +30,23 @@ const SLOTS = [
  * silently disagree the moment a mip chain is generated on the device rather than shipped. This says
  * *what* is resident; the manager says what it costs.
  *
- * @param {Node3D[]} roots
+ * @param {SceneNode[]} nodes a bundle's nodes
  * @returns {{count: number, formats: Map<string, {count: number, slots: Set<string>}>, textures: ShadeTexture[]}}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function texture_inventory(roots) {
+export function texture_inventory(nodes) {
     const formats = new Map();
-
     const images = new Set();
     const textures = new Set();
 
-    for (const root of roots) {
-        root.traverse(node => {
+    for (const node of nodes) {
+        {
             const material = node.material;
 
             if (material === undefined || material === null) {
-                return;
+                continue;
             }
 
             for (const [slot, role] of SLOTS) {
@@ -91,7 +90,7 @@ export function texture_inventory(roots) {
 
                 formats.set(format, entry);
             }
-        });
+        }
     }
 
     return { count: images.size, formats, textures: [...textures] };

package/src/shade/playground/ground_seam/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/main.js"],"names":[],"mappings":"AAiEA,uCA6yBC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/main.js"],"names":[],"mappings":"AAoEA,uCAmzBC"}

package/src/shade/playground/ground_seam/main.js

@@ -3,11 +3,14 @@ import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { place_light } from "../../renderer/light/place_light.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
 import { Renderer } from "../../renderer/Renderer.js";
 import { Scene } from "../../renderer/scene/Scene.js";
 import { load_default_environment } from "../load_default_environment.js";
 import { make_grid_texture } from "./make_grid_texture.js";
 import { GROUND_TRIANGULATION, make_ground } from "./make_ground.js";
+import { remove_primitive } from "../../renderer/scene/rows/place_primitive.js";
 import { FramePhase } from "../../renderer/extension/FramePhase.js";
 import { CaptureSceneColor } from "./capture_scene_color.js";
 import { depth_step_across_seam } from "./depth_step_across_seam.js";
@@ -111,13 +114,19 @@ export async function start() {
 
     const scene = new Scene();
 
+    // the sun stands at an entity, so the scene names a dataset for it
+    scene.dataset = new EntityComponentDataset();
+
+    // the scene's rows are on the renderer's context for it: where the ground goes
+    const scene_context = renderer.scenes.obtain(scene);
+
     const sun = make_sunlight({
         intensity: 0.9,
         direction: new Vector3(0.17, -1, 0.17),
         temperature: 5500,
     });
 
-    scene.lights.add(sun);
+    place_light(scene, sun);
 
     /**
      * Two textures differing only in whether the sampler is granted anisotropy, built up front so
@@ -132,6 +141,7 @@ export async function start() {
     };
 
     /** @type {Mesh|undefined} */
+    /** @type {{entity: number, geometry: MeshletGeometry}|undefined} */
     let ground;
 
     /**
@@ -149,10 +159,10 @@ export async function start() {
      */
     function rebuild_ground(segments, triangulation, yaw_degrees = 0, anisotropy = true, extent = 425) {
         if (ground !== undefined) {
-            scene.remove(ground);
+            remove_primitive(scene_context, ground.entity);
         }
 
-        ground = make_ground({
+        ground = make_ground(scene_context, {
             albedo: albedos[anisotropy ? 'anisotropic' : 'isotropic'],
             extent,
             segments,
@@ -160,7 +170,6 @@ export async function start() {
             yaw_degrees,
         });
 
-        scene.add(ground);
 
         /*
          Proof the index buffer actually reached the GPU differently, published so a null result on

package/src/shade/playground/ground_seam/make_ground.d.ts

@@ -13,6 +13,7 @@ export function uv_scale_for(extent: number): number;
 /**
  * The ground plane, and nothing else — the brief's scene reproduces with this alone.
  *
+ * @param {GPUSceneContext} scene_context the scene's context — its rows are where the ground goes
  * @param {object} options
  * @param {ShadeTexture} options.albedo
  * @param {number} [options.extent] edge length of the quad in world units. Bigger is worse
@@ -25,9 +26,10 @@ export function uv_scale_for(extent: number): number;
  * @param {number} [options.yaw_degrees] rotation about +Y, applied after the quad is laid flat
  * @param {number} [options.roughness]
  * @param {number} [options.metallic]
- * @returns {Mesh}
+ * @returns {{entity: number, geometry: MeshletGeometry}} the ground's entity, and the meshlets it
+ *          draws — the index order a triangulation A/B has to be able to prove reached the GPU
  */
-export function make_ground({ albedo, segments, indices, extent, yaw_degrees, roughness, metallic, }: {
+export function make_ground(scene_context: GPUSceneContext, { albedo, segments, indices, extent, yaw_degrees, roughness, metallic, }: {
     albedo: ShadeTexture;
     extent?: number;
     segments?: number;
@@ -35,7 +37,13 @@ export function make_ground({ albedo, segments, indices, extent, yaw_degrees, ro
     yaw_degrees?: number;
     roughness?: number;
     metallic?: number;
-}): Mesh;
+}): {
+    entity: number;
+    geometry: MeshletGeometry;
+};
+/**
+ * @typedef {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
 /**
  * Edge length of the ground quad, in world units.
  * @type {number}
@@ -66,5 +74,6 @@ export namespace GROUND_TRIANGULATION {
     export let flipped: number[];
     export let rotated: number[];
 }
-import { Mesh } from "../../renderer/scene/Mesh.js";
+export type GPUSceneContext = import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext;
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
 //# sourceMappingURL=make_ground.d.ts.map

package/src/shade/playground/ground_seam/make_ground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_ground.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/make_ground.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;GAUG;AACH,qCAHW,MAAM,GACJ,MAAM,CAIlB;AAyCD;;;;;;;;;;;;;;;;GAgBG;AACH;IAbiC,MAAM;IACX,MAAM,GAAvB,MAAM;IAKW,QAAQ,GAAzB,MAAM;IACa,OAAO,GAA1B,MAAM,EAAE;IACS,WAAW,GAA5B,MAAM;IACW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACJ,IAAI,CA2EhB;AAtJD;;;GAGG;AACH,4BAFU,MAAM,CAEiB;;;;;;;;;;;;;;;;;;;mCAmCvB,MAAM,EAAE;;;;;;;qBAzCG,8BAA8B"}
+{"version":3,"file":"make_ground.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/make_ground.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;GAUG;AACH,qCAHW,MAAM,GACJ,MAAM,CAIlB;AAyCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CAhBW,eAAe;IAEO,MAAM;IACX,MAAM,GAAvB,MAAM;IAKW,QAAQ,GAAzB,MAAM;IACa,OAAO,GAA1B,MAAM,EAAE;IACS,WAAW,GAA5B,MAAM;IACW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAC,CA0EvD;AA1JD;;GAEG;AAEH;;;GAGG;AACH,4BAFU,MAAM,CAEiB;;;;;;;;;;;;;;;;;;;mCAmCvB,MAAM,EAAE;;;;;;;8BA1CL,OAAO,yCAAyC,EAAE,eAAe;gCAR9C,4CAA4C"}

package/src/shade/playground/ground_seam/make_ground.js

@@ -6,7 +6,12 @@ import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
 import { make_plane_geometry } from "../../renderer/geometry/primitives/make_plane_geometry.js";
 import { StandardAttributes } from "../../renderer/geometry/StandardAttributes.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
-import { Mesh } from "../../renderer/scene/Mesh.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { place_primitive } from "../../renderer/scene/rows/place_primitive.js";
+
+/**
+ * @typedef {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
 
 /**
  * Edge length of the ground quad, in world units.
@@ -71,6 +76,7 @@ export const GROUND_TRIANGULATION = {
 /**
  * The ground plane, and nothing else — the brief's scene reproduces with this alone.
  *
+ * @param {GPUSceneContext} scene_context the scene's context — its rows are where the ground goes
  * @param {object} options
  * @param {ShadeTexture} options.albedo
  * @param {number} [options.extent] edge length of the quad in world units. Bigger is worse
@@ -83,9 +89,10 @@ export const GROUND_TRIANGULATION = {
  * @param {number} [options.yaw_degrees] rotation about +Y, applied after the quad is laid flat
  * @param {number} [options.roughness]
  * @param {number} [options.metallic]
- * @returns {Mesh}
+ * @returns {{entity: number, geometry: MeshletGeometry}} the ground's entity, and the meshlets it
+ *          draws — the index order a triangulation A/B has to be able to prove reached the GPU
  */
-export function make_ground({
+export function make_ground(scene_context, {
                                 albedo,
                                 segments = 1,
                                 indices = GROUND_TRIANGULATION.default,
@@ -115,12 +122,9 @@ export function make_ground({
         geometry.index = Attribute.from(new Uint32Array(indices), 1, StandardAttributes.Index);
     }
 
-    const mesh = new Mesh();
+    const meshlets = new MeshletGeometry();
 
-    mesh.name = 'ground';
-    mesh.geometry = new MeshletGeometry();
-
-    meshlet_geometry_build_from_geometry(geometry, mesh.geometry);
+    meshlet_geometry_build_from_geometry(geometry, meshlets);
 
     const material = new StandardShadeMaterial();
 
@@ -128,7 +132,6 @@ export function make_ground({
     material.roughness_factor = roughness;
     material.metallic_factor = metallic;
 
-    mesh.material = material;
 
     /*
      −90° about X lays the plane flat with its normal pointing at +Y.
@@ -140,9 +143,8 @@ export function make_ground({
      stays exactly where it was on screen while the two triangles swap roles, which is the one
      experiment that can tell a property of the *edge* from a property of a *triangle*.
 
-     `Transform64` keeps its matrix by hand, so the write is only real after `updateMatrix`, and the
-     world bounds the `meshes` table publishes only exist after `updateMatrices` — a mesh added on
-     its own is never reached by the scene's hierarchy walk.
+     `Transform64` keeps its matrix by hand, so the write is only real after `updateMatrix`; the
+     placement copies the transform, and the row's bounds are the GPU's to derive from it.
     */
     const rotation = Quaternion.fromAxisAngle(Vector3.right, -Math.PI / 2);
 
@@ -153,9 +155,12 @@ export function make_ground({
         rotation.normalize();
     }
 
-    mesh.transform_local.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
-    mesh.transform_local.updateMatrix();
-    mesh.updateMatrices();
+    const transform = new Transform64();
+
+    transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+    transform.updateMatrix();
+
+    const entity = place_primitive(scene_context, meshlets, material, transform, { name: 'ground' });
 
-    return mesh;
+    return { entity, geometry: meshlets };
 }

package/src/shade/playground/particle_ecs/bonfire_editor.js

@@ -166,9 +166,9 @@ export function install_effect_editor({ dataset, world, sprites, host, selector,
         const entity = entities[name];
 
         /*
-         Removed and added rather than assigned: see the note at the top. The system's `unlink` takes
-         the emitter node out of the scene, which retires its table row and kills the particles that
-         were running the old program; `link` builds a new one on the next comparison.
+         Removed and added rather than assigned: see the note at the top. The system's `unlink`
+         retires the emitter, which frees its table row and kills the particles that were running
+         the old program; `link` builds a new one on the next comparison.
         */
         dataset.removeComponentFromEntity(entity, ParticleEffect);
         dataset.addComponentToEntity(entity, component);

package/src/shade/playground/particle_system/main.js

@@ -85,9 +85,10 @@ async function main() {
     /** @type {import("../../renderer/particles/GPUParticleSystem.js").GPUParticleSystem|null} */
     let system = null;
 
-    const { scene, emitters } = await build_particle_scene();
+    const world = await build_particle_scene();
+    const { scene, emitters } = world;
 
-    Object.assign(globalThis, { camera, controller, scene, emitters });
+    Object.assign(globalThis, { camera, controller, scene, emitters, world });
 
     /**
      * Where the camera is and what it orbits, as plain numbers: enough to put another instance of
@@ -143,13 +144,13 @@ async function main() {
 
     element("burst").addEventListener("click", () => {
         /*
-         A row is assigned when the system sweeps the scene, which happens inside the frame it
-         simulates — so before the first frame the emitter has none and `spawn` refuses. And a burst
-         queued while the particles are switched off is never drained: the ring only empties inside
-         a simulated frame, so the clicks would pile up and arrive together, seconds late, the
-         moment they are switched back on. Both are the same answer: the button does nothing.
+         The emitter has a row from the moment configure_particles registered it, and none before
+         — `spawn` refuses an emitter it does not hold. And a burst queued while the particles are
+         switched off is never drained: the ring only empties inside a simulated frame, so the
+         clicks would pile up and arrive together, seconds late, the moment they are switched back
+         on. Both are the same answer: the button does nothing.
         */
-        if (system === null || !renderer.feature_particles_enabled || emitters.sparks.row === -1) {
+        if (system === null || !renderer.feature_particles_enabled || system.registry.context(emitters.sparks) === undefined) {
             return;
         }
 
@@ -190,7 +191,7 @@ async function main() {
     renderer.feature_automatic_exposure_enabled = false;
     renderer.exposure_compensation = 1.2;
 
-    system = configure_particles(renderer, scene);
+    system = configure_particles(renderer, world);
     globalThis.particles = system;
 
     apply_settings();
@@ -220,7 +221,7 @@ async function main() {
             renderer.resize(width, height);
         }
 
-        animate_particle_scene(emitters, time);
+        animate_particle_scene(world, system, time);
         controller.update();
 
         renderer.render(camera, scene, dt);

package/src/shade/playground/particle_system/particle_prototype.d.ts

@@ -43,22 +43,27 @@ export function smoke_effect(): {
 /**
  * Put a fire + smoke plume in a scene, optionally riding a bone.
  *
- * An emitter is a scene node, so this is scene-graph work and nothing else: build the two emitters,
- * parent them to the bone if there is one, add them to the scene. The particle system finds them
- * on its next frame, gives them rows, and the GPU composes the bone's motion into every particle
- * they spawn — there is no per-frame call to make.
+ * An emitter runs at an entity's row, so this is entity work and nothing else: spawn an entity per
+ * emitter in the scene's dataset — attached to the bone when there is one — give each a row in the
+ * scene context, and register the emitter at it. The GPU composes the bone's motion into every
+ * particle they spawn; there is no per-frame call to make.
  *
- * @param {import("../../renderer/scene/Scene.js").Scene} scene
+ * @param {GPUParticleSystem} particles the scene's particle system; the entities go in its scene
+ *        context's dataset
  * @param {object} [options]
- * @param {import("../../renderer/scene/Node3D.js").Node3D} [options.bone] a node, already in the
- *        scene, for both emitters to hang off
- * @returns {{fire: ParticleEmitter, smoke: ParticleEmitter}}
+ * @param {number} [options.bone] an entity already holding a row in the scene context, for both
+ *        emitters to hang off
+ * @returns {{fire: ParticleEmitter, smoke: ParticleEmitter, entities: {fire: number, smoke: number}}}
  */
-export function register_campfire(scene: import("../../renderer/scene/Scene.js").Scene, { bone }?: {
-    bone?: import("../../renderer/scene/Node3D.js").Node3D;
+export function register_campfire(particles: GPUParticleSystem, { bone }?: {
+    bone?: number;
 }): {
     fire: ParticleEmitter;
     smoke: ParticleEmitter;
+    entities: {
+        fire: number;
+        smoke: number;
+    };
 };
 import { ParticleLayout } from "../../renderer/particles/layout/ParticleLayout.js";
 import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitter.js";

package/src/shade/playground/particle_system/particle_prototype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_prototype.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH;IALsG,UAAU,GAArG,OAAO,iDAAiD,EAAE,sBAAsB;IACW,WAAW,GAAtG,OAAO,iDAAiD,EAAE,sBAAsB;IAC/D,eAAe,GAAhC,MAAM;IACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CA+GrE;AAED;;;;GAIG;AACH,gCAFa;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAYrE;AAED;;;;;;;;;;;;;GAaG;AACH,yCANW,OAAO,+BAA+B,EAAE,KAAK;IAEa,IAAI,GAA9D,OAAO,gCAAgC,EAAE,MAAM;IAE7C;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAC,CAe3D;+BAvL8B,mDAAmD;gCAElD,qDAAqD"}
+{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_prototype.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH;IALsG,UAAU,GAArG,OAAO,iDAAiD,EAAE,sBAAsB;IACW,WAAW,GAAtG,OAAO,iDAAiD,EAAE,sBAAsB;IAC/D,eAAe,GAAhC,MAAM;IACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CA+GrE;AAED;;;;GAIG;AACH,gCAFa;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAYrE;AAED;;;;;;;;;;;;;;GAcG;AACH;IAJ4B,IAAI,GAArB,MAAM;IAEJ;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC,CAkBpG;+BAjM8B,mDAAmD;gCAElD,qDAAqD"}

package/src/shade/playground/particle_system/particle_prototype.js

@@ -9,6 +9,12 @@ import { VM_BUILTIN } from "../../renderer/particles/isa/ParticleVMISA.js";
 import { ParticleLayout } from "../../renderer/particles/layout/ParticleLayout.js";
 import { create_particle_effect } from "../../renderer/particles/runtime/create_particle_effect.js";
 import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitter.js";
+import { row_of_entity } from "../../renderer/scene/rows/GPUSceneRows.js";
+import { GPUStateAuthorityFlags } from "../../../engine/ecs/gpu/GPUStateAuthorityFlags.js";
+import { gpu_authority_declare } from "../../../engine/ecs/gpu/gpu_authority_declare.js";
+import { gpu_authority_grant } from "../../../engine/ecs/gpu/gpu_authority_grant.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { TransformAttachment } from "../../../engine/ecs/transform-attachment/TransformAttachment.js";
 
 /**
  * Worked examples of authoring particle effects with the node graph + placing them in a scene for a
@@ -165,28 +171,63 @@ export function smoke_effect() {
 /**
  * Put a fire + smoke plume in a scene, optionally riding a bone.
  *
- * An emitter is a scene node, so this is scene-graph work and nothing else: build the two emitters,
- * parent them to the bone if there is one, add them to the scene. The particle system finds them
- * on its next frame, gives them rows, and the GPU composes the bone's motion into every particle
- * they spawn — there is no per-frame call to make.
+ * An emitter runs at an entity's row, so this is entity work and nothing else: spawn an entity per
+ * emitter in the scene's dataset — attached to the bone when there is one — give each a row in the
+ * scene context, and register the emitter at it. The GPU composes the bone's motion into every
+ * particle they spawn; there is no per-frame call to make.
  *
- * @param {import("../../renderer/scene/Scene.js").Scene} scene
+ * @param {GPUParticleSystem} particles the scene's particle system; the entities go in its scene
+ *        context's dataset
  * @param {object} [options]
- * @param {import("../../renderer/scene/Node3D.js").Node3D} [options.bone] a node, already in the
- *        scene, for both emitters to hang off
- * @returns {{fire: ParticleEmitter, smoke: ParticleEmitter}}
+ * @param {number} [options.bone] an entity already holding a row in the scene context, for both
+ *        emitters to hang off
+ * @returns {{fire: ParticleEmitter, smoke: ParticleEmitter, entities: {fire: number, smoke: number}}}
  */
-export function register_campfire(scene, { bone } = {}) {
+export function register_campfire(particles, { bone = -1 } = {}) {
+    const scene_context = particles.scene_context;
+    const dataset = scene_context.scene.dataset;
+
     const fire = ParticleEmitter.from({ ...fire_effect().emitter, name: "fire" });
     const smoke = ParticleEmitter.from({ ...smoke_effect().emitter, name: "smoke" });
 
-    if (bone !== undefined) {
-        bone.addChild(fire);
-        bone.addChild(smoke);
-        bone.updateMatrices();
+    const entities = {
+        fire: place(dataset, scene_context, bone),
+        smoke: place(dataset, scene_context, bone),
+    };
+
+    particles.add_emitter(fire, row_of_entity(entities.fire));
+    particles.add_emitter(smoke, row_of_entity(entities.smoke));
+
+    return { fire, smoke, entities };
+}
+
+/**
+ * An entity with a row: at the origin, or riding `bone` with no offset.
+ *
+ * @param {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} dataset
+ * @param {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
+ * @param {number} bone an entity, or -1
+ * @returns {number}
+ */
+function place(dataset, scene_context, bone) {
+    const entity = dataset.createEntity();
+
+    if (bone !== -1) {
+        const attachment = new TransformAttachment();
+
+        attachment.parent = bone;
+
+        dataset.addComponentToEntity(entity, attachment);
+
+        // the row's world is the GPU's to compose from the bone's; nothing on this side reads it,
+        // and nothing on this side composes it, so the authority says so
+        gpu_authority_declare(dataset, entity);
+        gpu_authority_grant(dataset, entity, GPUStateAuthorityFlags.Transform64);
     }
 
-    scene.add([fire, smoke]);
+    dataset.addComponentToEntity(entity, new Transform64());
+
+    scene_context.rows.acquire(entity);
 
-    return { fire, smoke };
+    return entity;
 }