@driftengine/core 4.8.6 → 4.8.7

package/src/index.ts

@@ -1065,8 +1065,12 @@ export {
   INSTANCE_FLOATS,
   INSTANCE_STRIDE,
 } from './render/instances.ts';
-export { ParticlePool } from './render/particlePool.ts';
-export type { ParticlePoolOptions, ParticleInstances } from './render/particlePool.ts';
+export { ParticlePool, DEVICE_PARTICLE_FLOATS } from './render/particlePool.ts';
+export type {
+  DeviceParticles,
+  ParticlePoolOptions,
+  ParticleInstances,
+} from './render/particlePool.ts';
 export { ParticleBatch } from './render/particleBatch.ts';
 export type {
   ParticleBatchOptions,

package/src/render/anisotropicLobe.ts

@@ -39,3 +39,32 @@ export function anisotropicLobe(
   const d = x * x + y * y + nh * nh;
   return 1 / Math.max(d * d, 1e-8);
 }
+
+/** Three components in the lobe's frame: along the direction, across it, along the normal. */
+export type FrameVector = readonly [number, number, number];
+
+/**
+ * The physical form of the same lobe, `π · D · Vis · N·L`, for a surface whose highlight is GGX's
+ * own (`SurfaceMaterial.physicalSpecular`): the stretched distribution normalised as a BRDF's, and
+ * Smith's height-correlated masking stretched with it (Heitz 2014, as Filament writes it), Fresnel
+ * left to the caller. The half vector, the light and the view are each in the lobe's frame. At
+ * strength 0 it is isotropic GGX, the term skin's and the eye's highlights are.
+ */
+export function anisotropicPhysicalLobe(
+  half: FrameVector,
+  light: FrameVector,
+  view: FrameVector,
+  alphaT: number,
+  alphaB: number,
+): number {
+  const x = half[0] / alphaT;
+  const y = half[1] / alphaB;
+  const d = x * x + y * y + half[2] * half[2];
+  const distribution = 1 / (Math.PI * alphaT * alphaB * d * d);
+  const ndl = light[2];
+  const ndv = view[2];
+  const lambdaView = ndl * Math.hypot(alphaT * view[0], alphaB * view[1], ndv);
+  const lambdaLight = ndv * Math.hypot(alphaT * light[0], alphaB * light[1], ndl);
+  const visibility = 0.5 / Math.max(lambdaView + lambdaLight, 1e-5);
+  return Math.PI * distribution * visibility * ndl;
+}

package/src/render/areaLights.ts

@@ -97,6 +97,22 @@ export interface AreaLightSource {
    * of a scene unit, and never inside the rectangle itself. Unreal's `AttenuationRadius`, in metres.
    */
   range?: number;
+  /**
+   * Barn doors: a flap hinged at each of the rectangle's four edges, standing this many degrees from
+   * its normal. 90, or absent, folds them flat and they hide nothing; smaller closes them, so the
+   * light narrows to the opening they leave — a rectangle at 50° throws a beam rather than filling
+   * its hemisphere. Unreal's `BarnDoorAngle`, whose default of 88° is nearly flat.
+   *
+   * What a fragment sees past the doors is the part of the rectangle no door's tip hides, one axis
+   * at a time, and the rectangle then shades as that smaller rectangle, its highlight included.
+   * Its shadow map is still baked from the whole rectangle's centre. **What it gives up**: each
+   * door is taken as endless along its hinge, so the two axes clip apart and the corner where two
+   * doors meet hides a square rather than the mitre two real flaps make. One-sided: a two-sided
+   * rectangle's back face has none.
+   */
+  barnDoorAngle?: number;
+  /** The barn doors' length in metres. Absent, 0.2: Unreal's default of 20 cm. */
+  barnDoorLength?: number;
 }
 
 /** The irradiance a derived `range` ends at, in scene units. See `AreaLightSource.range`. */
@@ -113,6 +129,11 @@ export interface AreaLightBuffer {
   readonly twoSided: Float32Array;
   /** One a rectangle: how far its light reaches. See `AreaLightSource.range`. */
   readonly ranges?: Float32Array;
+  /**
+   * Two a rectangle: the cosine of its barn doors' angle from its normal, then their length in
+   * metres — 0 and 0 for none. See `AreaLightSource.barnDoorAngle`.
+   */
+  readonly barnDoors?: Float32Array;
 }
 
 export function createAreaLightBuffer(capacity: number = MAX_AREA_LIGHTS): AreaLightBuffer {
@@ -125,9 +146,45 @@ export function createAreaLightBuffer(capacity: number = MAX_AREA_LIGHTS): AreaL
     sizes: new Float32Array(capacity * 2),
     twoSided: new Float32Array(capacity),
     ranges: new Float32Array(capacity),
+    barnDoors: new Float32Array(capacity * 2),
   };
 }
 
