@driftengine/core 4.10.0 → 4.11.1

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

@@ -0,0 +1,144 @@
+/**
+ * Several garments' packs as one set of buffers, so that one dispatch solves a colour of one kind of
+ * constraint for every garment at once: `packCloth`'s sections laid end to end, and each kind's
+ * records regrouped so a colour of all of them is one range.
+ *
+ * **Why regrouping by colour keeps each garment's solve.** A batch is a set of constraints that share
+ * no movable particle, and two garments share no particle at all, so colour `b` of every garment is
+ * still such a set. Each garment's own colours still run in its own order, 0 then 1 then 2, so it is
+ * solved exactly as it would be alone: the CPU solver, which steps garments one at a time, is the
+ * reference for every one of them.
+ *
+ * **Every index a record or a static holds is the set's**: a particle is offset by where its garment
+ * starts, a joint by where its garment's skin matrices start. A section `packCloth` lays at `s · n`
+ * lies at `s · N` here, with a garment's particles at its base inside it, and one more section says
+ * which garment each particle is — what a kernel reads its garment's numbers by.
+ *
+ * **What it gives up**: a colour is dispatched over the most records any garment has in it, so a set
+ * of one garment of nine colours and fourteen of three runs nine colours' dispatches for all of them;
+ * and a garment joins a set when the set is made, so changing one rebuilds the set.
+ */
+import { CLOTH_STATIC_FLOATS } from './clothSolvePack.js';
+/** Floats of statics a particle in a set: a garment's own, and which garment it is. */
+export const CLOTH_SET_STATIC_FLOATS = CLOTH_STATIC_FLOATS + 1;
+/** `packCloth`'s sections: where each starts, in particle counts, and its floats a particle. */
+const SECTIONS = [
+    [0, 1],
+    [1, 1],
+    [2, 2],
+    [4, 2],
+    [6, 1],
+    [7, 3],
+    [10, 3],
+    [13, 16],
+];
+/** Where the influences start, and where the garment's index sits, in particle counts. */
+const INFLUENCES = 13;
+const GARMENT = CLOTH_STATIC_FLOATS;
+export function packClothSet(packs) {
+    const garments = [];
+    let count = 0;
+    let joints = 0;
+    let colliders = 0;
+    for (const pack of packs) {
+        garments.push({
+            particleBase: count,
+            count: pack.count,
+            jointBase: joints,
+            joints: pack.joints,
+            colliderBase: colliders,
+            colliders: pack.colliders,
+            limits: pack.limits,
+            rigged: pack.rigged,
+        });
+        count += pack.count;
+        joints += pack.joints;
+        colliders += pack.colliders;
+    }
+    const statics = new Float32Array(count * CLOTH_SET_STATIC_FLOATS);
+    packs.forEach((pack, g) => {
+        const { particleBase: base, count: n, jointBase } = garments[g];
+        for (const [start, stride] of SECTIONS) {
+            const from = pack.statics.subarray(start * n, (start + stride) * n);
+            statics.set(from, start * count + base * stride);
+        }
+        /* Each influence's joint, the set's: four joints, four weights, four joints, four weights. */
+        for (let i = 0; i < n; i++) {
+            const at = INFLUENCES * count + (base + i) * 16;
+            for (let k = 0; k < 4; k++) {
+                statics[at + k] = statics[at + k] + jointBase;
+                statics[at + 8 + k] = statics[at + 8 + k] + jointBase;
+            }
+        }
+        statics.fill(g, GARMENT * count + base, GARMENT * count + base + n);
+    });
+    const distances = sum(packs, (pack) => pack.distances);
+    const bendings = sum(packs, (pack) => pack.bendings);
+    const tethers = sum(packs, (pack) => pack.tethers);
+    const constraints = new Uint32Array(distances * 4 + bendings * 6 + tethers * 3);
+    /* Each kind: where its records start, a record's words, how many of them are particles. */
+    const distanceBatches = regroup(packs, garments, constraints, 0, 4, 2, 'distanceBatches');
+    const bendingStart = distances * 4;
+    const bendingBatches = regroup(packs, garments, constraints, bendingStart, 6, 4, 'bendingBatches');
+    const tetherStart = bendingStart + bendings * 6;
+    const tetherBatches = regroup(packs, garments, constraints, tetherStart, 3, 2, 'tetherBatches');
+    return {
+        count,
+        statics,
+        constraints,
+        distances,
+        bendings,
+        tethers,
+        distanceBatches,
+        bendingBatches,
+        tetherBatches,
+        joints,
+        colliders,
+        garments,
+    };
+}
+function sum(packs, of) {
+    let total = 0;
+    for (const pack of packs)
+        total += of(pack);
+    return total;
+}
+/** Where one kind's records start in a garment's own pack, in words. */
+function kindStart(pack, kind) {
+    if (kind === 'distanceBatches')
+        return 0;
+    if (kind === 'bendingBatches')
+        return pack.distances * 4;
+    return pack.distances * 4 + pack.bendings * 6;
+}
+/**
+ * One kind's records, colour by colour and within a colour garment by garment, into `out` from
+ * `start`; each record's first `ids` words offset by its garment's first particle. The set's colours.
+ */
+function regroup(packs, garments, out, start, words, ids, kind) {
+    let colours = 0;
+    for (const pack of packs)
+        colours = Math.max(colours, pack[kind].length - 1);
+    const batches = new Uint32Array(colours + 1);
+    let record = 0;
+    for (let b = 0; b < colours; b++) {
+        packs.forEach((pack, g) => {
+            const own = pack[kind];
+            if (b + 1 >= own.length)
+                return;
+            const base = garments[g].particleBase;
+            const from = kindStart(pack, kind);
+            for (let r = own[b]; r < own[b + 1]; r++) {
+                const src = from + r * words;
+                const dst = start + record * words;
+                for (let w = 0; w < words; w++) {
+                    const word = pack.constraints[src + w];
+                    out[dst + w] = w < ids ? word + base : word;
+                }
+                record++;
+            }
+        });
+        batches[b + 1] = record;
+    }
+    return batches;
+}

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

