@driftengine/core 3.61.0

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

@@ -0,0 +1,280 @@
+import { mat3 } from 'gl-matrix';
+import { LIVE_POINT_SHADOW_MAPS, POINT_SHADOW_POOL } from '../../lightBudget.js';
+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 { UniformRing } from './uniformRing.js';
+/**
+ * A point light's shadow on this device: one octahedral layer, filled a face at a time.
+ *
+ * **The state is `PointShadowImage`'s and so is every decision in it**, which is what makes
+ * this file short: a cube texture, six single-layer views to attach, one cube view to sample,
+ * and a loop that opens a pass per face. Six shipped bug fixes come with the image rather than
+ * being re-earned here — see that module.
+ *
+ * **Six passes, not six draws into one.** WebGPU attaches exactly one texture subresource to a
+ * depth attachment, so a face is a render pass of its own; the clear that the GL path gets from
+ * `gl.clear` is the pass's own `depthClearValue`. The cost is the same either way — the caster
+ * set is walked once per face — which is why `pointShadowBudget.ts` exists on both backends.
+ */
+const USAGE_RENDER_ATTACHMENT = 0x10;
+const USAGE_TEXTURE_BINDING = 0x4;
+const USAGE_UNIFORM_DST = 0x40 | 0x8; // UNIFORM | COPY_DST
+const VISIBILITY_FRAGMENT = 0x2;
+/**
+ * Slots for one frame's resolves: every pool layer's six faces, which no budget ever reaches.
+ *
+ * At 256 bytes a slot that is 24 KB of staging for a ceiling nothing approaches — the face
+ * budget is a handful a frame — and the alternative is `allocate` returning null and a face
+ * silently not landing in its layer.
+ */
+const RESOLVE_SLOTS = (POINT_SHADOW_POOL + LIVE_POINT_SHADOW_MAPS) * FACE_COUNT;
+/** `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. */
+const faceRotation = mat3.create();
+/** One mat3x3 column, staged so `writeFloats` takes an array without allocating one. */
+const rotationColumn = new Float32Array(3);
+/**
+ * Every point light's shadow as one array texture, and the scratch that fills it.
+ *
+ * The WebGPU half of `pointShadowArray.ts`; the reasoning lives there, and this is one texture,
+ * one scratch and a pipeline. **The scratch is a separate texture on this backend too**, and not
+ * for WebGL2's reason: WebGPU rejects a pass outright for holding a texture it is also sampling,
+ * where WebGL2 raises `INVALID_OPERATION` at the draw. Two ways of saying the same thing, and
+ * both say the resolve reads the scratch.
+ */
+export class GpuPointShadowArray {
+    /** The array, as the shader samples it. */
+    view;
+    layers;
+    /** Where a face is rendered before it is resolved. One, shared by every light. */
+    scratchView;
+    texture;
+    scratch;
+    layerViews = [];
+    pipeline;
+    bindGroup;
+    /**
+     * A slot per resolved face, not one buffer written six times.
+     *
+     * **`queue.writeBuffer` does not interleave with encoded commands.** Writes are ordered on
+     * the queue timeline and the encoder is submitted afterwards, so six writes between six
+     * passes give all six passes the *last* face's rotation and index — and five of them then
+     * discard every fragment, because `uFaceIndex` does not match. The layer stays empty and the
+     * light stops casting, which reads as a lighting change rather than as a missing upload.
+     *
+     * That is the failure `UniformRing` exists for, described in its own header, and this file
+     * reproduced it exactly. Found by capturing: WebGPU diverged from WebGL2 by seven times and
+     * came out *brighter*, and flipping a coordinate in the resolve changed the frame by not one
+     * pixel — which is what an empty map looks like.
+     */
+    ring;
+    constructor(device, faceSize, lightCount, 
+    /** Layers above the point pool, for a world's casting rectangles. See `pointShadowArray.ts`. */
+    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.scratch = device.createTexture({
+            label: 'pointShadow.scratch',
+            size: [faceSize, faceSize],
+            format: SHADOW_FORMAT,
+            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');
+        /*
+         * `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
+         * Float, and nothing here asks the hardware to filter.
+         */
+        const layout = device.createBindGroupLayout({
+            label: 'pointShadow.resolve.layout',
+            entries: [
+                {
+                    binding: 1,
+                    visibility: VISIBILITY_FRAGMENT,
+                    buffer: {
+                        type: 'uniform',
+                        hasDynamicOffset: true,
+                        minBindingSize: RESOLVE_UNIFORM_SIZE,
+                    },
+                },
+                {
+                    binding: 32,
+                    visibility: VISIBILITY_FRAGMENT,
+                    texture: { sampleType: 'unfilterable-float' },
+                },
+                { binding: 33, visibility: VISIBILITY_FRAGMENT, sampler: { type: 'non-filtering' } },
+            ],
+        });
+        this.bindGroup = device.createBindGroup({
+            label: 'pointShadow.resolve',
+            layout,
+            entries: [
+                { binding: 1, resource: { buffer: this.ring.buffer, size: RESOLVE_UNIFORM_SIZE } },
+                { binding: 32, resource: this.scratchView },
+                { binding: 33, resource: device.createSampler({ label: 'pointShadow.resolve.sampler' }) },
+            ],
+        });
+        this.pipeline = device.createRenderPipeline({
+            label: 'pointShadow.resolve',
+            layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
+            vertex: {
+                module: device.createShaderModule({ code: OCTAHEDRAL_RESOLVE_VERT_WGSL }),
+                entryPoint: 'main',
+            },
+            fragment: {
+                module: device.createShaderModule({ code: OCTAHEDRAL_RESOLVE_FRAG_WGSL }),
+                entryPoint: 'main',
+                targets: [],
+            },
+            primitive: { topology: 'triangle-list' },
+            /*
+             * `always`, because this is a copy and not a render: the layer holds whatever the previous
+             * bake of this light left, and a fragment that lost a comparison would leave half of one
+             * image and half of another.
+             */
+            depthStencil: { format: SHADOW_FORMAT, depthWriteEnabled: true, depthCompare: 'always' },
+        });
+    }
+    /**
+     * Write the scratch's contents into `layer`'s region for `face`.
+     *
+     * A pass of its own on the caller's encoder, with `load` rather than `clear`: the other five
+     * faces of this layer are already there and must survive. `discard` in the shader is what
+     * keeps this face to its own region.
+     */
+    resolve(encoder, layer, face, far, near) {
+        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. */
+        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, column * 16, rotationColumn);
+        }
+        this.ring.writeInt(slot, 48, face);
+        this.ring.writeFloat(slot, 52, far);
+        this.ring.writeFloat(slot, 56, near);
+        this.ring.writeFloat(slot, 60, OCTAHEDRAL_EDGE);
+        const pass = encoder.beginRenderPass({
+            label: 'pointShadow.resolve',
+            colorAttachments: [],
+            depthStencilAttachment: {
+                view,
+                depthLoadOp: 'load',
+                depthStoreOp: 'store',
+            },
+        });
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, this.bindGroup, [slot]);
+        pass.draw(3);
+        pass.end();
+    }
+    /** Start a frame's bakes. See the ring: slots are reused and nothing is freed. */
+    beginFrame() {
+        this.ring.reset();
+    }
+    /** Upload every slot this frame's resolves took, in one write, before the encoder is submitted. */
+    flush() {
+        this.ring.flush();
+    }
+    dispose() {
+        this.texture.destroy();
+        this.scratch.destroy();
+        this.ring.dispose();
+    }
+}
+export class GpuPointShadowMap {
+    size;
+    /** Which layer of the shared array this map's image lives in. See `pointShadowMap.ts`. */
+    layer;
+    array;
+    image = new PointShadowImage();
+    range = createFaceRange();
+    constructor(array, layer, size) {
+        this.array = array;
+        this.layer = layer;
+        this.size = size;
+    }
+    get far() {
+        return this.image.far;
+    }
+    get near() {
+        return this.image.near;
+    }
+    get sourceRadius() {
+        return this.image.sourceRadius;
+    }
+    get hasBaked() {
+        return this.image.hasBaked;
+    }
+    get presence() {
+        return this.image.presence;
+    }
+    matchesSource(x, y, z, range, near, sourceRadius = DEFAULT_SOURCE_RADIUS, tolerance = 0) {
+        return this.image.matchesSource(x, y, z, range, near, sourceRadius, tolerance);
+    }
+    advance(dt) {
+        this.image.advance(dt);
+    }
+    forget() {
+        this.image.forget();
+    }
+    /**
+     * Render up to `maxFaces` of the six, resuming a bake already under way.
+     *
+     * Returns how many faces were rendered. `renderFace` is handed the attachment and the face's
+     * view-projection and is expected to open a pass and draw the casters into it — the renderer
+     * owns the encoder and the pipelines, so it owns the pass.
+     *
+     * The scratch matrix is the caller's for the same reason `pointShadowFaceViewProj` takes one:
+     * this runs once per face of every bake and `AGENTS.md` allows no allocation there.
+     */
+    bake(x, y, z, range, renderFace, resolveFace, scratch, near = POINT_SHADOW_NEAR, sourceRadius = DEFAULT_SOURCE_RADIUS, maxFaces = FACE_COUNT) {
+        /*
+         * What to render now, **and what to render it for**. A bake in flight owns the parameters
+         * it started with; the arguments here only propose one that is not already under way. See
+         * `planBake` for the permanent artefact reading them unconditionally left in a moving
+         * light's map, and `pointShadowMap.ts` for the other backend making the identical call.
+         */
+        const plan = this.image.planBake(x, y, z, range, near, sourceRadius, maxFaces, this.range);
+        const { first, last } = plan;
+        if (last <= first)
+            return 0;
+        const array = this.array();
+        if (array === null)
+            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);
+        }
+        this.image.completeBake(last, plan.x, plan.y, plan.z, plan.range, plan.near, plan.sourceRadius);
+        return last - first;
+    }
+    /** Nothing to free: every GPU object belongs to `GpuPointShadowArray` now. */
+    dispose() { }
+}

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

