@woosh/meep-engine 3.37.0 → 3.38.0

package/src/shade/renderer/water/chunk_water_transport.js

@@ -0,0 +1,94 @@
+import { CodeChunk } from '../shader/compiler/CodeChunk.js';
+import { chunk_decode_g_buffer_normal } from '../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js';
+import { chunk_inv_project_position } from '../shader/chunk/screen_space/chunk_inv_project_position.js';
+import { chunk_is_background } from '../shader/chunk/depth/chunk_is_background.js';
+
+export const chunk_water_refraction_confidence = CodeChunk.from(/* language=WGSL */ `
+fn water_refraction_lookup(original: vec2f, receiver: vec2f, confidence: f32) -> vec2f {
+    return mix(original, receiver, clamp(confidence, 0.0, 1.0));
+}
+fn water_refraction_confidence(uv: vec2f, original_uv: vec2f, size: vec2f, distance_tiles: f32) -> f32 {
+    let displacement = length((uv - original_uv) * size);
+    let fade_width = clamp(displacement, 8.0, 64.0);
+    let visibility = smoothstep(0.0, fade_width, distance_tiles * 4.0);
+    let source_edge = min(min(original_uv.x, original_uv.y), min(1.0-original_uv.x, 1.0-original_uv.y));
+    let receiver_edge = min(min(uv.x, uv.y), min(1.0-uv.x, 1.0-uv.y));
+    // Approaching an off-screen receiver must approach the control lookup continuously,
+    // even while the water fragment itself is far enough from the frame border.
+    return visibility * smoothstep(0.0, clamp(displacement / min(size.x, size.y), 0.01, 0.1),
+        min(source_edge, receiver_edge));
+}
+`);
+
+export const chunk_water_transport = CodeChunk.from(/* language=WGSL */ `
+struct WaterEvent { transmission: vec3f, radiance: vec3f }
+struct WaterTransport { transmission: vec3f, radiance: vec3f, background: vec3f }
+fn water_event(path: f32, extinction: vec3f, fresnel: f32, reflection: vec3f, body: vec3f) -> WaterEvent {
+    let absorption = exp(-max(extinction, vec3f(0.0)) * max(path, 0.0));
+    let raw = (1.0 - fresnel) * absorption;
+    let t = max(raw, vec3f(1e-6));
+    let scale = (1.0 - t) / max(1.0 - raw, vec3f(1e-20));
+    return WaterEvent(t, scale * (fresnel * reflection + (1.0-fresnel) * (1.0-absorption) * body));
+}
+// One selected lookup and its optical event. Only geometric coverage mixes images;
+// fading refraction interpolates the lookup UV before sampling, never two displaced colors.
+fn water_transport(event: WaterEvent, original: vec3f, receiver: vec3f,
+    coverage: f32) -> WaterTransport {
+    let a = clamp(coverage, 0.0, 1.0);
+    let t = (1.0-a) + a * event.transmission;
+    let w = a * event.radiance;
+    let background = ((1.0-a)*original + a*event.transmission*receiver) / t;
+    return WaterTransport(t, w, background);
+}
+`);
+
+// Filtering radiance across a silhouette must not introduce a surface that the ray never hit.
+// The center depth/face normal define receiver ownership; taps must lie on that same local plane.
+export const chunk_water_receiver_radiance = CodeChunk.from(/* language=WGSL */ `
+// Depth is stored at the texel center. Intersect the lookup's camera ray with that
+// local plane so subpixel lookup motion does not quantize water thickness.
+fn water_receiver_path(depth: texture_2d<f32>, normals: texture_2d<u32>, uv: vec2f,
+    inverse_projection: mat4x4f, world_to_view: mat4x4f, origin: vec3f) -> f32 {
+    let size = vec2f(textureDimensions(depth, 0));
+    let coord = clamp(vec2i(uv*size), vec2i(0), vec2i(size)-1);
+    let d = textureLoad(depth, coord, 0).r;
+    let p = inv_project_position(vec3f((vec2f(coord)+0.5)/size,d), inverse_projection);
+    let direction = inv_project_position(vec3f(uv,d), inverse_projection);
+    let n = (world_to_view * vec4f(decode_g_buffer_normal(textureLoad(normals,coord,0).zw),0.0)).xyz;
+    let denominator = dot(n,direction);
+    if (abs(denominator) <= 1e-6) { return distance(origin,p); }
+    return distance(origin, direction * (dot(n,p)/denominator));
+}
+fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, level: f32, below_interface: bool) -> vec4f {
+    let size = vec2i(textureDimensions(depth, 0));
+    let center = clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1);
+    let center_depth = textureLoad(depth, center, 0).r;
+    if (is_background(center_depth)) { return vec4f(0.0); }
+    let center_vs = inv_project_position(vec3f((vec2f(center)+0.5)/vec2f(size), center_depth), inverse_projection);
+    let p = (inverse_view * vec4f(center_vs, 1.0)).xyz;
+    let n = decode_g_buffer_normal(textureLoad(normals, center, 0).zw);
+    if (below_interface && p.y > level + 0.02) { return vec4f(0.0); }
+    let texel = uv * vec2f(size) - 0.5;
+    let base = vec2i(floor(texel));
+    let f = fract(texel);
+    var color = vec3f(0.0);
+    var weight = 0.0;
+    for (var y = 0; y < 2; y++) {
+        for (var x = 0; x < 2; x++) {
+            let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
+            let d = textureLoad(depth, coord, 0).r;
+            if (is_background(d)) { continue; }
+            let tap_vs = inv_project_position(vec3f((vec2f(coord)+0.5)/vec2f(size), d), inverse_projection);
+            let tap = (inverse_view * vec4f(tap_vs, 1.0)).xyz;
+            let tap_n = decode_g_buffer_normal(textureLoad(normals, coord, 0).zw);
+            if ((below_interface && tap.y > level+0.02) || dot(n,tap_n) < 0.95
+                || abs(dot(tap-p,n)) > 0.02) { continue; }
+            let w = select(1.0-f.x, f.x, x == 1) * select(1.0-f.y, f.y, y == 1);
+            color += w * textureLoad(scene, coord, 0).rgb;
+            weight += w;
+        }
+    }
+    return vec4f(color / max(weight, 1e-20), weight);
+}
+`, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_is_background]);

