@woosh/meep-engine 3.41.0 → 3.43.0

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

@@ -25,11 +25,12 @@ import { ParticipatingMediaVolume } from "../../renderer/volumetrics/Participati
 import { water_medium_preset } from "../../renderer/medium/water/water_presets.js";
 import { water_finalize_shader_brick4, water_finalize_shader_ibl, water_shader } from "../../renderer/water/shader_water.js";
 import * as water_shaders from "../../renderer/water/shader_water_avboit.js";
-import { shader_water_bodies_derive } from "../../renderer/water/medium/shader_water_bodies_derive.js";
-import { shader_water_meshlet_counts, shader_water_meshlets_expand } from "../../renderer/water/medium/shader_water_meshlets.js";
-import { shader_water_wave_batch, shader_water_wave_batch_finish } from "../../renderer/water/surface/shader_water_wave_batch.js";
-import { shader_water_wave_domain, shader_water_wave_bounds } from "../../renderer/water/surface/shader_water_wave_domain.js";
-import { shader_water_tiles } from "../../renderer/water/surface/shader_water_tiles.js";
+import { shader_water_meshlets_expand } from "../../renderer/water/medium/shader_water_meshlets.js";
+import * as spectrum_shaders from "../../renderer/water/surface/spectrum/shader_water_spectrum.js";
+import * as particle_shaders from "../../renderer/water/surface/particles/shader_water_particles.js";
+import * as cull_shaders from "../../renderer/water/surface/shader_water_cull.js";
+import * as lod_shaders from "../../renderer/water/surface/lod/shader_water_lod.js";
+import { shader_water_waves_combine } from "../../renderer/water/surface/shader_water_waves_combine.js";
 import { install_profile_hotkey } from "../profile_hotkey.js";
 import { build_world } from "./world.js";
 
