@driftengine/core 4.8.3 → 4.8.4

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

@@ -188,7 +188,9 @@ export declare function postPipeline(cache: PipelineCache, device: GPUDevice, la
  * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
  * rather than built per call, since this is asked for every frame.
  */
-export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[]): GPURenderPipeline;
+export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[], 
+/** For a pass drawn into the frame's own multisampled colour, which must match its count. */
+sampleCount?: number): GPURenderPipeline;
 /**
  * The temporal resolve's block and its four inputs.
  *

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

@@ -267,11 +267,14 @@ export function postPipeline(cache, device, layout, key, fragment, format, blend
  * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
  * rather than built per call, since this is asked for every frame.
  */
-export function postPipelineTargets(cache, device, layout, key, fragment, targets) {
-    return cache.get(key, () => describePost(device, layout, key, fragment, targets));
+export function postPipelineTargets(cache, device, layout, key, fragment, targets, 
+/** For a pass drawn into the frame's own multisampled colour, which must match its count. */
+sampleCount = 1) {
+    return cache.get(key, () => describePost(device, layout, key, fragment, targets, sampleCount));
 }
-function describePost(device, layout, key, fragment, targets) {
+function describePost(device, layout, key, fragment, targets, sampleCount = 1) {
     return {
+        ...(sampleCount > 1 ? { multisample: { count: sampleCount } } : {}),
         label: key,
         layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
         vertex: {

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

@@ -19,6 +19,10 @@ import { type ShadowLight } from '../../pointShadowSystem.ts';
 import { GpuText } from './textPass.ts';
 import type { TextStyle } from '../../textLayout.ts';
 import { GpuSurfaceTexture } from './surfaceTexturePass.ts';
+import { GpuClothBinding, GpuClothParticles } from './clothTextures.ts';
+import type { ComputeHost } from './computeHost.ts';
+import type { ClothBindingData } from '../../clothBindingData.ts';
+import type { CompressedTextureFormat, SurfaceSource } from '../../compressedSource.ts';
 import { GpuSdfText } from './sdfTextPass.ts';
 import type { SdfFont } from '../../sdfFont.ts';
 import type { SdfTextStyle } from '../../sdfTextLayout.ts';
@@ -151,6 +155,12 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly skinnedGroupsBeside;
     private readonly skinnedGroupsPalette;
     private readonly skinnedGroupsDeltas;
+    /** The cloth views each skinned twin was built with, compared by identity like the palette. */
+    private readonly skinnedGroupsCloth;
+    private readonly skinnedGroupsClothBinding;
+    /** The cloth the next skinned draws are placed by, or null. See `setCloth`. */
+    private cloth;
+    private clothStandCache;
     /**
      * Which palette slot the following draws skin by, or -1 for none.
      *
@@ -498,6 +508,16 @@ export declare class WebGPURenderer implements RendererApi {
     private refractSnapshotView;
     /** Whether this frame has taken it. One snapshot serves every refracting draw. */
     private refractSnapshotTaken;
+    /**
+     * Skin's screen-space scattering, made where the profile asks for it and has a composite to add
+     * into, and null otherwise — which is every profile by default. See `SkinScatterPass`.
+     */
+    private readonly skinScatter;
+    /** The pipelines skin's diffuse half is built for: the blur target's format, the frame's samples. */
+    private readonly skinPipelines;
+    /** Whether this frame has spread its skin: once, at its first blended draw or before its end. */
+    private skinScattered;
+    private readonly skinInverseProjection;
     private sceneColorView;
     /** The multisampled twin, when the profile asks for samples. Resolved into `sceneColor`. */
     private sceneColorMsaa;
@@ -676,6 +696,17 @@ export declare class WebGPURenderer implements RendererApi {
     private temporalJitterX;
     private temporalJitterY;
     private temporalJittering;
+    /**
+     * The frame a dithered cutout's pattern is offset by, advanced at `beginFrame` and wrapped at 64.
+     * See `cutoutDither.ts`.
+     */
+    private cutoutFrame;
+    /**
+     * How the current material's cutout edge is drawn this frame, decided when the material is staged
+     * — after `bindMeshPass` has settled whether the frame is temporal — and read by every draw: a
+     * coverage edge is pipeline state here (`|a2c`), and a blended draw tests hard.
+     */
+    private cutoutResolveStaged;
     /**
      * Whether this frame is being reconstructed, settled once in `bindMeshPass`.
      *
@@ -1082,6 +1113,12 @@ export declare class WebGPURenderer implements RendererApi {
     private ormMap;
     /** The caller's emissive map, or null for the stand-in. See `setMaterial`. */
     private emissiveMap;
+    /** The material's model map, or null for the stand-in. See `setMaterial` and `surfaceModel.ts`. */
+    private modelMap;
+    /** The material's shading model, which picks the lit pipeline: null the standard. */
+    private materialModel;
+    /** Its numbers, `uModelParams`, packed by `packModel`. */
+    private readonly modelParams;
     /**
      * The flat group for a material, keyed on **all four** of its maps.
      *
@@ -1124,9 +1161,16 @@ export declare class WebGPURenderer implements RendererApi {
     private materialDoubleSided;
     /** Whether the bound material has a map, for the warning a mesh with no coordinates earns. */
     private materialHasMaps;
-    createSurfaceTexture(source: TexImageSource, options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    createSurfaceTexture(source: SurfaceSource, options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    private compressedCache;
+    /**
+     * The BC formats this device takes as blocks: every one where the device carries
+     * `texture-compression-bc`, which `select.ts` asks for wherever the adapter offers it, and none
+     * where it does not. See `Renderer.compressedFormats`.
+     */
+    get compressedFormats(): readonly CompressedTextureFormat[];
     /** Several images of one size as an array's layers. See `RendererApi.createSurfaceTextureArray`. */
-    createSurfaceTextureArray(sources: readonly TexImageSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
+    createSurfaceTextureArray(sources: readonly SurfaceSource[], options?: SurfaceTextureOptions): GpuSurfaceTexture;
     /**
      * GPU textures an `updateSurfaceTexture` replaced, destroyed when the next frame begins.
      *
@@ -1159,6 +1203,40 @@ export declare class WebGPURenderer implements RendererApi {
      * surface must be answered by every backend, and answered honestly, per the 2026-08-13 rule.
      */
     setSkinPalette(palette: Float32Array | null): void;
+    /**
+     * A mesh's cloth binding. See `RendererApi.createClothBinding`. The pipelines that draw it bound
+     * are warmed here, every way this mesh can be drawn, so none compiles inside the first frame
+     * that draws a garment.
+     */
+    createClothBinding(mesh: GpuMesh, data: ClothBindingData): GpuClothBinding;
+    /** One character's particles. See `RendererApi.createClothParticles`. */
+    createClothParticles(count: number): GpuClothParticles;
+    /**
+     * This frame's particles. **Once a frame, before the character's draws**: a texture write lands
+     * ahead of every draw of the frame, so a second update between two draws would reach both.
+     */
+    updateClothParticles(particles: GpuClothParticles, positions: Float32Array): void;
+    /** Place the following skinned draws by a cloth, or by none. See `RendererApi.setCloth`. */
+    setCloth(binding: GpuClothBinding | null, particles?: GpuClothParticles | null): void;
+    /** Retired rather than destroyed: a draw recorded earlier in this frame may still read them. */
+    disposeClothBinding(binding: GpuClothBinding): void;
+    disposeClothParticles(particles: GpuClothParticles): void;
+    /**
+     * The device and the frame's bookkeeping, for compute a consumer opts into by importing it —
+     * `createSkinnedCloth` — rather than for anything this renderer runs itself. See `computeHost.ts`.
+     */
+    computeHost(): ComputeHost;
+    private readonly computeHostCache;
+    /**
+     * An eye's axis in the world for this draw, into the open material's \`uModelParams\`, and a new
+     * material slot when it moved: the axis is per draw, and a slot already taken by an earlier draw
+     * of the same eye must not be written under it. See \`eyeAxisInWorld\`.
+     */
+    private writeEyeAxis;
+    /** The views the draw's cloth binds, or the stand-in's where no cloth is set. */
+    private clothViews;
+    /** The one-texel stand-in a skinned group binds where there is no cloth, made on first need. */
+    private clothStand;
     /**
      * Choose the morph weights the following `drawMesh` calls deform by, or null for none.
      *
@@ -1725,6 +1803,8 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly shadowSkinnedGroups;
     private readonly shadowSkinnedGroupsBeside;
     private readonly shadowSkinnedGroupsPalette;
+    private readonly shadowSkinnedGroupsCloth;
+    private readonly shadowSkinnedGroupsClothBinding;
     /** Held from construction so the skinned group can be rebuilt without them being threaded. */
     private shadowBlankView;
     private shadowBlankSampler;
@@ -2093,9 +2173,9 @@ export declare class WebGPURenderer implements RendererApi {
     /**
      * Rewrite a mesh's positions, and its normals where the caller has them.
      *
-     * Refused in words on a mesh that did not declare itself dynamic, because the thing that makes
-     * an update possible on this backend — the interleaved array the vertex data was built from —
-     * is only kept when a consumer asked for it. See `GpuMesh.update`.
+     * Refused in words on a mesh that did not declare itself dynamic, because what makes an update
+     * cheap on this backend — positions and normals in buffers of their own — is a layout chosen at
+     * creation. See `GpuMesh.update`.
      */
     updateMesh(mesh: GpuMesh, positions: Float32Array, normals?: Float32Array): void;
     /**
@@ -2675,6 +2755,13 @@ export declare class WebGPURenderer implements RendererApi {
      * it before the motion pass reads it. See `SkinPaletteRing`.
      */
     private recordSkinnedMotion;
+    /**
+     * A cloth-bound draw's motion. **Recorded even where the caller named no previous place**, as a
+     * rewritten mesh's is: the particles carry their own past, and a garment swinging on a character
+     * standing still is motion nobody else can see. Where the rig is a `Mover` its last pose is taken
+     * as a skinned mover's is; otherwise the rig is taken not to have moved.
+     */
+    private recordClothMotion;
     private warnMoverTwice;
     /**
      * Where every mover was last frame, into the motion target. See `MotionPass`.
@@ -2849,6 +2936,27 @@ export declare class WebGPURenderer implements RendererApi {
      * glass, and a frame that refracts nothing breaks no pass at all.
      */
     private takeRefractSnapshot;
+    /**
+     * Whether a skin draw now draws its two halves: the profile asked, the frame has not spread its
+     * skin yet, and this is the frame's own picture — not a mirror's, a probe's, an overlay after
+     * the frame, or an order-independent set, none of which the spread reads.
+     */
+    private skinSplits;
+    /**
+     * A skin draw's diffuse half, kept for the spread: the frame's draw again, with the same slots,
+     * buffers and bind group, through the pipeline that writes the diffuse alone into the blur's
+     * target and tests for the depth its frame half wrote.
+     */
+    private keepSkinDiffuse;
+    /**
+     * Spread the frame's skin and add it back: once, at the first blended draw or before the frame's
+     * last flush. **A fifth instance of the boundary `takeRefractSnapshot` describes** — flush, end
+     * the pass, work between passes, reopen with `loadOp: 'load'` — and refused where that one is,
+     * for its reasons. Between the passes: the kept diffuse halves into their target against the
+     * frame's depth, the depth resolved, and `SkinScatterPass.spread` across and then down into the
+     * frame's colour.
+     */
+    private runSkinScatter;
     private takeVolumeDepth;
     /**
      * The pass to record into, reopening one on the canvas if the frame has already gone.