@driftengine/core 4.4.2 → 4.6.0

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

@@ -1,9 +1,14 @@
+import { instancesBox } from '../../instanceCull.ts';
 import { INSTANCE_FLOATS, INSTANCE_STRIDE, packInstances } from '../../instances.ts';
+import { destroySlot } from './instanceCullPass.ts';
+import type { CullSlot } from './instanceCullPass.ts';
 import type { MeshInstances } from '../../instances.ts';
 import type { GpuMesh } from './buffers.ts';
 
 /** VERTEX | COPY_DST, spelled the way every other pass here spells it. */
 const USAGE_VERTEX = 0x0020 | 0x0008;
+/** A culling batch's source is read by the cull as storage too. */
+const USAGE_STORAGE = 0x0080;
 
 /**
  * One mesh's per-instance buffer on the device.
@@ -21,9 +26,20 @@ export class GpuInstancedBatch {
   readonly capacity: number;
   private readonly staging: Float32Array;
 
-  constructor(device: GPUDevice, mesh: GpuMesh, capacity: number, label: string) {
+  /** Whether the camera draw culls this batch. See `InstancedOptions.cull`. */
+  readonly cull: boolean;
+  /** The world box around every live instance, fitted at upload. See `instancesBox`. */
+  readonly box = new Float32Array([1, 1, 1, -1, -1, -1]);
+  /** One set of survivors per view drawn this frame. See `InstanceCullPass`. */
+  readonly slots: CullSlot[] = [];
+  /** The frame the slots were last taken in, and how many were taken. */
+  slotFrame = -1;
+  slotsTaken = 0;
+
+  constructor(device: GPUDevice, mesh: GpuMesh, capacity: number, label: string, cull = false) {
     this.mesh = mesh;
     this.capacity = capacity;
+    this.cull = cull;
     this.staging = new Float32Array(capacity * INSTANCE_FLOATS);
     this.buffer = device.createBuffer({
       /*
@@ -31,25 +47,47 @@ export class GpuInstancedBatch {
        * naming the resource it was about, and an unlabelled buffer names nothing.
        */
       label,
-      size: capacity * INSTANCE_STRIDE,
-      usage: USAGE_VERTEX,
+      size: Math.max(1, capacity) * INSTANCE_STRIDE,
+      usage: USAGE_VERTEX | (cull ? USAGE_STORAGE : 0),
     });
   }
 
+  /** Last frame's packed slots, for a reconstruction; made on first use by the renderer. */
+  previousBuffer: GPUBuffer | null = null;
+  /** How many slots the upload before the last one held, and how many the last one holds. */
+  previousCount = 0;
+  liveCount = 0;
+  /** The frame of the last upload. See `changeFrames.ts`. */
+  changed = -1;
+
   /**
    * Pack and push `data.count` instances, in one write.
    *
    * Only the live prefix, for the reason `uploadScatter` gives: the rest is not drawn and
    * uploading it would be per-frame waste with nothing reading it.
+   *
+   * **Given `previous`, the placement still in the staging array — the last upload, which is last
+   * frame's — is written there first**, so a reconstruction can pair each slot with where it was.
+   * `writeBuffer` copies at the call, so packing afterwards cannot reach that copy.
    */
-  upload(queue: GPUQueue, data: MeshInstances): void {
+  upload(queue: GPUQueue, data: MeshInstances, previous: GPUBuffer | null = null): void {
+    if (this.cull) instancesBox(data, this.mesh.bounds, this.box);
     const count = Math.min(data.count, this.capacity);
+    if (previous !== null) {
+      if (this.liveCount > 0) {
+        queue.writeBuffer(previous, 0, this.staging, 0, this.liveCount * INSTANCE_FLOATS);
+      }
+      this.previousCount = this.liveCount;
+    }
+    this.liveCount = count;
     if (count === 0) return;
     packInstances(data, this.staging);
     queue.writeBuffer(this.buffer, 0, this.staging, 0, count * INSTANCE_FLOATS);
   }
 
   dispose(): void {
+    this.previousBuffer?.destroy();
     this.buffer.destroy();
+    for (const slot of this.slots) destroySlot(slot);
   }
 }

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

