@driftengine/core 4.10.0 → 4.11.0

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

@@ -7,7 +7,7 @@
  * each kernel there is an entry point here, one invocation a particle or a constraint, and the loop
  * over a batch is the dispatch. `clothPose.ts`' `skinParticles` is `pose`. The order of a step —
  * begin, then per substep predict, the batches, the limits, finish; then the blend — is
- * `gpuSkinnedCloth.ts`', taken from the same `ClothControl` the CPU solver is driven by.
+ * `gpuClothSet.ts`', taken from the same `ClothControl` the CPU solver is driven by.
  *
  * **Where it differs, it says so.** Single precision throughout, where the CPU rounds to single
  * only on a store. And the bending angle is `atan2(|n1 × n2|, n1 · n2)` rather than `acos(n1 · n2)`
@@ -28,6 +28,13 @@
  * start; `pose` the two skinned poses a step interpolates between and the latest skinned normals;
  * `statics` everything per particle that never changes. A section's offset is a multiple of the
  * particle count, which the constants carry — so no offset is a uniform to keep in step.
+ *
+ * **One dispatch serves every garment of a set** (`clothSetPack.ts`): the particles, constraints,
+ * joints and colliders of all of them in those buffers, and each garment's numbers — its step's
+ * fraction and blend, its damping, gravity and limits — a record of its own in `paces`, at the
+ * round's place. A kernel finds its garment from the particle, and returns at once where that
+ * garment has nothing to do this round: a garment that took fewer steps, or one settling alone after
+ * 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 = "\nstruct Constants {\n  count: u32,\n  distances: u32,\n  bendings: u32,\n  joints: u32,\n  colliders: u32,\n  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the set-up has at all. */\n  limits: u32,\n  width: u32,\n  pad0: u32,\n  h: f32,\n  invH: f32,\n  invH2: f32,\n  keep: f32,\n  dragKeep: f32,\n  maxDistanceScale: f32,\n  margin: f32,\n  pad1: f32,\n  gravity: vec4<f32>,\n}\n\n/* One step's numbers, at a dynamic offset: every step of a frame has its own slot. */\nstruct Step {\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  pad0: u32,\n  pad1: 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}\n\n/* One batch of one kind of constraint, at a dynamic offset; first resets the multipliers. */\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> pace: Step;\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\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) -> vec3<f32> {\n  let a = poseOf(pace.fromAt + i * 3u);\n  let b = poseOf(pace.toAt + i * 3u);\n  return a + (b - a) * pace.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 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 = pace.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 p = poseOf(pace.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 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));\n    return;\n  }\n  if (pace.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>(pace.turn0.xyz, pace.turn1.xyz, pace.turn2.xyz);\n  let share = pace.origin.w;\n  let x = p - pace.origin.xyz;\n  store(at, p + (turn * x - x) * share + pace.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 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 = pace.wind.xyz;\n  let v = air + (load(vAt) * c.keep - air) * c.dragKeep + c.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  /* 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 a = constraints[k * 4u];\n  let b = constraints[k * 4u + 1u];\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 (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  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 n = c.count;\n  let at = stateAt(POSITION, i);\n  var p = load(at);\n  let t = skinnedAt(i);\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 ((c.limits & 1u) != 0u && maxDistance >= 0.0) {\n    let limit = maxDistance * c.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 ((c.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 ((c.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] + c.margin;\n  let ends = c.joints * 16u;\n  let radii = ends + c.colliders * 6u;\n  for (var k = 0u; k < c.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  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  let t = skinnedAt(i);\n  let at = stateAt(POSITION, i);\n  store(at, t + (load(at) - t) * pace.blend);\n  let vAt = stateAt(VELOCITY, i);\n  store(vAt, load(vAt) * pace.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. */\n@compute @workgroup_size(64)\nfn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let a = load(stateAt(START, i));\n  let p = a + (load(stateAt(POSITION, i)) - a) * pace.alpha;\n  textureStore(output, vec2<u32>(i % c.width, i / c.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  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";

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

@@ -7,7 +7,7 @@
  * each kernel there is an entry point here, one invocation a particle or a constraint, and the loop
  * over a batch is the dispatch. `clothPose.ts`' `skinParticles` is `pose`. The order of a step —
  * begin, then per substep predict, the batches, the limits, finish; then the blend — is
