@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -33,7 +33,7 @@ input[type=range]{width:135px}input[type=number]{width:84px}input,select,button,
 <label>Internal scale<select id="resolution"><option value="1">1×</option><option value=".75">0.75×</option><option value=".5">0.5×</option></select></label>
 <label>Opaque SSR<input id="ssr" type="checkbox"></label><label>Atmospheric fog<input id="fog" type="checkbox"></label>
 <label>Transparency<select id="transparency"><option value="avboit">AVBOIT</option><option value="mboit">MBOIT (water unavailable)</option></select></label>
-<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="6">Residual</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option><option value="10">Refraction confidence</option></select></label>
+<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="6">Residual</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option></select></label>
 <div class="row"><button id="compile">Compile check</button><button id="profile">Profile (T)</button></div><pre id="probe">Shift-click water to read a pixel.</pre>
 <h2>Reproduce a view</h2><div class="row"><button id="copy">Copy state</button><button id="apply">Apply state</button></div><textarea id="state" aria-label="Saved camera and settings"></textarea>
 <p>Rear transparent radiance is attenuated on its original screen path. Initial optics select one water interface; underwater transport and caustics are follow-on work. <a href="./README.md">Review guide</a></p>

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

@@ -15,6 +15,11 @@ 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 { GPUFluidSystem } from "../../../engine/graphics3/GPUFluidSystem.js";
+import { FluidEffectorsComponent } from "../../../engine/physics/fluid/ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "../../../engine/physics/fluid/ecs/FluidEffectorsSystem.js";
+import { GPUFluidComponent } from "../../../engine/physics/fluid/ecs/GPUFluidComponent.js";
+import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/GlobalFluidEffector.js";
 import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { DynamicMeshAVBOITChannel } from "../../renderer/dynamic/DynamicMeshAVBOITChannel.js";
@@ -23,7 +28,9 @@ import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
 import { ShadeUpscalerType } from "../../renderer/ShadeUpscalerType.js";
 import { ParticipatingMediaVolume } from "../../renderer/volumetrics/ParticipatingMediaVolume.js";
 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 { water_finalize_shader, water_shader } from "../../renderer/water/shader_water.js";
+import { INDIRECT_LIGHTING } from "../../renderer/INDIRECT_LIGHTING.js";
+import { ShaderSwitchSet } from "../../renderer/shader/compiler/ShaderSwitchSet.js";
 import * as water_shaders from "../../renderer/water/shader_water_avboit.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";
@@ -56,10 +63,17 @@ async function main() {
     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));
+    // the scene's one wind, registered before its readers: the far field from the weather below and a small fluid on the pool
+    entities.addSystem(new FluidEffectorsSystem()); entities.addSystem(new GPUFluidSystem(graphics,scene));
     entities.addSystem(new GPUParticleEmitterSystem(graphics,scene,assets)); entities.addSystem(water_system);
     entities.attachDataset(dataset);
     await new Promise((resolve,reject) => entities.startup(resolve,reject));
     const world = await build_world(dataset), channel = new DynamicMeshAVBOITChannel(world.batch);
+    const weather = new GlobalFluidEffector();weather.drag=0.5;
+    const effectors = new FluidEffectorsComponent();effectors.addEffector(weather);
+    const weather_entity = new Entity().add(effectors);weather_entity.build(dataset);
+    const domain = new GPUFluidComponent();domain.resolution=[32,32,32];domain.cascade_count=2;
+    const domain_entity = new Entity().add(world.water_transform.clone()).add(domain);domain_entity.build(dataset);
     graphics.add_transparency_channel(channel);
     const sun = new Light(); sun.intensity.set(2.2);
     const sun_pose = new Transform64(), rotation = new Quaternion();
