@woosh/meep-engine 3.36.0 → 3.38.0

package/src/shade/renderer/shader/chunk/geometry/plane/{plane_ray_raycast.d.ts → chunk_plane_ray_raycast.d.ts}

@@ -2,6 +2,6 @@
  * Ported from meep
  * @type {CodeChunk}
  */
-export const plane_ray_raycast: CodeChunk;
+export const chunk_plane_ray_raycast: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=plane_ray_raycast.d.ts.map
+//# sourceMappingURL=chunk_plane_ray_raycast.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_plane_ray_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sCAFU,SAAS,CA2Cf;0BA/CsB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/plane/{plane_ray_raycast.js → chunk_plane_ray_raycast.js}

@@ -4,7 +4,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  * Ported from meep
  * @type {CodeChunk}
  */
-export const plane_ray_raycast = CodeChunk.from(
+export const chunk_plane_ray_raycast = CodeChunk.from(
     //language=WGSL
     `
 fn plane_ray_raycast(

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts

@@ -0,0 +1,4 @@
+/** Mayer et al. 2026 tangent-plane refinement. All arithmetic is in matrix view space. */
+export const chunk_screen_space_newton_ray: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_screen_space_newton_ray.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_screen_space_newton_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js"],"names":[],"mappings":"AAWA,0FAA0F;AAC1F,sDAwFkF;0BApGxD,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js

@@ -0,0 +1,101 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_is_background } from "../depth/chunk_is_background.js";
+import { chunk_decode_g_buffer_normal } from "../geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_plane_from_normal_and_point } from "../geometry/plane/chunk_plane_from_normal_and_point.js";
+import { chunk_plane_ray_raycast } from "../geometry/plane/chunk_plane_ray_raycast.js";
+import { RAY_STRUCT } from "../geometry/ray/RAY_STRUCT.js";
+import { chunk_ray_at } from "../geometry/ray/chunk_ray_at.js";
+import { chunk_ray_nearest_point } from "../geometry/ray/chunk_ray_nearest_point.js";
+import { chunk_inv_project_position } from "./chunk_inv_project_position.js";
+import { chunk_project_position } from "./chunk_project_position.js";
+
+/** Mayer et al. 2026 tangent-plane refinement. All arithmetic is in matrix view space. */
+export const chunk_screen_space_newton_ray = CodeChunk.from(/* language=WGSL */ `
+struct ScreenSpaceRayHit {
+    uv: vec2<f32>,
+    distance: f32,
+    residual: f32,
+    iterations: u32,
+    // 0 hit, 1 bounds/clip, 2 sky, 3 parallel/invalid, 4 interval, 5 exhausted/residual
+    status: u32,
+}
+
+fn screen_space_ray_in_bounds(uv: vec2<f32>) -> bool {
+    return all(uv >= vec2<f32>(0.0)) && all(uv < vec2<f32>(1.0));
+}
+
+fn screen_space_ray_projectable(p: vec3<f32>, projection: mat4x4<f32>) -> bool {
+    let clip = projection * vec4<f32>(p, 1.0);
+    return clip.w > 1e-6 && all(abs(clip) < vec4<f32>(1e30));
+}
+
+// Reconstruct the receiver at the subpixel lookup on its local tangent plane.
+// A texel-center position is a different surface point: projecting its nearest
+// point on the ray can exceed one pixel at grazing angles even for an exact hit.
+fn screen_space_ray_validate(
+    ray: Ray, uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
+    distance_tolerance: f32,
+) -> ScreenSpaceRayHit {
+    var hit = ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 1u);
+    if (!screen_space_ray_in_bounds(uv)) { return hit; }
+    let size = textureDimensions(depth, 0);
+    let coord = vec2<i32>(uv * vec2<f32>(size));
+    let d = textureLoad(depth, coord, 0).r;
+    if (is_background(d)) { hit.status = 2u; return hit; }
+    let center = (vec2<f32>(coord) + 0.5) / vec2<f32>(size);
+    let center_position = inv_project_position(vec3<f32>(center, d), inverse_projection);
+    let normal = (world_to_view * vec4f(decode_g_buffer_normal(textureLoad(normals, coord, 0).zw), 0.0)).xyz;
+    let lookup_ray = inv_project_position(vec3f(uv, d), inverse_projection);
+    let denominator = dot(normal, lookup_ray);
+    if (!(abs(denominator) > 1e-6)) { hit.status = 3u; return hit; }
+    let scale = dot(normal, center_position) / denominator;
+    if (!(scale > 0.0)) { hit.status = 3u; return hit; }
+    let p = lookup_ray * scale;
+    let travel = dot(p - ray.origin, ray.direction);
+    hit.distance = travel;
+    if (!(travel > 1e-4 && travel <= ray.tmax)) { hit.status = 4u; return hit; }
+    let nearest = ray_nearest_point(ray, p);
+    if (!screen_space_ray_projectable(nearest, projection)) { return hit; }
+    let pixel_error = length((project_position(nearest, projection).xy - uv) * vec2<f32>(size));
+    hit.residual = distance(p, nearest);
+    hit.status = 5u;
+    if (pixel_error <= 1.0 && hit.residual <= distance_tolerance) { hit.status = 0u; }
+    return hit;
+}
+
+fn screen_space_newton_ray(
+    ray: Ray, seed_uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
+    max_updates: u32, distance_tolerance: f32,
+) -> ScreenSpaceRayHit {
+    var uv = seed_uv;
+    var hit = ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 5u);
+    let size = textureDimensions(depth, 0);
+    for (var i = 0u; i < min(max_updates, 16u); i++) {
+        hit.iterations = i + 1u;
+        if (!screen_space_ray_in_bounds(uv)) { hit.status = 1u; return hit; }
+        let coord = vec2<i32>(uv * vec2<f32>(size));
+        let d = textureLoad(depth, coord, 0).r;
+        if (is_background(d)) { hit.status = 2u; return hit; }
+        let center = (vec2<f32>(coord) + 0.5) / vec2<f32>(size);
+        let receiver = inv_project_position(vec3<f32>(center, d), inverse_projection);
+        // .zw is the geometric face normal; .xy includes material normal mapping.
+        let world_normal = decode_g_buffer_normal(textureLoad(normals, coord, 0).zw);
+        let normal = (world_to_view * vec4<f32>(world_normal, 0.0)).xyz;
+        if (!(abs(dot(ray.direction, normal)) > 1e-4)) { hit.status = 3u; return hit; }
+        let plane = plane_from_normal_and_point(normal, receiver);
+        let travel = plane_ray_raycast(ray.origin, ray.direction, plane);
+        if (!(travel > 1e-4 && travel <= ray.tmax)) { hit.status = 4u; return hit; }
+        let next = ray_at(ray.origin, ray.direction, travel);
+        if (!screen_space_ray_projectable(next, projection)) { hit.status = 1u; return hit; }
+        uv = project_position(next, projection).xy;
+        hit = screen_space_ray_validate(ray, uv, depth, normals, projection, inverse_projection, world_to_view, distance_tolerance);
+        hit.iterations = i + 1u;
+        if (hit.status == 0u || hit.status == 1u || hit.status == 2u) { return hit; }
+    }
+    return hit;
+}
+`, [RAY_STRUCT.declaration_chunk, chunk_is_background, chunk_decode_g_buffer_normal,
+    chunk_plane_from_normal_and_point, chunk_plane_ray_raycast, chunk_ray_at,
+    chunk_ray_nearest_point, chunk_inv_project_position, chunk_project_position]);

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js

@@ -6,7 +6,7 @@ import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_aabb_atomic_f32 } from "../../../../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../../../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
 import { LIGHT_DATABASE_SPEC } from "../../../../light/LIGHT_DATABASE_SPEC.js";
 import { MESHES_TABLE } from "../../../../scene/chunk_scene_database_access.js";
 import { CSM_CASTER_RANGE_UNKNOWN } from "../CSM_CASTER_RANGE_STRUCT.js";
@@ -124,13 +124,13 @@ fn main(
 
         // one atomic per subgroup rather than one per row, and none where no row was inside
         if lane_id == 0u && near < RANGE_UNKNOWN {
-            aabb_atomic_min_f32(&ranges[settings.base + c], near);
+            atomic_min_f32_storage(&ranges[settings.base + c], near);
         }
     }
 }
 `, [
     MESHES_TABLE.chunk_iterate(WG),
-    chunk_aabb_atomic_f32,
+    chunk_atomic_min_f32_storage,
 ]);
 
 accumulate_body.addExtension(WebGPUExtensionType.Subgroups);

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

