@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_raycast_positive.js

@@ -2,43 +2,30 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { F32_MAX_DEFINITION } from "../../math/F32_MAX_DEFINITION.js";
 import { RAY_STRUCT } from "../ray/RAY_STRUCT.js";
 import { AABB3_STRUCT } from "./AABB3_STRUCT.js";
+import { chunk_aabb3_raycast } from "./chunk_aabb3_raycast.js";
 
 /**
  * Always produces a non-negative result, useful for when you don't want to check for -1 in result
+ *
+ * {@link chunk_aabb3_raycast} with F32_MAX for the miss instead of -1. The two used to be
+ * line-for-line identical apart from that sentinel — 25 lines of slab arithmetic each, and the
+ * 0 * inf guard in neither. A hit distance is never negative, so the sign of the answer is the miss
+ * test.
+ *
+ * @type {CodeChunk}
  */
 export const chunk_aabb3_raycast_positive = CodeChunk.from(
     //language=WGSL
     `
 fn aabb3_raycast_positive(aabb: ${AABB3_STRUCT.wgsl_ref}, ray:${RAY_STRUCT.wgsl_ref}) -> f32{
-    let p0 = (aabb.min - ray.origin) / ray.direction;
-    let p1 = (aabb.max - ray.origin) / ray.direction;
-    
-    let c_max = max(p0, p1);
-    let c_min = min(p0, p1);
-    
-    let tmax = min(c_max.x, min(c_max.y, c_max.z));
-    let tmin = max(c_min.x, max(c_min.y, c_min.z));
-    
-    // if tmax < 0, ray (line) is intersecting AABB, but whole AABB is behing us
-    // (RAY_STRUCT has no tmin field — tmin is implied to be 0)
-    if (tmax < 0.0) {
-        return F32_MAX;
-    }
+    let t = aabb3_raycast(aabb, ray);
 
-    // if tmin > tmax, ray doesn't intersect AABB
-    if (tmin > tmax || tmin > ray.tmax) {
-        return F32_MAX;
-    }
-
-    if (tmin < 0.0) {
-        return tmax;
-    }
-    
-    return tmin;
+    return select(t, F32_MAX, t < 0.0);
 }
     `, [
         F32_MAX_DEFINITION,
         AABB3_STRUCT.declaration_chunk,
         RAY_STRUCT.declaration_chunk,
+        chunk_aabb3_raycast,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_slab_span.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The distances at which a ray enters and leaves one slab, as `(near, far)`.
+ *
+ * `low` and `high` are the slab's two planes relative to the ray origin, and `inverse_direction` is
+ * the reciprocal of the ray's direction on this axis.
+ *
+ * The reciprocal is infinite when the direction component is exactly zero, and `low` or `high` is
+ * exactly zero when the origin sits exactly on one of the planes. Multiplying those together is
+ * `0 * inf`, which is NaN — and WGSL leaves `min` and `max` **indeterminate** when either operand
+ * is NaN, so the axis then contributes a value the shader cannot predict and the caller's
+ * comparison answers whichever way it fell. Measured on the CPU emulator as an asymmetry: a ray
+ * running along the slab's low plane came back a hit and the same ray along its high plane a miss.
+ *
+ * That arrangement is not exotic. It is what a ray travelling parallel to a flat surface meets, and
+ * bounds fitted exactly to flat geometry put a box face in the plane of that surface — so a bounce
+ * or shadow ray leaving one, and any axis-aligned probe ray, lands on it.
+ *
+ * Handling the parallel case on its own terms keeps the NaN from being formed rather than hoping
+ * `min`/`max` discard it. A ray parallel to a slab never crosses either plane: it is inside the slab
+ * for its whole length or outside it for its whole length, which is what the origin's own position
+ * says. The two returns are the same open and empty intervals the finite path produces, written as
+ * the largest finite float so nothing downstream has to reason about infinities either.
+ *
+ * Every ray/AABB slab test in this directory goes through here. There used to be four copies of the
+ * arithmetic and the guard was in one of them; `aabb3_slab_span.spec` pins the parallel and
+ * on-the-plane cases for all of them.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_slab_span: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aabb3_slab_span.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_slab_span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aabb3_slab_span.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_slab_span.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oCAFU,SAAS,CAqBZ;0BAnDmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_slab_span.js

@@ -0,0 +1,52 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { F32_MAX_DEFINITION } from "../../math/F32_MAX_DEFINITION.js";
+
+/**
+ * The distances at which a ray enters and leaves one slab, as `(near, far)`.
+ *
+ * `low` and `high` are the slab's two planes relative to the ray origin, and `inverse_direction` is
+ * the reciprocal of the ray's direction on this axis.
+ *
+ * The reciprocal is infinite when the direction component is exactly zero, and `low` or `high` is
+ * exactly zero when the origin sits exactly on one of the planes. Multiplying those together is
+ * `0 * inf`, which is NaN — and WGSL leaves `min` and `max` **indeterminate** when either operand
+ * is NaN, so the axis then contributes a value the shader cannot predict and the caller's
+ * comparison answers whichever way it fell. Measured on the CPU emulator as an asymmetry: a ray
+ * running along the slab's low plane came back a hit and the same ray along its high plane a miss.
+ *
+ * That arrangement is not exotic. It is what a ray travelling parallel to a flat surface meets, and
+ * bounds fitted exactly to flat geometry put a box face in the plane of that surface — so a bounce
+ * or shadow ray leaving one, and any axis-aligned probe ray, lands on it.
+ *
+ * Handling the parallel case on its own terms keeps the NaN from being formed rather than hoping
+ * `min`/`max` discard it. A ray parallel to a slab never crosses either plane: it is inside the slab
+ * for its whole length or outside it for its whole length, which is what the origin's own position
+ * says. The two returns are the same open and empty intervals the finite path produces, written as
+ * the largest finite float so nothing downstream has to reason about infinities either.
+ *
+ * Every ray/AABB slab test in this directory goes through here. There used to be four copies of the
+ * arithmetic and the guard was in one of them; `aabb3_slab_span.spec` pins the parallel and
+ * on-the-plane cases for all of them.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_slab_span = CodeChunk.from(
+    //language=WGSL
+    `
+fn aabb3_slab_span(low: f32, high: f32, inverse_direction: f32) -> vec2<f32> {
+    if (abs(inverse_direction) > F32_MAX) {
+        // parallel to this slab — inside it forever, or outside it forever
+        if (low <= 0.0 && high >= 0.0) {
+            return vec2(-F32_MAX, F32_MAX);
+        }
+
+        return vec2(F32_MAX, -F32_MAX);
+    }
+
+    let t0 = low * inverse_direction;
+    let t1 = high * inverse_direction;
+
+    return vec2(min(t0, t1), max(t0, t1));
+}`, [
+        F32_MAX_DEFINITION,
+    ]);

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_view_depth_range.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The view-space depth interval of a world-space axis-aligned box, as `vec2(nearest, farthest)`:
+ * the depth of the box's centre, plus or minus the box's extent along the view axis.
+ *
+ * A support-function projection rather than eight transformed corners: the box is axis-aligned in
+ * world space and only its extent along one axis is wanted. `view_axis` is the view matrix's third
+ * ROW — read as the z of the transformed basis vectors rather than as matrix columns, the same
+ * numbers in the form the WGSL emulator also evaluates.
+ *
+ * The camera looks down −Z, so depth is `-z`. Nothing is clamped: whether a box in front of the near
+ * plane counts is the caller's decision.
+ *
+ * Shared by the AVBOIT occupancy passes that start from a world-space box — the particles' measured
+ * emitter bounds and the dynamic meshes' live-triangle bounds.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_view_depth_range: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aabb3_view_depth_range.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_view_depth_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aabb3_view_depth_range.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_view_depth_range.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAuBZ;0BAzCmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_view_depth_range.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { AABB3_STRUCT } from "./AABB3_STRUCT.js";
+
+/**
+ * The view-space depth interval of a world-space axis-aligned box, as `vec2(nearest, farthest)`:
+ * the depth of the box's centre, plus or minus the box's extent along the view axis.
+ *
+ * A support-function projection rather than eight transformed corners: the box is axis-aligned in
+ * world space and only its extent along one axis is wanted. `view_axis` is the view matrix's third
+ * ROW — read as the z of the transformed basis vectors rather than as matrix columns, the same
+ * numbers in the form the WGSL emulator also evaluates.
+ *
+ * The camera looks down −Z, so depth is `-z`. Nothing is clamped: whether a box in front of the near
+ * plane counts is the caller's decision.
+ *
+ * Shared by the AVBOIT occupancy passes that start from a world-space box — the particles' measured
+ * emitter bounds and the dynamic meshes' live-triangle bounds.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_view_depth_range = CodeChunk.from(
+    //language=WGSL
+    `
+fn aabb3_view_depth_range(box : ${AABB3_STRUCT.wgsl_ref}, view : mat4x4<f32>) -> vec2<f32> {
+    let center = (box.min + box.max) * 0.5;
+    let half_extent = (box.max - box.min) * 0.5;
+
+    let view_axis = vec3<f32>(
+        (view * vec4<f32>(1.0, 0.0, 0.0, 0.0)).z,
+        (view * vec4<f32>(0.0, 1.0, 0.0, 0.0)).z,
+        (view * vec4<f32>(0.0, 0.0, 1.0, 0.0)).z,
+    );
+
+    // camera looks down -Z, so depth is -z
+    let depth = -(view * vec4<f32>(center, 1.0)).z;
+    let extent = dot(abs(view_axis), half_extent);
+
+    return vec2<f32>(depth - extent, depth + extent);
+}
+`, [
+        AABB3_STRUCT.declaration_chunk,
+    ]);

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_octahedral_uv_wrap.d.ts

@@ -1,5 +1,14 @@
 /**
- * Note: ported from meep. Tested extensively for correctness.
+ * Octahedral UV wrapping, with full winding support — the twin of
+ * `core/geom/3d/octahedra/octahedral_uv_wrap`.
+ *
+ * The port used to drop that function's opening step, the even-winding reduction, and keep only
+ * the four reflections. That makes it a ONE-reflection wrap: (2.5, 0.5) came out as (-0.5, 0.5)
+ * where the CPU gives (0.5, 0.5), because u lands back in range after a single reflection and
+ * nothing corrects it — a negative UV, outside the tile, which then samples the wrong face or
+ * clamps. Symmetrically (-1.5, 0.5) gave (1.5, 0.5). Its doc claimed the opposite, and the spec
+ * beside it only ever fed values in [-0.4, 1.4].
+ *
  * @type {CodeChunk}
  */
 export const chunk_octahedral_uv_wrap: CodeChunk;

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_octahedral_uv_wrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_octahedral_uv_wrap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/octahedron/chunk_octahedral_uv_wrap.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,uCAFU,SAAS,CAkClB;0BAtCyB,gCAAgC"}
+{"version":3,"file":"chunk_octahedral_uv_wrap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/octahedron/chunk_octahedral_uv_wrap.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,uCAFU,SAAS,CAwClB;0BArDyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_octahedral_uv_wrap.js

@@ -1,15 +1,30 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 
 /**
- * Note: ported from meep. Tested extensively for correctness.
+ * Octahedral UV wrapping, with full winding support — the twin of
+ * `core/geom/3d/octahedra/octahedral_uv_wrap`.
+ *
+ * The port used to drop that function's opening step, the even-winding reduction, and keep only
+ * the four reflections. That makes it a ONE-reflection wrap: (2.5, 0.5) came out as (-0.5, 0.5)
+ * where the CPU gives (0.5, 0.5), because u lands back in range after a single reflection and
+ * nothing corrects it — a negative UV, outside the tile, which then samples the wrong face or
+ * clamps. Symmetrically (-1.5, 0.5) gave (1.5, 0.5). Its doc claimed the opposite, and the spec
+ * beside it only ever fed values in [-0.4, 1.4].
+ *
  * @type {CodeChunk}
  */
 export const chunk_octahedral_uv_wrap = CodeChunk.from(
     //language=WGSL
     `
+/** Remove even windings, collapsing an arbitrary coordinate into [-1, 1]. */
+fn octahedral_reduce_even_wrap(x: f32) -> f32 {
+    return x - 2.0 * floor((x + 1.0) * 0.5);
+}
+
 fn octahedral_uv_wrap(in_uv: vec2<f32>) -> vec2<f32>{
-    var u = in_uv.x;
-    var v = in_uv.y;
+    // first collapse infinite windings, then reflect — the reflections alone handle one turn
+    var u = octahedral_reduce_even_wrap(in_uv.x);
+    var v = octahedral_reduce_even_wrap(in_uv.y);
 
     // Left side (u < 0)
     if (u < 0.0) {

package/src/shade/renderer/shader/chunk/geometry/quaternion/chunk_quat_encode_u32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_quat_encode_u32.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/quaternion/chunk_quat_encode_u32.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oCAFU,SAAS,CA2ElB;0BAlFyB,gCAAgC"}
+{"version":3,"file":"chunk_quat_encode_u32.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/quaternion/chunk_quat_encode_u32.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oCAFU,SAAS,CA+ElB;0BAtFyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/quaternion/chunk_quat_encode_u32.js

@@ -62,13 +62,17 @@ fn quat_encode_u32(base: vec4<f32>) -> u32{
         v2 = -v2;
     }
 
-    const l = length(vec4(v0, v1, v2, dropped));
+    // These are let and not const: every one of them reads a runtime value, and WGSL requires a
+    // const-declaration to be initialized from a const-expression. Declared const, the chunk was
+    // rejected at createShaderModule — the emulator does not model const-ness, so nothing written
+    // against it could have seen that.
+    let l = length(vec4(v0, v1, v2, dropped));
     let m = 511.0 / (l * SQRT1_2);
 
     // re-normalize the remaining components to 10 bit UINT value
-    const oV0 = u32(round(v0 * m + 511.0));
-    const oV1 = u32(round(v1 * m + 511.0));
-    const oV2 = u32(round(v2 * m + 511.0));
+    let oV0 = u32(round(v0 * m + 511.0));
+    let oV1 = u32(round(v1 * m + 511.0));
+    let oV2 = u32(round(v2 * m + 511.0));
 
     return (max & 0x3)
         | ((oV0 & 0x3FF) << 2)

package/src/shade/renderer/shader/chunk/grid/chunk_folded_workgroup_index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The flat index of a workgroup in a **folded** dispatch — one whose count was spread over x, then
+ * y, then z by {@link build_indirect_compute_dispatch_command} with `fold`, or by
+ * {@link shader_prefix_sum_to_command}.
+ *
+ * Both fill x to {@link WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION} before y grows past
+ * 1, and y to it before z does. So wherever a row or slice exists, the ones below it are full and
+ * the grid flattens with that constant as its stride — the same arithmetic as
+ * {@link chunk_grid3d_to_index} over the real extents, without asking the dispatch for them.
+ *
+ * Which is the point: `@builtin(num_workgroups)` in an indirectly dispatched shader costs ~15 µs on
+ * D3D12 whatever the grid, including an empty one. Dawn implements it there by duplicating the
+ * indirect arguments and dispatching through a command signature that sets root constants, where a
+ * plain indirect dispatch costs ~3 µs (measured 2026-09-25, RTX 4090, Chrome 154). The
+ * measurements and the reading of Dawn's source are in `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
+ * Only correct for a grid folded that way. A grid laid out any other way — x short of the constant
+ * while y is past 1 — is read with gaps; {@link chunk_grid3d_to_index} is the flattening for those.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_folded_workgroup_index: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_folded_workgroup_index.d.ts.map

package/src/shade/renderer/shader/chunk/grid/chunk_folded_workgroup_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_folded_workgroup_index.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_folded_workgroup_index.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CAFU,SAAS,CAWlB;0BAhCyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/grid/chunk_folded_workgroup_index.js

@@ -0,0 +1,36 @@
+import {
+    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
+} from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * The flat index of a workgroup in a **folded** dispatch — one whose count was spread over x, then
+ * y, then z by {@link build_indirect_compute_dispatch_command} with `fold`, or by
+ * {@link shader_prefix_sum_to_command}.
+ *
+ * Both fill x to {@link WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION} before y grows past
+ * 1, and y to it before z does. So wherever a row or slice exists, the ones below it are full and
+ * the grid flattens with that constant as its stride — the same arithmetic as
+ * {@link chunk_grid3d_to_index} over the real extents, without asking the dispatch for them.
+ *
+ * Which is the point: `@builtin(num_workgroups)` in an indirectly dispatched shader costs ~15 µs on
+ * D3D12 whatever the grid, including an empty one. Dawn implements it there by duplicating the
+ * indirect arguments and dispatching through a command signature that sets root constants, where a
+ * plain indirect dispatch costs ~3 µs (measured 2026-09-25, RTX 4090, Chrome 154). The
+ * measurements and the reading of Dawn's source are in `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
+ * Only correct for a grid folded that way. A grid laid out any other way — x short of the constant
+ * while y is past 1 — is read with gaps; {@link chunk_grid3d_to_index} is the flattening for those.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_folded_workgroup_index = CodeChunk.from(
+    //language=WGSL
+    `
+fn folded_workgroup_index( workgroup_id: vec3<u32> ) -> u32 {
+    const WIDTH = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
+
+    return workgroup_id.x + ( workgroup_id.y + workgroup_id.z * WIDTH ) * WIDTH;
+}
+    `
+)

package/src/shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.d.ts

@@ -1,6 +1,12 @@
 /**
  * Given a 3d coordinate, flatten it into a 1d index
  * see {@link chunk_index_to_grid3d} for reverse
+ *
+ * Flattening a dispatch's own workgroup grid: in a shader that is dispatched indirectly, do not
+ * feed this `@builtin(num_workgroups)`, which costs ~15 µs a dispatch on D3D12. A folded command
+ * flattens with {@link chunk_folded_workgroup_index} instead; see
+ * `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_grid3d_to_index: CodeChunk;

package/src/shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_grid3d_to_index.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,oCAFU,SAAS,CASlB;0BAdyB,6BAA6B"}
+{"version":3,"file":"chunk_grid3d_to_index.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,oCAFU,SAAS,CASlB;0BApByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.js

@@ -3,6 +3,12 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 /**
  * Given a 3d coordinate, flatten it into a 1d index
  * see {@link chunk_index_to_grid3d} for reverse
+ *
+ * Flattening a dispatch's own workgroup grid: in a shader that is dispatched indirectly, do not
+ * feed this `@builtin(num_workgroups)`, which costs ~15 µs a dispatch on D3D12. A folded command
+ * flattens with {@link chunk_folded_workgroup_index} instead; see
+ * `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_grid3d_to_index = CodeChunk.from(

package/src/shade/renderer/shader/chunk/light/INCIDENT_LIGHT_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"INCIDENT_LIGHT_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/light/INCIDENT_LIGHT_STRUCT.js"],"names":[],"mappings":"AAGA,iDAqB2B;6BAvBE,4BAA4B"}
+{"version":3,"file":"INCIDENT_LIGHT_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/light/INCIDENT_LIGHT_STRUCT.js"],"names":[],"mappings":"AAGA,iDA0B2B;6BA5BE,4BAA4B"}

package/src/shade/renderer/shader/chunk/light/INCIDENT_LIGHT_STRUCT.js

@@ -19,7 +19,12 @@ export const INCIDENT_LIGHT_STRUCT = WebGPUStruct.from({
     radius: f32,
 
     /**
-     * Distance to source
+     * Distance to the SURFACE of the emitter — the centre distance less the emitter radius,
+     * floored at zero. Both resolvers write it that way: it is what a shadow ray wants for its
+     * tmax, which is what every consumer uses it for, and a ray run to the centre would test the
+     * last `radius` metres of empty sphere interior for occluders.
+     *
+     * Not to be confused with {@link radius}, which is a solid angle and IS measured to the centre.
      */
     distance: f32,
 }, "IncidentLight").pack();

package/src/shade/renderer/shader/chunk/light/io/chunk_get_spot_light_info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_get_spot_light_info.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/io/chunk_get_spot_light_info.js"],"names":[],"mappings":"AAMA,kDA6CC;0BAnDyB,gCAAgC"}
+{"version":3,"file":"chunk_get_spot_light_info.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/io/chunk_get_spot_light_info.js"],"names":[],"mappings":"AAMA,kDAkDC;0BAxDyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/io/chunk_get_spot_light_info.js

@@ -20,7 +20,12 @@ fn get_spot_light_info(
 
     let distance_to_center = length( lVector );
 
-    result.distance = distance_to_center;
+    // the SURFACE of the emitter, matching get_point_light_info. The two are siblings that fill the
+    // same field of the same struct and are dispatched between by restir_get_light_info, and this
+    // one used to hand back the centre distance — so a shadow ray taking its tmax from here ran the
+    // emitter radius further for a spot light than for a point light, and that radius is what
+    // artists raise for softer shadows.
+    result.distance = max(0.0, distance_to_center - light.radius);
     result.radius = light.radius / distance_to_center;
 
     let angleCos = dot( result.direction, -light.direction );

package/src/shade/renderer/shader/chunk/material/chunk_albedo_unpremultiply.d.ts

@@ -0,0 +1,24 @@
+/**
+ * How an albedo texture's colour is read back out of it.
+ *
+ * Albedo textures are uploaded with alpha PREMULTIPLIED — `tiny-gltf` decodes them with
+ * `premultiplyAlpha: "none"` precisely because the upload does it — so a texel of `rgb=(0.3,0.5,0.2)`
+ * at `a=0.5` is stored as `(0.15,0.25,0.1)` and every consumer has to divide the coverage back out
+ * before shading with it. A consumer that does not is dark by exactly its alpha, and if it also
+ * treats that alpha as coverage it counts the same number twice.
+ *
+ * This exists as one function rather than as the same expression written twice because the two
+ * renderers disagreed about it: the deferred G-buffer divided, the path tracer did not, and the path
+ * tracer is the reference the raster path is compared against — so every alpha-masked or transparent
+ * material diverged between them by exactly its alpha, which is the place the comparison matters
+ * most.
+ *
+ * The guard is not decoration. A fully transparent texel is `rgb=0, a=0`, and a bilinear resample of
+ * the neighbourhood around one can land on an alpha that the visibility pass's alpha test disagrees
+ * with, so an unguarded divide puts a NaN into the albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_unpremultiply: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_albedo_unpremultiply.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_albedo_unpremultiply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_albedo_unpremultiply.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_albedo_unpremultiply.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yCAFU,SAAS,CASjB;0BA9BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_unpremultiply.js

@@ -0,0 +1,31 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * How an albedo texture's colour is read back out of it.
+ *
+ * Albedo textures are uploaded with alpha PREMULTIPLIED — `tiny-gltf` decodes them with
+ * `premultiplyAlpha: "none"` precisely because the upload does it — so a texel of `rgb=(0.3,0.5,0.2)`
+ * at `a=0.5` is stored as `(0.15,0.25,0.1)` and every consumer has to divide the coverage back out
+ * before shading with it. A consumer that does not is dark by exactly its alpha, and if it also
+ * treats that alpha as coverage it counts the same number twice.
+ *
+ * This exists as one function rather than as the same expression written twice because the two
+ * renderers disagreed about it: the deferred G-buffer divided, the path tracer did not, and the path
+ * tracer is the reference the raster path is compared against — so every alpha-masked or transparent
+ * material diverged between them by exactly its alpha, which is the place the comparison matters
+ * most.
+ *
+ * The guard is not decoration. A fully transparent texel is `rgb=0, a=0`, and a bilinear resample of
+ * the neighbourhood around one can land on an alpha that the visibility pass's alpha test disagrees
+ * with, so an unguarded divide puts a NaN into the albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_unpremultiply = CodeChunk.from(
+    //language=WGSL
+    `
+fn albedo_unpremultiply(diffuse_sample: vec4<f32>) -> vec3<f32> {
+    return diffuse_sample.rgb / max(diffuse_sample.a, 1e-4);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg2d.js

@@ -13,12 +13,12 @@ fn pcg2d(v:vec2<u32>) -> vec2<u32>{
     result.x += result.y * 1664525u;
     result.y += result.x * 1664525u;
 
-    result = result ^ (result >> 16u);
+    result = result ^ (result >> vec2(16u));
 
     result.x += result.y * 1664525u;
     result.y += result.x * 1664525u;
 
-    result = result ^ (result >> 16u);
+    result = result ^ (result >> vec2(16u));
 
     return result;
 }

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg3d16.js

@@ -19,7 +19,7 @@ fn pcg3d16(v:vec3<u32>) -> vec3<u32>{
     result.y += result.z * result.x;
     result.z += result.x * result.y;
 
-    result = result >> 16u;
+    result = result >> vec3(16u);
 
     return result;
 }

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg4d.js

@@ -15,7 +15,7 @@ fn pcg4d(v:vec4<u32>) -> vec4<u32>{
     result.z += result.x * result.y;
     result.w += result.y * result.z;
     
-    result = result ^ (result >> 16u);
+    result = result ^ (result >> vec4(16u));
     
     result.x += result.y * result.w;
     result.y += result.z * result.x;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_validate_hit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,gDAFU,SAAS,CAgBhB;AAEH,oEAoBC;AAGD;;;;;GAKG;AACH,gDAFU,SAAS,CAyDlB;AAED;;;;GAIG;AACH,0CAFU,SAAS,CAwBjB;0BA3IwB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_validate_hit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,gDAFU,SAAS,CAmBhB;AAEH,oEAoBC;AAGD;;;;;GAKG;AACH,gDAFU,SAAS,CAyDlB;AAED;;;;GAIG;AACH,0CAFU,SAAS,CAyBjB;0BA/IwB,6BAA6B"}

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

@@ -14,10 +14,13 @@ export const chunk_ffx_effect_compute_vignette = CodeChunk.from(
     `
 fn ffx_effect_compute_vignette(
     uv:vec2<f32>,
-    screen_size: vec2<f32>
+    screen_size: vec2<f32>,
+    edge_fade: f32
 ) -> f32{
     // Fade out hits near the screen borders
-    let fov      = 0.05 * vec2(screen_size.y / screen_size.x, 1.0);
+    // The fade width was hard-coded here as 0.05 while the effect declared a setting of that name
+    // and wrote 0.07 into the uniform every frame, read by nothing — the knob moved no picture.
+    let fov      = edge_fade * vec2(screen_size.y / screen_size.x, 1.0);
     let border   = smoothstep(vec2(0.0, 0.0), fov, uv) * (1.0 - smoothstep(vec2(1.0, 1.0) - fov, vec2(1.0, 1.0), uv));
     let vignette = border.x * border.y;
     
@@ -124,13 +127,14 @@ fn ffx_sssr_validate_hit(
     uv: vec2<f32>,
     view_space_ray_direction: vec3<f32>,
     screen_size: vec2<f32>,
-    depth_buffer_thickness: f32
+    depth_buffer_thickness: f32,
+    edge_fade: f32
 ) -> f32{
     var confidence = ffx_validate_screen_ray_hit(hit, uv, view_space_ray_direction, screen_size, depth_buffer_thickness);
     
     // Fade out reflections whose *sampled radiance* sits near the unreliable screen border —
     // the reference computes this from the hit position, not the receiver pixel
-    let vignette = ffx_effect_compute_vignette(hit.xy, screen_size);
+    let vignette = ffx_effect_compute_vignette(hit.xy, screen_size, edge_fade);
     
     return vignette * confidence;
 }

package/src/shade/renderer/shader/chunk/sdf/chunk_mesh_sdf_soft_shadow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_mesh_sdf_soft_shadow.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_mesh_sdf_soft_shadow.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,mDAgCO;0BAxCmB,6BAA6B"}
+{"version":3,"file":"chunk_mesh_sdf_soft_shadow.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_mesh_sdf_soft_shadow.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,mDA8CO;0BAtDmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_mesh_sdf_soft_shadow.js

@@ -24,16 +24,30 @@ fn mesh_sdf_soft_shadow(mesh_id: u32, ray:${RAY_STRUCT.wgsl_ref}, w:f32) -> f32{
         
         let distance = mesh_sdf_query_distance(mesh_id,position);
         
+        if( distance < 0.0001 ) {
+            // The ray reached the surface. This used to break with res still holding whatever the
+            // PREVIOUS step left there — and on a hit at the first step, its initialiser, meaning
+            // fully lit. A shading point sitting on the caster is the ordinary contact shadow, so
+            // the shadow was brightest exactly where it should have been blackest.
+            return 0.0;
+        }
+        
+        // the TIGHTEST the ray ever gets, which is what a penumbra term is. Assigning here instead
+        // gave the ratio at the LAST step — for a ray that escapes, the point furthest from any
+        // geometry, so the brightest value the march produced, squared and returned unclamped: the
+        // shadow term multiplied the light up rather than down.
+        res = min(res, distance / w);
+        
         t += abs(distance);
         
-        if( distance< 0.0001 || t>ray.tmax ) {
+        if( t > ray.tmax ) {
             break;
         }
         
-        res = (distance / w);
-        
     }
     
+    res = saturate(res);
+    
     return res*res;
 
 }

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.d.ts

@@ -1,5 +1,9 @@
 /**
  * Simplified way of running compute shaders
+ *
+ * The shader should not read `@builtin(num_workgroups)`: dispatched indirectly, that costs ~15 µs a
+ * dispatch on D3D12. See `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {ComputeShader} options.shader