@driftengine/core 4.10.0 → 4.11.1

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

@@ -7,7 +7,7 @@ import type { PickHit, PickableSource } from '../../pickable.ts';
 import type { RendererApi } from '../api.ts';
 import { GpuTimestamps } from './gpuTimestamps.ts';
 import type { Environment, FilmOptions, InsetRect, LightVolumeDrawOptions, SkyColors, TranslucentMeshOptions } from '../webgl2/renderer.ts';
-import type { IncrementalMeshHandle, MeshOptions } from '../api.ts';
+import type { IncrementalMeshHandle, MeshOptions, PrepareOptions } from '../api.ts';
 import type { LightmapPage } from '../../lightmap.ts';
 import { type BloomResponse } from '../../bloomChain.ts';
 import type { WaterBody } from '../../waterRenderer.ts';
@@ -133,6 +133,10 @@ export declare class WebGPURenderer implements RendererApi {
      * flight at the time, so a consumer that builds more meshes later can wait again.
      */
     ready(): Promise<void>;
+    /** Every distinct cache a lit draw reaches: the frame's, the canvas's, the late pass's, skin's. */
+    private pipelineCaches;
+    /** Whether a lit draw whose pipeline is not built is left out while it compiles. */
+    private skipCompiling;
     private presentedFrameCount;
     /**
      * The joint palettes this frame has set, one slot each. The WebGL2 field of this name is a
@@ -847,6 +851,8 @@ export declare class WebGPURenderer implements RendererApi {
     private temporalHistoryUsable;
     private readonly aoStaging;
     private readonly aoFloats;
+    /** Where occlusion fades out with distance, `uFade`: none until a caller sets one. */
+    private readonly aoFade;
     private aoBindGroup;
     private readonly aoBlurLayout;
     /**
@@ -1179,6 +1185,17 @@ export declare class WebGPURenderer implements RendererApi {
     private modelMap;
     /** The material's shading model, which picks the lit pipeline: null the standard. */
     private materialModel;
+    /** `uWorldUv`, the material's projection packed by `packSurfaceProjection`. */
+    private readonly projection;
+    /** `uLayers`, the material's layers packed by `packSurfaceLayers`. */
+    private readonly layerFloats;
+    /**
+     * `uGlassTint` as the material leaves it, its light from behind and that light's colour, which a
+     * pane overwrites for its own draw and `releaseSeeThrough` puts back. See `transmission.ts`.
+     */
+    private readonly transmission;
+    private warnedLayersModelMap;
+    private warnedLayersTriplanar;
     /** Its numbers, `uModelParams`, packed by `packModel`. */
     private readonly modelParams;
     /**
@@ -1398,6 +1415,8 @@ export declare class WebGPURenderer implements RendererApi {
      * this one is called per crossfading region per frame and a closure per call is an allocation.
      */
     setDitherFade(amount: number): void;
+    /** Whether the draws that follow spend their own opacity on that screen door. See `renderer.ts`. */
+    setDitherOpacity(on: boolean): void;
     /**
      * How strong the microscopic relief on the surfaces drawn next is, and how coarse.
      *
@@ -2013,6 +2032,22 @@ export declare class WebGPURenderer implements RendererApi {
      * the texel-for-texel comparison that settled it.
      */
     private readonly correctedLightViewProj;
+    /**
+     * What a receiver projects through to read the sun's static layers: the environment's
+     * `lightViewProj`, taken at `bindMeshPass` as WebGL2 takes it there.
+     *
+     * **It was the last shadow pass's matrix**, which is the environment's wherever both layers are
+     * drawn with one and the moving layer's wherever they are not: the static layer was then read
+     * through the moving layer's tight square, and a distant pillar lost its shadow on WebGPU and kept
+     * it on WebGL2, measured on demo/dev/sunLayers.html?moving=tight.
+     */
+    private readonly receiverLightViewProj;
+    /**
+     * The matrix the sun's dynamic shadow pass was last drawn with, uncorrected as the lit stage
+     * projects with, and whether one has been. See `movingLightFor`.
+     */
+    private readonly movingLightViewProj;
+    private movingLightKnown;
     /**
      * The same matrix *uncorrected*, which is what the flat shader must project with.
      *
@@ -2061,6 +2096,21 @@ export declare class WebGPURenderer implements RendererApi {
      * the lit pass on every surface whether they find anything or not.
      */
     private noteGlassCaster;
+    /**
+     * A material's layers where they can be drawn: none asked, or a model's map in the mask's place,
+     * said once, leave one layer.
+     */
+    private layersOf;
+    /** Says once that a layered material's triplanar projection is laid on the horizontal plane. */
+    private warnLayersTriplanar;
+    /**
+     * What the sun's moving layer is read through: the matrix its shadow pass was last drawn with,
+     * where the lit pipelines carry one (`MOVING_SUN`); the environment's otherwise, which every caller
+     * drawing both layers with one matrix hands it anyway.
+     */
+    private movingLightFor;
+    /** The moving layer's own matrix on, the first time a frame draws that layer with one. */
+    private enableMovingSun;
     /** One of the lit stage's switches on, in every cache a lit pipeline can come from. */
     private enableLit;
     /** One resolution every glass caster is read through, so recording one allocates nothing. */
@@ -2438,6 +2488,35 @@ export declare class WebGPURenderer implements RendererApi {
      */
     private refuseOitMultisampled;
     drawTranslucentMesh(mesh: GpuMesh, model: ReadonlyMat4, opacity: number, options?: TranslucentMeshOptions): void;
+    /**
+     * Compile off the main thread every pipeline a draw of `mesh` in `material` takes. **The other
+     * backend's `prepareMesh` carries the contract**; here a draw's key is `meshShape`'s, so a prepared
+     * key is exactly the one the draw asks for, and the compiles are started as a skipping draw starts
+     * them (`PipelineCache.lit`) whatever `pipelineCompile` says, into the frame's own caches.
+     */
+    prepareMesh(mesh: GpuMesh, material: SurfaceMaterial<GpuSurfaceTexture> | null, options?: PrepareOptions): void;
+    /** `prepareMesh` for an instanced batch. See the other backend's `prepareInstanced`. */
+    prepareInstanced(batch: GpuInstancedBatch, material: SurfaceMaterial<GpuSurfaceTexture> | null, options?: PrepareOptions): void;
+    /**
+     * `material` set, every cache a draw in it may build into passed to `start` with whether that draw
+     * blends, compiles started rather than built (`PipelineCache.lit`), and then no material set and
+     * each cache back to what `pipelineCompile` says.
+     */
+    private preparing;
+    /** What `meshShape` worked out for the mesh draw at hand. Reused, so a draw allocates no record. */
+    private readonly drawShape;
+    /**
+     * The key a mesh draw's pipeline is cached under, and the pipeline state that key encodes, under
+     * the current material and these options, into `drawShape`. **The one statement of it**:
+     * `submitMesh` draws by it and `prepareMesh` compiles by it, so the two cannot disagree about a key.
+     */
+    private meshShape;
+    /**
+     * The pipeline `drawShape` names: the one built, one built here, or none where draws skip a
+     * compile and this one has not landed (`PipelineCache.lit`) — and none for a split skin until all
+     * of its halves have.
+     */
+    private meshPipeline;
     /**
      * @param blend Which of the two entry points above this came through, and **not** something to
      * infer from `opacity`.
@@ -2528,6 +2607,13 @@ export declare class WebGPURenderer implements RendererApi {
      * **What it gives up** against `drawMesh` is skinning and morphing, refused where the variant
      * is built, and a per-instance opacity: `opacity` here dims the whole batch.
      */
+    /**
+     * An instanced draw's pipeline under the current material and these options: the one built, one
+     * built here, or none while it compiles (`PipelineCache.lit`), its key, base and model left in
+     * `drawShape`. **The one statement of an instanced key**: `submitInstanced` draws by it and
+     * `prepareInstanced` compiles by it.
+     */
+    private instancedPipeline;
     /**
      * The next of a batch's cull slots this frame, with its cull queued against the current view; null
      * when the batch has drawn from `MAX_CULL_SLOTS` views already or the frame's job ring is full,
@@ -3202,6 +3288,14 @@ export declare class WebGPURenderer implements RendererApi {
      * light alone and its colour alone into the blur's targets and test for the depth its frame half
      * wrote.
      */
+    /**
+     * Whether a split skin draw's two kept halves have pipelines, starting the compile of either that
+     * has not: a skin drawn without them would lose its diffuse light for the frames they take, so a
+     * split skin draws all three halves or none. See `PipelineCache.lit`.
+     */
+    private skinHalvesReady;
+    /** One kept half's pipeline, or none where it is still compiling: see `PipelineCache.lit`. */
+    private skinHalfPipeline;
     private keepSkinDiffuse;
     /**
      * Spread the frame's skin and add it back: once, at the first blended draw or before the frame's
@@ -3946,6 +4040,11 @@ export declare class WebGPURenderer implements RendererApi {
     setLocalExposure(strength: number): void;
     /** The exposure pass, built once; the composite's group holds placeholders until it exists. */
     private ensureExposurePass;
+    /**
+     * Where ambient occlusion fades out with distance. **The other backend's
+     * `setAmbientOcclusionFade` carries the reasoning**; this is the same setter over the same state.
+     */
+    setAmbientOcclusionFade(distance: number, radius: number): void;
     /**
      * Where this frame's lens is focused, how deep the sharp zone is, and how much of the ceiling
      * to take. **The other backend's `setDepthOfField` carries the reasoning**, whole: the