@woosh/meep-engine 3.67.0 → 3.69.0

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

@@ -0,0 +1,21 @@
+/**
+ * What a vertex stage hands the unlit AVBOIT fragment stages (`chunk_avboit_unlit_splat_fragment`,
+ * `chunk_avboit_unlit_draw_fragment`): `struct AVBOITUnlitVaryings`.
+ *
+ * - `clip` is the clip-space position.
+ * - `color` is straight, not premultiplied: RGB and the fragment's own opacity.
+ * - `view_depth` is the vertex's view-space depth, interpolated across the triangle. The splat
+ *   positions a fragment's extinction by it and the draw looks the volume up at it, so both take it
+ *   from here rather than reconstructing it from `@builtin(position).z`.
+ *
+ * `color` and `view_depth` are interpolated at the **centroid** of the samples a triangle covers. The
+ * splat is multisampled, and a thin triangle can cover some of a pixel's samples but not its centre;
+ * at the centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon
+ * seen nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where
+ * a fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_varyings: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_unlit_varyings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_unlit_varyings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_unlit_varyings.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAWjB;0BA7BwB,uCAAuC"}

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

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * What a vertex stage hands the unlit AVBOIT fragment stages (`chunk_avboit_unlit_splat_fragment`,
+ * `chunk_avboit_unlit_draw_fragment`): `struct AVBOITUnlitVaryings`.
+ *
+ * - `clip` is the clip-space position.
+ * - `color` is straight, not premultiplied: RGB and the fragment's own opacity.
+ * - `view_depth` is the vertex's view-space depth, interpolated across the triangle. The splat
+ *   positions a fragment's extinction by it and the draw looks the volume up at it, so both take it
+ *   from here rather than reconstructing it from `@builtin(position).z`.
+ *
+ * `color` and `view_depth` are interpolated at the **centroid** of the samples a triangle covers. The
+ * splat is multisampled, and a thin triangle can cover some of a pixel's samples but not its centre;
+ * at the centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon
+ * seen nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where
+ * a fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_varyings = CodeChunk.from(
+    //language=WGSL
+    `
+struct AVBOITUnlitVaryings {
+    @builtin(position) clip : vec4<f32>,
+    @location(0) @interpolate(perspective, centroid) color : vec4<f32>,
+    @location(1) @interpolate(perspective, centroid) view_depth : f32,
+}
+    `
+);

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

@@ -0,0 +1,101 @@
+/**
+ * Splat a channel's unlit geometry into the voxel volume.
+ *
+ * The raster is multisampled ({@link AVBOIT_UNLIT_SPLAT_SAMPLES}), so it cannot use the volume's
+ * single-sampled splat target: the pass makes its own at the volume's resolution, never written,
+ * cleared and discarded, and hands the volume's back untouched.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label the pass's label; its target is labelled after it
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_splat_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {number} params.warp graph handle
+ * @param {number[]} params.voxel_resolution the volume's width and height, which the raster is
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level groups are set, with `inputs` resolved
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_avboit_unlit_splat({ graph, label, pipeline, resources, inputs, warp, voxel_resolution, volume, is_empty, record, }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    label: string;
+    pipeline: import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    inputs: {
+        [x: string]: number;
+    };
+    warp: number;
+    voxel_resolution: number[];
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    is_empty: () => boolean;
+    record: (arg0: GPURenderPassEncoder, arg1: GraphicsContext, arg2: {
+        [x: string]: any;
+    }) => void;
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * Draw a channel's unlit geometry into the four accumulators, depth-tested against the opaque scene.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_draw_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {import("../../../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.depth_texture graph handle of the opaque scene's depth — tested, never written
+ * @param {number} params.warp graph handle
+ * @param {number} params.integral graph handle of the integral texture
+ * @param {number} params.volumetrics_lut graph handle
+ * @param {number} params.volumetrics_metadata graph handle
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level group is set, with `inputs` resolved
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_avboit_unlit_draw({ graph, label, pipeline, resources, inputs, view_ctx, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, is_empty, record, }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    label: string;
+    pipeline: import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    inputs: {
+        [x: string]: number;
+    };
+    view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+    depth_texture: number;
+    warp: number;
+    integral: number;
+    volumetrics_lut: number;
+    volumetrics_metadata: number;
+    accumulators: {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    is_empty: () => boolean;
+    record: (arg0: GPURenderPassEncoder, arg1: GraphicsContext, arg2: {
+        [x: string]: any;
+    }) => void;
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+//# sourceMappingURL=graph_avboit_unlit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_avboit_unlit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_avboit_unlit.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAfwG,KAAK,EAAlG,OAAO,iEAAiE,EAAE,UAAU;IACrE,KAAK,EAApB,MAAM;IACwG,QAAQ,EAAtH,OAAO,oEAAoE,EAAE,wBAAwB;IAEC,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9D,MAAM;YAA9B,MAAM,GAAE,MAAM;;IACN,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IACzB,QAAQ,QAAxB,OAAO;IAC8D,MAAM;YAAhC,MAAM;UAAO,IAAI;IAEtE;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA4FjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAnBwG,KAAK,EAAlG,OAAO,iEAAiE,EAAE,UAAU;IACrE,KAAK,EAApB,MAAM;IACwG,QAAQ,EAAtH,OAAO,oEAAoE,EAAE,wBAAwB;IAEC,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9D,MAAM;YAA9B,MAAM,GAAE,MAAM;;IAC4C,QAAQ,EAAzE,OAAO,iCAAiC,EAAE,cAAc;IACzC,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACvC,QAAQ,QAAxB,OAAO;IAC8D,MAAM;YAAhC,MAAM;UAAO,IAAI;IAEtE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAkG/E"}

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

@@ -0,0 +1,306 @@
+import { assert } from "../../../../../core/assert.js";
+import { GPUTextureUsage } from "../../../../descriptor/GPUTextureUsage.js";
+import { TextureViewDescriptor } from "../../../../descriptor/texture/TextureViewDescriptor.js";
+import { TextureResourceDescriptor } from "../../../../device/graph/TextureResourceDescriptor.js";
+import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../../../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { AVBOIT_UNLIT_DRAW_PASS_GROUP } from "./avboit_unlit_draw.js";
+import { AVBOIT_UNLIT_SPLAT_PASS_GROUP, AVBOIT_UNLIT_SPLAT_SAMPLES } from "./avboit_unlit_splat.js";
+import { AVBOIT_SPLAT_DUMMY_FORMAT, AVBOIT_SPLAT_VOLUME_GROUP } from "./shader_avboit_splat.js";
+
+/**
+ * The passes an `AVBOITSideChannel` of unlit straight-alpha geometry records for its splat and its draw,
+ * with everything but the draws themselves in one place: the attachments, the multisampled target of
+ * the splat, the pass-level bind groups and the frame-graph reads and writes. A channel supplies a
+ * pipeline built by `avboit_unlit_splat_pipeline` / `avboit_unlit_draw_pipeline`, the graph handles its
+ * own draws read, and a `record` callback that issues them; the dynamic meshes and the trails draw
+ * through the same passes this way, with different vertex stages.
+ *
+ * Order does not matter to either pass — the volume and the accumulators are sums — which is why
+ * nothing here sorts.
+ */
+
+/** The accumulators' and the splat target's view: one mip, the one the frame draws into. */
+const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
+
+/**
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} resources
+ * @param {import("../../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ * @returns {number} where the shader declares `group`
+ */
+function group_index(resources, group) {
+    const index = resources.groups.indexOf(group);
+
+    assert.notEqual(index, -1, "the shader does not bind this pass group");
+
+    return index;
+}
+
+/**
+ * Read every handle of `inputs` in `pass`, keeping the names.
+ *
+ * @param {object} pass the pass builder
+ * @param {Object<string, number>} inputs
+ * @returns {Object<string, number>} the handles as the pass reads them
+ */
+function read_inputs(pass, inputs) {
+    const read = {};
+
+    for (const name of Object.keys(inputs)) {
+        read[name] = pass.read(inputs[name]);
+    }
+
+    return read;
+}
+
+/**
+ * @param {Object<string, number>} handles
+ * @param {object} resources the pass's resolved resources
+ * @returns {Object<string, *>} the same names, resolved
+ */
+function resolve_inputs(handles, resources) {
+    const resolved = {};
+
+    for (const name of Object.keys(handles)) {
+        resolved[name] = resources.get(handles[name]);
+    }
+
+    return resolved;
+}
+
+/**
+ * Splat a channel's unlit geometry into the voxel volume.
+ *
+ * The raster is multisampled ({@link AVBOIT_UNLIT_SPLAT_SAMPLES}), so it cannot use the volume's
+ * single-sampled splat target: the pass makes its own at the volume's resolution, never written,
+ * cleared and discarded, and hands the volume's back untouched.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label the pass's label; its target is labelled after it
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_splat_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {number} params.warp graph handle
+ * @param {number[]} params.voxel_resolution the volume's width and height, which the raster is
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level groups are set, with `inputs` resolved
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_avboit_unlit_splat({
+                                             graph,
+                                             label,
+                                             pipeline,
+                                             resources,
+                                             inputs,
+                                             warp,
+                                             voxel_resolution,
+                                             volume,
+                                             is_empty,
+                                             record,
+                                         }) {
+    assert.isString(label, "label");
+    assert.isNonNegativeInteger(warp, "warp");
+    assert.isArrayLike(voxel_resolution, "voxel_resolution");
+    assert.defined(volume, "volume");
+    assert.isFunction(is_empty, "is_empty");
+    assert.isFunction(record, "record");
+
+    const pass_group_index = group_index(resources, AVBOIT_UNLIT_SPLAT_PASS_GROUP);
+    const volume_group_index = group_index(resources, AVBOIT_SPLAT_VOLUME_GROUP);
+
+    function execute(data, frame_resources, context) {
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+
+        if (is_empty()) {
+            return;
+        }
+
+        // By name, never by position (AVBOIT ledger entry 21): the order a shader declares its
+        // bindings in is the shader's business.
+        const pass_group = AVBOIT_UNLIT_SPLAT_PASS_GROUP.generateBindings({
+            warp: frame_resources.get(data.warp),
+        }, encoder);
+
+        const volume_group = AVBOIT_SPLAT_VOLUME_GROUP.generateBindings({
+            extinction_volume: frame_resources.get(data.extinction),
+            overflow_slice: frame_resources.get(data.overflow),
+        }, encoder);
+
+        // the target is never written; it only sizes the raster and gives it its samples
+        const pass_encoder = encoder.constructRenderPass({
+            label,
+            pipeline,
+            // the pass's groups are set once, just below; the draws set their own
+            bindings: [],
+            colorAttachments: [{
+                view: frame_resources.get(data.target).obtainView(COLOR_VIEW),
+                loadOp: "clear",
+                storeOp: "discard",
+            }],
+        });
+
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, pass_group_index, pass_group);
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, volume_group_index, volume_group);
+
+        record(pass_encoder, graphics, resolve_inputs(data.inputs, frame_resources));
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add(label, pass_data, execute);
+
+    pass_data.inputs = read_inputs(pass, inputs);
+    pass_data.warp = pass.read(warp);
+
+    pass.read(volume.extinction);
+    pass_data.extinction = pass.write(volume.extinction);
+    pass.read(volume.overflow);
+    pass_data.overflow = pass.write(volume.overflow);
+
+    const target = TextureResourceDescriptor.from({
+        resolution: voxel_resolution,
+        format: AVBOIT_SPLAT_DUMMY_FORMAT,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+
+    // `from` takes no sample count
+    target.sampleCount = AVBOIT_UNLIT_SPLAT_SAMPLES;
+
+    pass_data.target = pass.create(`${label} target`, target);
+
+    return {
+        extinction: pass_data.extinction,
+        overflow: pass_data.overflow,
+        // not this pass's to touch
+        dummy: volume.dummy,
+    };
+}
+
+/**
+ * Draw a channel's unlit geometry into the four accumulators, depth-tested against the opaque scene.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_draw_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {import("../../../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.depth_texture graph handle of the opaque scene's depth — tested, never written
+ * @param {number} params.warp graph handle
+ * @param {number} params.integral graph handle of the integral texture
+ * @param {number} params.volumetrics_lut graph handle
+ * @param {number} params.volumetrics_metadata graph handle
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level group is set, with `inputs` resolved
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_avboit_unlit_draw({
+                                            graph,
+                                            label,
+                                            pipeline,
+                                            resources,
+                                            inputs,
+                                            view_ctx,
+                                            depth_texture,
+                                            warp,
+                                            integral,
+                                            volumetrics_lut,
+                                            volumetrics_metadata,
+                                            accumulators,
+                                            is_empty,
+                                            record,
+                                        }) {
+    assert.isString(label, "label");
+    assert.isNonNegativeInteger(depth_texture, "depth_texture");
+    assert.isNonNegativeInteger(warp, "warp");
+    assert.isNonNegativeInteger(integral, "integral");
+    assert.defined(accumulators, "accumulators");
+    assert.isFunction(is_empty, "is_empty");
+    assert.isFunction(record, "record");
+
+    const pass_group_index = group_index(resources, AVBOIT_UNLIT_DRAW_PASS_GROUP);
+
+    function execute(data, frame_resources, context) {
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+
+        if (is_empty()) {
+            return;
+        }
+
+        // by name rather than by position, for the reason the splat gives
+        const pass_group = AVBOIT_UNLIT_DRAW_PASS_GROUP.generateBindings({
+            view: view_ctx.uniform_buffer.buffer,
+            warp: frame_resources.get(data.warp),
+            tIntegral: frame_resources.get(data.integral).obtainView(),
+            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE),
+            volumetrics_metadata: frame_resources.get(data.volumetrics_metadata),
+            tVolumetrics: frame_resources.get(data.volumetrics_lut).obtainView(),
+            tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
+        }, encoder);
+
+        const attachment = (handle) => ({
+            view: frame_resources.get(handle).obtainView(COLOR_VIEW),
+            loadOp: "load",
+            storeOp: "store",
+        });
+
+        const pass_encoder = encoder.constructRenderPass({
+            label,
+            pipeline,
+            // the pass's group is set once, just below; the draws set their own
+            bindings: [],
+            colorAttachments: [
+                attachment(data.color),
+                attachment(data.norm),
+                attachment(data.extinction),
+                attachment(data.emission),
+            ],
+            depthStencilAttachment: {
+                view: frame_resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                depthReadOnly: true,
+            },
+        });
+
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, pass_group_index, pass_group);
+
+        record(pass_encoder, graphics, resolve_inputs(data.inputs, frame_resources));
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add(label, pass_data, execute);
+
+    pass_data.inputs = read_inputs(pass, inputs);
+    pass_data.depth = pass.read(depth_texture);
+    pass_data.warp = pass.read(warp);
+    pass_data.integral = pass.read(integral);
+    pass_data.volumetrics_lut = pass.read(volumetrics_lut);
+    pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
+
+    for (const name of ["color", "norm", "extinction", "emission"]) {
+        pass.read(accumulators[name]);
+        pass_data[name] = pass.write(accumulators[name]);
+    }
+
+    return {
+        color: pass_data.color,
+        norm: pass_data.norm,
+        extinction: pass_data.extinction,
+        emission: pass_data.emission,
+    };
+}

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

@@ -10,11 +10,20 @@ export const AVBOIT_SPLAT_BIND_GROUP_VOLUME: number;
  * @type {GPUTextureFormat}
  */
 export const AVBOIT_SPLAT_DUMMY_FORMAT: GPUTextureFormat;
