@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/buffer/table/gpu_table_field_word.js

@@ -0,0 +1,111 @@
+import { assert } from "../../../../core/assert.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import { u32, vec2u, vec3u, vec4u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { GPU_DATABASE_BUFFER_ELEMENT_TYPE } from "./GPU_DATABASE_BUFFER_ELEMENT_TYPE.js";
+
+/**
+ * @typedef {import("../../shader/type/WebGPUType.js").WebGPUType} WebGPUType
+ */
+
+/**
+ * How many u32 lanes a path may index into, for each u32 vector type.
+ * @type {Map<WebGPUType, number>}
+ */
+const U32_VECTOR_LANES = new Map([
+    [vec2u, 2],
+    [vec3u, 3],
+    [vec4u, 4],
+]);
+
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*/;
+
+const INDEX = /^[0-9]+$/;
+
+/**
+ * The word offset, within one record of `type`, of the single `u32` word that `path` names.
+ *
+ * A path is a field name followed by any number of `.name` (into a struct) and `[i]` (into an array,
+ * or into one lane of a `u32` vector): `'node'`, `'joints[3].node'`, `'curves[2]'`. It has to end on
+ * exactly one `u32`: a vector, a struct or an array is refused, because a link is one word.
+ *
+ * Offsets come from the type as it is laid out — after `pack()` has reordered a struct — so a path
+ * names a field, never a position.
+ *
+ * @param {WebGPUType} type a table's record type
+ * @param {string} path
+ * @returns {number} offset from the start of the record, in {@link GPU_DATABASE_BUFFER_ELEMENT_TYPE} units
+ */
+export function gpu_table_field_word(type, path) {
+    assert.defined(type, 'type');
+    assert.isString(path, 'path');
+    assert.greaterThan(path.length, 0, 'path.length');
+
+    let current = type;
+    let byte_offset = 0;
+    let cursor = 0;
+
+    while (cursor < path.length) {
+        if (path[cursor] === '[') {
+            const close = path.indexOf(']', cursor);
+
+            assert.greaterThan(close, cursor, `'${path}': '[' at ${cursor} is never closed`);
+
+            const digits = path.slice(cursor + 1, close);
+
+            assert.ok(INDEX.test(digits), `'${path}': '[${digits}]' is not an index`);
+
+            const index = Number(digits);
+
+            cursor = close + 1;
+
+            if (current.isArray === true) {
+                assert.notOk(current.runtime_sized, `'${path}': a runtime-sized array has no fixed place in a record`);
+                assert.lessThan(index, current.count, `'${path}': index ${index} is past the array's ${current.count} elements`);
+
+                const element = current.type;
+
+                byte_offset += index * round_up(element.size, element.align);
+                current = element;
+
+                continue;
+            }
+
+            const lanes = U32_VECTOR_LANES.get(current);
+
+            assert.defined(lanes, `'${path}': [${index}] indexes something that is neither an array nor a u32 vector`);
+            assert.lessThan(index, lanes, `'${path}': lane ${index} is past the vector's ${lanes} lanes`);
+
+            byte_offset += index * u32.size;
+            current = u32;
+
+            continue;
+        }
+
+        if (cursor > 0) {
+            assert.equal(path[cursor], '.', `'${path}': expected '.', '[' or the end at ${cursor}`);
+
+            cursor++;
+        }
+
+        const match = NAME.exec(path.slice(cursor));
+
+        assert.notNull(match, `'${path}': expected a field name at ${cursor}`);
+
+        const name = match[0];
+
+        cursor += name.length;
+
+        assert.equal(current.isStruct, true, `'${path}': '${name}' names a field of something that is not a struct`);
+
+        // throws for a field the struct does not have
+        const field = current.get(name);
+
+        byte_offset += field.offset;
+        current = field.type;
+    }
+
+    assert.equal(current, u32, `'${path}' does not end on a u32 — a link is one word`);
+    assert.equal(byte_offset % GPU_DATABASE_BUFFER_ELEMENT_TYPE.size, 0, `'${path}' is not word-aligned`);
+
+    return byte_offset / GPU_DATABASE_BUFFER_ELEMENT_TYPE.size;
+}