@@ -26,6 +26,8 @@ export interface DrawCommand {
     readonly vertexBuffers: (GPUBuffer | null)[];
     vertexCount: number;
     indexBuffer: GPUBuffer | null;
+    /** How wide an index of `indexBuffer` is: a mesh's own, thirty-two bits for everything else. */
+    indexFormat: GPUIndexFormat;
     indexed: boolean;
     count: number;
     instances: number;

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

@@ -28,6 +28,7 @@ function emptyCommand() {
         vertexBuffers: new Array(VERTEX_BUFFER_SLOTS).fill(null),
         vertexCount: 0,
         indexBuffer: null,
+        indexFormat: 'uint32',
         indexed: false,
         count: 0,
         instances: 1,

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

@@ -294,7 +294,7 @@ skinPass?: SkinHalf,
  */
 reflectionSurface?: boolean, 
 /** An instanced pipeline that plays a bone animation. The key must carry it: `|anim`. */
-animated?: boolean): GPURenderPipeline;
+animated?: boolean): GPURenderPipeline | null;
 /**
  * The same pipeline, compiled off the main thread.
  *

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

@@ -625,7 +625,8 @@ skinPass = 'whole',
 reflectionSurface = false, 
 /** An instanced pipeline that plays a bone animation. The key must carry it: `|anim`. */
 animated = false) {
-    return cache.get(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided, alphaToCoverage, skinEight, cloth, model, skinPass, reflectionSurface, animated), true);
+    /* None where draws skip a compile and this one has not landed: see `PipelineCache.lit`. */
+    return cache.lit(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided, alphaToCoverage, skinEight, cloth, model, skinPass, reflectionSurface, animated));
 }
 /**
  * The same pipeline, compiled off the main thread.

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

@@ -0,0 +1,80 @@
+import type { SkinnedClothSetup } from '@driftengine/physics';
+import { GpuClothParticles } from './clothTextures.ts';
+export declare class GpuClothSet {
+    private readonly device;
+    private readonly garments;
+    private readonly packed;
+    private readonly kernels;
+    private readonly buffers;
+    private readonly state;
+    private readonly frameData;
+    private readonly paces;
+    private readonly group;
+    /** One round's records, every garment's: the head an op's, the rest each garment's own. */
+    private readonly staging;
+    private readonly stagingWords;
+    private readonly stagingFloats;
+    /** Each kind's first batch slot, and the first garment's publishing slot. */
+    private readonly batchSlot;
+    private readonly groups;
+    private readonly substeps;
+    private readonly iterations;
+    private encoder;
+    private pass;
+    private round;
+    constructor(device: GPUDevice, setups: readonly SkinnedClothSetup[]);
+    /** How many garments the set holds. */
+    get size(): number;
+    /** Garment `g`'s particles, what `setCloth` draws its bound meshes by. */
+    particles(g: number): GpuClothParticles;
+    /** Garment `g`'s rig for the steps to come; see `ClothControl.setPose`. */
+    setPose(g: number, globals: Float32Array, model: Float32Array): void;
+    /** The frame's sample of the scene's wind for garment `g`. See `SkinnedCloth.setWind`. */
+    setWind(g: number, x: number, y: number, z: number): void;
+    /** Garment `g` back to its skinned pose, settled; the next `step` publishes it. */
+    reset(g: number): void;
+    /**
+     * `dt` of the caller's time in whole fixed steps for every garment, and each garment's particles
+     * at its `alpha` published for the draws that follow, as the particles of `frame`.
+     */
+    step(dt: number, frame: number): void;
+    /**
+     * Garment `g`'s particles where its last step left them, three floats each: for the parity check,
+     * which compares them with the CPU solver's positions. Not for a frame — it waits on the device.
+     */
+    read(g: number): Promise<Float32Array>;
+    /** Its buffers; the particle textures are the renderer's to retire with the frame. */
+    dispose(): void;
+    private at;
+    /** Garment `g`: its schedule over a device that queues, its particles and its own numbers. */
+    private garment;
+    /**
+     * A garment's own words of its record, which every round carries: its colliders, its texture's
+     * width and its constants. Its limits ride in the head beside `live`, written as it joins a round.
+     */
+    private writeOwn;
+    /** Garments that cannot step together, refused by the first number they disagree on. */
+    private refuseStrangers;
+    private targetsChanged;
+    private queueOp;
+    private queueStep;
+    /** Every op every garment is waiting on, a round of one kind at a time, in each garment's order. */
+    private run;
+    /** Whether any garment has `kind` next. */
+    private waiting;
+    /** One round: every garment with `kind` next takes part, and the rest sit it out. */
+    private runRound;
+    private stepRound;
+    /** Every colour of one kind across the set, in colour order, each a dispatch over its range. */
+    private batches;
+    private dispatch;
+    private passFor;
+    /** A round's slot, sending what is recorded first where the slots are spent: its byte offset. */
+    private takeRound;
+    /** Where the records of the round at `roundAt` sit in `paces`. */
+    private paceOffset;
+    /** Send what has been recorded: every slot it reads was written ahead of it on the queue. */
+    private flush;
+    /** A garment's skin matrices — or its model, with no rig — and its colliders, into the set's. */
+    private writeFrameData;
+}