@woosh/meep-engine 3.38.0 → 3.39.0

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.js

@@ -0,0 +1,270 @@
+import { chunk_get_ibl_radiance } from "../../renderer/deferred/indirect/chunk_get_ibl_radiance.js";
+import { chunk_sh_exp_p4q2_base_reflectance } from "../../renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_p4q2_base_reflectance.js";
+import { SH_EXP_P4Q2_PROBE_STRUCT } from "../../renderer/shader/chunk/spherical_harmonics/exponential/SH_EXP_P4Q2_PROBE_STRUCT.js";
+import { chunk_D_GGX } from "../../renderer/shader/chunk/brdf/chunk_D_GGX.js";
+import { chunk_V_GGX_SmithCorrelated } from "../../renderer/shader/chunk/brdf/chunk_V_GGX_SmithCorrelated.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { f32, u32, vec4f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../renderer/texture/SAMPLER_LINEAR_UPSCALE.js";
+
+/**
+ * Rows of the sphere grid, top to bottom.
+ * @type {string[]}
+ */
+export const PLAYGROUND_ROWS = [
+    'reference (quadrature)',
+    'SH exponential, P4 Q2',
+    'engine IBL (split sum)',
+    'SH exponential − reference',
+];
+
+/**
+ * Step through the reference grid's cells: odd, so it visits every cell of a power-of-two grid once
+ * per pass, and large, so any run of consecutive steps is spread over the sphere and a partial sum
+ * is already a fair estimate of the whole.
+ *
+ * @type {number}
+ */
+export const REFERENCE_CELL_STRIDE = 7919;
+
+/**
+ * What both playground kernels read.
+ *
+ * - `right`, `up`, `back`: the orthographic camera's basis; `back` points at the viewer and is every
+ *   pixel's view direction;
+ * - `cell_size`: pixels per sphere cell, `columns` spheres per row, one per roughness;
+ * - `alpha_first_root`, `alpha_root_step`: column `c` is at roughness `first + step * c`, GGX alpha
+ *   its square — the paper's own sweep is 0.3 to 1 in steps of 0.1;
+ * - `slice_start`, `slice_count`: which reference cells this frame adds; `processed` how many will
+ *   have been added after it, of `cell_count`;
+ * - `exposure`, `error_gain`: display only.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PLAYGROUND_VIEW_STRUCT = WebGPUStruct.from({
+    right: vec4f,
+    up: vec4f,
+    back: vec4f,
+    cell_size: u32,
+    columns: u32,
+    slice_start: u32,
+    slice_count: u32,
+    cell_count: u32,
+    processed: u32,
+    alpha_first_root: f32,
+    alpha_root_step: f32,
+    exposure: f32,
+    error_gain: f32,
+}, "SHExpPlaygroundView");
+
+/**
+ * The sphere a pixel of a cell sees: `w` is 1 on the sphere and 0 off it, `xyz` the world normal.
+ */
+const chunk_playground_sphere = CodeChunk.from(
+    //language=WGSL
+    `
+const SPHERE_RADIUS : f32 = 0.92;
+
+fn playground_sphere_normal(local: vec2<u32>) -> vec4<f32> {
+    let p = (vec2<f32>(local) + 0.5) / f32(view.cell_size) * 2.0 - 1.0;
+    // screen y grows downwards
+    let q = vec2<f32>(p.x, -p.y) / SPHERE_RADIUS;
+    let r2 = dot(q, q);
+
+    if (r2 >= 1.0) {
+        return vec4<f32>(0.0);
+    }
+
+    let normal = view.right.xyz * q.x + view.up.xyz * q.y + view.back.xyz * sqrt(1.0 - r2);
+
+    return vec4<f32>(normalize(normal), 1.0);
+}
+
+fn playground_alpha(column: u32) -> f32 {
+    let root = view.alpha_first_root + view.alpha_root_step * f32(column);
+    return root * root;
+}
+`);
+
+const accumulate_resources = new ShaderResourceSetDescriptor();
+
+accumulate_resources.createGroup()
+    .addUniform("view", PLAYGROUND_VIEW_STRUCT)
+    .addStorageBuffer("cells", WebGPUArray.from(vec4f), false)
+    .addStorageBuffer("accumulation", WebGPUArray.from(vec4f), true);
+
+/**
+ * Adds one slice of the reference quadrature to every sphere pixel: `E0` summed over
+ * `slice_count` cells of an octahedral grid made by `shader_sh_exp_environment_cells`, at a finer
+ * resolution than the encoder fits on. Spread over frames, so no invocation loops over the sphere.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_accumulate_reference = ComputeShader.from({
+    label: "SH exponential playground / accumulate reference",
+    resources: accumulate_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let width = view.columns * view.cell_size;
+
+    if (id.x >= width || id.y >= view.cell_size) {
+        return;
+    }
+
+    let column = id.x / view.cell_size;
+    let local = vec2<u32>(id.x % view.cell_size, id.y);
+    let sphere = playground_sphere_normal(local);
+
+    if (sphere.w == 0.0) {
+        return;
+    }
+
+    let normal = sphere.xyz;
+    let view_direction = view.back.xyz;
+    let NoV = max(dot(normal, view_direction), 1e-4);
+    let alpha = playground_alpha(column);
+    let alpha2 = alpha * alpha;
+
+    var sum = vec3<f32>(0.0);
+
+    // a uniform trip count: the slice is the same for every pixel
+    for (var k = 0u; k < view.slice_count; k++) {
+        let cell = ((view.slice_start + k) * ${REFERENCE_CELL_STRIDE}u) % view.cell_count;
+        let light = cells[2u * cell].xyz;
+        let NoL = dot(normal, light);
+
+        if (NoL > 0.0) {
+            let half_vector = normalize(light + view_direction);
+            let NoH = saturate(dot(normal, half_vector));
+
+            sum += cells[2u * cell + 1u].xyz * (D_GGX(alpha2, NoH * NoH) * V_GGX_SmithCorrelated(alpha, NoL, NoV) * NoL);
+        }
+    }
+
+    let pixel = column * view.cell_size * view.cell_size + local.y * view.cell_size + local.x;
+
+    accumulation[pixel] += vec4<f32>(sum, 0.0);
+}
+`, [
+            chunk_playground_sphere,
+            chunk_D_GGX,
+            chunk_V_GGX_SmithCorrelated,
+        ]),
+});
+
+const view_resources = new ShaderResourceSetDescriptor();
+
+view_resources.createGroup()
+    .addUniform("view", PLAYGROUND_VIEW_STRUCT)
+    .addTexture("tEnvironment")
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addStorageBuffer("probe", SH_EXP_P4Q2_PROBE_STRUCT, false)
+    .addStorageBuffer("accumulation", WebGPUArray.from(vec4f), false)
+    .addStorageBuffer("values", WebGPUArray.from(vec4f), true)
+    .addStorageTexture("output", "rgba8unorm", "2d", "write-only");
+
+/**
+ * Draws the four rows of {@link PLAYGROUND_ROWS}, and writes the linear values of the first three
+ * into `values` (`[row][column][pixel]`, `w` = 1 on the sphere) for `verify()` to read.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_view = ComputeShader.from({
+    label: "SH exponential playground / view",
+    resources: view_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const BACKGROUND = vec3<f32>(0.035);
+
+fn tonemap(x: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(1.0) - exp(-max(x, vec3<f32>(0.0)) * view.exposure);
+}
+
+fn srgb_encode(x: vec3<f32>) -> vec3<f32> {
+    let low = x * 12.92;
+    let high = 1.055 * pow(x, vec3<f32>(1.0 / 2.4)) - 0.055;
+    return select(high, low, x <= vec3<f32>(0.0031308));
+}
+
+fn luminance(x: vec3<f32>) -> f32 {
+    return dot(x, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let width = view.columns * view.cell_size;
+
+    if (id.x >= width || id.y >= 4u * view.cell_size) {
+        return;
+    }
+
+    let column = id.x / view.cell_size;
+    let row = id.y / view.cell_size;
+    let local = vec2<u32>(id.x % view.cell_size, id.y % view.cell_size);
+    let pixel = column * view.cell_size * view.cell_size + local.y * view.cell_size + local.x;
+    let slots = view.columns * view.cell_size * view.cell_size;
+
+    let sphere = playground_sphere_normal(local);
+
+    if (sphere.w == 0.0) {
+        if (row < 3u) {
+            values[row * slots + pixel] = vec4<f32>(0.0);
+        }
+
+        textureStore(output, id.xy, vec4<f32>(srgb_encode(BACKGROUND), 1.0));
+        return;
+    }
+
+    let normal = sphere.xyz;
+    let view_direction = view.back.xyz;
+    let alpha = playground_alpha(column);
+    let roughness = sqrt(alpha);
+
+    // the partial sum so far stands for the whole sphere: the cells it has seen are spread over it
+    let reference = accumulation[pixel].xyz * (f32(view.cell_count) / f32(max(view.processed, 1u)));
+    let sh_exp = sh_exp_p4q2_base_reflectance(probe, view_direction, normal, alpha);
+
+    var value = vec3<f32>(0.0);
+
+    if (row == 0u) {
+        value = reference;
+    } else if (row == 1u) {
+        value = sh_exp;
+    } else if (row == 2u) {
+        // the forward path's specular with Fresnel taken out: prefiltered radiance times the
+        // split sum's F0 scale plus F90 bias, which together are the GGX directional albedo (the engine's
+        // LUT, to within 0.06%; see chunk_sh_exp_split_sum)
+        let NoV = saturate(dot(normal, view_direction));
+        let dfg = textureSampleLevel(tSplitSum, sLinear, vec2<f32>(NoV, roughness), 0.0).rg;
+
+        value = get_ibl_radiance(view_direction, normal, roughness) * (dfg.x + dfg.y);
+    }
+
+    var color: vec3<f32>;
+
+    if (row < 3u) {
+        values[row * slots + pixel] = vec4<f32>(value, 1.0);
+        color = tonemap(value);
+    } else {
+        // red: SH exponential brighter than the reference, blue: darker; on the tonemapped scale
+        let difference = (luminance(tonemap(sh_exp)) - luminance(tonemap(reference))) * view.error_gain;
+        color = vec3<f32>(max(difference, 0.0), 0.0, max(-difference, 0.0));
+    }
+
+    textureStore(output, id.xy, vec4<f32>(srgb_encode(saturate(color)), 1.0));
+}
+`, [
+            chunk_playground_sphere,
+            chunk_sh_exp_p4q2_base_reflectance,
+            chunk_get_ibl_radiance,
+        ]),
+});

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

@@ -21,11 +21,17 @@ one 1/60-second engine tick. Presets cover the shore, normal incidence, grazing
 screen edges, the emergent-object/shoreline discontinuity view, and the deliberately unsupported
 below-interface view. The grazing camera stays over the submerged floor.
 
-Water fields edit the actual component. Optical normals are independent of the legacy shoreline
-wave modulation. Screen reflections can be disabled while retaining the environment fallback.
+Water fields edit the actual component. The surface is a real mesh: a primitive wave simulation on a
+512² grid over the body, driven by the WaterWaves component (wind speed and direction), writes its
+its mesh behind the surface interface the production simulation will replace
+(WATER_OPTICS_PLAN_2026_10_02.md §7.2). Screen reflections can be disabled while retaining the
+fallback to the renderer's indirect lighting (IBL, or Brick4 when it is the active mode).
 The Newton, bounded HZB traversal, and undisplaced control modes all use the same AVBOIT path.
-An IOR of 1, zero RGB extinction and zero optical normal strength should leave opaque transport
-unchanged. Increase extinction to see independent color attenuation and the body-color source.
+The Medium select picks one of the water presets (`shade/renderer/medium/water/water_presets.js`):
+what fills the body as absorption and scattering in 1/m. The body's colour is not authored — it is the sun
+and sky scattered back up the refracted view ray, single scattering for now, and In-scatter segments
+sets how many steps that integral takes. Seen from above, light leaving the water crosses the surface
+by Fresnel and the n² law, so the floor reads about half as bright as it would dry.
 
 Move the card, alpha/additive particles and ribbon above/below the interface using Layer height.
 The box and five thin posts exercise opaque occlusion and discontinuities. Swap channel order
@@ -49,7 +55,7 @@ no readback. Arrays are `receiver=[u,v,path,status+updates/32]`,
 `transmission=[Tr,Tg,Tb,coverage]`, `radiance=[Wr,Wg,Wb,residual]`.
 The separate `confidence` field is the final weight after rejecting unsupported lookups; the
 confidence display reads this same weight rather than recomputing an approximation.
-Status 0 is a Newton-assisted, visibility-checked hit; codes 8–13 are validated HZB hits, 16–21 undisplaced opaque fallbacks,
+Status 0 is a converged Newton hit; codes 8–13 are validated HZB hits, 16–21 undisplaced opaque fallbacks,
 24–29 bounded sky fallbacks, and 31 the below-interface control. The low three bits preserve the
 Newton miss reason: 0 none/not attempted, 1 bounds/clip, 2 sky, 3 parallel/invalid, 4 ray interval,
 5 exhausted budget/residual. The probe decodes these names and the update count. Residual is capped
@@ -73,7 +79,7 @@ require a fresh probe.
 ## Integration boundaries and adversarial checks
 
 Opaque receiver transport uses the immutable pre-transparency HDR scene. Water contributes only its
-surface source and RGB extinction; shared resolve applies the transported opaque background once.
+reflection and in-scattered radiance and its RGB transmittance; shared resolve applies the transported opaque background once.
 Rear transparent surfaces/particles are attenuated at their original screen positions. Their radiance
 is not sampled through the bent ray. Missing/off-screen receivers get bounded, explicit fallbacks.
 Missing receivers use the local terrain column to estimate water thickness; the trace budget is only
@@ -86,14 +92,16 @@ that field, which would amplify them into large moving blotches. The raw receive
 still show classified misses; Refraction confidence shows the displacement fade actually used by
 the final image. Screen reflections also fade near the ray origin and frame
 edges to avoid self-hit speckles, reusing the existing SSR back-face/thickness/vignette validation.
-Displaced Newton roots also require first-intersection evidence from a water adapter using the
-existing FFX cell intersection/depth-loading chunks. The adapter traverses the HZB's actual integer
+As in the paper, a converged Newton root is final: screen bounds plus the one-pixel and distance
+residuals accept it, with no further visibility proof. Like the paper's method it can converge past
+a thin occluder between the interface and the receiver; that is the accepted cost of a few G-buffer
+reads per pixel. Pixels Newton fails fall back to a water adapter using the existing FFX cell
+intersection/depth-loading chunks. The adapter traverses the HZB's actual integer
 mip dimensions, including odd viewport sizes; it does not assume a floating halving of the source
 grid. It starts in the source pixel, since water is absent from opaque depth. HZB slab crossings
 are intersected once with the selected receiver plane and validated again before shading. A second
-Newton search here could jump to a farther root and falsely certify it as the first hit. Analytic ray distance sets the visibility
-interval instead of the biased texel-center projection. An exhausted traversal uses the control
-event. Color filtering accepts only taps on the validated
+Newton search here could jump past the first footprint to a root the traversal has ruled out.
+An exhausted traversal uses the control event. Color filtering accepts only taps on the validated
 receiver's local plane, with geometric-normal and interface-side checks. Receiver selection retains
 full-precision UV/path/control-path data. Final shading reads the same selected interface and
 deterministic surface owner before shared occupancy/extinction/draw consume its optical result.
@@ -112,13 +120,14 @@ statistics nor its timing results apply directly to this implementation.
 Acceptance reconstructs the receiver at its subpixel UV on the sampled face plane before measuring
 ray proximity. Using the texel-center position instead can reject exact planar intersections at
 grazing angles and introduce striped hit/control transitions. This is independent of adaptive mip
-filtering. First-hit traversal still has a finite budget: inspect trace status when increasing the
-fallback steps, since an exhausted visibility check deliberately selects the control event.
+filtering. Each Newton lookup reads depth and face normal once: the plane that rejects one lookup
+is the tangent plane for the next update, so N updates read N+1 texels. Fallback steps bound only
+the traversal for failed pixels and screen reflections.
 
 The main risks to check on target hardware are moving-wave temporal ghosts (water keeps the opaque
 depth/motion contract), coarse 8×8 volume attenuation near thin/partial edges, tangent-plane hits at
 depth discontinuities, and first activation of AVBOIT in otherwise opaque scenes. No paper performance
-claim is adopted; visibility checks and geometry-aware filtering add work to water rendering.
+claim is adopted; disocclusion fades and geometry-aware filtering add work to water rendering.
 Water transient targets cost approximately 68 bytes per internal pixel before allocator lifetime
 reuse, plus up to 0.375 bytes per pixel for the three quarter-resolution visibility fields:
 32 bytes for receiver/trace metadata, 4 for interface depth, and 32 for final optics/background. The tiny-loss
@@ -133,7 +142,7 @@ They also cover the actual shared WGSL contribution/resolve, count conservation,
 normal-incidence acceptance, analytic plane/sphere intersections, invalid rays, bounded fallback thickness,
 geometry-only visibility seeds, single-lookup transport, subpixel receiver thickness,
 grazing visibility intervals, odd-dimension traversal crossings, receiver ownership at silhouettes,
-first-receiver selection, source/receiver frame-edge fades and old/new serialization.
+converged roots kept without a traversal budget, source/receiver frame-edge fades and old/new serialization.
 Software-device orchestration verifies water precedes shared warp/integration/resolve without adding
 another one. Visual checks are complementary: inspect TAA/fog, mixed sources, below-interface fallback,
 overlap, no-water/MBOIT suppression, terrain replacement and device restart on a real GPU.

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

@@ -16,19 +16,17 @@ input[type=range]{width:135px}input[type=number]{width:84px}input,select,button,
 <h2>Water</h2><label>Enabled<input id="enabled" type="checkbox" checked></label>
 <label>Level<input id="level" type="range" min="-1.5" max="2" step=".05" value="0"></label>
 <label>IOR<input id="ior" type="range" min="1" max="1.6" step=".01" value="1.33"></label>
-<label>Optical normal<input id="normal" type="range" min="0" max=".5" step=".01" value=".08"></label>
-<label>Normal scale<input id="scale" type="range" min=".2" max="8" step=".1" value="3"></label>
-<label>Roughness<input id="roughness" type="range" min="0" max="1" step=".01" value=".08"></label>
-<label>Extinction R<input id="extinction_r" type="number" min="0" max="2" step=".01" value=".12"></label>
-<label>Extinction G<input id="extinction_g" type="number" min="0" max="2" step=".01" value=".035"></label>
-<label>Extinction B<input id="extinction_b" type="number" min="0" max="2" step=".01" value=".02"></label>
-<label>Body color<input id="color" type="color" value="#004d80"></label><label>Shore color<input id="shore_color" type="color" value="#95cad9"></label>
+<label>Wind m/s<input id="wind" type="range" min="0" max="12" step=".1" value="3"></label>
+<label>Wind direction °<input id="wind_direction" type="range" min="0" max="360" step="1" value="30"></label>
+<label>Roughness<input id="roughness" type="range" min="0" max="1" step=".01" value=".02"></label>
+<label>Medium<select id="medium"><option value="swimming_pool">Swimming pool</option><option value="clear_ocean">Clear ocean</option><option value="tropical_lagoon">Tropical lagoon</option><option value="open_ocean" selected>Open ocean</option><option value="coastal">Coastal</option><option value="green_lake">Green lake</option><option value="turbid_river">Turbid river</option></select></label>
+<label>In-scatter segments<input id="segments" type="range" min="1" max="16" step="1" value="4"></label>
 <label>Screen reflections<input id="reflection" type="checkbox" checked></label>
 <h2>Mixed transparency</h2><label>Layer height<input id="layer_height" type="range" min="-2" max="3" step=".05" value="0"></label>
 <label>Card opacity<input id="opacity" type="range" min=".02" max=".98" step=".02" value=".5"></label>
 <label>Alpha + additive particles<input id="particles" type="checkbox" checked></label>
 <label>Ribbon<input id="ribbon" type="checkbox" checked></label><label>Move submerged object<input id="animate" type="checkbox"></label>
-<label>Overlap water<input id="overlap" type="checkbox"></label><div class="row"><button id="order">Swap channel order</button><button id="terrain">Replace terrain</button><button id="restart">Restart device</button></div>
+<label>Overlap water<input id="overlap" type="checkbox"></label><label>Warp steps (4 per octave)<input id="warp_steps" type="checkbox" checked></label><div class="row"><button id="order">Swap channel order</button><button id="terrain">Replace terrain</button><button id="restart">Restart device</button></div>
 <h2>Tracing / frame</h2><label>Trace<select id="mode"><option value="0">Newton + fallback</option><option value="1">Bounded traversal</option><option value="2">Undisplaced control</option></select></label>
 <label>Newton updates<input id="iterations" type="number" min="0" max="16" value="4"></label><label>Fallback steps<input id="fallback" type="number" min="0" max="128" value="48"></label>
 <label>Temporal<select id="temporal"><option value="off">Off</option><option value="taa">TAA</option><option value="nss">NSS (requires weights)</option></select></label>

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

@@ -21,7 +21,8 @@ import { Scene } from "../../renderer/scene/Scene.js";
 import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
 import { ShadeUpscalerType } from "../../renderer/ShadeUpscalerType.js";
 import { ParticipatingMediaVolume } from "../../renderer/volumetrics/ParticipatingMediaVolume.js";
-import { water_shader, water_finalize_shader } from "../../renderer/water/shader_water.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 * as water_shaders from "../../renderer/water/shader_water_avboit.js";
 import { install_profile_hotkey } from "../profile_hotkey.js";
 import { build_world } from "./world.js";
@@ -33,13 +34,12 @@ const presets = {
     edge: [[22,5,18],[23,0,11]], underwater: [[19,-0.8,18],[12,-1,12]],
     discontinuities: [[18.946,7.002,6.28],[15.4,2.439,10.562]],
 };
-const input_ids = ["preset","enabled","level","ior","normal","scale","roughness","extinction_r","extinction_g",
-    "extinction_b","color","shore_color","reflection","layer_height","opacity","particles","ribbon","animate",
-    "overlap","mode","iterations","fallback","temporal","resolution","ssr","fog","transparency","debug"];
+const input_ids = ["preset","enabled","level","ior","wind","wind_direction","roughness","medium","segments",
+    "reflection","layer_height","opacity","particles","ribbon","animate",
+    "overlap","warp_steps","mode","iterations","fallback","temporal","resolution","ssr","fog","transparency","debug"];
 const initial_inputs = Object.fromEntries(input_ids.map(id => [id,element(id).type === "checkbox" ? element(id).checked : element(id).value]));
 const number = id => Number(element(id).value);
 const checked = id => element(id).checked;
-const color = (target, hex) => target.setRGB(...[1,3,5].map(i => parseInt(hex.slice(i,i+2),16)/255));
 
 async function main() {
     const viewport = element("viewport"), graphics = new GraphicsEngine(), scene = new Scene();
@@ -73,11 +73,11 @@ async function main() {
     function configure() {
         revision++;
         const w=world.water,s=water_system.settings,r=graphics.renderer;
-        w.level.set(number("level"));w.ior.set(number("ior"));w.opticalNormalStrength.set(number("normal"));
-        w.opticalNormalScale.set(number("scale"));w.reflectionRoughness.set(number("roughness"));
-        w.extinction.set(number("extinction_r"),number("extinction_g"),number("extinction_b"));
-        color(w.color,element("color").value);color(w.shoreColor,element("shore_color").value);
+        w.level.set(number("level"));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);
+        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"),
             fallback_steps:number("fallback"),reflections:checked("reflection")?1:0,debug_view:number("debug")});
         world.card.component.material.diffuse_color.a=number("opacity");
         world.effects.forEach(effect=>effect.emitting=checked("particles"));world.ribbon.visible=checked("ribbon");
@@ -86,6 +86,7 @@ async function main() {
         if(!checked("fog")&&fog_added){scene.volumetrics.remove(fog);fog_added=false;}
         if(r!==null&&r!==undefined){
             r.transparency_mode=element("transparency").value==="avboit"?ShadeTransparencyMode.AVBOIT:ShadeTransparencyMode.MBOIT;
+            r.avboit.warp_steps_per_octave=checked("warp_steps")?4:1;
             r.feature_taa_enabled=element("temporal").value!=="off";
             r.upscale_type=element("temporal").value==="nss"?ShadeUpscalerType.NSS:ShadeUpscalerType.TAA;
             r.feature_ssr_enabled=checked("ssr");r.pixel_ratio=number("resolution");
@@ -156,7 +157,7 @@ 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,...Object.values(water_shaders).map(s=>s.descriptor)]){
+        for(const shader of [water_shader,water_finalize_shader_ibl,water_finalize_shader_brick4,...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}`));
@@ -172,7 +173,7 @@ async function main() {
         try{const result=await water_system.request_probe([(event.clientX-rect.left)/rect.width,(event.clientY-rect.top)/rect.height]);
             const packed=result.receiver[3],code=Math.floor(packed);
             const classification=result.transmission[3]<=0?"no water coverage":code===31?"below-interface control":
-                ["Newton-assisted hit","HZB hit","undisplaced fallback","bounded sky"][Math.floor(code/8)]??"invalid";
+                ["Newton hit","HZB hit","undisplaced fallback","bounded sky"][Math.floor(code/8)]??"invalid";
             const reason=["none / not attempted","bounds / clip","sky","parallel / invalid","ray interval","budget / residual"][code%8];
             element("probe").textContent=JSON.stringify({...result,
                 stale:revision!==probe_revision||JSON.stringify(state().camera)!==probe_camera,

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

@@ -2,6 +2,7 @@
 export function build_world(dataset: any): Promise<{
     terrain: Terrain;
     water: Water;
+    waves: WaterWaves;
     water_entity: any;
     card: {
         transform: Transform64;
@@ -29,6 +30,7 @@ export function build_world(dataset: any): Promise<{
 export function height_at(x: any, z: any, offset?: number): number;
 import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
 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";
 import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { DynamicMeshBatch } from "../../renderer/scene/DynamicMeshBatch.js";

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":"AA0DA,+FAA+F;AAC/F;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EC;AA5GM,mEAAsE;oBAxBzD,4CAA4C;kBAI9C,6CAA6C;4BAHnC,8CAA8C;+BAE3C,wDAAwD;iCActD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EC;AA9GM,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

@@ -1,4 +1,5 @@
 import { Color } from "../../../core/color/Color.js";
+import { water_medium_preset } from "../../renderer/medium/water/water_presets.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { Entity } from "../../../engine/ecs/Entity.js";
@@ -7,6 +8,7 @@ import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import { t64_announce_change } from "../../../engine/ecs/transform/t64_announce_change.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 { ParticleEffect } from "../../../engine/graphics/ecs/particles/ParticleEffect.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
 import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
@@ -80,8 +82,10 @@ export async function build_world(dataset) {
     const floor_material=material([1,1,1]); floor_material.texture_albedo=checker();
     const floor_transform=pose(0,0,0);
     const floor_entity=build(new Entity().add(floor_transform).add(shaded(meshlets(floor_geo),floor_material)));
-    const water=new Water(); water.level.set(0); water.scattering.set(0.6);
-    const water_entity=build(new Entity().add(water));
+    const water=new Water(); water.level.set(0);
+    // the primitive wave simulation's forcing; the overlapping second body below has none and stays calm
+    const waves=new WaterWaves();
+    const water_entity=build(new Entity().add(water).add(waves));
     const add_mesh=(geo,m,x,y,z,rotation)=>{
         const t=pose(x,y,z,rotation);const component=shaded(meshlets(geo),m);
         const entity=build(new Entity().add(t).add(component)); return {transform:t,component,entity};
@@ -102,7 +106,7 @@ export async function build_world(dataset) {
     const batch=new DynamicMeshBatch(); batch.add(ribbon);
     let secondary=null;
     let last_update=null;
-    return {terrain,water,water_entity,card,submerged,batch,ribbon,effects:live_effects,entities,
+    return {terrain,water,waves,water_entity,card,submerged,batch,ribbon,effects:live_effects,entities,
         reset_particles() {
             particle_transforms.forEach(({entity},i)=>{
                 const replacement=live_effects[i].clone();
@@ -129,7 +133,7 @@ export async function build_world(dataset) {
         },
         overlap(enabled) {
             if(enabled&&secondary===null) {const other=new Water();other.level.set(water.level.getValue()-0.4);
-                other.color.setRGB(0.65,0.1,0.25);secondary=build(new Entity().add(other));}
+                other.medium=water_medium_preset({preset:'turbid_river'});secondary=build(new Entity().add(other));}
             if(!enabled&&secondary!==null) {dataset.removeEntity(secondary);secondary=null;}
         },
         dispose() {entities.forEach(id=>{if(dataset.entityExists(id)) dataset.removeEntity(id);});batch.clear();},

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

@@ -73,6 +73,8 @@ export class Renderer {
     feature_tetrahedron_point_shadows: boolean;
     set shadow_update_budget(v: number);
     get shadow_update_budget(): number;
+    set shadow_cascade_count(v: number);
+    get shadow_cascade_count(): number;
     feature_bloom_enabled: boolean;
     feature_automatic_exposure_enabled: boolean;
     set exposure_compensation(v: number);

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

@@ -77,6 +77,7 @@ import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { DEFAULT_SHADOWMAP_UPDATE_BUDGET } from "./shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js";
+import { SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT } from "./shadow/map/csm/SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT.js";
 import { CascadedSceneSDF } from "./shadow/sdf/cascade/CascadedSceneSDF.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
@@ -250,6 +251,26 @@ export class Renderer {
         return this.#shadow_update_budget;
     }
 
+    /**
+     * How many cascades a directional light's shadow map is split into, pushed to the scene's
+     * shadow context each frame; see {@link GPUSceneShadowmapContext.cascade_count}. More cascades
+     * put more shadow texels near the camera at the cost of a rasterization pass each. A change
+     * rebuilds every directional map, and its near planes come back loose for the two frames its
+     * caster range takes to be measured again.
+     * @type {number}
+     */
+    #shadow_cascade_count = SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT;
+
+    set shadow_cascade_count(v) {
+        assert.isPositiveInteger(v, 'shadow_cascade_count');
+
+        this.#shadow_cascade_count = v;
+    }
+
+    get shadow_cascade_count() {
+        return this.#shadow_cascade_count;
+    }
+
     feature_bloom_enabled = true;
     feature_automatic_exposure_enabled = true;
 
@@ -2093,6 +2114,8 @@ export class Renderer {
         sm.use_tetrahedron_point_shadows = this.feature_tetrahedron_point_shadows;
         // How many views the refresh scheduler may spend on this scene this frame.
         sm.update_budget = this.#shadow_update_budget;
+        // How many cascades a directional map has; a change rebuilds the maps inside process_lights.
+        sm.cascade_count = this.#shadow_cascade_count;
 
         const taa = this.#taa;
 

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAyF1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCA5IjB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AA+F1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCApJjB,8DAA8D;4CAY3D,mDAAmD;iCAC9D,+BAA+B"}