@driftengine/core 4.8.2 → 4.8.4

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

@@ -2,6 +2,7 @@ import { DEPTH_COMPARE } from '../../depthConvention.js';
 import { CAUSTICS_BINDINGS, CAUSTICS_FRAG_WGSL, CAUSTICS_VERT_WGSL, } from '../../shaders/generated/caustics.wgsl.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_KEEPS } from '../../sceneCoverage.js';
 /**
  * The caustics pass: a surface lit by nearby water.
  *
@@ -126,7 +127,7 @@ export function causticsPipeline(cache, device, layout) {
                     format: cache.format,
                     blend: {
                         color: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
-                        alpha: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
+                        alpha: SCENE_ALPHA_KEEPS,
                     },
                 },
             ],

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

@@ -0,0 +1,27 @@
+import type { SkinnedClothSetup } from '@driftengine/physics';
+/** Floats of statics a particle, across its sections. */
+export declare const CLOTH_STATIC_FLOATS = 29;
+/** Bit flags of the limits a set-up has: a max distance, a backstop, a frontstop. */
+export declare const CLOTH_LIMIT_MAX = 1;
+export declare const CLOTH_LIMIT_BACK = 2;
+export declare const CLOTH_LIMIT_FRONT = 4;
+export interface PackedCloth {
+    readonly count: number;
+    /** inverse mass, max distance, backstop ×2, frontstop ×2, thickness, rest ×3, normal ×3, influences ×16. */
+    readonly statics: Float32Array;
+    /** Distance records (a, b, rest, compliance), bending (four ids, rest, compliance), tethers (particle, anchor, length). */
+    readonly constraints: Uint32Array;
+    readonly distances: number;
+    readonly bendings: number;
+    readonly tethers: number;
+    /** Each kind's batches as offsets into its sorted records: batch b is `[b]` up to `[b + 1]`. */
+    readonly distanceBatches: Uint32Array;
+    readonly bendingBatches: Uint32Array;
+    readonly tetherBatches: Uint32Array;
+    readonly limits: number;
+    /** Skin matrices the solver uploads a pose: the rig's joints, or one for the model alone. */
+    readonly joints: number;
+    readonly rigged: boolean;
+    readonly colliders: number;
+}
+export declare function packCloth(setup: SkinnedClothSetup): PackedCloth;

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