@@ -81,7 +95,7 @@ async function main() {
         revision++;
         const w=world.water,s=water_system.settings,r=graphics.renderer;
         world.water_transform.setTranslation(16,number("level"),16);t64_announce_change(dataset,world.water_entity);w.ior.set(number("ior"));w.roughness.set(number("roughness"));
-        world.waves.windSpeed.set(number("wind"));world.waves.windDirection.set(number("wind_direction")*Math.PI/180);
+        const heading=number("wind_direction")*Math.PI/180;weather.wind=[number("wind")*Math.cos(heading),0,number("wind")*Math.sin(heading)];
         w.medium=water_medium_preset({preset:element("medium").value});
         Object.assign(s,{enabled:checked("enabled"),mode:number("mode"),max_updates:number("iterations"),
             inscatter_segments:number("segments"),
@@ -164,7 +178,8 @@ async function main() {
     element("compile").onclick=async()=>{
         if(!ready)return;
         const device=graphics.renderer.graphics.device,errors=[];
-        for(const shader of [water_shader,water_finalize_shader_ibl,water_finalize_shader_brick4,
+        for(const shader of [water_shader,
+            ...INDIRECT_LIGHTING.values.map(mode=>water_finalize_shader.variant(ShaderSwitchSet.EMPTY.with(INDIRECT_LIGHTING,mode))),
             ...[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)]){
@@ -205,6 +220,7 @@ async function main() {
     globalThis.water_playground.frame=frame;
     window.addEventListener("pagehide",()=>{
         ready=false;stop_loop?.();profile?.dispose();world.dispose();dataset.removeEntity(sun_entity.id);
+        dataset.removeEntity(weather_entity.id);dataset.removeEntity(domain_entity.id);
         channel.release(world.ribbon.geometry);graphics.remove_transparency_channel(channel);
         entities.shutdown(()=>{},console.error);controller.pointer.stop();controller.keyboard.stop();graphics.stop();
     },{once:true});

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

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_refraction/world.js"],"names":[],"mappings":"AA4DA,+FAA+F;AAC/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFC;AAxHM,mEAAsE;oBAzBzD,4CAA4C;kBAI9C,6CAA6C;uBACxC,kDAAkD;4BAJ7C,8CAA8C;+BAE3C,wDAAwD;iCAetD,0CAA0C;4BAD/C,qCAAqC;+BAXlC,0DAA0D"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_refraction/world.js"],"names":[],"mappings":"AA4DA,+FAA+F;AAC/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FC;AAzHM,mEAAsE;oBAzBzD,4CAA4C;kBAI9C,6CAA6C;uBACxC,kDAAkD;4BAJ7C,8CAA8C;+BAE3C,wDAAwD;iCAetD,0CAA0C;4BAD/C,qCAAqC;+BAXlC,0DAA0D"}

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

@@ -93,7 +93,8 @@ 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 wind that raises its waves; the overlapping second body below has none and stays calm
+    // its fetch and shore; the wind is the scene's, so the overlapping second body below, which has no WaterWaves,
+    // has the same wind over its own extent
     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

@@ -3,23 +3,31 @@
 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 |
+| Stop | Body | Mesh | Fetch | 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 |
+| Cup | 4 cm of tea on a table | a 32-segment disk | 9 cm | millimetre ripples at most; a click rings the cup and the wall sends it back |
+| Puddle | 2 m across, 1 cm deep | a wobbly disk | 2 m | 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 | 60–120 m | 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 | 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.
 
+**One wind** (`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md` §6). The scene has one: a `GlobalFluidEffector` is the
+far field, with a gust on top, and a `GPUFluidComponent` puts a fluid domain on the stop's body. Each body's
+waves follow the published field 10 m above its origin, low-passed over 20 s, so the four seas differ by their
+fetch and by the air around each, not by a wind of their own. Until the wind left `WaterWaves` each body had its
+own (cup 2, puddle 4, lake 6, ocean 10 m/s); at the default 8 m/s the ocean's sea is a little lower than it was,
+and the cup's, puddle's and lake's higher, the cup still in millimetre ripples.
+
 ## 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.
+- **Wind** sets the far field's steady wind, **Direction** where it blows, **Gust** the peak of the weather on top
+  (`GlobalFluidEffector#gust`, per axis). The air relaxes to a new wind over two seconds and the waves follow it
+  over 20 s; a change of direction past 3° turns them, 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)**

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

@@ -16,8 +16,9 @@ input[type=range]{width:130px}input,select,button{font:inherit;background:#202d3
 <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>Wind m/s<input id="wind" type="range" min="0" max="20" step=".5" value="8"></label>
 <label>Direction °<input id="direction" type="range" min="0" max="360" step="1" value="30"></label>
+<label>Gust m/s<input id="gust" type="range" min="0" max="6" step=".25" value="2"></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>

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

@@ -10,6 +10,11 @@ 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 { GPUFluidSystem } from "../../../engine/graphics3/GPUFluidSystem.js";
+import { FluidEffectorsComponent } from "../../../engine/physics/fluid/ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "../../../engine/physics/fluid/ecs/FluidEffectorsSystem.js";
+import { GPUFluidComponent } from "../../../engine/physics/fluid/ecs/GPUFluidComponent.js";
+import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/GlobalFluidEffector.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";
@@ -37,8 +42,13 @@ async function main() {
     viewport.appendChild(graphics.viewport.el);
     const dataset = new EntityComponentDataset(), entities = new EntityManager();
     const water_system = new WaterSystem(graphics, scene);
+    // the scene's one wind: the far field from the weather below, and a fluid around the stop's body; registered
+    // before the water, so the frame publishes the field before the water reads it
+    const fluid_system = new GPUFluidSystem(graphics, scene);
     entities.addSystem(new ShadedGeometrySystem(graphics, scene));
     entities.addSystem(new LightSystem(graphics, scene));
+    entities.addSystem(new FluidEffectorsSystem());
+    entities.addSystem(fluid_system);
     entities.addSystem(water_system);
     entities.attachDataset(dataset);
     await new Promise((resolve, reject) => entities.startup(resolve, reject));
@@ -52,26 +62,46 @@ async function main() {
     sun_pose.setRotation(rotation.x, rotation.y, rotation.z, rotation.w); sun_pose.updateMatrix();
     new Entity().add(sun).add(sun_pose).build(dataset);
 
+    // the weather: a steady wind the air relaxes to over two seconds, and a gust on top of it
+    const weather = new GlobalFluidEffector();
+    weather.drag = 0.5; weather.gust_period = 4;
+    const effectors = new FluidEffectorsComponent(); effectors.addEffector(weather);
+    new Entity().add(effectors).build(dataset);
+    // the fluid's domain sits on the stop's body, so the wind 10 m above it is the fluid's, not the far field's alone
+    const domain = { transform: new Transform64(), component: new GPUFluidComponent() };
+    new Entity().add(domain.transform).add(domain.component).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];
+        const body = world.bodies[stop.body].transform;
+        domain.transform.setTranslation(body.translation_x, body.translation_y, body.translation_z);
+        domain.transform.updateMatrix();
         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 = [];
+        const heading = number("direction") * Math.PI / 180;
+        weather.wind = [number("wind") * Math.cos(heading), 0, number("wind") * Math.sin(heading)];
+        weather.gust = number("gust");
+        describe_wind();
+    }
+    const far = new Float64Array(3);
+    function describe_wind() {
+        fluid_system.far_field(far);
+        const lines = [`far field now  ${Math.hypot(far[0], far[2]).toFixed(1)} m/s, ${far[1].toFixed(1)} up`,
+            `fluid domain   around the ${stop.body}`];
         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` : ''}`);
+            const upwind = body.waves.upwindFetch.getValue();
+            lines.push(`${name.padEnd(7)} its own extent along the wind${upwind > 0 ? ` + ${upwind / 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 id of ["wind", "direction", "gust"]) { element(id).addEventListener("input", configure); }
     for (const button of document.querySelectorAll("button.stop")) { button.onclick = () => go(button.dataset.stop); }
     configure(); go("cup");
 
@@ -105,7 +135,7 @@ async function main() {
     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'] });
+        settings: () => [stop.body, `wind ${number("wind")} m/s, gust ${number("gust")}`, element("rain").checked ? `rain ${number("rate")}/s` : 'no rain'] });
     element("profile").onclick = () => profile.toggle().catch(error => report(error.message));
 
     element("measure").onclick = async () => {
@@ -134,11 +164,13 @@ async function main() {
     };
 
     ready = true; report("Ready · click the water to splash");
-    Object.assign(globalThis, { graphics, scene, dataset, entities, world, water_system, camera, controller,
+    Object.assign(globalThis, { graphics, scene, dataset, entities, world, water_system, fluid_system, weather, domain, camera, controller,
         water_surface_playground: { go, splash_at, get ready() { return ready; } } });
 
+    let described = 0;
     create_frame_loop(raw_dt => {
         if (!ready) { return; }
+        if ((described += raw_dt) > 0.5) { described = 0; describe_wind(); }
         const dt = paused ? 0 : Math.min(raw_dt, 0.05);
         if (element("rain").checked && dt > 0) {
             rain_debt += number("rate") * dt;

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

@@ -1,6 +1,7 @@
 /**
  * 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.
+ * only its outline: the surface's detail comes from the waves, at any scale. They share the scene's one wind, so
+ * their seas differ by their fetch and by the air around each.
  */
 export function build_world(dataset: any): Promise<{
     bodies: {
@@ -10,7 +11,6 @@ export function build_world(dataset: any): Promise<{
             waves: WaterWaves;
             transform: Transform64;
             level: any;
-            base_wind: any;
         };
         puddle: {
             entity: any;
@@ -18,7 +18,6 @@ export function build_world(dataset: any): Promise<{
             waves: WaterWaves;
             transform: Transform64;
             level: any;
-            base_wind: any;
         };
         lake: {
             entity: any;
@@ -26,7 +25,6 @@ export function build_world(dataset: any): Promise<{
             waves: WaterWaves;
             transform: Transform64;
             level: any;
-            base_wind: any;
         };
         ocean: {
             entity: any;
@@ -34,7 +32,6 @@ export function build_world(dataset: any): Promise<{
             waves: WaterWaves;
             transform: Transform64;
             level: any;
-            base_wind: any;
         };
     };
 }>;

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

@@ -1 +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"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_surface/world.js"],"names":[],"mappings":"AAsGA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDC;kBA5JiB,6CAA6C;uBACxC,kDAAkD;4BAH7C,8CAA8C"}

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

@@ -102,7 +102,8 @@ const wobble = (seed, amount) => theta => 1 + amount * (0.6 * Math.sin(3 * theta
 
 /**
  * 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.
+ * only its outline: the surface's detail comes from the waves, at any scale. They share the scene's one wind, so
+ * their seas differ by their fetch and by the air around each.
  */
 export async function build_world(dataset) {
     await MeshoptClusterizer.ready;
@@ -111,15 +112,15 @@ export async function build_world(dataset) {
         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_body = ({ geometry, x, y, z, preset, 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);
+        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 };
+        return { entity, water, waves, transform, level: y };
     };
 
     // a floor for the cup's table and the puddle
@@ -130,18 +131,18 @@ export async function build_world(dataset) {
     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 });
+        x: 0, y: 0.83, z: 0, preset: 'swimming_pool', 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 });
+        x: 4, y: 0.01, z: 1, preset: 'swimming_pool', 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 });
+        x: 0, y: 0, z: 160, preset: 'tropical_lagoon', 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);
@@ -151,7 +152,7 @@ export async function build_world(dataset) {
     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 });
+        x: ocean_x, y: 0, z: ocean_z, preset: 'clear_ocean', 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);

package/src/shade/renderer/INDIRECT_LIGHTING.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Which indirect lighting a shader samples: the renderer's {@link ShadeIndirectLightingMode}, decided
+ * where a chunk graph asks for indirect light (the forward fragment, water's optics, SSR's resolve,
+ * froxel GI), so a pipeline links one mode's sampling and binds every mode's resources by name.
+ *
+ * The mode is the renderer's, for every pass at once, so the renderer sets this from
+ * `indirect_lighting_mode` in the switch set it hands its passes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const INDIRECT_LIGHTING: ShaderSwitch;
+import { ShaderSwitch } from "./shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=INDIRECT_LIGHTING.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"INDIRECT_LIGHTING.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/INDIRECT_LIGHTING.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,gCAFU,YAAY,CAE6E;6BAZtE,mCAAmC"}

package/src/shade/renderer/INDIRECT_LIGHTING.js

@@ -0,0 +1,14 @@
+import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { ShaderSwitch } from "./shader/compiler/ShaderSwitch.js";
+
+/**
+ * Which indirect lighting a shader samples: the renderer's {@link ShadeIndirectLightingMode}, decided
+ * where a chunk graph asks for indirect light (the forward fragment, water's optics, SSR's resolve,
+ * froxel GI), so a pipeline links one mode's sampling and binds every mode's resources by name.
+ *
+ * The mode is the renderer's, for every pass at once, so the renderer sets this from
+ * `indirect_lighting_mode` in the switch set it hands its passes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const INDIRECT_LIGHTING = ShaderSwitch.enum('indirect lighting', ShadeIndirectLightingMode);

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

@@ -38,6 +38,13 @@ export class Renderer {
      * @type {ShadeTransparencyMode}
      */
     transparency_mode: ShadeTransparencyMode;
+    /**
+     * How the exposed scene colour becomes display colour, on every output. An SDR and an HDR display run the same
+     * mode, so a scene looks alike on both; see {@link ShadeToneMappingMode}. Read every frame, so it can be flipped
+     * at runtime. A mode not in use at {@link initialize} compiles its pass on the first frame that draws with it.
+     * @type {ShadeToneMappingMode}
+     */
+    tone_mapping_mode: ShadeToneMappingMode;
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
      * @type {AVBOITSettings}
@@ -83,6 +90,10 @@ export class Renderer {
      * @type {boolean}
      */
     feature_virtual_shadow_maps: boolean;
+    /**
+     * @returns {ShaderSwitchSet} see {@link #shader_switches}
+     */
+    get shader_switches(): ShaderSwitchSet;
     set shadow_virtual_page_budget(v: number);
     get shadow_virtual_page_budget(): number;
     /**
@@ -434,6 +445,22 @@ export class Renderer {
         device?: GPUDevice;
         pixelRatio?: number;
     }): Promise<void>;
+    /**
+     * Offer the pipelines a frame draws with — see {@link PipelineEnquiry}. {@link initialize}
+     * compiles the answer off the main thread, and {@link render} draws nothing until it is in.
+     *
+     * Each subsystem is asked only when the feature flag that runs it is on, so the answer follows the
+     * features as they are set at that moment. It covers the default renderer: the opaque raster,
+     * shading, IBL, ambient occlusion, TAA, sharpening, bloom, exposure and the tonemap. Everything
+     * else is made the old way, by the first frame that draws with it: the features that are off by
+     * default (ReSTIR's passes, SSR, depth of field, motion blur, NSS, path tracing), the indirect
+     * lighting modes other than IBL, a feature turned on after {@link initialize}, and whatever a
+     * scene's content brings — shadow casters, transparent and alpha-tested materials, volumes,
+     * particles.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * Release everything {@link initialize} built, in reverse.
      *
@@ -474,9 +501,11 @@ export class Renderer {
      * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
      * draws the current state and moves nothing; a fixed fraction of a second here instead would run
      * the simulation at that rate no matter what the caller's clock was doing.
-     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
-     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
-     * yet neither hold this one back nor make it return false.
+     * @returns {boolean} whether a frame was encoded and submitted. False when there is nothing to
+     * draw with — the device was lost, or the renderer destroyed — and while a pipeline prepared
+     * ahead of use is still compiling: the ones {@link initialize} asked for, or a template
+     * prewarmed at a level load. Frames the GPU has not finished yet neither
+     * hold this one back nor make it return false.
      */
     render(camera: PerspectiveCamera, scene: Scene, time_delta_seconds?: number): boolean;
     /**
@@ -510,7 +539,9 @@ export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
+import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
+import { ShaderSwitchSet } from "./shader/compiler/ShaderSwitchSet.js";
 import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";
 import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
@@ -525,5 +556,6 @@ import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { NSS } from "./postprocess/nss/NSS.js";
+import { PipelineEnquiry } from "../device/pipeline/PipelineEnquiry.js";
 import { AccumulatingPathTracer } from "./path_tracer/accumulating/AccumulatingPathTracer.js";
 //# sourceMappingURL=Renderer.d.ts.map

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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"}