@driftengine/core 4.8.6 → 4.8.7

package/dist/render/backend/webgl2/renderer.js

@@ -41,7 +41,7 @@ import { createDriftLightUniforms, resolveDriftLight } from '../../driftLight/un
 import { flatFrag, flatVert } from '../../shaders/flat/index.js';
 import { skinEight } from '../../shaders/skinning.js';
 import { MODEL_MAP_TEXTURE_UNIT, MORPH_DELTA_TEXTURE_UNIT, SKIN_PALETTE_TEXTURE_UNIT, } from '../../lightBudget.js';
-import { MODEL_PARAM_FLOATS, eyeAxisInWorld, packModel } from '../../surfaceModel.js';
+import { MODEL_PARAM_FLOATS, eyeAxisInWorld, packModel, skinProfileDistance, } from '../../surfaceModel.js';
 import { lightmapRegionsBound, modelBound, skinHalfBound } from '../../shaders/flat/models.js';
 import { lightmapTexels, warnRegionsWithoutPage, warnUnpagedLightmap, withLightmapUvs, } from '../../lightmap.js';
 import { GlSkinScatter } from './skinScatter.js';
@@ -86,6 +86,8 @@ import { resolveRenderQuality } from '../../renderQuality.js';
 import { drawingBufferSize } from '../../drawingBuffer.js';
 import { Mesh, createMeshIncremental } from '../../mesh.js';
 import { SurfaceTexture } from '../../surfaceTexture.js';
+import { sceneCaptureTexels } from '../../sceneCapture.js';
+import { GlSceneCaptureTarget } from './sceneCaptureTarget.js';
 import { glCompressedFormats } from '../../glCompressed.js';
 import { PlumeRenderer } from '../../plumeRenderer.js';
 import { createScatterDeform, resolveScatterDeform } from '../../scatterDeform.js';