@@ -0,0 +1,129 @@
+/**
+ * A skinned cloth's set-up as the buffers `shaders/clothSolve.wgsl.ts` reads: per-particle
+ * statics in sections, and every constraint as a record sorted by batch.
+ *
+ * **Sorted by batch so a batch is a range**: a dispatch runs records `begin` to `end`, and a
+ * multiplier sits at its record's index. The batches are `batchesOf`'s — the set-up's own where it
+ * gives them, coloured otherwise — the same ones the CPU solver walks, so the two solve each batch
+ * in the same order.
+ *
+ * **What a device cannot be handed is said another way here.** An infinite max distance is −1, an
+ * infinite stop distance is a stop of radius 0: shader compilers may assume no infinity, and a
+ * comparison against one is then whatever the optimiser made of it. Tethers are coloured too, with
+ * every particle counted as movable, so two tethers on one particle never run in one dispatch —
+ * which keeps the CPU's order for that particle while the rest run at once.
+ *
+ * A cloth with no rig is skinned by its model matrix alone: one joint, weight 1, whose matrix the
+ * solver uploads as the model.
+ */
+import { batchesOf } from '@driftengine/physics';
+/** Floats of statics a particle, across its sections. */
+export const CLOTH_STATIC_FLOATS = 29;
+/** Bit flags of the limits a set-up has: a max distance, a backstop, a frontstop. */
+export const CLOTH_LIMIT_MAX = 1;
+export const CLOTH_LIMIT_BACK = 2;
+export const CLOTH_LIMIT_FRONT = 4;
+/** Whether a set-up is skinned by a rig, as `ClothTargets` decides it. */
+function riggedOf(setup) {
+    return (setup.joints !== undefined &&
+        setup.weights !== undefined &&
+        (setup.inverseBind?.length ?? 0) >= 16);
+}
+export function packCloth(setup) {
+    const n = setup.positions.length / 3;
+    const inverseMass = setup.inverseMass;
+    const limits = setup.limits ?? {};
+    const statics = new Float32Array(n * CLOTH_STATIC_FLOATS);
+    statics.set(inverseMass, 0);
+    const rigged = riggedOf(setup);
+    for (let i = 0; i < n; i++) {
+        const max = limits.maxDistance?.[i] ?? Infinity;
+        statics[n + i] = max < Infinity ? max : -1;
+        for (const [stops, at] of [
+            [limits.backstop, 2 * n],
+            [limits.frontstop, 4 * n],
+        ]) {
+            const distance = stops?.[i * 2] ?? Infinity;
+            const radius = stops?.[i * 2 + 1] ?? 0;
+            const real = distance < Infinity && radius > 0;
+            statics[at + i * 2] = real ? distance : 0;
+            statics[at + i * 2 + 1] = real ? radius : 0;
+        }
+        statics[6 * n + i] = limits.thickness?.[i] ?? 0;
+        for (let k = 0; k < 3; k++) {
+            statics[7 * n + i * 3 + k] = setup.positions[i * 3 + k];
+            statics[10 * n + i * 3 + k] = setup.normals?.[i * 3 + k] ?? (k === 2 ? 1 : 0);
+        }
+        const at = 13 * n + i * 16;
+        if (!rigged) {
+            statics[at + 4] = 1;
+            continue;
+        }
+        for (let k = 0; k < 4; k++) {
+            statics[at + k] = setup.joints?.[i * 4 + k] ?? 0;
+            statics[at + 4 + k] = setup.weights?.[i * 4 + k] ?? 0;
+            statics[at + 8 + k] = setup.joints2?.[i * 4 + k] ?? 0;
+            statics[at + 12 + k] = setup.weights2?.[i * 4 + k] ?? 0;
+        }
+    }
+    const { distance, bending, tethers } = setup;
+    const distances = distance.rest.length;
+    const bendings = bending?.rest.length ?? 0;
+    const tetherCount = tethers?.lengths.length ?? 0;
+    const words = new Uint32Array(distances * 4 + bendings * 6 + tetherCount * 3);
+    const floats = new Float32Array(words.buffer);
+    const distanceBatches = batchesOf('distance', distance.pairs, 2, inverseMass, distance.batches);
+    sorted(distanceBatches, (k, r) => {
+        const at = r * 4;
+        words[at] = distance.pairs[k * 2];
+        words[at + 1] = distance.pairs[k * 2 + 1];
+        floats[at + 2] = distance.rest[k];
+        floats[at + 3] = distance.compliance[k];
+    });
+    let bendingBatches = new Uint32Array([0]);
+    if (bending !== undefined) {
+        const batches = batchesOf('bending', bending.quads, 4, inverseMass, bending.batches);
+        bendingBatches = batches.batches;
+        sorted(batches, (k, r) => {
+            const at = distances * 4 + r * 6;
+            for (let j = 0; j < 4; j++)
+                words[at + j] = bending.quads[k * 4 + j];
+            floats[at + 4] = bending.rest[k];
+            floats[at + 5] = bending.compliance[k];
+        });
+    }
+    let tetherBatches = new Uint32Array([0]);
+    if (tethers !== undefined) {
+        const movable = new Float32Array(n).fill(1);
+        const batches = batchesOf('tethers', tethers.particles, 1, movable, undefined);
+        tetherBatches = batches.batches;
+        sorted(batches, (k, r) => {
+            const at = distances * 4 + bendings * 6 + r * 3;
+            words[at] = tethers.particles[k];
+            words[at + 1] = tethers.anchors[k];
+            floats[at + 2] = tethers.lengths[k];
+        });
+    }
+    return {
+        count: n,
+        statics,
+        constraints: words,
+        distances,
+        bendings,
+        tethers: tetherCount,
+        distanceBatches: distanceBatches.batches,
+        bendingBatches,
+        tetherBatches,
+        limits: (limits.maxDistance !== undefined ? CLOTH_LIMIT_MAX : 0) |
+            (limits.backstop !== undefined ? CLOTH_LIMIT_BACK : 0) |
+            (limits.frontstop !== undefined ? CLOTH_LIMIT_FRONT : 0),
+        joints: rigged ? (setup.inverseBind?.length ?? 0) / 16 : 1,
+        rigged,
+        colliders: setup.colliders?.length ?? 0,
+    };
+}
+/** Each constraint `k` with the place `r` it takes in batch order. */
+function sorted(batches, write) {
+    for (let r = 0; r < batches.order.length; r++)
+        write(batches.order[r], r);
+}

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

