@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/water/surface/shader_water_tiles.js

@@ -0,0 +1,123 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_read_meshlet_vertex_by_draw_index } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
+import { WATER_BODIES_TABLE, WATER_WAVES_TABLE } from "../medium/chunk_water_bodies.js";
+import { chunk_water_tessellation, WATER_TILE_CELLS, WATER_TILE_STRUCT, WATER_TESSELLATION_STRUCT } from "./chunk_water_tessellation.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.setImmediate('capacity', u32);
+resources.createGroup().addUniform('camera', CAMERA_UNIFORM_STRUCT).addUniform('tessellation', WATER_TESSELLATION_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('water_meshlets', MESHLET_COLLECTION_STRUCT)
+    .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+    .addStorageBuffer('tiles', WebGPUArray.from(WATER_TILE_STRUCT), true)
+    .addStorageBuffer('counts', COLLECTION_U32_STRUCT_READ, true);
+
+/** Keep triangle identity, including hidden bodies. Only displaced raster depth selects ownership. */
+export const shader_water_tiles = ComputeShader.from({ label: 'Water / classify view tiles', resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    if (i == 0u) { counts.count = capacity; }
+    if (i >= capacity) { return; }
+    counts.elements[i] = 0u;
+    let meshlet_slot = i / ${GEOMETRY_MESHLET_TRIANGLE_LIMIT}u;
+    if (meshlet_slot >= water_meshlets.count) { return; }
+    let definition = water_meshlets.elements[meshlet_slot];
+    let triangle = i % ${GEOMETRY_MESHLET_TRIANGLE_LIMIT}u;
+    let header = meshlet_metadata[definition.index];
+    if (triangle >= header.primitive_count) { return; }
+    let body = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, definition.mesh);
+    let node = scene_read_node(&scene_database, body.node);
+    let simulated = body.wave != ~0u;
+    var bounds = vec2f(0);
+    if (simulated) { bounds = ${WATER_WAVES_TABLE.marshalling_method_read}(&scene_database, body.wave).displacement_bounds; }
+    // Increasing near-plane distance is farther from the camera. Use the far endpoint;
+    // clipping it at the near plane cannot discard a point displaced into the visible frustum.
+    let direction = tessellation.view_projection_matrix * node.global[1];
+    let farther = direction.w - direction.z >= 0.0;
+    var anchor = 0.0;
+    var pixels = tessellation.pixels;
+    if (simulated) {
+        let box = geometries[body.geometry].bounding_box;
+        // A shared local-xz reference keeps adjacent triangles' generated edge vertices
+        // identical, including sloped rest geometry. Only reconstruction flattens height;
+        // rendered vertices still interpolate all three authored position coordinates.
+        anchor = select(box[1] + bounds.x, box[4] + bounds.y, farther);
+        let x = tessellation.view_projection_matrix * node.global[0];
+        let z = tessellation.view_projection_matrix * node.global[2];
+        let origin = tessellation.view_projection_matrix * node.global[3];
+        let plane = cross(x.xyw, z.xyw);
+        let reference = origin + direction * anchor;
+        let span = box[4] - box[1] + bounds.y - bounds.x;
+        if (span > 0.0 && abs(dot(plane, reference.xyw)) <= 1e-5 * length(plane) * max(length(reference.xyw), 1.0)
+            && abs(dot(plane, direction.xyw)) > 1e-20) {
+            anchor += select(-span, span, farther);
+        }
+        var minimum_w = 1e30;
+        for (var corner = 0u; corner < 4u; corner++) {
+            let p = vec3f(select(box[0], box[3], (corner & 1u) != 0u), anchor, select(box[2], box[5], (corner & 2u) != 0u));
+            minimum_w = min(minimum_w, (tessellation.view_projection_matrix * (node.global * vec4f(p, 1))).w);
+        }
+        let low = box[1] + bounds.x - anchor;
+        let high = box[4] + bounds.y - anchor;
+        let slopes = vec4f(direction.w + direction.x, direction.w - direction.x, direction.w + direction.y, direction.w - direction.y);
+        let allowance = max(vec4f(0), max(slopes * low, slopes * high));
+        // After swept side-plane clipping, the reference's NDC span is at most
+        // 2 + (left + right allowance)/minimum_w. Use this body-wide bound so a
+        // near-plane envelope cannot amplify patches or split shared edge grids.
+        let amplification = 1.0 + max(allowance.x + allowance.y, allowance.z + allowance.w)
+            / (2.0 * max(camera.clip_near_far.x, minimum_w));
+        pixels *= amplification;
+    }
+    let pa = read_meshlet_vertex_by_draw_index(header, triangle * 3u).position;
+    let pb = read_meshlet_vertex_by_draw_index(header, triangle * 3u + 1u).position;
+    let pc = read_meshlet_vertex_by_draw_index(header, triangle * 3u + 2u).position;
+    let a = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pa, anchor, simulated), 1));
+    let b = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pb, anchor, simulated), 1));
+    let c = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pc, anchor, simulated), 1));
+    let heights = select(vec3f(0), vec3f(pa.y, pb.y, pc.y) - vec3f(anchor), simulated);
+    var p = water_clip_polygon(water_triangle_polygon(), water_plane_distances(a,b,c,vec4f(0,0,-1,1)), 0u);
+    // The reference is unjittered, but raster samples may move into the viewport by
+    // a pixel. Retain that fixed border without letting jitter change the tile grid.
+    let border = vec2f(1.0) + vec2f(2.0) / tessellation.resolution;
+    let planes = array<vec4f,4>(vec4f(1,0,0,border.x),vec4f(-1,0,0,border.x),vec4f(0,1,0,border.y),vec4f(0,-1,0,border.y));
+    for (var plane = 0u; plane < 4u; plane++) {
+        let sweep = dot(direction, planes[plane]);
+        let allowance = max((heights + vec3f(bounds.x)) * sweep, (heights + vec3f(bounds.y)) * sweep);
+        p = water_clip_polygon(p, water_plane_distances(a,b,c,planes[plane]) + allowance, 0u);
+    }
+    if (p.count < 3u) { return; }
+    var lo = vec2f(1e30); var hi = vec2f(-1e30);
+    for (var corner = 0u; corner < p.count; corner++) {
+        let q = a * p.points[corner].x + b * p.points[corner].y + c * p.points[corner].z;
+        let pixel = (q.xy / q.w * vec2f(0.5,-0.5) + vec2f(0.5)) * tessellation.resolution;
+        lo = min(lo, pixel); hi = max(hi, pixel);
+    }
+    let tile_pixels = pixels * ${WATER_TILE_CELLS}.0;
+    let origin = vec2i(floor(lo / tile_pixels));
+    let end = vec2i(ceil(hi / tile_pixels));
+    let size = vec2u(max(end - origin, vec2i(0)));
+    if (any(size == vec2u(0))) { return; }
+    var tile: WaterTile;
+    tile.meshlet = definition.index; tile.triangle = triangle; tile.body = definition.mesh;
+    tile.anchor = anchor; tile.origin = origin; tile.size = size; tile.pixels = pixels;
+    tiles[i] = tile;
+    counts.elements[i] = size.x * size.y;
+}
+`, [chunk_water_tessellation, chunk_read_meshlet_vertex_by_draw_index, chunk_scene_database_access,
+    WATER_BODIES_TABLE.chunk_read, WATER_WAVES_TABLE.chunk_read, chunk_folded_workgroup_index]) });

package/src/shade/renderer/water/surface/shader_water_wave_batch.d.ts

@@ -0,0 +1,6 @@
+export const WATER_WAVE_BATCH_STRUCT: WebGPUStruct;
+export const shader_water_wave_batch: ComputeShader;
+export const shader_water_wave_batch_finish: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_wave_batch.d.ts.map

package/src/shade/renderer/water/surface/shader_water_wave_batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_wave_batch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_wave_batch.js"],"names":[],"mappings":"AAYA,mDAC+E;AAO/E,oDA8CwH;AAMxH,2DAY4F;6BA/E/D,mCAAmC;8BALlC,+BAA+B"}

package/src/shade/renderer/water/surface/shader_water_wave_batch.js

@@ -0,0 +1,85 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { WATER_WAVES_TABLE as table } from "../medium/chunk_water_bodies.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_srdnoise2 } from "../../shader/chunk/noise/psrdnoise/chunk_srdnoise2.js";
+import { chunk_water_wave } from "./chunk_water_wave.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+
+export const WATER_WAVE_BATCH_STRUCT = WebGPUStruct.from({ resolution: u32, capacity: u32,
+    dt: f32, time: f32, damping: f32, apply_impulses: u32 }, 'WaterWaveBatch');
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('domain', WebGPUArray.u32)
+    .addStorageBuffer('state_current', WebGPUArray.from(f32))
+    .addStorageBuffer('state_previous', WebGPUArray.from(f32), true);
+export const shader_water_wave_batch = ComputeShader.from({ label: 'Water / batched wave step', resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    let n = batch.resolution;
+    let row = i / (n * n);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read}(&scene_database, row);
+    if (params.first_write != 0u || params.node == 0u || params.node == ~0u || domain[i] == 0u) { state_previous[i] = 0.0; return; }
+    if (batch.dt == 0.0) { return; }
+    let cell = vec2u(i % n, (i / n) % n);
+    let start = row * n * n;
+    let spacing = max((params.extent.zw - params.extent.xy) / f32(n - 1u), vec2f(1e-20));
+    let world = scene_read_node(&scene_database, params.node).global;
+    let scale = vec3f(length(world[0].xyz), length(world[1].xyz), length(world[2].xyz));
+    // A temporarily collapsed transform must not poison persistent histories with NaNs.
+    if (any(scale <= vec3f(1e-10))) { state_previous[i] = state_current[i]; return; }
+    let world_spacing = max(spacing * scale.xz, vec2f(1e-10));
+    let h = state_current[i];
+    let left = start + cell.y * n + select(cell.x - 1u, 0u, cell.x == 0u);
+    let right = start + cell.y * n + min(cell.x + 1u, n - 1u);
+    let down = start + select(cell.y - 1u, 0u, cell.y == 0u) * n + cell.x;
+    let up = start + min(cell.y + 1u, n - 1u) * n + cell.x;
+    let laplacian = (state_current[left] + state_current[right] - 2.0 * h) / (world_spacing.x * world_spacing.x)
+        + (state_current[down] + state_current[up] - 2.0 * h) / (world_spacing.y * world_spacing.y);
+    let position = mix(params.extent.xy, params.extent.zw, vec2f(cell) / f32(n - 1u));
+    let wind = params.forcing.xy * scale.xz;
+    let wind_direction = wind / max(length(wind), 1e-20);
+    let drift = wind_direction * params.forcing.w * batch.time;
+    var force = params.forcing.z / scale.y * srdnoise2((position * scale.xz - drift) / 6.0, 0.0).x;
+    if (batch.apply_impulses != 0u) {
+        for (var j = 0u; j < params.impulse_count; j++) {
+            let impulse = params.impulses[j];
+            let d = position - impulse.xy;
+            let world_delta = (world * vec4f(d.x, 0.0, d.y, 0.0)).xyz;
+            force += impulse.w / (batch.dt * scale.y) * exp(-dot(world_delta, world_delta) / max(impulse.z * impulse.z, 1e-6));
+        }
+    }
+    let damping = batch.damping + water_wave_sponge(cell, n, max(4.0, f32(n) * 0.04), 4.0);
+    // The authored surface has no bathymetry. The primitive producer uses a one-metre reference
+    // depth; the CFL cap follows both axes of its local grid. It does not define the mesh outline.
+    let celerity = 0.6 * min(world_spacing.x, world_spacing.y) / batch.dt;
+    state_previous[i] = water_wave_step(h, state_previous[i], laplacian,
+        water_wave_celerity2(1.0, celerity), damping, force, batch.dt);
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_srdnoise2, chunk_water_wave, chunk_scene_database_access]) });
+
+const finish_resources = new ShaderResourceSetDescriptor();
+finish_resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32, true);
+const pg = table.page_iterator_symbol_prefix(64, true);
+export const shader_water_wave_batch_finish = ComputeShader.from({ label: 'Water / consume wave inputs', resources: finish_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
+    let slot = ${pg}_slot_in_page(lane);
+    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
+    let row = ${pg}_slot_to_index(slot);
+    ${table.marshalling_method_write_field('first_write')}(&scene_database, row, 0u);
+    if (batch.apply_impulses != 0u) { ${table.marshalling_method_write_field('impulse_count')}(&scene_database, row, 0u); }
+}
+`, [table.chunk_iterate(64, true), table.wgsl_gen_write_field_code('first_write'),
+        table.wgsl_gen_write_field_code('impulse_count'), chunk_folded_workgroup_index]) });