package/src/shade/renderer/buffer/table/gpu_table_range_well_formed.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+/**
+ * Whether a range's two words are the empty range, `(GPU_DATABASE_NULL, 0)`, or a run the target
+ * table could hold: a first row, a count above zero, and an end no further than the table's last
+ * row.
+ *
+ * Anything else names no run — it can only come from a bug that wrote the words — and neither the
+ * removal cascade nor the link check follows it: a garbage count could send either through four
+ * billion rows.
+ *
+ * @param {number} first the range's first word
+ * @param {number} count the range's count word
+ * @param {GPUTypedTableDescriptor} target the table the run would be in
+ * @returns {boolean}
+ */
+export function gpu_table_range_well_formed(first: number, count: number, target: GPUTypedTableDescriptor): boolean;
+export type GPUTypedTableDescriptor = import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+//# sourceMappingURL=gpu_table_range_well_formed.d.ts.map

package/src/shade/renderer/buffer/table/gpu_table_range_well_formed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu_table_range_well_formed.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_table_range_well_formed.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,mDALW,MAAM,SACN,MAAM,UACN,uBAAuB,GACrB,OAAO,CAQnB;sCAvBY,OAAO,8BAA8B,EAAE,uBAAuB"}

package/src/shade/renderer/buffer/table/gpu_table_range_well_formed.js

@@ -0,0 +1,27 @@
+import { GPU_DATABASE_NULL } from "./GPU_DATABASE_NULL.js";
+
+/**
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+
+/**
+ * Whether a range's two words are the empty range, `(GPU_DATABASE_NULL, 0)`, or a run the target
+ * table could hold: a first row, a count above zero, and an end no further than the table's last
+ * row.
+ *
+ * Anything else names no run — it can only come from a bug that wrote the words — and neither the
+ * removal cascade nor the link check follows it: a garbage count could send either through four
+ * billion rows.
+ *
+ * @param {number} first the range's first word
+ * @param {number} count the range's count word
+ * @param {GPUTypedTableDescriptor} target the table the run would be in
+ * @returns {boolean}
+ */
+export function gpu_table_range_well_formed(first, count, target) {
+    if (first === GPU_DATABASE_NULL) {
+        return count === 0;
+    }
+
+    return count > 0 && first + count <= target.page_limit * target.elements_per_page;
+}

package/src/shade/renderer/camera/CameraManager.d.ts