@@ -0,0 +1,342 @@
+import { RUSH_FRAG_WGSL } from '../../shaders/generated/rush.wgsl.ts';
+import { BLOOM_DOWNSAMPLE_FRAG_WGSL, BLOOM_PREFILTER_FRAG_WGSL, BLOOM_UPSAMPLE_FRAG_WGSL } from '../../shaders/generated/bloom.wgsl.ts';
+import { AO_BLUR_FRAG_WGSL, AO_FRAG_WGSL } from '../../shaders/generated/ambientOcclusion.wgsl.ts';
+import { TEMPORAL_RESOLVE_FRAG_WGSL } from '../../shaders/generated/temporalResolve.wgsl.ts';
+import { OIT_RESOLVE_FRAG_WGSL } from '../../shaders/generated/oitResolve.wgsl.ts';
+import { DECAL_PROJECT_FRAG_WGSL } from '../../shaders/generated/decalProject.wgsl.ts';
+import { SSR_TRACE_FRAG_WGSL } from '../../shaders/generated/ssrTrace.wgsl.ts';
+import { SSR_RESOLVE_FRAG_WGSL } from '../../shaders/generated/ssrResolve.wgsl.ts';
+import { MEDIUM_FRAG_WGSL, MEDIUM_UPSAMPLE_FRAG_WGSL } from '../../shaders/generated/globalMedium.wgsl.ts';
+import type { UniformFields } from './scatterPass.ts';
+import type { PipelineCache } from './pipelineCache.ts';
+/**
+ * The composite: everything that happens to the frame after the world is drawn.
+ *
+ * **The scene lands off-screen and one pass puts it on the canvas.** That pass is `rush.ts`, and
+ * it is one shader rather than four because every one of these effects reads the same resolved
+ * image: the speed blur, the camera motion blur, the occlusion it multiplies in, the bloom it
+ * adds and the tone curve it ends on. `sceneTarget.ts` makes the same argument on the other
+ * backend, and both are why `bindMeshPass` grades in the mesh pass *only* when there is no
+ * composite to grade in.
+ *
+ * **What differs here is depth.** WebGL2 resolves a multisampled depth buffer with
+ * `blitFramebuffer` and reads it back; WebGPU has no multisample depth resolve at all. So a
+ * frame that wants occlusion or motion blur gets a resolve of its own, written below, which
+ * reads sample zero through `texture_depth_multisampled_2d` and writes it to a single-sample
+ * float target the generated shaders can sample as an ordinary texture.
+ */
+export declare const RUSH_FRAG_FIELDS: UniformFields;
+export declare const RUSH_FRAG_SIZE: 160;
+declare const RUSH_UNIFORMS: 1;
+declare const RUSH_TEXTURES: {
+    readonly uScene: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+    readonly uAo: {
+        readonly texture: 36;
+        readonly sampler: 37;
+        readonly type: "sampler2D";
+    };
+    readonly uBloom: {
+        readonly texture: 38;
+        readonly sampler: 39;
+        readonly type: "sampler2D";
+    };
+    readonly uGradeLut: {
+        readonly texture: 40;
+        readonly sampler: 41;
+        readonly type: "sampler3D";
+    };
+};
+export declare const AO_FRAG_FIELDS: UniformFields;
+export declare const AO_FRAG_SIZE: 96;
+export declare const AO_BLUR_FIELDS: UniformFields;
+export declare const AO_BLUR_SIZE: 32;
+export declare const MEDIUM_FRAG_FIELDS: UniformFields;
+export declare const MEDIUM_FRAG_SIZE: 240;
+export declare const MEDIUM_UPSAMPLE_FIELDS: UniformFields;
+export declare const MEDIUM_UPSAMPLE_SIZE: 32;
+export declare const BLOOM_PREFILTER_FIELDS: UniformFields;
+/**
+ * The other two stages' blocks, read by name like every other block here.
+ *
+ * **Named rather than assumed to be the prefilter's**, because they are not: the downsample has
+ * a texel and no threshold, and the upsample has neither — it has a radius. All three happen to
+ * be sixteen bytes, which is exactly the coincidence that would let a wrong offset go unnoticed.
+ * `postField` throws on a name a block does not have, and that is the point of asking.
+ */
+export declare const BLOOM_DOWNSAMPLE_FIELDS: UniformFields;
+export declare const BLOOM_UPSAMPLE_FIELDS: UniformFields;
+/** The widest of the three, so one slot shape holds any stage's block. */
+export declare const BLOOM_STAGE_SIZE: number;
+/**
+ * What the scene is drawn into when the composite exists.
+ *
+ * `rgba16float` where the profile asks for an HDR scene, because that is the whole point of one:
+ * a bright pixel keeps its range until the tone curve, instead of being clipped at 1 by the mesh
+ * pass and then tone-mapped from a value that has already lost the information. `renderer.ts`
+ * calls the same option `hdrScene` and `keepsRange` for the same reason — a bloom threshold in
+ * scene units means nothing against a clamped buffer.
+ */
+export declare function sceneColorFormat(hdr: boolean): GPUTextureFormat;
+/** A single-sample depth the generated shaders can sample. See the module comment. */
+export declare const RESOLVED_DEPTH_FORMAT: GPUTextureFormat;
+export declare function createDepthResolveLayout(device: GPUDevice, multisampled: boolean): GPUBindGroupLayout;
+export declare function depthResolvePipeline(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, multisampled: boolean): GPURenderPipeline;
+/**
+ * One texture, one sampler, one uniform block: the shape every stage of this chain has.
+ *
+ * The bloom stages and the occlusion blur all read a source and a size, so they share a layout
+ * builder rather than three copies of the same six lines.
+ */
+export declare function createPostStageLayout(device: GPUDevice, uniformBinding: number, uniformSize: number, textures: readonly {
+    binding: {
+        texture: number;
+        sampler: number;
+    };
+    filterable?: boolean;
+    /**
+     * `'2d'` unless said otherwise, because every post input but one is a screen-sized target.
+     *
+     * The exception is the colour grade's lookup table, which is a cube of display values and
+     * declares `texture_3d<f32>` in the generated WGSL. A layout that left this at `'2d'` is
+     * rejected at bind-group creation rather than at draw — which is the *good* case, and is
+     * only good because it is stated: a dimension is a property of the texture and never of the
+     * pass reading it, which is the lesson `filterable` above records twice already.
+     */
+    dimension?: GPUTextureViewDimension;
+}[]): GPUBindGroupLayout;
+/**
+ * Additive, for the way back up the bloom pyramid.
+ *
+ * Each level is added *into* the one above it rather than replacing it, so level 0 ends up
+ * holding every octave at once — which is what makes the falloff the sum of the octaves rather
+ * than one kernel's. `bloomPass.ts` reaches the same place with `blendFunc(ONE, ONE)` and a
+ * `loadOp` of `load` is the other half of it here: a cleared attachment would discard the
+ * level the downsample just wrote and add the octave to nothing.
+ */
+/**
+ * What composites the order-independent buffers over the finished scene.
+ *
+ * Against a fragment carrying the average colour and the revealage, this computes
+ * `average * (1 - reveal) + scene * reveal` — which is the resolve. Doing it in the blend rather
+ * than by sampling means the pass never reads the target it writes.
+ */
+export declare const OIT_COMPOSITE_BLEND: GPUBlendState;
+/**
+ * What a drawn decal does to the pixel under it: `dst * src`.
+ *
+ * White is the identity, so a fragment the projector missed changes nothing and the shader needs
+ * no branch and no discard. It multiplies the *lit* pixel, which is the whole reason a mark placed
+ * this late still takes the receiver's lighting — `decalProject.ts` argues that where it is
+ * written, and `decalPass.ts` sets the same pair on the other backend.
+ */
+/**
+ * What a global medium does to the pixel under it: `dst * transmittance + inscatter`.
+ *
+ * **The transfer equation for one segment, written as a blend state.** The march puts scattered
+ * light in `rgb` and how much of the frame survives the journey in `a`, so `(one, src-alpha)` is
+ * exactly the integral — and the composite therefore never samples the colour it is modifying,
+ * which is the read both backends are entitled to call undefined.
+ *
+ * Alpha is `(zero, one)`: the frame's own alpha is not the medium's to spend. The scene target
+ * carries it to the canvas, and a medium that wrote there would make a foggy frame translucent.
+ */
+export declare const MEDIUM_TRANSMIT_BLEND: GPUBlendState;
+export declare const DECAL_MULTIPLY_BLEND: GPUBlendState;
+/**
+ * `over`, against colour a pass has already multiplied by its own coverage.
+ *
+ * What the screen-space reflection writes and what composites it: the trace multiplies what it
+ * found by how much of it lands, so two reflective surfaces overlapping layer the way two blended
+ * surfaces do rather than the way two independent guesses do — and the resolve then never has to
+ * sample the colour it is compositing onto.
+ */
+export declare const PREMULTIPLIED_OVER_BLEND: GPUBlendState;
+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.
+ *
+ * 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_UNIFORMS: 1;
+export declare const TAA_TEXTURES: {
+    readonly uScene: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uHistory: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 36;
+        readonly sampler: 37;
+        readonly type: "sampler2D";
+    };
+};
+/**
+ * The order-independent resolve's inputs. It has no uniform block of its own — the whole pass is
+ * two texture fetches and a divide — so only the textures are named here.
+ */
+export declare const OIT_TEXTURES: {
+    readonly uOitAccum: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uOitReveal: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+};
+/**
+ * A drawn decal's block and the one texture it reads.
+ *
+ * One block per mark and a frame may draw many, so the buffer holds an aligned slot each and the
+ * pass binds by dynamic offset — the arrangement the bloom chain already uses, and for the same
+ * reason: `queue.writeBuffer` does not interleave with recorded commands, so one block rewritten
+ * between two passes gives both passes the last write.
+ */
+export declare const DECAL_FRAG_FIELDS: UniformFields;
+export declare const DECAL_FRAG_SIZE: 192;
+export declare const DECAL_UNIFORMS: 1;
+export declare const DECAL_TEXTURES: {
+    readonly uDecalDepth: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+};
+/**
+ * The reflection trace's block and its two inputs, and the resolve's one.
+ *
+ * One block per surface and a frame may draw several, so the buffer holds an aligned slot each and
+ * the pass binds by dynamic offset — the arrangement the bloom chain and the decals already use,
+ * and for the reason `bloomStaging` states: `queue.writeBuffer` does not interleave with recorded
+ * commands, so one block rewritten between two passes gives both passes the last write.
+ */
+export declare const SSR_FRAG_FIELDS: UniformFields;
+export declare const SSR_FRAG_SIZE: 272;
+export declare const SSR_UNIFORMS: 1;
+export declare const SSR_TEXTURES: {
+    readonly uSsrDepth: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uSsrScene: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+};
+export declare const SSR_RESOLVE_TEXTURES: {
+    readonly uSsrReflection: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+};
+/**
+ * The resolve's layout: one texture and no uniform block.
+ *
+ * `createPostStageLayout` cannot express this — it makes a block mandatory, every other stage in
+ * the chain having one — and this pass has nothing to parameterise: it fetches a texel and hands it
+ * to the blend state. A buffer allocated, bound and never read is worse than a second builder.
+ */
+export declare function createSsrResolveLayout(device: GPUDevice): GPUBindGroupLayout;
+/**
+ * The resolve's layout: two textures and no uniform block.
+ *
+ * **`createPostStageLayout` cannot express this**, because every other pass in the chain has a
+ * block and it makes one mandatory. This pass has nothing to parameterise — it fetches the two
+ * buffers, divides and hands the result to the blend state — so a layout with a uniform binding
+ * nothing writes would be a buffer allocated, bound and never read.
+ */
+export declare function createOitResolveLayout(device: GPUDevice): GPUBindGroupLayout;
+export { MEDIUM_FRAG_WGSL, MEDIUM_UPSAMPLE_FRAG_WGSL };
+export declare const MEDIUM_UNIFORMS: 1;
+export declare const MEDIUM_TEXTURES: {
+    readonly uDepth: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uStaticShadowMap: {
+        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";
+    };
+};
+export declare const MEDIUM_UPSAMPLE_UNIFORMS: 1;
+export declare const MEDIUM_UPSAMPLE_TEXTURES: {
+    readonly uMedium: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+};
+export { RUSH_FRAG_WGSL, AO_FRAG_WGSL, AO_BLUR_FRAG_WGSL, TEMPORAL_RESOLVE_FRAG_WGSL, OIT_RESOLVE_FRAG_WGSL, DECAL_PROJECT_FRAG_WGSL, SSR_TRACE_FRAG_WGSL, SSR_RESOLVE_FRAG_WGSL, };
+export { BLOOM_PREFILTER_FRAG_WGSL, BLOOM_DOWNSAMPLE_FRAG_WGSL, BLOOM_UPSAMPLE_FRAG_WGSL };
+export { RUSH_UNIFORMS, RUSH_TEXTURES };
+export declare const AO_UNIFORMS: 1;
+export declare const AO_TEXTURES: {
+    readonly uDepth: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+};
+export declare const AO_BLUR_UNIFORMS: 1;
+export declare const AO_BLUR_TEXTURES: {
+    readonly uAo: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 34;
+        readonly sampler: 35;
+        readonly type: "sampler2D";
+    };
+};
+export declare const BLOOM_UNIFORMS: 1;
+export declare const BLOOM_TEXTURES: {
+    readonly uSource: {
+        readonly texture: 32;
+        readonly sampler: 33;
+        readonly type: "sampler2D";
+    };
+};