package/src/shade/renderer/water/surface/shader_water_wave_domain.d.ts

@@ -0,0 +1,6 @@
+/** Bake the authored footprint once per new wave row, using the existing geometry BLAS. */
+export const shader_water_wave_domain: ComputeShader;
+/** Bilinear reconstruction cannot leave the extrema of its samples. Include the rest surface. */
+export const shader_water_wave_bounds: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_wave_domain.d.ts.map

package/src/shade/renderer/water/surface/shader_water_wave_domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_wave_domain.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_wave_domain.js"],"names":[],"mappings":"AAwBA,2FAA2F;AAC3F,qDAqBsF;AAOtF,iGAAiG;AACjG,qDA4BmH;8BAlFrF,+BAA+B"}

package/src/shade/renderer/water/surface/shader_water_wave_domain.js

@@ -0,0 +1,83 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { chunk_ray_query_blas_nearest } from "../../shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WATER_WAVES_TABLE as table } from "../medium/chunk_water_bodies.js";
+import { WATER_WAVE_BATCH_STRUCT } from "./shader_water_wave_batch.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('blas_lookup', WebGPUArray.u32)
+    .addStorageBuffer('blas_data', WebGPUArray.from(BVH2_NODE_STRUCT))
+    .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+    .addStorageBuffer('domain', WebGPUArray.u32, true);
+
+/** Bake the authored footprint once per new wave row, using the existing geometry BLAS. */
+export const shader_water_wave_domain = ComputeShader.from({ label: 'Water / authored simulation domain', resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    let n = batch.resolution;
+    let row = i / (n * n);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read}(&scene_database, row);
+    if (params.node == 0u || params.node == ~0u) { domain[i] = 0u; return; }
+    if (params.first_write == 0u && batch.apply_impulses == 0u) { return; }
+    let geometry = geometries[params.geometry];
+    let cell = vec2u(i % n, (i / n) % n);
+    let xz = mix(params.extent.xy, params.extent.zw, vec2f(cell) / f32(n - 1u));
+    let margin = max(1e-3, (geometry.bounding_box[4] - geometry.bounding_box[1]) * 1e-4);
+    let top = geometry.bounding_box[4] + margin;
+    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+    let hit = ray_query_blas_nearest(Ray(vec3f(xz.x, top, xz.y), vec3f(0.0, -1.0, 0.0),
+        top - geometry.bounding_box[1] + margin), params.geometry, &stack, 0u);
+    domain[i] = select(0u, 1u, hit.t >= 0.0);
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_ray_query_blas_nearest]) });
+
+const bounds_resources = new ShaderResourceSetDescriptor();
+bounds_resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32, true)
+    .addStorageBuffer('state', WebGPUArray.from(f32));
+
+/** Bilinear reconstruction cannot leave the extrema of its samples. Include the rest surface. */
+export const shader_water_wave_bounds = ComputeShader.from({ label: 'Water / displacement bounds', resources: bounds_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+var<workgroup> lower: array<f32, 128>;
+var<workgroup> upper: array<f32, 128>;
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let row = folded_workgroup_index(group);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read_rw}(&scene_database, row);
+    let occupied = params.node != 0u && params.node != ~0u;
+    let size = select(0u, batch.resolution * batch.resolution, occupied);
+    var lo = 0.0;
+    var hi = 0.0;
+    for (var cell = lane; cell < size; cell += 128u) {
+        let h = state[row * size + cell];
+        lo = min(lo, h); hi = max(hi, h);
+    }
+    lower[lane] = lo; upper[lane] = hi;
+    workgroupBarrier();
+    for (var stride = 64u; stride != 0u; stride /= 2u) {
+        if (lane < stride) {
+            lower[lane] = min(lower[lane], lower[lane + stride]);
+            upper[lane] = max(upper[lane], upper[lane + stride]);
+        }
+        workgroupBarrier();
+    }
+    if (lane == 0u && occupied) { ${table.marshalling_method_write_field('displacement_bounds')}(&scene_database, row, vec2f(lower[0], upper[0])); }
+}
+`, [table.chunk_read_rw, table.wgsl_gen_write_field_code('displacement_bounds'), chunk_folded_workgroup_index]) });

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

@@ -1 +1 @@
-{"version":3,"file":"water_height_texture_from_sampler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_height_texture_from_sampler.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uEAFa,YAAY,CA4BxB;6BAnD4B,4BAA4B"}
+{"version":3,"file":"water_height_texture_from_sampler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_height_texture_from_sampler.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uEAFa,YAAY,CA8BxB;6BArD4B,4BAA4B"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../core/assert.js";
-import { to_half_float_uint16 } from "../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { ColorSpace } from "../texture/ColorSpace.js";
 import { ShadeTexture } from "../texture/ShadeTexture.js";
@@ -36,10 +35,12 @@ export function water_height_texture_from_sampler(sampler) {
 
     const count = sampler.width * sampler.height;
 
-    const data = new Uint16Array(count);
+    const data = new Float16Array(count);
 
     for (let i = 0; i < count; i++) {
-        data[i] = to_half_float_uint16(source[i]);
+        const value = source[i];
+        // Keep finite heights inside binary16's range without changing special values.
+        data[i] = Number.isFinite(value) ? Math.min(Math.max(value, -65504), 65504) : value;
     }
 
     const image = ShadeImage.fromArrayBuffer(

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

@@ -0,0 +1,17 @@
+/**
+ * How far the water passes integrate a body where nothing is seen through it on screen — the sky, the
+ * screen edge, a trace that failed: to where its clearest channel's beam transmittance has fallen to a
+ * thousandth, so the water's own light has stopped changing, bounded by the trace distance. A missing
+ * receiver is missing visibility; assuming nothing about the geometry that is not there, the water
+ * reads as deep.
+ *
+ * @param {Object} options
+ * @param {import("../medium/ParticipatingMedium.js").ParticipatingMedium} options.medium
+ * @param {number} options.max_distance the trace distance, m
+ * @returns {number} m
+ */
+export function water_missing_receiver_path({ medium, max_distance }: {
+    medium: import("../medium/ParticipatingMedium.js").ParticipatingMedium;
+    max_distance: number;
+}): number;
+//# sourceMappingURL=water_missing_receiver_path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"water_missing_receiver_path.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_missing_receiver_path.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IAJmF,MAAM,EAA9E,OAAO,kCAAkC,EAAE,mBAAmB;IAC9C,YAAY,EAA5B,MAAM;IACJ,MAAM,CA2BlB"}

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

@@ -0,0 +1,40 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * How far the water passes integrate a body where nothing is seen through it on screen — the sky, the
+ * screen edge, a trace that failed: to where its clearest channel's beam transmittance has fallen to a
+ * thousandth, so the water's own light has stopped changing, bounded by the trace distance. A missing
+ * receiver is missing visibility; assuming nothing about the geometry that is not there, the water
+ * reads as deep.
+ *
+ * @param {Object} options
+ * @param {import("../medium/ParticipatingMedium.js").ParticipatingMedium} options.medium
+ * @param {number} options.max_distance the trace distance, m
+ * @returns {number} m
+ */
+export function water_missing_receiver_path({ medium, max_distance }) {
+    assert.defined(medium, 'medium');
+    assert.isFinite(max_distance, 'max_distance');
+    assert.greaterThan(max_distance, 0, 'max_distance');
+
+    const lobes = medium.lobes;
+
+    let clearest = Infinity;
+
+    for (let c = 0; c < 3; c++) {
+        let extinction = medium.absorption[c];
+
+        for (let i = 0; i < lobes.length; i++) {
+            extinction += lobes[i].scattering[c];
+        }
+
+        clearest = Math.min(clearest, extinction);
+    }
+
+    if (!(clearest > 0)) {
+        // a channel the water never attenuates: as far as the trace goes
+        return max_distance;
+    }
+
+    return Math.min(Math.log(1000) / clearest, max_distance);
+}

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAuiBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAnkBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAkmBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UA9nBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}