@@ -1,33 +1,66 @@
-/**
- * Draws water surfaces over a lit frame.
- *
- * **Water is a transparent pass on top of opaque**, which is why it lives here rather than in the
- * material system: it is not shaded, it does not write the G-buffer, and it needs the finished
- * depth of everything behind it in order to know how much water the view is looking through.
- *
- * The pass reads scene depth and writes the frame's colour, so it belongs at
- * {@link FramePhase.AfterLighting} — opaque surfaces lit and composited, transparency not yet run.
- */
+/** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
-    /**
-     * Record the water draws into `graph`, over the colour it is given.
-     *
-     * @param {object} args
-     * @param {FrameGraph} args.graph
-     * @param {WaterSurface[]} args.surfaces
-     * @param {number} args.color colour resource handle to draw over
-     * @param {number} args.depth scene depth — **sampled**, which is why it is not also an
-     * attachment, and why the shader does its own depth test
-     * @param {GPUBuffer} args.camera
-     * @returns {number} the colour handle after the draws
-     */
-    graph_draw({ graph, surfaces, color, depth, camera }: {
-        graph: FrameGraph;
-        surfaces: WaterSurface[];
-        color: number;
-        depth: number;
-        camera: GPUBuffer;
-    }): number;
+    surfaces: any[];
+    settings: {
+        enabled: boolean;
+        max_distance: number;
+        distance_tolerance: number;
+        max_updates: number;
+        fallback_steps: number;
+        mode: number;
+        reflections: number;
+        debug_view: number;
+    };
+    avboit_is_empty(): boolean;
+    /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
+    request_probe(uv: any): Promise<any>;
+    dispose(): void;
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture }: {
+        graph: any;
+        view_ctx: any;
+        camera: any;
+        color_texture: any;
+        depth_texture: any;
+        normal_texture: any;
+        hzb_texture: any;
+        environment_texture: any;
+    }): {
+        background_color: any;
+    };
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }: {
+        graph: any;
+        camera: any;
+        cluster_parameters: any;
+        occupancy: any;
+    }): any;
+    avboit_splat({ graph, camera, warp, voxel_resolution, volume }: {
+        graph: any;
+        camera: any;
+        warp: any;
+        voxel_resolution: any;
+        volume: any;
+    }): {
+        extinction: any;
+        overflow: any;
+        dummy: any;
+    };
+    avboit_draw({ graph, view_ctx, camera, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators }: {
+        graph: any;
+        view_ctx: any;
+        camera: any;
+        warp: any;
+        integral: any;
+        volumetrics_lut: any;
+        volumetrics_metadata: any;
+        accumulators: any;
+    }): {
+        color: any;
+        norm: any;
+        extinction: any;
+        emission: any;
+    };
+    /** Debug presentation only: called after shared resolve, never sampled by production optics. */
+    inspect(graph: any, view_ctx: any, output_resolution: any): number;
     #private;
 }
 //# sourceMappingURL=GPUWaterRenderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AACH;IAwBI;;;;;;;;;;;OAWG;IACH;QAR4B,KAAK;QACD,QAAQ,EAA7B,cAAc;QACD,KAAK,EAAlB,MAAM;QACO,KAAK,EAAlB,MAAM;QAEU,MAAM;QACpB,MAAM,CAgBlB;;CA6FJ"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAaA,sFAAsF;AACtF;IACI,gBAAc;IACd;;;;;;;;;MACiF;IAOjF,2BAEC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;MA4GC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}