+/** Unreal's default barn door length, in metres. See `AreaLightSource.barnDoorLength`. */
+export const DEFAULT_BARN_DOOR_LENGTH = 0.2;
+
+/**
+ * A rectangle's barn doors as the shader reads them, into `out[at]` and `out[at + 1]`: the cosine of
+ * their angle and their length. An angle not between 0 and 90 degrees, or a length not above zero,
+ * is no doors at all, written as 0 and 0 — which the shader reads as "nothing hidden".
+ */
+export function barnDoorsOf(light: AreaLightSource, out: Float32Array, at: number): void {
+  const angle = light.barnDoorAngle;
+  const length = light.barnDoorLength ?? DEFAULT_BARN_DOOR_LENGTH;
+  if (angle === undefined || !(angle >= 0 && angle < 90) || !(length > 0)) {
+    out[at] = 0;
+    out[at + 1] = 0;
+    return;
+  }
+  out[at] = Math.cos((angle * Math.PI) / 180);
+  out[at + 1] = length;
+}
+
+/**
+ * The fixed arm's half extents and barn doors, four a rectangle as `uAreaLightSize` holds them: the
+ * two half extents, then the doors' cosine and length. Into a target the binder owns, for the first
+ * `MAX_AREA_LIGHTS` alone, which are all the fixed arm reads.
+ */
+export function packAreaSizesAndDoors(lights: AreaLightBuffer, out: Float32Array): void {
+  const doors = lights.barnDoors;
+  for (let a = 0; a < MAX_AREA_LIGHTS; a++) {
+    out[a * 4] = lights.sizes[a * 2] ?? 0;
+    out[a * 4 + 1] = lights.sizes[a * 2 + 1] ?? 0;
+    out[a * 4 + 2] = doors?.[a * 2] ?? 0;
+    out[a * 4 + 3] = doors?.[a * 2 + 1] ?? 0;
+  }
+}
+
 /**
  * How far a rectangle's light reaches when it names no range: where its irradiance on its own axis,
  * `L · A / d²` for a rectangle of radiance `L` and area `A` seen from far, falls to
@@ -227,6 +284,7 @@ export function selectAreaLights(
           ? light.range
           : areaRange(light.r, light.g, light.b, light.halfWidth, light.halfHeight);
     }
+    if (out.barnDoors !== undefined) barnDoorsOf(light, out.barnDoors, slot * 2);
   }
 
   return out;

package/src/render/backend/api.ts

@@ -1,5 +1,6 @@
 import type { Bounds } from '../../math/bounds.ts';
 import type { Vec3 } from '../../math/color.ts';
+import type { Camera } from '../camera.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { MeshData } from '../mesh.ts';
 import type { ProbeBakeOptions } from '../reflectionProbe.ts';
@@ -8,6 +9,7 @@ import type { InstancedOptions, MeshInstances } from '../instances.ts';
 import type { SurfaceMaterial } from '../surfaceTexture.ts';
 import type { SurfaceSource } from '../compressedSource.ts';
 import type { LightmapPage } from '../lightmap.ts';
+import type { DeviceParticles } from '../particlePool.ts';
 import type { ClothBindingData } from '../clothBindingData.ts';
 import type { TextStyle } from '../textLayout.ts';
 import type { SdfFont } from '../sdfFont.ts';
@@ -276,6 +278,7 @@ export type RendererApi = Omit<
   | 'disposeCaustics'
   | 'createParticles'
   | 'drawParticles'
+  | 'drawDeviceParticles'
   | 'disposeParticles'
   | 'createWindStreaks'
   | 'drawWindStreaks'
@@ -302,6 +305,8 @@ export type RendererApi = Omit<
   | 'createSurfaceTexture'
   | 'createSurfaceTextureArray'
   | 'createLightmap'
+  | 'createSceneCapture'
+  | 'captureScene'
   | 'updateSurfaceTexture'
   | 'disposeSurfaceTexture'
   | 'setSurfaceTexture'
@@ -365,13 +370,41 @@ export type RendererApi = Omit<
 
   /**
    * A baked lightmap page on the device, as the texture a `lightmapModel` material takes for its
-   * `modelMap`: two layers of half floats, the irradiance and the direction, filtered linearly and
-   * clamped at its edges, with no mip chain. Disposed as any texture is, with
+   * `modelMap`: two layers of four bytes a texel, the irradiance as an rgb9e5 word and the
+   * direction, which the lit stage decodes and filters itself, clamped at the page's edges, with no
+   * mip chain. A page whose irradiance arrives packed uploads where it lies. Disposed as any texture is, with
    * `disposeSurfaceTexture`; `updateSurfaceTexture` refuses it, as it refuses any array. See
    * `lightmap.ts` for what a surface does with it.
    */
   createLightmap(page: LightmapPage): SurfaceTextureHandle;
 
