@woosh/meep-engine 3.61.0 → 3.61.1

package/src/generation/foliage/skeleton/ShootWoodHash.js

@@ -1,3 +1,4 @@
+import { aabb3_intersects_segment3 } from "../../../core/geom/3d/aabb/aabb3_intersects_segment3.js";
 import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { shoot_radius } from "./shoot_geometry.js";
 
@@ -20,6 +21,14 @@ const CLEARANCE = 0.001;
  */
 const KEY_SPAN = 2048;
 
+/**
+ * Margin (m) a cell is widened by when asking whether an axis line crosses it: far above the rounding of a point at
+ * the key's 205 m span, far below any wood, so a line along a cell's face or through its edge is under the cells either
+ * side of it.
+ * @type {number}
+ */
+const CROSSING_TOLERANCE = WOOD_CELL * 2 ** -20;
+
 const SCRATCH_ST = new Float64Array(2);
 
 /**
@@ -27,7 +36,7 @@ const SCRATCH_ST = new Float64Array(2);
  * wood, and thinner wood that thicker wood has grown into can be found. A unit is added once, when it has grown, under
  * the cells its axis line crosses; a query reads every unit's place and radius from its axis as they are then, and
  * reaches as far round as the thickest wood ({@link max_radius}), so wood that thickens needs no re-adding. The units
- * of an axis that has died are passed over.
+ * of an axis that has died are passed over, and leave the hash at the next {@link refresh}.
  */
 export class ShootWoodHash {
     /** @type {Map<number, number[]>} */
@@ -89,6 +98,11 @@ export class ShootWoodHash {
         const y0 = Math.floor(Math.min(p[a + 1], p[b + 1]) / WOOD_CELL), y1 = Math.floor(Math.max(p[a + 1], p[b + 1]) / WOOD_CELL);
         const z0 = Math.floor(Math.min(p[a + 2], p[b + 2]) / WOOD_CELL), z1 = Math.floor(Math.max(p[a + 2], p[b + 2]) / WOOD_CELL);
         for (let x = x0; x <= x1; x++) for (let y = y0; y <= y1; y++) for (let z = z0; z <= z1; z++) {
+            if (!aabb3_intersects_segment3(
+                x * WOOD_CELL - CROSSING_TOLERANCE, y * WOOD_CELL - CROSSING_TOLERANCE, z * WOOD_CELL - CROSSING_TOLERANCE,
+                (x + 1) * WOOD_CELL + CROSSING_TOLERANCE, (y + 1) * WOOD_CELL + CROSSING_TOLERANCE, (z + 1) * WOOD_CELL + CROSSING_TOLERANCE,
+                p[a], p[a + 1], p[a + 2], p[b], p[b + 1], p[b + 2]
+            )) continue;
             const key = ((x + KEY_SPAN / 2) * KEY_SPAN + (y + KEY_SPAN / 2)) * KEY_SPAN + (z + KEY_SPAN / 2);
             let list = this.cells.get(key);
             if (list === undefined) {
@@ -102,21 +116,30 @@ export class ShootWoodHash {
 
     /**
      * Records each cell's thickest living unit, after the wood has thickened, and the thickest of all
-     * ({@link max_radius}).
+     * ({@link max_radius}). A dead axis does not live again, so its units leave their cells, in the order the rest
+     * were added, and a cell left empty leaves the hash.
      */
     refresh() {
         const axes = this.axes;
         let most = 0;
         for (const [key, list] of this.cells) {
             let max = 0;
+            let kept = 0;
             for (let i = 0; i < list.length; i++) {
                 const id = list[i];
                 const axis = axes[this.unit_axis[id]];
                 if (!axis.alive) continue;
+                list[kept++] = id;
                 const k = this.unit_index[id];
                 const thickest = axis.radii.length > k + 1 ? Math.max(axis.radii[k], axis.radii[k + 1]) : shoot_radius(axis.units[k], 0);
                 if (thickest > max) max = thickest;
             }
+            if (kept === 0) {
+                this.cells.delete(key);
+                this.cell_max.delete(key);
+                continue;
+            }
+            list.length = kept;
             this.cell_max.set(key, max);
             if (max > most) most = max;
         }

package/src/shade/renderer/buffer/graph_read_buffer.d.ts

@@ -5,7 +5,9 @@
  * @param {number} buffer
  * @param {number} [offset=0]
  * @param {number} [size] defaults to buffer.size - offset
- * @param {number} [timeout] in milliseconds, 0 for no timeout. Timeout will start immediately, meaning that if you don't schedule the graph immediately - you might see unexpected behaviour.
+ * @param {number} [timeout] in milliseconds, 0 for no timeout: how long the read waits for its pass to run, starting
+ * now. A graph that is never run, or stops at a throwing pass before this one, rejects the read here. Once the pass has
+ * run, the read waits for the device however far behind it is, and settles when the mapping does.
  * @returns {Promise<Reference<ArrayBuffer>>} don't forget to release the reference
  */
 export function graph_read_buffer({ graph, buffer, offset, size, timeout }: FrameGraph): Promise<Reference<ArrayBuffer>>;

package/src/shade/renderer/buffer/graph_read_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_read_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/graph_read_buffer.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,yFAFa,QAAQ,UAAU,WAAW,CAAC,CAAC,CAuH3C;0BApIyB,2CAA2C"}
+{"version":3,"file":"graph_read_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/graph_read_buffer.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,yFAFa,QAAQ,UAAU,WAAW,CAAC,CAAC,CAwH3C;0BAvIyB,2CAA2C"}

package/src/shade/renderer/buffer/graph_read_buffer.js

@@ -12,7 +12,9 @@ const scratch_buffer_descriptor = new BufferResourceDescriptor();
  * @param {number} buffer
  * @param {number} [offset=0]
  * @param {number} [size] defaults to buffer.size - offset
- * @param {number} [timeout] in milliseconds, 0 for no timeout. Timeout will start immediately, meaning that if you don't schedule the graph immediately - you might see unexpected behaviour.
+ * @param {number} [timeout] in milliseconds, 0 for no timeout: how long the read waits for its pass to run, starting
+ * now. A graph that is never run, or stops at a throwing pass before this one, rejects the read here. Once the pass has
+ * run, the read waits for the device however far behind it is, and settles when the mapping does.
  * @returns {Promise<Reference<ArrayBuffer>>} don't forget to release the reference
  */
 export function graph_read_buffer({
@@ -47,6 +49,12 @@ export function graph_read_buffer({
      * @param {GraphicsExecutionContext} context
      */
     function execute(data, resources, context) {
+        // the copy is recorded: the mapping lands, or is refused, however long the device takes
+        if (timeout_handle !== -1) {
+            clearTimeout(timeout_handle);
+            timeout_handle = -1;
+        }
+
         /**
          * @type {GPUBuffer}
          */
@@ -94,11 +102,6 @@ export function graph_read_buffer({
                 return;
             }
 
-            if (timeout_handle !== -1) {
-                clearTimeout(timeout_handle);
-                timeout_handle = -1;
-            }
-
             const data = destination.getMappedRange(0, _size);
 
             ref = new Reference();

package/src/shade/renderer/particles/GPUParticleSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/particles/GPUParticleSystem.js

@@ -68,13 +68,7 @@ const STORAGE_GROWABLE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUB
  */
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
 
-/**
- * Particles a scene holds at once unless the constructor is told otherwise — and the renderer never
- * tells it ({@link ../Renderer.js Renderer#particles}), so this is every scene's pool. 2^17: about
- * 18 MB of pool, free list, alive list and coherence scratch at a 128-byte record, which a game with
- * dense bursts (a body dissolving into thousands of motes) fills before 65,536 does.
- */
-const DEFAULT_CAPACITY = 131072;
+const DEFAULT_CAPACITY = 65536;
 
 /**
  * What {@link GPUParticleSystem#read_stats} decodes: the counts the GPU keeps between frames, named.

package/src/shade/renderer/restir/di/chunk_restir_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CA+DjB;0BAvFwB,oCAAoC"}
+{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CA4DjB;0BApFwB,oCAAoC"}

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,
+    ]
+);