@driftengine/core 4.8.2 → 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/panelPass.ts

@@ -7,6 +7,7 @@ import type { UniformFields } from './scatterPass.ts';
 import { DEPTH_FORMAT } from './flatPass.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import { shaderModule } from './shaderModules.ts';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.ts';
 
 /**
  * The panel pass: two triangles in screen space, one colour, one alpha.
@@ -121,7 +122,7 @@ export function panelPipeline(
           format: cache.format,
           blend: {
             color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+            alpha: SCENE_ALPHA_COVERS,
           },
         },
       ],

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

@@ -8,6 +8,7 @@ import { DEPTH_FORMAT } from './flatPass.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import type { UniformFields } from './scatterPass.ts';
 import { shaderModule } from './shaderModules.ts';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.ts';
 
 /**
  * The particle pass: a crossed pair of quads per live particle, rebuilt every frame.
@@ -367,7 +368,7 @@ export function particlePipeline(
                     dstFactor: 'one-minus-src-alpha',
                     operation: 'add',
                   },
-                  alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                  alpha: SCENE_ALPHA_COVERS,
                 },
         },
       ],

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

@@ -9,6 +9,7 @@ import { DEPTH_FORMAT } from './flatPass.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import type { UniformFields } from './scatterPass.ts';
 import { shaderModule } from './shaderModules.ts';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.ts';
 
 /**
  * The plume pass: crossed quads per plume, displaced and faded in the shaders.
@@ -251,7 +252,7 @@ function blendState(blend: 'additive' | 'alpha'): GPUBlendState {
       }
     : {
         color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-        alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+        alpha: SCENE_ALPHA_COVERS,
       };
 }
 

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

@@ -39,6 +39,7 @@ import {
 import type { UniformFields } from './scatterPass.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import { shaderModule } from './shaderModules.ts';
+import { SCENE_ALPHA_KEEPS, SCENE_ALPHA_TRANSMITS } from '../../sceneCoverage.ts';
 
 /**
  * The composite: everything that happens to the frame after the world is drawn.
@@ -271,7 +272,7 @@ export function createPostStageLayout(
  */
 export const OIT_COMPOSITE_BLEND: GPUBlendState = {
   color: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
-  alpha: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
+  alpha: SCENE_ALPHA_TRANSMITS,
 };
 
 /**
@@ -290,17 +291,19 @@ export const OIT_COMPOSITE_BLEND: GPUBlendState = {
  * exactly the integral — and the composite therefore never samples the colour it is modifying,
  * which is the read both backends are entitled to call undefined.
  *
- * Alpha is `(zero, one)`: the frame's own alpha is not the medium's to spend. The scene target
- * carries it to the canvas, and a medium that wrote there would make a foggy frame translucent.
+ * Alpha is the transmittance again, `share * a`: the scene's alpha is how much of the pixel is
+ * still the opaque surface, which is what the composite lets ambient occlusion darken, and a
+ * medium thick enough to hide a corner hides its occlusion too (`sceneCoverage.ts`). It reaches
+ * no canvas: both are opaque, and the composite writes 1.
  */
 export const MEDIUM_TRANSMIT_BLEND: GPUBlendState = {
   color: { srcFactor: 'one', dstFactor: 'src-alpha', operation: 'add' },
-  alpha: { srcFactor: 'zero', dstFactor: 'one', operation: 'add' },
+  alpha: SCENE_ALPHA_TRANSMITS,
 };
 
 export const DECAL_MULTIPLY_BLEND: GPUBlendState = {
   color: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
-  alpha: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
+  alpha: SCENE_ALPHA_KEEPS,
 };
 
 /**
@@ -316,6 +319,18 @@ export const PREMULTIPLIED_OVER_BLEND: GPUBlendState = {
   alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
 };
 
+/**
+ * The same `over` for the resolve that lands a reflection on the scene, keeping the scene's alpha.
+ *
+ * A reflection is a layer of the surface it is seen in, so the surface's share of the pixel is
+ * unchanged (`sceneCoverage.ts`). The trace keeps `PREMULTIPLIED_OVER_BLEND`, because its target is
+ * the reflection's own and its alpha is the coverage this resolve reads.
+ */
+export const REFLECTION_OVER_BLEND: GPUBlendState = {
+  color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+  alpha: SCENE_ALPHA_KEEPS,
+};
+
 export const ADDITIVE_BLEND: GPUBlendState = {
   color: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
   alpha: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
@@ -350,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(
@@ -360,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: {