@driftengine/core 4.4.2 → 4.6.0

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

@@ -1,5 +1,6 @@
 import type { ProbeBakeOptions } from '../../reflectionProbe.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
+import type { Mover } from '../../recon/mover.ts';
 import type { Vec3 } from '../../../math/color.ts';
 import { Camera } from '../../camera.ts';
 import type { PickHit, PickableSource } from '../../pickable.ts';
@@ -54,9 +55,12 @@ import type { Bounds } from '../../../math/bounds.ts';
 import { type ComputeDefinition, type ComputeHandle } from '../../compute.ts';
 import type { PassDefinition, PassHandle } from '../../pass.ts';
 import { GpuInstancedBatch } from './instanced.ts';
-import type { MeshInstances } from '../../instances.ts';
+import type { InstancedOptions, MeshInstances } from '../../instances.ts';
 import { LightField } from '../../driftLight/lightField.ts';
 import type { LightFieldOptions, LightFieldSource } from '../../driftLight/lightField.ts';
+import type { DenseLightVolume } from '../../driftLight/denseField.ts';
+import { WorldLightField } from '../../driftLight/worldLightField.ts';
+import type { WorldLightFieldOptions } from '../../driftLight/worldLightField.ts';
 /** Which directional shadow map a pass is filling, matching `renderer.ts`. */
 type ShadowLayer = 'static' | 'static-peel' | 'dynamic';
 export declare class WebGPURenderer implements RendererApi {
@@ -156,6 +160,8 @@ export declare class WebGPURenderer implements RendererApi {
      * caller who passed null gets — rather than reading a slot this frame has already re-let.
      */
     private skinPaletteSlot;
+    /** The palette `skinPaletteSlot` was uploaded from, for a skinned mover to copy. See `Mover`. */
+    private skinPaletteData;
     private readonly surface;
     /** The encoder for the frame in flight, or null between frames. */
     private encoder;
@@ -163,6 +169,27 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly meshPresent;
     private pass;
     private readonly pipelines;
+    /**
+     * The pipelines a reconstructing frame's blended draws are built for: the reconstructed picture's
+     * format at one sample, which is where `LatePass` draws them. Aliased to `pipelines` when the
+     * world already lands on exactly that, as `overlayPipelines` is.
+     */
+    private readonly latePipelines;
+    /** The blended draws of a reconstructing frame, drawn after the upscale. See `LatePass`. */
+    private latePass;
+    /** A late draw asked to refract: `runLate` copies the reconstructed picture before replaying. */
+    private lateRefractWanted;
+    /** The refraction copy's mip chain, recorded after each copy: what frosted glass reads. */
+    private refractMips;
+    /**
+     * The refraction copy's sampler: filtering, and **between levels as well**, so a frosted pane's
+     * level falls smoothly between two blurs rather than stepping from one to the next.
+     */
+    private refractSampler;
+    /** One glass resolution reused by every draw, so a pane allocates nothing. See `glass.ts`. */
+    private readonly glassScratch;
+    /** `issueCommand` bound once, so the late replay allocates no closure per frame. */
+    private readonly issueBound;
     /**
      * The same pipelines again, built for the canvas, for anything drawn after `endFrame`.
      *
@@ -489,6 +516,12 @@ export declare class WebGPURenderer implements RendererApi {
      * what the layout already declares.
      */
     private bloomGroups;
+    /**
+     * The picture the bloom reads, and its size: the scene target, or while reconstructing the
+     * resolved picture at the drawing buffer's size. See `rebuildBloomGroups`.
+     */
+    private bloomSourceWidth;
+    private bloomSourceHeight;
     private frameWidth;
     private frameHeight;
     /**
@@ -640,13 +673,25 @@ export declare class WebGPURenderer implements RendererApi {
      * the *unsharpened* result — sharpening into the history would sharpen a sharpened picture every
      * frame, which is the halo the reference's own clamp exists to prevent, compounded.
      *
-     * The motion target is render size and carries a drawn object's own motion where something wrote
-     * one. **Nothing writes it yet**, so it is cleared every frame and every pixel takes the camera's
-     * motion, which the resolve derives from the depth and the reprojection. Static geometry is
-     * exact that way and a moving object ghosts until the motion pass lands.
+     * The motion target is render size and carries a drawn object's own motion where the motion pass
+     * wrote one — a draw that named its mover, or passed last frame's matrix. Every other texel is
+     * cleared, and the resolve takes the camera's motion there, derived from the depth and the
+     * reprojection: exact for anything that did not move. See `MotionPass`.
      */
     private reconHistories;
     private reconHistoryViews;
+    /**
+     * Each output pixel's flicker record, a pair swapped with the histories: the temporal resolve's
+     * anti-flicker, over the reconstruction's own period (`recon/resolve.ts`).
+     */
+    private reconFlickers;
+    private reconFlickerViews;
+    /** Each output pixel's held depth swing, a pair of its own: see `recon/resolve.ts`. */
+    private reconSwings;
+    private reconSwingViews;
+    /** The anti-flicker's rule for the period last asked for, kept so a frame makes none. */
+    private reconFlickerPhases;
+    private reconFlickerRule;
     private reconWrite;
     private reconHasHistory;
     private reconShown;
@@ -665,40 +710,24 @@ export declare class WebGPURenderer implements RendererApi {
     private reconGroups;
     private reconSharpenGroups;
     private reconRushGroup;
-    /**
-     * What the motion pass will draw, recorded by `drawMesh` and spent once a frame.
-     *
-     * A parallel array of meshes and one flat matrix buffer rather than an array of objects, because
-     * this is written on the frame's hot path and the house rule about allocating there binds it: the
-     * matrices are copied into a buffer that only ever grows, and the count is what resets.
-     */
-    private readonly motionMeshes;
-    private motionMatrices;
-    private motionCount;
-    private motionLayout;
-    /**
-     * One pipeline per vertex stride, because a stride is a property of the *mesh*.
-     *
-     * Which optional attributes a mesh supplied decides how far apart its positions are, and this
-     * pass reads nothing but positions — so two meshes drawn by the same shader still need two
-     * vertex layouts. A map rather than a cache key on the pipeline cache: there is one shader here
-     * and a handful of strides in any scene.
-     */
-    private readonly motionPipelines;
-    private motionModule;
-    private motionPipelineLayout;
-    private motionFrameBuffer;
-    private motionDrawBuffer;
-    private motionDrawCapacity;
-    private motionGroup;
-    private readonly motionFrameStaging;
-    private motionDrawStaging;
+    /** The motion pass, made with the reconstruction's targets. See `MotionPass`. */
+    private motionPass;
+    /** This renderer's identity to a `Mover`. See `claimRendererId`. */
+    private readonly moverRenderer;
+    /** Frames begun, so a mover can tell last frame from any other. Advanced in `beginFrame`. */
+    private moverFrame;
+    /** Between `beginFrame` and `endFrame`. A change outside it is the next frame's. */
+    private inFrame;
+    private warnedMoverTwice;
     /** The scene's own clip transform with the generated shaders' y negation folded in. */
     private readonly motionRaster;
     private reconSizeKey;
     /** Last frame's raw view-projection and its inverse, and the two eyes. */
     private readonly reconPreviousRawViewProj;
     private readonly reconInverseViewProj;
+    /** The inverse and the reprojection, multiplied in double precision. See `runReconstruction`. */
+    private readonly reconInverse64;
+    private readonly reconReprojection64;
     private readonly reconPreviousInverseViewProj;
     private readonly reconEye;
     private readonly reconPreviousEye;
@@ -826,6 +855,8 @@ export declare class WebGPURenderer implements RendererApi {
     /** Said once for the whole renderer. See `refuseOitMultisampled`. */
     private oitMultisampleRefused;
     private oitReplaying;
+    /** `uSurfaceScene`, resolved once a pass. See `surfaceScene.ts`. */
+    private readonly surfaceScene;
     /** Which buffer the replay is filling, which the pipeline key must carry. */
     private oitMode;
     /**
@@ -1056,6 +1087,8 @@ export declare class WebGPURenderer implements RendererApi {
     /** Whether the bound material is seen from both faces. See `SurfaceMaterial.doubleSided`. */
     private materialDoubleSided;
     createSurfaceTexture(source: TexImageSource, options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    /** Several images of one size as an array's layers. See `RendererApi.createSurfaceTextureArray`. */
+    createSurfaceTextureArray(sources: readonly TexImageSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
     /**
      * GPU textures an `updateSurfaceTexture` replaced, destroyed when the next frame begins.
      *
@@ -1134,6 +1167,13 @@ export declare class WebGPURenderer implements RendererApi {
     /** How bright the environment the surfaces drawn next reflect is. See `renderer.ts`. */
     setEnvironmentGain(gain: number): void;
     setSurfaceGrain(amount: number): void;
+    /**
+     * How much of the surfaces drawn next survives a screen-door dither. See `renderer.ts`.
+     *
+     * Written straight into the scratch block rather than through `material()`'s callback, because
+     * this one is called per crossfading region per frame and a closure per call is an allocation.
+     */
+    setDitherFade(amount: number): void;
     /**
      * How strong the microscopic relief on the surfaces drawn next is, and how coarse.
      *
@@ -1474,6 +1514,8 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly waterLayout;
     /** The one-pixel stand-in, kept so the water bind group can be rebuilt without one. */
     private readonly blankView;
+    /** The blank texel as a one-layer array: the stand-in every surface-texture binding takes. */
+    private readonly blankSurfaceView;
     private readonly blankSampler;
     /**
      * A slot per body, not one buffer rewritten before each draw.
@@ -1597,8 +1639,39 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly sdfTextVerts;
     private readonly sdfTextFrags;
     private readonly sdfTextBindGroups;
-    private readonly shadowMap;
-    private readonly shadowView;
+    /**
+     * The sun's static, moving and peeled maps, as layers of one texture (`shadowMap.ts`). The three
+     * views below are single layers, what each pass attaches; the two here are what is sampled.
+     */
+    private sunShadowTexture;
+    /** Every layer, for the lit pass, the light volumes and the medium. */
+    private sunArrayView;
+    /**
+     * The static layer alone, as an array, for the peel: it draws into another layer of the same
+     * texture, and a view covering that layer too would put it in two usages in one pass.
+     */
+    private sunStaticArrayView;
+    /** How many layers the sun's texture holds: its maps, and the two glass layers once glass casts. */
+    private sunLayerCount;
+    /** The glass depth layers, static then moving, once glass has cast. See `growSunForGlass`. */
+    private sunGlassViews;
+    /** The texture a growth replaced, destroyed once the encoder that copied out of it is submitted. */
+    private retiredSunTexture;
+    /** What the sun's light keeps through glass: two `rgba8unorm` layers, made when glass first casts. */
+    private sunTint;
+    /** The tint pass's layouts, per-draw block, groups and pipelines, made when glass first casts. */
+    private glassTint;
+    /** The tint pass open while the glass list is replayed into it. */
+    private tintPass;
+    /** True while the glass list is replayed into a glass depth layer through `casterSink`. */
+    private drawingGlassDepth;
+    /** Whether the open sun pass is the movers' layer, whose glass goes to the moving glass layer. */
+    private shadowLayerIsDynamic;
+    /** The glass tints' sampler: filtering, and between levels, for frost's coarser reads. */
+    private readonly tintSampler;
+    /** The light a tint pass is drawn for: xyz a direction (w 0) or a position (w 1). */
+    private readonly glassLight;
+    private shadowView;
     private readonly shadowLayout;
     /** The same layout plus the joint palette. See `createDepthBindGroupLayout`. */
     private readonly shadowSkinnedLayout;
@@ -1624,8 +1697,7 @@ export declare class WebGPURenderer implements RendererApi {
      * read twice — so a profile that switches peeling off gets no map and no pass on either
      * backend rather than a map nothing writes.
      */
-    private readonly peelMap;
-    private readonly peelView;
+    private peelView;
     /**
      * The movers' own layer: the character, the rope it swings on, and anything else that walks.
      *
@@ -1646,10 +1718,9 @@ export declare class WebGPURenderer implements RendererApi {
      * and therefore as lit — so nothing looked broken, only empty, which is why it survived the
      * port and every gate in it.
      */
-    private readonly dynamicMap;
-    private readonly dynamicView;
+    private dynamicView;
     /** The peel's own bind groups: `uPeelShadowLayer` at 1, and the static map to peel against. */
-    private readonly shadowPeelBindGroup;
+    private shadowPeelBindGroup;
     /**
      * The cutout casters' layout, and a bind group per cutout map for each layer, built the first
      * time a map casts and kept: a `createBindGroup` per draw is the allocation the house rules forbid.
@@ -1661,7 +1732,7 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly cutoutPeelGroups;
     private shadowPeelPassUniforms;
     private shadowPeelSampler;
-    private readonly scatterDepthPeelBindGroup;
+    private scatterDepthPeelBindGroup;
     /** Which layer the open pass is writing, so the sink picks the bindings that match it. */
     private shadowLayerIsPeel;
     /**
@@ -1732,6 +1803,10 @@ export declare class WebGPURenderer implements RendererApi {
      * Built once and held, rather than made per call: it closes over `this` and a fresh one
      * every frame would be an allocation in a per-frame path.
      */
+    /** The glass the open shadow pass was offered, kept for its own passes: `glassCasters.ts`. */
+    private readonly glassCasters;
+    /** One resolution every glass caster is read through, so recording one allocates nothing. */
+    private readonly glassCasterScratch;
     private readonly casterSink;
     /** Said once rather than every frame, because a full ring is a flood otherwise. */
     private warnedFull;
@@ -2016,7 +2091,7 @@ export declare class WebGPURenderer implements RendererApi {
      */
     drawMesh(mesh: GpuMesh, model: ArrayLike<number>, depthLayer?: number, tint?: Vec3 | null, 
     /** Where it was last frame. See `RendererApi.drawMesh`, and `runMotion` for what reads it. */
-    previousModel?: ArrayLike<number> | null): void;
+    previousModel?: ArrayLike<number> | Mover | null): void;
     /**
      * Draw a mesh that lets the world through, at `opacity`.
      *
@@ -2104,9 +2179,11 @@ export declare class WebGPURenderer implements RendererApi {
      * anyway, because WebGL2 *cannot* and a capability one backend has and the other does not is
      * the shape this repository spent a week removing.
      */
-    createInstanced(mesh: GpuMesh, capacity: number): GpuInstancedBatch;
-    /** Which meshes already carry a batch, so a second is refused rather than silently shared. */
-    private readonly instanced;
+    createInstanced(mesh: GpuMesh, capacity: number, options?: InstancedOptions): GpuInstancedBatch;
+    /** The device instance culls, built on the first culling draw. See `InstanceCullPass`. */
+    private instanceCulls;
+    /** Counts frames, so a batch knows when its cull slots were last taken. */
+    private cullFrame;
     /** Push placement and colour. Only the live prefix; see `GpuInstancedBatch.upload`. */
     uploadInstanced(batch: GpuInstancedBatch, data: MeshInstances): void;
     /** Draw every live instance, opaque. */
@@ -2115,6 +2192,18 @@ export declare class WebGPURenderer implements RendererApi {
     drawTranslucentInstanced(batch: GpuInstancedBatch, data: MeshInstances, opacity: number, options?: TranslucentMeshOptions): void;
     /** Release the placement. The mesh is the caller's and is not released. */
     disposeInstanced(batch: GpuInstancedBatch): void;
+    /**
+     * Write what a translucent draw shows through it into the material scratch: refraction's bend and
+     * absorption, and glass. Returns whether the frame's copy is there to read, and so whether
+     * `releaseSeeThrough` owes the scratch back.
+     *
+     * **A glass draw takes the copy even when it does not bend**, since a pane shows what is behind it
+     * either way. A copy that cannot be taken — a mirror, a probe bake — leaves both off, so the pane
+     * shades as ordinary translucency rather than sampling a stand-in. See `glass.ts`.
+     */
+    private bindSeeThrough;
+    /** Put the scratch back after `bindSeeThrough`: refraction and glass off. */
+    private releaseSeeThrough;
     /**
      * One draw, one material slot, one uniform slot, however many instances.
      *
@@ -2127,6 +2216,12 @@ export declare class WebGPURenderer implements RendererApi {
      * **What it gives up** against `drawMesh` is skinning and morphing, refused where the variant
      * is built, and a per-instance opacity: `opacity` here dims the whole batch.
      */
+    /**
+     * The next of a batch's cull slots this frame, with its cull queued against the current view; null
+     * when the batch has drawn from `MAX_CULL_SLOTS` views already or the frame's job ring is full,
+     * and the draw then takes every instance.
+     */
+    private takeCullSlot;
     private submitInstanced;
     /** Upload a base mesh and size its per-instance buffers. See `createGpuScatter`. */
     createScatter(base: MeshData, data: InstanceData): GpuScatter;
@@ -2207,6 +2302,34 @@ export declare class WebGPURenderer implements RendererApi {
     drawSceneCasters(casters: ShadowCasters): void;
     drawShadowCasters(casters: ShadowCasters): void;
     /** Close the shadow pass and submit it, so the frame can sample what it wrote. */
+    /**
+     * Add the sun's two glass layers, once, carrying every layer it holds across on `encoder`.
+     *
+     * **Copied rather than re-baked**, for the reason `SunShadowArray.growForGlass` gives: the static
+     * map is the consumer's to bake and may be baked once, and the glass that grows the texture
+     * arrives in the very pass that drew it. Every view of the old texture is stale afterwards, so
+     * every group holding one is rebuilt here — the lit pass's, the volumes', the medium's and the
+     * peel's — and the old texture is destroyed only once this encoder is submitted.
+     */
+    private growSunForGlass;
+    /** Every group that holds a view of the sun's texture, rebuilt after it has been replaced. */
+    private rebuildSunGroups;
+    /** The sun's tint target, made the first time glass casts and born clear on `encoder`. */
+    private ensureSunTint;
+    /**
+     * Draw the pass's glass twice: where the nearest pane is, and what the panes let through.
+     *
+     * After the opaque casters, on the pass's own encoder. A layer that has held glass is redrawn
+     * even when this pass offered none, so glass that has gone takes its colour with it.
+     */
+    private flushSunGlass;
+    /** The glass list into a glass depth layer: `casterSink` itself, with glass let through. */
+    private readonly glassDepthSink;
+    /**
+     * The glass list into a tint layer, through the tint pipelines, **culling nothing**: every pane on
+     * a ray counts, whichever way it faces. See the other backend's `glassTintSink`.
+     */
+    private readonly glassTintSink;
     endShadowPass(): void;
     /**
      * The pool, or null where the profile switched cube shadows off.
@@ -2227,6 +2350,8 @@ export declare class WebGPURenderer implements RendererApi {
     private preparedPointLightCount;
     /** See `renderer.ts`: built when a world reports its lights, and rebuilt only to grow. */
     private pointShadowArray;
+    /** The array glass replaced, destroyed once the round that copied out of it is submitted. */
+    private retiredPointTexture;
     private readonly bakeScratch;
     /** Said once per renderer; see `updatePointShadows`. */
     private warnedNoPointShadowArray;
@@ -2461,28 +2586,51 @@ export declare class WebGPURenderer implements RendererApi {
      * called whenever any of them is replaced.
      */
     private rebuildReconGroups;
+    /** This frame's jitter and temporal frame, decided where its scene camera is bound. See `bindMeshPass`. */
+    private jitterFrame;
     /**
-     * Remember that this mesh moved, so the motion pass can draw where it was.
+     * Whether a blended draw recorded now lands after the upscale. See `lateRouting.ts`.
      *
-     * Silent unless a reconstruction is running: a scene that always states its previous transforms
-     * — which is the right thing for a scene to do, the alternative being to know what the renderer
-     * is configured as — must cost nothing at all when nobody is going to read them.
+     * Not during the order-independent replay, which owns its pass and issues into it directly.
+     */
+    private drawsLate;
+    /**
+     * The command a blended draw records into: the late pool while reconstructing, the frame graph
+     * otherwise. **Late draws record whatever `quality.frameGraph` says**, since the late replay is
+     * the only moment they can land; everything else keeps the path it has.
+     */
+    private recordBlended;
+    /** The pipelines a blended draw is built for: the reconstructed picture's while late. */
+    private blendedPipelines;
+    /**
+     * The blended draws of a reconstructing frame, over the reconstructed picture at the output size
+     * and unjittered, against the render's depth taken up to that size. Before occlusion, bloom and
+     * the grade, so they are graded exactly as they were when they were drawn into the scene.
      */
-    private recordMotion;
+    private runLate;
+    /** Whether this draw lands in the reconstructed picture. See `lateRouting.ts`. */
+    private tracksMotionNow;
     /**
-     * The pipeline the motion pass draws with, built once.
+     * What this draw's motion is, recorded for the motion pass.
      *
-     * **The position buffer alone**, because that is all the shader reads and a mesh keeps one buffer
-     * an attribute — so this binds buffer zero and nothing else, whatever else the mesh carries.
+     * A mesh rewritten this frame carries its vertex motion whatever else the draw says — under last
+     * frame's model where a mover or a matrix knows it, under this frame's where nothing does. A
+     * mover otherwise carries a rigid draw's last model or a skinned draw's last pose; a matrix
+     * carries a rigid draw's. A draw that says nothing and moved no vertex takes the camera's motion.
      */
-    private buildMotionPipeline;
-    /** The pipeline for one vertex stride, built on first sight of it. */
-    private motionPipelineFor;
+    private recordDrawMotion;
     /**
-     * Where every mover was last frame, into the motion target.
+     * A skinned mover's motion: this frame's palette is the draw's own slot, and last frame's takes a
+     * slot of its own, like any palette a draw binds — so it is uploaded once and nothing overwrites
+     * it before the motion pass reads it. See `SkinPaletteRing`.
+     */
+    private recordSkinnedMotion;
+    private warnMoverTwice;
+    /**
+     * Where every mover was last frame, into the motion target. See `MotionPass`.
      *
      * **After everything that draws and before the resolve reads it.** The frame's depth has to be
-     * finished for the equality test to mean anything, and the resolve is what consumes the result.
+     * finished for the pass's equality test to mean anything, and the resolve is what consumes it.
      */
     private runMotion;
     /**
@@ -2742,6 +2890,8 @@ export declare class WebGPURenderer implements RendererApi {
     private recordDraw;
     /** Replay one recorded draw into an open pass. */
     private replayNode;
+    /** One recorded draw, issued into an open pass. Shared by the graph's replay and `runLate`. */
+    private issueCommand;
     private ensurePass;
     /**
      * The pass a verb will draw into, without flushing what is already recorded.
@@ -2953,6 +3103,8 @@ export declare class WebGPURenderer implements RendererApi {
      * declares nothing behaves exactly as it did before. Read it beside `visible`, which answers the
      * other half of the same question.
      */
+    /** Whether a world-space box is wholly behind the declared occluders. See `Renderer.occludedBox`. */
+    occludedBox(min: ArrayLike<number>, max: ArrayLike<number>): boolean;
     occluded(bounds: Bounds, model: ReadonlyMat4): boolean;
     private readonly passes;
     /** Each registered pass's declared reads, as a mask, resolved once at registration. */
@@ -3137,6 +3289,13 @@ export declare class WebGPURenderer implements RendererApi {
     beginInset(rect: InsetRect, clearColor: Vec3 | null): number;
     /** Give the whole canvas back. Safe to call without a matching `beginInset`. */
     endInset(): void;
+    /**
+     * The size of the attachment the open pass draws into: the swap image — the drawing buffer —
+     * in the overlay after the present, the scene's render size in the frame's own pass. A tuple
+     * held once rather than a new array a call.
+     */
+    private passSize;
+    private readonly passSizeOut;
     /**
      * Copy a rectangle of the frame into a 2D canvas, pixel for pixel.
      *
@@ -3243,6 +3402,10 @@ export declare class WebGPURenderer implements RendererApi {
      *
      * What it gives up is one frame of history: the frame after a cut has no blur and no temporal
      * blend, as the first frame of a session has none. Nothing else is reset.
+     *
+     * **A reconstructing renderer depends on it**: its history is the last shot's, and without this
+     * call a cut blends that shot into the first frames of the next. Nothing detects a cut on the
+     * caller's behalf, deliberately — a fast pan and a cut look alike from here.
      */
     cameraCut(): void;
     /**
@@ -3369,8 +3532,12 @@ export declare class WebGPURenderer implements RendererApi {
     private probeView;
     private readonly probeSize;
     private readonly probeMipLayout;
-    /** The photometric atlas, allocated on first use. See `setIesProfiles`. */
-    private iesTexture;
+    /** The fixture atlas — cookies over profiles — built on first use. See `fixtureAtlas.ts`. */
+    private fixtureTexture;
+    private fixtureView;
+    /** The profiles as packed and the cookie images, kept so either can rebuild the atlas. */
+    private iesAtlas;
+    private cookieImages;
     /** The scene's DriftLight field, and its two volumes once it is whole. See `createLightField`. */
     private lightField;
     private driftIndex;
@@ -3384,10 +3551,7 @@ export declare class WebGPURenderer implements RendererApi {
     /** The frame's exact lights packed for the traced bake. See `gi/bounceLights.ts`. */
     private readonly bounceLights;
     private readonly bakeLamps;
-    private iesView;
-    private cookieTexture;
-    private cookieView;
-    /** Tiles in the cookie atlas. 0 is the white placeholder and the whole off path. */
+    /** Cookie tiles in the atlas. 0 is none, and the whole off path. */
     private cookieTiles;
     /** Rows in that atlas. One until a consumer loads a profile, which is the row of ones. */
     private iesRows;
@@ -3537,11 +3701,30 @@ export declare class WebGPURenderer implements RendererApi {
      * call a tile fills the row without a canvas in between.
      */
     setSpotCookies(images: readonly TexImageSource[]): void;
+    /** Let the atlas go, to be built again from what is in hand the next time it is bound. */
+    private forgetFixtureAtlas;
+    /**
+     * The fixture atlas's view, built from the profiles and cookies in hand if it is not already: the
+     * profiles' rows at the bottom, the cookies' tiles on top. See `renderer.ts` and `fixtureAtlas.ts`.
+     *
+     * **`rgba16float`, not `rgba32float`**: a 32-bit float texture is not filterable in core WebGPU,
+     * and binding one to a filtering sampler takes the whole bind group with it. Both tables want
+     * linear filtering. `RENDER_ATTACHMENT` because `copyExternalImageToTexture` writes through one.
+     */
+    private fixtureAtlasView;
     /**
      * Sum a scene's many fixed lights into a DriftLight field. The same contract as
      * `Renderer.createLightField`; see `driftLight/lightField.ts`.
      */
     createLightField(lights: readonly LightFieldSource[], options?: Omit<LightFieldOptions, 'falloff'>): LightField;
+    /**
+     * Hand a world's DriftLight volume to the renderer: every fixed light of a city, summed offline by
+     * `bakeDenseField`, standing in past the frame's exact choice. Replaces any field made before, of
+     * either kind; the scene calls `field.follow(buffer.complete, ...)` each frame as it would for
+     * `createLightField`, and marks the lights the volume summed `inLightField` so none is counted
+     * twice. See `driftLight/worldLightField.ts`.
+     */
+    createWorldLightField(volume: DenseLightVolume, options?: WorldLightFieldOptions): WorldLightField;
     /** Let go of the field and its volumes; the scene's lights are all exact again. */
     disposeLightField(): void;
     private forgetLightFieldVolumes;
@@ -3576,7 +3759,31 @@ export declare class WebGPURenderer implements RendererApi {
      * The occlusion and bloom targets are half size. Both are blurs read back at full size, so a
      * full-resolution intermediate buys nothing a bilinear fetch does not already give.
      */
+    /**
+     * The medium's march group, holding the shadow views it reads — built with the composite, and
+     * again when the sun's texture grows its glass layers and every view of the old one is stale.
+     *
+     * **The stand-in has to read as unoccluded and not as absent**, which is `emptyTexture.ts`'s
+     * point and `createLightVolumeBindGroup`'s: `occlusion()` calls any stored depth below the
+     * receiver's a blocker — so a black stand-in would put the whole medium in shadow, which is a
+     * picture rather than an error. `volumeBlank` is the white one-texel texture built for this.
+     */
+    private buildMediumBindGroup;
     private ensureComposite;
+    /**
+     * One group per source the bloom chain reads, in the order `runBloom` indexes them: the picture
+     * first, then every level. The prefilter reads the picture; the downsample into level `i` reads
+     * level `i - 1`, which is group `i`; the upsample into level `i - 1` reads level `i`, which is
+     * group `i + 1`.
+     *
+     * **While reconstructing the picture is the resolved one**, which `ensureReconstruction` makes
+     * after this runs and rebuilds these over. The scene target is the jittered render then: a bright
+     * thing smaller than a render texel is caught in some phases and missed in others, and its halo,
+     * wide and over everything round it, flashed with it — a night street's panels breathing a few
+     * levels of luma frame to frame. Built at the drawing buffer's size, which `ensureComposite`
+     * already sized the pyramid for.
+     */
+    private rebuildBloomGroups;
     /**
      * Every bloom stage's uniform block, written once per size rather than once per frame.
      *