@woosh/meep-engine 3.61.0 → 3.61.2

package/src/shade/renderer/restir/reservoir/chunk_rtxdi_stream_sample.js

@@ -36,7 +36,7 @@ fn rtxdi_stream_sample(
     if (selectSample) 
     {
         reservoir.lightData = lightIndex | RTXDI_Reservoir_LightValidBit;
-        reservoir.uvData = u32(saturate(uv.x) * 0xffff) | (u32(saturate(uv.y) * 0xffff) << 16);
+        reservoir.uvData = pack2x16unorm(uv);
         reservoir.targetPdf = targetPdf;
     }
 

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.d.ts

@@ -1,4 +1,18 @@
 /**
+ * Decodes a packed RGBE 9-9-9-5 (`u32`) word into linear RGB (`vec3<f32>`).
+ *
+ * Bit layout:
+ * - `[0..8]`: 9-bit R mantissa
+ * - `[9..17]`: 9-bit G mantissa
+ * - `[18..26]`: 9-bit B mantissa
+ * - `[27..31]`: 5-bit biased exponent E (bias = 15, mantissa bits = 9)
+ *
+ * Rather than evaluating a transcendental `exp2(E - 24.0)` on the SFU, `2^(E - 24)` is
+ * constructed directly in IEEE-754 binary32 bits: shifting E from `[27..31]` down to the
+ * float exponent field `[23..27]` and adding the combined exponent bias `(127 - 24) << 23 = 0x33800000u`.
+ * Because `E` is in `[0, 31]`, the biased IEEE-754 exponent `E + 103` is in `[103, 134]`,
+ * which is always a normal positive float.
+ *
  * @see https://en.wikipedia.org/wiki/RGBE_image_format
  * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/environment/hddagi_direct_light.glsl#L331
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_rgbe9995_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,oCAFU,SAAS,CAejB;0BApBwB,gCAAgC"}
+{"version":3,"file":"chunk_rgbe9995_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCAFU,SAAS,CAgBjB;0BAnCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js

@@ -1,21 +1,36 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-
-/**
- * @see https://en.wikipedia.org/wiki/RGBE_image_format
- * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/environment/hddagi_direct_light.glsl#L331
- * @type {CodeChunk}
- */
-export const chunk_rgbe9995_decode = CodeChunk.from(
-    //language=WGSL
-    `
-fn rgbe9995_decode(p_rgbe:u32) -> vec3<f32>{
-    // shift and mask
-    let rgbef = vec4<f32>(
-        (vec4(p_rgbe) >> vec4<u32>(0, 9, 18, 27)) 
-        & vec4<u32>(0x1FF, 0x1FF, 0x1FF, 0x1F)
-    );
-    
-    return rgbef.rgb * exp2(rgbef.a - 15.0 - 9.0);
-}
-    `
-);
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Decodes a packed RGBE 9-9-9-5 (`u32`) word into linear RGB (`vec3<f32>`).
+ *
+ * Bit layout:
+ * - `[0..8]`: 9-bit R mantissa
+ * - `[9..17]`: 9-bit G mantissa
+ * - `[18..26]`: 9-bit B mantissa
+ * - `[27..31]`: 5-bit biased exponent E (bias = 15, mantissa bits = 9)
+ *
+ * Rather than evaluating a transcendental `exp2(E - 24.0)` on the SFU, `2^(E - 24)` is
+ * constructed directly in IEEE-754 binary32 bits: shifting E from `[27..31]` down to the
+ * float exponent field `[23..27]` and adding the combined exponent bias `(127 - 24) << 23 = 0x33800000u`.
+ * Because `E` is in `[0, 31]`, the biased IEEE-754 exponent `E + 103` is in `[103, 134]`,
+ * which is always a normal positive float.
+ *
+ * @see https://en.wikipedia.org/wiki/RGBE_image_format
+ * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/environment/hddagi_direct_light.glsl#L331
+ * @type {CodeChunk}
+ */
+export const chunk_rgbe9995_decode = CodeChunk.from(
+    //language=WGSL
+    `
+fn rgbe9995_decode(p_rgbe: u32) -> vec3<f32> {
+    let rgb = vec3<f32>(
+        (vec3<u32>(p_rgbe) >> vec3<u32>(0u, 9u, 18u))
+        & vec3<u32>(0x1FFu)
+    );
+    let exp_bits = ((p_rgbe >> 4u) & 0x0F800000u) + 0x33800000u;
+    let scale = bitcast<f32>(exp_bits);
+
+    return rgb * scale;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_sample_gather.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Software-bilinear sample of an RGBE 9-9-9-5 (`r32uint`) 2D texture using a single `textureGather`.
+ *
+ * WebGPU's `rgb9e5ufloat` format is hardware-filterable, but cannot be written as a storage texture
+ * (`STORAGE_BINDING`) or render attachment, nor view-aliased with `r32uint`. When an HDR texture is
+ * produced on the GPU via `textureStore` into `r32uint`, this function performs a 4-texel bilinear
+ * tap using one `textureGather`:
+ *
+ * 1. Snaps the gather UV to `(floor(uv * tex_size - 0.5) + 1.0) * inv_tex_size` (dead-center
+ *    between the 4 texels) so the TMU's 16.8 fixed-point floor never disagrees with the ALU's
+ *    `f32` fractional weights near half-texel boundaries.
+ * 2. Constructs the four `2^(E - 24)` scale factors directly in IEEE-754 float bits via shift,
+ *    mask, bias addition (`103 << 23 = 0x33800000u`), and `bitcast<vec4<f32>>`, avoiding 4 SFU
+ *    `exp2` instructions.
+ * 3. Folds the 4 shared-exponent scales into the 4 bilinear weights (`w = bilinear * scale`) and
+ *    evaluates each RGB channel as a single `dot(mantissa, w)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_rgbe9995_sample_gather: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_rgbe9995_sample_gather.d.ts.map

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_sample_gather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_rgbe9995_sample_gather.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_sample_gather.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CAFU,SAAS,CA4CjB;0BA/DwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_sample_gather.js

@@ -0,0 +1,64 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Software-bilinear sample of an RGBE 9-9-9-5 (`r32uint`) 2D texture using a single `textureGather`.
+ *
+ * WebGPU's `rgb9e5ufloat` format is hardware-filterable, but cannot be written as a storage texture
+ * (`STORAGE_BINDING`) or render attachment, nor view-aliased with `r32uint`. When an HDR texture is
+ * produced on the GPU via `textureStore` into `r32uint`, this function performs a 4-texel bilinear
+ * tap using one `textureGather`:
+ *
+ * 1. Snaps the gather UV to `(floor(uv * tex_size - 0.5) + 1.0) * inv_tex_size` (dead-center
+ *    between the 4 texels) so the TMU's 16.8 fixed-point floor never disagrees with the ALU's
+ *    `f32` fractional weights near half-texel boundaries.
+ * 2. Constructs the four `2^(E - 24)` scale factors directly in IEEE-754 float bits via shift,
+ *    mask, bias addition (`103 << 23 = 0x33800000u`), and `bitcast<vec4<f32>>`, avoiding 4 SFU
+ *    `exp2` instructions.
+ * 3. Folds the 4 shared-exponent scales into the 4 bilinear weights (`w = bilinear * scale`) and
+ *    evaluates each RGB channel as a single `dot(mantissa, w)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_rgbe9995_sample_gather = CodeChunk.from(
+    //language=WGSL
+    `
+fn rgbe9995_sample_gather(
+    tex: texture_2d<u32>,
+    samp: sampler,
+    uv: vec2<f32>,
+    tex_size: vec2<f32>,
+    inv_tex_size: vec2<f32>
+) -> vec3<f32> {
+    // 1. Align UV to prevent 16.8 fixed-point TMU vs f32 ALU boundary mismatch
+    let coord = uv * tex_size - 0.5;
+    let base = floor(coord);
+    let f = coord - base;
+    let gather_uv = (base + 1.0) * inv_tex_size;
+
+    // WebGPU textureGather component order:
+    // .x = (u0, v1) [bottom-left], .y = (u1, v1) [bottom-right]
+    // .z = (u1, v0) [top-right],    .w = (u0, v0) [top-left]
+    let raw: vec4<u32> = textureGather(0, tex, samp, gather_uv);
+
+    // 2. Construct 2^(E - 24) directly in IEEE-754 float bits:
+    // Shift E from [27..31] to [23..27] and add bias (103 << 23 = 0x33800000u)
+    let exp_bits = ((raw >> vec4<u32>(4u)) & vec4<u32>(0x0F800000u)) + vec4<u32>(0x33800000u);
+    let scale = bitcast<vec4<f32>>(exp_bits);
+
+    // 3. Fold bilinear weights and shared-exponent scales into a single vec4 weight
+    let w = vec4<f32>(
+        (1.0 - f.x) * f.y,       // .x: (u0, v1)
+        f.x * f.y,               // .y: (u1, v1)
+        f.x * (1.0 - f.y),       // .z: (u1, v0)
+        (1.0 - f.x) * (1.0 - f.y)// .w: (u0, v0)
+    ) * scale;
+
+    // 4. Extract 9-bit mantissas and dot with combined weights
+    let r = vec4<f32>(raw & vec4<u32>(0x1FFu));
+    let g = vec4<f32>((raw >> vec4<u32>(9u)) & vec4<u32>(0x1FFu));
+    let b = vec4<f32>((raw >> vec4<u32>(18u)) & vec4<u32>(0x1FFu));
+
+    return vec3<f32>(dot(r, w), dot(g, w), dot(b, w));
+}
+    `
+);

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts

@@ -6,16 +6,27 @@
  *
  * ```wgsl
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
- * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> MultiscaleMean
+ * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
+ * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
  * ```
  *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
+ * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's
+ *   `View.PreExposure`. The reference's two absolute constants, its variance floor of 1e-5 and its firefly offset
+ *   of 0.1, are in exposed units, as Unreal states its world caches' thresholds (`MaxRayIntensity ·
+ *   OneOverPreExposure`): over a stream scaled by 1/E at an exposure of E the estimator does what it does over
+ *   the stream at an exposure of one, so it tells a change from noise as far as the display shows it. Held to the
+ *   positive normal f32 range, where neither constant overflows or vanishes.
+ * - **Deviation floor**: the least deviation the estimator divides by, √1e-5 / exposure, and never under one
+ *   half-float step of the short mean, `max(|short_mean|·2⁻¹⁰, 2⁻²⁴)`: the state is stored in halves, so a
+ *   smaller gap between the means is their rounding, and the floor stays above zero at any exposure. Taken as
+ *   `max(floor, √variance)`, the reference's `√max(floor², variance)` without squaring the floor.
  * - **Seed**: both means at the first sample, nothing of variance, no blend reduction, an inconsistency of one,
  *   as WickedEngine's surfels seed it.
- * - **Clip**: a sample past `0.1 + short_mean + 8·deviation` a channel is held there, a firefly. The 0.1 is
- *   the reference's, in the radiance's own units. A caller whose variance does not yet rest on a window of
- *   samples passes `clip` false: there is no spread to clip to.
+ * - **Clip**: a sample past `0.1 / exposure + short_mean + 8·deviation` a channel is held there, a firefly. A
+ *   caller whose variance does not yet rest on a window of samples passes `clip` false: there is no spread to clip
+ *   to.
  * - **Short mean**: blended by `short_blend`; the variance by `variance_blend`, the reference's half of it, so
  *   that its window outlasts the short mean's.
  * - **Long mean**: blended by the catch-up, `smoothstep(relative · max(0.02, inconsistency − 0.2))` held to

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,oCAFU,SAAS,CA4CZ;0BAtFmB,6BAA6B"}
+{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,oCAFU,SAAS,CAuDZ;0BAhHmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js

@@ -2,6 +2,10 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_rgb_to_luminance } from "../color/chunk_rgb_to_luminance.js";
 import { MULTISCALE_MEAN_STRUCT } from "./MULTISCALE_MEAN_STRUCT.js";
 
+/** 2⁻¹²⁶ and 2¹²⁷, the positive normal f32 range's ends */
+const EXPOSURE_MIN = '1.17549435e-38';
+const EXPOSURE_MAX = '1.70141183e38';
+
 /**
  * The multi-scale mean estimator (MSME) of a stream of RGB samples: a long mean that blends slowly while the
  * stream is steady and noisy, and catches up with a short mean once the two disagree by more than the stream's
@@ -10,16 +14,27 @@ import { MULTISCALE_MEAN_STRUCT } from "./MULTISCALE_MEAN_STRUCT.js";
  *
  * ```wgsl
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
- * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> MultiscaleMean
+ * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
+ * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
  * ```
  *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
+ * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's
+ *   `View.PreExposure`. The reference's two absolute constants, its variance floor of 1e-5 and its firefly offset
+ *   of 0.1, are in exposed units, as Unreal states its world caches' thresholds (`MaxRayIntensity ·
+ *   OneOverPreExposure`): over a stream scaled by 1/E at an exposure of E the estimator does what it does over
+ *   the stream at an exposure of one, so it tells a change from noise as far as the display shows it. Held to the
+ *   positive normal f32 range, where neither constant overflows or vanishes.
+ * - **Deviation floor**: the least deviation the estimator divides by, √1e-5 / exposure, and never under one
+ *   half-float step of the short mean, `max(|short_mean|·2⁻¹⁰, 2⁻²⁴)`: the state is stored in halves, so a
+ *   smaller gap between the means is their rounding, and the floor stays above zero at any exposure. Taken as
+ *   `max(floor, √variance)`, the reference's `√max(floor², variance)` without squaring the floor.
  * - **Seed**: both means at the first sample, nothing of variance, no blend reduction, an inconsistency of one,
  *   as WickedEngine's surfels seed it.
- * - **Clip**: a sample past `0.1 + short_mean + 8·deviation` a channel is held there, a firefly. The 0.1 is
- *   the reference's, in the radiance's own units. A caller whose variance does not yet rest on a window of
- *   samples passes `clip` false: there is no spread to clip to.
+ * - **Clip**: a sample past `0.1 / exposure + short_mean + 8·deviation` a channel is held there, a firefly. A
+ *   caller whose variance does not yet rest on a window of samples passes `clip` false: there is no spread to clip
+ *   to.
  * - **Short mean**: blended by `short_blend`; the variance by `variance_blend`, the reference's half of it, so
  *   that its window outlasts the short mean's.
  * - **Long mean**: blended by the catch-up, `smoothstep(relative · max(0.02, inconsistency − 0.2))` held to
@@ -55,17 +70,28 @@ fn multiscale_mean_seed(sample: vec3f) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
     })};
 }
 
-fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
+// the exposure, held to the positive normal f32 range
+fn multiscale_mean_exposure(exposure: f32) -> f32 {
+    return clamp(exposure, ${EXPOSURE_MIN}, ${EXPOSURE_MAX});
+}
+
+fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f {
+    return max(vec3f(sqrt(1e-5) / multiscale_mean_exposure(exposure)), max(abs(short_mean) * exp2(-10.0), vec3f(exp2(-24.0))));
+}
+
+fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
     var y = sample;
 
     if (clip) {
-        y = min(y, 0.1 + e.short_mean + 8.0 * sqrt(max(vec3f(1e-5), e.variance)));
+        let spread = max(multiscale_mean_deviation_floor(e.short_mean, exposure), sqrt(max(vec3f(0.0), e.variance)));
+
+        y = min(y, 0.1 / multiscale_mean_exposure(exposure) + e.short_mean + 8.0 * spread);
     }
 
     let delta = y - e.short_mean;
     let short_mean = mix(e.short_mean, y, short_blend);
     let variance = mix(e.variance, delta * (y - short_mean), variance_blend);
-    let deviation = sqrt(max(vec3f(1e-5), variance));
+    let deviation = max(multiscale_mean_deviation_floor(short_mean, exposure), sqrt(max(vec3f(0.0), variance)));
 
     let relative = rgb_to_luminance(abs(e.mean - short_mean) / deviation);
     let inconsistency = mix(e.inconsistency, relative, short_blend);

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_decode_vertex_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_decode_vertex_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_decode_vertex_normal.js"],"names":[],"mappings":"AAGA,mDAcE;0BAjBwB,gCAAgC"}
+{"version":3,"file":"chunk_decode_vertex_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_decode_vertex_normal.js"],"names":[],"mappings":"AAGA,mDASE;0BAZwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_decode_vertex_normal.js

@@ -1,18 +1,13 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_uv_octahedral_unit_decode } from "../octahedron/chunk_uv_octahedral_unit_decode.js";
-
-export const chunk_decode_vertex_normal = CodeChunk.from(
-    //language=WGSL
-    `
-fn decode_vertex_normal(base: u32) -> vec3<f32>{
-    
-    let decode = (vec2(base) >> vec2(0u, 16u)) & vec2(0xFFFFu, 0xFFFFu);
-    
-    let norm = vec2<f32>(decode) / vec2(65535.0, 65535.0);
-    
-    return uv_octahedral_unit_decode(norm);
-}    
-    `, [
-        chunk_uv_octahedral_unit_decode,
-    ]
-);
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_decode } from "../octahedron/chunk_uv_octahedral_unit_decode.js";
+
+export const chunk_decode_vertex_normal = CodeChunk.from(
+    //language=WGSL
+    `
+fn decode_vertex_normal(base: u32) -> vec3<f32>{
+    return uv_octahedral_unit_decode(unpack2x16unorm(base));
+}
+    `, [
+        chunk_uv_octahedral_unit_decode,
+    ]
+);

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_vertex_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_encode_vertex_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_vertex_normal.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAajB;0BA7BwB,gCAAgC"}
+{"version":3,"file":"chunk_encode_vertex_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_vertex_normal.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAWjB;0BA3BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_vertex_normal.js

@@ -1,30 +1,28 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_uv_octahedral_unit_encode } from "../octahedron/chunk_uv_octahedral_unit_encode.js";
-
-/**
- * Inverse of `decode_vertex_normal` — packs a unit normal into a single
- * `u32` via octahedral-unit encoding into two 16-bit u-norms (one per
- * u32 half).
- *
- * Layout matches the decoder:
- *  - bits [0, 15]: oct.x (16-bit u-norm of `uv_octahedral_unit_encode(n).x`)
- *  - bits [16, 31]: oct.y
- *
- * Round-trips lossily — the 16-bit quantization gives ~1.5° worst-case
- * angular error, which is what the format buys us in exchange for the
- * 4-byte stride.
- *
- * @type {CodeChunk}
- */
-export const chunk_encode_vertex_normal = CodeChunk.from(
-    //language=WGSL
-    `
-fn encode_vertex_normal(n: vec3<f32>) -> u32 {
-    let oct = uv_octahedral_unit_encode(n);
-    let q = vec2<u32>(oct * 65535.0) & vec2<u32>(0xFFFFu, 0xFFFFu);
-    return q.x | (q.y << 16u);
-}
-`, [
-        chunk_uv_octahedral_unit_encode,
-    ]
-);
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_encode } from "../octahedron/chunk_uv_octahedral_unit_encode.js";
+
+/**
+ * Inverse of `decode_vertex_normal` — packs a unit normal into a single
+ * `u32` via octahedral-unit encoding into two 16-bit u-norms (one per
+ * u32 half).
+ *
+ * Layout matches the decoder:
+ *  - bits [0, 15]: oct.x (16-bit u-norm of `uv_octahedral_unit_encode(n).x`)
+ *  - bits [16, 31]: oct.y
+ *
+ * Round-trips lossily — the 16-bit quantization gives ~1.5° worst-case
+ * angular error, which is what the format buys us in exchange for the
+ * 4-byte stride.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_encode_vertex_normal = CodeChunk.from(
+    //language=WGSL
+    `
+fn encode_vertex_normal(n: vec3<f32>) -> u32 {
+    return pack2x16unorm(uv_octahedral_unit_encode(n));
+}
+`, [
+        chunk_uv_octahedral_unit_encode,
+    ]
+);

package/src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_u32_to_vec2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_unit_u32_to_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_u32_to_vec2.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qCAFU,SAAS,CAUlB;0BAfyB,gCAAgC"}
+{"version":3,"file":"chunk_unit_u32_to_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_u32_to_vec2.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qCAFU,SAAS,CASlB;0BAdyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_u32_to_vec2.js

@@ -1,16 +1,15 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-
-/**
- * Quantized vec2 decoding, vector values must be in [0..1] range
- * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/skeleton.glsl#L66
- * @type {CodeChunk}
- */
-export const chunk_unit_u32_to_vec2 = CodeChunk.from(
-//language=WGSL
-    `
-fn unit_u32_to_vec2(base: u32) -> vec2<f32>{
-    let decode = (vec2(base) >> vec2(0u, 16u)) & vec2(0xFFFFu, 0xFFFFu);
-	return vec2<f32>(decode) / vec2(65535.0, 65535.0) * 2.0 - 1.0;
-}
-    `
-)
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Quantized vec2 decoding, vector values must be in [0..1] range
+ * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/skeleton.glsl#L66
+ * @type {CodeChunk}
+ */
+export const chunk_unit_u32_to_vec2 = CodeChunk.from(
+//language=WGSL
+    `
+fn unit_u32_to_vec2(base: u32) -> vec2<f32>{
+    return unpack2x16unorm(base) * 2.0 - 1.0;
+}
+    `
+)

package/src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_vec2_to_u32.d.ts

@@ -1,5 +1,4 @@
 /**
- * TODO consider pack2x16unorm instead
  * Quantized vec2 encoding, values must be in [0..1] range
  * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/skeleton.glsl#L93
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_vec2_to_u32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_unit_vec2_to_u32.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_vec2_to_u32.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,qCAFU,SAAS,CAUjB;0BAhBwB,gCAAgC"}
+{"version":3,"file":"chunk_unit_vec2_to_u32.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_vec2_to_u32.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qCAFU,SAAS,CASjB;0BAdwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/vec2/chunk_unit_vec2_to_u32.js

@@ -1,18 +1,15 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-
-/**
- * TODO consider pack2x16unorm instead
- * Quantized vec2 encoding, values must be in [0..1] range
- * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/skeleton.glsl#L93
- * @type {CodeChunk}
- */
-export const chunk_unit_vec2_to_u32 = CodeChunk.from(
-    //language=WGSL
-    `
-fn unit_vec2_to_u32(base:vec2<f32>) -> u32{
-    let enc = vec2<u32>(clamp(vec2<i32>(base * vec2(65535, 65535)), vec2(0), vec2(0xFFFF, 0xFFFF))) << vec2(0u, 16u);
-    return enc.x | enc.y;
-}
-    `
-);
-
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Quantized vec2 encoding, values must be in [0..1] range
+ * @see https://github.com/zhangjiangen11/godot/blob/b64ac6341347906dacdda712dc78b574334ff4af/servers/rendering/renderer_rd/shaders/skeleton.glsl#L93
+ * @type {CodeChunk}
+ */
+export const chunk_unit_vec2_to_u32 = CodeChunk.from(
+    //language=WGSL
+    `
+fn unit_vec2_to_u32(base:vec2<f32>) -> u32{
+    return pack2x16unorm(base);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Evaluates a 2D shuffled, Owen-scrambled Sobol (0, 2)-sequence point in [0, 1)^2
+ * entirely in registers with zero lookup tables.
+ *
+ * Every power-of-two prefix of 2^m samples forms a fully stratified (0, m, 2)-net
+ * across all elementary dyadic rectangles of area 2^-m, while per-pixel seeding
+ * decorrelates sample sets across pixels and bounce dimensions:
+ *
+ * 1. **Index shuffling (MSB-to-LSB):** `sample_idx` is Owen-scrambled top-down via
+ *    `reverseBits(hash_lk(reverseBits(sample_idx), ...))`. This maps every aligned
+ *    block of 2^m contiguous indices `[k * 2^m, (k + 1) * 2^m)` bijectively onto
+ *    another aligned 2^m block, randomizing traversal order per pixel while keeping
+ *    bits `i_31..i_m` constant across the block so prefix stratification holds.
+ * 2. **Dimension 0 (Van der Corput):** Prior to radical inversion, the base-2
+ *    Van der Corput sequence is the identity on `i`. Because bit 0 of `i` (`i_0`)
+ *    already represents the geometric MSB (2^-1), `hash_lk` is applied directly
+ *    followed by a single `reverseBits`.
+ * 3. **Dimension 1 (Sobol D1):** Computed without direction-number tables by
+ *    multiplying `i` by the 32x32 upper-triangular Pascal matrix over GF(2)
+ *    (`P_{k,j} = C(j, k) mod 2`, the 5-fold Kronecker power of `[1 1; 0 1]`) using
+ *    5 logarithmic butterfly shift-XOR stages before coordinate scrambling.
+ *
+ * For multi-bounce path tracing, pass a combined hash of `(pixel_coord, bounce_dim_pair)`
+ * as `pixel_seed` to construct padded 2D (0, 2)-sequences without high-dimensional
+ * direction tables.
+ *
+ * @see Brent Burley, "Practical Hash-based Owen Scrambling", Journal of Computer
+ *      Graphics Techniques (JCGT), vol. 9, no. 4, pp. 1-20, 2020.
+ *      http://jcgt.org/published/0009/04/01/
+ * @see Nathan Vegdahl, "Building a Better LK Hash", 2021.
+ *      https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
+ * @see Ilya M. Sobol', "On the distribution of points in a cube and the approximate
+ *      evaluation of integrals", USSR Computational Mathematics and Mathematical
+ *      Physics, vol. 7, no. 4, pp. 86-112, 1967.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sobol_sample_vec2: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sobol_sample_vec2.d.ts.map

package/src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sobol_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,sCAFU,SAAS,CAkClB;0BA1EyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.js

@@ -0,0 +1,75 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_hash_lk } from "../random/chunk_hash_lk.js";
+import { chunk_hash_to_float01 } from "../random/chunk_hash_to_float01.js";
+
+
+/**
+ * Evaluates a 2D shuffled, Owen-scrambled Sobol (0, 2)-sequence point in [0, 1)^2
+ * entirely in registers with zero lookup tables.
+ *
+ * Every power-of-two prefix of 2^m samples forms a fully stratified (0, m, 2)-net
+ * across all elementary dyadic rectangles of area 2^-m, while per-pixel seeding
+ * decorrelates sample sets across pixels and bounce dimensions:
+ *
+ * 1. **Index shuffling (MSB-to-LSB):** `sample_idx` is Owen-scrambled top-down via
+ *    `reverseBits(hash_lk(reverseBits(sample_idx), ...))`. This maps every aligned
+ *    block of 2^m contiguous indices `[k * 2^m, (k + 1) * 2^m)` bijectively onto
+ *    another aligned 2^m block, randomizing traversal order per pixel while keeping
+ *    bits `i_31..i_m` constant across the block so prefix stratification holds.
+ * 2. **Dimension 0 (Van der Corput):** Prior to radical inversion, the base-2
+ *    Van der Corput sequence is the identity on `i`. Because bit 0 of `i` (`i_0`)
+ *    already represents the geometric MSB (2^-1), `hash_lk` is applied directly
+ *    followed by a single `reverseBits`.
+ * 3. **Dimension 1 (Sobol D1):** Computed without direction-number tables by
+ *    multiplying `i` by the 32x32 upper-triangular Pascal matrix over GF(2)
+ *    (`P_{k,j} = C(j, k) mod 2`, the 5-fold Kronecker power of `[1 1; 0 1]`) using
+ *    5 logarithmic butterfly shift-XOR stages before coordinate scrambling.
+ *
+ * For multi-bounce path tracing, pass a combined hash of `(pixel_coord, bounce_dim_pair)`
+ * as `pixel_seed` to construct padded 2D (0, 2)-sequences without high-dimensional
+ * direction tables.
+ *
+ * @see Brent Burley, "Practical Hash-based Owen Scrambling", Journal of Computer
+ *      Graphics Techniques (JCGT), vol. 9, no. 4, pp. 1-20, 2020.
+ *      http://jcgt.org/published/0009/04/01/
+ * @see Nathan Vegdahl, "Building a Better LK Hash", 2021.
+ *      https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
+ * @see Ilya M. Sobol', "On the distribution of points in a cube and the approximate
+ *      evaluation of integrals", USSR Computational Mathematics and Mathematical
+ *      Physics, vol. 7, no. 4, pp. 86-112, 1967.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sobol_sample_vec2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_sobol_2d(sample_idx: u32, pixel_seed: u32) -> vec2<f32> {
+    // 1. Shuffle index (MSB -> LSB):
+    //    Reverse sample_idx so s_31 is at bit 0, run LSB->MSB hash,
+    //    then reverse back so i_0 is at bit 0 for Sobol generation.
+    let idx_seed = pixel_seed ^ 0x79c68e4au;
+    let i = reverseBits(hash_lk(reverseBits(sample_idx), idx_seed));
+
+    // 2. Dimension 0 (Van der Corput):
+    //    i_0 (geometric MSB) is already at bit 0. Hash LSB->MSB, then
+    //    reverse once so the geometric MSB sits at bit 31.
+    let u0 = reverseBits(hash_lk(i, pixel_seed ^ 0x9e3779b9u));
+
+    // 3. Dimension 1 (Sobol D1 via upper-triangular Pascal matrix):
+    //    Requires i_0 at bit 0 so high bits (i_31..i_m, which are constant
+    //    across 2^m-aligned blocks) shift down into low bits.
+    var b = i;
+    b ^= b >> 16u;
+    b ^= (b & 0xff00ff00u) >> 8u;
+    b ^= (b & 0xf0f0f0f0u) >> 4u;
+    b ^= (b & 0xccccccccu) >> 2u;
+    b ^= (b & 0xaaaaaaaau) >> 1u;
+    let u1 = reverseBits(hash_lk(b, pixel_seed ^ 0xbb67ae85u));
+
+    return vec2<f32>(hash_to_float01(u0), hash_to_float01(u1));
+}
+    `,[
+        chunk_hash_lk,
+        chunk_hash_to_float01
+    ]
+)

package/src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_vdc_radical_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wCAFU,SAAS,CAYlB;0BAlByB,6BAA6B"}
+{"version":3,"file":"chunk_vdc_radical_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,SAAS,CAalB;0BApByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_hash_to_float01 } from "../random/chunk_hash_to_float01.js";
 
 /**
  *
@@ -12,8 +13,9 @@ export const chunk_vdc_radical_inverse = CodeChunk.from(
 fn vdc_radical_inverse(bits:u32) -> f32{
     let b = reverseBits(bits);
     
-    return f32(b) * 2.3283064365386963e-10;
+    return hash_to_float01(b);
 }
     `, [
+        chunk_hash_to_float01
     ]
 )