@@ -0,0 +1,161 @@
+/**
+ * What a reconstructing frame draws after the upscale: its blended draws, at the output size.
+ *
+ * **Why late.** A blended surface writes no depth the motion pass could test against and has no
+ * single motion per pixel — a caption over a wall is two surfaces moving two ways — so a
+ * reconstruction can only smear it. Drawn after the resolve, at output resolution and unjittered,
+ * it is as sharp as a native frame and has no history to ghost.
+ *
+ * **What it holds**: a command pool of its own, because the frame graph's pool is spent at every
+ * scene flush and these must survive until the reconstruction has run; an output-size depth
+ * target; and the pass that fills it from the render's depth. Cost: translucent pixels are shaded
+ * at output resolution — 2.25x as many at ratio 1.5, only where translucency is — plus one
+ * full-screen depth pass.
+ */
+import { DEPTH_CLEAR, DEPTH_FORMAT } from '../../depthConvention.ts';
+import { LATE_DEPTH_WGSL } from '../../shaders/recon/lateDepth.wgsl.ts';
+import type { CommandPool, DrawCommand } from './drawCommand.ts';
+import { createCommandPool, resetPool, takeCommand } from './drawCommand.ts';
+
+export class LatePass {
+  private readonly device: GPUDevice;
+  private readonly commands: CommandPool = createCommandPool(64);
+  private depth: GPUTexture | null = null;
+  private depthTextureView: GPUTextureView | null = null;
+  private readonly layout: GPUBindGroupLayout;
+  private readonly pipeline: GPURenderPipeline;
+  private readonly sizes: GPUBuffer;
+  /** The render size and the output size, then the frame's jitter in render texels. */
+  private readonly sizeStaging = new Float32Array(8);
+  private group: GPUBindGroup | null = null;
+  private groupSource: GPUTextureView | null = null;
+
+  constructor(device: GPUDevice) {
+    this.device = device;
+    this.layout = device.createBindGroupLayout({
+      label: 'recon.lateDepth.layout',
+      entries: [
+        { binding: 0, visibility: 0x2, texture: { sampleType: 'depth' } },
+        { binding: 1, visibility: 0x2, buffer: { type: 'uniform' } },
+      ],
+    });
+    const module = device.createShaderModule({ label: 'recon.lateDepth', code: LATE_DEPTH_WGSL });
+    this.pipeline = device.createRenderPipeline({
+      label: 'recon.lateDepth',
+      layout: device.createPipelineLayout({ bindGroupLayouts: [this.layout] }),
+      vertex: { module, entryPoint: 'lateDepthVert' },
+      fragment: { module, entryPoint: 'lateDepthFrag', targets: [] },
+      primitive: { topology: 'triangle-list' },
+      depthStencil: { format: DEPTH_FORMAT, depthWriteEnabled: true, depthCompare: 'always' },
+    });
+    this.sizes = device.createBuffer({
+      label: 'recon.lateDepth.sizes',
+      size: 32,
+      usage: 0x40 | 0x8, // UNIFORM | COPY_DST
+    });
+  }
+
+  /** The output-size depth, (re)made when the output changes size. */
+  depthView(width: number, height: number): GPUTextureView {
+    if (this.depth === null || this.depth.width !== width || this.depth.height !== height) {
+      this.depth?.destroy();
+      this.depth = this.device.createTexture({
+        label: 'recon.lateDepth',
+        size: [width, height],
+        format: DEPTH_FORMAT,
+        usage: 0x10, // RENDER_ATTACHMENT
+      });
+      this.depthTextureView = this.depth.createView();
+    }
+    return this.depthTextureView as GPUTextureView;
+  }
+
+  /**
+   * Fill the output-size depth from `source`, the render's single-sample depth, drawn jittered by
+   * (`jitterX`, `jitterY`) render texels — which the fill takes back out (`recon/lateDepth.ts`).
+   */
+  upscale(
+    encoder: GPUCommandEncoder,
+    source: GPUTextureView,
+    renderWidth: number,
+    renderHeight: number,
+    outputWidth: number,
+    outputHeight: number,
+    jitterX: number,
+    jitterY: number,
+  ): void {
+    const target = this.depthView(outputWidth, outputHeight);
+    this.sizeStaging[0] = renderWidth;
+    this.sizeStaging[1] = renderHeight;
+    this.sizeStaging[2] = outputWidth;
+    this.sizeStaging[3] = outputHeight;
+    this.sizeStaging[4] = jitterX;
+    this.sizeStaging[5] = jitterY;
+    this.device.queue.writeBuffer(this.sizes, 0, this.sizeStaging);
+    if (this.group === null || this.groupSource !== source) {
+      this.group = this.device.createBindGroup({
+        label: 'recon.lateDepth.group',
+        layout: this.layout,
+        entries: [
+          { binding: 0, resource: source },
+          { binding: 1, resource: { buffer: this.sizes } },
+        ],
+      });
+      this.groupSource = source;
+    }
+    const pass = encoder.beginRenderPass({
+      label: 'recon.lateDepth',
+      colorAttachments: [],
+      depthStencilAttachment: {
+        view: target,
+        depthClearValue: DEPTH_CLEAR,
+        depthLoadOp: 'clear',
+        depthStoreOp: 'store',
+      },
+    });
+    pass.setPipeline(this.pipeline);
+    pass.setBindGroup(0, this.group);
+    pass.draw(3);
+    pass.end();
+  }
+
+  /** A command slot for one late draw. Every field a caller uses it fills; see `takeCommand`. */
+  take(): DrawCommand {
+    const at = takeCommand(this.commands);
+    const command = this.commands.commands[at] as DrawCommand;
+    command.offsetCount = 0;
+    command.vertexCount = 0;
+    command.indexBuffer = null;
+    command.indexed = false;
+    command.instances = 1;
+    command.indirect = null;
+    return command;
+  }
+
+  /** Late draws recorded this frame. */
+  get pending(): number {
+    return this.commands.taken;
+  }
+
+  /** Every late draw, in the order it was recorded, through the renderer's own issue. */
+  replay(
+    pass: GPURenderPassEncoder,
+    issue: (pass: GPURenderPassEncoder, command: DrawCommand) => void,
+  ): void {
+    for (let i = 0; i < this.commands.taken; i += 1) {
+      const command = this.commands.commands[i];
+      if (command !== undefined) issue(pass, command);
+    }
+  }
+
+  reset(): void {
+    resetPool(this.commands);
+  }
+
+  dispose(): void {
+    this.depth?.destroy();
+    this.depth = null;
+    this.depthTextureView = null;
+    this.sizes.destroy();
+  }
+}

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

@@ -87,7 +87,11 @@ export function createLightVolumeBindGroupLayout(
     entries.push({
       binding: texture.texture,
       visibility: VISIBILITY_FRAGMENT,
-      texture: { sampleType: 'unfilterable-float' },
+      texture: {
+        sampleType: 'unfilterable-float',
+        /* The sun's maps are one array since 4.5.0; see `shadowMap.ts`. */
+        ...(texture.type === 'sampler2DArray' ? { viewDimension: '2d-array' as const } : {}),
+      },
     });
     entries.push({
       binding: texture.sampler,