@driftengine/core 4.8.3 → 4.8.4

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

@@ -21,6 +21,7 @@ const RIGID = 0;
 const SKINNED = 1;
 const DYNAMIC = 2;
 const INSTANCED = 3;
+const CLOTH = 4;
 
 /** An instanced record's per-draw matrices are not read; this fills their slot. */
 const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
@@ -37,6 +38,22 @@ export class MotionPass {
   /** A skinned record's two palettes, this frame's and last frame's, by record index. */
   private readonly paletteNow: (GPUTextureView | null)[] = [];
   private readonly paletteWas: (GPUTextureView | null)[] = [];
+  /** A cloth record's binding and its particles now and last frame, by record index. */
+  private readonly clothBinding: (GPUTextureView | null)[] = [];
+  private readonly clothNow: (GPUTextureView | null)[] = [];
+  private readonly clothWas: (GPUTextureView | null)[] = [];
+  private clothLayout: GPUBindGroupLayout | null = null;
+  private clothPipelineLayout: GPUPipelineLayout | null = null;
+  /** Keyed as `skinnedPipelines` is. */
+  private readonly clothPipelines = new Map<number, GPURenderPipeline>();
+  /**
+   * A bind group per particles now, particles then and binding. Weak at the top, by this frame's
+   * particles, so a character's groups go when its particles do; a steady garment settles on three.
+   */
+  private clothGroups = new WeakMap<
+    GPUTextureView,
+    Map<GPUTextureView, Map<GPUTextureView, GPUBindGroup>>
+  >();
   /** A rewritten record's last-frame rows, by record index. */
   private readonly previousRows: (GPUBuffer | null)[] = [];
   /** One pipeline per stride for rewritten meshes: current and previous rows at that stride. */
@@ -95,6 +112,28 @@ export class MotionPass {
     this.paletteWas[at] = previousPalette;
   }
 
+  /**
+   * A cloth-bound skinned draw: its skinned positions under both poses, each carried toward the
+   * cloth by its painted weight — this frame's `particles` and last frame's `previousParticles`.
+   */
+  recordCloth(
+    mesh: GpuMesh,
+    model: ArrayLike<number>,
+    previousModel: ArrayLike<number>,
+    palette: GPUTextureView,
+    previousPalette: GPUTextureView,
+    binding: GPUTextureView,
+    particles: GPUTextureView,
+    previousParticles: GPUTextureView,
+  ): void {
+    const at = this.take(mesh, model, previousModel, CLOTH);
+    this.paletteNow[at] = palette;
+    this.paletteWas[at] = previousPalette;
+    this.clothBinding[at] = binding;
+    this.clothNow[at] = particles;
+    this.clothWas[at] = previousParticles;
+  }
+
   /** A rewritten mesh: its vertices as they were, read from `previous`, under last frame's model. */
   recordDynamic(
     mesh: GpuMesh,
@@ -188,6 +227,18 @@ export class MotionPass {
     this.skinnedLayout = this.device.createPipelineLayout({
       bindGroupLayouts: [this.layout, this.paletteLayout],
     });
+    /* The binding and the two particle textures, read with `textureLoad` as the palettes are. */
+    this.clothLayout = this.device.createBindGroupLayout({
+      label: 'recon.motion.cloth',
+      entries: [0, 1, 2].map((binding) => ({
+        binding,
+        visibility: 0x1,
+        texture: { sampleType: 'unfilterable-float' as const },
+      })),
+    });
+    this.clothPipelineLayout = this.device.createPipelineLayout({
+      bindGroupLayouts: [this.layout, this.paletteLayout, this.clothLayout],
+    });
   }
 
   /**
@@ -198,20 +249,38 @@ export class MotionPass {
    */
   private skinnedPipelineFor(
     stride: number,
-    offsets: { readonly joints: number; readonly weights: number },
+    offsets: {
+      readonly joints: number;
+      readonly weights: number;
+      readonly joints2: number;
+      readonly weights2: number;
+    },
+    cloth = false,
   ): GPURenderPipeline | null {
-    const key = (stride * 4096 + offsets.joints) * 4096 + offsets.weights;
-    const held = this.skinnedPipelines.get(key);
+    /* A rig of eight takes the stage that sums the second four as well. See motion.wgsl.ts. */
+    const eight = offsets.joints2 >= 0 && offsets.weights2 >= 0;
+    /*
+     * Five byte counts, each under 256 because a vertex is at most 172 bytes, as five base-256
+     * digits: exact below 2^40, so two layouts can never share a key.
+     */
+    const key =
+      (((stride * 256 + offsets.joints) * 256 + offsets.weights) * 256 + offsets.joints2 + 1) *
+        256 +
+      offsets.weights2 +
+      1;
+    const pipelines = cloth ? this.clothPipelines : this.skinnedPipelines;
+    const held = pipelines.get(key);
     if (held !== undefined) return held;
     const module = this.module;
-    const layout = this.skinnedLayout;
+    const layout = cloth ? this.clothPipelineLayout : this.skinnedLayout;
     if (module === null || layout === null) return null;
+    const stage = cloth ? 'Cloth' : 'Skinned';
     const pipeline = this.device.createRenderPipeline({
-      label: `recon.motion.skinned.${String(stride)}`,
+      label: `recon.motion.${cloth ? 'cloth' : 'skinned'}.${String(stride)}`,
       layout,
       vertex: {
         module,
-        entryPoint: 'motionSkinnedVert',
+        entryPoint: eight ? `motion${stage}EightVert` : `motion${stage}Vert`,
         buffers: [
           {
             arrayStride: stride,
@@ -219,6 +288,12 @@ export class MotionPass {
               { shaderLocation: 0, offset: 0, format: 'float32x3' },
               { shaderLocation: 11, offset: offsets.joints, format: 'float32x4' },
               { shaderLocation: 12, offset: offsets.weights, format: 'float32x4' },
+              ...(eight
+                ? ([
+                    { shaderLocation: 14, offset: offsets.joints2, format: 'float32x4' },
+                    { shaderLocation: 15, offset: offsets.weights2, format: 'float32x4' },
+                  ] as const)
+                : []),
             ],
           },
         ],
@@ -231,7 +306,7 @@ export class MotionPass {
         depthCompare: DEPTH_COMPARE_EQUAL,
       },
     });
-    this.skinnedPipelines.set(key, pipeline);
+    pipelines.set(key, pipeline);
     return pipeline;
   }
 
@@ -342,6 +417,40 @@ export class MotionPass {
     return group;
   }
 
+  /** The bind group holding a cloth's binding and its two particle textures, built on first sight. */
+  private clothGroup(
+    binding: GPUTextureView,
+    now: GPUTextureView,
+    was: GPUTextureView,
+  ): GPUBindGroup | null {
+    const layout = this.clothLayout;
+    if (layout === null) return null;
+    let byWas = this.clothGroups.get(now);
+    if (byWas === undefined) {
+      byWas = new Map();
+      this.clothGroups.set(now, byWas);
+    }
+    let byBinding = byWas.get(was);
+    if (byBinding === undefined) {
+      byBinding = new Map();
+      byWas.set(was, byBinding);
+    }
+    let group = byBinding.get(binding);
+    if (group === undefined) {
+      group = this.device.createBindGroup({
+        label: 'recon.motion.cloth',
+        layout,
+        entries: [
+          { binding: 0, resource: binding },
+          { binding: 1, resource: now },
+          { binding: 2, resource: was },
+        ],
+      });
+      byBinding.set(binding, group);
+    }
+    return group;
+  }
+
   /** The pipeline for one vertex stride, built on first sight of it. */
   private pipelineFor(stride: number): GPURenderPipeline | null {
     const held = this.pipelines.get(stride);
@@ -497,14 +606,23 @@ export class MotionPass {
           if (previous === null) continue;
           pipeline = this.dynamicPipelineFor(mesh.vertexStride);
           pass.setVertexBuffer(1, previous);
-        } else if (kind === SKINNED) {
+        } else if (kind === SKINNED || kind === CLOTH) {
           const offsets = mesh.skinOffsets;
           const now = this.paletteNow[i] ?? null;
           const was = this.paletteWas[i] ?? null;
           if (offsets === null || now === null || was === null) continue;
-          pipeline = this.skinnedPipelineFor(mesh.vertexStride, offsets);
+          pipeline = this.skinnedPipelineFor(mesh.vertexStride, offsets, kind === CLOTH);
           const palettes = this.paletteGroup(now, was);
           if (pipeline === null || palettes === null) continue;
+          if (kind === CLOTH) {
+            const binding = this.clothBinding[i] ?? null;
+            const particles = this.clothNow[i] ?? null;
+            const previous = this.clothWas[i] ?? null;
+            if (binding === null || particles === null || previous === null) continue;
+            const cloth = this.clothGroup(binding, particles, previous);
+            if (cloth === null) continue;
+            pass.setBindGroup(2, cloth);
+          }
           pass.setBindGroup(1, palettes);
         } else {
           pipeline = this.pipelineFor(mesh.vertexStride);
@@ -526,6 +644,7 @@ export class MotionPass {
 
   dispose(): void {
     this.paletteGroups.clear();
+    this.clothGroups = new WeakMap();
     this.frameBuffer?.destroy();
     this.drawBuffer?.destroy();
     this.frameBuffer = null;

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

@@ -365,8 +365,10 @@ export function postPipelineTargets(
   key: string,
   fragment: string,
   targets: GPUColorTargetState[],
+  /** For a pass drawn into the frame's own multisampled colour, which must match its count. */
+  sampleCount = 1,
 ): GPURenderPipeline {
-  return cache.get(key, () => describePost(device, layout, key, fragment, targets));
+  return cache.get(key, () => describePost(device, layout, key, fragment, targets, sampleCount));
 }
 
 function describePost(
@@ -375,8 +377,10 @@ function describePost(
   key: string,
   fragment: string,
   targets: GPUColorTargetState[],
+  sampleCount = 1,
 ): GPURenderPipelineDescriptor {
   return {
+    ...(sampleCount > 1 ? { multisample: { count: sampleCount } } : {}),
     label: key,
     layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
     vertex: {