@woosh/meep-engine 3.34.0 → 3.35.0

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js

@@ -1,185 +1,190 @@
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_sample_volumetrics } from "../../deferred/chunk_sample_volumetrics.js";
-import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
-import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
-import { AVBOIT_DRAW_TARGETS } from "../../rasterize/native/avboit/avboit_draw_fragment_body.js";
-import { chunk_avboit_sample_transmittance } from "../../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.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 { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
-import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
-import { chunk_particle_avboit_contribution } from "./chunk_particle_avboit_contribution.js";
-import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
-import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
-import { chunk_particle_lighting_unlit } from "./chunk_particle_lighting.js";
-
-/**
- * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
- * opaque scene, into the four accumulators the transparent meshes draw into
- * (`avboit_draw_fragment_body`). The particle counterpart of `shader_avboit_draw_ibl`.
- *
- * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
- * depth and the lighting hook, the volumetric fog composite exactly as the mesh draw applies it,
- * then the transmittance of everything in front from the integral texture — and a fragment the
- * volume already calls extinct is discarded unshaded.
- *
- * What is written depends on how the particle blends:
- *
- * - **alpha / premultiplied** — a surface: `color += premultiplied × T`, `norm += coverage × T`,
- *   `extinction += -log(1 - coverage)`, the same three the meshes write, with an untinted
- *   `T_self = 1 - coverage`; the splat recorded exactly that.
- * - **additive** — light: `emission += premultiplied × T`, nothing else. It joins the resolve
- *   attenuated by what is in front of it and outside the coverage normalization, which is what an
- *   additive fragment means.
- *
- * The scene depth is bound twice: as the read-only depth attachment the pipeline tests against, and
- * as the texture the soft fade reads. Both are reads, which WebGPU allows within one pass; the pass
- * is recorded with the attachment read-only for that reason.
- */
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("view", VIEW_UNIFORM_STRUCT)
-    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
-    .addStorageBuffer("pool", WebGPUArray.u32, false)
-    .addStorageBuffer("draw_list", WebGPUArray.u32, false)
-    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
-    .addTexture("atlas", "float")
-    .addSampler("atlas_sampler", "filtering")
-    .addTexture("scene_depth", "unfilterable-float")
-    // sampled through sLinear: linear, clamped on every axis, which is what the integral needs
-    .addTexture("tIntegral", "float", "3d")
-    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
-    // volumetrics (composited inline)
-    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addTexture("tVolumetrics", "float", "3d")
-    .addTexture("tSTBN_vec3", "float", "3d");
-
-const body = CodeChunk.from(
-    /* language=wgsl */ `
-const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
-const PARTICLE_FLAG_LIGHTING : u32 = ${EMITTER_FLAG.LIGHTING}u;
-const PARTICLE_SOFT_FADE_RANGE : f32 = ${PARTICLE_SOFT_FADE_RANGE};
-
-struct ParticleAVBOITDrawOutput {
-    @location(0) color : vec4<f32>,
-    @location(1) norm : vec4<f32>,
-    @location(2) extinction : vec4<f32>,
-    @location(3) emission : vec4<f32>,
-}
-
-// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
-fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
-    var out = particle_billboard_vertex(vi, ii);
-    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
-        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
-    }
-    return out;
-}
-
-@vertex
-fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
-}
-
-@vertex
-fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
-}
-
-@vertex
-fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
-}
-
-@fragment
-fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
-    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
-
-    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth);
-
-    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
-        // nothing this fragment contributes survives what is in front of it; skip the shading
-        discard;
-    }
-
-    var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
-
-    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
-        let scene_vd = particle_scene_view_depth(textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r, camera);
-        color = particle_fade_color(color, in.blend, particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE));
-    }
-
-    if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {
-        color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
-    }
-
-    if (particle_avboit_is_empty(color, in.blend)) {
-        discard;
-    }
-
-    let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
-
-    let contribution = particle_avboit_contribution(color, in.blend, transmittance, volumetrics);
-
-    var out : ParticleAVBOITDrawOutput;
-
-    out.color = contribution.color;
-    out.norm = contribution.norm;
-    out.extinction = contribution.extinction;
-    out.emission = contribution.emission;
-
-    return out;
-}
-`, [
-    chunk_particle_avboit_contribution,
-    chunk_particle_scene_view_depth,
-    chunk_particle_billboard_vertex,
-    chunk_particle_lighting_unlit,
-    chunk_sample_volumetrics,
-    chunk_avboit_sample_transmittance,
-]);
-
-const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
-
-/**
- * The variants share WGSL, bindings and attachments; only the vertex entry point and target writes
- * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
- * @param {string} label
- * @param {string} entryPoint
- * @param {number[]} writeMasks
- * @returns {RenderPipelineDescriptor}
- */
-function create_draw_pipeline(label, entryPoint, writeMasks) {
-    return RenderPipelineDescriptor.from({
-        label,
-        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-        vertex: { module: { code: descriptor.source }, entryPoint },
-        fragment: {
-            module: { code: descriptor.source },
-            entryPoint: "fs_main",
-            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
-        },
-        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
-        primitive: { topology: "triangle-list", cullMode: "none" },
-    });
-}
-
-export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
-export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
-export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
-
-/** The draw shader's resource set, for building its bind group. */
-export const PARTICLE_AVBOIT_DRAW_RESOURCES = resources;
-
-/** The assembled shader, for the validity tier. */
-export const shader_particle_avboit_draw = descriptor;
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_sample_volumetrics } from "../../deferred/chunk_sample_volumetrics.js";
+import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_DRAW_TARGETS } from "../../rasterize/native/avboit/avboit_draw_fragment_body.js";
+import { chunk_avboit_sample_transmittance } from "../../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.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 { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
+import { chunk_particle_avboit_contribution } from "./chunk_particle_avboit_contribution.js";
+import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
+import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
+import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
+
+/**
+ * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
+ * opaque scene, into the four accumulators the transparent meshes draw into
+ * (`avboit_draw_fragment_body`). The particle counterpart of `shader_avboit_draw_ibl`.
+ *
+ * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
+ * depth, lighting for an emitter flagged `EMITTER_FLAG.LIGHTING` (`chunk_particle_lighting`: the
+ * froxel irradiance volume: the lights and the indirect lighting), the volumetric fog composite exactly as the
+ * mesh draw applies it, then the transmittance of everything in front from the integral texture —
+ * and a fragment the volume already calls extinct is discarded unshaded. An emitter without the
+ * flag is its own colour, which is what an additive one wants.
+ *
+ * What is written depends on how the particle blends:
+ *
+ * - **alpha / premultiplied** — a surface: `color += premultiplied × T`, `norm += coverage × T`,
+ *   `extinction += -log(1 - coverage)`, the same three the meshes write, with an untinted
+ *   `T_self = 1 - coverage`; the splat recorded exactly that.
+ * - **additive** — light: `emission += premultiplied × T`, nothing else. It joins the resolve
+ *   attenuated by what is in front of it and outside the coverage normalization, which is what an
+ *   additive fragment means.
+ *
+ * The scene depth is bound twice: as the read-only depth attachment the pipeline tests against, and
+ * as the texture the soft fade reads. Both are reads, which WebGPU allows within one pass; the pass
+ * is recorded with the attachment read-only for that reason.
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    .addStorageBuffer("pool", WebGPUArray.u32, false)
+    .addStorageBuffer("draw_list", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    .addTexture("atlas", "float")
+    .addSampler("atlas_sampler", "filtering")
+    .addTexture("scene_depth", "unfilterable-float")
+    // sampled through sLinear: linear, clamped on every axis, which is what the integral needs
+    .addTexture("tIntegral", "float", "3d")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    // volumetrics (composited inline)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addTexture("tVolumetrics", "float", "3d")
+    .addTexture("tSTBN_vec3", "float", "3d")
+    // lighting (chunk_particle_lighting): the froxel irradiance volume, trilinear through sLinear
+    .addTexture("tIrradianceY", "float", "3d")
+    .addTexture("tIrradianceCoCg", "float", "3d");
+
+const body = CodeChunk.from(
+    /* language=wgsl */ `
+const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
+const PARTICLE_FLAG_LIGHTING : u32 = ${EMITTER_FLAG.LIGHTING}u;
+const PARTICLE_SOFT_FADE_RANGE : f32 = ${PARTICLE_SOFT_FADE_RANGE};
+
+struct ParticleAVBOITDrawOutput {
+    @location(0) color : vec4<f32>,
+    @location(1) norm : vec4<f32>,
+    @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
+}
+
+// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
+fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
+    var out = particle_billboard_vertex(vi, ii);
+    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
+        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+    }
+    return out;
+}
+
+@vertex
+fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
+}
+
+@vertex
+fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
+}
+
+@vertex
+fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
+}
+
+@fragment
+fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
+    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth);
+
+    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
+        // nothing this fragment contributes survives what is in front of it; skip the shading
+        discard;
+    }
+
+    var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
+
+    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
+        let scene_vd = particle_scene_view_depth(textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r, camera);
+        color = particle_fade_color(color, in.blend, particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE));
+    }
+
+    if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {
+        color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
+    }
+
+    if (particle_avboit_is_empty(color, in.blend)) {
+        discard;
+    }
+
+    let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
+
+    let contribution = particle_avboit_contribution(color, in.blend, transmittance, volumetrics);
+
+    var out : ParticleAVBOITDrawOutput;
+
+    out.color = contribution.color;
+    out.norm = contribution.norm;
+    out.extinction = contribution.extinction;
+    out.emission = contribution.emission;
+
+    return out;
+}
+`, [
+    chunk_particle_avboit_contribution,
+    chunk_particle_scene_view_depth,
+    chunk_particle_billboard_vertex,
+    chunk_particle_lighting,
+    chunk_sample_volumetrics,
+    chunk_avboit_sample_transmittance,
+]);
+
+const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
+
+/**
+ * The variants share WGSL, bindings and attachments; only the vertex entry point and target writes
+ * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
+ * @param {string} label
+ * @param {string} entryPoint
+ * @param {number[]} writeMasks
+ * @returns {RenderPipelineDescriptor}
+ */
+function create_draw_pipeline(label, entryPoint, writeMasks) {
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: descriptor.source }, entryPoint },
+        fragment: {
+            module: { code: descriptor.source },
+            entryPoint: "fs_main",
+            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
+        },
+        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}
+
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
+
+/** The draw shader's resource set, for building its bind group. */
+export const PARTICLE_AVBOIT_DRAW_RESOURCES = resources;
+
+/** The assembled shader, for the validity tier. */
+export const shader_particle_avboit_draw = descriptor;

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

