@driftengine/core 4.13.5 → 4.14.0

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

@@ -1,5 +1,5 @@
 import { FrameBudget } from '../budget.ts';
-import type { Mover } from '../../recon/mover.ts';
+import { type Mover } from '../../recon/mover.ts';
 import type { GlassOptions } from '../../glass.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { Camera } from '../../camera.ts';
@@ -15,6 +15,7 @@ import type { Vec3 } from '../../../math/color.ts';
 import type { LocalExposureOptions } from '../../shaders/localExposure.ts';
 import { GpuTimer } from '../../gpuTimer.ts';
 import { type SurfaceOverlay } from '../../surfaceOverlay.ts';
+import { type BaseDecal } from '../../baseDecals.ts';
 import type { ColourGradeLut } from '../../colourGrade.ts';
 import { type BloomResponse } from '../../bloomChain.ts';
 import { LightField } from '../../driftLight/lightField.ts';
@@ -1230,6 +1231,17 @@ export declare class WebGL2Renderer implements RendererApi {
     private iesAtlas;
     /** The cookie images, kept so a new set of profiles can rebuild the atlas around them. */
     private cookieImages;
+    /** The images the frame's base decals lay, in the atlas's band of them. See `setBaseDecalImages`. */
+    private decalImages;
+    /** The decals as last laid, packed again whenever the atlas moves their band. */
+    private baseDecalList;
+    /** `uBaseDecals`, held until the next `setBaseDecals`, across passes. */
+    private readonly baseDecalFloats;
+    /** Whether the lit stage has room for base decals, asked once. */
+    private decalRoom;
+    private warnedDecalRoom;
+    /** The refusals of a decal or its image already said, each once. */
+    private readonly warnedBaseDecals;
     /** Rows of profile in the atlas. One until a consumer loads a profile, which is the row of ones. */
     private iesRows;
     /** Cookie tiles in the atlas. 0 is none, and the whole off path. */
@@ -1312,6 +1324,18 @@ export declare class WebGL2Renderer implements RendererApi {
     private warnedLooksRoom;
     /** `uDetail`, the material's tiled detail packed by `packSurfaceDetail`. */
     private readonly detailFloats;
+    /** `uEmissiveFlow`, a material's glow moved and masked, packed by `packEmissiveFlow`. */
+    private readonly flowFloats;
+    /** Whether the lit stage has room for that, asked once. See `emissiveFlowFits`. */
+    private flowRoom;
+    private warnedFlowRoom;
+    /** `uIridescence`, a material's iridescent overlay packed by `packIridescentOverlay`. */
+    private readonly iridescentFloats;
+    /** Whether the lit stage has room for it, asked once. See `iridescentOf`. */
+    private iridescentRoom;
+    private warnedIridescentRoom;
+    /** The refusals of an overlay already said, each once. */
+    private readonly warnedIridescent;
     /** Whether the lit stage has room for detail on this part, asked once. See `detailOfMaterial`. */
     private detailRoom;
     private warnedDetailRoom;
@@ -1419,6 +1443,19 @@ export declare class WebGL2Renderer implements RendererApi {
     private shadowMatrix;
     private sceneMatrix;
     private shadowPassActive;
+    /**
+     * The motion WebGL2's temporal resolve follows: the frame's movers, recorded as they are drawn and
+     * drawn into a target of their own at `endFrame`. See `motionTarget.ts`.
+     */
+    private readonly motionPass;
+    /** Which renderer a `Mover` was last drawn by, and the frame serial it reads. See `mover.ts`. */
+    private readonly moverRenderer;
+    private moverFrame;
+    /** Between `beginFrame` and `endFrame`, which decides which frame a rewrite belongs to. */
+    private inFrame;
+    private readonly motionJittered;
+    private warnedMoverTwice;
+    private warnedMotionUnkept;
     /** Non-zero while the drawing buffer is pinned; see `lockDrawingBuffer`. */
     private lockedWidth;
     private lockedHeight;
@@ -1748,6 +1785,25 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     setSpotCookies(images: readonly TexImageSource[]): void;
     setIesProfiles(profiles: readonly PhotometricProfile[]): void;
+    /**
+     * The images the frame's base decals lay, each a `BASE_DECAL_TILE` square, into the fixture
+     * atlas's band of them. **Once a frame is what this is for**: the same count again uploads the
+     * squares and nothing else, while a different count builds the atlas again. An image of another
+     * size is refused, said once, and its square left clear. See `baseDecals.ts`.
+     */
+    setBaseDecalImages(images: readonly TexImageSource[]): void;
+    /** The decal images into their squares of the atlas bound on the fixture unit. */
+    private uploadDecalImages;
+    /** Whether an image is a decal's square, said once where it is not. */
+    private decalImageFits;
+    /**
+     * The decals laid into the base colours of the draws after it, until the next call, across
+     * passes: each a box, an image of `setBaseDecalImages` and how much of it. **Refused, said once,
+     * where the lit stage has no room** for their thirty-four vectors, and the draws are then marked
+     * by none. See `baseDecals.ts`.
+     */
+    setBaseDecals(decals: readonly BaseDecal[]): void;
+    private baseDecalsFit;
     /**
      * The fixture atlas from the profiles and cookies in hand: the profiles' rows at the bottom, the
      * cookies' tiles on top, one `RGBA16F` texture. See `fixtureAtlas.ts` for the layout.
@@ -1901,6 +1957,11 @@ export declare class WebGL2Renderer implements RendererApi {
      * floats, column-major. A command in the stream, so the draws after it read this pose.
      */
     posePointSkin(skin: GlPointSkin, matrices: Float32Array): void;
+    /**
+     * Rewrite part of a skin in place. A command in the stream like a pose, so the pose after it reads
+     * the rewrite. See `GlPointSkin.rewrite`.
+     */
+    updatePointSkin(skin: GlPointSkin, first: number, data: PointSkinData): void;
     disposePointSkin(skin: GlPointSkin): void;
     /**
      * Rewrite a mesh's colours, on a mesh made `dynamicColors`. The VAO is left alone for the reason
@@ -2186,6 +2247,17 @@ export declare class WebGL2Renderer implements RendererApi {
     private overlayRoomLeft;
     /** Whether the lit shader with the overlay compiled in fits this GPU: counted once. */
     private overlayFits;
+    /**
+     * A material's iridescent overlay, or null where it is refused: malformed, or the lit stage has no
+     * room for its thirty-six vectors. Each said once.
+     */
+    private iridescentOf;
+    /**
+     * Whether a material's glow can be moved and masked: the lit stage has room for its two vectors.
+     * **Refused, said once, where it has not**, and the glow is then drawn still and unmasked, as it
+     * was before it existed.
+     */
+    private emissiveFlowFits;
     /**
      * Whether a material's projection can be drawn: none asked, or the lit stage has the room for its
      * one vector. **Refused, said once, where it has not**, as the overlay is, and the material's
@@ -3901,14 +3973,36 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     tint?: Vec3 | null, 
     /**
-     * Where the mesh was last frame — a `Mover` or a matrix — which this backend takes and ignores.
-     *
-     * Accepted rather than absent so that one scene draws through both renderers unchanged — the
-     * parity rule this repository is built on. Reconstruction is WebGPU's, having no compute stage
-     * here, so there is no motion target for this to be written into, and a mover passed here is
-     * neither read nor advanced.
+     * Where the mesh was last frame, a `Mover` or a matrix, which the temporal resolve follows under
+     * `temporalAa`: a rigid, skinned or rewritten mesh is drawn again into the motion target at the
+     * end of the frame, so its pixels reproject by its own motion and not the camera's alone. See
+     * `motionTarget.ts`; a mover is advanced only where the resolve reads it.
      */
     previousModel?: ReadonlyMat4 | Mover | null): void;
+    /**
+     * The frame's movers drawn into the motion target against its depth, rasterised through the
+     * jittered matrix every geometry upload took (`viewProjFor`) and moved between the unjittered
+     * ones; null where nothing moved or the frame is multisampled, which keeps the camera's motion
+     * and says so once.
+     */
+    private drawMotionPass;
+    /**
+     * Whether a draw now is one the temporal resolve follows: the profile resolves temporally, this is
+     * the frame's own picture between `beginFrame` and `endFrame`, and not a mirror's, a probe's, a
+     * capture's, a shadow's or the view model's. See `motionTarget.ts`.
+     */
+    private followsMotion;
+    /**
+     * A draw's motion for the resolve, decided as WebGPU's `recordDrawMotion` decides it: a mesh
+     * rewritten this frame by its last positions, with or without a mover; a skinned mover by its last
+     * pose; a rigid one by its last model. A cloth draw keeps the camera's motion, said once.
+     */
+    private recordDrawMotion;
+    /**
+     * Keep a dynamic mesh's positions before its frame's first rewrite, where the temporal resolve
+     * follows motion: a rewrite before `beginFrame` belongs to the next frame (`frameOfChange`).
+     */
+    private keepPositionsBefore;
     /**
      * Whether a skin draw now draws its two halves: the profile asked, the frame has not spread its
      * skin yet, this is the frame's own picture — not a mirror's or a probe's, nor an overlay after