@driftengine/core 4.10.0 → 4.11.1

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

@@ -75,8 +75,13 @@ export interface GpuMesh {
         /** The second four influences' offsets, or -1 for a mesh with four. */
         readonly joints2: number;
         readonly weights2: number;
+        /** How the weights are read: floats, or sixteen-bit fixed point (`vertexPacking.ts`). */
+        readonly weightsFormat: GPUVertexFormat;
+        readonly weights2Format: GPUVertexFormat;
     } | null;
     readonly indexBuffer: GPUBuffer;
+    /** Sixteen or thirty-two bits an index: every pass that binds `indexBuffer` says which. */
+    readonly indexFormat: GPUIndexFormat;
     /**
      * How many indices the mesh draws. **Zero is a mesh with nothing to draw, and no pass draws it**:
      * a level can hold none of some kind of geometry, and a draw of zero indices does nothing but

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

@@ -4,6 +4,9 @@ import { validateMeshData } from '../../mesh.js';
 import { ABSENT_ATTRIBUTE } from '../../vertexDefaults.js';
 import { UPLOAD_BYTES_PER_STEP } from '../../uploadStep.js';
 import { INSTANCE_STRIDE } from '../../instances.js';
+import { compactIndices } from '../../indexWidth.js';
+import { SNORM16_ONE, UNORM16_ONE, packingFor, sharedValue, vertexPackingOf, } from '../../vertexPacking.js';
+import { formatBytes, interleaveFixed, packedFormat, packingIn } from './vertexFormats.js';
 /**
  * Mesh geometry as WebGPU buffers.
  *
@@ -160,13 +163,33 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
     const bounds = boundsOfPositions(data.positions, createBounds());
     const vertexCount = data.positions.length / 3;
     const layered = data.layers !== undefined;
-    const supplied = VERTEX_LAYOUT.filter((attribute) => (!attribute.optional || data[attribute.name] !== undefined) &&
-        !(dynamic && isStreamed(attribute))).map((attribute) => laidOut(attribute, layered));
+    /* How each attribute travels, which the pipeline key says too: `vertexPacking.ts`. */
+    const packing = vertexPackingOf(data, dynamic);
     /* Interleaved: one stride holding every attribute the mesh actually supplied — less a dynamic
-       mesh's positions and normals, which are buffers of their own. */
-    const stride = supplied.reduce((sum, attribute) => sum + attribute.components * 4, 0);
-    const step = stride / 4;
-    const interleaved = new Float32Array(step * vertexCount);
+       mesh's positions and normals, which are buffers of their own, and any attribute every vertex
+       shares, which is a constant. */
+    const fields = [];
+    let stride = 0;
+    for (const declared of VERTEX_LAYOUT) {
+        if (declared.optional && data[declared.name] === undefined)
+            continue;
+        if (dynamic && isStreamed(declared))
+            continue;
+        const attribute = laidOut(declared, layered);
+        const how = packingFor(packing, attribute.name);
+        if (how === 'constant')
+            continue;
+        const format = packedFormat(attribute.format, how);
+        fields.push({ attribute, packing: how, format, offset: stride });
+        stride += formatBytes(format);
+    }
+    const buffer = new ArrayBuffer(stride * vertexCount);
+    const rows = {
+        floats: new Float32Array(buffer),
+        signed: new Int16Array(buffer),
+        unsigned: new Uint16Array(buffer),
+        bytes: new Uint8Array(buffer),
+    };
     /*
      * **Refused here, in one sentence, rather than by the driver a hundred times.**
      *
@@ -181,7 +204,7 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
      * whose adapter caps at the default, and it deserves a sentence naming the model's size and
      * the device's rather than a wall of validation.
      */
