@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/playground/tonemap_sdr/ToneMapCompare.js

@@ -3,7 +3,8 @@ import { FrameRecord } from "../../renderer/extension/FrameRecord.js";
 import { PresentTarget } from "../../renderer/extension/PresentTarget.js";
 import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
 import { SceneColor } from "../../renderer/extension/SceneColor.js";
-import { chunk_CRM_FROM_REC2020_TO_P3 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC2020_TO_P3.js";
+import { chunk_CRM_FROM_REC2020_TO_REC709 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC2020_TO_REC709.js";
+import { chunk_CRM_FROM_REC709_TO_P3 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_P3.js";
 import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
 import { chunk_sRGBTransferOETF } from "../../renderer/shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
 import { chunk_PAPER_WHITE_NITS } from "../../renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
@@ -118,7 +119,14 @@ fn compare_gain(op: u32) -> f32 {
 fn compare_tonemap(op: u32, c: vec3<f32>, headroom: f32) -> vec3<f32> {
     switch op {
         case 0u: { return tonemap_gt7_sdr_reference(c); }
-        case 1u: { return saturate(tonemap_gt7(c, PAPER_WHITE_NITS * headroom, PAPER_WHITE_NITS)); }
+        case 1u: {
+            let c_2020 = tonemap_gt7_rec2020(
+                CRM_FROM_REC709_TO_REC2020 * c,
+                PAPER_WHITE_NITS * headroom,
+                PAPER_WHITE_NITS
+            );
+            return saturate(CRM_FROM_REC2020_TO_REC709 * c_2020);
+        }
         default: { return saturate(tonemap_khronos_pbr(c, headroom)); }
     }
 }
@@ -179,7 +187,7 @@ fn main(
     color = compare_tonemap(op, color, headroom);
 
     if (settings.to_p3 == 1u) {
-        color = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+        color = CRM_FROM_REC709_TO_P3 * color;
     }
 
     color = sRGBTransferOETF(color);
@@ -195,7 +203,8 @@ fn main(
                 chunk_tonemap_khronos_pbr,
                 chunk_PAPER_WHITE_NITS,
                 chunk_CRM_FROM_REC709_TO_REC2020,
-                chunk_CRM_FROM_REC2020_TO_P3,
+                chunk_CRM_FROM_REC2020_TO_REC709,
+                chunk_CRM_FROM_REC709_TO_P3,
                 chunk_sRGBTransferOETF,
                 chunk_dither_color_8bit_triangle_noise,
             ]

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

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

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

@@ -346,6 +346,7 @@ const NOISE_WIND = [1.2, 0, 0.4];
 function advance_noise(scene, dt) {
     const strength = globalThis.__VOL_NOISE ?? 1;
     let changed = false;
+    let scrolled = false;
 
     for (const v of scene.volumetrics.volumes) {
         if (!noisy_volumes.has(v)) {
@@ -358,13 +359,18 @@ function advance_noise(scene, dt) {
         }
 
         if (strength > 0 && participating_media_volume_advance_noise(v, NOISE_WIND, dt)) {
-            changed = true;
+            scrolled = true;
         }
     }
 
     if (changed) {
         scene.volumetrics.invalidate();
     }
+
+    if (scrolled) {
+        // the phases alone: their words of each row, not a repack
+        scene.volumetrics.invalidate_noise();
+    }
 }
 
 /**

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

@@ -23,8 +23,10 @@ below-interface view. The grazing camera stays over the submerged floor.
 
 Water is an entity with `Water`, `MeshletGeometry` and `Transform64`. The mesh authors the outline
 and elevations, and the transform places it; Level edits the transform's height. This fixture
-has a curved, coarse authored outline. Optical controls edit Water. Optional WaterWaves sets the wind:
-the body's waves are a fetch-limited JONSWAP sea over its own extent along the wind, drawn from 18
+has a curved, coarse authored outline. Optical controls edit Water. The wind is the scene's: Wind and
+Wind direction set a `GlobalFluidEffector`, the far field, and a small `GPUFluidComponent` sits on the pool;
+every body takes the field 10 m above its origin, low-passed over 20 s, so a change of wind reaches the waves
+over a minute. The body's waves are a fetch-limited JONSWAP sea over its own extent along the wind, drawn from 18
 spectral bands every body shares, plus the wave particles of its splashes, which reflect off the mesh's
 outline (`WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md`). Vertices sample both in the body's metric local
 frame and move in it; deep water is assumed, and nothing is inferred from bathymetry. A body with a

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