@woosh/meep-engine 3.17.1 → 3.18.0

package/src/core/binary/meshopt/meshopt_write_uint_var.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Write one LEB128 ("varint-7") unsigned integer — the inverse of {@link meshopt_read_uint_var}.
+ *
+ * Seven bits of the value go in each byte, least significant group first, and the top bit says
+ * whether another byte follows. A value's encoding is unique because the loop stops as soon as
+ * nothing is left, so a stream this wrote reads back at exactly the length it wrote.
+ *
+ * {@link BinaryBuffer#writeUintVar} is the same encoding and is deliberately not used here, for the
+ * same reasons the reader gives: this writes into a plain byte range at an offset the caller
+ * carries, not through a `DataView` over a whole `ArrayBuffer`.
+ *
+ * @param {Uint8Array} destination at least {@link MESHOPT_UINT_VAR_MAX_BYTES} writable bytes at
+ *   `offset`, which is what lets this be checked once per stream instead of once per byte
+ * @param {number} offset
+ * @param {number} value unsigned 32-bit
+ * @returns {number} the offset just past what was written
+ */
+export function meshopt_write_uint_var(destination: Uint8Array, offset: number, value: number): number;
+/**
+ * The most bytes a 32-bit value can take: four groups of seven bits, then the four that are left.
+ * @type {number}
+ */
+export const MESHOPT_UINT_VAR_MAX_BYTES: number;
+//# sourceMappingURL=meshopt_write_uint_var.d.ts.map

package/src/core/binary/meshopt/meshopt_write_uint_var.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_write_uint_var.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_write_uint_var.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH,oDANW,UAAU,UAEV,MAAM,SACN,MAAM,GACJ,MAAM,CAelB;AApCD;;;GAGG;AACH,yCAFU,MAAM,CAE4B"}

package/src/core/binary/meshopt/meshopt_write_uint_var.js

@@ -0,0 +1,39 @@
+import { assert } from "../../assert.js";
+
+/**
+ * The most bytes a 32-bit value can take: four groups of seven bits, then the four that are left.
+ * @type {number}
+ */
+export const MESHOPT_UINT_VAR_MAX_BYTES = 5;
+
+/**
+ * Write one LEB128 ("varint-7") unsigned integer — the inverse of {@link meshopt_read_uint_var}.
+ *
+ * Seven bits of the value go in each byte, least significant group first, and the top bit says
+ * whether another byte follows. A value's encoding is unique because the loop stops as soon as
+ * nothing is left, so a stream this wrote reads back at exactly the length it wrote.
+ *
+ * {@link BinaryBuffer#writeUintVar} is the same encoding and is deliberately not used here, for the
+ * same reasons the reader gives: this writes into a plain byte range at an offset the caller
+ * carries, not through a `DataView` over a whole `ArrayBuffer`.
+ *
+ * @param {Uint8Array} destination at least {@link MESHOPT_UINT_VAR_MAX_BYTES} writable bytes at
+ *   `offset`, which is what lets this be checked once per stream instead of once per byte
+ * @param {number} offset
+ * @param {number} value unsigned 32-bit
+ * @returns {number} the offset just past what was written
+ */
+export function meshopt_write_uint_var(destination, offset, value) {
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    let remaining = value >>> 0;
+
+    while (remaining >= 0x80) {
+        destination[offset++] = (remaining & 0x7f) | 0x80;
+        remaining = remaining >>> 7;
+    }
+
+    destination[offset++] = remaining;
+
+    return offset;
+}

package/src/core/math/random/seededRandom_Mulberry32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seededRandom_Mulberry32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/seededRandom_Mulberry32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+CAHW,MAAM,UACQ,MAAM;wBAAwB,MAAM,KAAK,IAAI;oBAAiB,OAAY,MAAM,CAAC;EA2BzG"}
+{"version":3,"file":"seededRandom_Mulberry32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/seededRandom_Mulberry32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+CAHW,MAAM,UACQ,MAAM;wBAAwB,MAAM,KAAK,IAAI;oBAAiB,OAAY,MAAM,CAAC;EA6BzG"}

package/src/core/math/random/seededRandom_Mulberry32.js

@@ -7,7 +7,7 @@ export function seededRandom_Mulberry32(seed = 0) {
     let _seed = seed;
 
     function random() {
-        _seed += 0x6D2B79F5;
+        _seed = (_seed + 0x6D2B79F5) | 0;
 
         // Mulberry32 generator
         let t = _seed;
@@ -16,7 +16,9 @@ export function seededRandom_Mulberry32(seed = 0) {
 
         t ^= t + Math.imul(t ^ t >>> 7, t | 61);
 
-        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        const u = (t ^ t >>> 14) >>> 0;
+
+        return u / 4294967296;
     }
 
     random.setCurrentSeed = function (v) {

package/src/core/process/undo/Action.d.ts

@@ -22,6 +22,25 @@ export class Action<CTX> {
      * @param {CTX} context
      */
     revert(context: CTX): Promise<void>;
+    /**
+     * Declare what {@link apply} will write, before it runs. A host that records actions into a
+     * shared history (the scene editor's project session) captures the prior state of every
+     * declared key, lets the action apply, and diffs; an action that declares nothing is local
+     * to the host (a selection change) and is never recorded. {@link ActionProcessor} itself
+     * never calls this.
+     *
+     * `writes` offers `component(entity, componentClass)`, `entity(entity)` for creation or
+     * removal of the entity itself, and `blob(entity, componentClass, field, x, y, w, h)` for a
+     * rectangle of an externalised array field.
+     *
+     * @param {CTX} context
+     * @param {{component: function(number, Function): void, entity: function(number): void, blob: function(number, Function, string, number, number, number, number): void}} writes
+     */
+    collectWrites(context: CTX, writes: {
+        component: (arg0: number, arg1: Function) => void;
+        entity: (arg0: number) => void;
+        blob: (arg0: number, arg1: Function, arg2: string, arg3: number, arg4: number, arg5: number, arg6: number) => void;
+    }): void;
     /**
      * Used for quick instanceof checks
      * @type {boolean}

package/src/core/process/undo/Action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/Action.js"],"names":[],"mappings":"AACA;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,mBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,eAFW,GAAG,iBAIb;IAED;;;OAGG;IACH,gBAFW,GAAG,iBAIb;IAGL;;;OAGG;IACH,UAFU,OAAO,CAEQ;CANxB"}
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/Action.js"],"names":[],"mappings":"AACA;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,mBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,eAFW,GAAG,iBAIb;IAED;;;OAGG;IACH,gBAFW,GAAG,iBAIb;IAED;;;;;;;;;;;;;OAaG;IACH,uBAHW,GAAG,UACH;QAAC,SAAS,SAAW,MAAM,qBAAa,IAAI,CAAC;QAAC,MAAM,SAAW,MAAM,KAAG,IAAI,CAAC;QAAC,IAAI,SAAW,MAAM,wBAAY,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;KAAC,QAGvK;IAGL;;;OAGG;IACH,UAFU,OAAO,CAEQ;CANxB"}

package/src/core/process/undo/Action.js

@@ -31,6 +31,23 @@ export class Action {
     async revert(context) {
         throw new Error('Not Implemented. Needs to be overridden in subclass');
     }
+
+    /**
+     * Declare what {@link apply} will write, before it runs. A host that records actions into a
+     * shared history (the scene editor's project session) captures the prior state of every
+     * declared key, lets the action apply, and diffs; an action that declares nothing is local
+     * to the host (a selection change) and is never recorded. {@link ActionProcessor} itself
+     * never calls this.
+     *
+     * `writes` offers `component(entity, componentClass)`, `entity(entity)` for creation or
+     * removal of the entity itself, and `blob(entity, componentClass, field, x, y, w, h)` for a
+     * rectangle of an externalised array field.
+     *
+     * @param {CTX} context
+     * @param {{component: function(number, Function): void, entity: function(number): void, blob: function(number, Function, string, number, number, number, number): void}} writes
+     */
+    collectWrites(context, writes) {
+    }
 }
 
 /**

package/src/engine/graphics3/GPUParticleEmitterSystem.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @typedef {object} ParticleAtlasTexture
+ * @property {number} references Number of emitters using this URL.
+ * @property {import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch|null} patch Null while loading or after failure.
+ */
+/**
+ * @typedef {object} ParticleAtlasEntry
+ * @property {string|null} url Last observed emitter texture URL.
+ * @property {ParticleAtlasTexture|null} texture Shared image record, or null for an untextured emitter.
+ * @property {number} seen Last membership sweep that visited this emitter.
+ */
+/**
+ * Asset and atlas ownership for Shade's GPU particle emitters in one scene.
+ *
+ * This ECS system observes the scene's ParticleEmitter nodes, so it needs no additional component
+ * or duplicate transform. Add/remove nodes through the scene as usual. One system owns the sprite
+ * atlas for that scene; the legacy ParticleEmitterSystem continues to serve CPU particle effects.
+ *
+ * Images load through the supplied AssetManager and share a patch by URL. TextureAtlas already
+ * handles packing, growth and repacking with MaxRectanglesPacker. A FrameStart extension publishes
+ * the pixels and every current patch before the renderer records particle simulation and drawing.
+ * Pending/failed images sample transparent; emitters without an image sample white.
+ */
+export class GPUParticleEmitterSystem extends System<any> {
+    /**
+     * @param {import("./GraphicsEngine.js").GraphicsEngine} graphics
+     * @param {import("../../shade/renderer/scene/Scene.js").Scene} scene scene whose particle atlas this system owns
+     * @param {import("../asset/AssetManager.js").AssetManager} assets
+     */
+    constructor(graphics: import("./GraphicsEngine.js").GraphicsEngine, scene: import("../../shade/renderer/scene/Scene.js").Scene, assets: import("../asset/AssetManager.js").AssetManager<any>);
+    /**
+     * CPU atlas, exposed for inspection. Owned by this system.
+     * @type {TextureAtlas}
+     */
+    atlas: TextureAtlas;
+    /**
+     * @param {import("../ecs/EntityManager.js").EntityManager} entityManager
+     * @returns {Promise<void>}
+     */
+    startup(entityManager: import("../ecs/EntityManager.js").EntityManager): Promise<void>;
+    /** @returns {Promise<void>} */
+    shutdown(): Promise<void>;
+    /** @returns {void} */
+    update(): void;
+    /** Publish atlas data at FrameStart, after scene rows exist and before particle passes record.
+     * @param {import("../../shade/renderer/extension/FrameContext.js").FrameContext} frame
+     * @returns {void}
+     */
+    prepare(frame: import("../../shade/renderer/extension/FrameContext.js").FrameContext): void;
+    #private;
+}
+export type ParticleAtlasTexture = {
+    /**
+     * Number of emitters using this URL.
+     */
+    references: number;
+    /**
+     * Null while loading or after failure.
+     */
+    patch: import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch | null;
+};
+export type ParticleAtlasEntry = {
+    /**
+     * Last observed emitter texture URL.
+     */
+    url: string | null;
+    /**
+     * Shared image record, or null for an untextured emitter.
+     */
+    texture: ParticleAtlasTexture | null;
+    /**
+     * Last membership sweep that visited this emitter.
+     */
+    seen: number;
+};
+import { System } from "../ecs/System.js";
+import { TextureAtlas } from "../graphics/texture/atlas/TextureAtlas.js";
+//# sourceMappingURL=GPUParticleEmitterSystem.d.ts.map

package/src/engine/graphics3/GPUParticleEmitterSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AACH;IA0CI;;;;OAIG;IACH,sBAJW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAY7D;IAvDD;;;OAGG;IACH,OAFU,YAAY,CAEO;IAqD7B;;;OAGG;IACH,uBAHW,OAAO,yBAAyB,EAAE,aAAa,GAC7C,QAAQ,IAAI,CAAC,CASzB;IAED,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAkB1B;IAUD,sBAAsB;IACtB,UADc,IAAI,CAWjB;IA6DD;;;OAGG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CA2CJ;;;;;gBApRa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;;;;SAKjE,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;;;UACzB,MAAM;;uBAjBG,kBAAkB;6BAGZ,2CAA2C"}

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -0,0 +1,310 @@
+import { assert } from "../../core/assert.js";
+import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
+import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
+import { GPUTextureContext } from "../../shade/renderer/texture/GPUTextureContext.js";
+import { System } from "../ecs/System.js";
+import { GameAssetType } from "../asset/GameAssetType.js";
+import { ImageRGBADataLoader } from "../asset/loaders/image/ImageRGBADataLoader.js";
+import { TextureAtlas } from "../graphics/texture/atlas/TextureAtlas.js";
+import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
+import { sampler2d_ensure_uint8_RGBA } from "../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
+
+/**
+ * @typedef {object} ParticleAtlasTexture
+ * @property {number} references Number of emitters using this URL.
+ * @property {import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch|null} patch Null while loading or after failure.
+ */
+
+/**
+ * @typedef {object} ParticleAtlasEntry
+ * @property {string|null} url Last observed emitter texture URL.
+ * @property {ParticleAtlasTexture|null} texture Shared image record, or null for an untextured emitter.
+ * @property {number} seen Last membership sweep that visited this emitter.
+ */
+
+/**
+ * Asset and atlas ownership for Shade's GPU particle emitters in one scene.
+ *
+ * This ECS system observes the scene's ParticleEmitter nodes, so it needs no additional component
+ * or duplicate transform. Add/remove nodes through the scene as usual. One system owns the sprite
+ * atlas for that scene; the legacy ParticleEmitterSystem continues to serve CPU particle effects.
+ *
+ * Images load through the supplied AssetManager and share a patch by URL. TextureAtlas already
+ * handles packing, growth and repacking with MaxRectanglesPacker. A FrameStart extension publishes
+ * the pixels and every current patch before the renderer records particle simulation and drawing.
+ * Pending/failed images sample transparent; emitters without an image sample white.
+ */
+export class GPUParticleEmitterSystem extends System {
+    /**
+     * CPU atlas, exposed for inspection. Owned by this system.
+     * @type {TextureAtlas}
+     */
+    atlas = new TextureAtlas(64);
+
+    /** @type {import("./GraphicsEngine.js").GraphicsEngine} */
+    #graphics;
+    /** @type {import("../../shade/renderer/scene/Scene.js").Scene} */
+    #scene;
+    /** @type {import("../asset/AssetManager.js").AssetManager} */
+    #assets;
+    /** @type {Map<import("../../shade/renderer/particles/runtime/ParticleEmitter.js").ParticleEmitter, ParticleAtlasEntry>} */
+    #entries = new Map();
+    /** @type {Map<string, ParticleAtlasTexture>} */
+    #textures = new Map();
+    /** @type {number} */
+    #sweep = 0;
+    /** @type {number} */
+    #membership_version = -1;
+    /** @type {import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch} */
+    #white;
+    /** @type {import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch} */
+    #transparent;
+    /** @type {GPUParticleAtlasExtension|null} */
+    #extension = null;
+    /** @type {GPUTextureContext|null} */
+    #texture = null;
+    /** @type {GPUTextureView|null} */
+    #view = null;
+    /** @type {GPUDevice|null} */
+    #device = null;
+    /** @type {number} */
+    #uploaded_version = -1;
+    /** @type {import("../../shade/renderer/particles/GPUParticleSystem.js").GPUParticleSystem|null} */
+    #particles = null;
+    /** @type {GPUTextureView|null} */
+    #previous_atlas = null;
+    /** @type {Float32Array} */
+    #region = new Float32Array(4);
+
+    /**
+     * @param {import("./GraphicsEngine.js").GraphicsEngine} graphics
+     * @param {import("../../shade/renderer/scene/Scene.js").Scene} scene scene whose particle atlas this system owns
+     * @param {import("../asset/AssetManager.js").AssetManager} assets
+     */
+    constructor(graphics, scene, assets) {
+        super();
+        assert.defined(graphics, "graphics");
+        assert.equal(scene.isScene, true, "scene.isScene !== true");
+        assert.defined(assets, "assets");
+        this.#graphics = graphics;
+        this.#scene = scene;
+        this.#assets = assets;
+        this.#create_defaults();
+    }
+
+    /**
+     * @param {import("../ecs/EntityManager.js").EntityManager} entityManager
+     * @returns {Promise<void>}
+     */
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+        if (!this.#assets.hasLoaderForType(GameAssetType.Image)) {
+            await this.#assets.registerLoader(GameAssetType.Image, new ImageRGBADataLoader());
+        }
+        this.#extension = new GPUParticleAtlasExtension(this);
+        this.#graphics.add_extension(this.#extension);
+    }
+
+    /** @returns {Promise<void>} */
+    async shutdown() {
+        if (this.#extension !== null) {
+            this.#graphics.remove_extension(this.#extension);
+            this.#extension = null;
+        }
+        this.#detach();
+        this.#texture?.destroy();
+        this.#texture = null;
+        this.#view = null;
+        this.#device = null;
+        this.#uploaded_version = -1;
+        this.#entries.clear();
+        this.#membership_version = -1;
+        // An in-flight load checks its record's identity here before adding a patch.
+        this.#textures.clear();
+        this.atlas.reset();
+        this.#create_defaults();
+    }
+
+    /** @returns {void} */
+    #create_defaults() {
+        const white = Sampler2D.uint8(4, 1, 1);
+        white.data.fill(255);
+        this.#white = this.atlas.add(white);
+        this.#transparent = this.atlas.add(Sampler2D.uint8(4, 1, 1));
+    }
+
+    /** @returns {void} */
+    update() {
+        this.#sync_membership();
+        for (const [emitter, entry] of this.#entries) {
+            if (entry.url !== emitter.texture) {
+                this.#release(entry.url);
+                entry.url = emitter.texture;
+                entry.texture = entry.url === null ? null : this.#acquire(entry.url);
+            }
+        }
+        this.atlas.update();
+    }
+
+    /** @returns {void} */
+    #sync_membership() {
+        const instances = this.#scene.instances;
+        if (instances.version === this.#membership_version) { return; }
+        const sweep = ++this.#sweep;
+        for (const emitter of instances.nodes) {
+            if (emitter.isParticleEmitter !== true) { continue; }
+            let entry = this.#entries.get(emitter);
+            if (entry === undefined) {
+                entry = { url: null, texture: null, seen: sweep };
+                this.#entries.set(emitter, entry);
+            }
+            entry.seen = sweep;
+        }
+        for (const [emitter, entry] of this.#entries) {
+            if (entry.seen !== sweep) {
+                this.#release(entry.url);
+                this.#entries.delete(emitter);
+            }
+        }
+        this.#membership_version = instances.version;
+    }
+
+    /**
+     * @param {string} url
+     * @returns {ParticleAtlasTexture}
+     */
+    #acquire(url) {
+        let texture = this.#textures.get(url);
+        if (texture !== undefined) {
+            texture.references++;
+            return texture;
+        }
+        texture = { references: 1, patch: null };
+        this.#textures.set(url, texture);
+        this.#assets.promise(url, GameAssetType.Image).then(asset => {
+            // Removed, changed URL, or shut down while loading: the completion owns nothing now.
+            if (this.#textures.get(url) !== texture) { return; }
+            texture.patch = this.atlas.add(sampler2d_ensure_uint8_RGBA(asset.create()));
+        }).catch(error => {
+            if (this.#textures.get(url) === texture) {
+                console.warn(`GPU particle texture '${url}' could not be loaded`, error);
+            }
+        });
+        return texture;
+    }
+
+    /**
+     * @param {string|null} url
+     * @returns {void}
+     */
+    #release(url) {
+        if (url === null) { return; }
+        const texture = this.#textures.get(url);
+        if (--texture.references !== 0) { return; }
+        this.#textures.delete(url);
+        if (texture.patch !== null) { this.atlas.remove(texture.patch); }
+    }
+
+    /** Publish atlas data at FrameStart, after scene rows exist and before particle passes record.
+     * @param {import("../../shade/renderer/extension/FrameContext.js").FrameContext} frame
+     * @returns {void}
+     */
+    prepare(frame) {
+        if (frame.view.scene.scene !== this.#scene) { return; }
+        this.update();
+        const renderer = this.#graphics.renderer;
+        renderer.feature_particles_enabled = true;
+        const particles = renderer.particles(frame.view.scene);
+        if (particles !== this.#particles) {
+            this.#detach();
+            this.#particles = particles;
+            this.#previous_atlas = particles.atlas;
+        }
+        particles.sync_membership();
+        this.#upload(renderer.graphics.device);
+        particles.atlas = this.#view;
+
+        for (const [emitter, entry] of this.#entries) {
+            if (particles.registry.context(emitter) === undefined) { continue; }
+            const patch = entry.texture === null ? this.#white : entry.texture.patch ?? this.#transparent;
+            const uv = patch.uv;
+            const region = this.#region;
+            if (patch === this.#white || patch === this.#transparent) {
+                // Sample the texel centre everywhere, avoiding interpolation into the gutter.
+                region[0] = uv.position.x + uv.size.x * 0.5;
+                region[1] = uv.position.y + uv.size.y * 0.5;
+                region[2] = 0;
+                region[3] = 0;
+            } else {
+                region[0] = uv.position.x;
+                region[1] = uv.position.y;
+                region[2] = uv.size.x;
+                region[3] = uv.size.y;
+            }
+            // Re-read every patch after packing: growth also changes UVs of unchanged images.
+            particles.registry.set_atlas_region(emitter, region);
+        }
+    }
+
+    /**
+     * @param {GPUDevice} device
+     * @returns {void}
+     */
+    #upload(device) {
+        const source = this.atlas.sampler;
+        if (this.#device !== device || this.#texture === null) {
+            this.#texture?.destroy();
+            this.#device = device;
+            this.#texture = new GPUTextureContext(device);
+            const descriptor = this.#texture.descriptor;
+            descriptor.label = "particles/sprite atlas";
+            descriptor.format = "rgba8unorm";
+            descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+            this.#uploaded_version = -1;
+        }
+        const texture = this.#texture;
+        if (texture.width !== source.width || texture.height !== source.height) {
+            texture.resize(source.width, source.height);
+            this.#uploaded_version = -1;
+        }
+        if (this.#uploaded_version !== source.version) {
+            device.queue.writeTexture({ texture: texture.gpu_texture }, source.data,
+                { bytesPerRow: source.width * 4 }, [source.width, source.height]);
+            texture.incrementVersion();
+            this.#uploaded_version = source.version;
+        }
+        this.#view = texture.obtainView();
+    }
+
+    /** @returns {void} */
+    #detach() {
+        if (this.#particles !== null && this.#particles.atlas === this.#view) {
+            this.#particles.atlas = this.#previous_atlas;
+            for (const emitter of this.#particles.emitters) {
+                this.#particles.registry.set_atlas_region(emitter, [0, 0, 1, 1]);
+            }
+        }
+        this.#particles = null;
+        this.#previous_atlas = null;
+    }
+}
+
+class GPUParticleAtlasExtension extends RenderExtension {
+    /** @type {string} */
+    name = "gpu particle atlas";
+    /** @type {FramePhase} */
+    phase = FramePhase.FrameStart;
+    /** @type {GPUParticleEmitterSystem} */
+    #system;
+
+    /** @param {GPUParticleEmitterSystem} system */
+    constructor(system) {
+        super();
+        this.#system = system;
+    }
+    /**
+     * @param {import("../../shade/renderer/extension/FrameContext.js").FrameContext} frame
+     * @returns {void}
+     */
+    record(frame) { this.#system.prepare(frame); }
+}

package/src/engine/graphics3/GraphicsEngine.d.ts

@@ -272,6 +272,23 @@ export class GraphicsEngine {
      * @returns {Promise<void>}
      */
     start(): Promise<void>;
+    /**
+     * Re-point the viewport at a canvas, and the page with it. This is the wrinkle E1 named:
+     * `start` builds a *new* canvas, so a restart would otherwise leave the dead one mounted and
+     * the live one detached. `View.el` is read unguarded all over the view layer, so it is replaced
+     * rather than cleared — it always holds an element.
+     *
+     * The inline `pointer-events` of the element being replaced comes along: the engine opts the
+     * viewport back in (`auto`) under a game view that lets clicks fall through (`none`), and it
+     * does so on the placeholder element before there is a canvas. A canvas that did not inherit
+     * the opt-in inherited the fall-through instead, and every pointer device bound to the canvas
+     * — the editor's tools — was deaf to every press.
+     *
+     * Public so that the swap can be driven without a device.
+     *
+     * @param {HTMLCanvasElement} canvas
+     */
+    adopt_canvas(canvas: HTMLCanvasElement): void;
     /**
      * Tear the device down and let go of the canvas.
      *

package/src/engine/graphics3/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iDAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,2DAWC;IAED;;;;;;;;;;OAUG;IACH,oCAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,8CAFa,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,kBAAgB,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,yBAEL,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CA4DzB;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAoDnB;;CACJ;yBAzxBwB,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iDAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,2DAWC;IAED;;;;;;;;;;OAUG;IACH,oCAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,8CAFa,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,kBAAgB,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,yBAEL,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAkDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAoDnB;;CACJ;yBA7yBwB,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}

package/src/engine/graphics3/GraphicsEngine.js

@@ -603,22 +603,42 @@ export class GraphicsEngine {
         this.#renderer = renderer;
         this.domElement = canvas;
 
-        // Re-point the viewport, and the page with it. This is the wrinkle E1 named: `start` builds
-        // a *new* canvas, so a restart would otherwise leave the dead one mounted and the live one
-        // detached. `View.el` is read unguarded all over the view layer, so it is replaced rather
-        // than cleared — it always holds an element.
+        this.adopt_canvas(canvas);
+
+        this.updateSize();
+
+        // so the first frame's interval is a real one rather than the whole of the boot
+        this.#last_render_timestamp = performance.now();
+    }
+
+    /**
+     * Re-point the viewport at a canvas, and the page with it. This is the wrinkle E1 named:
+     * `start` builds a *new* canvas, so a restart would otherwise leave the dead one mounted and
+     * the live one detached. `View.el` is read unguarded all over the view layer, so it is replaced
+     * rather than cleared — it always holds an element.
+     *
+     * The inline `pointer-events` of the element being replaced comes along: the engine opts the
+     * viewport back in (`auto`) under a game view that lets clicks fall through (`none`), and it
+     * does so on the placeholder element before there is a canvas. A canvas that did not inherit
+     * the opt-in inherited the fall-through instead, and every pointer device bound to the canvas
+     * — the editor's tools — was deaf to every press.
+     *
+     * Public so that the swap can be driven without a device.
+     *
+     * @param {HTMLCanvasElement} canvas
+     */
+    adopt_canvas(canvas) {
         const previous = this.viewport.el;
 
+        if (previous != null && previous !== canvas && previous.style !== undefined && previous.style.pointerEvents !== "") {
+            canvas.style.pointerEvents = previous.style.pointerEvents;
+        }
+
         this.viewport.el = canvas;
 
-        if (previous != null && previous.parentNode !== null) {
+        if (previous != null && previous !== canvas && previous.parentNode !== null) {
             previous.parentNode.replaceChild(canvas, previous);
         }
-
-        this.updateSize();
-
-        // so the first frame's interval is a real one rather than the whole of the boot
-        this.#last_render_timestamp = performance.now();
     }
 
     /**

package/src/engine/graphics3/particles/particle_gpu_records.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_gpu_records.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/particles/particle_gpu_records.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;GAWG;AACH,+DAHW,YAAY,GACV,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IALoC,YAAY,EAArC,UAAU,MAAM,CAAC;IACH,KAAK,EAAnB,MAAM;IACS,UAAU,EAAzB,OAAO;IACL,MAAM,CA0ClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CATW,WAAW,YACX,YAAY,cACZ,MAAM,2CAEN,MAAM,EAAE,gBACR,MAAM,EAAE,aACR,MAAM,EAAE,GACN,MAAM,CA4ElB;AA5MD;;;;;;;GAOG;AACH,qCAFU,MAAM,CAEwB;AAExC;;GAEG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;GAEG;AACH,kCAFU,MAAM,CAEqB;AAErC;;GAEG;AACH,qCAFU,MAAM,CAEwB;6BA9CX,gDAAgD"}
+{"version":3,"file":"particle_gpu_records.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/particles/particle_gpu_records.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;GAWG;AACH,+DAHW,YAAY,GACV,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IALoC,YAAY,EAArC,UAAU,MAAM,CAAC;IACH,KAAK,EAAnB,MAAM;IACS,UAAU,EAAzB,OAAO;IACL,MAAM,CAwClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CATW,WAAW,YACX,YAAY,cACZ,MAAM,2CAEN,MAAM,EAAE,gBACR,MAAM,EAAE,aACR,MAAM,EAAE,GACN,MAAM,CA4ElB;AA1MD;;;;;;;GAOG;AACH,qCAFU,MAAM,CAEwB;AAExC;;GAEG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;GAEG;AACH,kCAFU,MAAM,CAEqB;AAErC;;GAEG;AACH,qCAFU,MAAM,CAEwB;6BA9CX,gDAAgD"}

package/src/engine/graphics3/particles/particle_gpu_records.js

@@ -124,8 +124,6 @@ export function particle_layer_record({ atlas_region, blend, soft_depth }) {
         spawn_rate: 0,
         node: NODE3D_SCENE_ID,
         generation: PARTICLE_GENERATION_FIRST,
-        bounds_center: [0, 0, 0],
-        bounds_radius: 0,
     };
 }
 

package/src/engine/interpolation/InterpolationSystem.d.ts

@@ -88,6 +88,13 @@ export class InterpolationSystem extends System<any> {
         tick_b: number;
         t: number;
     }): void;
+    /**
+     * Forget a source (its peer left). Entities still marked with it are left where they are
+     * until their marker goes; the system does not blend from a source it does not have.
+     * @param {number} sourceId
+     * @returns {boolean} whether it was registered
+     */
+    unregisterSource(sourceId: number): boolean;
     /**
      * @param {Interpolated} interpolated
      * @param {number} entity