@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/rasterize/forward/{chunk_forward_shade_standard_fragment_brick4.js → chunk_forward_shade_standard_fragment.js}

@@ -1,13 +1,9 @@
 import { chunk_shade_standard_material_direct } from "../../deferred/chunk_shade_standard_material_direct.js";
-import { chunk_material_draw_side } from "../../material/chunk_material_draw_side.js";
-import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
-import {
-    chunk_brick4_sample_forward_indirect
-} from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
 import { BSDF_ROUGHNESS_MINIMUM } from "../../light/environment/DEFINES.js";
+import { chunk_material_draw_side } from "../../material/chunk_material_draw_side.js";
 import { chunk_compute_specular_occlusion } from "../../shader/chunk/brdf/chunk_compute_specular_occlusion.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 {
@@ -16,6 +12,7 @@ import {
 import {
     chunk_build_orthonormal_matrix_nt
 } from "../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_nt.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import {
     chunk_compute_indirect_specular
 } from "../../shader/chunk/material/chunk_compute_indirect_specular.js";
@@ -25,39 +22,61 @@ import {
 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_forward_sample_indirect } from "./chunk_forward_sample_indirect.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "./FORWARD_VERTEX_SHADER_STRUCT.js";
-
-export const chunk_forward_shade_standard_fragment_brick4 = CodeChunk.from(
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import {
+    MATERIAL_DIFFUSE_SAMPLER_RESOURCE,
+    MATERIAL_DIFFUSE_TEXTURE_RESOURCE,
+    MATERIAL_EMISSIVE_SAMPLER_RESOURCE,
+    MATERIAL_EMISSIVE_TEXTURE_RESOURCE,
+    MATERIAL_INFO_RESOURCE,
+    MATERIAL_NORMAL_SAMPLER_RESOURCE,
+    MATERIAL_NORMAL_TEXTURE_RESOURCE,
+    MATERIAL_ORM_SAMPLER_RESOURCE,
+    MATERIAL_ORM_TEXTURE_RESOURCE
+} from "../../material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
+
+/**
+ * Forward shading of a standard material: the clustered direct lights, then the indirect light the
+ * renderer's mode supplies through {@link chunk_forward_sample_indirect}. Linked by the transparent
+ * passes (the AVBOIT draw and the MBOIT resolve), which bind every mode's indirect resources and get
+ * one mode's sampling per pipeline. `point_budget` and `spot_budget` are the linking pass's light
+ * budgets, handed to {@link chunk_shade_standard_material_direct}.
+ */
+export const chunk_forward_shade_standard_fragment = CodeChunk.from(
     //language=WGSL
     `
 fn forward_shade_standard_fragment(
     vert: ${FORWARD_VERTEX_SHADER_STRUCT.wgsl_ref},
     front_facing: bool,
+    point_budget: u32,
+    spot_budget: u32,
 ) -> vec4f {
     let world_tangent_frame = build_orthonormal_matrix_nt(vert.normal, vert.tangent);
-    
+
     let t_normal = decode_tangent_normal(textureSample(texture_normal, texture_normal_sampler, vert.uv));
     var world_shading_normal:vec3<f32> = normalize( world_tangent_frame * t_normal );
-    
+
     // flip the normal when looking at the surface's back. The raw front_facing cannot say:
     // a back-sided material emits its winding reversed on purpose, so its "front" faces
     // are the surface's back.
     if(!material_fragment_faces_front(front_facing, material_info.draw_side)) {
         world_shading_normal = -world_shading_normal;
     }
-    
+
     let position_ws = vert.position_ws;
-    
+
     let view_position = mat4_extract_position(camera.transform);
     let view_direction = normalize(view_position - position_ws);
-    
+
     let geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.make({
         shading_normal: 'world_shading_normal',
         geometric_normal: 'world_shading_normal',
         position: 'position_ws',
         view_direction: 'view_direction',
     })};
-    
+
     let t_pbr = textureSample(texture_orm, texture_orm_sampler, vert.uv);
     let t_diffuse = textureSample(texture_diffuse, texture_diffuse_sampler, vert.uv);
     let t_emissive = textureSample(texture_emissive, texture_emissive_sampler, vert.uv);
@@ -85,22 +104,18 @@ fn forward_shade_standard_fragment(
 
     let surface_alpha = t_diffuse.a * material_info.albedo_color.a;
 
-    // IOR-aware F0 (default ior=1.5 gives the legacy F0=0.04 dielectric).
-    // F0 is built from the unmultiplied diffuse so metals carry the right tint
-    // (the prior call passed already-substrate-scaled albedo here, which
-    // collapsed metal F0 to zero — silently broken for any transparent metal).
+    // IOR-aware F0 (default ior=1.5 collapses to the legacy F0=0.04), built from the
+    // unmultiplied diffuse so that metals carry their tint.
     let specularF0 = dielectric_specular_color(f_ior, f_metalness, diffuse);
     // the two F0s it blends, apart for multiple-scattering compensation
     let specularF0_dielectric = dielectric_specular_color(f_ior, 0.0, diffuse);
 
     // Glass coverage: blend toward view-angle Fresnel as transmission_factor
-    // approaches 1. There is no per-channel transmission tint in the material
-    // today — scalar MBOIT can't filter the background per-channel without
-    // tripling the moments cost. For tinted/dark glass, use the legacy
-    // alpha-blend authoring path (transparency_mode = Transparent,
-    // diffuse_color.a < 1).
+    // approaches 1. No per-channel transmission tint in the material today;
+    // for tinted/dark glass use the legacy alpha-blend authoring path
+    // (transparency_mode = Transparent, diffuse_color.a < 1).
     let NoV_alpha = saturate( dot(world_shading_normal, view_direction) );
-    let F_view = F_Hauber(specularF0, 1.0, NoV_alpha);
+    let F_view = F_Schlick(specularF0, 1.0, NoV_alpha);
     let F_scalar = max(F_view.r, max(F_view.g, F_view.b));
     let opacity = mix(surface_alpha, F_scalar, f_transmission);
 
@@ -122,21 +137,22 @@ fn forward_shade_standard_fragment(
         material,
         geometry,
         vert.position.xy,
-        view_depth
+        view_depth,
+        point_budget,
+        spot_budget,
     );
 
-    // do indirect
+    // do indirect, from the renderer's indirect lighting mode
     {
         const INDIRECT_INTENSITY = ${INDIRECT_LIGHT_INTENSITY};
 
         var radiance: vec3f;
         var irradiance: vec3f;
 
-        brick4_sample_forward_indirect(
+        forward_sample_indirect(
             geometry.position,
             geometry.view_direction,
             geometry.shading_normal,
-            geometry.shading_normal,
             material.roughness,
             &radiance,
             &irradiance,
@@ -156,13 +172,13 @@ fn forward_shade_standard_fragment(
         );
 
         // apply AO
-        let indirect_diffuse = indirect[0] * material.occlusion;
+        let indirect_diffuse = indirect[1] * material.occlusion;
         let NoV = saturate( dot(geometry.shading_normal, geometry.view_direction) );
         // NOTE: deferred uses compute_specular_occlusion_bn (bent-normal cone-cone overlap), but
         // forward paths only have a per-material AO scalar — no bent-normal texture per material
         // (and none planned). The NoV/AO scalar approximation remains the right call here.
         let specular_occlusion = compute_specular_occlusion( NoV, material.occlusion, material.roughness );
-        let indirect_specular = indirect[1] * specular_occlusion;
+        let indirect_specular = indirect[0] * specular_occlusion;
 
         let indirect_total = INDIRECT_INTENSITY * ( indirect_diffuse + indirect_specular );
 
@@ -178,15 +194,26 @@ fn forward_shade_standard_fragment(
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_mat4_extract_position,
         chunk_dielectric_specular_color,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
         chunk_build_orthonormal_matrix_nt,
         chunk_decode_tangent_normal,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_shade_standard_material_direct,
         chunk_get_view_space_depth,
         chunk_compute_indirect_specular,
-        chunk_brick4_sample_forward_indirect,
+        chunk_forward_sample_indirect,
         chunk_compute_specular_occlusion,
         chunk_material_draw_side,
     ]
-)
+)
+
+chunk_forward_shade_standard_fragment.requireResource(CAMERA_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_INFO_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_DIFFUSE_TEXTURE_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_DIFFUSE_SAMPLER_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_EMISSIVE_TEXTURE_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_EMISSIVE_SAMPLER_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_NORMAL_TEXTURE_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_NORMAL_SAMPLER_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_ORM_TEXTURE_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(MATERIAL_ORM_SAMPLER_RESOURCE);

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

@@ -36,8 +36,8 @@
 export type AVBOITSideChannel = {
     /**
      * Optional optics preparation before occupancy; at most one producer per view. Inputs are
-     * immutable opaque resources; the light clusters, the shadow atlas, the GI mode and the shader
-     * switches are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
+     * immutable opaque resources; the light clusters, the shadow atlas and the shader switches (the
+     * indirect lighting mode among them) are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
      * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
      */
     avboit_prepare?: (args: {
@@ -53,7 +53,6 @@ export type AVBOITSideChannel = {
         light_cluster_lookup: number;
         light_cluster_data: number;
         shadowmap_atlas: number;
-        indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
         shader_switches: import("../../../shader/compiler/ShaderSwitchSet.js").ShaderSwitchSet;
     }) => {
         background_color?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;QACxG,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;KAC1F,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;KAC1F,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

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

@@ -40,12 +40,11 @@
  *     hzb_texture: number, environment_texture: number,
  *     light_cluster_parameters: number, light_cluster_lookup: number, light_cluster_data: number,
  *     shadowmap_atlas: number,
- *     indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode,
  *     shader_switches: import("../../../shader/compiler/ShaderSwitchSet.js").ShaderSwitchSet,
  * }) => {background_color?: number}} [avboit_prepare]
  *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
- *     immutable opaque resources; the light clusters, the shadow atlas, the GI mode and the shader
- *     switches are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
+ *     immutable opaque resources; the light clusters, the shadow atlas and the shader switches (the
+ *     indirect lighting mode among them) are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
  *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,

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

@@ -1,8 +1,13 @@
 /**
- * The fragment stage of the AVBOIT draw pass, shared verbatim by the IBL and Brick4 pipelines
- * (`shader_avboit_draw_ibl`, `shader_avboit_draw_brick4`), which differ only in which
- * `forward_shade_standard_fragment` they link and in one storage buffer in the view group. Same
- * arrangement as the two MBOIT resolve shaders, with the body held in one place.
+ * The most point lights, and separately spot lights, of a fragment's cluster cell the AVBOIT draw 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 AVBOIT_DRAW_LIGHT_BUDGET: number;
+/**
+ * The fragment stage of the AVBOIT draw pass (`shader_avboit_draw`), which links it with
+ * `forward_shade_standard_fragment`; the indirect lighting mode is a shader switch inside that. Same
+ * arrangement as the MBOIT resolve, with the body held in one place.
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,

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

@@ -1 +1 @@
-{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,MAAM,CAoEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CAWnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}
+{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wCAFU,MAAM,CAoEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CAWnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}

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

@@ -10,10 +10,16 @@ import { chunk_avboit_sample_transmittance } from "./chunk_avboit_sample_transmi
 import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint.js";
 
 /**
- * The fragment stage of the AVBOIT draw pass, shared verbatim by the IBL and Brick4 pipelines
- * (`shader_avboit_draw_ibl`, `shader_avboit_draw_brick4`), which differ only in which
- * `forward_shade_standard_fragment` they link and in one storage buffer in the view group. Same
- * arrangement as the two MBOIT resolve shaders, with the body held in one place.
+ * The most point lights, and separately spot lights, of a fragment's cluster cell the AVBOIT draw 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 AVBOIT_DRAW_LIGHT_BUDGET = 32;
+
+/**
+ * The fragment stage of the AVBOIT draw pass (`shader_avboit_draw`), which links it with
+ * `forward_shade_standard_fragment`; the indirect lighting mode is a shader switch inside that. Same
+ * arrangement as the MBOIT resolve, with the body held in one place.
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,
@@ -78,7 +84,7 @@ fn main(
         discard;
     }
 
-    let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing);
+    let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing, ${AVBOIT_DRAW_LIGHT_BUDGET}u, ${AVBOIT_DRAW_LIGHT_BUDGET}u);
 
     // composite volumetric fog between the camera and this fragment
     let volumetrics = sample_volumetrics(frag_view_depth, frag_screen_uv, vert_adjusted.position.xy);

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

@@ -104,11 +104,10 @@ export function graph_avboit_integrate({ graph, warp, extinction, overflow, voxe
  * @param {number} volumetrics_lut
  * @param {number} volumetrics_metadata
  * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
- * @param {ShadeIndirectLightingMode} indirect_lighting_mode
  * @param {ShaderSwitchSet} shader_switches the renderer's; the draw's pipelines are built for them
  * @returns {{color: number, norm: number, extinction: number}}
  */
-export function graph_avboit_draw({ graph, view_ctx, material_count, materials, draw_commands, meshlets, depth_texture, warp, integral, primitive, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, accumulators, indirect_lighting_mode, shader_switches, }: FrameGraph): {
+export function graph_avboit_draw({ graph, view_ctx, material_count, materials, draw_commands, meshlets, depth_texture, warp, integral, primitive, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, accumulators, shader_switches, }: FrameGraph): {
     color: number;
     norm: number;
     extinction: number;
@@ -159,15 +158,15 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  * @param {{Y: number, CoCg: number}} options.volumetrics_irradiance the froxel irradiance volume
  *   (`chunk_volumetrics_irradiance_sh`), for side channels that light their own fragments; the
  *   MBOIT orchestrator ignores it
- * @param {ShadeIndirectLightingMode} options.indirect_lighting_mode
  * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; every pipeline that lights a fragment is
- *   built for them, the side channels' included
+ *   built for them, the side channels' included, and the set is all a pass needs to know of the
+ *   indirect lighting mode
  * @param {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, indirect_lighting_mode, shader_switches, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, shader_switches, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;
@@ -185,12 +184,10 @@ export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view
         Y: number;
         CoCg: number;
     };
-    indirect_lighting_mode: ShadeIndirectLightingMode;
     shader_switches?: ShaderSwitchSet;
     avboit?: AVBOITSettings;
     side_channels?: import("./AVBOITSideChannel.js").AVBOITSideChannel[];
 }): number;
 import { AVBOITSettings } from "./AVBOITSettings.js";
-import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
 import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=graph_rasterize_meshes_transparent_avboit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sVAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA0N7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAxB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGU,sBAAsB,EAAzD,yBAAyB;IACC,eAAe,GAAzC,eAAe;IAEU,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAoTlB;+BAl+B8B,qBAAqB;0CA9BV,uCAAuC;gCAmCjD,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA2DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8TAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAqM7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAxB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGU,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAkTlB;+BAz8B8B,qBAAqB;gCAIpB,6CAA6C"}

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

@@ -6,7 +6,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_compute_pass } from "../../../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../../../shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
@@ -39,8 +38,7 @@ import { avboit_build_depth_curve } from "./avboit_build_depth_curve.js";
 import { AVBOITSettings } from "./AVBOITSettings.js";
 import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
 import { AVBOIT_BUILD_WARP_SETTINGS_STRUCT, shader_avboit_build_warp } from "./shader_avboit_build_warp.js";
-import { shader_avboit_draw_brick4 } from "./shader_avboit_draw_brick4.js";
-import { shader_avboit_draw_ibl } from "./shader_avboit_draw_ibl.js";
+import { AVBOIT_DRAW_VIEW_GROUP, shader_avboit_draw } from "./shader_avboit_draw.js";
 import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 import { shader_avboit_integrate } from "./shader_avboit_integrate.js";
 import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT, shader_avboit_occupancy } from "./shader_avboit_occupancy.js";
@@ -439,7 +437,6 @@ export function graph_avboit_integrate({
  * @param {number} volumetrics_lut
  * @param {number} volumetrics_metadata
  * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
- * @param {ShadeIndirectLightingMode} indirect_lighting_mode
  * @param {ShaderSwitchSet} shader_switches the renderer's; the draw's pipelines are built for them
  * @returns {{color: number, norm: number, extinction: number}}
  */
@@ -461,7 +458,6 @@ export function graph_avboit_draw({
                                       volumetrics_lut,
                                       volumetrics_metadata,
                                       accumulators,
-                                      indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                                       shader_switches = ShaderSwitchSet.EMPTY,
                                   }) {
 
@@ -538,10 +534,7 @@ export function graph_avboit_draw({
             ]
         ));
 
-        const use_brick4 = data.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4;
-        const render_pass_descriptor = (use_brick4
-            ? shader_avboit_draw_brick4
-            : shader_avboit_draw_ibl).variant(data.shader_switches);
+        const render_pass_descriptor = shader_avboit_draw.variant(data.shader_switches);
 
         const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
             colorTargets: [t_color, t_norm, t_extinction, t_emission],
@@ -563,38 +556,22 @@ export function graph_avboit_draw({
         const t_split_sum_lut = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.split_sum);
         const stbn_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-        // Entry order matches the view group declared in shader_avboit_draw_ibl / _brick4; the
-        // Brick4 variant carries its lightmap buffer right after the integral texture.
-        const view_bind_entries = use_brick4
-            ? [
-                { buffer: view_ctx.camera.buffer.buffer },
-                { buffer: view_ctx.uniform_buffer.buffer },
-                { buffer: warp_buffer },
-                t_integral.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 },
-                { buffer: warp_buffer },
-                t_integral.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
+            AVBOIT_DRAW_VIEW_GROUP.generateBindings({
+                camera: view_ctx.camera.buffer.buffer,
+                view: view_ctx.uniform_buffer.buffer,
+                warp: warp_buffer,
+                tIntegral: t_integral,
+                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);
@@ -614,7 +591,6 @@ export function graph_avboit_draw({
     }
 
     const pass_data = {
-        indirect_lighting_mode,
         shader_switches,
         clear_targets: accumulators === undefined,
     };
@@ -716,9 +692,9 @@ export function avboit_create_accumulators(pass, resolution) {
  * @param {{Y: number, CoCg: number}} options.volumetrics_irradiance the froxel irradiance volume
  *   (`chunk_volumetrics_irradiance_sh`), for side channels that light their own fragments; the
  *   MBOIT orchestrator ignores it
- * @param {ShadeIndirectLightingMode} options.indirect_lighting_mode
  * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; every pipeline that lights a fragment is
- *   built for them, the side channels' included
+ *   built for them, the side channels' included, and the set is all a pass needs to know of the
+ *   indirect lighting mode
  * @param {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
@@ -745,7 +721,6 @@ export function graph_rasterize_meshes_transparent_avboit({
                                                               volumetrics_metadata,
                                                               volumetrics_irradiance,
 
-                                                              indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                                                               shader_switches = ShaderSwitchSet.EMPTY,
                                                               avboit = DEFAULT_SETTINGS,
                                                               side_channels = [],
@@ -840,7 +815,7 @@ export function graph_rasterize_meshes_transparent_avboit({
     for (const channel of preparers) {
         const prepared = channel.avboit_prepare({ graph, view_ctx, camera: gr_camera, color_texture,
             depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture, light_cluster_parameters,
-            light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode, shader_switches });
+            light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches });
         if (prepared?.background_color !== undefined) {
             assert.isNonNegativeInteger(prepared.background_color, 'prepared.background_color');
             background_color = prepared.background_color;
@@ -965,7 +940,6 @@ export function graph_rasterize_meshes_transparent_avboit({
         shadowmap_atlas,
         volumetrics_lut,
         volumetrics_metadata,
-        indirect_lighting_mode,
         shader_switches,
     };
 

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,34 +52,35 @@ 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, switches) => {
+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);
 
@@ -106,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;