- * `gpuSkinnedCloth.ts`', taken from the same `ClothControl` the CPU solver is driven by.
+ * `gpuClothSet.ts`', taken from the same `ClothControl` the CPU solver is driven by.
  *
  * **Where it differs, it says so.** Single precision throughout, where the CPU rounds to single
  * only on a store. And the bending angle is `atan2(|n1 × n2|, n1 · n2)` rather than `acos(n1 · n2)`
@@ -28,32 +28,43 @@
  * start; `pose` the two skinned poses a step interpolates between and the latest skinned normals;
  * `statics` everything per particle that never changes. A section's offset is a multiple of the
  * particle count, which the constants carry — so no offset is a uniform to keep in step.
+ *
+ * **One dispatch serves every garment of a set** (`clothSetPack.ts`): the particles, constraints,
+ * joints and colliders of all of them in those buffers, and each garment's numbers — its step's
+ * fraction and blend, its damping, gravity and limits — a record of its own in `paces`, at the
+ * round's place. A kernel finds its garment from the particle, and returns at once where that
+ * garment has nothing to do this round: a garment that took fewer steps, or one settling alone after
+ * a reset, sits the round out while the rest of the set runs it.
  */
 export const CLOTH_WORKGROUP = 64;
 export const CLOTH_SOLVE_WGSL = /* wgsl */ `
+/* The set's: every garment's particles, records, skin matrices and colliders, and the step length
+   they all share. */
 struct Constants {
   count: u32,
   distances: u32,
   bendings: u32,
   joints: u32,
   colliders: u32,
-  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the set-up has at all. */
-  limits: u32,
-  width: u32,
   pad0: u32,
+  pad1: u32,
+  pad2: u32,
   h: f32,
   invH: f32,
   invH2: f32,
-  keep: f32,
-  dragKeep: f32,
-  maxDistanceScale: f32,
-  margin: f32,
-  pad1: f32,
-  gravity: vec4<f32>,
+  pad3: f32,
+}
+
+/* Where this dispatch's round of records starts in paces, at a dynamic offset. */
+struct Round {
+  at: u32,
+  pad0: u32,
+  pad1: u32,
+  pad2: u32,
 }
 
-/* One step's numbers, at a dynamic offset: every step of a frame has its own slot. */
-struct Step {
+/* One garment's numbers for one round: its step's, and its own that never change. */
+struct Pace {
   fraction: f32,
   blend: f32,
   alpha: f32,
@@ -61,8 +72,10 @@ struct Step {
   /* Where the pose a step starts from and the one it moves toward sit in pose, in floats. */
   fromAt: u32,
   toAt: u32,
-  pad0: u32,
-  pad1: u32,
+  /* 0 where the garment sits this round out. Not active, which WGSL reserves. */
+  live: u32,
+  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the garment has at all. */
+  limits: u32,
   /* The character's turn since the last step, by columns; origin.w is the share carried. */
   turn0: vec4<f32>,
   turn1: vec4<f32>,
@@ -71,9 +84,19 @@ struct Step {
   shift: vec4<f32>,
   /* The frame's wind: one wind, sampled once a frame, so a step's rather than the set-up's. */
   wind: vec4<f32>,
+  colliderBase: u32,
+  colliders: u32,
+  width: u32,
+  pad0: u32,
+  keep: f32,
+  dragKeep: f32,
+  maxDistanceScale: f32,
+  margin: f32,
+  gravity: vec4<f32>,
 }
 
-/* One batch of one kind of constraint, at a dynamic offset; first resets the multipliers. */
+/* One colour of one kind of constraint across the set, at a dynamic offset; first resets the
+   multipliers. Publishing reads one garment's particles as begin to end, and first is the garment. */
 struct Batch {
   begin: u32,
   end: u32,
@@ -82,7 +105,7 @@ struct Batch {
 }
 
 @group(0) @binding(0) var<uniform> c: Constants;
-@group(0) @binding(1) var<uniform> pace: Step;
+@group(0) @binding(1) var<uniform> round: Round;
 @group(0) @binding(2) var<uniform> batch: Batch;
 @group(0) @binding(3) var<storage, read_write> state: array<f32>;
 @group(0) @binding(4) var<storage, read_write> pose: array<f32>;
@@ -90,6 +113,12 @@ struct Batch {
 @group(0) @binding(6) var<storage, read> constraints: array<u32>;
 @group(0) @binding(7) var<storage, read_write> lambda: array<f32>;
 @group(0) @binding(8) var<storage, read> frame: array<f32>;
+@group(0) @binding(9) var<storage, read> paces: array<Pace>;
+
+/* The record of particle i's garment this round: which garment a particle is, in statics. */
+fn paceAt(i: u32) -> u32 {
+  return round.at + u32(statics[29u * c.count + i]);
+}
 
 fn stateAt(section: u32, i: u32) -> u32 {
   return section * 3u * c.count + i * 3u;
@@ -120,10 +149,10 @@ fn inverseMass(i: u32) -> f32 {
 }
 
 /* Where skinning puts particle i, fraction of the way from the last pose to the latest. */
-fn skinnedAt(i: u32) -> vec3<f32> {
-  let a = poseOf(pace.fromAt + i * 3u);
-  let b = poseOf(pace.toAt + i * 3u);
-  return a + (b - a) * pace.fraction;
+fn skinnedAt(i: u32, g: u32) -> vec3<f32> {
+  let a = poseOf(paces[g].fromAt + i * 3u);
+  let b = poseOf(paces[g].toAt + i * 3u);
+  return a + (b - a) * paces[g].fraction;
 }
 
 fn skinMatrix(j: u32) -> mat4x4<f32> {
@@ -142,6 +171,10 @@ fn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
+  let g = paceAt(i);
+  if (paces[g].live == 0u) {
+    return;
+  }
   let n = c.count;
   let restAt = 7u * n + i * 3u;
   let normalAt = 10u * n + i * 3u;
@@ -161,7 +194,7 @@ fn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {
       q += w * (mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * q0);
     }
   }
-  let to = pace.toAt + i * 3u;
+  let to = paces[g].toAt + i * 3u;
   pose[to] = p.x;
   pose[to + 1u] = p.y;
   pose[to + 2u] = p.z;
@@ -180,7 +213,11 @@ fn clothRest(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
-  let p = poseOf(pace.toAt + i * 3u);
+  let g = paceAt(i);
+  if (paces[g].live == 0u) {
+    return;
+  }
+  let p = poseOf(paces[g].toAt + i * 3u);
   store(stateAt(POSITION, i), p);
   store(stateAt(START, i), p);
   store(stateAt(VELOCITY, i), vec3<f32>(0.0));
@@ -193,21 +230,25 @@ fn clothBegin(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
+  let g = paceAt(i);
+  if (paces[g].live == 0u) {
+    return;
+  }
   let at = stateAt(POSITION, i);
   let p = load(at);
   store(stateAt(START, i), p);
   if (inverseMass(i) == 0.0) {
-    store(at, skinnedAt(i));
+    store(at, skinnedAt(i, g));
     return;
   }
-  if (pace.carry == 0u) {
+  if (paces[g].carry == 0u) {
     return;
   }
   /* carryParticles: the share of the character's turn about its old origin, and of its move. */
-  let turn = mat3x3<f32>(pace.turn0.xyz, pace.turn1.xyz, pace.turn2.xyz);
-  let share = pace.origin.w;
-  let x = p - pace.origin.xyz;
-  store(at, p + (turn * x - x) * share + pace.shift.xyz);
+  let turn = mat3x3<f32>(paces[g].turn0.xyz, paces[g].turn1.xyz, paces[g].turn2.xyz);
+  let share = paces[g].origin.w;
+  let x = p - paces[g].origin.xyz;
+  store(at, p + (turn * x - x) * share + paces[g].shift.xyz);
   let vAt = stateAt(VELOCITY, i);
   let v = load(vAt);
   store(vAt, v + (turn * v - v) * share);
@@ -220,6 +261,10 @@ fn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
+  let g = paceAt(i);
+  if (paces[g].live == 0u) {
+    return;
+  }
   let at = stateAt(POSITION, i);
   let p = load(at);
   store(stateAt(PREVIOUS, i), p);
@@ -227,8 +272,8 @@ fn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {
     return;
   }
   let vAt = stateAt(VELOCITY, i);
-  let air = pace.wind.xyz;
-  let v = air + (load(vAt) * c.keep - air) * c.dragKeep + c.gravity.xyz * c.h;
+  let air = paces[g].wind.xyz;
+  let v = air + (load(vAt) * paces[g].keep - air) * paces[g].dragKeep + paces[g].gravity.xyz * c.h;
   store(vAt, v);
   store(at, p + v * c.h);
 }
@@ -240,13 +285,17 @@ fn clothDistance(@builtin(global_invocation_id) id: vec3<u32>) {
   if (k >= batch.end) {
     return;
   }
+  let a = constraints[k * 4u];
+  let b = constraints[k * 4u + 1u];
+  /* A garment sitting the round out solves nothing, and its next step's first pass resets. */
+  if (paces[paceAt(a)].live == 0u) {
+    return;
+  }
   /* The first pass of a substep starts the multiplier at nothing, as the CPU's fill(0) does —
      written before any early return, so a skipped constraint does not carry the last one. */
   if (batch.first == 1u) {
     lambda[k] = 0.0;
   }
-  let a = constraints[k * 4u];
-  let b = constraints[k * 4u + 1u];
   let wa = inverseMass(a);
   let wb = inverseMass(b);
   let w = wa + wb;
@@ -283,6 +332,9 @@ fn clothBending(@builtin(global_invocation_id) id: vec3<u32>) {
   }
   let at = c.distances * 4u + k * 6u;
   let slot = c.distances + k;
+  if (paces[paceAt(constraints[at])].live == 0u) {
+    return;
+  }
   if (batch.first == 1u) {
     lambda[slot] = 0.0;
   }
@@ -351,6 +403,9 @@ fn clothTether(@builtin(global_invocation_id) id: vec3<u32>) {
     return;
   }
   let at = c.distances * 4u + c.bendings * 6u + k * 3u;
+  if (paces[paceAt(constraints[at])].live == 0u) {
+    return;
+  }
   let pAt = stateAt(POSITION, constraints[at]);
   let anchor = load(stateAt(POSITION, constraints[at + 1u]));
   let d = load(pAt) - anchor;
@@ -379,14 +434,19 @@ fn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count || inverseMass(i) == 0.0) {
     return;
   }
+  let g = paceAt(i);
+  if (paces[g].live == 0u) {
+    return;
+  }
+  let limits = paces[g].limits;
   let n = c.count;
   let at = stateAt(POSITION, i);
   var p = load(at);
-  let t = skinnedAt(i);
+  let t = skinnedAt(i, g);
   /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */
   let maxDistance = statics[n + i];
-  if ((c.limits & 1u) != 0u && maxDistance >= 0.0) {
-    let limit = maxDistance * c.maxDistanceScale;
+  if ((limits & 1u) != 0u && maxDistance >= 0.0) {
+    let limit = maxDistance * paces[g].maxDistanceScale;
     let d = p - t;
     let d2 = dot(d, d);
     if (d2 > limit * limit) {
@@ -394,22 +454,23 @@ fn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {
     }
   }
   let normal = poseOf(6u * n + i * 3u);
-  if ((c.limits & 2u) != 0u) {
+  if ((limits & 2u) != 0u) {
     let radius = statics[2u * n + i * 2u + 1u];
     if (radius > 0.0) {
       p = pushOut(p, t - normal * (statics[2u * n + i * 2u] + radius), radius);
     }
   }
-  if ((c.limits & 4u) != 0u) {
+  if ((limits & 4u) != 0u) {
     let radius = statics[4u * n + i * 2u + 1u];
     if (radius > 0.0) {
       p = pushOut(p, t + normal * (statics[4u * n + i * 2u] + radius), radius);
     }
   }
-  let pad = statics[6u * n + i] + c.margin;
+  let pad = statics[6u * n + i] + paces[g].margin;
   let ends = c.joints * 16u;
   let radii = ends + c.colliders * 6u;
-  for (var k = 0u; k < c.colliders; k++) {
+  let first = paces[g].colliderBase;
+  for (var k = first; k < first + paces[g].colliders; k++) {
     let a = vec3<f32>(frame[ends + k * 6u], frame[ends + k * 6u + 1u], frame[ends + k * 6u + 2u]);
     let e = vec3<f32>(frame[ends + k * 6u + 3u], frame[ends + k * 6u + 4u], frame[ends + k * 6u + 5u]) - a;
     let e2 = dot(e, e);
@@ -431,6 +492,9 @@ fn clothFinish(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
+  if (paces[paceAt(i)].live == 0u) {
+    return;
+  }
   let vAt = stateAt(VELOCITY, i);
   if (inverseMass(i) == 0.0) {
     store(vAt, vec3<f32>(0.0));
@@ -446,24 +510,34 @@ fn clothBlend(@builtin(global_invocation_id) id: vec3<u32>) {
   if (i >= c.count) {
     return;
   }
-  let t = skinnedAt(i);
+  /* A blend of 0 is none, not a last step of one: see ClothDevice.step. */
+  let g = paceAt(i);
+  let blend = paces[g].blend;
+  if (paces[g].live == 0u || blend <= 0.0) {
+    return;
+  }
+  let t = skinnedAt(i, g);
   let at = stateAt(POSITION, i);
-  store(at, t + (load(at) - t) * pace.blend);
+  store(at, t + (load(at) - t) * blend);
   let vAt = stateAt(VELOCITY, i);
-  store(vAt, load(vAt) * pace.blend);
+  store(vAt, load(vAt) * blend);
 }
 
 @group(1) @binding(0) var output: texture_storage_2d<rgba32float, write>;
 
-/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads. */
+/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads: one garment's, whose
+   particles are batch.begin to batch.end and whose record is batch.first's. */
 @compute @workgroup_size(64)
 fn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {
-  let i = id.x;
-  if (i >= c.count) {
+  let i = batch.begin + id.x;
+  if (i >= batch.end) {
     return;
   }
+  let g = round.at + batch.first;
   let a = load(stateAt(START, i));
-  let p = a + (load(stateAt(POSITION, i)) - a) * pace.alpha;
-  textureStore(output, vec2<u32>(i % c.width, i / c.width), vec4<f32>(p, 0.0));
+  let p = a + (load(stateAt(POSITION, i)) - a) * paces[g].alpha;
+  let local = id.x;
+  let width = paces[g].width;
+  textureStore(output, vec2<u32>(local % width, local / width), vec4<f32>(p, 0.0));
 }
 `;

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