-    const byteLength = align4(interleaved.byteLength);
+    const byteLength = align4(buffer.byteLength);
     const ceiling = device.limits.maxBufferSize;
     if (typeof ceiling === 'number' && byteLength > ceiling) {
         throw new Error(`this mesh needs a ${Math.round(byteLength / 1024 / 1024)} MB vertex buffer and this GPU ` +
@@ -216,10 +239,20 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
             continue;
         absent.set(value, slot * (CONSTANT_SLOT / 4));
     }
+    /* And what every vertex shares, where a mesh's attribute is one value: `vertexPacking.ts`. */
+    for (let slot = 0; slot < VERTEX_LAYOUT.length; slot++) {
+        const attribute = VERTEX_LAYOUT[slot];
+        if (packingFor(packing, attribute.name) !== 'constant')
+            continue;
+        const values = data[attribute.name];
+        absent.set(sharedValue(values, attribute.components), slot * (CONSTANT_SLOT / 4));
+    }
     device.queue.writeBuffer(constants, 0, absent);
+    /* Sixteen bits where every vertex fits, which every draw of this mesh says: indexWidth.ts. */
+    const indices = compactIndices(data.indices, vertexCount);
     const indexBuffer = device.createBuffer({
         label: 'mesh.indices',
-        size: align4(data.indices.byteLength),
+        size: align4(indices.byteLength),
         usage: USAGE.INDEX | USAGE.COPY_DST,
     });
     /* A dynamic mesh's two moving streams: copied from as well as written, for last frame's positions. */
@@ -243,10 +276,11 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
      * buffer never holds a torn one even for the frame between two steps.
      */
     const verticesPerStep = Math.max(1, Math.floor(UPLOAD_BYTES_PER_STEP / (stride + (dynamic ? 24 : 0))));
-    const indexWidth = data.indices.BYTES_PER_ELEMENT;
-    const indicesPerStep = Math.max(1, Math.floor(UPLOAD_BYTES_PER_STEP / indexWidth));
+    /* Whole four-byte words a step, which is all a queue writes: two sixteen-bit indices to one. */
+    const indexWidth = indices.BYTES_PER_ELEMENT;
+    const indicesPerStep = Math.max(1, Math.floor(UPLOAD_BYTES_PER_STEP / 4)) * (4 / indexWidth);
     const totalSteps = Math.max(1, Math.ceil(vertexCount / verticesPerStep)) +
-        Math.max(1, Math.ceil(data.indices.length / indicesPerStep));
+        Math.max(1, Math.ceil(indices.length / indicesPerStep));
     /*
      * **The mesh is assembled out here, by functions of its own, and that is the fix for a copy
      * nobody named.** It was an object literal in this scope, and its `complete` getter shared this
@@ -262,6 +296,7 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
         constants,
         streams,
         indexBuffer,
+        indexFormat: indices instanceof Uint16Array ? 'uint16' : 'uint32',
         stride: streams === null ? stride : 12,
         indexCount: data.indices.length,
         bounds,
@@ -271,7 +306,7 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
         isSkinnedEight: data.joints !== undefined && data.joints2 !== undefined,
         vertexCount,
         hasUvs: data.uvs !== undefined,
-        skinOffsets: streams === null ? skinOffsetsOf(supplied) : null,
+        skinOffsets: streams === null ? skinOffsetsOf(fields) : null,
         hasChannel: data.channel !== undefined,
         morph: data.morphTargets === undefined || data.morphTargetCount === undefined
             ? null
@@ -282,14 +317,14 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
     });
     const job = {
         data,
-        interleaved,
+        indices,
+        rows,
         device,
-        supplied,
+        fields,
         streams,
         vertices,
         indexBuffer,
         vertexCount,
-        step,
         stride,
         verticesPerStep,
         indicesPerStep,
@@ -299,26 +334,35 @@ export function createGpuMeshIncremental(device, data, dynamic = false) {
     return { mesh, upload: uploadSteps(job) };
 }
 function* uploadSteps(job) {
-    const { device, supplied, vertices, indexBuffer, vertexCount, step, stride } = job;
+    const { device, fields, vertices, indexBuffer, vertexCount, stride } = job;
+    /* Floats and halves a vertex: every field is whole words, so both divide. */
+    const step = stride / 4;
+    const halves = stride / 2;
     let taken = 0;
     for (let from = 0; from < vertexCount; from += job.verticesPerStep) {
         const data = job.data;
-        const interleaved = job.interleaved;
+        const rows = job.rows;
         const to = Math.min(from + job.verticesPerStep, vertexCount);
-        let fieldOffset = 0;
-        for (const attribute of supplied) {
+        for (const field of fields) {
+            const attribute = field.attribute;
             const source = data[attribute.name];
-            if (attribute === LAYERED_UVS) {
+            if (field.packing === 'snorm16') {
+                interleaveFixed(rows.signed, source, attribute.components, halves, field.offset / 2, from, to, SNORM16_ONE);
+            }
+            else if (field.packing === 'unorm16') {
+                interleaveFixed(rows.unsigned, source, attribute.components, halves, field.offset / 2, from, to, UNORM16_ONE);
+            }
+            else if (attribute === LAYERED_UVS) {
                 /* (u, v) from the coordinates and the layer after them, one field of three. */
-                interleaveField(interleaved, source, 2, step, fieldOffset, from, to);
-                interleaveField(interleaved, data.layers, 1, step, fieldOffset + 2, from, to);
+                const at = field.offset / 4;
+                interleaveField(rows.floats, source, 2, step, at, from, to);
+                interleaveField(rows.floats, data.layers, 1, step, at + 2, from, to);
             }
             else {
-                interleaveField(interleaved, source, attribute.components, step, fieldOffset, from, to);
+                interleaveField(rows.floats, source, attribute.components, step, field.offset / 4, from, to);
             }
-            fieldOffset += attribute.components;
         }
-        device.queue.writeBuffer(vertices, from * stride, interleaved, from * step, (to - from) * step);
+        device.queue.writeBuffer(vertices, from * stride, rows.bytes, from * stride, (to - from) * stride);
         if (job.streams !== null) {
             const count = (to - from) * 3;
             device.queue.writeBuffer(job.streams.positions, from * 12, data.positions, from * 3, count);
@@ -328,7 +372,7 @@ function* uploadSteps(job) {
         if (taken < job.totalSteps)
             yield;
     }
-    const indices = job.data.indices;
+    const indices = job.indices;
     const indexWidth = indices.BYTES_PER_ELEMENT;
     for (let from = 0; from < indices.length; from += job.indicesPerStep) {
         const to = Math.min(from + job.indicesPerStep, indices.length);
@@ -338,7 +382,8 @@ function* uploadSteps(job) {
             yield;
     }
     job.data = null;
-    job.interleaved = null;
+    job.indices = null;
+    job.rows = null;
     job.progress.uploaded = true;
 }
 /**
@@ -383,28 +428,33 @@ function interleaveField(rows, source, width, step, fieldOffset, from, to) {
  * Where the joints and weights sit in a vertex of `supplied`, the attributes a mesh interleaves in
  * layout order; null unless it supplied both.
  */
-function skinOffsetsOf(supplied) {
-    let floats = 0;
+function skinOffsetsOf(fields) {
     let joints = -1;
     let weights = -1;
     let joints2 = -1;
     let weights2 = -1;
-    for (const attribute of supplied) {
-        if (attribute.name === 'joints')
-            joints = floats * 4;
-        if (attribute.name === 'weights')
-            weights = floats * 4;
-        if (attribute.name === 'joints2')
-            joints2 = floats * 4;
-        if (attribute.name === 'weights2')
-            weights2 = floats * 4;
-        floats += attribute.components;
+    let weightsFormat = 'float32x4';
+    let weights2Format = 'float32x4';
+    for (const field of fields) {
+        const name = field.attribute.name;
+        if (name === 'joints')
+            joints = field.offset;
+        if (name === 'joints2')
+            joints2 = field.offset;
+        if (name === 'weights') {
+            weights = field.offset;
+            weightsFormat = field.format;
+        }
+        if (name === 'weights2') {
+            weights2 = field.offset;
+            weights2Format = field.format;
+        }
     }
     if (joints < 0 || weights < 0)
         return null;
     return joints2 >= 0 && weights2 >= 0
-        ? { joints, weights, joints2, weights2 }
-        : { joints, weights, joints2: -1, weights2: -1 };
+        ? { joints, weights, joints2, weights2, weightsFormat, weights2Format }
+        : { joints, weights, joints2: -1, weights2: -1, weightsFormat, weights2Format };
 }
 /** The handle, made where it can see only what it hands out. */
 function gpuMeshOf(parts) {
@@ -419,6 +469,7 @@ function gpuMeshOf(parts) {
         vertexStride: parts.stride,
         skinOffsets: parts.skinOffsets,
         indexBuffer,
+        indexFormat: parts.indexFormat,
         indexCount: parts.indexCount,
         bounds: parts.bounds,
         get complete() {
@@ -553,7 +604,9 @@ instanced = false) {
          * in the interleaved one. A *skinned* mesh interleaves them, so removing them would shift
          * the stride under every other attribute — which is why `createInstanced` refuses one.
          */
-        const supplied = !attribute.optional || present[String(attribute.name)] === true;
+        /* One value every vertex shares sits with the absent ones: `vertexPacking.ts`. */
+        const packing = packingIn(present, String(attribute.name));
+        const supplied = (!attribute.optional || present[String(attribute.name)] === true) && packing !== 'constant';
         if (instanced && INSTANCE_LOCATIONS.has(attribute.shaderLocation)) {
             /*
              * **Free to drop only because the mesh does not supply it.** An absent optional attribute
@@ -573,12 +626,9 @@ instanced = false) {
             return;
         }
         if (supplied) {
-            interleaved.push({
-                shaderLocation: attribute.shaderLocation,
-                offset,
-                format: attribute.format,
-            });
-            offset += attribute.components * 4;
+            const format = packedFormat(attribute.format, packing);
+            interleaved.push({ shaderLocation: attribute.shaderLocation, offset, format });
+            offset += formatBytes(format);
             return;
         }
         constants.push({

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

@@ -0,0 +1,8 @@
+export declare const CLOTH_ENTRIES: readonly ['clothPose', 'clothRest', 'clothBegin', 'clothPredict', 'clothDistance', 'clothBending', 'clothTether', 'clothLimit', 'clothFinish', 'clothBlend', 'clothPublish'];
+export type ClothEntry = (typeof CLOTH_ENTRIES)[number];
+export interface ClothKernels {
+    readonly layout: GPUBindGroupLayout;
+    readonly outputLayout: GPUBindGroupLayout;
+    readonly pipelines: Readonly<Record<ClothEntry, GPUComputePipeline>>;
+}
+export declare function clothKernelsFor(device: GPUDevice): ClothKernels;

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

@@ -0,0 +1,76 @@
+/**
+ * The cloth solver's layouts and one compute pipeline an entry point of `shaders/clothSolve.wgsl.ts`,
+ * built once a device and shared by every set of garments on it.
+ */
+import { CLOTH_SOLVE_WGSL } from './shaders/clothSolve.wgsl.js';
+import { shaderModule } from './shaderModules.js';
+const COMPUTE = 0x4;
+export const CLOTH_ENTRIES = [
+    'clothPose',
+    'clothRest',
+    'clothBegin',
+    'clothPredict',
+    'clothDistance',
+    'clothBending',
+    'clothTether',
+    'clothLimit',
+    'clothFinish',
+    'clothBlend',
+    'clothPublish',
+];
+const kernelsByDevice = new WeakMap();
+export function clothKernelsFor(device) {
+    const held = kernelsByDevice.get(device);
+    if (held !== undefined)
+        return held;
+    const uniform = (binding, dynamic) => ({
+        binding,
+        visibility: COMPUTE,
+        buffer: { type: 'uniform', hasDynamicOffset: dynamic },
+    });
+    const storage = (binding, type) => ({
+        binding,
+        visibility: COMPUTE,
+        buffer: { type },
+    });
+    /* Seven storage buffers of the eight a stage is granted: the shader's header says why so few. */
+    const layout = device.createBindGroupLayout({
+        label: 'cloth.solve',
+        entries: [
+            uniform(0, false),
+            uniform(1, true),
+            uniform(2, true),
+            storage(3, 'storage'),
+            storage(4, 'storage'),
+            storage(5, 'read-only-storage'),
+            storage(6, 'read-only-storage'),
+            storage(7, 'storage'),
+            storage(8, 'read-only-storage'),
+            storage(9, 'read-only-storage'),
+        ],
+    });
+    const outputLayout = device.createBindGroupLayout({
+        label: 'cloth.publish',
+        entries: [
+            {
+                binding: 0,
+                visibility: COMPUTE,
+                storageTexture: { access: 'write-only', format: 'rgba32float' },
+            },
+        ],
+    });
+    const module = shaderModule(device, { label: 'cloth.solve', code: CLOTH_SOLVE_WGSL });
+    const solve = device.createPipelineLayout({ bindGroupLayouts: [layout] });
+    const publish = device.createPipelineLayout({ bindGroupLayouts: [layout, outputLayout] });
+    const pipelines = {};
+    for (const entry of CLOTH_ENTRIES) {
+        pipelines[entry] = device.createComputePipeline({
+            label: `cloth.${entry}`,
+            layout: entry === 'clothPublish' ? publish : solve,
+            compute: { module, entryPoint: entry },
+        });
+    }
+    const kernels = { layout, outputLayout, pipelines };
+    kernelsByDevice.set(device, kernels);
+    return kernels;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * What one garment of a set has asked the device for and the device has not yet recorded: a pose, a
+ * reset to rest, steps — each with the numbers its round reads, taken when it was asked for.
+ *
+ * **Taken when asked for, because they change after.** `ClothControl` moves its targets to a step's
+ * fraction and calls the device; by the time the set records the step, the next step has moved them
+ * again. So each op keeps the head of its record — fraction, blend, the poses it reads, the carry and
+ * the wind — as it stood, and the set copies it into the round that runs it.
+ *
+ * Grows by doubling and never shrinks, so a settled set allocates nothing a frame.
+ */
+/** Words of a garment's record in a round: the shader's `Pace`. */
+export declare const PACE_WORDS = 44;
+/** The head of it, which an op carries: everything before the garment's own constants. */
+export declare const PACE_HEAD_WORDS = 32;
+export declare const CLOTH_OP_POSE = 0;
+export declare const CLOTH_OP_REST = 1;
+export declare const CLOTH_OP_STEP = 2;
+export declare class ClothOps {
+    private kinds;
+    private heads;
+    private floats;
+    private words;
+    private first;
+    private end;
+    get pending(): number;
+    /** The kind of the op to run next, or -1 where there is none. */
+    get next(): number;
+    /** A new op of `kind`, its head zeroed, for the caller to fill: the float and word offset of it. */
+    push(kind: number): number;
+    get headFloats(): Float32Array;
+    get headWords(): Uint32Array;
+    /**
+     * The next op's head into `out` at `at`, and the op gone. Copied as words, since a head holds
+     * integers too, and a word at a time, since a view a call would be an allocation a round.
+     */
+    take(out: Uint32Array, at: number): void;
+    private grow;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * What one garment of a set has asked the device for and the device has not yet recorded: a pose, a
+ * reset to rest, steps — each with the numbers its round reads, taken when it was asked for.
+ *
+ * **Taken when asked for, because they change after.** `ClothControl` moves its targets to a step's
+ * fraction and calls the device; by the time the set records the step, the next step has moved them
+ * again. So each op keeps the head of its record — fraction, blend, the poses it reads, the carry and
+ * the wind — as it stood, and the set copies it into the round that runs it.
+ *
+ * Grows by doubling and never shrinks, so a settled set allocates nothing a frame.
+ */
+/** Words of a garment's record in a round: the shader's `Pace`. */
+export const PACE_WORDS = 44;
+/** The head of it, which an op carries: everything before the garment's own constants. */
+export const PACE_HEAD_WORDS = 32;
+export const CLOTH_OP_POSE = 0;
+export const CLOTH_OP_REST = 1;
+export const CLOTH_OP_STEP = 2;
+export class ClothOps {
+    kinds = new Uint8Array(8);
+    heads = new ArrayBuffer(8 * PACE_HEAD_WORDS * 4);
+    floats = new Float32Array(this.heads);
+    words = new Uint32Array(this.heads);
+    first = 0;
+    end = 0;
+    get pending() {
+        return this.end - this.first;
+    }
+    /** The kind of the op to run next, or -1 where there is none. */
+    get next() {
+        return this.first < this.end ? this.kinds[this.first] : -1;
+    }
+    /** A new op of `kind`, its head zeroed, for the caller to fill: the float and word offset of it. */
+    push(kind) {
+        if (this.end === this.kinds.length)
+            this.grow();
+        const at = this.end * PACE_HEAD_WORDS;
+        this.floats.fill(0, at, at + PACE_HEAD_WORDS);
+        this.kinds[this.end] = kind;
+        this.end++;
+        return at;
+    }
+    get headFloats() {
+        return this.floats;
+    }
+    get headWords() {
+        return this.words;
+    }
+    /**
+     * The next op's head into `out` at `at`, and the op gone. Copied as words, since a head holds
+     * integers too, and a word at a time, since a view a call would be an allocation a round.
+     */
+    take(out, at) {
+        const from = this.first * PACE_HEAD_WORDS;
+        for (let w = 0; w < PACE_HEAD_WORDS; w++)
+            out[at + w] = this.words[from + w];
+        this.first++;
+        if (this.first === this.end) {
+            this.first = 0;
+            this.end = 0;
+        }
+    }
+    grow() {
+        const live = this.end - this.first;
+        const capacity = this.kinds.length * 2;
+        const kinds = new Uint8Array(capacity);
+        kinds.set(this.kinds.subarray(this.first, this.end));
+        const heads = new ArrayBuffer(capacity * PACE_HEAD_WORDS * 4);
+        const floats = new Float32Array(heads);
+        floats.set(this.floats.subarray(this.first * PACE_HEAD_WORDS, this.end * PACE_HEAD_WORDS));
+        this.kinds = kinds;
+        this.heads = heads;
+        this.floats = floats;
+        this.words = new Uint32Array(heads);
+        this.first = 0;
+        this.end = live;
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * What a set of garments writes once into the buffers its rounds read, and the one per-step number
+ * worked out on the CPU: the constants, each round slot's first record, each colour's and each
+ * garment's batch slot, and the carry a step hands a garment that keeps less than all of its
+ * character's motion. Plain functions over the packed set, apart from the solver that schedules.
+ */
+import type { ResolvedClothParameters } from '@driftengine/physics';
+import type { PackedClothSet } from './clothSetPack.ts';
+/** Bytes of the shader's `Constants`. */
+export declare const CLOTH_CONSTANT_BYTES = 48;
+/** The set's `Constants`: its totals, and the substep length every garment of it shares. */
+export declare function clothConstants(packed: PackedClothSet, h: number): ArrayBuffer;
+/** Each of `rounds` round slots' first record: the round's index times the garments. */
+export declare function clothRoundOffsets(rounds: number, garments: number): Uint32Array<ArrayBuffer>;
+/**
+ * Each colour's range, twice — opening a substep's iterations and not — at a slot each, kind by
+ * kind; then one slot a garment for publishing, its particles' range and its index.
+ */
+export declare function clothBatchSlots(packed: PackedClothSet): Uint32Array<ArrayBuffer>;
+/**
+ * `carryParticles`' rotation, origin and move, into a record's head at `at`, between the model
+ * matrices before and after the step; nothing where the garment keeps all of its character's
+ * motion, which leaves the head's carry at 0.
+ */
+export declare function writeClothCarry(parameters: ResolvedClothParameters, previous: Float32Array, next: Float32Array, words: Uint32Array, f: Float32Array, at: number): void;

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

@@ -0,0 +1,84 @@
+import { DYNAMIC_ALIGNMENT } from './uniformRing.js';
+/** Bytes of the shader's `Constants`. */
+export const CLOTH_CONSTANT_BYTES = 48;
+/** The set's `Constants`: its totals, and the substep length every garment of it shares. */
+export function clothConstants(packed, h) {
+    const bytes = new ArrayBuffer(CLOTH_CONSTANT_BYTES);
+    const u = new Uint32Array(bytes);
+    const f = new Float32Array(bytes);
+    u[0] = packed.count;
+    u[1] = packed.distances;
+    u[2] = packed.bendings;
+    u[3] = packed.joints;
+    u[4] = packed.colliders;
+    f[8] = h;
+    f[9] = 1 / h;
+    f[10] = 1 / (h * h);
+    return bytes;
+}
+/** Each of `rounds` round slots' first record: the round's index times the garments. */
+export function clothRoundOffsets(rounds, garments) {
+    const words = new Uint32Array((rounds * DYNAMIC_ALIGNMENT) / 4);
+    for (let r = 0; r < rounds; r++)
+        words[(r * DYNAMIC_ALIGNMENT) / 4] = r * garments;
+    return words;
+}
+/**
+ * Each colour's range, twice — opening a substep's iterations and not — at a slot each, kind by
+ * kind; then one slot a garment for publishing, its particles' range and its index.
+ */
+export function clothBatchSlots(packed) {
+    const { distanceBatches, bendingBatches, tetherBatches, garments } = packed;
+    const kinds = [distanceBatches, bendingBatches, tetherBatches];
+    let slots = garments.length;
+    for (const batches of kinds)
+        slots += (batches.length - 1) * 2;
+    const words = new Uint32Array((slots * DYNAMIC_ALIGNMENT) / 4);
+    let slot = 0;
+    for (const batches of kinds) {
+        for (let b = 0; b + 1 < batches.length; b++) {
+            for (let first = 0; first < 2; first++) {
+                const at = (slot * DYNAMIC_ALIGNMENT) / 4;
+                words[at] = batches[b];
+                words[at + 1] = batches[b + 1];
+                words[at + 2] = first;
+                slot++;
+            }
+        }
+    }
+    garments.forEach((range, g) => {
+        const at = (slot * DYNAMIC_ALIGNMENT) / 4;
+        words[at] = range.particleBase;
+        words[at + 1] = range.particleBase + range.count;
+        words[at + 2] = g;
+        slot++;
+    });
+    return words;
+}
+/**
+ * `carryParticles`' rotation, origin and move, into a record's head at `at`, between the model
+ * matrices before and after the step; nothing where the garment keeps all of its character's
+ * motion, which leaves the head's carry at 0.
+ */
+export function writeClothCarry(parameters, previous, next, words, f, at) {
+    const turn = 1 - parameters.angularInertia;
+    const move = 1 - parameters.linearInertia;
+    if (turn === 0 && move === 0)
+        return;
+    words[at + 3] = 1;
+    /* Column c of R = R_next × R_previousᵀ, at turn0 … turn2. */
+    for (let col = 0; col < 3; col++) {
+        for (let row = 0; row < 3; row++) {
+            let sum = 0;
+            for (let k = 0; k < 3; k++) {
+                sum += next[k * 4 + row] * previous[k * 4 + col];
+            }
+            f[at + 8 + col * 4 + row] = sum;
+        }
+    }
+    for (let k = 0; k < 3; k++) {
+        f[at + 20 + k] = previous[12 + k];
+        f[at + 24 + k] = (next[12 + k] - previous[12 + k]) * move;
+    }
+    f[at + 23] = turn;
+}

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

@@ -0,0 +1,33 @@
+import type { PackedCloth } from './clothSolvePack.ts';
+/** Floats of statics a particle in a set: a garment's own, and which garment it is. */
+export declare const CLOTH_SET_STATIC_FLOATS: number;
+/** Where one garment sits in a set. */
+export interface ClothGarmentRange {
+    readonly particleBase: number;
+    readonly count: number;
+    readonly jointBase: number;
+    readonly joints: number;
+    readonly colliderBase: number;
+    readonly colliders: number;
+    /** `packCloth`'s limit flags, the garment's own. */
+    readonly limits: number;
+    readonly rigged: boolean;
+}
+export interface PackedClothSet {
+    /** Particles across every garment. */
+    readonly count: number;
+    readonly statics: Float32Array;
+    readonly constraints: Uint32Array;
+    readonly distances: number;
+    readonly bendings: number;
+    readonly tethers: number;
+    /** Each kind's colours across the set: colour `b` of every garment is `[b]` up to `[b + 1]`. */
+    readonly distanceBatches: Uint32Array;
+    readonly bendingBatches: Uint32Array;
+    readonly tetherBatches: Uint32Array;
+    /** Skin matrices and colliders across every garment. */
+    readonly joints: number;
+    readonly colliders: number;
+    readonly garments: readonly ClothGarmentRange[];
+}
+export declare function packClothSet(packs: readonly PackedCloth[]): PackedClothSet;