@driftengine/core 4.4.1 → 4.5.0

package/dist/render/backend/webgpu/pointGlassTintPass.js

@@ -0,0 +1,193 @@
+/**
+ * What a lamp's light keeps through glass, on this device: an `rgba8unorm` array of one layer a
+ * light, the face-sized colour scratch a face's glass is multiplied into, and the resolve that
+ * copies a face into its octahedral region. The twin of `pointGlassTint.ts`, which says what the
+ * channels hold and why the chain exists.
+ *
+ * **The chain is a `SnapshotMips` per layer**, made the first time that layer is touched and
+ * recorded once a round for the layers the round touched — a layer's levels are its own
+ * subresources here, so nothing is staged the way the other backend must.
+ */
+import { mat3 } from 'gl-matrix';
+import { pointShadowFaceRotation } from '../../pointShadowImage.js';
+import { OCTAHEDRAL_RESOLVE_TINT_FRAG_WGSL, OCTAHEDRAL_RESOLVE_VERT_WGSL, OCTAHEDRALRESOLVE_BINDINGS, } from '../../shaders/generated/octahedralResolve.wgsl.js';
+import { SnapshotMips } from './snapshotMips.js';
+import { UniformRing } from './uniformRing.js';
+const USAGE_RENDER_ATTACHMENT = 0x10;
+const USAGE_TEXTURE_BINDING = 0x4;
+const USAGE_UNIFORM_DST = 0x40 | 0x8; // UNIFORM | COPY_DST
+const VISIBILITY_FRAGMENT = 0x2;
+const TINT = OCTAHEDRALRESOLVE_BINDINGS.OCTAHEDRAL_RESOLVE_TINT_FRAG;
+const faceRotation = mat3.create();
+const rotationColumn = new Float32Array(3);
+export class GpuPointGlassTint {
+    texture;
+    /** The whole array, for the lit pass. */
+    view;
+    /** The colour scratch a face's glass is multiplied into. */
+    scratchView;
+    edge;
+    device;
+    pipelines;
+    scratch;
+    layerViews = [];
+    mips = [];
+    pipeline;
+    bindGroup;
+    ring;
+    heldFaces;
+    dirty;
+    constructor(device, pipelines, faceSize, edge, layers, 
+    /** Resolves a frame can make: the array's own figure, since every face resolves once. */
+    slots, encoder) {
+        this.device = device;
+        this.pipelines = pipelines;
+        this.edge = edge;
+        this.heldFaces = new Uint8Array(layers);
+        /* Every layer's chain is filled once at birth, so a level nothing has touched is white too. */
+        this.dirty = new Uint8Array(layers).fill(1);
+        this.texture = device.createTexture({
+            label: 'pointShadow.tint',
+            size: [edge, edge, layers],
+            format: 'rgba8unorm',
+            mipLevelCount: Math.floor(Math.log2(Math.max(1, edge))) + 1,
+            usage: USAGE_RENDER_ATTACHMENT | USAGE_TEXTURE_BINDING,
+        });
+        this.view = this.texture.createView({ dimension: '2d-array' });
+        for (let layer = 0; layer < layers; layer++) {
+            this.layerViews.push(this.texture.createView({
+                label: `pointShadow.tint.layer${layer}`,
+                dimension: '2d',
+                baseArrayLayer: layer,
+                arrayLayerCount: 1,
+                baseMipLevel: 0,
+                mipLevelCount: 1,
+            }));
+        }
+        this.scratch = device.createTexture({
+            label: 'pointShadow.tint.scratch',
+            size: [faceSize, faceSize],
+            format: 'rgba8unorm',
+            usage: USAGE_RENDER_ATTACHMENT | USAGE_TEXTURE_BINDING,
+        });
+        this.scratchView = this.scratch.createView();
+        this.ring = new UniformRing(device, TINT.uniformSize, slots, USAGE_UNIFORM_DST, 'pointShadow.tint.uniforms');
+        const layout = device.createBindGroupLayout({
+            label: 'pointShadow.tint.resolve.layout',
+            entries: [
+                {
+                    binding: TINT.uniforms,
+                    visibility: VISIBILITY_FRAGMENT,
+                    buffer: { type: 'uniform', hasDynamicOffset: true, minBindingSize: TINT.uniformSize },
+                },
+                {
+                    binding: TINT.textures.uFace.texture,
+                    visibility: VISIBILITY_FRAGMENT,
+                    texture: { sampleType: 'float' },
+                },
+                {
+                    binding: TINT.textures.uFace.sampler,
+                    visibility: VISIBILITY_FRAGMENT,
+                    sampler: { type: 'non-filtering' },
+                },
+            ],
+        });
+        this.bindGroup = device.createBindGroup({
+            label: 'pointShadow.tint.resolve',
+            layout,
+            entries: [
+                { binding: TINT.uniforms, resource: { buffer: this.ring.buffer, size: TINT.uniformSize } },
+                { binding: TINT.textures.uFace.texture, resource: this.scratchView },
+                {
+                    binding: TINT.textures.uFace.sampler,
+                    resource: device.createSampler({ label: 'pointShadow.tint.resolve.sampler' }),
+                },
+            ],
+        });
+        this.pipeline = device.createRenderPipeline({
+            label: 'pointShadow.tint.resolve',
+            layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
+            vertex: {
+                module: device.createShaderModule({ code: OCTAHEDRAL_RESOLVE_VERT_WGSL }),
+                entryPoint: 'main',
+            },
+            fragment: {
+                module: device.createShaderModule({ code: OCTAHEDRAL_RESOLVE_TINT_FRAG_WGSL }),
+                entryPoint: 'main',
+                targets: [{ format: 'rgba8unorm' }],
+            },
+            primitive: { topology: 'triangle-list' },
+        });
+        /* Every layer born clear: a light no pane has reached lets everything through. */
+        for (const view of this.layerViews) {
+            encoder
+                .beginRenderPass({
+                label: 'pointShadow.tint.clear',
+                colorAttachments: [{ view, loadOp: 'clear', clearValue: [1, 1, 1, 1], storeOp: 'store' }],
+            })
+                .end();
+        }
+    }
+    /** Whether `face` of `layer` holds glass: a face that does must be cleared before it is reused. */
+    held(layer, face) {
+        return (((this.heldFaces[layer] ?? 0) >> face) & 1) === 1;
+    }
+    /** Copy the colour scratch into `face`'s region of `layer`, and remember whether it held glass. */
+    resolve(encoder, layer, face, drawn) {
+        const view = this.layerViews[layer];
+        if (view === undefined)
+            return;
+        const slot = this.ring.allocate();
+        if (slot === null)
+            return;
+        pointShadowFaceRotation(face, faceRotation);
+        /* WGSL pads a mat3x3 to three four-float columns; the generated struct expects that. */
+        const rotation = TINT.fields.uFaceRotation.offset;
+        for (let column = 0; column < 3; column++) {
+            rotationColumn[0] = faceRotation[column * 3];
+            rotationColumn[1] = faceRotation[column * 3 + 1];
+            rotationColumn[2] = faceRotation[column * 3 + 2];
+            this.ring.writeFloats(slot, rotation + column * 16, rotationColumn);
+        }
+        this.ring.writeInt(slot, TINT.fields.uFaceIndex.offset, face);
+        this.ring.writeFloat(slot, TINT.fields.uEdge.offset, this.edge);
+        const pass = encoder.beginRenderPass({
+            label: 'pointShadow.tint.resolve',
+            colorAttachments: [{ view, loadOp: 'load', storeOp: 'store' }],
+        });
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, this.bindGroup, [slot]);
+        pass.draw(3);
+        pass.end();
+        const bit = 1 << face;
+        const was = this.heldFaces[layer] ?? 0;
+        this.heldFaces[layer] = drawn ? was | bit : was & ~bit;
+        this.dirty[layer] = 1;
+    }
+    /** The chain frost reads, for every layer touched since the last call. */
+    recordMips(encoder) {
+        for (let layer = 0; layer < this.dirty.length; layer++) {
+            if (this.dirty[layer] !== 1)
+                continue;
+            this.dirty[layer] = 0;
+            let chain = this.mips[layer];
+            if (chain === undefined) {
+                chain = new SnapshotMips(this.device, this.pipelines, this.texture, 'rgba8unorm', layer, 'pointShadow.tint.mips');
+                this.mips[layer] = chain;
+            }
+            chain.record(encoder);
+        }
+    }
+    beginFrame() {
+        this.ring.reset();
+    }
+    /** Before the round's submit: the slots are written and must be up before any pass reads. */
+    flush() {
+        this.ring.flush();
+    }
+    dispose() {
+        this.texture.destroy();
+        this.scratch.destroy();
+        this.ring.dispose();
+    }
+}