@@ -164,9 +165,9 @@ async function main() {
         if(!ready)return;
         const device=graphics.renderer.graphics.device,errors=[];
         for(const shader of [water_shader,water_finalize_shader_ibl,water_finalize_shader_brick4,
-            ...[shader_water_bodies_derive,shader_water_meshlet_counts,shader_water_meshlets_expand,
-                shader_water_wave_batch,shader_water_wave_batch_finish,shader_water_wave_domain,shader_water_wave_bounds,
-                shader_water_tiles,...Object.values(water_shaders)].map(s=>s.descriptor)]){
+            ...[shader_water_meshlets_expand,shader_water_waves_combine,...Object.values(spectrum_shaders),
+                ...Object.values(particle_shaders),...Object.values(cull_shaders),...Object.values(lod_shaders),
+                ...Object.values(water_shaders)].map(s=>s?.descriptor)]){
             if(typeof shader?.source!=="string")continue;
             const module=device.createShaderModule({code:shader.source});const info=await module.getCompilationInfo();
             errors.push(...info.messages.filter(m=>m.type==="error").map(m=>`${m.lineNum}: ${m.message}`));

package/src/shade/playground/water_refraction/world.js

@@ -93,7 +93,7 @@ export async function build_world(dataset) {
         water_normals[i]=0;water_normals[i+1]=1;water_normals[i+2]=0;
     }
     const water_geometry=meshlets(water_plane),water_transform=pose(16,0,16);
-    // the primitive wave simulation's forcing; the overlapping second body below has none and stays calm
+    // the wind that raises its waves; the overlapping second body below has none and stays calm
     const waves=new WaterWaves();
     const water_entity=build(new Entity().add(water).add(waves).add(water_geometry).add(water_transform));
     const add_mesh=(geo,m,x,y,z,rotation)=>{

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

@@ -0,0 +1,43 @@
+# Water / surface
+
+One scene, four bodies of water, from a cup to an ocean: the surface simulation of
+`WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md` at every scale it has to work at.
+
+| Stop | Body | Mesh | Wind | What to look for |
+|---|---|---|---|---|
+| Cup | 4 cm of tea on a table | a 32-segment disk | 2 m/s | centimetre ripples at most; a click rings the cup and the wall sends it back |
+| Puddle | 2 m across, 1 cm deep | a wobbly disk | 4 m/s | rain (the checkbox) is the point here: rings of a few millimetres that die within a second |
+| Lake | 120 × 60 m in a basin | its outline only | 6 m/s | short wind waves over the checkered bed; splashes reflect off the shore at 0.3 |
+| Ocean | 5 km disk round an island hole | an annulus | 10 m/s, 200 km of sea upwind | swell; the island's outline reflects particles |
+
+Every body is an ordinary entity: `Water` + `WaterWaves` + `MeshletGeometry` + `Transform64`. The meshes
+author outlines; the surface's detail comes from the waves. Nothing in the scene is specific to its scale: the
+wind and the fetch set each body's spectrum (fetch-limited JONSWAP over the body's extent along the wind,
+plus `upwindFetch`), and all four share the same 18 spectral bands and one wave-particle pool.
+
+## Controls
+
+- **Scale** buttons move the camera and set its near and far planes for the stop.
+- **Wind ×** scales every body's own wind speed; **Direction** turns all of them. A change of direction
+  turns the waves over four seconds.
+- **Click** the water to splash it, with a radius suited to the stop and the **Kick** speed. **Rain** drops
+  splashes on the current stop's body at the chosen rate.
+- **Measure GPU** records 2.5 s of frames and lists the surface passes in µs per frame. **Profile (T)**
+  saves a full `.sgpt` capture.
+
+## What it shows and what it does not
+
+The floors under the water are checkered so refraction shows the slopes without a sky. The page asks for the
+default octahedral sky (`/test_assets/environments/octahedral/rustig_koppie_puresky_2k.hdr`); without it,
+reflections show the procedural sky only, and the ocean, seen from above its deep water, reads dark and flat
+except where it refracts the island's slope.
+
+The ocean stop puts the camera 9 m above the sea; at the wind slider's top (20 m/s) the camera is among the waves.
+The surface is cut from a distance-LOD lattice (`WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md`), so the waves
+near the camera keep their cells however tall they are.
+
+Measured on an RTX 4090, 1058 × 746 (headless Chrome, 2026-10-06), the ocean at 20 m/s from 9 m, with a fixed load
+holding the GPU's clocks: culling 17 µs, band spectrum 30 µs (the bands the view can draw), bounds 7 µs, lattice passes
+232 µs and scans 61 µs for 2,820 patches, 176,000 interior and 146,000 boundary cells; the two surface passes 1.06 and
+1.50 ms, of which ~0.25 ms each shades the waves too short for the cells per pixel. Bodies out of view cost one culling thread each: 4,000 added under 2 µs. The GPU lowers its clocks on a light
+frame, so time a pass against another setting in the same capture, or with a fixed load beside it.

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

@@ -0,0 +1,30 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Water · surface at every scale</title>
+<style>
+:root{color-scheme:dark;font:14px/1.45 system-ui,sans-serif;color:#d6e4ea;background:#10161b}*{box-sizing:border-box}
+body{margin:0;display:grid;grid-template-columns:minmax(0,1fr) 320px;grid-template-rows:minmax(0,1fr);height:100vh;overflow:hidden}
+#viewport{min-width:0;min-height:0;overflow:hidden;position:relative;outline:none}#viewport canvas{width:100%;height:100%}
+aside{padding:20px;overflow:auto;border-left:1px solid #2d3a42;background:#151e25}h1{font-size:20px;margin:0 0 6px}h2{font-size:13px;color:#8cb9bf;text-transform:uppercase;letter-spacing:.07em;margin:22px 0 9px}
+p{margin:8px 0;color:#9faeb9;font-size:12px}label{display:flex;align-items:center;justify-content:space-between;gap:8px;margin:8px 0}
+input[type=range]{width:130px}input,select,button{font:inherit;background:#202d36;border:1px solid #3c505e;border-radius:5px;color:#e2edf0;padding:5px}button{cursor:pointer}button:hover{background:#304753}
+.row{display:flex;gap:6px;flex-wrap:wrap}pre{white-space:pre-wrap;overflow-wrap:anywhere;font:11px/1.5 monospace;color:#8bd3d5;background:#0c151b;padding:10px;border-radius:5px}
+#status{border-left:3px solid #70b8b5;padding:10px;font-size:12px;background:#1d2c32}#badge{position:absolute;top:16px;left:16px;pointer-events:none;background:#13242cd9;padding:8px 12px;border-radius:5px;color:#c7eff0;font-size:12px}
+</style></head>
+<body tabindex="0"><div id="viewport" tabindex="0"><div id="badge">Drag to orbit · wheel to zoom · click the water to splash</div></div>
+<aside><h1>Water / surface</h1><p>One spectrum and one particle pool for a cup, a puddle, a lake and an ocean.</p><div id="status">Starting renderer…</div>
+<h2>Scale</h2>
+<div class="row"><button class="stop" data-stop="cup">Cup</button><button class="stop" data-stop="puddle">Puddle</button><button class="stop" data-stop="lake">Lake</button><button class="stop" data-stop="ocean">Ocean</button><button class="stop" data-stop="aerial">Ocean, aerial</button></div>
+<h2>Wind</h2>
+<label>Wind × each body's own<input id="wind" type="range" min="0" max="2" step=".05" value="1"></label>
+<label>Direction °<input id="direction" type="range" min="0" max="360" step="1" value="30"></label>
+<pre id="winds"></pre>
+<h2>Splashes</h2>
+<label>Kick m/s<input id="kick" type="range" min="0.1" max="4" step=".1" value="1.5"></label>
+<label>Rain on this body<input id="rain" type="checkbox"></label>
+<label>Drops per second<input id="rate" type="range" min="1" max="200" step="1" value="40"></label>
+<div class="row"><button id="pause">Pause</button><button id="measure">Measure GPU</button><button id="profile">Profile (T)</button></div>
+<pre id="report">Measure records 2.5 s of frames and lists the surface passes, µs per frame.</pre>
+</aside>
+<script type="module" src="./main.js"></script>
+</body></html>

package/src/shade/playground/water_surface/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_surface/main.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,154 @@
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../engine/ecs/EntityManager.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { Light } from "../../../engine/graphics/ecs/light/Light.js";
+import { GraphicsEngine } from "../../../engine/graphics3/GraphicsEngine.js";
+import { LightSystem } from "../../../engine/graphics3/LightSystem.js";
+import { ShadedGeometrySystem } from "../../../engine/graphics3/ShadedGeometrySystem.js";
+import { WaterSystem } from "../../../engine/graphics3/WaterSystem.js";
+import { GPUProfileLevel } from "../../device/timing/profile/GPUProfileLevel.js";
+import { GPUProfileSession } from "../../device/timing/profile/GPUProfileSession.js";
+import { sgpt_read_capture } from "../../device/timing/profile/sgpt_read_capture.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { load_default_environment } from "../load_default_environment.js";
+import { install_profile_hotkey } from "../profile_hotkey.js";
+import { build_world } from "./world.js";
+
+const element = id => document.getElementById(id);
+const number = id => Number(element(id).value);
+
+/** Where each stop looks from, its near and far planes, and the splash and raindrop radii there. */
+const STOPS = {
+    cup: { body: 'cup', eye: [0.16, 0.98, 0.16], target: [0, 0.83, 0], near: 0.003, far: 400, splash: 0.005, drop: 0.002 },
+    puddle: { body: 'puddle', eye: [5.0, 0.9, 2.3], target: [4, 0, 1], near: 0.02, far: 2000, splash: 0.03, drop: 0.004 },
+    lake: { body: 'lake', eye: [22, 4, 188], target: [0, -1, 166], near: 0.1, far: 6000, splash: 0.3, drop: 0.01 },
+    ocean: { body: 'ocean', eye: [0, 9, 5000 + 150], target: [25, 0, 5000 + 230], near: 0.2, far: 12000, splash: 3, drop: 0.02 },
+    aerial: { body: 'ocean', eye: [700, 320, 4300], target: [0, 0, 5000], near: 0.5, far: 12000, splash: 3, drop: 0.02 },
+};
+
+async function main() {
+    const viewport = element("viewport"), graphics = new GraphicsEngine(), scene = new Scene();
+    viewport.appendChild(graphics.viewport.el);
+    const dataset = new EntityComponentDataset(), entities = new EntityManager();
+    const water_system = new WaterSystem(graphics, scene);
+    entities.addSystem(new ShadedGeometrySystem(graphics, scene));
+    entities.addSystem(new LightSystem(graphics, scene));
+    entities.addSystem(water_system);
+    entities.attachDataset(dataset);
+    await new Promise((resolve, reject) => entities.startup(resolve, reject));
+    const world = await build_world(dataset);
+    load_default_environment(scene);
+
+    const sun = new Light(); sun.intensity.set(2.4);
+    const sun_pose = new Transform64(), rotation = new Quaternion();
+    // low and ahead of the views, so its glitter path shows the slopes
+    rotation.fromUnitVectors(Vector3.forward, new Vector3(-0.15, -0.3, -0.94).normalize());
+    sun_pose.setRotation(rotation.x, rotation.y, rotation.z, rotation.w); sun_pose.updateMatrix();
+    new Entity().add(sun).add(sun_pose).build(dataset);
+
+    const camera = graphics.camera.camera, controller = new OrbitalCameraController(camera, viewport);
+    camera.fov = Math.PI / 3;
+    let stop = STOPS.cup;
+    function go(name) {
+        stop = STOPS[name];
+        camera.near = stop.near; camera.far = stop.far;
+        controller.look(new Vector3(...stop.eye), new Vector3(...stop.target));
+        for (const button of document.querySelectorAll("button.stop")) { button.style.borderColor = button.dataset.stop === name ? "#8dd3db" : ""; }
+    }
+    function configure() {
+        const lines = [];
+        for (const [name, body] of Object.entries(world.bodies)) {
+            body.waves.windSpeed.set(body.base_wind * number("wind"));
+            body.waves.windDirection.set(number("direction") * Math.PI / 180);
+            lines.push(`${name.padEnd(7)} ${(body.base_wind * number("wind")).toFixed(1)} m/s${body.waves.upwindFetch.getValue() > 0 ? `, ${body.waves.upwindFetch.getValue() / 1000} km of sea upwind` : ''}`);
+        }
+        element("winds").textContent = lines.join("\n");
+    }
+    const report = message => { element("status").textContent = message; };
+    for (const id of ["wind", "direction"]) { element(id).addEventListener("input", configure); }
+    for (const button of document.querySelectorAll("button.stop")) { button.onclick = () => go(button.dataset.stop); }
+    configure(); go("cup");
+
+    // a click splashes where its ray meets the stop's body at rest
+    const inverse = new Float64Array(16);
+    function splash_at(u, v, radius) {
+        const body = world.bodies[stop.body];
+        if (!m4_invert(inverse, camera.view_projection_matrix)) { return; }
+        const unproject = z => {
+            const x = 2 * u - 1, y = 1 - 2 * v;
+            const w = inverse[3] * x + inverse[7] * y + inverse[11] * z + inverse[15];
+            return [0, 1, 2].map(i => (inverse[i] * x + inverse[4 + i] * y + inverse[8 + i] * z + inverse[12 + i]) / w);
+        };
+        const near = unproject(1), far = unproject(0.5);
+        const direction = far.map((value, i) => value - near[i]);
+        if (Math.abs(direction[1]) < 1e-9) { return; }
+        const t = (body.level - near[1]) / direction[1];
+        if (!(t > 0)) { return; }
+        water_system.splash(body.entity, near.map((value, i) => value + direction[i] * t), radius, number("kick"));
+    }
+    viewport.addEventListener("click", event => {
+        const rect = viewport.getBoundingClientRect();
+        splash_at((event.clientX - rect.left) / rect.width, (event.clientY - rect.top) / rect.height, stop.splash);
+    });
+
+    let paused = false, ready = false, rain_debt = 0;
+    element("pause").onclick = () => { paused = !paused; element("pause").textContent = paused ? "Resume" : "Pause"; };
+    graphics.on.contextFailed.add(error => report(error.message));
+    graphics.on.contextLost.add(error => { ready = false; report(`GPU device lost · ${error.message}`); });
+    await graphics.start();
+    const renderer = graphics.renderer;
+    renderer.graphics.device.addEventListener("uncapturederror", event => { ready = false; report(event.error.message); console.error(event.error.message); });
+    const profile = install_profile_hotkey({ renderer, name: "water_surface", status: element("status"), target: viewport,
+        settings: () => [stop.body, `wind × ${number("wind")}`, element("rain").checked ? `rain ${number("rate")}/s` : 'no rain'] });
+    element("profile").onclick = () => profile.toggle().catch(error => report(error.message));
+
+    element("measure").onclick = async () => {
+        element("report").textContent = "recording…";
+        const session = new GPUProfileSession({ level: GPUProfileLevel.WORKLOAD, note: 'water_surface measure' });
+        renderer.profile_session = session; session.start();
+        await new Promise(resolve => setTimeout(resolve, 2500));
+        renderer.profile_session = null;
+        const bytes = await session.stop();
+        const capture = sgpt_read_capture(bytes instanceof ArrayBuffer ? bytes : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+        const sums = new Map();
+        let frames = 0, total = 0;
+        for (const frame of capture.frames) {
+            if (!frame.spans || frame.spans.length === 0) { continue; }
+            frames++;
+            for (const span of frame.spans) {
+                total += span.duration_ns;
+                if (!/^Water \/ (spectrum|waves|particles|classify)/.test(span.label)) { continue; }
+                sums.set(span.label, (sums.get(span.label) ?? 0) + span.duration_ns);
+            }
+        }
+        const rows = [...sums.entries()].sort((a, b) => b[1] - a[1]);
+        const surface = rows.reduce((sum, [, ns]) => sum + ns, 0);
+        element("report").textContent = [`${frames} frames · every pass ${(total / frames / 1000).toFixed(0)} µs · surface ${(surface / frames / 1000).toFixed(1)} µs`,
+            ...rows.map(([label, ns]) => `${(ns / frames / 1000).toFixed(1).padStart(7)}  ${label.replace('Water / ', '')}`)].join("\n");
+    };
+
+    ready = true; report("Ready · click the water to splash");
+    Object.assign(globalThis, { graphics, scene, dataset, entities, world, water_system, camera, controller,
+        water_surface_playground: { go, splash_at, get ready() { return ready; } } });
+
+    create_frame_loop(raw_dt => {
+        if (!ready) { return; }
+        const dt = paused ? 0 : Math.min(raw_dt, 0.05);
+        if (element("rain").checked && dt > 0) {
+            rain_debt += number("rate") * dt;
+            for (; rain_debt >= 1; rain_debt--) { splash_at(Math.random(), 0.3 + 0.7 * Math.random(), stop.drop); }
+        }
+        graphics.viewport.size.set(Math.max(1, viewport.clientWidth), Math.max(1, viewport.clientHeight));
+        controller.update();
+        entities.update(dt);
+        graphics.render(dt);
+    }, 60);
+}
+
+main().catch(error => { console.error(error); element("status").textContent = error.message; });

package/src/shade/playground/water_surface/world.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Four bodies of water, from a cup to an ocean, each a `Water` + `WaterWaves` entity whose mesh authors
+ * only its outline: the surface's detail comes from the waves, at any scale.
+ */
+export function build_world(dataset: any): Promise<{
+    bodies: {
+        cup: {
+            entity: any;
+            water: Water;
+            waves: WaterWaves;
+            transform: Transform64;
+            level: any;
+            base_wind: any;
+        };
+        puddle: {
+            entity: any;
+            water: Water;
+            waves: WaterWaves;
+            transform: Transform64;
+            level: any;
+            base_wind: any;
+        };
+        lake: {
+            entity: any;
+            water: Water;
+            waves: WaterWaves;
+            transform: Transform64;
+            level: any;
+            base_wind: any;
+        };
+        ocean: {
+            entity: any;
+            water: Water;
+            waves: WaterWaves;
+            transform: Transform64;
+            level: any;
+            base_wind: any;
+        };
+    };
+}>;
+import Water from "../../../engine/graphics/ecs/water/Water.js";
+import WaterWaves from "../../../engine/graphics/ecs/water/WaterWaves.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+//# sourceMappingURL=world.d.ts.map

package/src/shade/playground/water_surface/world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_surface/world.js"],"names":[],"mappings":"AAsGA;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDC;kBA3JiB,6CAA6C;uBACxC,kDAAkD;4BAH7C,8CAA8C"}

package/src/shade/playground/water_surface/world.js

@@ -0,0 +1,160 @@
+import { Color } from "../../../core/color/Color.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import Water from "../../../engine/graphics/ecs/water/Water.js";
+import WaterWaves from "../../../engine/graphics/ecs/water/WaterWaves.js";
+import { Attribute } from "../../renderer/geometry/Attribute.js";
+import { Geometry } from "../../renderer/geometry/Geometry.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { meshlet_geometry_build_from_geometry } from "../../renderer/geometry/meshlet_geometry_build_from_geometry.js";
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
+import { make_box_geometry } from "../../renderer/geometry/primitives/make_box_geometry.js";
+import { make_cylinder_geometry } from "../../renderer/geometry/primitives/make_cylinder_geometry.js";
+import { StandardAttributes } from "../../renderer/geometry/StandardAttributes.js";
+import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { water_medium_preset } from "../../renderer/medium/water/water_presets.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { ColorSpace } from "../../renderer/texture/ColorSpace.js";
+import { ShadeTexture } from "../../renderer/texture/ShadeTexture.js";
+import { ShadeImage } from "../../renderer/texture/source/ShadeImage.js";
+
+function pose(x, y, z) {
+    const transform = new Transform64();
+    transform.setTranslation(x, y, z);
+    transform.updateMatrix();
+    return transform;
+}
+
+let checker_texture = null;
+/** Sharp light and dark squares, one per UV unit: what refraction bends shows the slopes without a sky. */
+function checker() {
+    if (checker_texture !== null) { return checker_texture; }
+    const size = 512, data = Sampler2D.uint8(4, size, size);
+    for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+        const bright = ((x >> 8) + (y >> 8)) % 2 === 0;
+        data.data.set(bright ? [215, 220, 200, 255] : [42, 66, 84, 255], (y * size + x) * 4);
+    }
+    const image = ShadeImage.fromSampler2D(data); image.color_space = ColorSpace.SRGB;
+    return checker_texture = ShadeTexture.from(image);
+}
+
+function material(rgb, roughness = 0.8, textured = false) {
+    const m = new StandardShadeMaterial();
+    m.diffuse_color.copy(new Color(...rgb, 1));
+    m.metallic_factor = 0; m.roughness_factor = roughness; m.draw_side = ShadeDrawSide.Double;
+    if (textured) { m.texture_albedo = checker(); }
+    return m;
+}
+
+function meshlets(geometry) {
+    const result = new MeshletGeometry();
+    meshlet_geometry_build_from_geometry(geometry, result);
+    return result;
+}
+
+/**
+ * A polar mesh in local xz, wound to face +y: rings of `segments` vertices at radii `radius(theta, t)` for
+ * t from 0 to 1, at heights `height(theta, t)`. A disk has a centre vertex for t = 0; with `hole`, t = 0 is a
+ * ring, and the mesh an annulus. Texture coordinates are local xz over `texel` metres: two checker squares.
+ */
+function polar_geometry({ segments, rings, radius, height = () => 0, hole = false, texel = 1 }) {
+    const positions = [], normals = [], uvs = [], index = [];
+    const centre = !hole;
+    if (centre) { positions.push(0, height(0, 0), 0); normals.push(0, 1, 0); uvs.push(0, 0); }
+    const first = centre ? 1 : 0;
+    const ring_count = centre ? rings : rings + 1;
+    for (let r = 0; r < ring_count; r++) {
+        const t = centre ? (r + 1) / rings : r / rings;
+        for (let s = 0; s < segments; s++) {
+            const theta = 2 * Math.PI * s / segments;
+            const rho = radius(theta, t);
+            positions.push(Math.cos(theta) * rho, height(theta, t), Math.sin(theta) * rho);
+            normals.push(0, 1, 0);
+            uvs.push(Math.cos(theta) * rho / texel, Math.sin(theta) * rho / texel);
+        }
+    }
+    const vertex = (r, s) => first + r * segments + (s % segments);
+    const triangle = (a, b, c) => {
+        const p = i => [positions[3 * i], positions[3 * i + 1], positions[3 * i + 2]];
+        const [pa, pb, pc] = [p(a), p(b), p(c)];
+        const ny = (pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]);
+        if (ny >= 0) { index.push(a, b, c); } else { index.push(a, c, b); }
+    };
+    if (centre) { for (let s = 0; s < segments; s++) { triangle(0, vertex(0, s), vertex(0, s + 1)); } }
+    for (let r = 0; r + 1 < ring_count; r++) {
+        for (let s = 0; s < segments; s++) {
+            triangle(vertex(r, s), vertex(r + 1, s), vertex(r + 1, s + 1));
+            triangle(vertex(r, s), vertex(r + 1, s + 1), vertex(r, s + 1));
+        }
+    }
+    const geometry = new Geometry();
+    geometry.index = Attribute.from(new Uint32Array(index), 1, 'index');
+    geometry.addAttribute(Attribute.from(new Float32Array(positions), 3, StandardAttributes.Position));
+    geometry.addAttribute(Attribute.from(new Float32Array(normals), 3, StandardAttributes.Normal));
+    geometry.addAttribute(Attribute.from(new Float32Array(uvs), 2, StandardAttributes.TextureCoordinates0));
+    return geometry;
+}
+
+/** A wobbly outline of mean radius one, the same for the water and the ground around it. */
+const wobble = (seed, amount) => theta => 1 + amount * (0.6 * Math.sin(3 * theta + seed) + 0.4 * Math.sin(5 * theta + 2 * seed));
+
+/**
+ * Four bodies of water, from a cup to an ocean, each a `Water` + `WaterWaves` entity whose mesh authors
+ * only its outline: the surface's detail comes from the waves, at any scale.
+ */
+export async function build_world(dataset) {
+    await MeshoptClusterizer.ready;
+    const build = builder => { builder.build(dataset); return builder.id; };
+    const solid = (geometry, m, x, y, z) => {
+        const shaded = new ShadedGeometry(); shaded.geometry = meshlets(geometry); shaded.material = m;
+        return build(new Entity().add(pose(x, y, z)).add(shaded));
+    };
+    const water_body = ({ geometry, x, y, z, preset, wind, upwind = 0, reflection = 0.5, roughness = 0.02 }) => {
+        const water = new Water();
+        water.medium = water_medium_preset({ preset });
+        water.roughness.set(roughness);
+        const waves = new WaterWaves();
+        waves.windSpeed.set(wind); waves.upwindFetch.set(upwind); waves.shoreReflection.set(reflection);
+        const transform = pose(x, y, z);
+        const entity = build(new Entity().add(water).add(waves).add(meshlets(geometry)).add(transform));
+        return { entity, water, waves, transform, level: y, base_wind: wind };
+    };
+
+    // a floor for the cup's table and the puddle
+    solid(polar_geometry({ segments: 48, rings: 6, radius: (theta, t) => 40 * t, texel: 0.5 }), material([1, 1, 1], 0.8, true), 0, 0, 0);
+
+    // a cup of tea on a table: 4 cm across, 7 cm deep
+    solid(make_box_geometry(1.2, 0.75, 0.8), material([0.45, 0.28, 0.16], 0.5), 0, 0.375, 0);
+    solid(make_cylinder_geometry(0.045, 0.04, 0.095, 32, 1, true), material([0.92, 0.92, 0.9], 0.3), 0, 0.75 + 0.0475, 0);
+    solid(polar_geometry({ segments: 32, rings: 1, radius: (theta, t) => 0.04 * t, texel: 0.02 }), material([1, 1, 1], 0.3, true), 0, 0.751, 0);
+    const cup = water_body({ geometry: polar_geometry({ segments: 32, rings: 2, radius: (theta, t) => 0.0435 * t }),
+        x: 0, y: 0.83, z: 0, preset: 'swimming_pool', wind: 2, reflection: 0.9 });
+
+    // a puddle on the floor: a centimetre deep, two metres across
+    const puddle_outline = wobble(1.3, 0.25);
+    const puddle = water_body({ geometry: polar_geometry({ segments: 64, rings: 3, radius: (theta, t) => 1.0 * t * puddle_outline(theta) }),
+        x: 4, y: 0.01, z: 1, preset: 'swimming_pool', wind: 4, reflection: 0.2 });
+
+    // a mountain lake, 120 × 60 m, in a basin whose shore is its outline
+    const lake_outline = wobble(0.4, 0.15);
+    const lake_radius = (theta, t) => t * lake_outline(theta) * (60 - 30 * Math.sin(theta) ** 2);
+    const lake = water_body({ geometry: polar_geometry({ segments: 96, rings: 6, radius: lake_radius }),
+        x: 0, y: 0, z: 160, preset: 'tropical_lagoon', wind: 6, reflection: 0.3 });
+    solid(polar_geometry({ segments: 96, rings: 24, radius: (theta, t) => lake_radius(theta, 3 * t),
+        height: (theta, t) => { const f = 3 * t; return f < 1 ? -4 * (1 - f * f) : 18 * ((f - 1) / 2) ** 2; }, texel: 4 }),
+        material([0.75, 0.85, 0.65], 0.8, true), 0, 0, 160);
+
+    // an open ocean disk, 5 km across, around an island the mesh leaves a hole for; the sea runs on for 200 km upwind
+    const ocean_x = 0, ocean_z = 5000;
+    const island = wobble(2.1, 0.12);
+    const ocean = water_body({ geometry: polar_geometry({ segments: 128, rings: 24, hole: true,
+        radius: (theta, t) => { const rim = 130 * island(theta); return rim * (2500 / rim) ** t; } }),
+        x: ocean_x, y: 0, z: ocean_z, preset: 'clear_ocean', wind: 10, upwind: 200000, reflection: 0.6 });
+    solid(polar_geometry({ segments: 128, rings: 48, radius: (theta, t) => 2600 * t * t,
+        height: (theta, t) => { const r = 2600 * t * t / (220 * island(theta)); return r < 1 ? 60 - 100 * r ** 1.2 : -40; }, texel: 16 }),
+        material([0.95, 0.9, 0.75], 0.8, true), ocean_x, 0, ocean_z);
+
+    return { bodies: { cup, puddle, lake, ocean } };
+}

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

@@ -2514,11 +2514,12 @@ export class Renderer {
             resolution: view_ctx.resolution,
         });
 
-        // Build the view's volumetric fog LUTs (participating media -> per-froxel lighting ->
-        // ray-marched integration). Needs the light clusters and shadow atlas. Built every frame so
-        // the transparency (OIT) pass always has a valid LUT to sample — an empty scene integrates
-        // to a no-op (transmittance 1, in-scatter 0). The opaque composite below is still skipped
-        // when the scene has no fog.
+        // The view's volumetrics: the fog every surface is seen through (participating media ->
+        // per-froxel lighting -> ray-marched integration), and the froxel irradiance lit particles
+        // are lit by. Both need the light clusters and shadow atlas. A scene with no volumes records
+        // no fog and hands the transparency pass a constant LUT that reads as none (transmittance 1,
+        // in-scatter 0); the irradiance is built only when something reads it. The opaque composite
+        // below is skipped on the same fact.
         const has_volumetrics = view_ctx.scene.volumetrics.source.volumes.length > 0;
 
         const volumetrics = view_ctx.volumetrics.graph_update({

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA1xCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA+NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA/xCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -711,6 +711,11 @@ export class GPUMeshSkinningContext {
      */
     update(cmd_ctx) {
         if (this.#bindings.length === 0) {
+            if (this.#bindings_dirty) {
+                this.#refresh_bindings_from_records();
+                this.#upload_prev_position_offsets();
+                this.#bindings_dirty = false;
+            }
             return false;
         }
 

package/src/shade/renderer/atmosphere/GPUSky.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ */
 export class GPUSky {
     /**
      *
@@ -14,6 +17,14 @@ export class GPUSky {
      * @returns {GPUTextureContext}
      */
     get lut_multiple_scattering(): GPUTextureContext;
+    /**
+     * Whether the LUTs still hold nothing a reader could use: true until the first {@link update}.
+     * What reads {@link lut_transmittance} or {@link lut_multiple_scattering} has to see this false,
+     * as a texture nobody wrote reads as zero rather than failing.
+     *
+     * @returns {boolean}
+     */
+    get needs_update(): boolean;
     destroy(): void;
     debug(): void;
     /**
@@ -22,5 +33,6 @@ export class GPUSky {
     update(): void;
     #private;
 }
+export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
 //# sourceMappingURL=GPUSky.d.ts.map

package/src/shade/renderer/atmosphere/GPUSky.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/GPUSky.js"],"names":[],"mappings":"AAUA;IAuCI;;;OAGG;IACH,uCAmBC;IAlDD;;;OAGG;IACH,2CAEC;IAOD;;;OAGG;IACH,iDAEC;IAiCD,gBAGC;IAED,cAYC;IAED;;OAEG;IACH,eAiDC;;CAEJ;kCA7IiC,iCAAiC"}
+{"version":3,"file":"GPUSky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/GPUSky.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;IAkDI;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IA7DD;;;OAGG;IACH,2CAEC;IAOD;;;OAGG;IACH,iDAEC;IAQD;;;;;;OAMG;IACH,4BAEC;IA2BD,gBAGC;IAED,cAYC;IAED;;OAEG;IACH,eAiDC;;CAEJ;8BAvJY,OAAO,uBAAuB,EAAE,eAAe;kCAL1B,iCAAiC"}