@@ -70,6 +70,10 @@ export type AVBOITSideChannel = {
     /**
      * draw the
      * channel's fragments into the accumulators; returns their handles after the draw.
+     * `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
+     * (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
+     * indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
+     * the fog, written by the pass that lights the fog.
      */
     avboit_draw: (args: {
         graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
@@ -80,6 +84,10 @@ export type AVBOITSideChannel = {
         integral: number;
         volumetrics_lut: number;
         volumetrics_metadata: number;
+        volumetrics_irradiance: {
+            Y: number;
+            CoCg: number;
+        };
         accumulators: {
             color: number;
             norm: 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCc,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,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;;;;;;sBAE9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCc,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;;;;;;sBAM9D,MAAM,OAAO"}

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

@@ -62,9 +62,14 @@
  *     integral: number,
  *     volumetrics_lut: number,
  *     volumetrics_metadata: number,
+ *     volumetrics_irradiance: {Y: number, CoCg: number},
  *     accumulators: {color: number, norm: number, extinction: number, emission: number},
  * }) => {color: number, norm: number, extinction: number, emission: number}} avboit_draw draw the
  *     channel's fragments into the accumulators; returns their handles after the draw.
+ *     `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
+ *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
+ *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
+ *     the fog, written by the pass that lights the fog.
  * @property {() => boolean} [avboit_is_empty] whether the channel would add nothing this frame;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.

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

@@ -155,13 +155,16 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  * @param {number} options.shadowmap_atlas
  * @param {number} options.volumetrics_lut
  * @param {number} options.volumetrics_metadata
+ * @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 {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, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, indirect_lighting_mode, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ 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, volumetrics_irradiance, indirect_lighting_mode, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;
@@ -175,6 +178,10 @@ export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view
     shadowmap_atlas: number;
     volumetrics_lut: number;
     volumetrics_metadata: number;
+    volumetrics_irradiance: {
+        Y: number;
+        CoCg: number;
+    };
     indirect_lighting_mode: ShadeIndirectLightingMode;
     avboit?: AVBOITSettings;
     side_channels?: import("./AVBOITSideChannel.js").AVBOITSideChannel[];

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":"AA4DA;;;;;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,CAsDlB;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,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAnB+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,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAwRlB;+BA57B8B,qBAAqB;0CA9BV,uCAAuC"}
+{"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":"AA4DA;;;;;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,CAsDlB;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,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAtB+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;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CA8RlB;+BAr8B8B,qBAAqB;0CA9BV,uCAAuC"}

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

@@ -708,6 +708,9 @@ export function avboit_create_accumulators(pass, resolution) {
  * @param {number} options.shadowmap_atlas
  * @param {number} options.volumetrics_lut
  * @param {number} options.volumetrics_metadata
+ * @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 {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
@@ -730,6 +733,7 @@ export function graph_rasterize_meshes_transparent_avboit({
 
                                                               volumetrics_lut,
                                                               volumetrics_metadata,
+                                                              volumetrics_irradiance,
 
                                                               indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                                                               avboit = DEFAULT_SETTINGS,
@@ -747,6 +751,10 @@ export function graph_rasterize_meshes_transparent_avboit({
 
     assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
 
+    assert.defined(volumetrics_irradiance, 'volumetrics_irradiance');
+    assert.isNonNegativeInteger(volumetrics_irradiance.Y, 'volumetrics_irradiance.Y');
+    assert.isNonNegativeInteger(volumetrics_irradiance.CoCg, 'volumetrics_irradiance.CoCg');
+
     assert.equal(view_ctx.isGPUViewContext, true, 'view_ctx.isGPUViewContext !== true');
 
     const scene_ctx = view_ctx.scene;
@@ -971,6 +979,7 @@ export function graph_rasterize_meshes_transparent_avboit({
             integral,
             volumetrics_lut,
             volumetrics_metadata,
+            volumetrics_irradiance,
             accumulators,
         });
     }

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts

@@ -30,16 +30,26 @@ export class GPUViewVolumetrics {
      * @param {number} options.light_cluster_lookup
      * @param {number} options.light_cluster_parameters
      * @param {number} options.shadowmap_atlas
+     * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode the renderer's; picks the froxel GI
+     *   module that starts the froxel irradiance volume
+     * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
+     *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
+     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
      */
-    graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, }: {
+    graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, indirect_lighting_mode, }: {
         graph: FrameGraph;
         light_cluster_data: number;
         light_cluster_lookup: number;
         light_cluster_parameters: number;
         shadowmap_atlas: number;
+        indirect_lighting_mode: import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
     }): {
-        resolved: any;
-        metadata: any;
+        resolved: number;
+        metadata: number;
+        irradiance: {
+            Y: number;
+            CoCg: number;
+        };
     };
     #private;
 }

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;;;;MAoFhB;;CAEJ;yBA5eY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;;;;;;OAaG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAyFvF;;CAEJ;yBApfY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -429,6 +429,11 @@ export class GPUViewVolumetrics {
      * @param {number} options.light_cluster_lookup
      * @param {number} options.light_cluster_parameters
      * @param {number} options.shadowmap_atlas
+     * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode the renderer's; picks the froxel GI
+     *   module that starts the froxel irradiance volume
+     * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
+     *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
+     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
      */
     graph_update({
                      graph,
@@ -436,6 +441,7 @@ export class GPUViewVolumetrics {
                      light_cluster_lookup,
                      light_cluster_parameters,
                      shadowmap_atlas,
+                     indirect_lighting_mode,
                  }) {
 
         const view = this.#view;
@@ -487,7 +493,7 @@ export class GPUViewVolumetrics {
             taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
         }
 
-        const { lut_aerial } = graph_build_volumetrics({
+        const { lut_aerial, irradiance } = graph_build_volumetrics({
             graph,
             camera,
             lights,
@@ -496,6 +502,7 @@ export class GPUViewVolumetrics {
             light_cluster_lookup,
             light_cluster_parameters,
             shadowmap_atlas,
+            indirect_lighting_mode,
 
             volumetrics_metadata: gr_metadata,
             volumetric_resolution: resolution,
@@ -511,6 +518,7 @@ export class GPUViewVolumetrics {
         return {
             resolved: lut_aerial,
             metadata: gr_metadata,
+            irradiance,
         };
     }