@@ -875,6 +877,15 @@ export class WebGL2Renderer {
     warnedEnvironmentAmbient = false;
     /** Whether a probe is being baked, so the passes that would recurse into one can tell. */
     probePassActive = false;
+    /**
+     * Whether a scene capture is being drawn (`captureScene`): an off-screen pass like a bake, so the
+     * frame's own view, its refraction copy and skin's spread are left alone, but lit as the frame is.
+     */
+    capturePassActive = false;
+    /** Each capture's framebuffer, beside the texture a material binds. See `createSceneCapture`. */
+    captureTargets = new WeakMap();
+    /** Said once, where a driver refuses to draw into a capture. */
+    warnedCapture = false;
     /** Whether the bake under way lights its faces by the grid. `ProbeBakeOptions.bounce`. */
     probeBounce = false;
     /** The clip-control extension, or null where this context does not offer it. */
@@ -941,7 +952,8 @@ export class WebGL2Renderer {
      * the camera's matrix unchanged and multiplies nothing.
      */
     viewProjFor(camera) {
-        const scene = this.probePassActive
+        /* A capture's rows are flipped as a probe face's are, so it reads as an image does. */
+        const scene = this.probePassActive || this.capturePassActive
             ? cubeFaceProjection(this.cubeFaceViewProj, this.sceneMatrix(camera.viewProjection))
             : this.sceneMatrix(camera.viewProjection);
         /*
@@ -2545,6 +2557,76 @@ export class WebGL2Renderer {
     createLightmap(page) {
         return new SurfaceTexture(this.gl, lightmapTexels(page), { wrap: 'clamp', mipmap: false });
     }
+    /**
+     * A texture the scene can be drawn into, for a material to show. See `RendererApi` and
+     * `sceneCapture.ts`. Half floats where the frame keeps range, as a probe does.
+     */
+    createSceneCapture(width, height) {
+        const float = this.quality.hdrScene && this.gl.getExtension('EXT_color_buffer_float') !== null;
+        const texture = new SurfaceTexture(this.gl, sceneCaptureTexels(width, height, float), {
+            wrap: 'clamp',
+            mipmap: false,
+        });
+        this.captureTargets.set(texture, new GlSceneCaptureTarget(this.gl, texture, width, height, this.sceneTarget?.sampleCount ?? 1, float));
+        return texture;
+    }
+    /**
+     * Draw the scene into a capture from `camera`: `draw` is handed the camera, its matrices updated
+     * for the capture's shape, and submits the scene as it would to the screen. See `RendererApi`.
+     *
+     * **Radiance, as a probe bake stores it**: the output transform and exposure are held off for the
+     * pass, so the frame grades a screen showing it once. No temporal jitter, which a capture has no
+     * resolve to undo. Returns whether it drew: false for a texture that is not a capture, or one the
+     * driver will not draw into.
+     */
+    captureScene(capture, camera, clearColor, draw) {
+        if (this.contextLost)
+            return false;
+        const target = this.captureTargets.get(capture);
+        if (target === undefined)
+            return false;
+        if (!target.usable) {
+            if (!this.warnedCapture) {
+                this.warnedCapture = true;
+                console.warn('Renderer: this driver will not draw into a scene capture, so it keeps its clear. ' +
+                    'Nothing else is affected.');
+            }
+            return false;
+        }
+        camera.updateMatrices(target.width / target.height);
+        const { gl } = this;
+        const jittering = this.temporalJittering;
+        this.temporalJittering = false;
+        this.capturePassActive = true;
+        this.useFlatProgram();
+        gl.uniform1i(this.flatUniforms['uOutputTransform'] ?? null, 0);
+        gl.uniform1f(this.flatUniforms['uOutputExposure'] ?? null, 1);
+        this.materials.dirty();
+        target.begin(gl, clearColor, this.depthClear);
+        /*
+         * **Rows flipped, as a probe face's are.** A GL framebuffer's first row is its bottom and an
+         * image's is its top, so a capture drawn upright would be shown upside down by every material
+         * reading it as the image it is; `viewProjFor` negates clip y for the pass, and negating one axis
+         * reverses every triangle's winding, which the front face follows. WebGPU's rows already run
+         * the image's way.
+         */
+        gl.frontFace(gl.CW);
+        try {
+            draw(camera);
+        }
+        finally {
+            target.end(gl);
+            gl.frontFace(gl.CCW);
+            this.useFlatProgram();
+            gl.uniform1i(this.flatUniforms['uOutputTransform'] ?? null, this.gradeCode());
+            gl.uniform1f(this.flatUniforms['uOutputExposure'] ?? null, this.gradeExposure());
+            this.materials.dirty();
+            this.capturePassActive = false;
+            this.temporalJittering = jittering;
+            this.restoreViewport();
+        }
+        return true;
+    }
     /**
      * Replace a surface texture's pixels, keeping the GPU object and its sampler state.
      *
@@ -2566,6 +2648,8 @@ export class WebGL2Renderer {
         if (this.contextLost)
             return;
         texture.dispose(this.gl);
+        this.captureTargets.get(texture)?.dispose(this.gl);
+        this.captureTargets.delete(texture);
     }
     /**
      * Choose the surface texture the following `drawMesh` calls sample, or `null` for none.
@@ -2768,7 +2852,7 @@ export class WebGL2Renderer {
         const model = material?.model;
         warnUnpagedLightmap(model, material?.modelMap);
         if (model?.kind === 'skin' && this.skinScatter !== null) {
-            this.skinScatter.setProfile(model.profile, model.scatterColor[0] * model.radius, model.scatterColor[1] * model.radius, model.scatterColor[2] * model.radius);
+            this.skinScatter.setProfile(model.profile, skinProfileDistance(model, 0), skinProfileDistance(model, 1), skinProfileDistance(model, 2));
         }
         /*
          * Written to every flat program, because material state persists across draws and a skinned
@@ -2892,7 +2976,10 @@ export class WebGL2Renderer {
         if (modelMap !== null)
             modelMap.bind(gl, MODEL_MAP_TEXTURE_UNIT);
         gl.uniform1i(u['uModelMap'] ?? null, MODEL_MAP_TEXTURE_UNIT);
-        packModel(material?.model ?? null, modelMap !== null, this.modelParams);
+        packModel(material?.model ?? null, modelMap !== null, this.modelParams, material?.physicalSpecular === true);
+        /* The first physical highlight asked for is when the lit programs start carrying one. */
+        if (material?.physicalSpecular === true)
+            this.askLit('PHYSICAL_SPECULAR');
         gl.uniform4fv(u['uModelParams'] ?? null, this.modelParams);
         /* The albedo's effects table, or the stand-in the shader reads as none. Before the early
            return, so a material with no albedo still leaves a complete texture on the unit. */
@@ -2952,18 +3039,6 @@ export class WebGL2Renderer {
         gl.activeTexture(gl.TEXTURE0 + SURFACE_TEXTURE_UNIT);
         gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.emptyTexture2DArray);
     }
-    /**
-     * A pass-level scale over the grain the geometry itself declared, 0 to 1.
-     *
-     * Which surfaces are mineral is now `MeshData.grain`, stated per vertex through
-     * `MeshBuilder.setGrain` — because it is a property of a material, and absent means none.
-     * This stays as the override for the case that has no answer to state: an imported model
-     * arrives with no grain information at all, and a caller drawing one decides for it.
-     *
-     * Pass state, like `setSurfaceTexture`, because a material covers many draws. The default
-     * is 1 and `bindMeshPass` restores it, so it scales geometry that declared grain and
-     * leaves geometry that did not exactly as it is.
-     */
     /**
      * The ambient the following draws take, as nine spherical-harmonic coefficients of incoming
      * radiance — red, green and blue of each, twenty-seven numbers — or `null` for the frame's own:
@@ -2975,16 +3050,6 @@ export class WebGL2Renderer {
      * only — a glossy surface still reflects the probes — and it is pass state like the material,
      * which `bindMeshPass` clears, so a mirror or a probe bake drawn after does not inherit it.
      */
-    /**
-     * How much of the environment the following draws mirror, 0 to 1.
-     *
-     * Pass state beside the grain, and the counterpart to it: grain is a surface being uneven,
-     * this is a surface being smooth enough to carry an image. Polished paint, glass, chrome
-     * and still water want it; plaster and stone want none.
-     *
-     * Defaults to zero and bindMeshPass restores it, so a scene that never calls this looks
-     * exactly as it did.
-     */
     setAmbientSH(coefficients) {
         if (this.contextLost)
             return;
@@ -2996,6 +3061,16 @@ export class WebGL2Renderer {
         }
         this.useFlatProgram();
     }
+    /**
+     * How much of the environment the following draws mirror, 0 to 1.
+     *
+     * Pass state beside the grain, and the counterpart to it: grain is a surface being uneven,
+     * this is a surface being smooth enough to carry an image. Polished paint, glass, chrome
+     * and still water want it; plaster and stone want none.
+     *
+     * Defaults to zero and bindMeshPass restores it, so a scene that never calls this looks
+     * exactly as it did.
+     */
     setSurfaceReflectivity(amount) {
         if (this.contextLost)
             return;
@@ -3043,6 +3118,18 @@ export class WebGL2Renderer {
         console.warn('Renderer: setEnvironmentAmbient no longer does anything. A baked probe now lights a ' +
             'surface through projected irradiance, and there is nothing left to tune.');
     }
+    /**
+     * A pass-level scale over the grain the geometry itself declared, 0 to 1.
+     *
+     * Which surfaces are mineral is now `MeshData.grain`, stated per vertex through
+     * `MeshBuilder.setGrain` — because it is a property of a material, and absent means none.
+     * This stays as the override for the case that has no answer to state: an imported model
+     * arrives with no grain information at all, and a caller drawing one decides for it.
+     *
+     * Pass state, like `setSurfaceTexture`, because a material covers many draws. The default
+     * is 1 and `bindMeshPass` restores it, so it scales geometry that declared grain and
+     * leaves geometry that did not exactly as it is.
+     */
     setSurfaceGrain(amount) {
         if (this.contextLost)
             return;
@@ -3464,7 +3551,7 @@ export class WebGL2Renderer {
         const glassy = resolveGlass(options.glass, this.glassScratch);
         if (refraction <= 0 && !glassy)
             return false;
-        if (this.probePassActive || this.reflectionPassActive)
+        if (this.probePassActive || this.reflectionPassActive || this.capturePassActive)
             return false;
         const snapshot = this.sceneTarget?.snapshotColor(false, glassy) ?? null;
         if (snapshot === null)
@@ -3763,6 +3850,20 @@ export class WebGL2Renderer {
     createParticles(capacity, options) {
         return new ParticleBatch(this.gl, capacity, options);
     }
+    /**
+     * Particles a caller's own compute wrote: WebGPU's alone, since this backend has no compute stage
+     * to have written them (`computeSupported`). Said once, and nothing is drawn.
+     */
+    drawDeviceParticles(_batch, _particles, _camera, _env, _timeSeconds) {
+        if (this.warnedDeviceParticles)
+            return;
+        this.warnedDeviceParticles = true;
+        console.warn('Renderer: drawDeviceParticles draws particles a compute shader wrote, and WebGL2 has no ' +
+            'compute stage, so nothing is drawn. Check `computeSupported`, and draw a pool with ' +
+            '`drawParticles` where it is false.');
+    }
+    /** Said once: see `drawDeviceParticles`. */
+    warnedDeviceParticles = false;
     /**
      * Draw a live particle pool.
      *
@@ -3820,7 +3921,10 @@ export class WebGL2Renderer {
         const u = batch.uniforms;
         const scene = this.sceneTarget;
         let depth = null;
-        if (batch.softDepth > 0 && !this.reflectionPassActive && !this.probePassActive) {
+        if (batch.softDepth > 0 &&
+            !this.reflectionPassActive &&
+            !this.probePassActive &&
+            !this.capturePassActive) {
             depth = scene?.snapshotDepth(true) ?? null;
             if (depth === null && !this.warnedSpriteDepth) {
                 this.warnedSpriteDepth = true;
@@ -4692,6 +4796,7 @@ export class WebGL2Renderer {
             lightFixtures: this.litOn.LIGHT_FIXTURES,
             surfaceEffects: this.litOn.SURFACE_EFFECTS,
             driftLight: this.litOn.DRIFT_LIGHT,
+            physicalSpecular: this.litOn.PHYSICAL_SPECULAR,
             maxLights: budget.maxLights,
             maxAreaLights: budget.maxAreaLights,
         });
@@ -6328,7 +6433,10 @@ export class WebGL2Renderer {
          */
         if (this.framePresented)
             this.temporalJittering = false;
-        if (!this.reflectionPassActive && !this.probePassActive && !this.framePresented) {
+        if (!this.reflectionPassActive &&
+            !this.probePassActive &&
+            !this.capturePassActive &&
+            !this.framePresented) {
             this.frameViewProj = camera.viewProjection;
             /* Copied rather than referenced: a caller moves its camera in place, and the decal pass
                reads this at the end of the frame. */
@@ -6986,6 +7094,7 @@ export class WebGL2Renderer {
             !this.skinScattered &&
             !this.reflectionPassActive &&
             !this.probePassActive &&
+            !this.capturePassActive &&
             !this.framePresented &&
             skin.ready(scene));
     }
@@ -7006,7 +7115,9 @@ export class WebGL2Renderer {
         this.skinScattered = true;
         if (!skin.pending)
             return;
-        if (this.reflectionPassActive || this.probePassActive || projection === null)
+        if (this.reflectionPassActive || this.probePassActive || this.capturePassActive)
+            return;
+        if (projection === null)
             return;
         const depth = scene.snapshotDepth(true);
         mat4.invert(this.skinInverseProjection, projection);

package/dist/render/backend/webgl2/sceneCaptureTarget.d.ts

@@ -0,0 +1,29 @@
+import type { SurfaceTexture } from '../../surfaceTexture.ts';
+/**
+ * A scene capture's framebuffers on WebGL2: the capture's own texture as the colour a pass resolves
+ * into, and a depth of its own, at the capture's size. See `sceneCapture.ts` for what a capture is.
+ *
+ * **At the frame's sample count, as WebGPU's is**, so a capture's edges are antialiased exactly as
+ * the frame's are: drawn into multisampled renderbuffers and blitted into the texture at the end,
+ * since a texture layer cannot be multisampled and sampled both. A count the driver refuses falls
+ * back to one, as the scene target's does, rather than drawing nothing.
+ */
+export declare class GlSceneCaptureTarget {
+    readonly width: number;
+    readonly height: number;
+    /** Where the capture resolves: its texture's layer, and a depth when it is drawn into directly. */
+    private readonly resolveFramebuffer;
+    private readonly resolveDepth;
+    /** Where it is drawn above one sample, or null. */
+    private multisampleFramebuffer;
+    private multisampleColor;
+    private multisampleDepth;
+    /** False where the driver refused the attachment, said once by the renderer. */
+    readonly usable: boolean;
+    constructor(gl: WebGL2RenderingContext, texture: SurfaceTexture, width: number, height: number, samples: number, float: boolean);
+    /** Bind where the pass draws, size the viewport and clear: colour to `clear`, depth to `depthClear`. */
+    begin(gl: WebGL2RenderingContext, clear: readonly [number, number, number], depthClear: number): void;
+    /** Resolve the multisampled colour into the texture, where there is any. */
+    end(gl: WebGL2RenderingContext): void;
+    dispose(gl: WebGL2RenderingContext): void;
+}

package/dist/render/backend/webgl2/sceneCaptureTarget.js

@@ -0,0 +1,96 @@
+import { glSceneDepthFormat } from '../../depthConvention.js';
+/**
+ * A scene capture's framebuffers on WebGL2: the capture's own texture as the colour a pass resolves
+ * into, and a depth of its own, at the capture's size. See `sceneCapture.ts` for what a capture is.
+ *
+ * **At the frame's sample count, as WebGPU's is**, so a capture's edges are antialiased exactly as
+ * the frame's are: drawn into multisampled renderbuffers and blitted into the texture at the end,
+ * since a texture layer cannot be multisampled and sampled both. A count the driver refuses falls
+ * back to one, as the scene target's does, rather than drawing nothing.
+ */
+export class GlSceneCaptureTarget {
+    width;
+    height;
+    /** Where the capture resolves: its texture's layer, and a depth when it is drawn into directly. */
+    resolveFramebuffer;
+    resolveDepth;
+    /** Where it is drawn above one sample, or null. */
+    multisampleFramebuffer = null;
+    multisampleColor = null;
+    multisampleDepth = null;
+    /** False where the driver refused the attachment, said once by the renderer. */
+    usable;
+    constructor(gl, texture, width, height, samples, float) {
+        this.width = width;
+        this.height = height;
+        const depthFormat = glSceneDepthFormat(gl).internalFormat;
+        this.resolveFramebuffer = must(gl.createFramebuffer());
+        this.resolveDepth = must(gl.createRenderbuffer());
+        gl.bindRenderbuffer(gl.RENDERBUFFER, this.resolveDepth);
+        gl.renderbufferStorage(gl.RENDERBUFFER, depthFormat, width, height);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.resolveFramebuffer);
+        texture.attachColor(gl);
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this.resolveDepth);
+        this.usable = gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE;
+        const maximum = gl.getParameter(gl.MAX_SAMPLES);
+        const count = Math.max(1, Math.min(Math.round(samples), Number.isFinite(maximum) ? maximum : 1));
+        if (this.usable && count > 1) {
+            const color = must(gl.createRenderbuffer());
+            const depth = must(gl.createRenderbuffer());
+            gl.bindRenderbuffer(gl.RENDERBUFFER, color);
+            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, count, float ? gl.RGBA16F : gl.RGBA8, width, height);
+            gl.bindRenderbuffer(gl.RENDERBUFFER, depth);
+            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, count, depthFormat, width, height);
+            const framebuffer = must(gl.createFramebuffer());
+            gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, color);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depth);
+            if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE) {
+                this.multisampleFramebuffer = framebuffer;
+                this.multisampleColor = color;
+                this.multisampleDepth = depth;
+            }
+            else {
+                gl.deleteFramebuffer(framebuffer);
+                gl.deleteRenderbuffer(color);
+                gl.deleteRenderbuffer(depth);
+            }
+        }
+        gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    }
+    /** Bind where the pass draws, size the viewport and clear: colour to `clear`, depth to `depthClear`. */
+    begin(gl, clear, depthClear) {
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.multisampleFramebuffer ?? this.resolveFramebuffer);
+        gl.viewport(0, 0, this.width, this.height);
+        gl.clearColor(clear[0], clear[1], clear[2], 1);
+        gl.clearDepth(depthClear);
+        gl.depthMask(true);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+    }
+    /** Resolve the multisampled colour into the texture, where there is any. */
+    end(gl) {
+        if (this.multisampleFramebuffer === null)
+            return;
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this.multisampleFramebuffer);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.resolveFramebuffer);
+        gl.blitFramebuffer(0, 0, this.width, this.height, 0, 0, this.width, this.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+    }
+    dispose(gl) {
+        gl.deleteFramebuffer(this.resolveFramebuffer);
+        gl.deleteRenderbuffer(this.resolveDepth);
+        if (this.multisampleFramebuffer !== null)
+            gl.deleteFramebuffer(this.multisampleFramebuffer);
+        if (this.multisampleColor !== null)
+            gl.deleteRenderbuffer(this.multisampleColor);
+        if (this.multisampleDepth !== null)
+            gl.deleteRenderbuffer(this.multisampleDepth);
+    }
+}
+function must(made) {
+    if (made === null)
+        throw new Error('GlSceneCaptureTarget: a GL object could not be created');
+    return made;
+}

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

