@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The draw's own group, group 2: the view, the AVBOIT volume, and what every indirect lighting mode
+ * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_DRAW_VIEW_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * AVBOIT draw. See `avboit_draw_fragment_body.js`. One pipeline per template that can be drawn
+ * forward and per switch set: the set picks the indirect lighting the fragment links
+ * (`chunk_forward_sample_indirect`), and the bindings are the same for every set.
+ *
+ * @type {TemplatePassDescriptor}
+ */
+export const shader_avboit_draw: TemplatePassDescriptor;
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { TemplatePassDescriptor } from "../../TemplatePassDescriptor.js";
+//# sourceMappingURL=shader_avboit_draw.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,qCAFU,6BAA6B,CAEmC;AAgC1E;;;;;;GAMG;AACH,iCAFU,sBAAsB,CAmC7B;8CApG2C,2DAA2D;uCAalE,iCAAiC"}

package/src/shade/renderer/rasterize/native/avboit/{shader_avboit_draw_brick4.js → shader_avboit_draw.js}

@@ -12,9 +12,7 @@ import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
-import {
-    chunk_forward_shade_standard_fragment_brick4
-} from "../../forward/chunk_forward_shade_standard_fragment_brick4.js";
+import { chunk_forward_shade_standard_fragment } from "../../forward/chunk_forward_shade_standard_fragment.js";
 import {
     FORWARD_LIGHT_LAYOUT,
     forward_fragment_resources,
@@ -31,16 +29,21 @@ import {
     AVBOIT_DRAW_TARGETS
 } from "./avboit_draw_fragment_body.js";
 
-// Order is load-bearing: the orchestrator's view bind group lists its entries in this sequence.
-// Identical to the IBL variant except for the brick4 buffer after the integral sampler.
-const view_group = new ShaderResourceGroupDescriptor();
+/**
+ * The draw's own group, group 2: the view, the AVBOIT volume, and what every indirect lighting mode
+ * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_DRAW_VIEW_GROUP = new ShaderResourceGroupDescriptor();
 
-view_group
+AVBOIT_DRAW_VIEW_GROUP
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
     // sampled through sLinear below: linear, clamped on every axis, which is what the integral needs
     .addTexture("tIntegral", "float", "3d")
+    // the light map, read under Brick4 indirect lighting
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false)
     .addTexture("tSplitSum", "float")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
@@ -49,39 +52,41 @@ view_group
     .addTexture("tVolumetrics", "float", "3d")
     .addTexture("tSTBN_vec3", "float", "3d")
 
-const pass_groups = [view_group, SHADING_LIGHT_RESOURCE_GROUP];
+const pass_groups = [AVBOIT_DRAW_VIEW_GROUP, SHADING_LIGHT_RESOURCE_GROUP];
 
 // the view group keeps the visibility the orchestrator builds its bind group for, as the vertex stage
 // reads the camera from it; the lights are the fragment stage's alone
 const pass_layouts = [
-    view_group.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    AVBOIT_DRAW_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
     FORWARD_LIGHT_LAYOUT,
 ];
 
 const shader_vertex = ShaderDescriptor.from({
-    label: 'AVBOIT Brick4 / vertex shader',
+    label: 'AVBOIT / vertex shader',
     body: vertex_shader_chunk,
-    resources: forward_vertex_resources([view_group]),
+    resources: forward_vertex_resources([AVBOIT_DRAW_VIEW_GROUP]),
 });
 
 /**
- * AVBOIT draw, Brick4 (sparse volumetric lightmap) indirect lighting. See `avboit_draw_fragment_body.js`.
- * One pipeline per template that can be drawn forward.
+ * AVBOIT draw. See `avboit_draw_fragment_body.js`. One pipeline per template that can be drawn
+ * forward and per switch set: the set picks the indirect lighting the fragment links
+ * (`chunk_forward_sample_indirect`), and the bindings are the same for every set.
  *
  * @type {TemplatePassDescriptor}
  */
-export const shader_avboit_draw_brick4 = new TemplatePassDescriptor("AVBOIT Brick4 / draw", template => {
+export const shader_avboit_draw = new TemplatePassDescriptor("AVBOIT / draw", (template, switches) => {
     const shader_fragment = ShaderDescriptor.from({
-        label: "AVBOIT Brick4 / draw",
+        label: "AVBOIT / draw",
         resources: forward_fragment_resources(template, pass_groups),
         body: CodeChunk.from(AVBOIT_DRAW_FRAGMENT_BODY, [
             ...AVBOIT_DRAW_FRAGMENT_DEPENDENCIES,
-            chunk_forward_shade_standard_fragment_brick4,
+            chunk_forward_shade_standard_fragment,
         ])
-    });
+    }).variant(switches);
 
     return RenderPipelineDescriptor.from({
-        label: "AVBOIT Brick4 / draw",
+        // the variant's, which names the switch values it was built for
+        label: shader_fragment.label,
         layout: forward_pipeline_layout(template, pass_layouts),
         vertex: {
             module: {
@@ -105,11 +110,11 @@ export const shader_avboit_draw_brick4 = new TemplatePassDescriptor("AVBOIT Bric
 });
 
 // the standard template's, for what reads one pipeline: its groups 1 and up are every template's
-shader_avboit_draw_brick4.pipeline = shader_avboit_draw_brick4.template_pipeline_descriptor(STANDARD_MATERIAL_TEMPLATE);
-shader_avboit_draw_brick4.colorAttachments = AVBOIT_DRAW_TARGETS.map(() => RenderPassColorAttachmentDescriptor.from({
+shader_avboit_draw.pipeline = shader_avboit_draw.template_pipeline_descriptor(STANDARD_MATERIAL_TEMPLATE);
+shader_avboit_draw.colorAttachments = AVBOIT_DRAW_TARGETS.map(() => RenderPassColorAttachmentDescriptor.from({
     clearValue: [0, 0, 0, 0],
 }));
 /**
  * Clear depth to 0 for reverse Z technique
  */
-shader_avboit_draw_brick4.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;
+shader_avboit_draw.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js

@@ -4,7 +4,7 @@ import { atomic_u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js"
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { STANDARD_MATERIAL_TEMPLATE } from "../../../material/standard/STANDARD_MATERIAL_TEMPLATE.js";
-import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_F_Schlick } from "../../../shader/chunk/brdf/fresnel/chunk_F_Schlick.js";
 import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_dielectric_specular_color } from "../../../shader/chunk/material/chunk_dielectric_specular_color.js";
@@ -125,7 +125,7 @@ fn main(
         let view_position = mat4_extract_position(camera.transform);
         let view_direction = normalize(view_position - vert.position_ws);
         let nov = saturate(abs(dot(normalize(vert.normal), view_direction)));
-        let f_view = F_Hauber(specular_f0, 1.0, nov);
+        let f_view = F_Schlick(specular_f0, 1.0, nov);
         let f_scalar = max(f_view.r, max(f_view.g, f_view.b));
 
         opacity = mix(surface_alpha, f_scalar, f_transmission);
@@ -158,7 +158,7 @@ fn main(
         chunk_get_view_space_depth,
         chunk_mat4_extract_position,
         chunk_dielectric_specular_color,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
         chunk_avboit_splat_slice,
         chunk_avboit_transmission_tint,
         chunk_avboit_transmittance_to_extinction,

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts

@@ -12,8 +12,9 @@
  * @param {number} light_cluster_lookup
  * @param {number} light_cluster_data
  * @param {number} shadowmap_atlas
- * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
+ *   the set is all the resolve needs to know of the indirect lighting mode
  * @returns {number} resource ID of modified color texture
  */
-export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, indirect_lighting_mode, }: FrameGraph): number;
+export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, shader_switches, }: FrameGraph): number;
 //# sourceMappingURL=graph_rasterize_meshes_transparent_oit.d.ts.map

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AA6ZA;;;;;;;;;;;;;;;;GAgBG;AACH,uSAFa,MAAM,CAyOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAuYA;;;;;;;;;;;;;;;;;GAiBG;AACH,gSAFa,MAAM,CAyOlB"}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js

@@ -5,7 +5,6 @@ import { BindGroupDescriptor } from "../../../binding/BindGroupDescriptor.js";
 import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
 import { TransparencyMode } from "../../../material/TransparencyMode.js";
-import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
 import { graph_image_pass } from "../../../shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "../../../shader/graph/graph_import_texture.js";
@@ -26,8 +25,8 @@ import {
 import { material_draw_indirect } from "../material_draw_indirect.js";
 import { shader_oit_blend } from "./shader_oit_blend.js";
 import { shader_oit_generate_moments } from "./shader_oit_generate_moments.js";
-import { shader_oit_resolve_moments } from "./shader_oit_resolve_moments.js";
-import { shader_oit_resolve_moments_ibl } from "./shader_oit_resolve_moments_ibl.js";
+import { OIT_RESOLVE_VIEW_GROUP, shader_oit_resolve_moments } from "./shader_oit_resolve_moments.js";
+import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 import { FORWARD_LIGHT_LAYOUT } from "../../forward/forward_template_pipeline.js";
 import { SHADING_SCENE_LAYOUT } from "../../forward/SHADING_SCENE_RESOURCE_GROUP.js";
 
@@ -49,7 +48,7 @@ import { SHADING_SCENE_LAYOUT } from "../../forward/SHADING_SCENE_RESOURCE_GROUP
  * @param {number} shadowmap_atlas
  * @param {number} output
  * @param {PrimitiveState} primitive
- * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @param {ShaderSwitchSet} shader_switches the renderer's; the resolve's pipelines are built for them
  * @return {number}
  */
 function graph_oit_resolve_moments({
@@ -74,7 +73,7 @@ function graph_oit_resolve_moments({
                                        volumetrics_metadata,
 
                                        output = -1,
-                                       indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
+                                       shader_switches = ShaderSwitchSet.EMPTY,
                                    }) {
 
     assert.isNonNegativeInteger(material_count, 'material_count');
@@ -146,11 +145,7 @@ function graph_oit_resolve_moments({
             ]
         ));
 
-        // Select render pass descriptor based on indirect lighting mode
-        const use_brick4 = data.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4;
-        const render_pass_descriptor = use_brick4
-            ? shader_oit_resolve_moments
-            : shader_oit_resolve_moments_ibl;
+        const render_pass_descriptor = shader_oit_resolve_moments.variant(data.shader_switches);
 
         const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
             colorTargets: [t_resolved],
@@ -171,39 +166,22 @@ function graph_oit_resolve_moments({
 
         const stbn_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-        // Brick4 variant requires brick4 buffer in the view bind group;
-        // IBL variant does not. Volumetrics bindings are appended last (after sLinear), matching
-        // the order declared in shader_oit_resolve_moments[_ibl].
-        const view_bind_entries = use_brick4
-            ? [
-                { buffer: view_ctx.camera.buffer.buffer },
-                { buffer: view_ctx.uniform_buffer.buffer },
-                t_moments.obtainView(),
-                t_optical_depth.obtainView(),
-                { buffer: view_ctx.scene.volumetric_light_map.buffer },
-                t_split_sum_lut.obtainView(),
-                sampler_linear,
-                // volumetrics
-                { buffer: volumetrics_metadata },
-                t_volumetrics_lut.obtainView(),
-                stbn_vec3.obtainView(),
-            ]
-            : [
-                { buffer: view_ctx.camera.buffer.buffer },
-                { buffer: view_ctx.uniform_buffer.buffer },
-                t_moments.obtainView(),
-                t_optical_depth.obtainView(),
-                t_split_sum_lut.obtainView(),
-                sampler_linear,
-                // volumetrics
-                { buffer: volumetrics_metadata },
-                t_volumetrics_lut.obtainView(),
-                stbn_vec3.obtainView(),
-            ];
-
+        // by name: every indirect lighting mode's resources, whichever the pipeline's variant reads
         const view_bindings = bind_manager.obtain(BindGroupDescriptor.from(
-            render_pass_descriptor.pipeline.layout.bindGroupLayouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
-            view_bind_entries
+            render_pass_descriptor.pipeline_layout.bindGroupLayouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
+            OIT_RESOLVE_VIEW_GROUP.generateBindings({
+                camera: view_ctx.camera.buffer.buffer,
+                view: view_ctx.uniform_buffer.buffer,
+                moments: t_moments,
+                optical_depth: t_optical_depth,
+                brick4: view_ctx.scene.volumetric_light_map.buffer,
+                tSplitSum: t_split_sum_lut,
+                sLinear: sampler_linear,
+                // volumetrics
+                volumetrics_metadata,
+                tVolumetrics: t_volumetrics_lut,
+                tSTBN_vec3: stbn_vec3,
+            }, encoder)
         ));
 
         pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
@@ -224,7 +202,7 @@ function graph_oit_resolve_moments({
     }
 
     const pass_data = {
-        indirect_lighting_mode,
+        shader_switches,
     };
     const pass = graph.add("MBOIT/resolve moments", pass_data, execute);
 
@@ -425,7 +403,8 @@ function graph_oit_generate_moments({
  * @param {number} light_cluster_lookup
  * @param {number} light_cluster_data
  * @param {number} shadowmap_atlas
- * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
+ *   the set is all the resolve needs to know of the indirect lighting mode
  * @returns {number} resource ID of modified color texture
  */
 export function graph_rasterize_meshes_transparent_oit({
@@ -445,7 +424,7 @@ export function graph_rasterize_meshes_transparent_oit({
                                                            volumetrics_lut,
                                                            volumetrics_metadata,
 
-                                                           indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
+                                                           shader_switches = ShaderSwitchSet.EMPTY,
                                                        }) {
 
 
@@ -615,7 +594,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_lut,
         volumetrics_metadata,
 
-        indirect_lighting_mode,
+        shader_switches,
     });
 
     resolved = graph_oit_resolve_moments({
@@ -642,7 +621,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_lut,
         volumetrics_metadata,
 
-        indirect_lighting_mode,
+        shader_switches,
     });
 
     const [blended] = graph_image_pass({

package/src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.d.ts

@@ -1,13 +1,17 @@
 /**
- * The fragment stage of the MBOIT resolve pass, shared verbatim by the IBL and Brick4 pipelines
- * (`shader_oit_resolve_moments_ibl`, `shader_oit_resolve_moments`), which differ only in which
- * `forward_shade_standard_fragment` they link and in one storage buffer in the view group.
+ * The most point lights, and separately spot lights, of a fragment's cluster cell the MBOIT resolve shades.
+ * Every transparent layer over a pixel pays it. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const OIT_RESOLVE_LIGHT_BUDGET: number;
+/**
+ * The fragment stage of the MBOIT resolve pass (`shader_oit_resolve_moments`), which links it with
+ * `forward_shade_standard_fragment`; the indirect lighting mode is a shader switch inside that.
  *
- * `diff` over the two files used to report differences on exactly those two imports, that one bind
- * entry and five label strings — the ~110 lines of WGSL were character-identical. Only one of the two
- * runs at a time, whichever `indirect_lighting_mode` selects, so a fix landing in one and not the other
- * had nothing to make it visible. The `c[2] -> 0` guard, the NaN backstop and the coverage clamp all
- * live in here now.
+ * It once ran in two pipelines, one per indirect lighting mode, whose files `diff` reported as
+ * differing in two imports, one bind entry and five label strings — the ~110 lines of WGSL were
+ * character-identical. Only one ran at a time, so a fix landing in one and not the other had nothing
+ * to make it visible. The `c[2] -> 0` guard, the NaN backstop and the coverage clamp all live in here.
  *
  * Same arrangement as `avboit_draw_fragment_body.js`, which reached it first: the body is a literal
  * WGSL string and the dependencies a list, so neither is generated or templated — the caller adds its

package/src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oit_resolve_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,wCAFU,MAAM,CA4DN;AAEV;;;;;GAKG;AACH,gDAFU,WAAW,CAQnB;AAEF;;;;;GAKG;AACH,kCAFU,qBAAqB,CAkB7B"}
+{"version":3,"file":"oit_resolve_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;GAcG;AACH,wCAFU,MAAM,CA4DN;AAEV;;;;;GAKG;AACH,gDAFU,WAAW,CAQnB;AAEF;;;;;GAKG;AACH,kCAFU,qBAAqB,CAkB7B"}

package/src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.js

@@ -1,123 +1,128 @@
-import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
-import {
-    chunk_resolve_power_moments_4
-} from "../../../shader/chunk/mboit/moments/power/chunk_resolve_power_moments_4.js";
-import { chunk_unjitter_uv } from "../../../shader/chunk/texture/chunk_unjitter_uv.js";
-import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
-import { chunk_oit_linearize_depth } from "./chunk_oit_linearize_depth.js";
-import { OIT_COVERAGE_MAX } from "./OIT_CONSTANTS.js";
-
-/**
- * The fragment stage of the MBOIT resolve pass, shared verbatim by the IBL and Brick4 pipelines
- * (`shader_oit_resolve_moments_ibl`, `shader_oit_resolve_moments`), which differ only in which
- * `forward_shade_standard_fragment` they link and in one storage buffer in the view group.
- *
- * `diff` over the two files used to report differences on exactly those two imports, that one bind
- * entry and five label strings — the ~110 lines of WGSL were character-identical. Only one of the two
- * runs at a time, whichever `indirect_lighting_mode` selects, so a fix landing in one and not the other
- * had nothing to make it visible. The `c[2] -> 0` guard, the NaN backstop and the coverage clamp all
- * live in here now.
- *
- * Same arrangement as `avboit_draw_fragment_body.js`, which reached it first: the body is a literal
- * WGSL string and the dependencies a list, so neither is generated or templated — the caller adds its
- * shading chunk to the list and links it.
- *
- * @type {string}
- */
-export const OIT_RESOLVE_FRAGMENT_BODY =
-    //language=WGSL
-    `
-@fragment
-fn main(
-    @builtin(front_facing) front_facing : bool,
-    vert: ${FORWARD_VERTEX_SHADER_STRUCT.wgsl_ref},
-) -> @location(0) vec4<f32>{
-
-    let coord_u = vec2u(vert.position.xy);
-
-    // this is total absorbance
-    let b_0 = textureLoad(optical_depth, coord_u, 0).r;
-
-    if(b_0 < 0.00100050033f){
-        // indicates that pixel has no opacity
-        // would result in division by 0
-        discard;
-    }
-
-    // need to unjitter UV to account for TAA
-    var vert_adjusted = vert;
-    vert_adjusted.uv = unjitter_uv(vert.uv, view.jitter);
-
-    let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing);
-
-    // composite volumetric fog between the camera and this transparent fragment. Use the linear
-    // view-space depth from the fragment's device depth (vert.position is @builtin(position), so
-    // .z is the device depth — the same metric the opaque path feeds the froxel lookup). NOT
-    // oit_linearize_depth, which returns a normalized [0,1] log-depth for the moment warp and would
-    // collapse every fragment onto a near slice (no fog).
-    let frag_view_depth = get_view_space_depth(vert_adjusted.position.z, camera);
-    let frag_screen_uv = vert_adjusted.position.xy / vec2<f32>(f32(view.width), f32(view.height));
-    let volumetrics = sample_volumetrics(frag_view_depth, frag_screen_uv, vert_adjusted.position.xy);
-
-    let color = shaded.rgb * volumetrics.w + volumetrics.xyz;
-    let opacity = shaded.a;
-
-    // if opacity is 1 - we end up with 0 transmittance, which breaks the algorithm
-    let coverage = min(opacity, ${OIT_COVERAGE_MAX});
-
-    let total_moments1234 = textureLoad(moments, coord_u, 0);
-
-    // linear distance to fragment (vert_adjusted.position is @builtin(position); .z is device depth)
-    let depth = oit_linearize_depth(vert_adjusted.position.z, camera);
-
-    let transmittance = resolve_power_moments_4(
-        depth,
-        b_0,
-        total_moments1234,
-    );
-
-    return vec4(
-        color * coverage, // premultiply
-        coverage
-    ) * transmittance;
-
-}
-        `;
-
-/**
- * Everything {@link OIT_RESOLVE_FRAGMENT_BODY} needs except the shading chunk, which is the one thing
- * the two pipelines choose differently.
- *
- * @type {CodeChunk[]}
- */
-export const OIT_RESOLVE_FRAGMENT_DEPENDENCIES = [
-    FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
-    chunk_resolve_power_moments_4,
-    chunk_oit_linearize_depth,
-    chunk_unjitter_uv,
-    chunk_sample_volumetrics,
-];
-
-/**
- * The single HDR colour target both resolve pipelines write, additively — the resolve sums one
- * premultiplied contribution per transparent fragment, which is what makes it order-independent.
- *
- * @type {GPUColorTargetState[]}
- */
-export const OIT_RESOLVE_TARGETS = [
-    {
-        format: "rgba16float",
-        blend: {
-            color: {
-                operation: "add",
-                srcFactor: "one",
-                dstFactor: "one",
-            },
-            alpha: {
-                operation: "add",
-                srcFactor: "one",
-                dstFactor: "one",
-            }
-        }
-    }
-];
+import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
+import {
+    chunk_resolve_power_moments_4
+} from "../../../shader/chunk/mboit/moments/power/chunk_resolve_power_moments_4.js";
+import { chunk_unjitter_uv } from "../../../shader/chunk/texture/chunk_unjitter_uv.js";
+import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
+import { chunk_oit_linearize_depth } from "./chunk_oit_linearize_depth.js";
+import { OIT_COVERAGE_MAX } from "./OIT_CONSTANTS.js";
+
+/**
+ * The most point lights, and separately spot lights, of a fragment's cluster cell the MBOIT resolve shades.
+ * Every transparent layer over a pixel pays it. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const OIT_RESOLVE_LIGHT_BUDGET = 32;
+
+/**
+ * The fragment stage of the MBOIT resolve pass (`shader_oit_resolve_moments`), which links it with
+ * `forward_shade_standard_fragment`; the indirect lighting mode is a shader switch inside that.
+ *
+ * It once ran in two pipelines, one per indirect lighting mode, whose files `diff` reported as
+ * differing in two imports, one bind entry and five label strings — the ~110 lines of WGSL were
+ * character-identical. Only one ran at a time, so a fix landing in one and not the other had nothing
+ * to make it visible. The `c[2] -> 0` guard, the NaN backstop and the coverage clamp all live in here.
+ *
+ * Same arrangement as `avboit_draw_fragment_body.js`, which reached it first: the body is a literal
+ * WGSL string and the dependencies a list, so neither is generated or templated — the caller adds its
+ * shading chunk to the list and links it.
+ *
+ * @type {string}
+ */
+export const OIT_RESOLVE_FRAGMENT_BODY =
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(front_facing) front_facing : bool,
+    vert: ${FORWARD_VERTEX_SHADER_STRUCT.wgsl_ref},
+) -> @location(0) vec4<f32>{
+
+    let coord_u = vec2u(vert.position.xy);
+
+    // this is total absorbance
+    let b_0 = textureLoad(optical_depth, coord_u, 0).r;
+
+    if(b_0 < 0.00100050033f){
+        // indicates that pixel has no opacity
+        // would result in division by 0
+        discard;
+    }
+
+    // need to unjitter UV to account for TAA
+    var vert_adjusted = vert;
+    vert_adjusted.uv = unjitter_uv(vert.uv, view.jitter);
+
+    let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing, ${OIT_RESOLVE_LIGHT_BUDGET}u, ${OIT_RESOLVE_LIGHT_BUDGET}u);
+
+    // composite volumetric fog between the camera and this transparent fragment. Use the linear
+    // view-space depth from the fragment's device depth (vert.position is @builtin(position), so
+    // .z is the device depth — the same metric the opaque path feeds the froxel lookup). NOT
+    // oit_linearize_depth, which returns a normalized [0,1] log-depth for the moment warp and would
+    // collapse every fragment onto a near slice (no fog).
+    let frag_view_depth = get_view_space_depth(vert_adjusted.position.z, camera);
+    let frag_screen_uv = vert_adjusted.position.xy / vec2<f32>(f32(view.width), f32(view.height));
+    let volumetrics = sample_volumetrics(frag_view_depth, frag_screen_uv, vert_adjusted.position.xy);
+
+    let color = shaded.rgb * volumetrics.w + volumetrics.xyz;
+    let opacity = shaded.a;
+
+    // if opacity is 1 - we end up with 0 transmittance, which breaks the algorithm
+    let coverage = min(opacity, ${OIT_COVERAGE_MAX});
+
+    let total_moments1234 = textureLoad(moments, coord_u, 0);
+
+    // linear distance to fragment (vert_adjusted.position is @builtin(position); .z is device depth)
+    let depth = oit_linearize_depth(vert_adjusted.position.z, camera);
+
+    let transmittance = resolve_power_moments_4(
+        depth,
+        b_0,
+        total_moments1234,
+    );
+
+    return vec4(
+        color * coverage, // premultiply
+        coverage
+    ) * transmittance;
+
+}
+        `;
+
+/**
+ * Everything {@link OIT_RESOLVE_FRAGMENT_BODY} needs except the shading chunk, which is the one thing
+ * the two pipelines choose differently.
+ *
+ * @type {CodeChunk[]}
+ */
+export const OIT_RESOLVE_FRAGMENT_DEPENDENCIES = [
+    FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
+    chunk_resolve_power_moments_4,
+    chunk_oit_linearize_depth,
+    chunk_unjitter_uv,
+    chunk_sample_volumetrics,
+];
+
+/**
+ * The single HDR colour target both resolve pipelines write, additively — the resolve sums one
+ * premultiplied contribution per transparent fragment, which is what makes it order-independent.
+ *
+ * @type {GPUColorTargetState[]}
+ */
+export const OIT_RESOLVE_TARGETS = [
+    {
+        format: "rgba16float",
+        blend: {
+            color: {
+                operation: "add",
+                srcFactor: "one",
+                dstFactor: "one",
+            },
+            alpha: {
+                operation: "add",
+                srcFactor: "one",
+                dstFactor: "one",
+            }
+        }
+    }
+];