@@ -175,6 +175,7 @@ export function takeRecorded(pool) {
     command.offsetCount = 0;
     command.vertexCount = 0;
     command.indexBuffer = null;
+    command.indexFormat = 'uint32';
     command.indexed = false;
     command.instances = 1;
     command.indirect = null;
@@ -213,7 +214,7 @@ export function encodeBundle(device, target, pool, passOffset, viewOffset, label
                 encoder.setVertexBuffer(slot, buffer);
         }
         if (command.indexed && command.indexBuffer !== null) {
-            encoder.setIndexBuffer(command.indexBuffer, 'uint32');
+            encoder.setIndexBuffer(command.indexBuffer, command.indexFormat);
             if (command.indirect !== null)
                 encoder.drawIndexedIndirect(command.indirect, 0);
             else

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

@@ -0,0 +1,22 @@
+import { type AttributePacking, type VertexPacking } from '../../vertexPacking.ts';
+/** The key's suffix for this packing: one word each attribute not travelling as floats. */
+export declare function packingKey(packing: VertexPacking): string;
+/** Mark this packing in a pipeline's `present`, which is what `vertexBufferLayouts` reads. */
+export declare function markPacking(present: Record<string, boolean>, packing: VertexPacking): void;
+/** Mark the packing a mesh's key names, for a pass that has the mesh and not its data. */
+export declare function markPackingOfKey(present: Record<string, boolean>, key: string): void;
+/** How `present` says this attribute travels: floats unless a word says otherwise. */
+export declare function packingIn(present: Readonly<Record<string, boolean>>, name: string): AttributePacking;
+/** The format an attribute is read with, packed this way, or `float` as given. */
+export declare function packedFormat(float: GPUVertexFormat, packing: AttributePacking): GPUVertexFormat;
+/** Bytes a vertex spends on one attribute read with `format`. */
+export declare function formatBytes(format: GPUVertexFormat): number;
+/**
+ * One attribute of vertices `from` to `to` into its sixteen-bit field of the interleaved rows,
+ * `scale` being `SNORM16_ONE` or `UNORM16_ONE`. Rounded by `toFixed16`, as `fixedArray` rounds
+ * for the other backend; the range was checked when the packing was chosen.
+ *
+ * Unrolled by width, as `interleaveField` is and for its reason: the general loop was most of a
+ * heavy load's upload. Three and four are the widths a packed attribute has.
+ */
+export declare function interleaveFixed(rows: Int16Array | Uint16Array, source: Float32Array, width: number, step: number, fieldOffset: number, from: number, to: number, scale: number): void;

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

@@ -0,0 +1,97 @@
+import { PACKED_ATTRIBUTES, toFixed16, } from '../../vertexPacking.js';
+/**
+ * A mesh's packed attributes as a WebGPU vertex reads them: each one's format and bytes, the words
+ * a pipeline key carries for them, and the writers that put sixteen-bit fixed point into the
+ * interleaved rows. What is packed how is `vertexPacking.ts`'s decision; this is only its binding.
+ *
+ * **Sixteen-bit fields are four wide, never three**, because WebGPU has no three-component
+ * sixteen-bit format: a normal or a colour takes `x4` and leaves the fourth zero, and the shader's
+ * `vec3` input reads the first three. So a normal costs eight bytes here against six on WebGL2,
+ * 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'];
+/** The pipeline key's word for one attribute's packing. Not a prefix of any other word. */
+function word(name, packing) {
+    return `${name}~${packing}`;
+}
+/** The key's suffix for this packing: one word each attribute not travelling as floats. */
+export function packingKey(packing) {
+    let key = '';
+    for (const name of PACKED_ATTRIBUTES) {
+        if (packing[name] !== 'float')
+            key += `:${word(name, packing[name])}`;
+    }
+    return key;
+}
+/** Mark this packing in a pipeline's `present`, which is what `vertexBufferLayouts` reads. */
+export function markPacking(present, packing) {
+    for (const name of PACKED_ATTRIBUTES) {
+        if (packing[name] !== 'float')
+            present[word(name, packing[name])] = true;
+    }
+}
+/** Mark the packing a mesh's key names, for a pass that has the mesh and not its data. */
+export function markPackingOfKey(present, key) {
+    for (const name of PACKED_ATTRIBUTES) {
+        for (const packing of PACKINGS) {
+            if (key.includes(`:${word(name, packing)}`))
+                present[word(name, packing)] = true;
+        }
+    }
+}
+/** How `present` says this attribute travels: floats unless a word says otherwise. */
+export function packingIn(present, name) {
+    for (const packing of PACKINGS) {
+        if (present[word(name, packing)] === true)
+            return packing;
+    }
+    return 'float';
+}
+/** The format an attribute is read with, packed this way, or `float` as given. */
+export function packedFormat(float, packing) {
+    if (packing === 'snorm16')
+        return 'snorm16x4';
+    if (packing === 'unorm16')
+        return 'unorm16x4';
+    return float;
+}
+/** Bytes a vertex spends on one attribute read with `format`. */
+export function formatBytes(format) {
+    if (format === 'snorm16x4' || format === 'unorm16x4')
+        return 8;
+    if (format === 'float32x4')
+        return 16;
+    if (format === 'float32x3')
+        return 12;
+    if (format === 'float32x2')
+        return 8;
+    return 4;
+}
+/**
+ * One attribute of vertices `from` to `to` into its sixteen-bit field of the interleaved rows,
+ * `scale` being `SNORM16_ONE` or `UNORM16_ONE`. Rounded by `toFixed16`, as `fixedArray` rounds
+ * for the other backend; the range was checked when the packing was chosen.
+ *
+ * Unrolled by width, as `interleaveField` is and for its reason: the general loop was most of a
+ * heavy load's upload. Three and four are the widths a packed attribute has.
+ */
+export function interleaveFixed(rows, source, width, step, fieldOffset, from, to, scale) {
+    let write = from * step + fieldOffset;
+    const end = to * width;
+    if (width === 3) {
+        for (let read = from * 3; read < end; read += 3, write += step) {
+            rows[write] = toFixed16(source[read], scale);
+            rows[write + 1] = toFixed16(source[read + 1], scale);
+            rows[write + 2] = toFixed16(source[read + 2], scale);
+        }
+    }
+    else {
+        for (let read = from * 4; read < end; read += 4, write += step) {
+            rows[write] = toFixed16(source[read], scale);
+            rows[write + 1] = toFixed16(source[read + 1], scale);
+            rows[write + 2] = toFixed16(source[read + 2], scale);
+            rows[write + 3] = toFixed16(source[read + 3], scale);
+        }
+    }
+}

package/dist/render/globalMediumPass.d.ts

@@ -11,6 +11,8 @@ export interface MediumLight {
     readonly sunShadow: number;
     /** World → light clip, **uncorrected**: the shader does its own `* 0.5 + 0.5`. */
     readonly lightViewProj: ReadonlyMat4;
+    /** The same for the sun's moving layer, whose shadow pass may be drawn with its own. */
+    readonly movingLightViewProj: ReadonlyMat4;
     /** The sun's static, moving and peeled maps, as one array. See `shadowMap.ts`. */
     readonly sunShadows: WebGLTexture;
     readonly peeledEnabled: boolean;

package/dist/render/globalMediumPass.js

@@ -173,6 +173,7 @@ export class GlobalMediumPass {
         gl.uniform1i(u['uSteps'] ?? null, steps);
         gl.uniform1f(u['uSunShadow'] ?? null, light.sunShadow);
         gl.uniformMatrix4fv(u['uLightViewProj'] ?? null, false, light.lightViewProj);
+        gl.uniformMatrix4fv(u['uMovingLightViewProj'] ?? null, false, light.movingLightViewProj);
         gl.uniform1i(u['uPeeledShadowEnabled'] ?? null, light.peeledEnabled ? 1 : 0);
         gl.drawArrays(gl.TRIANGLES, 0, 3);
         gl.bindVertexArray(null);

package/dist/render/indexWidth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A mesh's indices in the narrowest type that holds them: sixteen bits where every vertex can be
+ * named in sixteen, thirty-two otherwise — half the index memory for every mesh of 65,536 vertices
+ * or fewer, which is most of them. Lossless because `validateMeshData` has already refused an
+ * index past the last vertex.
+ *
+ * **Padded to an even count**, so the sixteen-bit copy is a whole number of four-byte words: WebGPU
+ * writes a buffer only in whole words. The extra index is never drawn, since every draw counts the
+ * mesh's own indices. What would make this wrong is a draw that counts the buffer instead.
+ *
+ * **What it costs** is a copy of the indices while the mesh is built, let go once they are on the
+ * device; and every draw of the mesh has to say which width it holds, which is why the width
+ * travels with the mesh rather than being worked out where it is drawn.
+ */
+/** The most vertices sixteen-bit indices can name: every index below 65,536. */
+export declare const MAX_UINT16_VERTICES = 65536;
+export declare function compactIndices(indices: Uint32Array, vertexCount: number): Uint16Array | Uint32Array;

package/dist/render/indexWidth.js

@@ -0,0 +1,23 @@
+/**
+ * A mesh's indices in the narrowest type that holds them: sixteen bits where every vertex can be
+ * named in sixteen, thirty-two otherwise — half the index memory for every mesh of 65,536 vertices
+ * or fewer, which is most of them. Lossless because `validateMeshData` has already refused an
+ * index past the last vertex.
+ *
+ * **Padded to an even count**, so the sixteen-bit copy is a whole number of four-byte words: WebGPU
+ * writes a buffer only in whole words. The extra index is never drawn, since every draw counts the
+ * mesh's own indices. What would make this wrong is a draw that counts the buffer instead.
+ *
+ * **What it costs** is a copy of the indices while the mesh is built, let go once they are on the
+ * device; and every draw of the mesh has to say which width it holds, which is why the width
+ * travels with the mesh rather than being worked out where it is drawn.
+ */
+/** The most vertices sixteen-bit indices can name: every index below 65,536. */
+export const MAX_UINT16_VERTICES = 65536;
+export function compactIndices(indices, vertexCount) {
+    if (vertexCount > MAX_UINT16_VERTICES)
+        return indices;
+    const out = new Uint16Array(indices.length + (indices.length % 2));
+    out.set(indices);
+    return out;
+}