@@ -7,6 +7,17 @@ export class CameraManager {
      * @param {GPUDevice} device
      */
     constructor(device: GPUDevice);
+    /**
+     *
+     * @param {Camera} camera
+     * @return {GPUCameraContext}
+     */
+    /**
+     * Release every camera context this handed out. Each holds a GPU uniform buffer.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
     /**
      *
      * @param {Camera} camera

package/src/shade/renderer/camera/CameraManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/CameraManager.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;IAaI;;;OAGG;IACH,+BAEC;IAaD;;;;OAIG;IACH,eAHW,MAAM,GACL,gBAAgB,CAU3B;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAShB;;CAEJ;qBAtEY,OAAO,aAAa,EAAE,MAAM;iCAHR,uBAAuB"}
+{"version":3,"file":"CameraManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/CameraManager.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;IAaI;;;OAGG;IACH,+BAEC;IAaD;;;;OAIG;IACH;;;;OAIG;IACH,WAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,gBAAgB,CAU3B;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAShB;;CAEJ;qBAxFY,OAAO,aAAa,EAAE,MAAM;iCAHR,uBAAuB"}

package/src/shade/renderer/camera/CameraManager.js

@@ -36,6 +36,24 @@ export class CameraManager {
 
     }
 
+    /**
+     *
+     * @param {Camera} camera
+     * @return {GPUCameraContext}
+     */
+    /**
+     * Release every camera context this handed out. Each holds a GPU uniform buffer.
+     *
+     * @returns {void}
+     */
+    destroy() {
+        for (const ctx of this.#cache.values()) {
+            ctx.destroy();
+        }
+
+        this.#cache.clear();
+    }
+
     /**
      *
      * @param {Camera} camera

package/src/shade/renderer/create_frame_loop.d.ts

@@ -1,6 +1,22 @@
 /**
+ * A requestAnimationFrame loop with an optional frame-rate cap.
+ *
+ * The callback is handed **two different intervals** and picking the wrong one
+ * is easy, so: the first is the distance from the limiter's *scheduled* slot,
+ * a clock this loop advances by exactly one frame delay at a time. It is
+ * smooth and drift-free, which is what a simulation step wants. The second is
+ * the real time since the previous dispatch.
+ *
+ * Only the second describes what the machine did. A readout that prints the
+ * first as "N ms / M fps" is naming a property of the scheduler and the
+ * display: at a 60 cap on a 144 Hz screen it reads 19.4 ms / 51 fps while the
+ * page is delivering a frame every 16.7 ms, and it reads differently again at
+ * another refresh rate for identical work. `create_frame_loop.spec.js` holds
+ * both numbers.
  *
  * @param {function(time_delta_s:number, raw_refresh_time_s: number)} callback
+ *   `(scheduled-slot interval, real interval since the last dispatch)`, both
+ *   in seconds
  * @param {number} [frame_cap]
  * @returns {(function(): void)} call the function to terminate the loop
  */

package/src/shade/renderer/create_frame_loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create_frame_loop.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/create_frame_loop.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,6DAHW,MAAM,GACJ,OAAa,IAAI,CAAC,CA6D9B"}
+{"version":3,"file":"create_frame_loop.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/create_frame_loop.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,6DAHW,MAAM,GACJ,OAAa,IAAI,CAAC,CA6D9B"}

package/src/shade/renderer/create_frame_loop.js

@@ -1,6 +1,22 @@
 /**
+ * A requestAnimationFrame loop with an optional frame-rate cap.
+ *
+ * The callback is handed **two different intervals** and picking the wrong one
+ * is easy, so: the first is the distance from the limiter's *scheduled* slot,
+ * a clock this loop advances by exactly one frame delay at a time. It is
+ * smooth and drift-free, which is what a simulation step wants. The second is
+ * the real time since the previous dispatch.
+ *
+ * Only the second describes what the machine did. A readout that prints the
+ * first as "N ms / M fps" is naming a property of the scheduler and the
+ * display: at a 60 cap on a 144 Hz screen it reads 19.4 ms / 51 fps while the
+ * page is delivering a frame every 16.7 ms, and it reads differently again at
+ * another refresh rate for identical work. `create_frame_loop.spec.js` holds
+ * both numbers.
  *
  * @param {function(time_delta_s:number, raw_refresh_time_s: number)} callback
+ *   `(scheduled-slot interval, real interval since the last dispatch)`, both
+ *   in seconds
  * @param {number} [frame_cap]
  * @returns {(function(): void)} call the function to terminate the loop
  */

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Brute-force direct shading of a standard material: every occupied directional light through the
+ * shared CSM helper, then a per-pixel loop over every point and spot light in the froxel cluster, each
+ * shadow-mapped.
+ *
+ * **One chunk, linked by both the deferred and the forward paths.** `shader_deferred_main` links it
+ * (through the `_heavy` alias next door) and so do
+ * `chunk_forward_shade_standard_fragment_ibl` / `..._brick4`. It used to exist twice under this one
+ * WGSL function name, with the cluster metadata lookup, the point loop, the spot loop and the
+ * emissive sum character-identical between the two and only the directional half differing: this copy
+ * re-inlined `chunk_shade_directional_lights`' body where the other called it. Two files one edit away
+ * from shading the same scene differently depending on which of them the pass reached.
+ *
+ * The ReSTIR DI variant ({@link chunk_shade_standard_material_direct_restir}) is a genuinely different
+ * function — it replaces the cluster loop with one resampled, ray-traced sample — and stays separate.
+ * The three are selected as separate compiled shaders, not via a runtime branch.
+ *
+ * A note carried by the inlined copy, kept because it is still true and now has nowhere else to sit:
+ * a screen-space ray-trace for directional visibility would be wanted on the deferred path only, and
+ * adding it means splitting these paths again deliberately rather than by accident.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_shade_standard_material_direct: CodeChunk;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_shade_standard_material_direct.d.ts.map

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAiBA,6DA4GE;0BA/GwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mDAFU,SAAS,CAuFjB;0BAhHwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.js

@@ -1,11 +1,5 @@
 import { chunk_light_cluster_counts } from "../light/cluster/chunk_light_cluster_counts.js";
 import { chunk_light_cluster_metadata_by_position } from "../light/cluster/chunk_light_cluster_metadata_by_position.js";
-import {
-    chunk_directional_lights_iteration_mask
-} from "../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
-import {
-    chunk_get_directional_light_info_by_index
-} from "../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
 import { chunk_get_point_light_info_by_index } from "../shader/chunk/light/io/chunk_get_point_light_info_by_index.js";
 import { chunk_get_spot_light_info_by_index } from "../shader/chunk/light/io/chunk_get_spot_light_info_by_index.js";
 import { REFLECTED_LIGHT_STRUCT } from "../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
@@ -14,7 +8,31 @@ import { GEOMETRIC_SHADING_INFO_STRUCT } from "../shader/chunk/material/GEOMETRI
 import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
-
+import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights.js";
+
+/**
+ * Brute-force direct shading of a standard material: every occupied directional light through the
+ * shared CSM helper, then a per-pixel loop over every point and spot light in the froxel cluster, each
+ * shadow-mapped.
+ *
+ * **One chunk, linked by both the deferred and the forward paths.** `shader_deferred_main` links it
+ * (through the `_heavy` alias next door) and so do
+ * `chunk_forward_shade_standard_fragment_ibl` / `..._brick4`. It used to exist twice under this one
+ * WGSL function name, with the cluster metadata lookup, the point loop, the spot loop and the
+ * emissive sum character-identical between the two and only the directional half differing: this copy
+ * re-inlined `chunk_shade_directional_lights`' body where the other called it. Two files one edit away
+ * from shading the same scene differently depending on which of them the pass reached.
+ *
+ * The ReSTIR DI variant ({@link chunk_shade_standard_material_direct_restir}) is a genuinely different
+ * function — it replaces the cluster loop with one resampled, ray-traced sample — and stays separate.
+ * The three are selected as separate compiled shaders, not via a runtime branch.
+ *
+ * A note carried by the inlined copy, kept because it is still true and now has nowhere else to sit:
+ * a screen-space ray-trace for directional visibility would be wanted on the deferred path only, and
+ * adding it means splitting these paths again deliberately rather than by accident.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_shade_standard_material_direct = CodeChunk.from(
     //language=WGSL
     `
@@ -27,29 +45,7 @@ fn shade_standard_material_direct(
 
     var reflected_light : ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
 
-    // Iterate occupied directional lights from the first bitmap word
-    // (max 32 enforced by GPULightCollection).
-    var directional_bits = directional_lights_iteration_mask(&light_data);
-    while (directional_bits != 0u) {
-        let directional_index = countTrailingZeros(directional_bits);
-        directional_bits &= ~(1u << directional_index);
-
-        var direct_light = get_directional_light_info_by_index(&light_data, directional_index);
-
-        let visibility = shadowmap_get_directional_light_visibility(
-            &light_data,
-            directional_index,
-            geometry.position,
-            geometry.view_direction,
-            geometry.shading_normal
-        );
-
-        // TODO add a screen-space ray-trace, but only for deferred path
-
-        direct_light.color *= visibility;
-
-        re_direct_physical(direct_light, geometry, material, &reflected_light);
-    }
+    shade_directional_lights(material, geometry, &reflected_light);
 
     // Process local lights (point, then spot)
     let cluster_metadata = light_cluster_metadata_by_position(
@@ -119,8 +115,7 @@ fn shade_standard_material_direct(
         chunk_light_cluster_counts,
         chunk_get_point_light_info_by_index,
         chunk_get_spot_light_info_by_index,
-        chunk_get_directional_light_info_by_index,
-        chunk_directional_lights_iteration_mask,
+        chunk_shade_directional_lights,
         chunk_shadowmap_get_light_visibility,
     ]
 );

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.d.ts

@@ -1,13 +1,15 @@
 /**
- * Brute-force deferred direct shading: directional lights (shared CSM helper)
- * plus a per-pixel loop over every point/spot light in the froxel cluster,
- * each shadow-mapped. The ReSTIR DI variant
- * ({@link chunk_shade_standard_material_direct_restir}) replaces the cluster
- * loop with one resampled, ray-traced sample; the two are selected as separate
- * compiled shaders, not via a runtime branch.
+ * Brute-force deferred direct shading: directional lights (shared CSM helper) plus a per-pixel loop
+ * over every point/spot light in the froxel cluster, each shadow-mapped. The ReSTIR DI variant
+ * ({@link chunk_shade_standard_material_direct_restir}) replaces the cluster loop with one resampled,
+ * ray-traced sample; the two are selected as separate compiled shaders, not via a runtime branch.
+ *
+ * This *is* {@link chunk_shade_standard_material_direct}. The two were separate chunks declaring one
+ * WGSL function name with byte-identical cluster loops, differing only in whether the directional
+ * half called `shade_directional_lights` or re-inlined it. The name is kept because it is public
+ * surface and because it reads next to `_restir` at the deferred pass's selection site.
  *
  * @type {CodeChunk}
  */
 export const chunk_shade_standard_material_direct_heavy: CodeChunk;
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_shade_standard_material_direct_heavy.d.ts.map

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct_heavy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yDAFU,SAAS,CAuFjB;0BAnGwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_standard_material_direct_heavy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,mEAA+F"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js

@@ -1,108 +1,16 @@
-import { chunk_light_cluster_counts } from "../light/cluster/chunk_light_cluster_counts.js";
-import { chunk_light_cluster_metadata_by_position } from "../light/cluster/chunk_light_cluster_metadata_by_position.js";
-import { chunk_get_point_light_info_by_index } from "../shader/chunk/light/io/chunk_get_point_light_info_by_index.js";
-import { chunk_get_spot_light_info_by_index } from "../shader/chunk/light/io/chunk_get_spot_light_info_by_index.js";
-import { REFLECTED_LIGHT_STRUCT } from "../shader/chunk/light/REFLECTED_LIGHT_STRUCT.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 { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
-import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights.js";
-
-/**
- * Brute-force deferred direct shading: directional lights (shared CSM helper)
- * plus a per-pixel loop over every point/spot light in the froxel cluster,
- * each shadow-mapped. The ReSTIR DI variant
- * ({@link chunk_shade_standard_material_direct_restir}) replaces the cluster
- * loop with one resampled, ray-traced sample; the two are selected as separate
- * compiled shaders, not via a runtime branch.
- *
- * @type {CodeChunk}
- */
-export const chunk_shade_standard_material_direct_heavy = CodeChunk.from(
-    //language=WGSL
-    `
-fn shade_standard_material_direct(
-    material: ${MATERIAL_SHADING_INFO_STRUCT.wgsl_ref},
-    geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
-    coord: vec2<f32>,
-    view_depth: f32,
-) -> vec3<f32>{
-
-    var reflected_light : ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
-
-    shade_directional_lights(material, geometry, &reflected_light);
-
-    // Process local lights (point, then spot)
-    let cluster_metadata = light_cluster_metadata_by_position(
-        coord.xy,
-        view_depth,
-        vec2(view.width, view.height)
-    );
-
-    let cluster_offset = cluster_metadata.offset;
-    let point_count = light_cluster_count_point(cluster_metadata.counts);
-    let spot_count = light_cluster_count_spot(cluster_metadata.counts);
-
-    for (var i = 0u; i < point_count; i++) {
-        let light_index = cluster_data[cluster_offset + i];
-
-        var direct_light = get_point_light_info_by_index(&light_data, light_index, geometry.position);
-
-        let visibility = shadowmap_get_point_light_visibility(
-            &light_data,
-            light_index,
-            geometry.position,
-            geometry.shading_normal
-        );
-
-        direct_light.color *= visibility;
-
-        if (all(direct_light.color == vec3(0.0))) {
-            continue;
-        }
-
-        re_direct_physical(direct_light, geometry, material, &reflected_light);
-    }
-
-    for (var j = 0u; j < spot_count; j++) {
-        let light_index = cluster_data[cluster_offset + point_count + j];
-
-        var direct_light = get_spot_light_info_by_index(&light_data, light_index, geometry.position);
-
-        let visibility = shadowmap_get_spot_light_visibility(
-            &light_data,
-            light_index,
-            geometry.position,
-            geometry.shading_normal
-        );
-
-        direct_light.color *= visibility;
-
-        if (all(direct_light.color == vec3(0.0))) {
-            continue;
-        }
-
-        re_direct_physical(direct_light, geometry, material, &reflected_light);
-    }
-
-    var total_emissive_radiance = vec3(material.emissive);
-
-    let outgoing_light = reflected_light.diffuse + reflected_light.specular + total_emissive_radiance;
-
-    return outgoing_light;
-}
-    `, [
-        REFLECTED_LIGHT_STRUCT.declaration_chunk,
-        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
-        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
-        chunk_re_direct_physical,
-        chunk_shade_directional_lights,
-        chunk_light_cluster_metadata_by_position,
-        chunk_light_cluster_counts,
-        chunk_get_point_light_info_by_index,
-        chunk_get_spot_light_info_by_index,
-        chunk_shadowmap_get_light_visibility,
-    ]
-);
+import { chunk_shade_standard_material_direct } from "./chunk_shade_standard_material_direct.js";
+
+/**
+ * Brute-force deferred direct shading: directional lights (shared CSM helper) plus a per-pixel loop
+ * over every point/spot light in the froxel cluster, each shadow-mapped. The ReSTIR DI variant
+ * ({@link chunk_shade_standard_material_direct_restir}) replaces the cluster loop with one resampled,
+ * ray-traced sample; the two are selected as separate compiled shaders, not via a runtime branch.
+ *
+ * This *is* {@link chunk_shade_standard_material_direct}. The two were separate chunks declaring one
+ * WGSL function name with byte-identical cluster loops, differing only in whether the directional
+ * half called `shade_directional_lights` or re-inlined it. The name is kept because it is public
+ * surface and because it reads next to `_restir` at the deferred pass's selection site.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shade_standard_material_direct_heavy = chunk_shade_standard_material_direct;