@@ -2,6 +2,7 @@ import { DEPTH_COMPARE } from '../../depthConvention.js';
 import { particleShaders } from '../../particleMaterial.js';
 import { PARTICLE_BINDINGS } from '../../shaders/generated/particle.wgsl.js';
 import { PARTICLE_BLADES, PARTICLE_INDICES, PARTICLE_VERTS } from '../../shaders/particle.js';
+import { DEVICE_PARTICLE_FLOATS } from '../../particlePool.js';
 import { packSpriteStream } from '../../particleBatch.js';
 import { createParticleSort } from '../../particleSort.js';
 import { DEPTH_FORMAT } from './flatPass.js';
@@ -45,7 +46,7 @@ const USAGE_UNIFORM_DST = 0x0040 | 0x0008;
  * Floats per instance, in the order they are packed: position 3, size 1, spin 1, colour 3,
  * alpha 1, age 1, seed 1, velocity 3, and a sprite's frame and half-height 2.
  */
-const INSTANCE_FLOATS = 16;
+const INSTANCE_FLOATS = DEVICE_PARTICLE_FLOATS;
 const INSTANCE_ATTRIBUTES = [
     { shaderLocation: 2, offset: 0, format: 'float32x3' },
     { shaderLocation: 3, offset: 12, format: 'float32' },

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

@@ -36,7 +36,7 @@ import { type GpuCaustics } from './causticsPass.ts';
 import type { BoltSegments } from '../../boltPool.ts';
 import type { LineSegments } from '../../linePoints.ts';
 import { type ParticleBatchOptions } from '../../particleBatch.ts';
-import type { ParticleInstances } from '../../particlePool.ts';
+import type { DeviceParticles, ParticleInstances } from '../../particlePool.ts';
 import type { PlumeOptions, PlumePlacement } from '../../plumeRenderer.ts';
 import type { InstanceData } from '../../instancedMesh.ts';
 import { type RenderQuality } from '../../renderQuality.ts';
@@ -1186,6 +1186,27 @@ export declare class WebGPURenderer implements RendererApi {
     createSurfaceTextureArray(sources: readonly SurfaceSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
     /** A baked lightmap page, as a `lightmapModel` material's `modelMap`. See `RendererApi`. */
     createLightmap(page: LightmapPage): GpuSurfaceTexture;
+    /**
+     * A texture the scene can be drawn into, for a material to show. See `RendererApi` and
+     * `sceneCapture.ts`. At the world's own format, which under `hdrScene` is half floats.
+     */
+    createSceneCapture(width: number, height: number): GpuSurfaceTexture;
+    /** Each capture's attachments, beside the texture a material binds. */
+    private readonly captureTargets;
+    /**
+     * Whether a scene capture is being drawn: an off-screen pass as a probe bake is, so the frame's
+     * camera, jitter, motion, refraction copy, skin's spread and late routing are left alone, but
+     * lit by the probes and DriftLight as the frame is. See `captureScene`.
+     */
+    private capturePassActive;
+    /**
+     * Draw the scene into a capture from `camera`. See `RendererApi.captureScene`.
+     *
+     * **Its own encoder, as a probe bake's**: the frame's pass is set aside and restored, the rings
+     * are marked and rewound around the submit, and the frame graph is flushed at both boundaries so
+     * no recorded draw crosses one. **Radiance**: the output transform and exposure are held off.
+     */
+    captureScene(capture: GpuSurfaceTexture, camera: Camera, clearColor: Vec3, draw: (camera: Camera) => void): boolean;
     /**
      * GPU textures an `updateSurfaceTexture` replaced, destroyed when the next frame begins.
      *
@@ -1448,6 +1469,17 @@ export declare class WebGPURenderer implements RendererApi {
     private gradeCode;
     private gradeExposure;
     drawParticles(batch: GpuParticles, data: ParticleInstances, camera: Camera, env: Environment, timeSeconds: number): void;
+    /**
+     * Draw particles a caller's own compute wrote, where they lie. See `DeviceParticles`.
+     *
+     * **The pool's draw with its instance stream swapped**: the same material, blend, flipbook, soft
+     * edge and fog, reading the caller's buffer in place of the one the pool uploads into — so nothing
+     * crosses back to the CPU. Not sorted, and a count past what the buffer holds is cut to it rather
+     * than handed to a draw the device would refuse with the frame.
+     */
+    drawDeviceParticles(batch: GpuParticles, particles: DeviceParticles, camera: Camera, env: Environment, timeSeconds: number): void;
+    /** A pool's uniforms for this view, and its draw from `instances`: both entry points' tail. */
+    private drawParticleInstances;
     /**
      * A sprite's flipbook and fades into its fragment block `f`, and the bind group holding the
      * frame's depth copy its soft edge reads — built again only when that copy is replaced.
@@ -1767,6 +1799,8 @@ export declare class WebGPURenderer implements RendererApi {
     private writeWind;
     /** Refilled per frame rather than allocated; see `resolvePointLights`. */
     private readonly lights;
+    /** The fixed arm's rectangles as `uAreaLightSize` holds them. See `packAreaSizesAndDoors`. */
+    private readonly areaSizesAndDoors;
     /** Refilled per frame rather than allocated; see `resolveAtmosphere`. */
     private readonly medium;
     private readonly panelLayout;