@driftengine/core 4.4.1 → 4.5.0

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

@@ -0,0 +1,133 @@
+/**
+ * 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.js';
+import { LATE_DEPTH_WGSL } from '../../shaders/recon/lateDepth.wgsl.js';
+import { createCommandPool, resetPool, takeCommand } from './drawCommand.js';
+export class LatePass {
+    device;
+    commands = createCommandPool(64);
+    depth = null;
+    depthTextureView = null;
+    layout;
+    pipeline;
+    sizes;
+    sizeStaging = new Float32Array(4);
+    group = null;
+    groupSource = null;
+    constructor(device) {
+        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: 16,
+            usage: 0x40 | 0x8, // UNIFORM | COPY_DST
+        });
+    }
+    /** The output-size depth, (re)made when the output changes size. */
+    depthView(width, height) {
+        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;
+    }
+    /** Fill the output-size depth from `source`, the render's single-sample depth. */
+    upscale(encoder, source, renderWidth, renderHeight, outputWidth, outputHeight) {
+        const target = this.depthView(outputWidth, outputHeight);
+        this.sizeStaging[0] = renderWidth;
+        this.sizeStaging[1] = renderHeight;
+        this.sizeStaging[2] = outputWidth;
+        this.sizeStaging[3] = outputHeight;
+        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() {
+        const at = takeCommand(this.commands);
+        const command = this.commands.commands[at];
+        command.offsetCount = 0;
+        command.vertexCount = 0;
+        command.indexBuffer = null;
+        command.indexed = false;
+        command.instances = 1;
+        return command;
+    }
+    /** Late draws recorded this frame. */
+    get pending() {
+        return this.commands.taken;
+    }
+    /** Every late draw, in the order it was recorded, through the renderer's own issue. */
+    replay(pass, issue) {
+        for (let i = 0; i < this.commands.taken; i += 1) {
+            const command = this.commands.commands[i];
+            if (command !== undefined)
+                issue(pass, command);
+        }
+    }
+    reset() {
+        resetPool(this.commands);
+    }
+    dispose() {
+        this.depth?.destroy();
+        this.depth = null;
+        this.depthTextureView = null;
+        this.sizes.destroy();
+    }
+}

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

@@ -55,7 +55,11 @@ export function createLightVolumeBindGroupLayout(device, variant) {
         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' } : {}),
+            },
         });
         entries.push({
             binding: texture.sampler,

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

@@ -0,0 +1,95 @@
+import type { GpuMesh } from './buffers.ts';
+export declare class MotionPass {
+    private readonly device;
+    /** The frame's movers, in the order they were drawn. */
+    private readonly meshes;
+    /** Two matrices a mover — this frame's model and last frame's — at `MOTION_DRAW_FLOATS` apart. */
+    private matrices;
+    private count;
+    /** `RIGID` or `SKINNED` per record, grown beside `matrices`. */
+    private kinds;
+    /** A skinned record's two palettes, this frame's and last frame's, by record index. */
+    private readonly paletteNow;
+    private readonly paletteWas;
+    /** A rewritten record's last-frame rows, by record index. */
+    private readonly previousRows;
+    /** One pipeline per stride for rewritten meshes: current and previous rows at that stride. */
+    private readonly dynamicPipelines;
+    /** An instanced record's placement this frame and last frame, and how many slots pair. */
+    private readonly instancesNow;
+    private readonly instancesWas;
+    private instanceCounts;
+    private readonly instancedPipelines;
+    private layout;
+    private paletteLayout;
+    private skinnedLayout;
+    /** Keyed by stride and the two skin offsets, packed into one number so a lookup builds nothing. */
+    private readonly skinnedPipelines;
+    /**
+     * A bind group per pair of palette views. The ring keeps its textures from frame to frame, so a
+     * steady scene settles on a handful of pairs and builds nothing per frame.
+     */
+    private readonly paletteGroups;
+    private module;
+    private pipelineLayout;
+    private readonly pipelines;
+    private frameBuffer;
+    private drawBuffer;
+    private drawCapacity;
+    private group;
+    private readonly frameStaging;
+    private drawStaging;
+    /** A float view of `drawStaging`, made when it is, so a frame's upload allocates nothing. */
+    private drawFloats;
+    constructor(device: GPUDevice);
+    /** A frame states its movers afresh. */
+    reset(): void;
+    /** A rigid mover: the same positions under last frame's model. */
+    recordRigid(mesh: GpuMesh, model: ArrayLike<number>, previousModel: ArrayLike<number>): void;
+    /** A skinned mover: its positions under last frame's pose as well as last frame's model. */
+    recordSkinned(mesh: GpuMesh, model: ArrayLike<number>, previousModel: ArrayLike<number>, palette: GPUTextureView, previousPalette: GPUTextureView): void;
+    /** A rewritten mesh: its vertices as they were, read from `previous`, under last frame's model. */
+    recordDynamic(mesh: GpuMesh, model: ArrayLike<number>, previousModel: ArrayLike<number>, previous: GPUBuffer): void;
+    /** An instanced batch: its first `count` slots, each under last frame's placement of that slot. */
+    recordInstanced(mesh: GpuMesh, placement: GPUBuffer, previousPlacement: GPUBuffer, count: number): void;
+    /** One record's slot: its mesh, its two matrices and its kind. Returns the record's index. */
+    private take;
+    /**
+     * The pipeline layout and module, built once.
+     *
+     * **The position alone**, at offset zero of the mesh's interleaved rows: that is all the rigid
+     * stage reads, and positions are the layout's first attribute and never optional.
+     */
+    private buildLayout;
+    /**
+     * The skinned pipeline for one stride and one placement of the joints and weights in it.
+     *
+     * Same fragment stage, winding and depth test as the rigid one — see `pipelineFor` — with the two
+     * skinning attributes read from the interleaved rows at the offsets the mesh records.
+     */
+    private skinnedPipelineFor;
+    /** The rewritten pipeline for one stride: position from each of two buffers of that stride. */
+    private dynamicPipelineFor;
+    /**
+     * The instanced pipeline for one mesh stride: the mesh's positions, then this frame's and last
+     * frame's placements, one matrix an instance, as the scene's instanced stage reads them.
+     */
+    private instancedPipelineFor;
+    /** The bind group holding one pair of palettes, built the first time the pair is seen. */
+    private paletteGroup;
+    /** The pipeline for one vertex stride, built on first sight of it. */
+    private pipelineFor;
+    /**
+     * Every mover of the frame, into `target`, tested against the finished `depth`.
+     *
+     * **After everything that draws and before the resolve reads it.** `raster` is the scene's clip
+     * transform with the generated stages' y negation folded in; `viewProj` and `previousViewProj`
+     * are this frame's and last frame's unjittered view-projections.
+     *
+     * **Cleared every frame, even when nothing moved.** A texel left from last frame is a flag saying
+     * "a draw wrote this", and the resolve would take a motion belonging to a surface that is no
+     * longer there. The clear is the pass's own load operation, so an empty frame still runs it.
+     */
+    run(encoder: GPUCommandEncoder, target: GPUTextureView, depth: GPUTextureView, raster: Float32Array, viewProj: Float32Array, previousViewProj: Float32Array, timestampWrites: GPURenderPassTimestampWrites | undefined): void;
+    dispose(): void;
+}