@@ -0,0 +1,68 @@
+import type { ClothBindingData } from '../../clothBindingData.ts';
+/** The three views a skinned bind group takes for its cloth. */
+export interface ClothViews {
+    readonly binding: GPUTextureView;
+    readonly particles: GPUTextureView;
+    readonly rest: GPUTextureView;
+}
+/** A one-texel float texture, as all three views, for every draw with no cloth. */
+export declare function clothStandIn(device: GPUDevice): {
+    texture: GPUTexture;
+    views: ClothViews;
+};
+/** A mesh's binding and its particles at rest. */
+export declare class GpuClothBinding {
+    readonly binding: GPUTexture;
+    readonly rest: GPUTexture;
+    readonly bindingView: GPUTextureView;
+    readonly restView: GPUTextureView;
+    readonly particles: number;
+    constructor(device: GPUDevice, data: ClothBindingData);
+    /** Its textures, for the renderer to retire once no draw of this frame can read them. */
+    get textures(): readonly GPUTexture[];
+}
+/**
+ * One character's particles: this frame's and the last, in two textures that swap. Written from
+ * the CPU with `update`, or — `storage` — by the device solver's publish pass, `publish` then
+ * saying which texture it writes.
+ */
+export declare class GpuClothParticles {
+    readonly count: number;
+    /** Texels a row, which the publish pass wraps a particle index by. */
+    readonly width: number;
+    private readonly height;
+    private readonly staging;
+    /** Both textures, for the renderer to retire once no draw of this frame can read them. */
+    readonly textures: readonly [GPUTexture, GPUTexture];
+    private readonly views;
+    private latest;
+    /** The frame each texture was last written for, so a motion knows whether the other is last frame's. */
+    private readonly written;
+    private paired;
+    private pairedViews;
+    constructor(device: GPUDevice, count: number, storage?: boolean);
+    /** This frame's particles. */
+    get current(): GPUTextureView;
+    /** Last frame's. */
+    get previous(): GPUTextureView;
+    /**
+     * Where they were last frame, for a motion vector at `frame`: the other texture where it was
+     * written the frame before this one's update, and this frame's otherwise — particles not updated
+     * this frame did not move, and a first update has no past to measure from.
+     */
+    previousAt(frame: number): GPUTextureView;
+    /** A texture's view, by index: the publish pass binds both, one at a time. */
+    viewOf(k: number): GPUTextureView;
+    /**
+     * The device is about to write the particles of `frame`: the older texture becomes this frame's,
+     * as an `update` makes it, and its index is returned for the pass that writes it.
+     */
+    publish(frame: number): number;
+    /** Write `positions` as the particles of `frame`; last frame's stays. */
+    update(device: GPUDevice, positions: Float32Array, frame: number): void;
+    /**
+     * The three views a draw of `binding` with these particles binds, kept so a cached bind group
+     * compares equal frame after frame. Two objects, one for each texture that is current.
+     */
+    viewsWith(binding: GpuClothBinding): ClothViews;
+}

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

