@woosh/meep-engine 3.64.0 → 3.65.0

package/src/shade/playground/grass_surfaces/read_grass_surfaces.js

@@ -0,0 +1,188 @@
+import {
+    GRASS_POOL_BAKED,
+    GRASS_POOL_FREE_COUNT,
+    GRASS_POOL_HEADER_WORDS,
+    GRASS_POOL_REMOVED,
+    GRASS_POOL_STARVED,
+    GRASS_SLOT_LAYER_COUNT,
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_FREE,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_SURFEL_COUNT,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z,
+    GRASS_SLOT_WANTED_FRAME,
+    GRASS_SLOT_WORDS,
+    GRASS_TILE_COLUMNS
+} from "../../renderer/grass/surface/GRASS_SURFACE.js";
+
+/**
+ * @typedef {object} GrassSlotReading
+ * @property {number} slot
+ * @property {number} surface the surface's `transforms` row
+ * @property {number} level
+ * @property {number} layer
+ * @property {number[]} tile `[x, z]`, in tiles of the level
+ * @property {number} state `GRASS_SLOT_STATE_*`
+ * @property {number} wanted_frame
+ * @property {number} layer_count
+ * @property {number} surfel_count
+ */
+
+/**
+ * @typedef {object} GrassSurfelReading
+ * @property {number} x column along the tile's x, `[0, GRASS_TILE_COLUMNS)`
+ * @property {number} z column along the tile's z
+ * @property {number} height along the frame's up axis
+ * @property {number} member the member's `meshes` row
+ * @property {number} clear_height
+ * @property {number} density
+ */
+
+/**
+ * Copy a range of a buffer off the device.
+ *
+ * @param {GPUDevice} device
+ * @param {GPUBuffer} buffer needs `COPY_SRC`
+ * @param {number} size bytes, a multiple of 4
+ * @returns {Promise<ArrayBuffer>}
+ */
+async function read_buffer(device, buffer, size) {
+    const staging = device.createBuffer({ size, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+
+    const encoder = device.createCommandEncoder();
+
+    encoder.copyBufferToBuffer(buffer, 0, staging, 0, size);
+
+    device.queue.submit([encoder.finish()]);
+
+    await staging.mapAsync(GPUMapMode.READ);
+
+    const copy = staging.getMappedRange().slice(0);
+
+    staging.unmap();
+    staging.destroy();
+
+    return copy;
+}
+
+/**
+ * Read the grass surfaces' pool off the device: its counters, every slot that is not free, and on request
+ * the surfels the slots hold. A playground's inspection tool; nothing in a frame calls it.
+ *
+ * @param {GPUDevice} device
+ * @param {import("../../renderer/grass/surface/GPUGrassSurfaces.js").GPUGrassSurfaces} surfaces
+ * @param {boolean} [with_surfels] also read the atlas, and give every slot its `surfels`
+ * @returns {Promise<{capacity: number, free_count: number, starved: number, baked: number, removed: number, listed: number, slots: (GrassSlotReading & {surfels?: GrassSurfelReading[]})[]}>}
+ *          `removed` is the records taken out of the directory since the pool was made, `listed` the records it holds
+ */
+export async function read_grass_surfaces(device, surfaces, with_surfels = false) {
+    const capacity = surfaces.slot_capacity;
+
+    if (capacity === 0) {
+        return { capacity: 0, free_count: 0, starved: 0, baked: 0, removed: 0, listed: 0, slots: [] };
+    }
+
+    const words = new Uint32Array(await read_buffer(device, surfaces.pool_buffer, (GRASS_POOL_HEADER_WORDS + capacity * GRASS_SLOT_WORDS) * 4));
+
+    /** @type {GrassSlotReading[]} */
+    const slots = [];
+
+    for (let slot = 0; slot < capacity; slot++) {
+        const record = GRASS_POOL_HEADER_WORDS + slot * GRASS_SLOT_WORDS;
+
+        if (words[record + GRASS_SLOT_STATE] === GRASS_SLOT_STATE_FREE) {
+            continue;
+        }
+
+        const level_layer = words[record + GRASS_SLOT_LEVEL_LAYER];
+
+        slots.push({
+            slot,
+            surface: words[record + GRASS_SLOT_SURFACE],
+            level: level_layer & 0xff,
+            layer: (level_layer >> 8) & 0xff,
+            tile: [words[record + GRASS_SLOT_TILE_X] | 0, words[record + GRASS_SLOT_TILE_Z] | 0],
+            state: words[record + GRASS_SLOT_STATE],
+            wanted_frame: words[record + GRASS_SLOT_WANTED_FRAME],
+            layer_count: words[record + GRASS_SLOT_LAYER_COUNT],
+            surfel_count: words[record + GRASS_SLOT_SURFEL_COUNT],
+        });
+    }
+
+    const result = {
+        capacity,
+        free_count: words[GRASS_POOL_FREE_COUNT],
+        starved: words[GRASS_POOL_STARVED],
+        baked: words[GRASS_POOL_BAKED],
+        removed: words[GRASS_POOL_REMOVED],
+        listed: new Uint32Array(await read_buffer(device, surfaces.directory_buffer, 8))[0],
+        slots,
+    };
+
+    if (!with_surfels) {
+        return result;
+    }
+
+    const atlas = surfaces.atlas;
+    const width = atlas.width;
+    const height = atlas.height;
+
+    // four words a texel
+    const staging = device.createBuffer({ size: width * height * 16, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+
+    const encoder = device.createCommandEncoder();
+
+    encoder.copyTextureToBuffer({ texture: atlas }, { buffer: staging, bytesPerRow: width * 16, rowsPerImage: height }, [width, height]);
+
+    device.queue.submit([encoder.finish()]);
+
+    await staging.mapAsync(GPUMapMode.READ);
+
+    const texels = new Uint32Array(staging.getMappedRange().slice(0));
+    const texel_floats = new Float32Array(texels.buffer);
+
+    staging.unmap();
+    staging.destroy();
+
+    const half = new Float16Array(1);
+    const half_bits = new Uint16Array(half.buffer);
+
+    for (const reading of slots) {
+        // a GPUTileAtlas2D: tiles in rows as wide as the texture
+        const row_slots = width / GRASS_TILE_COLUMNS;
+
+        const corner_x = (reading.slot % row_slots) * GRASS_TILE_COLUMNS;
+        const corner_z = Math.floor(reading.slot / row_slots) * GRASS_TILE_COLUMNS;
+
+        /** @type {GrassSurfelReading[]} */
+        const surfels = [];
+
+        for (let z = 0; z < GRASS_TILE_COLUMNS; z++) {
+            for (let x = 0; x < GRASS_TILE_COLUMNS; x++) {
+                const at = ((corner_z + z) * width + corner_x + x) * 4;
+                const member = texels[at + 2];
+
+                if (member === 0) {
+                    continue;
+                }
+
+                half_bits[0] = texels[at + 3] & 0xffff;
+
+                surfels.push({
+                    x,
+                    z,
+                    height: texel_floats[at],
+                    member,
+                    clear_height: half[0],
+                    density: (texels[at + 3] >>> 16) / 65535,
+                });
+            }
+        }
+
+        reading.surfels = surfels;
+    }
+
+    return result;
+}

package/src/shade/playground/probe_clipmap/index.html

@@ -124,6 +124,11 @@
 
     <hr>
 
+    <label>
+        <input type="checkbox" id="sun" checked>
+        <span>Sun <span class="hint">— the directional light; L flips it</span></span>
+    </label>
+
     <label>
         <span>Sun height</span>
         <input type="range" id="sun_elevation" min="2" max="88" value="62">

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAsSzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAuUzB"}

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

@@ -178,7 +178,11 @@ export async function start() {
     // a sun the sliders turn, whatever lights the file brought
     const sun = make_sunlight({ intensity: 7.2 });
 
-    place_light(scene, sun);
+    /**
+     * The sun's entity while it is in the scene, -1 while the toggle has it out.
+     * @type {number}
+     */
+    let sun_entity = place_light(scene, sun);
 
     const rotation = new Quaternion();
     const sun_direction = new Vector3();
@@ -229,6 +233,33 @@ export async function start() {
     element('sun_elevation').addEventListener('input', on_sun_input);
     element('sun_azimuth').addEventListener('input', on_sun_input);
 
+    const sun_toggle = element('sun');
+
+    /**
+     * Take the sun out of the scene, or put it back; out, it is gone from the lights, its shadows and the
+     * probes' hits alike, rather than dimmed to nothing.
+     * @param {boolean} enabled
+     */
+    function set_sun(enabled) {
+        sun_toggle.checked = enabled;
+
+        if (enabled === (sun_entity !== -1)) {
+            return;
+        }
+
+        if (enabled) {
+            sun_entity = place_light(scene, sun);
+        } else {
+            scene.lights.remove(sun);
+            scene.dataset.removeEntity(sun_entity);
+            sun_entity = -1;
+        }
+
+        lights_changed();
+    }
+
+    sun_toggle.addEventListener('change', event => set_sun(event.target.checked));
+
     load_default_environment(scene);
 
     // ---- controls -------------------------------------------------------------------------
@@ -311,6 +342,8 @@ export async function start() {
         } else if (event.code === 'KeyT') {
             ray_resampling_toggle.checked = !ray_resampling_toggle.checked;
             renderer.probe_clipmap.ray_resampling = ray_resampling_toggle.checked;
+        } else if (event.code === 'KeyL') {
+            set_sun(sun_entity === -1);
         }
     });
 

package/src/shade/playground/probe_clipmap_box/README.md

@@ -34,7 +34,8 @@ then open <http://localhost:5173/src/shade/playground/probe_clipmap_box/index.ht
 | Sun (1, 2, 3) | through the hole onto the red wall or the green wall, from 45°, or straight down onto the floor |
 | Hole open (H) | closed, a lid of the hole's size sits flush in the ceiling; it is placed into the scene and taken out again, so the bricks the rays march are rebuilt as a level's would be |
 | Indirect light | the probe clipmap, or IBL to compare against |
-| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches |
+| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches; the probes' indirect diffuse and indirect specular, each before the surface's material |
+| Roughness | every slab's, 1 as the box starts. The indirect specular view samples the probes at the surface's roughness: at 1 it is their SH alone, and toward 0.05 it is one tap of their radiance tiles along the reflection, the walls as the probes hold them. A slab keeps its geometry, so the bricks the rays march do not change |
 | Restart GI (K) | gives the clipmaps back and builds them again from nothing, the geometry caches kept: a cold start without a reload |
 | Path tracer (P) | the accumulating path tracer, three bounces, for context; TAA is off while it is on |
 | TAA | the resolve the probe pick's noise is meant for |
@@ -47,6 +48,9 @@ The stats line counts the frames since the sun or the hole last changed.
 - **Hole closed**: the inside should go black. Whatever light stays is what the probes still hold.
 - **Sun moved between the walls**: the colour bleeding onto the back wall and the floor should swap from red
   to green.
+- **Indirect specular, roughness low**: the reflections are the probes' 16 × 16 radiance tiles, tapped along the
+  reflection with no parallax (the proposal's §9.3, "Parallax correction"): the walls show blurred, and placed as
+  if they were far.
 - **Restart**: until the brick clipmap has built (about 48 frames at the default build budget), the rays see
   no walls and every probe sees the sky; the light then has to drain out of the probes.
 

package/src/shade/playground/probe_clipmap_box/index.html

@@ -128,9 +128,21 @@
             <option value="BrickClipmap">Brick clipmap — what the rays see</option>
             <option value="MeshSDF">Mesh SDF — the geometry caches</option>
             <option value="MeshSurfaces">Mesh surfaces — each mesh's surface cache</option>
+            <option value="IndirectDiffuse">Indirect diffuse — the probes' irradiance / π, before the material</option>
+            <option value="IndirectSpecular">Indirect specular — the probes' radiance, before the material</option>
         </select>
     </label>
 
+    <label>
+        <span>Roughness</span>
+        <input type="range" id="roughness" min="0.05" max="1" step="0.05" value="1">
+        <output id="roughness_value"></output>
+    </label>
+    <p class="note">
+        Every slab's. At 1 the indirect specular view shows the probes' SH alone; lower it to see the reflections
+        their radiance tiles hold.
+    </p>
+
     <label>
         <span>Restart GI</span>
         <button id="restart">Restart</button>

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap_box/main.js"],"names":[],"mappings":"AAsEA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAwPzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap_box/main.js"],"names":[],"mappings":"AAsEA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAuQzB"}

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

@@ -123,6 +123,7 @@ export async function start() {
     const box = await build_hole_box(scene, scene_context, {
         aim: BoxSunAim[element('sun_aim').value],
         open: element('hole_open').checked,
+        roughness: Number(element('roughness').value),
     });
 
     // inside, against the front wall, looking at the back one: both coloured walls and the floor in view
@@ -210,6 +211,20 @@ export async function start() {
 
     element('restart').addEventListener('click', restart_gi);
 
+    const roughness_slider = element('roughness');
+
+    function show_roughness() {
+        element('roughness_value').textContent = Number(roughness_slider.value).toFixed(2);
+    }
+
+    show_roughness();
+    roughness_slider.addEventListener('input', show_roughness);
+    // on release: every stop on the way would be ten materials of its own
+    roughness_slider.addEventListener('change', () => {
+        box.roughness = Number(roughness_slider.value);
+        box_changed();
+    });
+
     const exposure_slider = element('exposure');
 
     function show_exposure() {

package/src/shade/playground/probe_clipmap_box/scene.d.ts

@@ -46,16 +46,23 @@ export function box_lid(): {
  * @param {number[]} [options.sky] linear radiance of the flat sky
  * @param {BoxSunAim} [options.aim]
  * @param {boolean} [options.open]
+ * @param {number} [options.roughness] every slab's, 1 the Cornell box's own
  */
-export function build_hole_box(scene: import("../../renderer/scene/Scene.js").Scene, scene_context: import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext, { sun_intensity, sky, aim, open, }?: {
+export function build_hole_box(scene: import("../../renderer/scene/Scene.js").Scene, scene_context: import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext, { sun_intensity, sky, aim, open, roughness, }?: {
     sun_intensity?: number;
     sky?: number[];
     aim?: BoxSunAim;
     open?: boolean;
+    roughness?: number;
 }): Promise<{
     sun: import("../../renderer/light/model/DirectionalLight.js").DirectionalLight;
     aim: number;
     open: boolean;
+    /**
+     * Every slab's roughness.
+     * @returns {number}
+     */
+    roughness: number;
 }>;
 /**
  * The inside of the box, a side, metres: x and z in [−½, ½] of it, y in [0, 1] of it. Five probe spacings of

package/src/shade/playground/probe_clipmap_box/scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap_box/scene.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,uCAJW,OAAO,OACP,SAAS,GACP,OAAO,CAgBnB;AAED;;;;;;;GAOG;AACH,6BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,EAAE,CAwBhF;AAED;;;;GAIG;AACH,2BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,CAI9E;AAgBD;;;;;;;;;;;;;;;GAeG;AACH,sCARW,OAAO,+BAA+B,EAAE,KAAK,iBAC7C,OAAO,yCAAyC,EAAE,eAAe;IAEhD,aAAa,GAA9B,MAAM;IACa,GAAG,GAAtB,MAAM,EAAE;IACY,GAAG,GAAvB,SAAS;IACS,IAAI,GAAtB,OAAO;;;;;GAuGjB;AAnPD;;;;GAIG;AACH,yBAFU,MAAM,CAEY;AAE5B;;;;GAIG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;;GAIG;AACH,qCAFU,MAAM,CAEyB;;;;wBAY/B,MAAM;;;;;;oBA/CI,+BAA+B"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap_box/scene.js"],"names":[],"mappings":"AA6DA;;;;;;GAMG;AACH,uCAJW,OAAO,OACP,SAAS,GACP,OAAO,CAgBnB;AAED;;;;;;;GAOG;AACH,6BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,EAAE,CAwBhF;AAED;;;;GAIG;AACH,2BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,CAI9E;AAiBD;;;;;;;;;;;;;;;;GAgBG;AACH,sCATW,OAAO,+BAA+B,EAAE,KAAK,iBAC7C,OAAO,yCAAyC,EAAE,eAAe;IAEhD,aAAa,GAA9B,MAAM;IACa,GAAG,GAAtB,MAAM,EAAE;IACY,GAAG,GAAvB,SAAS;IACS,IAAI,GAAtB,OAAO;IACU,SAAS,GAA1B,MAAM;;;;;IA+HT;;;OAGG;;GAsCV;AAtTD;;;;GAIG;AACH,yBAFU,MAAM,CAEY;AAE5B;;;;GAIG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;;GAIG;AACH,qCAFU,MAAM,CAEyB;;;;wBAY/B,MAAM;;;;;;oBAhDI,+BAA+B"}

package/src/shade/playground/probe_clipmap_box/scene.js

@@ -7,6 +7,7 @@ import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshop
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { place_light } from "../../renderer/light/place_light.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { place_primitive, remove_primitive } from "../../renderer/scene/rows/place_primitive.js";
 import { make_flat_environment } from "../skinned_blas_refit/flat_environment.js";
 
@@ -124,13 +125,14 @@ export function box_lid() {
 
 /**
  * @param {number[]} rgb linear
+ * @param {number} roughness
  * @returns {StandardShadeMaterial}
  */
-function diffuse(rgb) {
+function dielectric(rgb, roughness) {
     const material = new StandardShadeMaterial();
 
     material.diffuse_color.copy(new Color(rgb[0], rgb[1], rgb[2]));
-    material.roughness_factor = 1;
+    material.roughness_factor = roughness;
     material.metallic_factor = 0;
 
     return material;
@@ -151,12 +153,14 @@ function diffuse(rgb) {
  * @param {number[]} [options.sky] linear radiance of the flat sky
  * @param {BoxSunAim} [options.aim]
  * @param {boolean} [options.open]
+ * @param {number} [options.roughness] every slab's, 1 the Cornell box's own
  */
 export async function build_hole_box(scene, scene_context, {
     sun_intensity = 7.2,
     sky = [0.2, 0.25, 0.35],
     aim = BoxSunAim.RedWall,
     open = true,
+    roughness = 1,
 } = {}) {
     // meshlet geometry is built as it is made
     await MeshoptClusterizer.ready;
@@ -176,13 +180,42 @@ export async function build_hole_box(scene, scene_context, {
         return place_primitive(scene_context, geometry, material, transform, { name: slab.name });
     }
 
-    for (const slab of box_slabs()) {
-        place(slab, new BoxGeometry(slab.size[0], slab.size[1], slab.size[2]), diffuse(slab.colour));
+    /**
+     * A slab's material at a roughness, made once. A material's GPU side does not change after its upload, so a
+     * slab at another roughness draws with another material.
+     * @type {Map<string, StandardShadeMaterial>}
+     */
+    const materials = new Map();
+
+    /**
+     * @param {{name: string, colour: number[]}} slab
+     * @param {number} value
+     * @returns {StandardShadeMaterial}
+     */
+    function material_of(slab, value) {
+        const key = `${slab.name}/${value}`;
+
+        let material = materials.get(key);
+
+        if (material === undefined) {
+            material = dielectric(slab.colour, value);
+
+            materials.set(key, material);
+        }
+
+        return material;
     }
 
+    let current_roughness = roughness;
+
+    const slabs = box_slabs().map(slab => {
+        const geometry = new BoxGeometry(slab.size[0], slab.size[1], slab.size[2]);
+
+        return { slab, geometry, entity: place(slab, geometry, material_of(slab, current_roughness)) };
+    });
+
     const lid = box_lid();
     const lid_geometry = new BoxGeometry(lid.size[0], lid.size[1], lid.size[2]);
-    const lid_material = diffuse(lid.colour);
 
     /**
      * The lid's entity while it closes the hole, -1 while the hole is open.
@@ -243,7 +276,42 @@ export async function build_hole_box(scene, scene_context, {
                 remove_primitive(scene_context, lid_entity);
                 lid_entity = -1;
             } else {
-                lid_entity = place(lid, lid_geometry, lid_material);
+                lid_entity = place(lid, lid_geometry, material_of(lid, current_roughness));
+            }
+        },
+
+        /**
+         * Every slab's roughness.
+         * @returns {number}
+         */
+        get roughness() {
+            return current_roughness;
+        },
+
+        /**
+         * Each slab keeps its entity and its geometry and draws with a material of the new roughness, so the
+         * distance field the rays march does not change.
+         *
+         * @param {number} v in [0, 1]
+         */
+        set roughness(v) {
+            if (v === current_roughness) {
+                return;
+            }
+
+            current_roughness = v;
+
+            const placed = slabs.map(s => [s.entity, s.slab, s.geometry]);
+
+            if (lid_entity !== -1) {
+                placed.push([lid_entity, lid, lid_geometry]);
+            }
+
+            for (const [entity, slab, geometry] of placed) {
+                const material = material_of(slab, v);
+
+                scene.dataset.getComponent(entity, ShadedGeometry).material = material;
+                scene_context.rows.attach_mesh(entity, geometry, material);
             }
         },
 

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -2824,49 +2824,8 @@ export class Renderer {
 
         const gr_shadowmap_atlas = graph_import_texture(graph, sm.texture);
 
-        // The frame's surface handles exist now, so this is where the records that carry them are
-        // published. There is no colour yet, which is what makes this the phase for G-buffer work.
-        frame.phase = FramePhase.AfterGBuffer;
-
-        const record_gbuffer = frame.create(GBufferTextures);
-        const record_view_textures = frame.create(ViewTextures);
-
-        record_gbuffer.albedo = gr_texture_material_albedo_ao;
-        record_gbuffer.normal = gr_texture_normal;
-        record_gbuffer.pbr = gr_texture_pbr;
-        record_gbuffer.emissive = gr_texture_material_emissive;
-
-        record_view_textures.depth = gr_texture_depth_current;
-        record_view_textures.depth_previous = gr_texture_depth_previous;
-        record_view_textures.visibility = gr_visibility;
-        record_view_textures.visible_meshlets = gr_visible_meshlets;
-
-        this.#extensions.run(frame);
-
-        /*
-         `GBufferTextures` is in/out at this phase, and frozen after it. An extension that wants to
-         *change* surface properties — decals are the reason this exists — cannot blend into these
-         targets: two of the four are integer formats, and one texture cannot be a render attachment
-         and a sampled source in the same pass. So it reads a copy — of the targets, or of the part
-         it changes — and writes, and publishes the handles it wrote. Everything downstream carries
-         what it left.
-
-         Publishing is what makes it a contract. A written handle is a *renamed* clone of the same
-         physical resource, so a change written in place and not published would land in the
-         texture the shading pass reads only because the graph happens to execute in insertion
-         order, with no dependency edge saying so. Threading the handles makes the edge real,
-         whether they name replacements or the originals written through `write`.
-        */
-        gr_texture_pbr = record_gbuffer.pbr;
-        gr_texture_normal = record_gbuffer.normal;
-        gr_texture_material_albedo_ao = record_gbuffer.albedo;
-        gr_texture_material_emissive = record_gbuffer.emissive;
-
-        gr_texture_depth_current = record_view_textures.depth;
-        gr_texture_depth_previous = record_view_textures.depth_previous;
-        gr_visibility = record_view_textures.visibility;
-        gr_visible_meshlets = record_view_textures.visible_meshlets;
-
+        // Ahead of the phase below, from the scene's own depth and visibility: an extension that draws
+        // surfaces the visibility buffer cannot describe writes their motion over this.
         // Velocity pass with three branches: rotation-reprojection
         // background, rigid per-object foreground (mesh.global delta),
         // and skinned per-vertex foreground (barycentric interpolation
@@ -2924,6 +2883,51 @@ export class Renderer {
             view: view_ctx,
         });
 
+        // The frame's surface handles exist now, so this is where the records that carry them are
+        // published. There is no colour yet, which is what makes this the phase for G-buffer work.
+        frame.phase = FramePhase.AfterGBuffer;
+
+        const record_gbuffer = frame.create(GBufferTextures);
+        const record_view_textures = frame.create(ViewTextures);
+
+        record_gbuffer.albedo = gr_texture_material_albedo_ao;
+        record_gbuffer.normal = gr_texture_normal;
+        record_gbuffer.pbr = gr_texture_pbr;
+        record_gbuffer.emissive = gr_texture_material_emissive;
+
+        record_view_textures.depth = gr_texture_depth_current;
+        record_view_textures.depth_previous = gr_texture_depth_previous;
+        record_view_textures.visibility = gr_visibility;
+        record_view_textures.visible_meshlets = gr_visible_meshlets;
+        record_view_textures.velocity = gr_velocity;
+
+        this.#extensions.run(frame);
+
+        /*
+         `GBufferTextures` is in/out at this phase, and frozen after it. An extension that wants to
+         *change* surface properties — decals are the reason this exists — cannot blend into these
+         targets: two of the four are integer formats, and one texture cannot be a render attachment
+         and a sampled source in the same pass. So it reads a copy — of the targets, or of the part
+         it changes — and writes, and publishes the handles it wrote. Everything downstream carries
+         what it left.
+
+         Publishing is what makes it a contract. A written handle is a *renamed* clone of the same
+         physical resource, so a change written in place and not published would land in the
+         texture the shading pass reads only because the graph happens to execute in insertion
+         order, with no dependency edge saying so. Threading the handles makes the edge real,
+         whether they name replacements or the originals written through `write`.
+        */
+        gr_texture_pbr = record_gbuffer.pbr;
+        gr_texture_normal = record_gbuffer.normal;
+        gr_texture_material_albedo_ao = record_gbuffer.albedo;
+        gr_texture_material_emissive = record_gbuffer.emissive;
+
+        gr_texture_depth_current = record_view_textures.depth;
+        gr_texture_depth_previous = record_view_textures.depth_previous;
+        gr_visibility = record_view_textures.visibility;
+        gr_visible_meshlets = record_view_textures.visible_meshlets;
+        gr_velocity = record_view_textures.velocity;
+
         // rg8unorm: r is the history confidence, g records which texel won the nearest-depth search,
         // so the TAA resolve can reproject with exactly the velocity this pass validated.
         let [gr_occlusion_clip] = graph_image_pass({

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -1,14 +1,10 @@
 /**
  * What the frame knows about where each pixel came from: this frame's depth, last frame's depth,
- * the visibility buffer, and the visible-meshlet table that resolves it.
+ * the visibility buffer, the visible-meshlet table that resolves it, and how far each pixel moved.
  *
  * Carried from {@link FramePhase.AfterGBuffer} through {@link FramePhase.BeforePresent}, and
  * writable wherever it is carried — an extension that rasterizes geometry which should own depth
  * publishes a replacement here, the same way any other record is published into.
- *
- * `velocity` is deliberately absent: it is one of the frame's optional products, and products are
- * their own delivery step. A field nothing may legally read yet would be a promise with no
- * mechanism behind it.
  */
 export class ViewTextures extends FrameRecord {
     static is_present_at(phase: any): boolean;
@@ -43,6 +39,17 @@ export class ViewTextures extends FrameRecord {
      * @returns {number}
      */
     get visible_meshlets(): number;
+    set velocity(handle: number);
+    /**
+     * How far each pixel's surface moved on screen since the last frame: `rg16float`, in pixels, this
+     * frame's place less last frame's, free of the sub-pixel jitter. The renderer fills it from depth and
+     * {@link visibility} before {@link FramePhase.AfterGBuffer}; an extension that draws surfaces the
+     * visibility buffer cannot describe writes their pixels' motion over it at that phase and publishes
+     * the handle it wrote. What is published later than that phase reaches nothing the renderer runs.
+     *
+     * @returns {number}
+     */
+    get velocity(): number;
     #private;
 }
 import { FrameRecord } from "./FrameRecord.js";

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;;CAKJ;4BAjF2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAOI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;IAmBD,6BAEC;IAfD;;;;;;;;OAQG;IACH,uBAEC;;CAKJ;4BA/F2B,kBAAkB"}