@driftengine/core 4.13.0 → 4.13.2

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

@@ -60,6 +60,9 @@ import { GpuSceneCaptureTarget } from './sceneCaptureTarget.js';
 import { sceneCaptureTexels } from '../../sceneCapture.js';
 import { gpuCompressedFormats } from './compressedUpload.js';
 import { GpuClothBinding, GpuClothParticles, clothStandIn } from './clothTextures.js';
+import { GroupShelf } from './groupShelf.js';
+import { GpuPointSkin, createPointSkinPipeline } from './pointSkinPass.js';
+import { poseBounds, validatePointSkin, validatePose, } from '../../pointSkin.js';
 import { MODEL_PARAM_FLOATS, eyeAxisInWorld, packModel, skinProfileDistance, } from '../../surfaceModel.js';
 import { OVERLAY_FLOATS, overlayLays, packSurfaceOverlay, } from '../../surfaceOverlay.js';
 import { PROJECTION_FLOATS, packSurfaceProjection } from '../../surfaceProjection.js';
@@ -920,7 +923,9 @@ export class WebGPURenderer {
      * thirty-odd sections, each its own material, built one a section a frame — about ninety a frame
      * for two characters, reported by a consumer. A slot's map holds one entry a material its rigs
      * are drawn in, and is emptied wherever the unskinned groups are, whose identities it is keyed
-     * by.
+     * by. **And by what each group was built with, on a shelf a material** (`groupShelf.ts`): a
+     * garment's particles take turns between two textures and several meshes may follow one cloth,
+     * so one group a material was made again draw after draw.
      */
     skinnedGroups = [];
     /** The cloth the next skinned draws are placed by, or null. See `setCloth`. */
@@ -4931,17 +4936,14 @@ export class WebGPURenderer {
     /** The same layout plus the joint palette. See `createDepthBindGroupLayout`. */
     shadowSkinnedLayout;
     /**
-     * The skinned shadow bind groups, one per palette slot, cached against what can invalidate them.
+     * The skinned shadow bind groups, a shelf per palette slot, each found by what it was built with.
      *
      * The same argument `flatBindGroupFor` makes, and per slot for the same reason: the group it was
      * built beside, and the palette view, which now differs between two characters casting into one
-     * bake. Comparing object identity makes a missed invalidation impossible rather than unlikely.
+     * bake, and the cloth's particles and binding, which take turns. Comparing object identity makes
+     * a missed invalidation impossible rather than unlikely. See `groupShelf.ts`.
      */
-    shadowSkinnedGroups = [];
-    shadowSkinnedGroupsBeside = [];
-    shadowSkinnedGroupsPalette = [];
-    shadowSkinnedGroupsCloth = [];
-    shadowSkinnedGroupsClothBinding = [];
+    shadowSkinnedShelves = [];
     /** Held from construction so the skinned group can be rebuilt without them being threaded. */
     shadowBlankView = null;
     shadowBlankSampler = null;
@@ -5098,18 +5100,17 @@ export class WebGPURenderer {
      */
     shadowSkinnedGroup(palette, at, cloth) {
         const beside = this.shadowBindGroup;
-        if ((this.shadowSkinnedGroups[at] ?? null) === null ||
-            this.shadowSkinnedGroupsBeside[at] !== beside ||
-            this.shadowSkinnedGroupsPalette[at] !== palette ||
-            this.shadowSkinnedGroupsCloth[at] !== cloth.particles ||
-            this.shadowSkinnedGroupsClothBinding[at] !== cloth.binding) {
-            this.shadowSkinnedGroups[at] = createDepthBindGroup(this.surface.device, this.shadowSkinnedLayout, this.shadowDraws.buffer, this.shadowPassUniforms, this.shadowBlankView, this.shadowBlankSampler, palette, null, cloth);
-            this.shadowSkinnedGroupsBeside[at] = beside;
-            this.shadowSkinnedGroupsPalette[at] = palette;
-            this.shadowSkinnedGroupsCloth[at] = cloth.particles;
-            this.shadowSkinnedGroupsClothBinding[at] = cloth.binding;
-        }
-        return this.shadowSkinnedGroups[at];
+        let shelf = this.shadowSkinnedShelves[at];
+        if (shelf === undefined) {
+            shelf = new GroupShelf();
+            this.shadowSkinnedShelves[at] = shelf;
+        }
+        const kept = shelf.find(beside, palette, cloth.particles, cloth.binding);
+        if (kept !== null)
+            return kept;
+        const group = createDepthBindGroup(this.surface.device, this.shadowSkinnedLayout, this.shadowDraws.buffer, this.shadowPassUniforms, this.shadowBlankView, this.shadowBlankSampler, palette, null, cloth);
+        shelf.keep(group, beside, palette, cloth.particles, cloth.binding);
+        return group;
     }
     scatterDepthGroup() {
         return this.shadowLayerIsPeel && this.scatterDepthPeelBindGroup !== null
@@ -6863,7 +6864,7 @@ export class WebGPURenderer {
      * neither the pipeline set nor the key depends on whether the geometry lands in one call or
      * over six frames.
      */
-    warmFlatPipelines(data, dynamic) {
+    warmFlatPipelines(data, dynamic, dynamicColors = false) {
         /*
          * **Every optional attribute, not the two that come to mind.** `present` decides where
          * each attribute sits in the interleaved buffer, and `createGpuMesh` decides the same
@@ -6901,9 +6902,10 @@ export class WebGPURenderer {
         }
         /*
          * And how each attribute travels (`vertexPacking.ts`): a field read as sixteen bits rather than
-         * thirty-two, or not interleaved at all, moves every field after it, so the key says so.
+         * thirty-two, or not interleaved at all, moves every field after it, so the key says so. A
+         * `dynamicColors` mesh's colours are one of those, as `:colors~stream`.
          */
-        const packing = vertexPackingOf(data, dynamic);
+        const packing = vertexPackingOf(data, dynamic, dynamicColors);
         markPacking(present, packing);
         key += packingKey(packing);
         const fullKey = `${this.variant}|${key}`;
@@ -6993,8 +6995,10 @@ export class WebGPURenderer {
     createMesh(given, options = {}) {
         /* The streams it is drawn with, before anything records which it has. See `withLightmapUvs`. */
         const data = withLightmapUvs(given);
-        const fullKey = this.warmFlatPipelines(data, options.dynamic === true);
-        return this.keyed(createGpuMesh(this.surface.device, data, options.dynamic === true), fullKey);
+        const dynamic = options.dynamic === true;
+        const dynamicColors = options.dynamicColors === true;
+        const fullKey = this.warmFlatPipelines(data, dynamic, dynamicColors);
+        return this.keyed(createGpuMesh(this.surface.device, data, dynamic, dynamicColors), fullKey);
     }
     /**
      * Geometry in, handle out — but the geometry lands over as many frames as the caller gives it.
@@ -7007,8 +7011,10 @@ export class WebGPURenderer {
      */
     createMeshIncremental(given, options = {}) {
         const data = withLightmapUvs(given);
-        const fullKey = this.warmFlatPipelines(data, options.dynamic === true);
-        const { mesh, upload } = createGpuMeshIncremental(this.surface.device, data, options.dynamic === true);
+        const dynamic = options.dynamic === true;
+        const dynamicColors = options.dynamicColors === true;
+        const fullKey = this.warmFlatPipelines(data, dynamic, dynamicColors);
+        const { mesh, upload } = createGpuMeshIncremental(this.surface.device, data, dynamic, dynamicColors);
         const surface = this.surface;
         return {
             mesh: this.keyed(mesh, fullKey),
@@ -7102,6 +7108,75 @@ export class WebGPURenderer {
         }
         mesh.update(this.surface.device, positions, normals, staged);
     }
+    /** The pipeline every point skin poses with, made at the first one. See `pointSkinPass.ts`. */
+    pointSkinPipeline = null;
+    /**
+     * A dynamic mesh posed on the device from weighted points in its joints' spaces. Refused in words
+     * on a mesh that is not dynamic, whose positions share one buffer with the rest of each vertex.
+     */
+    createPointSkin(mesh, data) {
+        if (mesh.update === null) {
+            throw new Error('a point skin poses a mesh created with { dynamic: true }, whose positions and normals ' +
+                'have buffers of their own for the pose to write. Say so at `createMesh`.');
+        }
+        validatePointSkin(data, mesh.vertexCount);
+        const device = this.surface.device;
+        this.pointSkinPipeline ??= createPointSkinPipeline(device);
+        return new GpuPointSkin(device, this.pointSkinPipeline, mesh, data);
+    }
+    /**
+     * Pose a skin: `matrices` holds each joint's transform into the mesh's model space, sixteen floats,
+     * column-major. Recorded into the encoder the frame's next submit leads with, behind a copy of
+     * last frame's positions where a reconstruction keeps them, as `updateMesh` records its rewrite.
+     */
+    posePointSkin(skin, matrices) {
+        validatePose(matrices, skin.reach);
+        if (this.surface.lost)
+            return;
+        const mesh = skin.mesh;
+        poseBounds(matrices, skin.reach, mesh.bounds);
+        const encoder = this.rewriteCopies();
+        const motion = mesh.motion;
+        if (motion !== null && this.reconstructionWanted) {
+            const frame = frameOfChange(this.moverFrame, this.inFrame);
+            if (keepsPrevious(motion.changed, frame)) {
+                const size = mesh.vertexBuffers[0]?.size ?? 0;
+                motion.previous ??= this.surface.device.createBuffer({
+                    label: 'recon.dynamicPrevious',
+                    size,
+                    usage: 0x0020 | 0x0008, // VERTEX | COPY_DST
+                });
+                encoder.copyBufferToBuffer(mesh.vertexBuffers[0], 0, motion.previous, 0, size);
+            }
+            motion.changed = frame;
+        }
+        skin.pose(this.surface.device, encoder, matrices);
+    }
+    /**
+     * **The pending rewrites go first**, since a pose recorded into them reads the skin's buffers and
+     * a destroyed buffer in a submit loses the whole command buffer. Nothing else reads them, so once
+     * the rewrites are submitted, which only moves them earlier, the buffers can go at once.
+     */
+    disposePointSkin(skin) {
+        if (this.pendingRewrites !== null && !this.surface.lost)
+            this.submit([]);
+        skin.dispose();
+    }
+    /**
+     * Rewrite a mesh's colours. Refused in words on a mesh that did not ask for `dynamicColors`,
+     * whose colours are interleaved with the rest of a vertex or are one value with no buffer at all.
+     * See `GpuMesh.updateColors`.
+     */
+    updateMeshColors(mesh, colors) {
+        if (mesh.updateColors === null) {
+            throw new Error('this mesh was not created with { dynamicColors: true }, so its colours are packed with ' +
+                'the rest of each vertex, or are one value with no buffer at all, and cannot be ' +
+                'rewritten. Say so at `createMesh`: the flag gives the colours a buffer of their own.');
+        }
+        if (this.surface.lost)
+            return;
+        mesh.updateColors(this.surface.device, colors);
+    }
     /**
      * Settle everything the frame shares: the camera, the lights and the fog.
      *
@@ -10067,26 +10142,22 @@ export class WebGPURenderer {
             byMaterial = new Map();
             this.skinnedGroups[at] = byMaterial;
         }
-        let twin = byMaterial.get(base);
-        if (twin === undefined ||
-            twin.palette !== palette ||
-            twin.deltas !== deltas ||
-            twin.cloth !== (cloth?.particles ?? null) ||
-            twin.clothBinding !== (cloth?.binding ?? null)) {
-            /* Built from the live material, with the overlay's atlas where `base` is its twin. */
-            this.overlayBinding = base !== this.bindGroup;
-            const group = createFlatBindGroup(this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, this.perDraw.buffer, this.passRing.buffer, this.materialStore.buffer, this.viewRing.buffer, this.flatTextures, palette, deltas, cloth);
-            this.overlayBinding = false;
-            twin = {
-                group,
-                palette,
-                deltas,
-                cloth: cloth?.particles ?? null,
-                clothBinding: cloth?.binding ?? null,
-            };
-            byMaterial.set(base, twin);
-        }
-        return twin.group;
+        let shelf = byMaterial.get(base);
+        if (shelf === undefined) {
+            shelf = new GroupShelf();
+            byMaterial.set(base, shelf);
+        }
+        const particles = cloth?.particles ?? null;
+        const binding = cloth?.binding ?? null;
+        const kept = shelf.find(palette, deltas, particles, binding);
+        if (kept !== null)
+            return kept;
+        /* Built from the live material, with the overlay's atlas where `base` is its twin. */
+        this.overlayBinding = base !== this.bindGroup;
+        const group = createFlatBindGroup(this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, this.perDraw.buffer, this.passRing.buffer, this.materialStore.buffer, this.viewRing.buffer, this.flatTextures, palette, deltas, cloth);
+        this.overlayBinding = false;
+        shelf.keep(group, palette, deltas, particles, binding);
+        return group;
     }
     /** The layout matching a pair of vertex flags. A pipeline and its bind group must agree. */
     flatLayoutFor(skinned, morphed) {

package/dist/render/backend/webgpu/shaders/clothSolve.wgsl.d.ts

@@ -37,4 +37,4 @@
  * a reset, sits the round out while the rest of the set runs it.
  */
 export declare const CLOTH_WORKGROUP = 64;
-export declare const CLOTH_SOLVE_WGSL = "\n/* The set's: every garment's particles, records, skin matrices and colliders, and the step length\n   they all share. */\nstruct Constants {\n  count: u32,\n  distances: u32,\n  bendings: u32,\n  joints: u32,\n  colliders: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n  h: f32,\n  invH: f32,\n  invH2: f32,\n  pad3: f32,\n}\n\n/* Where this dispatch's round of records starts in paces, at a dynamic offset. */\nstruct Round {\n  at: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n}\n\n/* One garment's numbers for one round: its step's, and its own that never change. */\nstruct Pace {\n  fraction: f32,\n  blend: f32,\n  alpha: f32,\n  carry: u32,\n  /* Where the pose a step starts from and the one it moves toward sit in pose, in floats. */\n  fromAt: u32,\n  toAt: u32,\n  /* 0 where the garment sits this round out. Not active, which WGSL reserves. */\n  live: u32,\n  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the garment has at all. */\n  limits: u32,\n  /* The character's turn since the last step, by columns; origin.w is the share carried. */\n  turn0: vec4<f32>,\n  turn1: vec4<f32>,\n  turn2: vec4<f32>,\n  origin: vec4<f32>,\n  shift: vec4<f32>,\n  /* The frame's wind: one wind, sampled once a frame, so a step's rather than the set-up's. */\n  wind: vec4<f32>,\n  colliderBase: u32,\n  colliders: u32,\n  width: u32,\n  pad0: u32,\n  keep: f32,\n  dragKeep: f32,\n  maxDistanceScale: f32,\n  margin: f32,\n  gravity: vec4<f32>,\n}\n\n/* One colour of one kind of constraint across the set, at a dynamic offset; first resets the\n   multipliers. Publishing reads one garment's particles as begin to end, and first is the garment. */\nstruct Batch {\n  begin: u32,\n  end: u32,\n  first: u32,\n  pad: u32,\n}\n\n@group(0) @binding(0) var<uniform> c: Constants;\n@group(0) @binding(1) var<uniform> round: Round;\n@group(0) @binding(2) var<uniform> batch: Batch;\n@group(0) @binding(3) var<storage, read_write> state: array<f32>;\n@group(0) @binding(4) var<storage, read_write> pose: array<f32>;\n@group(0) @binding(5) var<storage, read> statics: array<f32>;\n@group(0) @binding(6) var<storage, read> constraints: array<u32>;\n@group(0) @binding(7) var<storage, read_write> lambda: array<f32>;\n@group(0) @binding(8) var<storage, read> frame: array<f32>;\n@group(0) @binding(9) var<storage, read> paces: array<Pace>;\n\n/* The record of particle i's garment this round: which garment a particle is, in statics. */\nfn paceAt(i: u32) -> u32 {\n  return round.at + u32(statics[29u * c.count + i]);\n}\n\nfn stateAt(section: u32, i: u32) -> u32 {\n  return section * 3u * c.count + i * 3u;\n}\n\nfn load(at: u32) -> vec3<f32> {\n  return vec3<f32>(state[at], state[at + 1u], state[at + 2u]);\n}\n\nfn store(at: u32, v: vec3<f32>) {\n  state[at] = v.x;\n  state[at + 1u] = v.y;\n  state[at + 2u] = v.z;\n}\n\nfn poseOf(at: u32) -> vec3<f32> {\n  return vec3<f32>(pose[at], pose[at + 1u], pose[at + 2u]);\n}\n\n/* Sections of state. */\nconst POSITION = 0u;\nconst PREVIOUS = 1u;\nconst VELOCITY = 2u;\nconst START = 3u;\n\nfn inverseMass(i: u32) -> f32 {\n  return statics[i];\n}\n\n/* Where skinning puts particle i, fraction of the way from the last pose to the latest. */\nfn skinnedAt(i: u32, g: u32) -> vec3<f32> {\n  let a = poseOf(paces[g].fromAt + i * 3u);\n  let b = poseOf(paces[g].toAt + i * 3u);\n  return a + (b - a) * paces[g].fraction;\n}\n\nfn skinMatrix(j: u32) -> mat4x4<f32> {\n  let at = j * 16u;\n  return mat4x4<f32>(\n    vec4<f32>(frame[at], frame[at + 1u], frame[at + 2u], frame[at + 3u]),\n    vec4<f32>(frame[at + 4u], frame[at + 5u], frame[at + 6u], frame[at + 7u]),\n    vec4<f32>(frame[at + 8u], frame[at + 9u], frame[at + 10u], frame[at + 11u]),\n    vec4<f32>(frame[at + 12u], frame[at + 13u], frame[at + 14u], frame[at + 15u]));\n}\n\n/* skinParticles: each particle's skinned position and normal by up to eight influences. */\n@compute @workgroup_size(64)\nfn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let n = c.count;\n  let restAt = 7u * n + i * 3u;\n  let normalAt = 10u * n + i * 3u;\n  let x = vec4<f32>(statics[restAt], statics[restAt + 1u], statics[restAt + 2u], 1.0);\n  let q0 = vec3<f32>(statics[normalAt], statics[normalAt + 1u], statics[normalAt + 2u]);\n  var p = vec3<f32>(0.0);\n  var q = vec3<f32>(0.0);\n  for (var half = 0u; half < 2u; half++) {\n    for (var k = 0u; k < 4u; k++) {\n      let at = 13u * n + i * 16u + half * 8u;\n      let w = statics[at + 4u + k];\n      if (w == 0.0) {\n        continue;\n      }\n      let m = skinMatrix(u32(statics[at + k]));\n      p += w * (m * x).xyz;\n      q += w * (mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * q0);\n    }\n  }\n  let to = paces[g].toAt + i * 3u;\n  pose[to] = p.x;\n  pose[to + 1u] = p.y;\n  pose[to + 2u] = p.z;\n  let len = sqrt(dot(q, q));\n  let inv = select(0.0, 1.0 / len, len > 1e-12);\n  let normal = 6u * n + i * 3u;\n  pose[normal] = q.x * inv;\n  pose[normal + 1u] = q.y * inv;\n  pose[normal + 2u] = q.z * inv;\n}\n\n/* SkinnedCloth.rest: every particle at the latest skinned position, at rest. */\n@compute @workgroup_size(64)\nfn clothRest(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let p = poseOf(paces[g].toAt + i * 3u);\n  store(stateAt(POSITION, i), p);\n  store(stateAt(START, i), p);\n  store(stateAt(VELOCITY, i), vec3<f32>(0.0));\n}\n\n/* The step's start: the step start kept, a free particle carried, a kinematic one placed. */\n@compute @workgroup_size(64)\nfn clothBegin(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(START, i), p);\n  if (inverseMass(i) == 0.0) {\n    store(at, skinnedAt(i, g));\n    return;\n  }\n  if (paces[g].carry == 0u) {\n    return;\n  }\n  /* carryParticles: the share of the character's turn about its old origin, and of its move. */\n  let turn = mat3x3<f32>(paces[g].turn0.xyz, paces[g].turn1.xyz, paces[g].turn2.xyz);\n  let share = paces[g].origin.w;\n  let x = p - paces[g].origin.xyz;\n  store(at, p + (turn * x - x) * share + paces[g].shift.xyz);\n  let vAt = stateAt(VELOCITY, i);\n  let v = load(vAt);\n  store(vAt, v + (turn * v - v) * share);\n}\n\n/* predictParticles. */\n@compute @workgroup_size(64)\nfn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(PREVIOUS, i), p);\n  if (inverseMass(i) == 0.0) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  let air = paces[g].wind.xyz;\n  let v = air + (load(vAt) * paces[g].keep - air) * paces[g].dragKeep + paces[g].gravity.xyz * c.h;\n  store(vAt, v);\n  store(at, p + v * c.h);\n}\n\n/* solveDistanceBatch: one invocation a constraint of the batch, constraints sorted by batch. */\n@compute @workgroup_size(64)\nfn clothDistance(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let a = constraints[k * 4u];\n  let b = constraints[k * 4u + 1u];\n  /* A garment sitting the round out solves nothing, and its next step's first pass resets. */\n  if (paces[paceAt(a)].live == 0u) {\n    return;\n  }\n  /* The first pass of a substep starts the multiplier at nothing, as the CPU's fill(0) does \u2014\n     written before any early return, so a skipped constraint does not carry the last one. */\n  if (batch.first == 1u) {\n    lambda[k] = 0.0;\n  }\n  let wa = inverseMass(a);\n  let wb = inverseMass(b);\n  let w = wa + wb;\n  if (w == 0.0) {\n    return;\n  }\n  let aAt = stateAt(POSITION, a);\n  let bAt = stateAt(POSITION, b);\n  let d = load(bAt) - load(aAt);\n  let len = sqrt(dot(d, d));\n  if (len < 1e-9) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[k * 4u + 3u]) * c.invH2;\n  let old = lambda[k];\n  let delta = (-(len - bitcast<f32>(constraints[k * 4u + 2u])) - alpha * old) / (w + alpha);\n  lambda[k] = old + delta;\n  let s = delta / len;\n  /* A pinned particle is shared across a batch, so it is never written, even with itself. */\n  if (wa > 0.0) {\n    store(aAt, load(aAt) - d * s * wa);\n  }\n  if (wb > 0.0) {\n    store(bAt, load(bAt) + d * s * wb);\n  }\n}\n\n/* solveBendingBatch, with the angle from atan2 (see the header). */\n@compute @workgroup_size(64)\nfn clothBending(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + k * 6u;\n  let slot = c.distances + k;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  if (batch.first == 1u) {\n    lambda[slot] = 0.0;\n  }\n  let ids = vec4<u32>(constraints[at], constraints[at + 1u], constraints[at + 2u], constraints[at + 3u]);\n  let w = vec4<f32>(inverseMass(ids.x), inverseMass(ids.y), inverseMass(ids.z), inverseMass(ids.w));\n  if (w.x + w.y + w.z + w.w == 0.0) {\n    return;\n  }\n  let origin = load(stateAt(POSITION, ids.x));\n  let e = load(stateAt(POSITION, ids.y)) - origin;\n  let p3 = load(stateAt(POSITION, ids.z)) - origin;\n  let p4 = load(stateAt(POSITION, ids.w)) - origin;\n  var n1 = cross(e, p3);\n  var n2 = cross(e, p4);\n  let l1 = sqrt(dot(n1, n1));\n  let l2 = sqrt(dot(n2, n2));\n  if (l1 < 1e-12 || l2 < 1e-12) {\n    return;\n  }\n  n1 = n1 / l1;\n  n2 = n2 / l2;\n  let d = clamp(dot(n1, n2), -1.0, 1.0);\n  let sine = sqrt(dot(cross(n1, n2), cross(n1, n2)));\n  if (sine < 1e-6) {\n    return;\n  }\n  /* The q vectors: the negative of the derivative of n1 \u00B7 n2. See solveBendingBatch. */\n  let q3 = (cross(e, n2) + cross(n1, e) * d) / l1;\n  let q4 = (cross(e, n1) + cross(n2, e) * d) / l2;\n  let q2 = -((cross(p3, n2) + cross(n1, p3) * d) / l1 + (cross(p4, n1) + cross(n2, p4) * d) / l2);\n  let q1 = -(q2 + q3 + q4);\n  var sum = w.x * dot(q1, q1) + w.y * dot(q2, q2) + w.z * dot(q3, q3) + w.w * dot(q4, q4);\n  sum = sum / (sine * sine);\n  if (sum < 1e-12) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[at + 5u]) * c.invH2;\n  let old = lambda[slot];\n  let angle = atan2(sine, d);\n  let delta = (-(angle - bitcast<f32>(constraints[at + 4u])) - alpha * old) / (sum + alpha);\n  lambda[slot] = old + delta;\n  let scale = delta / sine;\n  if (w.x > 0.0) {\n    let p = stateAt(POSITION, ids.x);\n    store(p, load(p) + w.x * scale * q1);\n  }\n  if (w.y > 0.0) {\n    let p = stateAt(POSITION, ids.y);\n    store(p, load(p) + w.y * scale * q2);\n  }\n  if (w.z > 0.0) {\n    let p = stateAt(POSITION, ids.z);\n    store(p, load(p) + w.z * scale * q3);\n  }\n  if (w.w > 0.0) {\n    let p = stateAt(POSITION, ids.w);\n    store(p, load(p) + w.w * scale * q4);\n  }\n}\n\n/* solveTethers, one invocation a tether of the batch: a batch holds a particle once. */\n@compute @workgroup_size(64)\nfn clothTether(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + c.bendings * 6u + k * 3u;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  let pAt = stateAt(POSITION, constraints[at]);\n  let anchor = load(stateAt(POSITION, constraints[at + 1u]));\n  let d = load(pAt) - anchor;\n  let dist = sqrt(dot(d, d));\n  let reach = bitcast<f32>(constraints[at + 2u]);\n  if (dist <= reach || dist < 1e-9) {\n    return;\n  }\n  store(pAt, anchor + d * (reach / dist));\n}\n\n/* pushOut: the point onto the sphere's surface if it is inside. A point at the centre stays. */\nfn pushOut(p: vec3<f32>, centre: vec3<f32>, radius: f32) -> vec3<f32> {\n  let d = p - centre;\n  let d2 = dot(d, d);\n  if (d2 >= radius * radius || d2 < 1e-18) {\n    return p;\n  }\n  return centre + d * (radius / sqrt(d2));\n}\n\n/* applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */\n@compute @workgroup_size(64)\nfn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count || inverseMass(i) == 0.0) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let limits = paces[g].limits;\n  let n = c.count;\n  let at = stateAt(POSITION, i);\n  var p = load(at);\n  let t = skinnedAt(i, g);\n  /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */\n  let maxDistance = statics[n + i];\n  if ((limits & 1u) != 0u && maxDistance >= 0.0) {\n    let limit = maxDistance * paces[g].maxDistanceScale;\n    let d = p - t;\n    let d2 = dot(d, d);\n    if (d2 > limit * limit) {\n      p = t + d * (limit / sqrt(d2));\n    }\n  }\n  let normal = poseOf(6u * n + i * 3u);\n  if ((limits & 2u) != 0u) {\n    let radius = statics[2u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t - normal * (statics[2u * n + i * 2u] + radius), radius);\n    }\n  }\n  if ((limits & 4u) != 0u) {\n    let radius = statics[4u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t + normal * (statics[4u * n + i * 2u] + radius), radius);\n    }\n  }\n  let pad = statics[6u * n + i] + paces[g].margin;\n  let ends = c.joints * 16u;\n  let radii = ends + c.colliders * 6u;\n  let first = paces[g].colliderBase;\n  for (var k = first; k < first + paces[g].colliders; k++) {\n    let a = vec3<f32>(frame[ends + k * 6u], frame[ends + k * 6u + 1u], frame[ends + k * 6u + 2u]);\n    let e = vec3<f32>(frame[ends + k * 6u + 3u], frame[ends + k * 6u + 4u], frame[ends + k * 6u + 5u]) - a;\n    let e2 = dot(e, e);\n    var s = 0.0;\n    if (e2 > 1e-18) {\n      s = clamp(dot(p - a, e) / e2, 0.0, 1.0);\n    }\n    let r0 = frame[radii + k * 2u];\n    let r1 = frame[radii + k * 2u + 1u];\n    p = pushOut(p, a + e * s, r0 + (r1 - r0) * s + pad);\n  }\n  store(at, p);\n}\n\n/* finishParticles. */\n@compute @workgroup_size(64)\nfn clothFinish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  if (paces[paceAt(i)].live == 0u) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  if (inverseMass(i) == 0.0) {\n    store(vAt, vec3<f32>(0.0));\n    return;\n  }\n  store(vAt, (load(stateAt(POSITION, i)) - load(stateAt(PREVIOUS, i))) * c.invH);\n}\n\n/* SkinnedCloth.blend: after a reset, the simulation's share grows over the blend's steps. */\n@compute @workgroup_size(64)\nfn clothBlend(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  /* A blend of 0 is none, not a last step of one: see ClothDevice.step. */\n  let g = paceAt(i);\n  let blend = paces[g].blend;\n  if (paces[g].live == 0u || blend <= 0.0) {\n    return;\n  }\n  let t = skinnedAt(i, g);\n  let at = stateAt(POSITION, i);\n  store(at, t + (load(at) - t) * blend);\n  let vAt = stateAt(VELOCITY, i);\n  store(vAt, load(vAt) * blend);\n}\n\n@group(1) @binding(0) var output: texture_storage_2d<rgba32float, write>;\n\n/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads: one garment's, whose\n   particles are batch.begin to batch.end and whose record is batch.first's. */\n@compute @workgroup_size(64)\nfn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = batch.begin + id.x;\n  if (i >= batch.end) {\n    return;\n  }\n  let g = round.at + batch.first;\n  let a = load(stateAt(START, i));\n  let p = a + (load(stateAt(POSITION, i)) - a) * paces[g].alpha;\n  let local = id.x;\n  let width = paces[g].width;\n  textureStore(output, vec2<u32>(local % width, local / width), vec4<f32>(p, 0.0));\n}\n";
+export declare const CLOTH_SOLVE_WGSL = "\n/* The set's: every garment's particles, records, skin matrices and colliders, and the step length\n   they all share. */\nstruct Constants {\n  count: u32,\n  distances: u32,\n  bendings: u32,\n  joints: u32,\n  colliders: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n  h: f32,\n  invH: f32,\n  invH2: f32,\n  pad3: f32,\n}\n\n/* Where this dispatch's round of records starts in paces, at a dynamic offset. */\nstruct Round {\n  at: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n}\n\n/* One garment's numbers for one round: its step's, and its own that never change. */\nstruct Pace {\n  fraction: f32,\n  blend: f32,\n  alpha: f32,\n  carry: u32,\n  /* Where the pose a step starts from and the one it moves toward sit in pose, in floats. */\n  fromAt: u32,\n  toAt: u32,\n  /* 0 where the garment sits this round out. Not active, which WGSL reserves. */\n  live: u32,\n  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the garment has at all. */\n  limits: u32,\n  /* The character's turn since the last step, by columns; origin.w is the share carried. */\n  turn0: vec4<f32>,\n  turn1: vec4<f32>,\n  turn2: vec4<f32>,\n  origin: vec4<f32>,\n  shift: vec4<f32>,\n  /* The frame's wind: one wind, sampled once a frame, so a step's rather than the set-up's. */\n  wind: vec4<f32>,\n  colliderBase: u32,\n  colliders: u32,\n  width: u32,\n  /* The share of its offset from its skinned position a particle keeps a substep: the pull's. */\n  pullKeep: f32,\n  keep: f32,\n  dragKeep: f32,\n  maxDistanceScale: f32,\n  margin: f32,\n  gravity: vec4<f32>,\n}\n\n/* One colour of one kind of constraint across the set, at a dynamic offset; first resets the\n   multipliers. Publishing reads one garment's particles as begin to end, and first is the garment. */\nstruct Batch {\n  begin: u32,\n  end: u32,\n  first: u32,\n  pad: u32,\n}\n\n@group(0) @binding(0) var<uniform> c: Constants;\n@group(0) @binding(1) var<uniform> round: Round;\n@group(0) @binding(2) var<uniform> batch: Batch;\n@group(0) @binding(3) var<storage, read_write> state: array<f32>;\n@group(0) @binding(4) var<storage, read_write> pose: array<f32>;\n@group(0) @binding(5) var<storage, read> statics: array<f32>;\n@group(0) @binding(6) var<storage, read> constraints: array<u32>;\n@group(0) @binding(7) var<storage, read_write> lambda: array<f32>;\n@group(0) @binding(8) var<storage, read> frame: array<f32>;\n@group(0) @binding(9) var<storage, read> paces: array<Pace>;\n\n/* The record of particle i's garment this round: which garment a particle is, in statics. */\nfn paceAt(i: u32) -> u32 {\n  return round.at + u32(statics[29u * c.count + i]);\n}\n\nfn stateAt(section: u32, i: u32) -> u32 {\n  return section * 3u * c.count + i * 3u;\n}\n\nfn load(at: u32) -> vec3<f32> {\n  return vec3<f32>(state[at], state[at + 1u], state[at + 2u]);\n}\n\nfn store(at: u32, v: vec3<f32>) {\n  state[at] = v.x;\n  state[at + 1u] = v.y;\n  state[at + 2u] = v.z;\n}\n\nfn poseOf(at: u32) -> vec3<f32> {\n  return vec3<f32>(pose[at], pose[at + 1u], pose[at + 2u]);\n}\n\n/* Sections of state. */\nconst POSITION = 0u;\nconst PREVIOUS = 1u;\nconst VELOCITY = 2u;\nconst START = 3u;\n\nfn inverseMass(i: u32) -> f32 {\n  return statics[i];\n}\n\n/* Where skinning puts particle i, fraction of the way from the last pose to the latest. */\nfn skinnedAt(i: u32, g: u32) -> vec3<f32> {\n  let a = poseOf(paces[g].fromAt + i * 3u);\n  let b = poseOf(paces[g].toAt + i * 3u);\n  return a + (b - a) * paces[g].fraction;\n}\n\nfn skinMatrix(j: u32) -> mat4x4<f32> {\n  let at = j * 16u;\n  return mat4x4<f32>(\n    vec4<f32>(frame[at], frame[at + 1u], frame[at + 2u], frame[at + 3u]),\n    vec4<f32>(frame[at + 4u], frame[at + 5u], frame[at + 6u], frame[at + 7u]),\n    vec4<f32>(frame[at + 8u], frame[at + 9u], frame[at + 10u], frame[at + 11u]),\n    vec4<f32>(frame[at + 12u], frame[at + 13u], frame[at + 14u], frame[at + 15u]));\n}\n\n/* skinParticles: each particle's skinned position and normal by up to eight influences. */\n@compute @workgroup_size(64)\nfn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let n = c.count;\n  let restAt = 7u * n + i * 3u;\n  let normalAt = 10u * n + i * 3u;\n  let x = vec4<f32>(statics[restAt], statics[restAt + 1u], statics[restAt + 2u], 1.0);\n  let q0 = vec3<f32>(statics[normalAt], statics[normalAt + 1u], statics[normalAt + 2u]);\n  var p = vec3<f32>(0.0);\n  var q = vec3<f32>(0.0);\n  for (var half = 0u; half < 2u; half++) {\n    for (var k = 0u; k < 4u; k++) {\n      let at = 13u * n + i * 16u + half * 8u;\n      let w = statics[at + 4u + k];\n      if (w == 0.0) {\n        continue;\n      }\n      let m = skinMatrix(u32(statics[at + k]));\n      p += w * (m * x).xyz;\n      q += w * (mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * q0);\n    }\n  }\n  let to = paces[g].toAt + i * 3u;\n  pose[to] = p.x;\n  pose[to + 1u] = p.y;\n  pose[to + 2u] = p.z;\n  let len = sqrt(dot(q, q));\n  let inv = select(0.0, 1.0 / len, len > 1e-12);\n  let normal = 6u * n + i * 3u;\n  pose[normal] = q.x * inv;\n  pose[normal + 1u] = q.y * inv;\n  pose[normal + 2u] = q.z * inv;\n}\n\n/* SkinnedCloth.rest: every particle at the latest skinned position, at rest. */\n@compute @workgroup_size(64)\nfn clothRest(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let p = poseOf(paces[g].toAt + i * 3u);\n  store(stateAt(POSITION, i), p);\n  store(stateAt(START, i), p);\n  store(stateAt(VELOCITY, i), vec3<f32>(0.0));\n}\n\n/* The step's start: the step start kept, a free particle carried, a kinematic one placed. */\n@compute @workgroup_size(64)\nfn clothBegin(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(START, i), p);\n  if (inverseMass(i) == 0.0) {\n    store(at, skinnedAt(i, g));\n    return;\n  }\n  if (paces[g].carry == 0u) {\n    return;\n  }\n  /* carryParticles: the share of the character's turn about its old origin, and of its move. */\n  let turn = mat3x3<f32>(paces[g].turn0.xyz, paces[g].turn1.xyz, paces[g].turn2.xyz);\n  let share = paces[g].origin.w;\n  let x = p - paces[g].origin.xyz;\n  store(at, p + (turn * x - x) * share + paces[g].shift.xyz);\n  let vAt = stateAt(VELOCITY, i);\n  let v = load(vAt);\n  store(vAt, v + (turn * v - v) * share);\n}\n\n/* predictParticles. */\n@compute @workgroup_size(64)\nfn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(PREVIOUS, i), p);\n  if (inverseMass(i) == 0.0) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  let air = paces[g].wind.xyz;\n  let v = air + (load(vAt) * paces[g].keep - air) * paces[g].dragKeep + paces[g].gravity.xyz * c.h;\n  store(vAt, v);\n  store(at, p + v * c.h);\n}\n\n/* solveDistanceBatch: one invocation a constraint of the batch, constraints sorted by batch. */\n@compute @workgroup_size(64)\nfn clothDistance(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let a = constraints[k * 4u];\n  let b = constraints[k * 4u + 1u];\n  /* A garment sitting the round out solves nothing, and its next step's first pass resets. */\n  if (paces[paceAt(a)].live == 0u) {\n    return;\n  }\n  /* The first pass of a substep starts the multiplier at nothing, as the CPU's fill(0) does \u2014\n     written before any early return, so a skipped constraint does not carry the last one. */\n  if (batch.first == 1u) {\n    lambda[k] = 0.0;\n  }\n  let wa = inverseMass(a);\n  let wb = inverseMass(b);\n  let w = wa + wb;\n  if (w == 0.0) {\n    return;\n  }\n  let aAt = stateAt(POSITION, a);\n  let bAt = stateAt(POSITION, b);\n  let d = load(bAt) - load(aAt);\n  let len = sqrt(dot(d, d));\n  if (len < 1e-9) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[k * 4u + 3u]) * c.invH2;\n  let old = lambda[k];\n  let delta = (-(len - bitcast<f32>(constraints[k * 4u + 2u])) - alpha * old) / (w + alpha);\n  lambda[k] = old + delta;\n  let s = delta / len;\n  /* A pinned particle is shared across a batch, so it is never written, even with itself. */\n  if (wa > 0.0) {\n    store(aAt, load(aAt) - d * s * wa);\n  }\n  if (wb > 0.0) {\n    store(bAt, load(bAt) + d * s * wb);\n  }\n}\n\n/* solveBendingBatch, with the angle from atan2 (see the header). */\n@compute @workgroup_size(64)\nfn clothBending(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + k * 6u;\n  let slot = c.distances + k;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  if (batch.first == 1u) {\n    lambda[slot] = 0.0;\n  }\n  let ids = vec4<u32>(constraints[at], constraints[at + 1u], constraints[at + 2u], constraints[at + 3u]);\n  let w = vec4<f32>(inverseMass(ids.x), inverseMass(ids.y), inverseMass(ids.z), inverseMass(ids.w));\n  if (w.x + w.y + w.z + w.w == 0.0) {\n    return;\n  }\n  let origin = load(stateAt(POSITION, ids.x));\n  let e = load(stateAt(POSITION, ids.y)) - origin;\n  let p3 = load(stateAt(POSITION, ids.z)) - origin;\n  let p4 = load(stateAt(POSITION, ids.w)) - origin;\n  var n1 = cross(e, p3);\n  var n2 = cross(e, p4);\n  let l1 = sqrt(dot(n1, n1));\n  let l2 = sqrt(dot(n2, n2));\n  if (l1 < 1e-12 || l2 < 1e-12) {\n    return;\n  }\n  n1 = n1 / l1;\n  n2 = n2 / l2;\n  let d = clamp(dot(n1, n2), -1.0, 1.0);\n  let sine = sqrt(dot(cross(n1, n2), cross(n1, n2)));\n  if (sine < 1e-6) {\n    return;\n  }\n  /* The q vectors: the negative of the derivative of n1 \u00B7 n2. See solveBendingBatch. */\n  let q3 = (cross(e, n2) + cross(n1, e) * d) / l1;\n  let q4 = (cross(e, n1) + cross(n2, e) * d) / l2;\n  let q2 = -((cross(p3, n2) + cross(n1, p3) * d) / l1 + (cross(p4, n1) + cross(n2, p4) * d) / l2);\n  let q1 = -(q2 + q3 + q4);\n  var sum = w.x * dot(q1, q1) + w.y * dot(q2, q2) + w.z * dot(q3, q3) + w.w * dot(q4, q4);\n  sum = sum / (sine * sine);\n  if (sum < 1e-12) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[at + 5u]) * c.invH2;\n  let old = lambda[slot];\n  let angle = atan2(sine, d);\n  let delta = (-(angle - bitcast<f32>(constraints[at + 4u])) - alpha * old) / (sum + alpha);\n  lambda[slot] = old + delta;\n  let scale = delta / sine;\n  if (w.x > 0.0) {\n    let p = stateAt(POSITION, ids.x);\n    store(p, load(p) + w.x * scale * q1);\n  }\n  if (w.y > 0.0) {\n    let p = stateAt(POSITION, ids.y);\n    store(p, load(p) + w.y * scale * q2);\n  }\n  if (w.z > 0.0) {\n    let p = stateAt(POSITION, ids.z);\n    store(p, load(p) + w.z * scale * q3);\n  }\n  if (w.w > 0.0) {\n    let p = stateAt(POSITION, ids.w);\n    store(p, load(p) + w.w * scale * q4);\n  }\n}\n\n/* solveTethers, one invocation a tether of the batch: a batch holds a particle once. */\n@compute @workgroup_size(64)\nfn clothTether(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + c.bendings * 6u + k * 3u;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  let pAt = stateAt(POSITION, constraints[at]);\n  let anchor = load(stateAt(POSITION, constraints[at + 1u]));\n  let d = load(pAt) - anchor;\n  let dist = sqrt(dot(d, d));\n  let reach = bitcast<f32>(constraints[at + 2u]);\n  if (dist <= reach || dist < 1e-9) {\n    return;\n  }\n  store(pAt, anchor + d * (reach / dist));\n}\n\n/* pushOut: the point onto the sphere's surface if it is inside. A point at the centre stays. */\nfn pushOut(p: vec3<f32>, centre: vec3<f32>, radius: f32) -> vec3<f32> {\n  let d = p - centre;\n  let d2 = dot(d, d);\n  if (d2 >= radius * radius || d2 < 1e-18) {\n    return p;\n  }\n  return centre + d * (radius / sqrt(d2));\n}\n\n/* applyPull, applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */\n@compute @workgroup_size(64)\nfn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count || inverseMass(i) == 0.0) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let limits = paces[g].limits;\n  let n = c.count;\n  let at = stateAt(POSITION, i);\n  var p = load(at);\n  let t = skinnedAt(i, g);\n  /* Only where there is a pull, as on the CPU: t + (p - t) is not p in floats. */\n  if (paces[g].pullKeep < 1.0) {\n    p = t + (p - t) * paces[g].pullKeep;\n  }\n  /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */\n  let maxDistance = statics[n + i];\n  if ((limits & 1u) != 0u && maxDistance >= 0.0) {\n    let limit = maxDistance * paces[g].maxDistanceScale;\n    let d = p - t;\n    let d2 = dot(d, d);\n    if (d2 > limit * limit) {\n      p = t + d * (limit / sqrt(d2));\n    }\n  }\n  let normal = poseOf(6u * n + i * 3u);\n  if ((limits & 2u) != 0u) {\n    let radius = statics[2u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t - normal * (statics[2u * n + i * 2u] + radius), radius);\n    }\n  }\n  if ((limits & 4u) != 0u) {\n    let radius = statics[4u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t + normal * (statics[4u * n + i * 2u] + radius), radius);\n    }\n  }\n  let pad = statics[6u * n + i] + paces[g].margin;\n  let ends = c.joints * 16u;\n  let radii = ends + c.colliders * 6u;\n  let first = paces[g].colliderBase;\n  for (var k = first; k < first + paces[g].colliders; k++) {\n    let a = vec3<f32>(frame[ends + k * 6u], frame[ends + k * 6u + 1u], frame[ends + k * 6u + 2u]);\n    let e = vec3<f32>(frame[ends + k * 6u + 3u], frame[ends + k * 6u + 4u], frame[ends + k * 6u + 5u]) - a;\n    let e2 = dot(e, e);\n    var s = 0.0;\n    if (e2 > 1e-18) {\n      s = clamp(dot(p - a, e) / e2, 0.0, 1.0);\n    }\n    let r0 = frame[radii + k * 2u];\n    let r1 = frame[radii + k * 2u + 1u];\n    p = pushOut(p, a + e * s, r0 + (r1 - r0) * s + pad);\n  }\n  store(at, p);\n}\n\n/* finishParticles. */\n@compute @workgroup_size(64)\nfn clothFinish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  if (paces[paceAt(i)].live == 0u) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  if (inverseMass(i) == 0.0) {\n    store(vAt, vec3<f32>(0.0));\n    return;\n  }\n  store(vAt, (load(stateAt(POSITION, i)) - load(stateAt(PREVIOUS, i))) * c.invH);\n}\n\n/* SkinnedCloth.blend: after a reset, the simulation's share grows over the blend's steps. */\n@compute @workgroup_size(64)\nfn clothBlend(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  /* A blend of 0 is none, not a last step of one: see ClothDevice.step. */\n  let g = paceAt(i);\n  let blend = paces[g].blend;\n  if (paces[g].live == 0u || blend <= 0.0) {\n    return;\n  }\n  let t = skinnedAt(i, g);\n  let at = stateAt(POSITION, i);\n  store(at, t + (load(at) - t) * blend);\n  let vAt = stateAt(VELOCITY, i);\n  store(vAt, load(vAt) * blend);\n}\n\n@group(1) @binding(0) var output: texture_storage_2d<rgba32float, write>;\n\n/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads: one garment's, whose\n   particles are batch.begin to batch.end and whose record is batch.first's. */\n@compute @workgroup_size(64)\nfn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = batch.begin + id.x;\n  if (i >= batch.end) {\n    return;\n  }\n  let g = round.at + batch.first;\n  let a = load(stateAt(START, i));\n  let p = a + (load(stateAt(POSITION, i)) - a) * paces[g].alpha;\n  let local = id.x;\n  let width = paces[g].width;\n  textureStore(output, vec2<u32>(local % width, local / width), vec4<f32>(p, 0.0));\n}\n";

package/dist/render/backend/webgpu/shaders/clothSolve.wgsl.js

@@ -87,7 +87,8 @@ struct Pace {
   colliderBase: u32,
   colliders: u32,
   width: u32,
-  pad0: u32,
+  /* The share of its offset from its skinned position a particle keeps a substep: the pull's. */
+  pullKeep: f32,
   keep: f32,
   dragKeep: f32,
   maxDistanceScale: f32,
@@ -427,7 +428,7 @@ fn pushOut(p: vec3<f32>, centre: vec3<f32>, radius: f32) -> vec3<f32> {
   return centre + d * (radius / sqrt(d2));
 }
 
-/* applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */
+/* applyPull, applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */
 @compute @workgroup_size(64)
 fn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {
   let i = id.x;
@@ -443,6 +444,10 @@ fn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {
   let at = stateAt(POSITION, i);
   var p = load(at);
   let t = skinnedAt(i, g);
+  /* Only where there is a pull, as on the CPU: t + (p - t) is not p in floats. */
+  if (paces[g].pullKeep < 1.0) {
+    p = t + (p - t) * paces[g].pullKeep;
+  }
   /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */
   let maxDistance = statics[n + i];
   if ((limits & 1u) != 0u && maxDistance >= 0.0) {

package/dist/render/backend/webgpu/shaders/pointSkin.wgsl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A point skin posed on the device, in WGSL, hand-authored under the compute exception `AGENTS.md`
+ * records (2026-08-24): a compute shader has no WebGL2 twin to generate from, and `npm run wgsl`
+ * neither writes nor polices this file. WebGL2 poses the same skin by transform feedback, in
+ * `backend/webgl2/pointSkinFeedback.ts`, by the same arithmetic in the same order.
+ *
+ * One invocation a vertex: its position the sum of each weighted point moved by its joint, an
+ * influence of weight 0 skipped, and its normal the first joint's turn of the normal it was given,
+ * made unit length where it has any. Written into the mesh's own position and normal buffers, three
+ * floats a vertex, which every pass then draws as it draws any dynamic mesh.
+ */
+export declare const POINT_SKIN_WORKGROUP = 64;
+export declare const POINT_SKIN_WGSL = "\nstruct Params {\n  count: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> joints: array<mat4x4<f32>>;\n@group(0) @binding(2) var<storage, read> points: array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read> named: array<vec4<u32>>;\n@group(0) @binding(4) var<storage, read> normals: array<vec4<f32>>;\n@group(0) @binding(5) var<storage, read_write> posedPositions: array<f32>;\n@group(0) @binding(6) var<storage, read_write> posedNormals: array<f32>;\n\n@compute @workgroup_size(64)\nfn posePoints(@builtin(global_invocation_id) id: vec3<u32>) {\n  let v = id.x;\n  if (v >= params.count) {\n    return;\n  }\n  let j = named[v];\n  var p = vec3<f32>(0.0, 0.0, 0.0);\n  for (var k = 0u; k < 4u; k = k + 1u) {\n    let q = points[v * 4u + k];\n    if (q.w != 0.0) {\n      p = p + q.w * (joints[j[k]] * vec4<f32>(q.xyz, 1.0)).xyz;\n    }\n  }\n  let m = joints[j.x];\n  let raw = mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * normals[v].xyz;\n  let l = length(raw);\n  var n = raw;\n  if (l > 0.0) {\n    n = raw / l;\n  }\n  posedPositions[v * 3u] = p.x;\n  posedPositions[v * 3u + 1u] = p.y;\n  posedPositions[v * 3u + 2u] = p.z;\n  posedNormals[v * 3u] = n.x;\n  posedNormals[v * 3u + 1u] = n.y;\n  posedNormals[v * 3u + 2u] = n.z;\n}\n";

package/dist/render/backend/webgpu/shaders/pointSkin.wgsl.js

@@ -0,0 +1,57 @@
+/**
+ * A point skin posed on the device, in WGSL, hand-authored under the compute exception `AGENTS.md`
+ * records (2026-08-24): a compute shader has no WebGL2 twin to generate from, and `npm run wgsl`
+ * neither writes nor polices this file. WebGL2 poses the same skin by transform feedback, in
+ * `backend/webgl2/pointSkinFeedback.ts`, by the same arithmetic in the same order.
+ *
+ * One invocation a vertex: its position the sum of each weighted point moved by its joint, an
+ * influence of weight 0 skipped, and its normal the first joint's turn of the normal it was given,
+ * made unit length where it has any. Written into the mesh's own position and normal buffers, three
+ * floats a vertex, which every pass then draws as it draws any dynamic mesh.
+ */
+export const POINT_SKIN_WORKGROUP = 64;
+export const POINT_SKIN_WGSL = /* wgsl */ `
+struct Params {
+  count: u32,
+  pad0: u32,
+  pad1: u32,
+  pad2: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> joints: array<mat4x4<f32>>;
+@group(0) @binding(2) var<storage, read> points: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read> named: array<vec4<u32>>;
+@group(0) @binding(4) var<storage, read> normals: array<vec4<f32>>;
+@group(0) @binding(5) var<storage, read_write> posedPositions: array<f32>;
+@group(0) @binding(6) var<storage, read_write> posedNormals: array<f32>;
+
+@compute @workgroup_size(${POINT_SKIN_WORKGROUP})
+fn posePoints(@builtin(global_invocation_id) id: vec3<u32>) {
+  let v = id.x;
+  if (v >= params.count) {
+    return;
+  }
+  let j = named[v];
+  var p = vec3<f32>(0.0, 0.0, 0.0);
+  for (var k = 0u; k < 4u; k = k + 1u) {
+    let q = points[v * 4u + k];
+    if (q.w != 0.0) {
+      p = p + q.w * (joints[j[k]] * vec4<f32>(q.xyz, 1.0)).xyz;
+    }
+  }
+  let m = joints[j.x];
+  let raw = mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * normals[v].xyz;
+  let l = length(raw);
+  var n = raw;
+  if (l > 0.0) {
+    n = raw / l;
+  }
+  posedPositions[v * 3u] = p.x;
+  posedPositions[v * 3u + 1u] = p.y;
+  posedPositions[v * 3u + 2u] = p.z;
+  posedNormals[v * 3u] = n.x;
+  posedNormals[v * 3u + 1u] = n.y;
+  posedNormals[v * 3u + 2u] = n.z;
+}
+`;

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

@@ -10,7 +10,7 @@ import { PACKED_ATTRIBUTES, toFixed16, } from '../../vertexPacking.js';
  * which reads three. Every field stays a whole number of four-byte words, so a vertex does too.
  */
 /** The ways an attribute can travel other than as floats, as the key words name them. */
-const PACKINGS = ['snorm16', 'unorm16', 'constant'];
+const PACKINGS = ['snorm16', 'unorm16', 'constant', 'stream'];
 /** The pipeline key's word for one attribute's packing. Not a prefix of any other word. */
 function word(name, packing) {
     return `${name}~${packing}`;

package/dist/render/lightBudget.d.ts

@@ -253,6 +253,12 @@ export declare const PARTICLE_DEPTH_UNIT: number;
 export declare const BONE_PLACES_TEXTURE_UNIT: number;
 export declare const BONE_TURNS_TEXTURE_UNIT: number;
 export declare const INSTANCE_CLOCKS_TEXTURE_UNIT: number;
+/**
+ * A point skin's joints (`pointSkin.ts`), read by the transform-feedback program that poses it. Past
+ * every unit a draw binds, so a pose taken between two draws leaves nothing a draw expects to find.
+ * Twenty-nine.
+ */
+export declare const POINT_SKIN_TEXTURE_UNIT: number;
 /**
  * A cookie's tile, in texels a side.
  *

package/dist/render/lightBudget.js

@@ -254,6 +254,12 @@ export const PARTICLE_DEPTH_UNIT = PARTICLE_SPRITE_UNIT + 1;
 export const BONE_PLACES_TEXTURE_UNIT = PARTICLE_DEPTH_UNIT + 1;
 export const BONE_TURNS_TEXTURE_UNIT = BONE_PLACES_TEXTURE_UNIT + 1;
 export const INSTANCE_CLOCKS_TEXTURE_UNIT = BONE_TURNS_TEXTURE_UNIT + 1;
+/**
+ * A point skin's joints (`pointSkin.ts`), read by the transform-feedback program that poses it. Past
+ * every unit a draw binds, so a pose taken between two draws leaves nothing a draw expects to find.
+ * Twenty-nine.
+ */
+export const POINT_SKIN_TEXTURE_UNIT = INSTANCE_CLOCKS_TEXTURE_UNIT + 1;
 /**
  * A cookie's tile, in texels a side.
  *

package/dist/render/mesh.d.ts

@@ -17,6 +17,13 @@ export declare class Mesh {
      * this — two references, and only where a consumer asked.
      */
     private readonly deformable;
+    /** A dynamic mesh's position and normal buffers, for a pose written on the device; else null. */
+    get streams(): {
+        readonly positions: WebGLBuffer;
+        readonly normals: WebGLBuffer;
+    } | null;
+    /** The colour buffer, kept so `updateColors` can rewrite it. Null unless `dynamicColors`. */
+    private readonly recolourable;
     /** How many floats the position buffer holds, so an update of the wrong size is refused. */
     private readonly positionFloats;
     /**
@@ -114,8 +121,9 @@ export declare class Mesh {
      * and the default is the fast path: filling a buffer with `bufferData` in one call skips the
      * zero-fill that `bufferData(size)` then `bufferSubData` pays for, and every mesh in the
      * engine that does not need to be spread should keep skipping it.
+     * @param dynamicColors Colours as floats in a buffer kept for `updateColors`.
      */
-    constructor(gl: WebGL2RenderingContext, data: MeshData, dynamic?: boolean, spread?: boolean);
+    constructor(gl: WebGL2RenderingContext, data: MeshData, dynamic?: boolean, spread?: boolean, dynamicColors?: boolean);
     /** Caller is responsible for having the flat program + uniforms bound. */
     draw(gl: WebGL2RenderingContext): void;
     /**
@@ -135,15 +143,21 @@ export declare class Mesh {
     /**
      * Rewrite this mesh's positions, and its normals where the caller has them.
      *
-     * **Only the two attributes that move.** Colour, emissive and the rest describe what a surface
-     * *is* and do not change because it bent; rewriting them would be uploading unchanged bytes
-     * every frame. A caller with genuinely changing colour wants a second mesh or a tint.
+     * **Only the two attributes that move.** Emissive and the rest describe what a surface *is* and
+     * do not change because it bent; rewriting them would be uploading unchanged bytes every frame.
+     * A caller whose colours change has `updateColors`, on a mesh made `dynamicColors`.
      *
      * **The bounds are recomputed**, because everything that decides whether this is on screen
      * starts from them — a cloth that blew sideways out of its original box would be culled while
      * still visible, which is the kind of bug that only shows up at the edge of the frame.
      */
     update(gl: WebGL2RenderingContext, positions: Float32Array, normals?: Float32Array): void;
+    /**
+     * Rewrite this mesh's colours, three floats a vertex, into the buffer they have to themselves.
+     *
+     * Nothing else moves, the bounds included: a colour does not change where a vertex is.
+     */
+    updateColors(gl: WebGL2RenderingContext, colors: Float32Array): void;
     /**
      * One attribute's buffer, as floats or in its sixteen-bit fixed point (`vertexPacking.ts`), which
      * WebGL2 reads back through a normalised `SHORT` or `UNSIGNED_SHORT`: three lanes wide where
@@ -198,6 +212,6 @@ export interface IncrementalMesh {
  * the allocations. The bounds are the deliberate one — a streamer places and culls a region from
  * them before a byte of it has landed.
  */
-export declare function createMeshIncremental(gl: WebGL2RenderingContext, data: MeshData, dynamic?: boolean): IncrementalMesh;
+export declare function createMeshIncremental(gl: WebGL2RenderingContext, data: MeshData, dynamic?: boolean, dynamicColors?: boolean): IncrementalMesh;
 /** Texture coordinates and layers interleaved as (u, v, layer), one row a vertex. */
 export declare function packUvLayers(uvs: Float32Array, layers: Float32Array): Float32Array;

package/dist/render/mesh.js

@@ -92,6 +92,12 @@ export class Mesh {
      * this — two references, and only where a consumer asked.
      */
     deformable = null;
+    /** A dynamic mesh's position and normal buffers, for a pose written on the device; else null. */
+    get streams() {
+        return this.deformable;
+    }
+    /** The colour buffer, kept so `updateColors` can rewrite it. Null unless `dynamicColors`. */
+    recolourable = null;
     /** How many floats the position buffer holds, so an update of the wrong size is refused. */
     positionFloats;
     /**
@@ -191,8 +197,9 @@ export class Mesh {
      * and the default is the fast path: filling a buffer with `bufferData` in one call skips the
      * zero-fill that `bufferData(size)` then `bufferSubData` pays for, and every mesh in the
      * engine that does not need to be spread should keep skipping it.
+     * @param dynamicColors Colours as floats in a buffer kept for `updateColors`.
      */
-    constructor(gl, data, dynamic = false, spread = false) {
+    constructor(gl, data, dynamic = false, spread = false, dynamicColors = false) {
         validateMeshData(data);
         this.spread = spread;
         this.hasUvs = data.uvs !== undefined;
@@ -212,12 +219,17 @@ export class Mesh {
          */
         const usage = dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW;
         /* How each attribute travels: sixteen-bit fixed point, or one value as a constant. */
-        const packing = vertexPackingOf(data, dynamic);
+        const packing = vertexPackingOf(data, dynamic, dynamicColors);
         const positions = this.attachAttribute(gl, ATTR_POSITION, data.positions, 3, usage);
         const normals = this.attachAttribute(gl, ATTR_NORMAL, data.normals, 3, usage, packing.normals);
         if (dynamic)
             this.deformable = { positions, normals };
-        this.attachShared(gl, ATTR_COLOR, data.colors, 3, packing.colors);
+        if (packing.colors === 'stream') {
+            this.recolourable = this.attachAttribute(gl, ATTR_COLOR, data.colors, 3, gl.DYNAMIC_DRAW);
+        }
+        else {
+            this.attachShared(gl, ATTR_COLOR, data.colors, 3, packing.colors);
+        }
         this.attachShared(gl, ATTR_EMISSIVE, data.emissive, 1, packing.emissive);
         /*
          * Absent means "not shiny", supplied as a constant rather than as a buffer of
@@ -418,9 +430,9 @@ export class Mesh {
     /**
      * Rewrite this mesh's positions, and its normals where the caller has them.
      *
-     * **Only the two attributes that move.** Colour, emissive and the rest describe what a surface
-     * *is* and do not change because it bent; rewriting them would be uploading unchanged bytes
-     * every frame. A caller with genuinely changing colour wants a second mesh or a tint.
+     * **Only the two attributes that move.** Emissive and the rest describe what a surface *is* and
+     * do not change because it bent; rewriting them would be uploading unchanged bytes every frame.
+     * A caller whose colours change has `updateColors`, on a mesh made `dynamicColors`.
      *
      * **The bounds are recomputed**, because everything that decides whether this is on screen
      * starts from them — a cloth that blew sideways out of its original box would be culled while
@@ -445,6 +457,25 @@ export class Mesh {
             gl.bufferSubData(gl.ARRAY_BUFFER, 0, normals);
         }
     }
+    /**
+     * Rewrite this mesh's colours, three floats a vertex, into the buffer they have to themselves.
+     *
+     * Nothing else moves, the bounds included: a colour does not change where a vertex is.
+     */
+    updateColors(gl, colors) {
+        if (this.recolourable === null) {
+            throw new Error('this mesh was not created with { dynamicColors: true }, so its colours are packed or are ' +
+                'one value with no buffer at all, and cannot be rewritten. Say so at `createMesh`: the ' +
+                'flag gives the colours a buffer of their own.');
+        }
+        if (colors.length !== this.positionFloats) {
+            throw new Error(`this mesh has ${this.positionFloats / 3} vertices and the colours have ` +
+                `${colors.length / 3}. A mesh's vertex count is fixed at creation: the index buffer, ` +
+                'the pipeline and every other attribute are sized against it.');
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.recolourable);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, colors);
+    }
     /**
      * One attribute's buffer, as floats or in its sixteen-bit fixed point (`vertexPacking.ts`), which
      * WebGL2 reads back through a normalised `SHORT` or `UNSIGNED_SHORT`: three lanes wide where
@@ -537,8 +568,8 @@ export class Mesh {
  * the allocations. The bounds are the deliberate one — a streamer places and culls a region from
  * them before a byte of it has landed.
  */
-export function createMeshIncremental(gl, data, dynamic = false) {
-    const mesh = new Mesh(gl, data, dynamic, true);
+export function createMeshIncremental(gl, data, dynamic = false, dynamicColors = false) {
+    const mesh = new Mesh(gl, data, dynamic, true, dynamicColors);
     return { mesh, upload: mesh.uploads(gl) };
 }
 /** Texture coordinates and layers interleaved as (u, v, layer), one row a vertex. */