+  /**
+   * A texture the scene can be drawn into from a camera of the caller's (`captureScene`), which a
+   * material then shows like any image — most often as its `emissive`, for a screen in the world
+   * showing what a camera elsewhere sees. `width` and `height` in pixels, 1 to 4096. It holds
+   * radiance, at the colour format a probe takes: half floats under `hdrScene`, bytes otherwise.
+   * Disposed as any texture is; `updateSurfaceTexture` refuses it. See `sceneCapture.ts`.
+   */
+  createSceneCapture(width: number, height: number): SurfaceTextureHandle;
+
+  /**
+   * Draw the scene into a capture from `camera`, at the moment a caller says, usually once a frame
+   * before the frame's own world. `draw` is handed the camera, its matrices updated for the
+   * capture's shape, and submits the scene exactly as it would to the screen — `bindMeshPass`,
+   * `drawMesh` and the rest; `bindMeshPass` the frame's own camera again afterwards. The output
+   * transform is held off, so a screen showing it is graded once, with the frame.
+   *
+   * **The mesh pass alone**, as a probe bake is: what a scene draws after its world is in the
+   * capture only if `draw` draws it, and no temporal resolve or effect after the world runs on it.
+   * Returns whether it drew: false for a texture that is not a capture.
+   */
+  captureScene(
+    capture: SurfaceTextureHandle,
+    camera: Camera,
+    clearColor: Vec3,
+    draw: (camera: Camera) => void,
+  ): boolean;
+
   /**
    * Replace a texture's pixels, keeping the GPU object and its sampler state.
    *
@@ -735,6 +768,20 @@ export type RendererApi = Omit<
     timeSeconds: number,
   ): void;
 
+  /**
+   * Draw a pool's particles from a buffer a caller's own compute wrote (`registerCompute`), where
+   * they lie: the pool's material, blend, flipbook and fades, its instance stream the caller's
+   * buffer. WebGPU only; WebGL2 says so once and draws nothing. Not sorted. See `DeviceParticles`
+   * for the layout.
+   */
+  drawDeviceParticles(
+    batch: ParticleHandle,
+    particles: DeviceParticles,
+    camera: Parameters<Renderer['drawParticles']>[2],
+    env: Parameters<Renderer['drawParticles']>[3],
+    timeSeconds: number,
+  ): void;
+
   /** Release a particle pool. */
   disposeParticles(batch: ParticleHandle): void;
 

package/src/render/backend/webgl2/renderer.ts

@@ -136,7 +136,12 @@ import {
   MORPH_DELTA_TEXTURE_UNIT,
   SKIN_PALETTE_TEXTURE_UNIT,
 } from '../../lightBudget.ts';