@@ -0,0 +1,145 @@
+/**
+ * A cloth binding's textures on WebGPU: the binding and the rest particles once, a mesh's; the
+ * particles every frame, a character's — the twin of `webgl2/clothTextures.ts`.
+ *
+ * `rgba32float`, read by `textureLoad` in the vertex stage, so bound as `unfilterable-float` and
+ * never sampled. Two particle textures that swap on each update, so last frame's positions stay for
+ * a motion vector with no copy. **Written with `writeTexture`, whose queue order is the trap the
+ * per-draw rings exist for**: an update lands before every draw of the frame, so a character's
+ * particles are updated once a frame, before its draws, never between two draws of it.
+ *
+ * `clothStandIn` is what a skinned pipeline binds where no cloth is set: its layout declares the
+ * three textures whatever the draw, and WebGPU binds every declared texture.
+ */
+import { clothTextureSize, packClothBinding, packClothParticles } from '../../clothBindingData.js';
+const USAGE = 0x4 | 0x2; // TEXTURE_BINDING | COPY_DST
+const STORAGE_BINDING = 0x8;
+function floatTexture(device, label, width, height, texels, storage = false) {
+    const texture = device.createTexture({
+        label,
+        size: [width, height],
+        format: 'rgba32float',
+        usage: storage ? USAGE | STORAGE_BINDING : USAGE,
+    });
+    if (texels !== null) {
+        device.queue.writeTexture({ texture }, texels, { bytesPerRow: width * 16, rowsPerImage: height }, { width, height });
+    }
+    return texture;
+}
+/** A one-texel float texture, as all three views, for every draw with no cloth. */
+export function clothStandIn(device) {
+    const texture = floatTexture(device, 'cloth.standIn', 1, 1, new Float32Array(4));
+    const view = texture.createView();
+    return { texture, views: { binding: view, particles: view, rest: view } };
+}
+/** A mesh's binding and its particles at rest. */
+export class GpuClothBinding {
+    binding;
+    rest;
+    bindingView;
+    restView;
+    particles;
+    constructor(device, data) {
+        const size = clothTextureSize(data.weights.length * 2);
+        this.binding = floatTexture(device, 'cloth.binding', size.width, size.height, packClothBinding(data));
+        this.particles = data.rest.length / 3;
+        const rest = clothTextureSize(this.particles);
+        const texels = new Float32Array(rest.width * rest.height * 4);
+        packClothParticles(data.rest, texels);
+        this.rest = floatTexture(device, 'cloth.rest', rest.width, rest.height, texels);
+        this.bindingView = this.binding.createView();
+        this.restView = this.rest.createView();
+    }
+    /** Its textures, for the renderer to retire once no draw of this frame can read them. */
+    get textures() {
+        return [this.binding, this.rest];
+    }
+}
+/**
+ * One character's particles: this frame's and the last, in two textures that swap. Written from
+ * the CPU with `update`, or — `storage` — by the device solver's publish pass, `publish` then
+ * saying which texture it writes.
+ */
+export class GpuClothParticles {
+    count;
+    /** Texels a row, which the publish pass wraps a particle index by. */
+    width;
+    height;
+    staging;
+    /** Both textures, for the renderer to retire once no draw of this frame can read them. */
+    textures;
+    views;
+    latest = 0;
+    /** The frame each texture was last written for, so a motion knows whether the other is last frame's. */
+    written = [-1, -1];
+    paired = null;
+    pairedViews = [];
+    constructor(device, count, storage = false) {
+        this.count = count;
+        const size = clothTextureSize(count);
+        this.width = size.width;
+        this.height = size.height;
+        this.staging = new Float32Array(size.width * size.height * 4);
+        this.textures = [
+            floatTexture(device, 'cloth.particles', size.width, size.height, this.staging, storage),
+            floatTexture(device, 'cloth.particles', size.width, size.height, this.staging, storage),
+        ];
+        this.views = [this.textures[0].createView(), this.textures[1].createView()];
+    }
+    /** This frame's particles. */
+    get current() {
+        return this.views[this.latest];
+    }
+    /** Last frame's. */
+    get previous() {
+        return this.views[1 - this.latest];
+    }
+    /**
+     * Where they were last frame, for a motion vector at `frame`: the other texture where it was
+     * written the frame before this one's update, and this frame's otherwise — particles not updated
+     * this frame did not move, and a first update has no past to measure from.
+     */
+    previousAt(frame) {
+        const fresh = this.written[this.latest] === frame && this.written[1 - this.latest] === frame - 1;
+        return fresh ? this.previous : this.current;
+    }
+    /** A texture's view, by index: the publish pass binds both, one at a time. */
+    viewOf(k) {
+        return this.views[k];
+    }
+    /**
+     * The device is about to write the particles of `frame`: the older texture becomes this frame's,
+     * as an `update` makes it, and its index is returned for the pass that writes it.
+     */
+    publish(frame) {
+        this.latest = 1 - this.latest;
+        this.written[this.latest] = frame;
+        return this.latest;
+    }
+    /** Write `positions` as the particles of `frame`; last frame's stays. */
+    update(device, positions, frame) {
+        if (positions.length !== this.count * 3) {
+            throw new Error(`cloth: ${this.count} particles and an update of ${positions.length / 3}; a cloth's ` +
+                'particle count is fixed when its particles are created');
+        }
+        packClothParticles(positions, this.staging);
+        this.latest = 1 - this.latest;
+        this.written[this.latest] = frame;
+        device.queue.writeTexture({ texture: this.textures[this.latest] }, this.staging, { bytesPerRow: this.width * 16, rowsPerImage: this.height }, { width: this.width, height: this.height });
+    }
+    /**
+     * The three views a draw of `binding` with these particles binds, kept so a cached bind group
+     * compares equal frame after frame. Two objects, one for each texture that is current.
+     */
+    viewsWith(binding) {
+        if (this.paired !== binding) {
+            this.paired = binding;
+            this.pairedViews = [0, 1].map((k) => ({
+                binding: binding.bindingView,
+                particles: this.views[k],
+                rest: binding.restView,
+            }));
+        }
+        return this.pairedViews[this.latest];
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * BC on WebGPU: which formats this device samples, and the upload of a stored chain.
+ *
+ * **One feature covers every BC format**, `texture-compression-bc`, which `select.ts` asks for
+ * wherever the adapter offers it and never demands: a device without it is still a device, and the
+ * loader decodes for it. Desktop adapters have it; phones have ASTC and ETC2 instead.
+ *
+ * **Written with `writeTexture`, level by level**, because `copyExternalImageToTexture` takes images
+ * and a compressed format cannot be a render attachment, so neither the image upload nor the mip
+ * blit applies. Each level's copy is whole blocks: a level smaller than a block is still one, and
+ * its copy extent is the block's four texels — WebGPU's physical size — rather than the one or two
+ * the level nominally has.
+ */
+import type { CompressedTextureFormat, CompressedTextureSource } from '../../compressedSource.ts';
+/** Every BC format, where the device carries the feature; none where it does not. */
+export declare function gpuCompressedFormats(device: GPUDevice): CompressedTextureFormat[];
+/** A texture holding `layers` as `name`, `levels` levels of each, written as they are. */
+export declare function createCompressedTexture(device: GPUDevice, name: CompressedTextureFormat, layers: readonly CompressedTextureSource[], levels: number): GPUTexture;

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

@@ -0,0 +1,38 @@
+import { BLOCK_BYTES } from '../../compressedSource.js';
+const GPU_FORMAT = {
+    bc1: 'bc1-rgba-unorm',
+    'bc1-srgb': 'bc1-rgba-unorm-srgb',
+    bc2: 'bc2-rgba-unorm',
+    'bc2-srgb': 'bc2-rgba-unorm-srgb',
+    bc3: 'bc3-rgba-unorm',
+    'bc3-srgb': 'bc3-rgba-unorm-srgb',
+    bc4: 'bc4-r-unorm',
+    bc5: 'bc5-rg-unorm',
+    bc7: 'bc7-rgba-unorm',
+    'bc7-srgb': 'bc7-rgba-unorm-srgb',
+};
+/** Every BC format, where the device carries the feature; none where it does not. */
+export function gpuCompressedFormats(device) {
+    return device.features.has('texture-compression-bc')
+        ? Object.keys(GPU_FORMAT)
+        : [];
+}
+/** A texture holding `layers` as `name`, `levels` levels of each, written as they are. */
+export function createCompressedTexture(device, name, layers, levels) {
+    const { format, width, height } = layers[0];
+    const texture = device.createTexture({
+        label: 'surface.texture.bc',
+        size: [width, height, layers.length],
+        format: GPU_FORMAT[name],
+        mipLevelCount: levels,
+        usage: 0x2 | 0x4, // COPY_DST | TEXTURE_BINDING
+    });
+    for (let level = 0; level < levels; level++) {
+        const across = Math.ceil(Math.max(1, width >> level) / 4);
+        const down = Math.ceil(Math.max(1, height >> level) / 4);
+        for (let layer = 0; layer < layers.length; layer++) {
+            device.queue.writeTexture({ texture, mipLevel: level, origin: [0, 0, layer] }, layers[layer].levels[level], { bytesPerRow: across * BLOCK_BYTES[format], rowsPerImage: down }, { width: across * 4, height: down * 4, depthOrArrayLayers: 1 });
+        }
+    }
+    return texture;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * What compute a consumer opts into needs from the WebGPU renderer: its device, whether the device
+ * is gone, which frame a change made now belongs to, and a place to retire textures the frame being
+ * recorded may still read.
+ *
+ * **Why a door rather than renderer methods.** A skinned cloth's solver is fifteen kilobytes
+ * gzipped of compute, WGSL and the CPU solver beneath it, and a renderer method that constructs it
+ * is a static reference no bundler can shake — every game would ship a garment solver whether or
+ * not it draws a garment. Behind this, `createSkinnedCloth` is a barrel function, and only a game
+ * that imports it carries it. **What it gives up**: a function reaching the renderer through a door
+ * the public surface does not show; the door stays this narrow so that is all it reaches.
+ */
+export interface ComputeHost {
+    device(): GPUDevice;
+    lost(): boolean;
+    /** The frame a change made now is drawn in: this one inside a frame, the next between frames. */
+    changeFrame(): number;
+    retire(textures: readonly GPUTexture[]): void;
+}
+/** The host of a renderer that has one: the WebGPU backend, and nothing else. */
+export declare function computeHostOf(renderer: object): ComputeHost | null;

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

@@ -0,0 +1,5 @@
+/** The host of a renderer that has one: the WebGPU backend, and nothing else. */
+export function computeHostOf(renderer) {
+    const asked = renderer.computeHost;
+    return typeof asked === 'function' ? asked.call(renderer) : null;
+}

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

@@ -1,5 +1,6 @@
 import { DEPTH_FRAG_WGSL } from '../../shaders/generated/depth.wgsl.ts';
 import type { PipelineCache } from './pipelineCache.ts';
+import type { ClothViews } from './clothTextures.ts';
 /**
  * The shadow pass: the world drawn from the light, into a depth map.
  *
@@ -87,13 +88,18 @@ export declare const DEPTH_CUTOUT_VERT_FIELDS: {
         readonly size: 8;
         readonly type: "vec2";
     };
-    readonly uAlphaCutout: {
+    readonly uUvOffset: {
         readonly offset: 168;
-        readonly size: 4;
-        readonly type: "float";
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uAlphaCutout: {
+        readonly offset: 176;
+        readonly size: 8;
+        readonly type: "vec2";
     };
 };
-export declare const DEPTH_CUTOUT_VERT_SIZE: 176;
+export declare const DEPTH_CUTOUT_VERT_SIZE: 192;
 export declare const DEPTH_INSTANCED_CUTOUT_VERT_FIELDS: {
     readonly uLightViewProj: {
         readonly offset: 0;
@@ -105,10 +111,15 @@ export declare const DEPTH_INSTANCED_CUTOUT_VERT_FIELDS: {
         readonly size: 8;
         readonly type: "vec2";
     };
-    readonly uAlphaCutout: {
+    readonly uUvOffset: {
         readonly offset: 72;
-        readonly size: 4;
-        readonly type: "float";
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uAlphaCutout: {
+        readonly offset: 80;
+        readonly size: 8;
+        readonly type: "vec2";
     };
 };
 /** Re-exported so the scatter depth pass can pair with the same fragment stage. */
@@ -157,7 +168,9 @@ palette?: GPUTextureView | null,
 cutout?: {
     readonly view: GPUTextureView;
     readonly sampler: GPUSampler;
-} | null): GPUBindGroup;
+} | null, 
+/** A skinned group's cloth views: the caster's, or the stand-in where it has none. */
+cloth?: ClothViews | null): GPUBindGroup;
 /**
  * The depth pipeline.
  *
@@ -189,4 +202,11 @@ skinned?: boolean,
  */
 instanced?: boolean, 
 /** Whether this pipeline casts a cutout: the variant that reads a map and discards by it. */