package/src/shade/renderer/water/shader_water.d.ts

@@ -1,33 +1,16 @@
-/**
- * Build the water pipeline.
- *
- * **It has no depth attachment, and that is forced rather than chosen.** The shader *samples* scene
- * depth to know how much water the view looks through, and a texture may not be a sampled source
- * and a render attachment in the same pass. So the depth test the hardware would have done is done
- * in the shader instead — which is also why the fragment `discard` there is load-bearing rather
- * than a guard: without it, water would draw over the things standing in it.
- *
- * @param {object} [options]
- * @param {string} [options.color_format]
- * @returns {RenderPipelineDescriptor}
- */
-export function create_water_pipeline({ color_format }?: {
-    color_format?: string;
-}): RenderPipelineDescriptor;
-/**
- * One water surface. Small, and rewritten per surface per frame rather than tabled — a level has a
- * handful of these, not thousands.
- */
+export function create_water_pipeline(): RenderPipelineDescriptor;
+export function create_water_finalize_pipeline(): RenderPipelineDescriptor;
 export const WATER_DRAW_STRUCT: WebGPUStruct;
+export const WATER_TRACE_STRUCT: WebGPUStruct;
+export const WATER_FINALIZE_RESOURCES: ShaderResourceSetDescriptor;
+export const water_transport_fallback: CodeChunk;
+export const chunk_water_screen_ray: CodeChunk;
 export const water_shader: ShaderDescriptor;
-/**
- * The pipeline's resource set, for building bind groups.
- *
- * @type {ShaderResourceSetDescriptor}
- */
+export const water_finalize_shader: ShaderDescriptor;
 export const WATER_RESOURCES: ShaderResourceSetDescriptor;
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 //# sourceMappingURL=shader_water.d.ts.map

package/src/shade/renderer/water/shader_water.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAiNA;;;;;;;;;;;;GAYG;AACH;IAH4B,YAAY,GAA7B,MAAM;IACJ,wBAAwB,CAkBpC;AAnOD;;;GAGG;AACH,6CAuCuB;AAwIvB,4CAIG;AA8CH;;;;GAIG;AACH,8BAFU,2BAA2B,CAEI;yCAnPA,8DAA8D;6BAO1E,gCAAgC;iCAF5B,+BAA+B;4CADpB,mDAAmD"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA8XA,kEAAuH;AACvH,2EAAuJ;AA3WvJ,6CAKuB;AAEvB,8CAGwB;AAmBxB,mEAA8D;AAE9D,iDAIG;AAsCH,+CAmGoH;AA8KpH,4CAAmG;AACnG,qDAA2J;AAC3J,0DAAyC;yCA9WA,8DAA8D;6BAe1E,gCAAgC;4CAHjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}