@driftengine/core 4.10.0 → 4.11.1

package/src/render/backend/webgpu/buffers.ts

@@ -6,6 +6,16 @@ import type { MeshData } from '../../mesh.ts';
 import { ABSENT_ATTRIBUTE } from '../../vertexDefaults.ts';
 import { UPLOAD_BYTES_PER_STEP } from '../../uploadStep.ts';
 import { INSTANCE_STRIDE } from '../../instances.ts';
+import { compactIndices } from '../../indexWidth.ts';
+import {
+  SNORM16_ONE,
+  UNORM16_ONE,
+  packingFor,
+  sharedValue,
+  vertexPackingOf,
+  type AttributePacking,
+} from '../../vertexPacking.ts';
+import { formatBytes, interleaveFixed, packedFormat, packingIn } from './vertexFormats.ts';
 
 /**
  * Mesh geometry as WebGPU buffers.
@@ -172,8 +182,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
@@ -357,17 +372,31 @@ export function createGpuMeshIncremental(
   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 as keyof MeshData] !== 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: Field[] = [];
+  let stride = 0;
+  for (const declared of VERTEX_LAYOUT) {
+    if (declared.optional && data[declared.name as keyof MeshData] === 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: 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.**
@@ -383,7 +412,7 @@ export function createGpuMeshIncremental(
    * 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(
@@ -420,11 +449,20 @@ export function createGpuMeshIncremental(
     if (value === undefined) 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] as VertexAttribute;
+    if (packingFor(packing, attribute.name) !== 'constant') continue;
+    const values = data[attribute.name as keyof MeshData] as Float32Array;
+    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,
   });
 
@@ -453,11 +491,12 @@ export function createGpuMeshIncremental(
     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
@@ -474,6 +513,7 @@ export function createGpuMeshIncremental(
     constants,
     streams,
     indexBuffer,
+    indexFormat: indices instanceof Uint16Array ? 'uint16' : 'uint32',
     stride: streams === null ? stride : 12,
     indexCount: data.indices.length,
     bounds,
@@ -483,7 +523,7 @@ export function createGpuMeshIncremental(
     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
@@ -502,14 +542,14 @@ export function createGpuMeshIncremental(
 
   const job: UploadJob = {
     data,
-    interleaved,
+    indices,
+    rows,
     device,
-    supplied,
+    fields,
     streams,
     vertices,
     indexBuffer,
     vertexCount,
-    step,
     stride,
     verticesPerStep,
     indicesPerStep,
@@ -519,20 +559,38 @@ export function createGpuMeshIncremental(
   return { mesh, upload: uploadSteps(job) };
 }
 
+/** One attribute as a mesh interleaves it: how it travels, the format it is read with, where. */
+interface Field {
+  readonly attribute: VertexAttribute;
+  readonly packing: AttributePacking;
+  readonly format: GPUVertexFormat;
+  /** Bytes into the vertex. */
+  readonly offset: number;
+}
+
+/** The interleaved rows, viewed as each field's type writes them. */
+interface Rows {
+  readonly floats: Float32Array;
+  readonly signed: Int16Array;
+  readonly unsigned: Uint16Array;
+  readonly bytes: Uint8Array;
+}
+
 /**
  * What an upload reads, held by the upload alone and let go when it finishes — so a caller that
  * keeps its iterator, as a streamer keeps the handle it was given, keeps nothing through it.
  */
 interface UploadJob {
   data: MeshData | null;
-  interleaved: Float32Array | null;
+  /** The mesh's indices at the width its buffer holds them: `compactIndices`. */
+  indices: Uint16Array | Uint32Array | null;
+  rows: Rows | null;
   readonly device: GPUDevice;
-  readonly supplied: readonly VertexAttribute[];
+  readonly fields: readonly Field[];
   readonly streams: { readonly positions: GPUBuffer; readonly normals: GPUBuffer } | null;
   readonly vertices: GPUBuffer;
   readonly indexBuffer: GPUBuffer;
   readonly vertexCount: number;
-  readonly step: number;
   readonly stride: number;
   readonly verticesPerStep: number;
   readonly indicesPerStep: number;
@@ -541,33 +599,64 @@ interface UploadJob {
 }
 
 function* uploadSteps(job: UploadJob): Generator<void, void, void> {
-  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 as MeshData;
-    const interleaved = job.interleaved as Float32Array;
+    const rows = job.rows as 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 as keyof MeshData] as Float32Array;
-      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);
+        const at = field.offset / 4;
+        interleaveField(rows.floats, source, 2, step, at, from, to);
+        interleaveField(rows.floats, data.layers as Float32Array, 1, step, at + 2, from, to);
+      } else {
         interleaveField(
-          interleaved,
-          data.layers as Float32Array,
-          1,
+          rows.floats,
+          source,
+          attribute.components,
           step,
-          fieldOffset + 2,
+          field.offset / 4,
           from,
           to,
         );
-      } else {
-        interleaveField(interleaved, source, attribute.components, step, fieldOffset, 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);
@@ -577,7 +666,7 @@ function* uploadSteps(job: UploadJob): Generator<void, void, void> {
     if (taken < job.totalSteps) yield;
   }
 
-  const indices = (job.data as MeshData).indices;
+  const indices = job.indices as Uint16Array | Uint32Array;
   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);
@@ -587,7 +676,8 @@ function* uploadSteps(job: UploadJob): Generator<void, void, void> {
   }
 
   job.data = null;
