@woosh/meep-engine 3.60.9 → 3.61.1

package/src/shade/renderer/restir/di/chunk_restir_resolve.js

@@ -1,94 +1,91 @@
-import { REFLECTED_LIGHT_STRUCT } from "../../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
-import { chunk_re_direct_multiscatter } from "../../shader/chunk/material/chunk_re_direct_multiscatter.js";
-import { chunk_re_direct_physical } from "../../shader/chunk/material/chunk_re_direct_physical.js";
-import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
-import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
-import { RTXDI_Reservoir } from "../reservoir/RTXDI_Reservoir.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_restir_get_light_info } from "./chunk_restir_get_light_info.js";
-import { chunk_restir_light_ref } from "./chunk_restir_light_ref.js";
-import { chunk_restir_sample_light_record } from "./chunk_restir_sample_light_record.js";
-import { chunk_restir_trace_visibility } from "./chunk_restir_trace_visibility.js";
-
-/**
- * Resolve a finalized reservoir to outgoing radiance for the selected light:
- *
- *   radiance = BRDF·Le·G (full RGB, unshadowed) · W · V
- *
- * where W == reservoir.weightSum after FinalizeResampling (it already folds in
- * 1/p_hat and 1/M) and V is the traced visibility (the RTXDI `f_rgb · weightSum`
- * identity). p_hat is the luminance of the single-scattering BRDF·Le·G; this
- * BRDF also carries `re_direct_multiscatter`'s per-pixel scale of the specular,
- * so f / p_hat is no longer 1 but stays within [1, that scale]. The estimate is
- * unbiased either way: f and p_hat are positive on the same lights.
- *
- * Visibility is a single opaque shadow ray toward the survivor's sampled emitter
- * point — matching the brute-force NEE reference (`ray_sample_light`), which also
- * uses `ray_query_occluded`. Requires the RTX resource group to be bound.
- *
- * Emissive is intentionally excluded; the deferred pass adds it once.
- *
- * @type {CodeChunk}
- */
-export const chunk_restir_resolve = CodeChunk.from(
-    //language=WGSL
-    `
-fn restir_resolve(
-    i_coord: vec2<u32>,
-    reservoir: ${RTXDI_Reservoir.wgsl_ref},
-    geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
-    material: ${MATERIAL_SHADING_INFO_STRUCT.wgsl_ref},
-    use_screen_space_shadow: u32
-) -> vec3<f32> {
-    if (!restir_light_ref_is_valid(reservoir.lightData) || reservoir.weightSum <= 0.0) {
-        return vec3<f32>(0.0);
-    }
-
-    let light_type = restir_light_ref_type(reservoir.lightData);
-    let light_index = restir_light_ref_index(reservoir.lightData);
-
-    // Full RGB unshadowed contribution via the representative-point incident light.
-    let incident = restir_get_light_info(light_type, light_index, geometry.position);
-    var reflected: ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
-    re_direct_physical(incident, geometry, material, &reflected);
-    re_direct_multiscatter(geometry, material, &reflected);
-    let radiance = reflected.diffuse + reflected.specular;
-
-    if (all(radiance <= vec3<f32>(0.0))) {
-        return vec3<f32>(0.0);
-    }
-
-    // Decode the stored 16-bit-fixed-point area-light sample point.
-    let uv = vec2<f32>(
-        f32(reservoir.uvData & 0xFFFFu) / 65535.0,
-        f32((reservoir.uvData >> 16u) & 0xFFFFu) / 65535.0
-    );
-    let record = restir_sample_light_record(light_type, light_index, geometry.position, uv);
-
-    var visibility = 1.0;
-    if (record.distance > 0.0) {
-        visibility = restir_trace_visibility(
-            i_coord,
-            geometry.position,
-            geometry.geometric_normal,
-            record.direction,
-            record.distance,
-            use_screen_space_shadow != 0u,
-        );
-    }
-
-    return radiance * reservoir.weightSum * visibility;
-}
-    `, [
-        RTXDI_Reservoir.declaration_chunk,
-        REFLECTED_LIGHT_STRUCT.declaration_chunk,
-        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
-        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
-        chunk_re_direct_physical,
-        chunk_re_direct_multiscatter,
-        chunk_restir_get_light_info,
-        chunk_restir_light_ref,
-        chunk_restir_sample_light_record,
-        chunk_restir_trace_visibility,
-    ]
-);
+import { REFLECTED_LIGHT_STRUCT } from "../../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_re_direct_multiscatter } from "../../shader/chunk/material/chunk_re_direct_multiscatter.js";
+import { chunk_re_direct_physical } from "../../shader/chunk/material/chunk_re_direct_physical.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
+import { RTXDI_Reservoir } from "../reservoir/RTXDI_Reservoir.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_restir_get_light_info } from "./chunk_restir_get_light_info.js";
+import { chunk_restir_light_ref } from "./chunk_restir_light_ref.js";
+import { chunk_restir_sample_light_record } from "./chunk_restir_sample_light_record.js";
+import { chunk_restir_trace_visibility } from "./chunk_restir_trace_visibility.js";
+
+/**
+ * Resolve a finalized reservoir to outgoing radiance for the selected light:
+ *
+ *   radiance = BRDF·Le·G (full RGB, unshadowed) · W · V
+ *
+ * where W == reservoir.weightSum after FinalizeResampling (it already folds in
+ * 1/p_hat and 1/M) and V is the traced visibility (the RTXDI `f_rgb · weightSum`
+ * identity). p_hat is the luminance of the single-scattering BRDF·Le·G; this
+ * BRDF also carries `re_direct_multiscatter`'s per-pixel scale of the specular,
+ * so f / p_hat is no longer 1 but stays within [1, that scale]. The estimate is
+ * unbiased either way: f and p_hat are positive on the same lights.
+ *
+ * Visibility is a single opaque shadow ray toward the survivor's sampled emitter
+ * point — matching the brute-force NEE reference (`ray_sample_light`), which also
+ * uses `ray_query_occluded`. Requires the RTX resource group to be bound.
+ *
+ * Emissive is intentionally excluded; the deferred pass adds it once.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_restir_resolve = CodeChunk.from(
+    //language=WGSL
+    `
+fn restir_resolve(
+    i_coord: vec2<u32>,
+    reservoir: ${RTXDI_Reservoir.wgsl_ref},
+    geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
+    material: ${MATERIAL_SHADING_INFO_STRUCT.wgsl_ref},
+    use_screen_space_shadow: u32
+) -> vec3<f32> {
+    if (!restir_light_ref_is_valid(reservoir.lightData) || reservoir.weightSum <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+
+    let light_type = restir_light_ref_type(reservoir.lightData);
+    let light_index = restir_light_ref_index(reservoir.lightData);
+
+    // Full RGB unshadowed contribution via the representative-point incident light.
+    let incident = restir_get_light_info(light_type, light_index, geometry.position);
+    var reflected: ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
+    re_direct_physical(incident, geometry, material, &reflected);
+    re_direct_multiscatter(geometry, material, &reflected);
+    let radiance = reflected.diffuse + reflected.specular;
+
+    if (all(radiance <= vec3<f32>(0.0))) {
+        return vec3<f32>(0.0);
+    }
+
+    // Decode the stored 16-bit-fixed-point area-light sample point.
+    let uv = unpack2x16unorm(reservoir.uvData);
+    let record = restir_sample_light_record(light_type, light_index, geometry.position, uv);
+
+    var visibility = 1.0;
+    if (record.distance > 0.0) {
+        visibility = restir_trace_visibility(
+            i_coord,
+            geometry.position,
+            geometry.geometric_normal,
+            record.direction,
+            record.distance,
+            use_screen_space_shadow != 0u,
+        );
+    }
+
+    return radiance * reservoir.weightSum * visibility;
+}
+    `, [
+        RTXDI_Reservoir.declaration_chunk,
+        REFLECTED_LIGHT_STRUCT.declaration_chunk,
+        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
+        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
+        chunk_re_direct_physical,
+        chunk_re_direct_multiscatter,
+        chunk_restir_get_light_info,
+        chunk_restir_light_ref,
+        chunk_restir_sample_light_record,
+        chunk_restir_trace_visibility,
+    ]
+);

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/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/subgroup/chunk_subgroup_bitset_or.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The index {@link chunk_subgroup_bitset_or} skips.
+ *
+ * @type {number}
+ */
+export const SUBGROUP_BITSET_OR_NONE: number;
+/**
+ * Set bit `index` of a bitset, one atomic per distinct word the subgroup holds: the lanes holding
+ * the first outstanding word take a round, OR together the bits they hold in it — or skip that when
+ * they all hold the same bit — one of them sets them with one `atomicOr`, and the rounds repeat
+ * until no word is left.
+ *
+ * `fn subgroup_bitset_or(bits: ptr<storage, array<atomic<u32>>, read_write>, index: u32)`
+ *
+ * Bit `index` is bit `index & 31` of word `index >> 5`. An index of {@link SUBGROUP_BITSET_OR_NONE},
+ * or one whose word is past the end of `bits`, sets nothing. Every lane of the subgroup calls it,
+ * from subgroup-uniform control flow.
+ *
+ * The atomic is made by a lane of the round, so a lane that holds nothing never stands in for one
+ * that does — in a fragment shader, a helper invocation given {@link SUBGROUP_BITSET_OR_NONE} can
+ * never be the one that writes, and its write would be discarded.
+ *
+ * A subgroup runs one round per distinct word it holds, so the loop is bounded by its lane count.
+ * Indices that follow the screen — a material per pixel — come in runs, and a subgroup ordinarily
+ * holds one or two.
+ *
+ * @see chunk_subgroup_keyed_append for the counting twin
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_bitset_or: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_subgroup_bitset_or.d.ts.map

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_bitset_or.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_subgroup_bitset_or.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_bitset_or.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,sCAFU,MAAM,CAEkC;AAElD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAsChB;0BApEuB,6BAA6B"}