@driftengine/core 4.8.2 → 4.8.4

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

@@ -13,6 +13,7 @@ const RIGID = 0;
 const SKINNED = 1;
 const DYNAMIC = 2;
 const INSTANCED = 3;
+const CLOTH = 4;
 /** An instanced record's per-draw matrices are not read; this fills their slot. */
 const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 export class MotionPass {
@@ -27,6 +28,19 @@ export class MotionPass {
     /** A skinned record's two palettes, this frame's and last frame's, by record index. */
     paletteNow = [];
     paletteWas = [];
+    /** A cloth record's binding and its particles now and last frame, by record index. */
+    clothBinding = [];
+    clothNow = [];
+    clothWas = [];
+    clothLayout = null;
+    clothPipelineLayout = null;
+    /** Keyed as `skinnedPipelines` is. */
+    clothPipelines = new Map();
+    /**
+     * A bind group per particles now, particles then and binding. Weak at the top, by this frame's
+     * particles, so a character's groups go when its particles do; a steady garment settles on three.
+     */
+    clothGroups = new WeakMap();
     /** A rewritten record's last-frame rows, by record index. */
     previousRows = [];
     /** One pipeline per stride for rewritten meshes: current and previous rows at that stride. */
@@ -74,6 +88,18 @@ export class MotionPass {
         this.paletteNow[at] = palette;
         this.paletteWas[at] = previousPalette;
     }
+    /**
+     * A cloth-bound skinned draw: its skinned positions under both poses, each carried toward the
+     * cloth by its painted weight — this frame's `particles` and last frame's `previousParticles`.
+     */
+    recordCloth(mesh, model, previousModel, palette, previousPalette, binding, particles, previousParticles) {
+        const at = this.take(mesh, model, previousModel, CLOTH);
+        this.paletteNow[at] = palette;
+        this.paletteWas[at] = previousPalette;
+        this.clothBinding[at] = binding;
+        this.clothNow[at] = particles;
+        this.clothWas[at] = previousParticles;
+    }
     /** A rewritten mesh: its vertices as they were, read from `previous`, under last frame's model. */
     recordDynamic(mesh, model, previousModel, previous) {
         const at = this.take(mesh, model, previousModel, DYNAMIC);
@@ -147,6 +173,18 @@ export class MotionPass {
         this.skinnedLayout = this.device.createPipelineLayout({
             bindGroupLayouts: [this.layout, this.paletteLayout],
         });
+        /* The binding and the two particle textures, read with `textureLoad` as the palettes are. */
+        this.clothLayout = this.device.createBindGroupLayout({
+            label: 'recon.motion.cloth',
+            entries: [0, 1, 2].map((binding) => ({
+                binding,
+                visibility: 0x1,
+                texture: { sampleType: 'unfilterable-float' },
+            })),
+        });
+        this.clothPipelineLayout = this.device.createPipelineLayout({
+            bindGroupLayouts: [this.layout, this.paletteLayout, this.clothLayout],
+        });
     }
     /**
      * The skinned pipeline for one stride and one placement of the joints and weights in it.
@@ -154,21 +192,32 @@ export class MotionPass {
      * Same fragment stage, winding and depth test as the rigid one — see `pipelineFor` — with the two
      * skinning attributes read from the interleaved rows at the offsets the mesh records.
      */
-    skinnedPipelineFor(stride, offsets) {
-        const key = (stride * 4096 + offsets.joints) * 4096 + offsets.weights;
-        const held = this.skinnedPipelines.get(key);
+    skinnedPipelineFor(stride, offsets, cloth = false) {
+        /* A rig of eight takes the stage that sums the second four as well. See motion.wgsl.ts. */
+        const eight = offsets.joints2 >= 0 && offsets.weights2 >= 0;
+        /*
+         * Five byte counts, each under 256 because a vertex is at most 172 bytes, as five base-256
+         * digits: exact below 2^40, so two layouts can never share a key.
+         */
+        const key = (((stride * 256 + offsets.joints) * 256 + offsets.weights) * 256 + offsets.joints2 + 1) *
+            256 +
+            offsets.weights2 +
+            1;
+        const pipelines = cloth ? this.clothPipelines : this.skinnedPipelines;
+        const held = pipelines.get(key);
         if (held !== undefined)
             return held;
         const module = this.module;
-        const layout = this.skinnedLayout;
+        const layout = cloth ? this.clothPipelineLayout : this.skinnedLayout;
         if (module === null || layout === null)
             return null;
+        const stage = cloth ? 'Cloth' : 'Skinned';
         const pipeline = this.device.createRenderPipeline({
-            label: `recon.motion.skinned.${String(stride)}`,
+            label: `recon.motion.${cloth ? 'cloth' : 'skinned'}.${String(stride)}`,
             layout,
             vertex: {
                 module,
-                entryPoint: 'motionSkinnedVert',
+                entryPoint: eight ? `motion${stage}EightVert` : `motion${stage}Vert`,
                 buffers: [
                     {
                         arrayStride: stride,
@@ -176,6 +225,12 @@ export class MotionPass {
                             { shaderLocation: 0, offset: 0, format: 'float32x3' },
                             { shaderLocation: 11, offset: offsets.joints, format: 'float32x4' },
                             { shaderLocation: 12, offset: offsets.weights, format: 'float32x4' },
+                            ...(eight
+                                ? [
+                                    { shaderLocation: 14, offset: offsets.joints2, format: 'float32x4' },
+                                    { shaderLocation: 15, offset: offsets.weights2, format: 'float32x4' },
+                                ]
+                                : []),
                         ],
                     },
                 ],
@@ -188,7 +243,7 @@ export class MotionPass {
                 depthCompare: DEPTH_COMPARE_EQUAL,
             },
         });
-        this.skinnedPipelines.set(key, pipeline);
+        pipelines.set(key, pipeline);
         return pipeline;
     }
     /** The rewritten pipeline for one stride: position from each of two buffers of that stride. */
@@ -300,6 +355,36 @@ export class MotionPass {
         }
         return group;
     }
+    /** The bind group holding a cloth's binding and its two particle textures, built on first sight. */
+    clothGroup(binding, now, was) {
+        const layout = this.clothLayout;
+        if (layout === null)
+            return null;
+        let byWas = this.clothGroups.get(now);
+        if (byWas === undefined) {
+            byWas = new Map();
+            this.clothGroups.set(now, byWas);
+        }
+        let byBinding = byWas.get(was);
+        if (byBinding === undefined) {
+            byBinding = new Map();
+            byWas.set(was, byBinding);
+        }
+        let group = byBinding.get(binding);
+        if (group === undefined) {
+            group = this.device.createBindGroup({
+                label: 'recon.motion.cloth',
+                layout,
+                entries: [
+                    { binding: 0, resource: binding },
+                    { binding: 1, resource: now },
+                    { binding: 2, resource: was },
+                ],
+            });
+            byBinding.set(binding, group);
+        }
+        return group;
+    }
     /** The pipeline for one vertex stride, built on first sight of it. */
     pipelineFor(stride) {
         const held = this.pipelines.get(stride);
@@ -450,16 +535,27 @@ export class MotionPass {
                     pipeline = this.dynamicPipelineFor(mesh.vertexStride);
                     pass.setVertexBuffer(1, previous);
                 }
-                else if (kind === SKINNED) {
+                else if (kind === SKINNED || kind === CLOTH) {
                     const offsets = mesh.skinOffsets;
                     const now = this.paletteNow[i] ?? null;
                     const was = this.paletteWas[i] ?? null;
                     if (offsets === null || now === null || was === null)
                         continue;
-                    pipeline = this.skinnedPipelineFor(mesh.vertexStride, offsets);
+                    pipeline = this.skinnedPipelineFor(mesh.vertexStride, offsets, kind === CLOTH);
                     const palettes = this.paletteGroup(now, was);
                     if (pipeline === null || palettes === null)
                         continue;
+                    if (kind === CLOTH) {
+                        const binding = this.clothBinding[i] ?? null;
+                        const particles = this.clothNow[i] ?? null;
+                        const previous = this.clothWas[i] ?? null;
+                        if (binding === null || particles === null || previous === null)
+                            continue;
+                        const cloth = this.clothGroup(binding, particles, previous);
+                        if (cloth === null)
+                            continue;
+                        pass.setBindGroup(2, cloth);
+                    }
                     pass.setBindGroup(1, palettes);
                 }
                 else {
@@ -482,6 +578,7 @@ export class MotionPass {
     }
     dispose() {
         this.paletteGroups.clear();
+        this.clothGroups = new WeakMap();
         this.frameBuffer?.destroy();
         this.drawBuffer?.destroy();
         this.frameBuffer = null;

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

@@ -1,6 +1,7 @@
 import { PANEL_BINDINGS, PANEL_FRAG_WGSL, PANEL_VERT_WGSL, } from '../../shaders/generated/panel.wgsl.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The panel pass: two triangles in screen space, one colour, one alpha.
  *
@@ -97,7 +98,7 @@ export function panelPipeline(cache, device, layout) {
                     format: cache.format,
                     blend: {
                         color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-                        alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        alpha: SCENE_ALPHA_COVERS,
                     },
                 },
             ],

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

@@ -4,6 +4,7 @@ import { PARTICLE_BINDINGS } from '../../shaders/generated/particle.wgsl.js';
 import { PARTICLE_BLADES, PARTICLE_INDICES, PARTICLE_VERTS } from '../../shaders/particle.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The particle pass: a crossed pair of quads per live particle, rebuilt every frame.
  *
@@ -269,7 +270,7 @@ export function particlePipeline(cache, device, layout, material, blend) {
                                 dstFactor: 'one-minus-src-alpha',
                                 operation: 'add',
                             },
-                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: SCENE_ALPHA_COVERS,
                         },
                 },
             ],

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

@@ -6,6 +6,7 @@ import { FIRE_BINDINGS } from '../../shaders/generated/fire.wgsl.js';
 import { SMOKE_BINDINGS } from '../../shaders/generated/smoke.wgsl.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The plume pass: crossed quads per plume, displaced and faded in the shaders.
  *
@@ -179,7 +180,7 @@ function blendState(blend) {
         }
         : {
             color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+            alpha: SCENE_ALPHA_COVERS,
         };
 }
 /**

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

@@ -156,8 +156,10 @@ export declare const OIT_COMPOSITE_BLEND: GPUBlendState;
  * 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.
+ * Alpha is the transmittance again, `share * a`: the scene's alpha is how much of the pixel is
+ * still the opaque surface, which is what the composite lets ambient occlusion darken, and a
+ * medium thick enough to hide a corner hides its occlusion too (`sceneCoverage.ts`). It reaches
+ * no canvas: both are opaque, and the composite writes 1.
  */
 export declare const MEDIUM_TRANSMIT_BLEND: GPUBlendState;
 export declare const DECAL_MULTIPLY_BLEND: GPUBlendState;
@@ -170,6 +172,14 @@ export declare const DECAL_MULTIPLY_BLEND: GPUBlendState;
  * sample the colour it is compositing onto.
  */
 export declare const PREMULTIPLIED_OVER_BLEND: GPUBlendState;
+/**
+ * The same `over` for the resolve that lands a reflection on the scene, keeping the scene's alpha.
+ *
+ * A reflection is a layer of the surface it is seen in, so the surface's share of the pixel is
+ * unchanged (`sceneCoverage.ts`). The trace keeps `PREMULTIPLIED_OVER_BLEND`, because its target is
+ * the reflection's own and its alpha is the coverage this resolve reads.
+ */
+export declare const REFLECTION_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;
@@ -178,7 +188,9 @@ export declare function postPipeline(cache: PipelineCache, device: GPUDevice, la
  * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
  * rather than built per call, since this is asked for every frame.
  */
-export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[]): GPURenderPipeline;
+export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[], 
+/** For a pass drawn into the frame's own multisampled colour, which must match its count. */
+sampleCount?: number): GPURenderPipeline;
 /**
  * The temporal resolve's block and its four inputs.
  *

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

@@ -9,6 +9,7 @@ import { SSRTRACE_BINDINGS as SSR_BINDINGS, SSR_TRACE_FRAG_WGSL, } from '../../s
 import { SSRRESOLVE_BINDINGS as SSR_RESOLVE_BINDINGS, SSR_RESOLVE_FRAG_WGSL, } from '../../shaders/generated/ssrResolve.wgsl.js';
 import { GLOBALMEDIUM_BINDINGS as MEDIUM_BINDINGS, MEDIUM_FRAG_WGSL, MEDIUM_UPSAMPLE_FRAG_WGSL, } from '../../shaders/generated/globalMedium.wgsl.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_KEEPS, SCENE_ALPHA_TRANSMITS } from '../../sceneCoverage.js';
 /**
  * The composite: everything that happens to the frame after the world is drawn.
  *
@@ -197,7 +198,7 @@ export function createPostStageLayout(device, uniformBinding, uniformSize, textu
  */
 export const OIT_COMPOSITE_BLEND = {
     color: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
-    alpha: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
+    alpha: SCENE_ALPHA_TRANSMITS,
 };
 /**
  * What a drawn decal does to the pixel under it: `dst * src`.
@@ -215,16 +216,18 @@ export const OIT_COMPOSITE_BLEND = {
  * 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.
+ * Alpha is the transmittance again, `share * a`: the scene's alpha is how much of the pixel is
+ * still the opaque surface, which is what the composite lets ambient occlusion darken, and a
+ * medium thick enough to hide a corner hides its occlusion too (`sceneCoverage.ts`). It reaches
+ * no canvas: both are opaque, and the composite writes 1.
  */
 export const MEDIUM_TRANSMIT_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'src-alpha', operation: 'add' },
-    alpha: { srcFactor: 'zero', dstFactor: 'one', operation: 'add' },
+    alpha: SCENE_ALPHA_TRANSMITS,
 };
 export const DECAL_MULTIPLY_BLEND = {
     color: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
-    alpha: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
+    alpha: SCENE_ALPHA_KEEPS,
 };
 /**
  * `over`, against colour a pass has already multiplied by its own coverage.
@@ -238,6 +241,17 @@ export const PREMULTIPLIED_OVER_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
     alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
 };
+/**
+ * The same `over` for the resolve that lands a reflection on the scene, keeping the scene's alpha.
+ *
+ * A reflection is a layer of the surface it is seen in, so the surface's share of the pixel is
+ * unchanged (`sceneCoverage.ts`). The trace keeps `PREMULTIPLIED_OVER_BLEND`, because its target is
+ * the reflection's own and its alpha is the coverage this resolve reads.
+ */
+export const REFLECTION_OVER_BLEND = {
+    color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+    alpha: SCENE_ALPHA_KEEPS,
+};
 export const ADDITIVE_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
     alpha: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