-cutout?: boolean): GPURenderPipeline;
+cutout?: boolean, 
+/**
+ * Whether a skinned caster reads its second four influences, as its visible draw does. The key
+ * must carry it, so the shadow parts from nothing the body does. See `skinning.ts`.
+ */
+skinEight?: boolean, 
+/** Whether a skinned caster is placed by a cloth binding, as its visible draw is. The key carries it. */
+cloth?: boolean): GPURenderPipeline;

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

@@ -1,5 +1,6 @@
 import { DEPTH_BINDINGS, DEPTH_CUTOUT_FRAG_WGSL, DEPTH_CUTOUT_VERT_WGSL, DEPTH_FRAG_WGSL, DEPTH_INSTANCED_CUTOUT_VERT_WGSL, DEPTH_INSTANCED_VERT_WGSL, DEPTH_SKINNED_VERT_WGSL, DEPTH_VERT_WGSL, } from '../../shaders/generated/depth.wgsl.js';
 import { vertexBufferLayouts } from './buffers.js';
+import { vertexConstants } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
 /**
  * The shadow pass: the world drawn from the light, into a depth map.
@@ -12,9 +13,10 @@ export const DEPTH_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_VERT.fields;
 export const DEPTH_VERT_SIZE = DEPTH_BINDINGS.DEPTH_VERT.uniformSize;
 export const DEPTH_FRAG_SIZE = DEPTH_BINDINGS.DEPTH_FRAG.uniformSize;
 /*
- * The cutout variants' vertex blocks. The rigid one is the plain block with `uUvScale` and
- * `uAlphaCutout` after every other field, so a slot written for it is written with the plain
- * offsets plus these two; the instanced one has no model and no wind, so its two sit earlier.
+ * The cutout variants' vertex blocks. The rigid one is the plain block with `uUvScale`,
+ * `uUvOffset` and `uAlphaCutout` after every other field, so a slot written for it is written with
+ * the plain offsets plus these three; the instanced one has no model and no wind, so its three sit
+ * earlier.
  */
 export const DEPTH_CUTOUT_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_CUTOUT_VERT.fields;
 export const DEPTH_CUTOUT_VERT_SIZE = DEPTH_BINDINGS.DEPTH_CUTOUT_VERT.uniformSize;