-import { MODEL_PARAM_FLOATS, eyeAxisInWorld, packModel } from '../../surfaceModel.ts';
+import {
+  MODEL_PARAM_FLOATS,
+  eyeAxisInWorld,
+  packModel,
+  skinProfileDistance,
+} from '../../surfaceModel.ts';
 import type { SurfaceModelKind } from '../../surfaceModel.ts';
 import { lightmapRegionsBound, modelBound, skinHalfBound } from '../../shaders/flat/models.ts';
 import {
@@ -251,6 +256,8 @@ import type { IncrementalMesh } from '../../mesh.ts';
 import type { MeshData } from '../../mesh.ts';
 import type { MeshOptions } from '../api.ts';
 import { SurfaceTexture } from '../../surfaceTexture.ts';
+import { sceneCaptureTexels } from '../../sceneCapture.ts';
+import { GlSceneCaptureTarget } from './sceneCaptureTarget.ts';
 import { glCompressedFormats } from '../../glCompressed.ts';
 import type { CompressedTextureFormat, SurfaceSource } from '../../compressedSource.ts';
 import type { SurfaceMaterial, SurfaceTextureOptions } from '../../surfaceTexture.ts';
@@ -274,7 +281,7 @@ import { PlanarReflection } from '../../planarReflection.ts';
 import { InstancedMesh } from '../../instancedMesh.ts';
 import { ParticleBatch } from '../../particleBatch.ts';
 import type { ParticleBatchOptions } from '../../particleBatch.ts';
-import type { ParticleInstances } from '../../particlePool.ts';
+import type { DeviceParticles, ParticleInstances } from '../../particlePool.ts';
 import { BoltBatch } from '../../boltBatch.ts';
 import type { BoltSegments } from '../../boltPool.ts';
 import { LineBatch } from '../../lineBatch.ts';
@@ -435,6 +442,11 @@ export interface Environment extends Atmosphere {
   lightDirections: Float32Array;
   /** Two per active light: the cosine of the inner cone angle, then of the outer. */
   lightConeCos: Float32Array;
+  /**
+   * One per active light: its own falloff exponent, or 0 for the frame's. Optional: absent is 0 for
+   * every light. See `PointLightSource.falloffExponent`.
+   */
+  lightFalloffExponents?: Float32Array;
   /** One per active light: a row of the photometric atlas, or −1 for none. */
   lightIesProfiles: Float32Array;
   /**
@@ -1621,6 +1633,15 @@ export class WebGL2Renderer implements RendererApi {
   private warnedEnvironmentAmbient = false;
   /** Whether a probe is being baked, so the passes that would recurse into one can tell. */
   private 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.
+   */
+  private capturePassActive = false;
+  /** Each capture's framebuffer, beside the texture a material binds. See `createSceneCapture`. */
+  private readonly captureTargets = new WeakMap<SurfaceTexture, GlSceneCaptureTarget>();
+  /** Said once, where a driver refuses to draw into a capture. */
+  private warnedCapture = false;
   /** Whether the bake under way lights its faces by the grid. `ProbeBakeOptions.bounce`. */
   private probeBounce = false;
   /** The clip-control extension, or null where this context does not offer it. */
@@ -1692,12 +1713,14 @@ export class WebGL2Renderer implements RendererApi {
    * the camera's matrix unchanged and multiplies nothing.
    */
   private viewProjFor(camera: { readonly viewProjection: ReadonlyMat4 }): ReadonlyMat4 {
-    const scene = this.probePassActive
-      ? (cubeFaceProjection(
-          this.cubeFaceViewProj,
-          this.sceneMatrix(camera.viewProjection) as unknown as ArrayLike<number>,
-        ) as unknown as ReadonlyMat4)
-      : this.sceneMatrix(camera.viewProjection);
+    /* 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) as unknown as ArrayLike<number>,
+          ) as unknown as ReadonlyMat4)
+        : this.sceneMatrix(camera.viewProjection);
     /*
      * **The jitter goes on here and nowhere else.** This is the one funnel every geometry upload
      * passes through, so one line covers the mesh passes, the sky, the water and the effects
@@ -3499,6 +3522,92 @@ export class WebGL2Renderer implements RendererApi {
     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: number, height: number): SurfaceTexture {
+    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: SurfaceTexture,
+    camera: Camera,
+    clearColor: Vec3,
+    draw: (camera: Camera) => void,
+  ): boolean {
+    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.
    *
@@ -3519,6 +3628,8 @@ export class WebGL2Renderer implements RendererApi {
   disposeSurfaceTexture(texture: SurfaceTexture): void {
     if (this.contextLost) return;
     texture.dispose(this.gl);
+    this.captureTargets.get(texture)?.dispose(this.gl);
+    this.captureTargets.delete(texture);
   }
 
   /**
@@ -3751,9 +3862,9 @@ export class WebGL2Renderer implements RendererApi {
     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,
+        skinProfileDistance(model, 0),
+        skinProfileDistance(model, 1),
+        skinProfileDistance(model, 2),
       );
     }
     /*
@@ -3901,7 +4012,14 @@ export class WebGL2Renderer implements RendererApi {
     gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.emptyTexture2DArray);
     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
@@ -3963,18 +4081,6 @@ export class WebGL2Renderer implements RendererApi {
     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:
@@ -3986,16 +4092,6 @@ export class WebGL2Renderer implements RendererApi {
    * 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: ArrayLike<number> | null): void {
     if (this.contextLost) return;
     packAmbientSH(coefficients, this.ambientSH);
@@ -4007,6 +4103,16 @@ export class WebGL2Renderer implements RendererApi {
     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: number): void {
     if (this.contextLost) return;
     this.materials.dirty();
@@ -4056,6 +4162,18 @@ export class WebGL2Renderer implements RendererApi {
     );
   }
 
+  /**
+   * 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: number): void {
     if (this.contextLost) return;
     this.materials.dirty();
@@ -4485,7 +4603,7 @@ export class WebGL2Renderer implements RendererApi {
     const refraction = options.refraction ?? 0;
     const glassy = resolveGlass(options.glass, this.glassScratch);
     if (refraction <= 0 && !glassy) return false;
-    if (this.probePassActive || this.reflectionPassActive) return false;
+    if (this.probePassActive || this.reflectionPassActive || this.capturePassActive) return false;
     const snapshot = this.sceneTarget?.snapshotColor(false, glassy) ?? null;
     if (snapshot === null) return false;
     gl.activeTexture(gl.TEXTURE0 + REFRACT_SCENE_TEXTURE_UNIT);
@@ -4847,6 +4965,29 @@ export class WebGL2Renderer implements RendererApi {
     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: ParticleBatch,
+    _particles: DeviceParticles,
+    _camera: Camera,
+    _env: Environment,
+    _timeSeconds: number,
+  ): void {
+    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`. */
+  private warnedDeviceParticles = false;
+
   /**
    * Draw a live particle pool.
    *
@@ -4913,7 +5054,12 @@ export class WebGL2Renderer implements RendererApi {
     const u = batch.uniforms;
     const scene = this.sceneTarget;
     let depth: WebGLTexture | null = 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;
@@ -5982,6 +6128,7 @@ export class WebGL2Renderer implements RendererApi {
       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,
     });
@@ -7877,7 +8024,12 @@ export class WebGL2Renderer implements RendererApi {
      * other position, and the anti-flicker's period never started.
      */
     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. */
@@ -8599,6 +8751,7 @@ export class WebGL2Renderer implements RendererApi {
       !this.skinScattered &&
       !this.reflectionPassActive &&
       !this.probePassActive &&
+      !this.capturePassActive &&
       !this.framePresented &&
       skin.ready(scene)
     );
@@ -8619,7 +8772,8 @@ export class WebGL2Renderer implements RendererApi {
     /* Latched whether or not skin was drawn: a skin drawn after this point is the whole surface. */
     this.skinScattered = true;
     if (!skin.pending) return;
-    if (this.reflectionPassActive || this.probePassActive || projection === null) return;
+    if (this.reflectionPassActive || this.probePassActive || this.capturePassActive) return;
+    if (projection === null) return;
     const depth = scene.snapshotDepth(true);
     mat4.invert(this.skinInverseProjection, projection);
     skin.spread(scene, depth, this.emptyTexture2D, projection, this.skinInverseProjection);