-  job.interleaved = null;
+  job.indices = null;
+  job.rows = null;
   job.progress.uploaded = true;
 }
 
@@ -638,23 +728,30 @@ function interleaveField(
  * 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: readonly VertexAttribute[]): GpuMesh['skinOffsets'] {
-  let floats = 0;
+function skinOffsetsOf(fields: readonly Field[]): GpuMesh['skinOffsets'] {
   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: GPUVertexFormat = 'float32x4';
+  let weights2Format: GPUVertexFormat = '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. */
@@ -663,6 +760,7 @@ function gpuMeshOf(parts: {
   readonly constants: GPUBuffer;
   readonly streams: { readonly positions: GPUBuffer; readonly normals: GPUBuffer } | null;
   readonly indexBuffer: GPUBuffer;
+  readonly indexFormat: GPUIndexFormat;
   readonly stride: number;
   readonly indexCount: number;
   readonly bounds: Bounds;
@@ -690,6 +788,7 @@ function gpuMeshOf(parts: {
     vertexStride: parts.stride,
     skinOffsets: parts.skinOffsets,
     indexBuffer,
+    indexFormat: parts.indexFormat,
     indexCount: parts.indexCount,
     bounds: parts.bounds,
     get complete(): boolean {
@@ -844,7 +943,10 @@ export function vertexBufferLayouts(
      * 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
@@ -866,12 +968,9 @@ export function vertexBufferLayouts(
       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/src/render/backend/webgpu/clothKernels.ts

@@ -0,0 +1,86 @@
+/**
+ * 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.ts';
+import { shaderModule } from './shaderModules.ts';
+
+const COMPUTE = 0x4;
+
+export const CLOTH_ENTRIES = [
+  'clothPose',
+  'clothRest',
+  'clothBegin',
+  'clothPredict',
+  'clothDistance',
+  'clothBending',
+  'clothTether',
+  'clothLimit',
+  'clothFinish',
+  'clothBlend',
+  'clothPublish',
+] as const;
+export type ClothEntry = (typeof CLOTH_ENTRIES)[number];
+
+export interface ClothKernels {
+  readonly layout: GPUBindGroupLayout;
+  readonly outputLayout: GPUBindGroupLayout;
+  readonly pipelines: Readonly<Record<ClothEntry, GPUComputePipeline>>;
+}
+
+const kernelsByDevice = new WeakMap<GPUDevice, ClothKernels>();
+
+export function clothKernelsFor(device: GPUDevice): ClothKernels {
+  const held = kernelsByDevice.get(device);
+  if (held !== undefined) return held;
+  const uniform = (binding: number, dynamic: boolean): GPUBindGroupLayoutEntry => ({
+    binding,
+    visibility: COMPUTE,
+    buffer: { type: 'uniform', hasDynamicOffset: dynamic },
+  });
+  const storage = (binding: number, type: GPUBufferBindingType): GPUBindGroupLayoutEntry => ({
+    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 = {} as Record<ClothEntry, GPUComputePipeline>;
+  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/src/render/backend/webgpu/clothOps.ts

@@ -0,0 +1,86 @@
+/**
+ * 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 {
+  private kinds = new Uint8Array(8);
+  private heads = new ArrayBuffer(8 * PACE_HEAD_WORDS * 4);
+  private floats = new Float32Array(this.heads);
+  private words = new Uint32Array(this.heads);
+  private first = 0;
+  private end = 0;
+
+  get pending(): number {
+    return this.end - this.first;
+  }
+
+  /** The kind of the op to run next, or -1 where there is none. */
+  get next(): number {
+    return this.first < this.end ? (this.kinds[this.first] as number) : -1;
+  }
+
+  /** A new op of `kind`, its head zeroed, for the caller to fill: the float and word offset of it. */
+  push(kind: number): number {
+    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(): Float32Array {
+    return this.floats;
+  }
+
+  get headWords(): Uint32Array {
+    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: Uint32Array, at: number): void {
+    const from = this.first * PACE_HEAD_WORDS;
+    for (let w = 0; w < PACE_HEAD_WORDS; w++) out[at + w] = this.words[from + w] as number;
+    this.first++;
+    if (this.first === this.end) {
+      this.first = 0;
+      this.end = 0;
+    }
+  }
+
+  private grow(): void {
+    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/src/render/backend/webgpu/clothSetLayout.ts

@@ -0,0 +1,102 @@
+/**
+ * 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';
+import { DYNAMIC_ALIGNMENT } from './uniformRing.ts';
+
+/** 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: PackedClothSet, h: number): ArrayBuffer {
+  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: number, garments: number): Uint32Array<ArrayBuffer> {
+  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: PackedClothSet): Uint32Array<ArrayBuffer> {
+  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] as number;
+        words[at + 1] = batches[b + 1] as number;
+        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: ResolvedClothParameters,
+  previous: Float32Array,
+  next: Float32Array,
+  words: Uint32Array,
+  f: Float32Array,
+  at: number,
+): void {
+  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] as number) * (previous[k * 4 + col] as number);
+      }
+      f[at + 8 + col * 4 + row] = sum;
+    }
+  }
+  for (let k = 0; k < 3; k++) {
+    f[at + 20 + k] = previous[12 + k] as number;
+    f[at + 24 + k] = ((next[12 + k] as number) - (previous[12 + k] as number)) * move;
+  }
+  f[at + 23] = turn;
+}