@@ -29,6 +31,12 @@ const FRAG_BINDING = DEPTH_BINDINGS.DEPTH_FRAG.uniforms;
 const PREVIOUS = DEPTH_BINDINGS.DEPTH_FRAG.textures.uPreviousShadowMap;
 /** Where the skinned vertex stage reads the joint palette. Generated, not chosen here. */
 export const DEPTH_PALETTE_BINDING = DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uJointPalette;
+/** And the cloth binding's three textures, which every skinned caster declares. */
+const CLOTH_TEXTURES = [
+    DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uClothBinding,
+    DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uClothParticles,
+    DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uClothRest,
+];
 const VISIBILITY_VERTEX = 0x1;
 const VISIBILITY_FRAGMENT = 0x2;
 /**
@@ -63,13 +71,11 @@ cutout = false) {
                coordinate with nothing to filter, which is what `flatPass.ts` binds for the same
                palette. naga declares a sampler for it and nothing ever reads one. */
             ...(skinned
-                ? [
-                    {
-                        binding: DEPTH_PALETTE_BINDING.texture,
-                        visibility: VISIBILITY_VERTEX,
-                        texture: { sampleType: 'unfilterable-float' },
-                    },
-                ]
+                ? [DEPTH_PALETTE_BINDING, ...CLOTH_TEXTURES].map((binding) => ({
+                    binding: binding.texture,
+                    visibility: VISIBILITY_VERTEX,
+                    texture: { sampleType: 'unfilterable-float' },
+                }))
                 : []),
             {
                 binding: VERT_BINDING,
@@ -139,7 +145,9 @@ export function createDepthBindGroup(device, layout, perDraw, perPass, previous,
 /** The joint palette, for a layout built with `skinned`. Omit for the rigid layout. */
 palette = null, 
 /** The cutout map and its sampler, for a layout built with `cutout`. */
-cutout = null) {
+cutout = null, 
+/** A skinned group's cloth views: the caster's, or the stand-in where it has none. */
+cloth = null) {
     return device.createBindGroup({
         label: palette !== null
             ? 'depth.bindGroup.skinned'
@@ -159,6 +167,13 @@ cutout = null) {
             { binding: PREVIOUS.texture, resource: previous },
             { binding: PREVIOUS.sampler, resource: sampler },
             ...(palette !== null ? [{ binding: DEPTH_PALETTE_BINDING.texture, resource: palette }] : []),
+            ...(palette !== null
+                ? [
+                    { binding: CLOTH_TEXTURES[0].texture, resource: clothOf(cloth).binding },
+                    { binding: CLOTH_TEXTURES[1].texture, resource: clothOf(cloth).particles },
+                    { binding: CLOTH_TEXTURES[2].texture, resource: clothOf(cloth).rest },
+                ]
+                : []),
             ...(cutout !== null
                 ? [
                     { binding: CUTOUT_MAP.texture, resource: cutout.view },
@@ -199,7 +214,14 @@ skinned = false,
  */
 instanced = false, 
 /** Whether this pipeline casts a cutout: the variant that reads a map and discards by it. */
-cutout = false) {
+cutout = false, 
+/**
+ * Whether a skinned caster reads its second four influences, as its visible draw does. The key
+ * must carry it, so the shadow parts from nothing the body does. See `skinning.ts`.
+ */
+skinEight = false, 
+/** Whether a skinned caster is placed by a cloth binding, as its visible draw is. The key carries it. */
+cloth = false) {
     return cache.get(key, () => ({
         label: key,
         layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
@@ -215,6 +237,9 @@ cutout = false) {
                         : { label: 'depth.vert', code: DEPTH_VERT_WGSL }),
             entryPoint: 'main',
             buffers: vertexBufferLayouts(present, instanced),
+            ...(skinned && !instanced && !cutout
+                ? { constants: vertexConstants(DEPTH_BINDINGS.DEPTH_SKINNED_VERT, skinEight, cloth) }
+                : {}),
         },
         fragment: {
             module: shaderModule(device, cutout
@@ -292,3 +317,9 @@ cutout = false) {
         },
     }));
 }
+function clothOf(cloth) {
+    if (cloth === null) {
+        throw new Error('depthPass: a skinned bind group needs cloth views, the stand-in at the least');
+    }
+    return cloth;
+}