package/dist/render/backend/webgpu/pointShadowPass.d.ts

@@ -1,5 +1,7 @@
 import { type mat4 } from 'gl-matrix';
 import { type PointShadowSource } from '../../pointShadowImage.ts';
+import { GpuPointGlassTint } from './pointGlassTintPass.ts';
+import type { MipPipelines } from './surfaceTexturePass.ts';
 /**
  * Every point light's shadow as one array texture, and the scratch that fills it.
  *
@@ -10,14 +12,18 @@ import { type PointShadowSource } from '../../pointShadowImage.ts';
  * both say the resolve reads the scratch.
  */
 export declare class GpuPointShadowArray {
-    /** The array, as the shader samples it. */
-    readonly view: GPUTextureView;
+    /** Lights this array holds; the storage doubles under it once glass arrives. */
     readonly layers: number;
     /** Where a face is rendered before it is resolved. One, shared by every light. */
     readonly scratchView: GPUTextureView;
-    private readonly texture;
+    /** Replaced once, when glass first casts: see `growForGlass`. */
+    private texture;
+    private arrayView;
+    private tint;
+    private readonly device;
+    private readonly faceSize;
     private readonly scratch;
-    private readonly layerViews;
+    private layerViews;
     private readonly pipeline;
     private readonly bindGroup;
     /**
@@ -46,6 +52,26 @@ export declare class GpuPointShadowArray {
      * keeps this face to its own region.
      */
     resolve(encoder: GPUCommandEncoder, layer: number, face: number, far: number, near: number): void;
+    /** The face's glass depth into light `layer`'s glass layer, 2L + 1. */
+    resolveGlass(encoder: GPUCommandEncoder, layer: number, face: number, far: number, near: number): void;
+    /** The array, as the shader samples it. Replaced once, when glass first casts. */
+    get view(): GPUTextureView;
+    get hasGlass(): boolean;
+    /** Physical layers a light: 1, or 2 once glass has interleaved the array. */
+    get stride(): number;
+    /** The lights' glass tint, once glass has cast. */
+    get glassTint(): GpuPointGlassTint | null;
+    /**
+     * Interleave the array for glass, on `encoder`: light L's depth moves to 2L and its glass takes
+     * 2L + 1, every glass layer born at the far plane, and the tint made. The reasoning, and why no
+     * map re-bakes, is `PointShadowArray.growForGlass`'s.
+     *
+     * Returns the texture it replaced, which the caller destroys once `encoder` is submitted — the
+     * copies out of it are recorded there — or null when the array had already grown.
+     */
+    growForGlass(encoder: GPUCommandEncoder, tintEdge: number, pipelines: MipPipelines): GPUTexture | null;
+    /** The scratch into physical layer `physical`'s region for `face`. */
+    private resolveInto;
     /** Start a frame's bakes. See the ring: slots are reused and nothing is freed. */
     beginFrame(): void;
     /** Upload every slot this frame's resolves took, in one write, before the encoder is submitted. */
@@ -54,8 +80,11 @@ export declare class GpuPointShadowArray {
 }
 /** What a face's pass needs from the caller: somewhere to record, and the casters to record. */
 export type PointShadowFacePass = (view: GPUTextureView, viewProj: mat4) => void;
-/** And what turns that face into its region of the light's octahedral layer. */
-export type PointShadowResolve = (layer: number, face: number, far: number, near: number) => void;
+/**
+ * And what turns that face into its region of the light's octahedral layer — and, where the face
+ * offered glass, draws and resolves that too, lit from the bake origin `x`, `y`, `z`.
+ */
+export type PointShadowResolve = (layer: number, face: number, far: number, near: number, x: number, y: number, z: number) => void;
 export declare class GpuPointShadowMap implements PointShadowSource {
     readonly size: number;
     /** Which layer of the shared array this map's image lives in. See `pointShadowMap.ts`. */

package/dist/render/backend/webgpu/pointShadowPass.js

@@ -4,6 +4,7 @@ import { OCTAHEDRAL_EDGE } from '../../pointShadowArray.js';
 import { createFaceRange, DEFAULT_SOURCE_RADIUS, FACE_COUNT, POINT_SHADOW_NEAR, PointShadowImage, pointShadowFaceRotation, pointShadowFaceViewProj, } from '../../pointShadowImage.js';
 import { OCTAHEDRAL_RESOLVE_FRAG_WGSL, OCTAHEDRAL_RESOLVE_VERT_WGSL, } from '../../shaders/generated/octahedralResolve.wgsl.js';
 import { SHADOW_FORMAT } from './depthPass.js';
+import { GpuPointGlassTint } from './pointGlassTintPass.js';
 import { UniformRing } from './uniformRing.js';
 /**
  * A point light's shadow on this device: one octahedral layer, filled a face at a time.
@@ -30,6 +31,9 @@ const VISIBILITY_FRAGMENT = 0x2;
  * silently not landing in its layer.
  */
 const RESOLVE_SLOTS = (POINT_SHADOW_POOL + LIVE_POINT_SHADOW_MAPS) * FACE_COUNT;
+/** Twice once glass arrives: a face resolves its opaque depth and then its glass. */
+const DEPTH_RESOLVE_SLOTS = 2 * RESOLVE_SLOTS;
+const USAGE_COPY = 0x01 | 0x02; // COPY_SRC | COPY_DST
 /** `mat3x3<f32>` then four scalars, at std140's sixteen-byte columns: see the generated struct. */
 const RESOLVE_UNIFORM_SIZE = 64;
 /** Filled per resolved face, at module scope, because a bake runs inside the frame's budget. */
@@ -46,12 +50,16 @@ const rotationColumn = new Float32Array(3);
  * both say the resolve reads the scratch.
  */
 export class GpuPointShadowArray {
-    /** The array, as the shader samples it. */
-    view;
+    /** Lights this array holds; the storage doubles under it once glass arrives. */
     layers;
     /** Where a face is rendered before it is resolved. One, shared by every light. */
     scratchView;
+    /** Replaced once, when glass first casts: see `growForGlass`. */
     texture;
+    arrayView;
+    tint = null;
+    device;
+    faceSize;
     scratch;
     layerViews = [];
     pipeline;
@@ -76,21 +84,11 @@ export class GpuPointShadowArray {
     extraLayers = 0) {
         this.layers =
             Math.min(lightCount, POINT_SHADOW_POOL) + LIVE_POINT_SHADOW_MAPS + Math.max(0, extraLayers);
-        this.texture = device.createTexture({
-            label: 'pointShadow.array',
-            size: [OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, this.layers],
-            format: SHADOW_FORMAT,
-            usage: USAGE_RENDER_ATTACHMENT | USAGE_TEXTURE_BINDING,
-        });
-        this.view = this.texture.createView({ dimension: '2d-array' });
-        for (let layer = 0; layer < this.layers; layer++) {
-            this.layerViews.push(this.texture.createView({
-                label: `pointShadow.layer${layer}`,
-                dimension: '2d',
-                baseArrayLayer: layer,
-                arrayLayerCount: 1,
-            }));
-        }
+        this.device = device;
+        this.faceSize = faceSize;
+        this.texture = depthArray(device, this.layers);
+        this.arrayView = this.texture.createView({ dimension: '2d-array' });
+        this.layerViews = layerViewsOf(this.texture, this.layers);
         this.scratch = device.createTexture({
             label: 'pointShadow.scratch',
             size: [faceSize, faceSize],
@@ -98,7 +96,7 @@ export class GpuPointShadowArray {
             usage: USAGE_RENDER_ATTACHMENT | USAGE_TEXTURE_BINDING,
         });
         this.scratchView = this.scratch.createView();
-        this.ring = new UniformRing(device, RESOLVE_UNIFORM_SIZE, RESOLVE_SLOTS, USAGE_UNIFORM_DST, 'pointShadow.resolve.uniforms');
+        this.ring = new UniformRing(device, RESOLVE_UNIFORM_SIZE, DEPTH_RESOLVE_SLOTS, USAGE_UNIFORM_DST, 'pointShadow.resolve.uniforms');
         /*
          * `non-filtering` and `unfilterable-float`, matching `flatPass.ts`: the scratch is a depth
          * format, whose supported sample types are UnfilterableFloat and Depth and never plain
@@ -162,7 +160,69 @@ export class GpuPointShadowArray {
      * keeps this face to its own region.
      */
     resolve(encoder, layer, face, far, near) {
-        const view = this.layerViews[layer];
+        this.resolveInto(encoder, layer * this.stride, face, far, near);
+    }
+    /** The face's glass depth into light `layer`'s glass layer, 2L + 1. */
+    resolveGlass(encoder, layer, face, far, near) {
+        if (this.tint === null)
+            return;
+        this.resolveInto(encoder, 2 * layer + 1, face, far, near);
+    }
+    /** The array, as the shader samples it. Replaced once, when glass first casts. */
+    get view() {
+        return this.arrayView;
+    }
+    get hasGlass() {
+        return this.tint !== null;
+    }
+    /** Physical layers a light: 1, or 2 once glass has interleaved the array. */
+    get stride() {
+        return this.tint === null ? 1 : 2;
+    }
+    /** The lights' glass tint, once glass has cast. */
+    get glassTint() {
+        return this.tint;
+    }
+    /**
+     * Interleave the array for glass, on `encoder`: light L's depth moves to 2L and its glass takes
+     * 2L + 1, every glass layer born at the far plane, and the tint made. The reasoning, and why no
+     * map re-bakes, is `PointShadowArray.growForGlass`'s.
+     *
+     * Returns the texture it replaced, which the caller destroys once `encoder` is submitted — the
+     * copies out of it are recorded there — or null when the array had already grown.
+     */
+    growForGlass(encoder, tintEdge, pipelines) {
+        if (this.tint !== null)
+            return null;
+        const old = this.texture;
+        const texture = depthArray(this.device, this.layers * 2);
+        for (let layer = 0; layer < this.layers; layer++) {
+            encoder.copyTextureToTexture({ texture: old, origin: { x: 0, y: 0, z: layer } }, { texture, origin: { x: 0, y: 0, z: 2 * layer } }, [OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, 1]);
+        }
+        this.texture = texture;
+        this.arrayView = texture.createView({ dimension: '2d-array' });
+        this.layerViews = layerViewsOf(texture, this.layers * 2);
+        /* Nothing is nearer a lamp than a pane that has not been drawn. */
+        for (let layer = 0; layer < this.layers; layer++) {
+            encoder
+                .beginRenderPass({
+                label: 'pointShadow.glass.clear',
+                colorAttachments: [],
+                depthStencilAttachment: {
+                    view: this.layerViews[2 * layer + 1],
+                    depthClearValue: 1,
+                    depthLoadOp: 'clear',
+                    depthStoreOp: 'store',
+                },
+            })
+                .end();
+        }
+        this.tint = new GpuPointGlassTint(this.device, pipelines, this.faceSize, tintEdge, this.layers, RESOLVE_SLOTS, encoder);
+        return old;
+    }
+    /** The scratch into physical layer `physical`'s region for `face`. */
+    resolveInto(encoder, physical, face, far, near) {
+        const view = this.layerViews[physical];
         if (view === undefined)
             return;
         const slot = this.ring.allocate();
@@ -197,15 +257,18 @@ export class GpuPointShadowArray {
     /** Start a frame's bakes. See the ring: slots are reused and nothing is freed. */
     beginFrame() {
         this.ring.reset();
+        this.tint?.beginFrame();
     }
     /** Upload every slot this frame's resolves took, in one write, before the encoder is submitted. */
     flush() {
         this.ring.flush();
+        this.tint?.flush();
     }
     dispose() {
         this.texture.destroy();
         this.scratch.destroy();
         this.ring.dispose();
+        this.tint?.dispose();
     }
 }
 export class GpuPointShadowMap {
@@ -280,7 +343,7 @@ export class GpuPointShadowMap {
             return 0;
         for (let face = first; face < last; face++) {
             renderFace(array.scratchView, pointShadowFaceViewProj(face, plan.x, plan.y, plan.z, plan.near, plan.range, scratch));
-            resolveFace(this.layer, face, plan.range, plan.near);
+            resolveFace(this.layer, face, plan.range, plan.near, plan.x, plan.y, plan.z);
         }
         this.image.completeBake(last, plan.x, plan.y, plan.z, plan.range, plan.near, plan.sourceRadius);
         return last - first;
@@ -288,3 +351,25 @@ export class GpuPointShadowMap {
     /** Nothing to free: every GPU object belongs to `GpuPointShadowArray` now. */
     dispose() { }
 }
+/** The depth array, copyable so glass can interleave it without a re-bake. */
+function depthArray(device, layers) {
+    return device.createTexture({
+        label: 'pointShadow.array',
+        size: [OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, layers],
+        format: SHADOW_FORMAT,
+        usage: USAGE_RENDER_ATTACHMENT | USAGE_TEXTURE_BINDING | USAGE_COPY,
+    });
+}
+/** One single-layer view per physical layer: a depth attachment takes exactly one. */
+function layerViewsOf(texture, layers) {
+    const views = [];
+    for (let layer = 0; layer < layers; layer++) {
+        views.push(texture.createView({
+            label: `pointShadow.layer${layer}`,
+            dimension: '2d',
+            baseArrayLayer: layer,
+            arrayLayerCount: 1,
+        }));
+    }
+    return views;
+}

package/dist/render/backend/webgpu/postPass.d.ts

@@ -174,14 +174,20 @@ export declare const ADDITIVE_BLEND: GPUBlendState;
 /** A fullscreen pass over one or more inputs, writing to one colour target. */
 export declare function postPipeline(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, format: GPUTextureFormat, blend?: GPUBlendState): GPURenderPipeline;
 /**
- * The temporal resolve's block and its three inputs.
+ * The same over several colour targets, in the fragment's output order: the temporal resolve
+ * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
+ * rather than built per call, since this is asked for every frame.
+ */
+export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[]): GPURenderPipeline;
+/**
+ * The temporal resolve's block and its four inputs.
  *
  * Named like the occlusion's beside it, and for the same reason `BLOOM_DOWNSAMPLE_FIELDS` is: a
  * block read by assumption rather than by name is a uniform written to the wrong offset, which
  * draws a plausible picture.
  */
 export declare const TAA_FRAG_FIELDS: UniformFields;
-export declare const TAA_FRAG_SIZE: 80;
+export declare const TAA_FRAG_SIZE: 112;
 export declare const TAA_UNIFORMS: 1;
 export declare const TAA_TEXTURES: {
     readonly uScene: {
@@ -194,11 +200,21 @@ export declare const TAA_TEXTURES: {
         readonly sampler: 35;
         readonly type: "sampler2D";
     };
-    readonly uDepth: {
+    readonly uFlicker: {
         readonly texture: 36;
         readonly sampler: 37;
         readonly type: "sampler2D";
     };
+    readonly uFlickerMotion: {
+        readonly texture: 38;
+        readonly sampler: 39;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 40;
+        readonly sampler: 41;
+        readonly type: "sampler2D";
+    };
 };
 /**
  * The order-independent resolve's inputs. It has no uniform block of its own — the whole pass is
@@ -289,20 +305,10 @@ export declare const MEDIUM_TEXTURES: {
         readonly sampler: 33;
         readonly type: "sampler2D";
     };
-    readonly uStaticShadowMap: {
+    readonly uSunShadows: {
         readonly texture: 34;
         readonly sampler: 35;
-        readonly type: "sampler2D";
-    };
-    readonly uPeeledShadowMap: {
-        readonly texture: 36;
-        readonly sampler: 37;
-        readonly type: "sampler2D";
-    };
-    readonly uDynamicShadowMap: {
-        readonly texture: 38;
-        readonly sampler: 39;
-        readonly type: "sampler2D";
+        readonly type: "sampler2DArray";
     };
 };
 export declare const MEDIUM_UPSAMPLE_UNIFORMS: 1;

package/dist/render/backend/webgpu/postPass.js

@@ -244,7 +244,20 @@ export const ADDITIVE_BLEND = {
 };
 /** A fullscreen pass over one or more inputs, writing to one colour target. */
 export function postPipeline(cache, device, layout, key, fragment, format, blend) {
-    return cache.get(key, () => ({
+    return cache.get(key, () => describePost(device, layout, key, fragment, [
+        blend === undefined ? { format } : { format, blend },
+    ]));
+}
+/**
+ * The same over several colour targets, in the fragment's output order: the temporal resolve
+ * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
+ * rather than built per call, since this is asked for every frame.
+ */
+export function postPipelineTargets(cache, device, layout, key, fragment, targets) {
+    return cache.get(key, () => describePost(device, layout, key, fragment, targets));
+}
+function describePost(device, layout, key, fragment, targets) {
+    return {
         label: key,
         layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
         vertex: {
@@ -254,7 +267,7 @@ export function postPipeline(cache, device, layout, key, fragment, format, blend
         fragment: {
             module: shaderModule(device, { label: key, code: fragment }),
             entryPoint: 'main',
-            targets: [blend === undefined ? { format } : { format, blend }],
+            targets,
         },
         /*
          * No depth at all, which is what makes this different from every other pipeline here: the
@@ -262,10 +275,10 @@ export function postPipeline(cache, device, layout, key, fragment, format, blend
          * disables the test, the write and culling by hand for the same draw.
          */
         primitive: { topology: 'triangle-list', cullMode: 'none' },
-    }));
+    };
 }
 /**
- * The temporal resolve's block and its three inputs.
+ * The temporal resolve's block and its four inputs.
  *
  * Named like the occlusion's beside it, and for the same reason `BLOOM_DOWNSAMPLE_FIELDS` is: a
  * block read by assumption rather than by name is a uniform written to the wrong offset, which