@@ -253,11 +267,14 @@ export function postPipeline(cache, device, layout, key, fragment, format, blend
  * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
  * rather than built per call, since this is asked for every frame.
  */
-export function postPipelineTargets(cache, device, layout, key, fragment, targets) {
-    return cache.get(key, () => describePost(device, layout, key, fragment, targets));
+export function postPipelineTargets(cache, device, layout, key, fragment, targets, 
+/** For a pass drawn into the frame's own multisampled colour, which must match its count. */
+sampleCount = 1) {
+    return cache.get(key, () => describePost(device, layout, key, fragment, targets, sampleCount));
 }
-function describePost(device, layout, key, fragment, targets) {
+function describePost(device, layout, key, fragment, targets, sampleCount = 1) {
     return {
+        ...(sampleCount > 1 ? { multisample: { count: sampleCount } } : {}),
         label: key,
         layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
         vertex: {

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

@@ -19,6 +19,10 @@ import { type ShadowLight } from '../../pointShadowSystem.ts';
 import { GpuText } from './textPass.ts';
 import type { TextStyle } from '../../textLayout.ts';
 import { GpuSurfaceTexture } from './surfaceTexturePass.ts';
+import { GpuClothBinding, GpuClothParticles } from './clothTextures.ts';
+import type { ComputeHost } from './computeHost.ts';
+import type { ClothBindingData } from '../../clothBindingData.ts';
+import type { CompressedTextureFormat, SurfaceSource } from '../../compressedSource.ts';
 import { GpuSdfText } from './sdfTextPass.ts';
 import type { SdfFont } from '../../sdfFont.ts';
 import type { SdfTextStyle } from '../../sdfTextLayout.ts';
@@ -151,6 +155,12 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly skinnedGroupsBeside;
     private readonly skinnedGroupsPalette;
     private readonly skinnedGroupsDeltas;
+    /** The cloth views each skinned twin was built with, compared by identity like the palette. */
+    private readonly skinnedGroupsCloth;
+    private readonly skinnedGroupsClothBinding;
+    /** The cloth the next skinned draws are placed by, or null. See `setCloth`. */
+    private cloth;
+    private clothStandCache;
     /**
      * Which palette slot the following draws skin by, or -1 for none.
      *
@@ -498,6 +508,16 @@ export declare class WebGPURenderer implements RendererApi {
     private refractSnapshotView;
     /** Whether this frame has taken it. One snapshot serves every refracting draw. */
     private refractSnapshotTaken;
+    /**
+     * Skin's screen-space scattering, made where the profile asks for it and has a composite to add
+     * into, and null otherwise — which is every profile by default. See `SkinScatterPass`.
+     */
+    private readonly skinScatter;
+    /** The pipelines skin's diffuse half is built for: the blur target's format, the frame's samples. */
+    private readonly skinPipelines;
+    /** Whether this frame has spread its skin: once, at its first blended draw or before its end. */
+    private skinScattered;
+    private readonly skinInverseProjection;
     private sceneColorView;
     /** The multisampled twin, when the profile asks for samples. Resolved into `sceneColor`. */
     private sceneColorMsaa;
@@ -676,6 +696,17 @@ export declare class WebGPURenderer implements RendererApi {
     private temporalJitterX;
     private temporalJitterY;
     private temporalJittering;
+    /**
+     * The frame a dithered cutout's pattern is offset by, advanced at `beginFrame` and wrapped at 64.
+     * See `cutoutDither.ts`.
+     */
+    private cutoutFrame;
+    /**
+     * How the current material's cutout edge is drawn this frame, decided when the material is staged
+     * — after `bindMeshPass` has settled whether the frame is temporal — and read by every draw: a
+     * coverage edge is pipeline state here (`|a2c`), and a blended draw tests hard.
+     */
+    private cutoutResolveStaged;
     /**
      * Whether this frame is being reconstructed, settled once in `bindMeshPass`.
      *
@@ -1082,6 +1113,12 @@ export declare class WebGPURenderer implements RendererApi {
     private ormMap;
     /** The caller's emissive map, or null for the stand-in. See `setMaterial`. */
     private emissiveMap;
+    /** The material's model map, or null for the stand-in. See `setMaterial` and `surfaceModel.ts`. */
+    private modelMap;
+    /** The material's shading model, which picks the lit pipeline: null the standard. */
+    private materialModel;
+    /** Its numbers, `uModelParams`, packed by `packModel`. */
+    private readonly modelParams;
     /**
      * The flat group for a material, keyed on **all four** of its maps.
      *
@@ -1113,13 +1150,27 @@ export declare class WebGPURenderer implements RendererApi {
     private blankAlbedoBindGroup;
     /** Repeats across the mesh's own UV range. Per draw, because `uUvScale` is a vertex uniform. */
     private readonly uvScale;
+    /** Where the texture starts, after the scale. Per draw, beside `uvScale`. */
+    private readonly uvOffset;
+    /**
+     * How the surfaces drawn next meet the medium: what `setSurfaceFog` set, and `FOG_RECEDE` from
+     * each `bindMeshPass`. A translucent draw's own fog is measured against this and puts it back.
+     */
+    private surfaceFog;
     /** Whether the bound material is seen from both faces. See `SurfaceMaterial.doubleSided`. */
     private materialDoubleSided;
     /** Whether the bound material has a map, for the warning a mesh with no coordinates earns. */
     private materialHasMaps;
-    createSurfaceTexture(source: TexImageSource, options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    createSurfaceTexture(source: SurfaceSource, options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    private compressedCache;
+    /**
+     * The BC formats this device takes as blocks: every one where the device carries
+     * `texture-compression-bc`, which `select.ts` asks for wherever the adapter offers it, and none
+     * where it does not. See `Renderer.compressedFormats`.
+     */
+    get compressedFormats(): readonly CompressedTextureFormat[];
     /** Several images of one size as an array's layers. See `RendererApi.createSurfaceTextureArray`. */
-    createSurfaceTextureArray(sources: readonly TexImageSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    createSurfaceTextureArray(sources: readonly SurfaceSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
     /**
      * GPU textures an `updateSurfaceTexture` replaced, destroyed when the next frame begins.
      *
@@ -1152,6 +1203,40 @@ export declare class WebGPURenderer implements RendererApi {
      * surface must be answered by every backend, and answered honestly, per the 2026-08-13 rule.
      */
     setSkinPalette(palette: Float32Array | null): void;
+    /**
+     * A mesh's cloth binding. See `RendererApi.createClothBinding`. The pipelines that draw it bound
+     * are warmed here, every way this mesh can be drawn, so none compiles inside the first frame
+     * that draws a garment.
+     */
+    createClothBinding(mesh: GpuMesh, data: ClothBindingData): GpuClothBinding;
+    /** One character's particles. See `RendererApi.createClothParticles`. */
+    createClothParticles(count: number): GpuClothParticles;
+    /**
+     * This frame's particles. **Once a frame, before the character's draws**: a texture write lands
+     * ahead of every draw of the frame, so a second update between two draws would reach both.
+     */
+    updateClothParticles(particles: GpuClothParticles, positions: Float32Array): void;
+    /** Place the following skinned draws by a cloth, or by none. See `RendererApi.setCloth`. */
+    setCloth(binding: GpuClothBinding | null, particles?: GpuClothParticles | null): void;
+    /** Retired rather than destroyed: a draw recorded earlier in this frame may still read them. */
+    disposeClothBinding(binding: GpuClothBinding): void;
+    disposeClothParticles(particles: GpuClothParticles): void;
+    /**
+     * The device and the frame's bookkeeping, for compute a consumer opts into by importing it —
+     * `createSkinnedCloth` — rather than for anything this renderer runs itself. See `computeHost.ts`.
+     */
+    computeHost(): ComputeHost;
+    private readonly computeHostCache;
+    /**
+     * An eye's axis in the world for this draw, into the open material's \`uModelParams\`, and a new
+     * material slot when it moved: the axis is per draw, and a slot already taken by an earlier draw
+     * of the same eye must not be written under it. See \`eyeAxisInWorld\`.
+     */
+    private writeEyeAxis;
+    /** The views the draw's cloth binds, or the stand-in's where no cloth is set. */
+    private clothViews;
+    /** The one-texel stand-in a skinned group binds where there is no cloth, made on first need. */
+    private clothStand;
     /**
      * Choose the morph weights the following `drawMesh` calls deform by, or null for none.
      *
@@ -1198,6 +1283,8 @@ 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;
+    /** Whether the surfaces drawn next meet the medium. See `renderer.ts`. */
+    setSurfaceFog(enabled: boolean): void;
     /**
      * How much of the surfaces drawn next survives a screen-door dither. See `renderer.ts`.
      *
@@ -1716,6 +1803,8 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly shadowSkinnedGroups;
     private readonly shadowSkinnedGroupsBeside;
     private readonly shadowSkinnedGroupsPalette;
+    private readonly shadowSkinnedGroupsCloth;
+    private readonly shadowSkinnedGroupsClothBinding;
     /** Held from construction so the skinned group can be rebuilt without them being threaded. */
     private shadowBlankView;
     private shadowBlankSampler;
@@ -1816,7 +1905,7 @@ export declare class WebGPURenderer implements RendererApi {
      */
     /** The cutout bind group for `texture` in the open layer, built the first time it casts there. */
     private cutoutGroup;
-    /** The cutoff and UV scale into a cutout draw's slot, at the offsets its own variant declares. */
+    /** The cutoff and UV scale and offset into a cutout draw's slot, at its own variant's offsets. */
     private writeCutout;
     private shadowGroup;
     /**
@@ -2084,9 +2173,9 @@ export declare class WebGPURenderer implements RendererApi {
     /**
      * Rewrite a mesh's positions, and its normals where the caller has them.
      *
-     * Refused in words on a mesh that did not declare itself dynamic, because the thing that makes
-     * an update possible on this backend — the interleaved array the vertex data was built from —
-     * is only kept when a consumer asked for it. See `GpuMesh.update`.
+     * Refused in words on a mesh that did not declare itself dynamic, because what makes an update
+     * cheap on this backend — positions and normals in buffers of their own — is a layout chosen at
+     * creation. See `GpuMesh.update`.
      */
     updateMesh(mesh: GpuMesh, positions: Float32Array, normals?: Float32Array): void;
     /**
@@ -2666,6 +2755,13 @@ export declare class WebGPURenderer implements RendererApi {
      * it before the motion pass reads it. See `SkinPaletteRing`.
      */
     private recordSkinnedMotion;
+    /**
+     * A cloth-bound draw's motion. **Recorded even where the caller named no previous place**, as a
+     * rewritten mesh's is: the particles carry their own past, and a garment swinging on a character
+     * standing still is motion nobody else can see. Where the rig is a `Mover` its last pose is taken
+     * as a skinned mover's is; otherwise the rig is taken not to have moved.
+     */
+    private recordClothMotion;
     private warnMoverTwice;
     /**
      * Where every mover was last frame, into the motion target. See `MotionPass`.
@@ -2840,6 +2936,27 @@ export declare class WebGPURenderer implements RendererApi {
      * glass, and a frame that refracts nothing breaks no pass at all.
      */
     private takeRefractSnapshot;
+    /**
+     * Whether a skin draw now draws its two halves: the profile asked, the frame has not spread its
+     * skin yet, and this is the frame's own picture — not a mirror's, a probe's, an overlay after
+     * the frame, or an order-independent set, none of which the spread reads.
+     */
+    private skinSplits;
+    /**
+     * A skin draw's diffuse half, kept for the spread: the frame's draw again, with the same slots,
+     * buffers and bind group, through the pipeline that writes the diffuse alone into the blur's
+     * target and tests for the depth its frame half wrote.
+     */
+    private keepSkinDiffuse;
+    /**
+     * Spread the frame's skin and add it back: once, at the first blended draw or before the frame's
+     * last flush. **A fifth instance of the boundary `takeRefractSnapshot` describes** — flush, end
+     * the pass, work between passes, reopen with `loadOp: 'load'` — and refused where that one is,
+     * for its reasons. Between the passes: the kept diffuse halves into their target against the
+     * frame's depth, the depth resolved, and `SkinScatterPass.spread` across and then down into the
+     * frame's colour.
+     */
+    private runSkinScatter;
     private takeVolumeDepth;
     /**
      * The pass to record into, reopening one on the canvas if the frame has already gone.