@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -11,6 +11,7 @@
  * puts emitters to sleep when they leave the visible set; §4.5 retires CPU render culling, so every
  * linked emitter simulates and the GPU decides what is on screen. An emitter that should not
  * simulate says so itself, through {@link ParticleEmitterFlag.Emitting}.
+ * @deprecated use {@link GPUParticleSystem} instead, it can do everything this can and more.
  */
 export class ParticleEmitterSystem extends System<any> {
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IAiDI;;;OAGG;IACH,4DAUC;IA9DD,8DAA8C;IAuC9C;;;;OAIG;IACH,kCAEC;IAkBD,2CAUC;IAED,4CAeC;IAED;;;;OAIG;IACH,cAJW,eAAe,aACf,WAAW,UACX,MAAM,QAsChB;IAED;;;;;;;;;OASG;IACH,iBAFW,eAAe,QAqBzB;IAED;;;;OAIG;IACH,gBAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0BhB;IAED,6BAaC;IAED;;OAEG;IACH,kCA+BC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,qBAAqB,EAM/B;IAED,yBAEC;;CACJ;uBA3SsB,kBAAkB;4BACb,iCAAiC;gCAC7B,oEAAoE;gCANpE,mDAAmD"}
+{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AACH;IAiDI;;;OAGG;IACH,4DAUC;IA9DD,8DAA8C;IAuC9C;;;;OAIG;IACH,kCAEC;IAkBD,2CAUC;IAED,4CAeC;IAED;;;;OAIG;IACH,cAJW,eAAe,aACf,WAAW,UACX,MAAM,QAsChB;IAED;;;;;;;;;OASG;IACH,iBAFW,eAAe,QAqBzB;IAED;;;;OAIG;IACH,gBAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0BhB;IAED,6BAaC;IAED;;OAEG;IACH,kCA+BC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,qBAAqB,EAM/B;IAED,yBAEC;;CACJ;uBA5SsB,kBAAkB;4BACb,iCAAiC;gCAC7B,oEAAoE;gCANpE,mDAAmD"}

package/src/engine/graphics3/ParticleEmitterSystem.js

@@ -25,6 +25,7 @@ import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHA
  * puts emitters to sleep when they leave the visible set; §4.5 retires CPU render culling, so every
  * linked emitter simulates and the GPU decides what is on screen. An emitter that should not
  * simulate says so itself, through {@link ParticleEmitterFlag.Emitting}.
+ * @deprecated use {@link GPUParticleSystem} instead, it can do everything this can and more.
  */
 export class ParticleEmitterSystem extends System {
     dependencies = [ParticleEmitter, Transform64];

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

@@ -1,8 +1,8 @@
 /**
  * Draws terrain under Shade: each built tile becomes one entity that draws — a `ShadedGeometry`
- * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved
- * — and a pass after the opaque geometry textures the lot. The system that owns primitives puts
- * the tile in the scene's rows; this one makes and keeps the entity.
+ * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved.
+ * The system that owns primitives puts the tile in the scene's rows; this one makes and keeps the
+ * entity, and the terrain's material.
  *
  * **The tile is the unit, not the terrain.** Tiles are built on demand as the camera sees them and
  * destroyed as it leaves, which is the streaming the tile manager already does; this system follows
@@ -11,13 +11,13 @@
  * **Tile vertices are already in terrain space** — the height-field builder positions each tile
  * within the whole grid rather than at its own origin — so every tile mesh carries the terrain
  * entity's transform and nothing else. That is also why the tile's own raycast inverts the same
- * matrix.
+ * matrix, and why the terrain's surface can map from geometry-space position.
  *
- * **Texturing is a full-screen pass, not a material** (U3b, D40): the tiles draw with one flat
- * material, and at {@link FramePhase.AfterGBuffer} the splat mix and grid overlay are painted over
- * every pixel the visibility buffer attributes to a tile — the architecture decals built (D23),
- * keyed on mesh rows rather than froxels. Registered before `DecalSystem` in the profile, which
- * is what puts scorch marks on top of the textured ground rather than under it.
+ * **Texturing is a material.** Every tile of a terrain draws with one {@link TerrainShadeMaterial},
+ * whose template runs the splat mix and the grid overlay in the G-buffer pass, where every other
+ * surface is shaded — so decals, lighting and everything after the G-buffer see textured ground
+ * without being ordered after anything. What this system does per frame is keep that material's
+ * parameters current; the textures upload when their own versions move.
  *
  * **It does not call `Terrain.link`.** That method binds a three `ShaderMaterial` through
  * `graphics.getMaterialManager()`, which `GraphicsEngine` does not have and will not; the parts of
@@ -26,8 +26,7 @@
 export class TerrainSystem extends System<any> {
     /**
      * @param {GraphicsEngine} graphics
-     * @param {Scene} scene the scene the profile draws; a tile is an entity in its rows, put there
-     *        by the system that owns primitives, so this one keeps nothing of the scene itself
+     * @param {Scene} scene the scene the profile draws
      * @param {AssetManager} assetManager
      */
     constructor(graphics: GraphicsEngine, scene: Scene, assetManager: AssetManager);
@@ -52,37 +51,8 @@ export class TerrainSystem extends System<any> {
      * @returns {Int32Array}
      */
     tiles_of(entity: number): Int32Array;
-    /**
-     * Everything the splat pass draws one terrain from. What the pass consumes and what a gate
-     * inspects are deliberately the same object — the same reason `DecalSystem` exposes its
-     * packed records.
-     *
-     * @param {number} entity
-     * @returns {object|null} `null` when this terrain has nothing to texture — no tiles built
-     */
-    splat_frame(entity: number): object | null;
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame: FrameContext): void;
-    #private;
-}
-/**
- * The splat and the grid overlay are a full-screen pass writing a replacement albedo, so this is
- * {@link FramePhase.AfterGBuffer} — the one phase where the G-buffer may be published into.
- *
- * Everything that paints on top of the ground declares itself after this rather than being
- * registered after it; {@link DecalExtension} is the one that does.
- */
-export class TerrainExtension extends RenderExtension {
-    /**
-     * @param {TerrainSystem} system
-     */
-    constructor(system: TerrainSystem);
-    record(frame: any): void;
     #private;
 }
 import { System } from "../ecs/System.js";
 import Terrain from "../ecs/terrain/ecs/Terrain.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 //# sourceMappingURL=TerrainSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TerrainSystem.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA0BI;;;;;OAKG;IACH,gFASC;IAxCD,iCAAyB;IA0CzB,2CAQC;IAED,4CAUC;IAED;;;OAGG;IACH,cAHW,OAAO,UACP,MAAM,QA2DhB;IAED;;;OAGG;IACH,gBAHW,OAAO,UACP,MAAM,QAMhB;IAED,6BA0BC;IAqFD;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,UAAU,CAUtB;IAiID;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAsFvB;IAED;;OAEG;IACH,kCAaC;;CACJ;AAED;;;;;;GAMG;AACH;IAUI;;OAEG;IACH,oBAFW,aAAa,EAMvB;IAED,yBAEC;;CACJ;uBA5lBsB,kBAAkB;oBACrB,+BAA+B;gCAcnB,mDAAmD"}
+{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TerrainSystem.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA6BI;;;;OAIG;IACH,gFAUC;IA3CD,iCAAyB;IA6CzB,2CAMC;IAED,4CAIC;IA0CD;;;OAGG;IACH,cAHW,OAAO,UACP,MAAM,QAiDhB;IAED;;;OAGG;IACH,gBAHW,OAAO,UACP,MAAM,QAMhB;IAED,6BAkCC;IAkLD;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,UAAU,CAUtB;;CAiIJ;uBAzkBsB,kBAAkB;oBACrB,+BAA+B"}

package/src/engine/graphics3/TerrainSystem.js

@@ -4,7 +4,6 @@ import {
 } from "../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_frustum.js";
 import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
 import { noop } from "../../core/function/noop.js";
-import { m4_invert } from "../../core/geom/3d/mat4/m4_invert.js";
 import { GameAssetType } from "../asset/GameAssetType.js";
 import { ImageRGBADataLoader } from "../asset/loaders/image/ImageRGBADataLoader.js";
 import { System } from "../ecs/System.js";
@@ -21,11 +20,8 @@ import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { sampler2d_ensure_uint8_RGBA } from "../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
 import { WHITE_PIXEL_DATA_URL } from "../graphics/WHITE_PIXEL_DATA_URL.js";
-import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { StandardShadeMaterial } from "../../shade/renderer/material/StandardShadeMaterial.js";
-import { GPUTerrainSplatRenderer } from "./terrain/GPUTerrainSplatRenderer.js";
-import { pack_terrain_row_table } from "./terrain/pack_terrain_row_table.js";
+import { TERRAIN_MATERIAL_TEMPLATE } from "./terrain/TERRAIN_MATERIAL_TEMPLATE.js";
+import { TerrainShadeMaterial } from "./terrain/TerrainShadeMaterial.js";
 
 /**
  * Tile indices a frustum query answers with. Module-static because the query runs every frame and
@@ -54,9 +50,9 @@ const TILE_COMPONENT_TYPES = [Transform64, ShadedGeometry, Name, ParentEntity, S
 
 /**
  * Draws terrain under Shade: each built tile becomes one entity that draws — a `ShadedGeometry`
- * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved
- * — and a pass after the opaque geometry textures the lot. The system that owns primitives puts
- * the tile in the scene's rows; this one makes and keeps the entity.
+ * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved.
+ * The system that owns primitives puts the tile in the scene's rows; this one makes and keeps the
+ * entity, and the terrain's material.
  *
  * **The tile is the unit, not the terrain.** Tiles are built on demand as the camera sees them and
  * destroyed as it leaves, which is the streaming the tile manager already does; this system follows
@@ -65,13 +61,13 @@ const TILE_COMPONENT_TYPES = [Transform64, ShadedGeometry, Name, ParentEntity, S
  * **Tile vertices are already in terrain space** — the height-field builder positions each tile
  * within the whole grid rather than at its own origin — so every tile mesh carries the terrain
  * entity's transform and nothing else. That is also why the tile's own raycast inverts the same
- * matrix.
+ * matrix, and why the terrain's surface can map from geometry-space position.
  *
- * **Texturing is a full-screen pass, not a material** (U3b, D40): the tiles draw with one flat
- * material, and at {@link FramePhase.AfterGBuffer} the splat mix and grid overlay are painted over
- * every pixel the visibility buffer attributes to a tile — the architecture decals built (D23),
- * keyed on mesh rows rather than froxels. Registered before `DecalSystem` in the profile, which
- * is what puts scorch marks on top of the textured ground rather than under it.
+ * **Texturing is a material.** Every tile of a terrain draws with one {@link TerrainShadeMaterial},
+ * whose template runs the splat mix and the grid overlay in the G-buffer pass, where every other
+ * surface is shaded — so decals, lighting and everything after the G-buffer see textured ground
+ * without being ordered after anything. What this system does per frame is keep that material's
+ * parameters current; the textures upload when their own versions move.
  *
  * **It does not call `Terrain.link`.** That method binds a three `ShaderMaterial` through
  * `graphics.getMaterialManager()`, which `GraphicsEngine` does not have and will not; the parts of
@@ -86,10 +82,13 @@ export class TerrainSystem extends System {
     #graphics;
 
     /**
-     * @type {RenderExtension|null}
+     * The scene the profile draws — a tile is an entity in its rows, put there by the system that
+     * owns primitives. Held for the door to its GPU state, which is where the terrain's material
+     * is prewarmed and released.
+     *
+     * @type {Scene}
      */
-    #extension = null;
-
+    #scene;
 
     /**
      * @type {AssetManager}
@@ -99,14 +98,13 @@ export class TerrainSystem extends System {
     /**
      * What each terrain entity has spawned.
      *
-     * @type {Map<number, {terrain: Terrain, material: StandardShadeMaterial, tiles: Map<TerrainTile, number>, bindings: SignalBinding[]}>}
+     * @type {Map<number, {terrain: Terrain, material: TerrainShadeMaterial, tiles: Map<TerrainTile, number>, bindings: SignalBinding[]}>}
      */
     #entries = new Map();
 
     /**
      * @param {GraphicsEngine} graphics
-     * @param {Scene} scene the scene the profile draws; a tile is an entity in its rows, put there
-     *        by the system that owns primitives, so this one keeps nothing of the scene itself
+     * @param {Scene} scene the scene the profile draws
      * @param {AssetManager} assetManager
      */
     constructor(graphics, scene, assetManager) {
@@ -117,29 +115,62 @@ export class TerrainSystem extends System {
         assert.defined(assetManager, 'assetManager');
 
         this.#graphics = graphics;
+        this.#scene = scene;
         this.#assetManager = assetManager;
     }
 
     async startup(entityManager) {
         this.entityManager = entityManager;
 
-        this.#extension = this.#graphics.add_extension(new TerrainExtension(this));
-
         // the terrain's own layer loading decodes images; the decoder is renderer-neutral and the
         // legacy system registers the same one
         await this.#assetManager.tryRegisterLoader(GameAssetType.Image, new ImageRGBADataLoader());
     }
 
     async shutdown(entityManager) {
-        if (this.#extension !== null) {
-            this.#graphics.remove_extension(this.#extension);
+        for (const entity of Array.from(this.#entries.keys())) {
+            this.#drop(entity);
+        }
+    }
+
+    /**
+     * The material manager of the renderer drawing the scene, or `null` while there is none.
+     *
+     * @returns {GPUMaterialManager|null}
+     */
+    #materials() {
+        const scene_context = this.#graphics.scene_context(this.#scene);
 
-            this.#extension = null;
+        return scene_context === null ? null : scene_context.materials;
+    }
+
+    /**
+     * The managers the terrain template has been prewarmed on. A renderer that starts after a
+     * terrain is linked, or restarts, has a manager of its own that has not compiled anything. Weak,
+     * so a stopped renderer's manager is not kept alive by having been prewarmed.
+     *
+     * @type {WeakSet<GPUMaterialManager>}
+     */
+    #prewarmed = new WeakSet();
+
+    /**
+     * Compile the terrain template's pipeline on the current renderer, once — at load, rather than on
+     * the frame the first tile draws.
+     */
+    #prewarm() {
+        if (this.#entries.size === 0) {
+            return;
         }
 
-        for (const entity of Array.from(this.#entries.keys())) {
-            this.#drop(entity);
+        const materials = this.#materials();
+
+        if (materials === null || this.#prewarmed.has(materials)) {
+            return;
         }
+
+        materials.prewarm(TERRAIN_MATERIAL_TEMPLATE);
+
+        this.#prewarmed.add(materials);
     }
 
     /**
@@ -154,33 +185,23 @@ export class TerrainSystem extends System {
         const entry = {
             terrain,
             /*
-             One material for the whole terrain, and a flat one on purpose: the splat pass rewrites
-             the albedo after the G-buffer is drawn (U3b), so what the material contributes is the
-             other three channels — roughness 1 and metalness 0, which is exactly what the legacy
-             splat shader forced.
+             One material for the whole terrain: it describes the surface, not the piece, and the
+             textures it binds are the terrain's own.
              */
-            material: new StandardShadeMaterial(),
+            material: new TerrainShadeMaterial(),
             tiles: new Map(),
-            bindings: [],
-            renderer: new GPUTerrainSplatRenderer(),
-            /**
-             * The pass's per-frame tables and settings, reused between frames.
-             */
-            rows: new Uint32Array(0),
-            scales: new Float32Array(0),
-            world_to_terrain: new Float32Array(16),
-            inv_world_size: new Float32Array(2),
-            grid_transform: new Float32Array(4),
-            grid_resolution: new Float32Array(2),
-            sprite: WHITE_SPRITE
+            bindings: []
         };
 
         entry.material.name = 'terrain';
-        entry.material.roughness_factor = 1;
-        entry.material.metallic_factor = 0;
+
+        this.#sync_material(entry);
 
         this.#entries.set(entity, entry);
 
+        // the template compiles here, at load, rather than on the frame the first tile appears
+        this.#prewarm();
+
         const manager = terrain.tiles;
 
         const built = new SignalBinding(manager.on.tileBuilt, tile => this.#add_tile(entity, tile));
@@ -228,6 +249,8 @@ export class TerrainSystem extends System {
             return;
         }
 
+        this.#prewarm();
+
         ecd.traverseComponents(Terrain, (terrain, entity) => {
             const transform = ecd.getComponent(entity, Transform64);
 
@@ -240,9 +263,108 @@ export class TerrainSystem extends System {
             this.#place(entity, transform);
 
             this.#build_visible_tiles(terrain);
+
+            const entry = this.#entries.get(entity);
+
+            if (entry !== undefined) {
+                this.#sync_material(entry);
+            }
         });
     }
 
+    /**
+     * Bring the terrain's material in line with the terrain. Everything here is compared before it
+     * is written: the uniform fields move the material's version, which restages its metadata row
+     * and the resident material mirror, so they move it only when one of them changed; the images
+     * are handed over by identity, and the template uploads one only when its own version moves.
+     *
+     * @param {{terrain: Terrain, material: TerrainShadeMaterial, tiles: Map<TerrainTile, number>}} entry
+     */
+    #sync_material(entry) {
+        const terrain = entry.terrain;
+        const material = entry.material;
+
+        const world_x = terrain.size.x * terrain.gridScale;
+        const world_y = terrain.size.y * terrain.gridScale;
+
+        const grid_transform = terrain.gridTransform;
+
+        const layers = terrain.layers;
+        const layer_count = layers.count();
+
+        let changed = false;
+
+        changed = assign(material.inv_world_size, 0, 1 / world_x) || changed;
+        changed = assign(material.inv_world_size, 1, 1 / world_y) || changed;
+
+        changed = assign(material.grid_transform, 0, grid_transform.scale_x) || changed;
+        changed = assign(material.grid_transform, 1, grid_transform.scale_y) || changed;
+        changed = assign(material.grid_transform, 2, grid_transform.offset_x) || changed;
+        changed = assign(material.grid_transform, 3, grid_transform.offset_y) || changed;
+
+        changed = assign(material.grid_resolution, 0, terrain.size.x) || changed;
+        changed = assign(material.grid_resolution, 1, terrain.size.y) || changed;
+
+        if (material.layer_count !== layer_count) {
+            material.layer_count = layer_count;
+
+            changed = true;
+        }
+
+        if (changed) {
+            material.needsUpdate = true;
+        }
+
+        if (material.layer_scales.length < layer_count * 2) {
+            material.layer_scales = new Float32Array(layer_count * 2);
+        }
+
+        // the legacy `updateLayerScales`, computed at the source instead of read off a texture
+        let scales_changed = false;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers.get(i);
+
+            scales_changed = assign(material.layer_scales, i * 2, world_x / layer.size.x) || scales_changed;
+            scales_changed = assign(material.layer_scales, i * 2 + 1, world_y / layer.size.y) || scales_changed;
+        }
+
+        if (scales_changed) {
+            material.layer_scales_version++;
+        }
+
+        const splat = terrain.splat;
+        const layer_image = layers.sampler;
+
+        if (layer_count > 0 && entry.tiles.size > 0) {
+            // `Terrain.build` and `addLayer` keep all three in step; a mismatch is an upstream bug
+            // that would draw the wrong layer, silently. Asked only once something draws, as the
+            // splat pass asked it, so a terrain part-way through loading its layers is left alone.
+            assert.equal(splat.depth, layer_count, 'splat weight layers disagree with the layer list');
+            assert.equal(layer_image.depth, layer_count, 'layer texture depth disagrees with the layer list');
+        }
+
+        // the authored stores themselves, not copies — the upload watches these identities and
+        // versions
+        const weights = material.weights;
+
+        weights.data = splat.weightData;
+        weights.width = splat.size.x;
+        weights.height = splat.size.y;
+        weights.depth = splat.depth;
+        weights.version = splat.weights.version;
+
+        const layer_texture = material.layers;
+
+        layer_texture.data = layer_image.data;
+        layer_texture.width = layer_image.width;
+        layer_texture.height = layer_image.height;
+        layer_texture.depth = layer_image.depth;
+        layer_texture.version = layer_image.version;
+
+        material.overlay = terrain.overlay.sampler;
+    }
+
     /**
      * Ask for the tiles the camera can see. The manager owns what that costs — a tile already built
      * or already building is not requested again.
@@ -431,7 +553,8 @@ export class TerrainSystem extends System {
 
         entry.tiles.clear();
 
-        entry.renderer.destroy();
+        // the tiles that drew with it are gone; its textures go with it
+        this.#materials()?.release(entry.material);
 
         this.#entries.delete(entity);
     }
@@ -454,7 +577,7 @@ export class TerrainSystem extends System {
         const url = terrain.overlay.baseTileImage;
 
         if (url === WHITE_PIXEL_DATA_URL) {
-            entry.sprite = WHITE_SPRITE;
+            entry.material.sprite = WHITE_SPRITE;
 
             return;
         }
@@ -465,150 +588,28 @@ export class TerrainSystem extends System {
                 return;
             }
 
-            entry.sprite = sampler2d_ensure_uint8_RGBA(asset.create());
+            entry.material.sprite = sampler2d_ensure_uint8_RGBA(asset.create());
         });
     }
-
-    /**
-     * Everything the splat pass draws one terrain from. What the pass consumes and what a gate
-     * inspects are deliberately the same object — the same reason `DecalSystem` exposes its
-     * packed records.
-     *
-     * @param {number} entity
-     * @returns {object|null} `null` when this terrain has nothing to texture — no tiles built
-     */
-    splat_frame(entity) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined || entry.tiles.size === 0) {
-            return null;
-        }
-
-        const packed = pack_terrain_row_table({ tiles: entry.tiles, table: entry.rows });
-
-        entry.rows = packed.table;
-
-        const terrain = entry.terrain;
-
-        const invertible = m4_invert(entry.world_to_terrain, terrain.transform);
-
-        assert.equal(invertible, true, 'terrain transform is not invertible');
-
-        const world_x = terrain.size.x * terrain.gridScale;
-        const world_y = terrain.size.y * terrain.gridScale;
-
-        entry.inv_world_size[0] = 1 / world_x;
-        entry.inv_world_size[1] = 1 / world_y;
-
-        const grid_transform = terrain.gridTransform;
-
-        entry.grid_transform[0] = grid_transform.scale_x;
-        entry.grid_transform[1] = grid_transform.scale_y;
-        entry.grid_transform[2] = grid_transform.offset_x;
-        entry.grid_transform[3] = grid_transform.offset_y;
-
-        entry.grid_resolution[0] = terrain.size.x;
-        entry.grid_resolution[1] = terrain.size.y;
-
-        const layers = terrain.layers;
-        const layer_count = layers.count();
-
-        if (entry.scales.length < layer_count * 2) {
-            entry.scales = new Float32Array(layer_count * 2);
-        }
-
-        // the legacy `updateLayerScales`, computed at the source instead of read off a texture
-        for (let i = 0; i < layer_count; i++) {
-            const layer = layers.get(i);
-
-            entry.scales[i * 2] = world_x / layer.size.x;
-            entry.scales[i * 2 + 1] = world_y / layer.size.y;
-        }
-
-        const splat = terrain.splat;
-        const layer_image = layers.sampler;
-
-        if (layer_count > 0) {
-            // `Terrain.build` and `addLayer` keep all three in step; a mismatch is an upstream bug
-            // that would draw the wrong layer, silently
-            assert.equal(splat.depth, layer_count, 'splat weight layers disagree with the layer list');
-            assert.equal(layer_image.depth, layer_count, 'layer texture depth disagrees with the layer list');
-        }
-
-        return {
-            rows: entry.rows,
-            row_count: packed.size,
-            scales: entry.scales,
-            layer_count,
-            world_to_terrain: entry.world_to_terrain,
-            inv_world_size: entry.inv_world_size,
-            grid_transform: entry.grid_transform,
-            grid_resolution: entry.grid_resolution,
-            weights: {
-                data: splat.weightData,
-                width: splat.size.x,
-                height: splat.size.y,
-                depth: splat.depth,
-                version: splat.weights.version
-            },
-            layer_image: {
-                data: layer_image.data,
-                width: layer_image.width,
-                height: layer_image.height,
-                depth: layer_image.depth,
-                version: layer_image.version
-            },
-            overlay: terrain.overlay.sampler,
-            sprite: entry.sprite
-        };
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame) {
-        for (const entity of this.#entries.keys()) {
-            const splat = this.splat_frame(entity);
-
-            if (splat === null) {
-                // nothing of this terrain on screen; the frame keeps the albedo it already had
-                continue;
-            }
-
-            splat.frame = frame;
-
-            this.#entries.get(entity).renderer.graph_draw(splat);
-        }
-    }
 }
 
 /**
- * The splat and the grid overlay are a full-screen pass writing a replacement albedo, so this is
- * {@link FramePhase.AfterGBuffer} — the one phase where the G-buffer may be published into.
+ * Write one element of a parameter array, saying whether it changed.
  *
- * Everything that paints on top of the ground declares itself after this rather than being
- * registered after it; {@link DecalExtension} is the one that does.
+ * @param {Float32Array} array
+ * @param {number} index
+ * @param {number} value
+ * @returns {boolean}
  */
-export class TerrainExtension extends RenderExtension {
-    name = "terrain";
-
-    phase = FramePhase.AfterGBuffer;
+function assign(array, index, value) {
+    // compared as the array stores it, or a value f32 cannot represent would read as changed forever
+    const stored = Math.fround(value);
 
-    /**
-     * @type {TerrainSystem}
-     */
-    #system;
-
-    /**
-     * @param {TerrainSystem} system
-     */
-    constructor(system) {
-        super();
-
-        this.#system = system;
+    if (array[index] === stored) {
+        return false;
     }
 
-    record(frame) {
-        this.#system.record(frame);
-    }
+    array[index] = stored;
+
+    return true;
 }