+/**
+ * The voxel volume a splat adds its extinction into: the packed counts and the per-channel first
+ * overflow, both atomics, so fragment-only. Every splat that writes through `avboit_splat_slice` binds
+ * this group.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_SPLAT_VOLUME_GROUP: ShaderResourceGroupDescriptor;
 /**
  * One pipeline per template that can be drawn forward.
  *
  * @type {TemplatePassDescriptor}
  */
 export const shader_avboit_splat: TemplatePassDescriptor;
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { TemplatePassDescriptor } from "../../TemplatePassDescriptor.js";
 //# sourceMappingURL=shader_avboit_splat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA8HnD;;;;GAIG;AACH,kCAFU,sBAAsB,CA+B7B;uCApLoC,iCAAiC"}
+{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AASnD;;;;;;GAMG;AACH,wCAFU,6BAA6B,CAEsC;AAqH7E;;;;GAIG;AACH,kCAFU,sBAAsB,CA+B7B;8CArM2C,2DAA2D;uCAUlE,iCAAiC"}

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

@@ -49,14 +49,21 @@ view_group
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
 ;
 
-const volume_group = new ShaderResourceGroupDescriptor();
+/**
+ * The voxel volume a splat adds its extinction into: the packed counts and the per-channel first
+ * overflow, both atomics, so fragment-only. Every splat that writes through `avboit_splat_slice` binds
+ * this group.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_SPLAT_VOLUME_GROUP = new ShaderResourceGroupDescriptor();
 
-volume_group
+AVBOIT_SPLAT_VOLUME_GROUP
     .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
     .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true)
 ;
 
-const pass_groups = [view_group, volume_group];
+const pass_groups = [view_group, AVBOIT_SPLAT_VOLUME_GROUP];
 
 /*
  The layout is built group by group rather than with one visibility for every group: WebGPU refuses
@@ -67,7 +74,7 @@ const pass_groups = [view_group, volume_group];
 */
 const pass_layouts = [
     view_group.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    volume_group.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
+    AVBOIT_SPLAT_VOLUME_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
 ];
 
 const shader_vertex = ShaderDescriptor.from({

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAr3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QAUzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAt3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -98,6 +98,7 @@ export class GPUSceneContext {
         GPUDatabase.enquirePipelines(enquiry);
         GPUAnimationManager.enquirePipelines(enquiry);
         enquiry.compute.push(shader_refresh_all_mesh_bounds.pipeline);
+        GPUSky.enquirePipelines(enquiry);
         GPULightCollection.enquirePipelines(enquiry);
         GPUInstancesAccelerationStructure.enquirePipelines(enquiry);
         GPUSceneVolumetrics.enquirePipelines(enquiry);
@@ -314,7 +315,7 @@ export class GPUSceneContext {
 
         this.#wind = new GPUSceneWind(device);
 
-        this.#sky = new GPUSky(graphics);
+        this.#sky = new GPUSky(graphics, scene.atmosphere);
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }

package/src/shade/renderer/scene/Scene.d.ts

@@ -2,8 +2,8 @@
  * @typedef {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
  */
 /**
- * A scene: the dataset whose entities are what it draws and poses, and the three things that are
- * not entities — its lights' collection, a light probe volume, volumetrics.
+ * A scene: the dataset whose entities are what it draws and poses, and the things that are
+ * not entities — its lights' collection, atmosphere, a light probe volume, volumetrics.
  *
  * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
  * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
@@ -27,6 +27,12 @@ export class Scene {
      * @type {LightCollection}
      */
     lights: LightCollection;
+    /**
+     * Physical Hillaire (2020) sky and atmosphere configuration.
+     *
+     * @type {SceneAtmosphere}
+     */
+    atmosphere: SceneAtmosphere;
     /**
      *
      * @type {LightProbeVolume}
@@ -45,6 +51,7 @@ export class Scene {
 }
 export type EntityComponentDataset = import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset;
 import { LightCollection } from "../light/LightCollection.js";
+import { SceneAtmosphere } from "../atmosphere/SceneAtmosphere.js";
 import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
 import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
 //# sourceMappingURL=Scene.d.ts.map

package/src/shade/renderer/scene/Scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;OAOG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCA1CY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;iCAD5B,gDAAgD;iCAEhD,oCAAoC"}
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;OAOG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;;OAIG;IACH,YAFU,eAAe,CAEU;IAEnC;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCAjDY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;gCAF7B,kCAAkC;iCACjC,gDAAgD;iCAEhD,oCAAoC"}

package/src/shade/renderer/scene/Scene.js

@@ -1,3 +1,4 @@
+import { SceneAtmosphere } from "../atmosphere/SceneAtmosphere.js";
 import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
 import { LightCollection } from "../light/LightCollection.js";
 import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
@@ -7,8 +8,8 @@ import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
  */
 
 /**
- * A scene: the dataset whose entities are what it draws and poses, and the three things that are
- * not entities — its lights' collection, a light probe volume, volumetrics.
+ * A scene: the dataset whose entities are what it draws and poses, and the things that are
+ * not entities — its lights' collection, atmosphere, a light probe volume, volumetrics.
  *
  * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
  * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
@@ -34,6 +35,13 @@ export class Scene {
      */
     lights = new LightCollection();
 
+    /**
+     * Physical Hillaire (2020) sky and atmosphere configuration.
+     *
+     * @type {SceneAtmosphere}
+     */
+    atmosphere = new SceneAtmosphere();
+
     /**
      *
      * @type {LightProbeVolume}