@driftengine/core 4.13.5 → 4.14.0

package/CHANGELOG.json

@@ -1,4 +1,66 @@
 [
+  {
+    "version": "4.14.0",
+    "date": "2026-10-18",
+    "entries": [
+      {
+        "kind": "added",
+        "short": "A point skin rewritten in part: `updatePointSkin(skin, first, data)` sends a range of vertices, where a skin that changed shape was made again whole.",
+        "text": "`updatePointSkin(skin, first, data)` rewrites a point skin's vertices from `first` onward, as many as `data` holds, their joints, weights, points and normals, and sends only those: a hand that closes or a face whose picture is taken away moves a few hundred vertices a few times a second, and a skin made again whole for each change was the largest part of a character's drawing on the main thread in the report that asked for this. The pose after the rewrite reads it and a pose before it in the frame does not, on both backends: WebGPU submits a pose it has already recorded before it writes, which a queue write would otherwise reach. The bounds take in what a rewrite reaches and never shrink, since the vertices it replaced may have been the farthest, so a skin changing back and forth settles at the box of all its shapes; a joint none of its vertices named before grows what the device holds for the joints, once. A range outside the mesh, arrays of different lengths and a joint past 511 are refused in words. Measured on an RX 9070 XT (`demo/dev/pointSkin.html?rewrite=grow`): a skin made with its hand on the elbow and rewritten onto a third joint at frame 30 draws what the skin made whole draws, to the pixel on both backends, where the skin left unrewritten differs by 25,968 pixels."
+      },
+      {
+        "kind": "added",
+        "short": "The global medium's sky fill in a colour of its own: `skyFill` beside `skyScatter`, for a scene whose surfaces are lit by more than its flat ambient.",
+        "text": "`setGlobalMedium` takes `skyFill`, the sky's light the medium scatters as a colour of the medium's own, in the units of `Environment.ambient`, which `skyScatter` then scales; absent, the medium scatters the frame's ambient as it did. A scene lit by a sky's cubemap, probes and a bake keeps its flat ambient for what falls outside them, so that ambient is the wrong colour for the sky's light in the air, and setting it to the right one would relight those surfaces too. Both backends upload the one decision (`mediumSkyFill`), and the shader is unchanged. Measured on both backends: a fill equal to the ambient draws what the ambient draws, to the pixel, and a blue fill with the sun scattering nothing raises blue alone at every pixel of the scene and leaves red and green where they were."
+      },
+      {
+        "kind": "added",
+        "short": "A material's glow moved and masked: `emissiveScroll` moves the emissive map by the surface clock, `emissiveMaskLayer` keeps it where a layer's alpha at the mesh's own coordinates says.",
+        "text": "`SurfaceMaterial.emissiveScroll` moves the emissive map alone, `[u, v]` in its own repeats a second by `Environment.surfaceTime`, wrapped to one repeat so a long clock keeps its precision, wherever the map is read: at the mesh's coordinates, at a layer's place or on a projection's planes. `emissiveMaskLayer` names a layer of the emissive array whose alpha multiplies the emission, read at the mesh's own first coordinates before `uScale`, `uOffset`, the layers or a projection, so a glow repeated eight times across a surface is held to cracks a map spanning it once draws, where folding the mask into each vertex's emission spread it over whole faces of a coarse mesh. The mask is alpha because alpha is never decoded as sRGB, and a layer of the emissive array because the lit stage has no texture binding left. A lit switch, `EMISSIVE_FLOW`, compiled in the first time a material asks, two uniform vectors, refused in words on a WebGL2 part with no room. Measured on both backends (`demo/dev/emissiveFlow.html`): the mask takes the glow off exactly half a wall whose stripes repeat sixteen times, a quarter repeat moves them, a whole repeat draws the control, and the two backends agree to the pixel."
+      },
+      {
+        "kind": "added",
+        "short": "A surface's iridescent overlay: a hue turned by the view laid over the base colour before it is lit, from a ramp of colours, a direction, four numbers and a mask.",
+        "text": "`SurfaceMaterial.iridescentOverlay` lays a hue that turns with the view over the base colour before any light reads it, the sheen of a coat running through a spectrum as it turns. With `N` the mapped normal, `V` toward the eye and `u` the mesh's own first coordinate, `x = N·V + u + blend (h − N·V)`, the sheen `h` being `N·H` raised to `contrast` for `H` halfway between `V` and the overlay's `direction`, and 0 where `N·H` is at or below zero; the `ramp` is read at `fract(x · tiling)`, and the base moves toward the overlay blend of itself and that colour by `x · mask · weight`. The mask is a channel of a layer of the material's ORM, model, albedo or emissive array. The lit stage has no texture binding left, so the ramp is thirty-two colours of uniforms, resampled from any length: thirty-six vectors behind a lit switch, `IRIDESCENT_OVERLAY`, which WebGL2 refuses in words on a part with no room. The same arithmetic runs on the CPU, and a square whose every term is constant draws on the device exactly the colour it gives, to the pixel on both backends (`demo/dev/iridescence.html?mode=probe`); a weight of 0 draws what no overlay draws."
+      },
+      {
+        "kind": "added",
+        "short": "Decals laid into the base colour before it is lit: `setBaseDecals` and `setBaseDecalImages`, the glow, roughness and normal left as they are, a material refusing them.",
+        "text": "`setBaseDecals(decals)` lays up to eight decals into the base colour of the draws after it, held across passes until the next call: each a box as a `DecalBox` is, an image of `setBaseDecalImages` read across its face, and an opacity. The base colour moves toward the image's colour by its alpha times the opacity before any light is added, so the surface is then lit and glows as it would; `DecalProjector` multiplies the finished pixel instead, which dims whatever glows under a mark. Images are 128-texel squares in a band of the fixture atlas, since the lit stage has no texture binding left, read as pictures, and rewriting them once a frame costs an upload of the squares. `facingCos` keeps a mark aimed at a floor off the sides of what stands on it, judged by the geometric normal, and `SurfaceMaterial.receivesDecals: false` keeps a surface in the box unmarked. Where a mesh names no emissive colour, its glow takes the base colour from before the decals. A lit switch, `BASE_DECALS`, thirty-four vectors, refused in words on a WebGL2 part with no room. Measured on both backends (`demo/dev/baseDecals.html`): a floor under a black decal at 60% and an orange one draws, to the pixel, a floor built in the colours they make with its glowing stripe glowing as it did."
+      },
+      {
+        "kind": "added",
+        "short": "WebGL2's temporal antialiasing follows what moves: rigid, skinned and rewritten movers drawn again into a motion target the resolve reads in place of the camera's motion.",
+        "text": "Under `temporalAa`, WebGL2's resolve reprojected the last frame by the camera's motion alone, which is exact for a still world and leaves a trail where something moves across a background close to its own colour. A draw naming a `Mover`, or last frame's model matrix, is now drawn again at the end of the frame into a motion target, depth-tested against the frame's own depth, each texel saying where the surface it shows stood last frame; a mesh rewritten with `updateMesh` or a point skin is followed by its kept positions without one. The resolve reads that offset where a mover wrote one and the camera's reprojection everywhere else. Rigid, skinned and rewritten meshes are followed; cloth, instanced batches and a multisampled frame keep the camera's motion, said once. WebGPU follows movers through its reconstruction, as before. Measured on an RX 9070 XT (`demo/dev/moverTaa.html`), a block, a skinned bar and a posed box moving under a still camera: 1,036 pixels differ from the frame without the resolve by 8 levels or more, where the camera's motion alone left 6,500, on ANGLE over Vulkan and over OpenGL alike; with nothing moving, the two agree within a level."
+      },
+      {
+        "kind": "added",
+        "short": "A container back out to glTF: `drft export` writes a `.drft` as a `.glb` that `drft bake` reads back to the same file, and `bakeModel` is the bake as a function.",
+        "text": "`npm run export -- model.drft -o model.glb`, and `drftToGlb` in `@driftengine/assets` under it, write a container as a glTF 2.0 binary, so a baked character or level opens in Blender or any glTF editor and bakes back. What glTF has a field for goes in it: meshes with every attribute, materials with vertex colours, the skeleton with the bone names a game binds by, every clip by name with its keys at their times, attachment points as nodes under their joints, morph targets and the lamps through `KHR_lights_punctual`. What it has no field for, the entity manifest, colliders, regions, placements and the outline, rides in `extras`, which Blender keeps, and the format's other chunks ride as their own bytes; each is used again only while the glTF fields beside it are unchanged, so an artist's edit always wins. A container the baker wrote comes back byte for byte: two fixtures carrying every one of those chunks, and twenty-three of the repository's own models, bake, export and bake back identical, and a scene of ten thousand lamps does too. A kit-built world and a splat capture are refused, since glTF has no form for either, and raw or block-compressed textures go out as PNG. `bakeModel` is the bake `drft bake` runs, moved out of the command so the export, a test and a tool share it."
+      },
+      {
+        "kind": "fixed",
+        "short": "The desktop shell's `drift://` answers a byte range with 206 and its length, so a video seeks, and a missing file is 404; a movie is served as video.",
+        "text": "The packaged desktop app's `drift://` scheme streamed every file whole, with neither a length nor an answer to a `Range` request, so a `<video>` played from its start but could not be sought: a game seeking its movie to keep up with the frame it showed watched it go back to its first frames each time. Every answer now carries `Accept-Ranges` and a `Content-Length`, a single range is answered `206` with `Content-Range`, one starting past the end `416`, and a file that is not there `404` where it was a `200`. Several ranges at once are answered whole, as the RFC allows. `.mp4` and `.webm` are served as video. Measured in the real shell (`drift-package run`) on a twenty-second movie: seeks to 14, 3 and 17.5 seconds land there, where the shell before landed every one at 0."
+      },
+      {
+        "kind": "fixed",
+        "short": "An Android build on Windows from a folder with a backslash escape in its path: the SDK's folder is written escaped into `local.properties`, as a properties file reads it.",
+        "text": "The packager wrote `sdk.dir=` into the staged Android project's `local.properties` with the SDK's folder exactly as found. A properties file reads a backslash as an escape, so on Windows `C:\\tools\\new\\android-sdk` came back with a tab for `\\t`, a new line for `\\n` and every other backslash dropped, and Gradle's lint stopped on a folder nobody named. The value is now written as `Properties.store` writes one: each backslash doubled, a leading space escaped, and everything past printable ASCII as `\\uXXXX`, so a folder under a user name with letters past ASCII reads back as itself whatever encoding opens the file."
+      }
+    ]
+  },
+  {
+    "version": "4.13.6",
+    "date": "2026-10-14",
+    "entries": [
+      {
+        "kind": "fixed",
+        "short": "The packager builds for Android on Windows again: `sdkmanager.bat` and `gradle.bat` start through `cmd.exe`, which Node has required of a batch file since its April 2024 security releases.",
+        "text": "An Android build on Windows stopped at accepting the SDK licences with `spawn EINVAL` and nothing else. Since the April 2024 security releases (CVE-2024-27980: Node 18.20.2, 20.12.2, 21.7.3 and every release after them), Node refuses to start a `.bat` or `.cmd` without a shell, and the packager's Android toolchain on Windows is two of them, `sdkmanager.bat` and `gradle.bat`. A batch file on Windows now starts through `cmd.exe`, with its AutoRun commands left out, every part of the line quoted by hand with its own quotes doubled, and the line passed as it is: an SDK root under a user folder with a space in its name stays one argument, and so does a package such as `platforms;android-35`, whose semicolon a batch file would otherwise read as a separator. Node's own `shell: true` does not quote, so an argument with a space would arrive in two. Every other tool, and a batch file on any other platform, starts as it did."
+      }
+    ]
+  },
   {
     "version": "4.13.5",
     "date": "2026-10-12",

package/README.md

@@ -6,7 +6,7 @@ WebGL2 everywhere else, behind one API, and carries the fixed-step loop, the ren
 input, the scene graph, geometry, text and the whole of `@driftengine/physics`, which it re-exports.
 Everything else is a separate package a game adds when it reaches for it.
 
-**Cost: 951.0 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`,
+**Cost: 966.4 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`,
 which fails the build if the figure drifts by more than 3%.
 
 The manual is at **[driftengine.dev/docs](https://driftengine.dev/docs)**, with an example running

package/dist/index.d.ts

@@ -234,6 +234,9 @@ export type { SurfaceProjection } from './render/surfaceProjection.ts';
 export type { SurfaceLayers } from './render/surfaceLayers.ts';
 export type { SurfaceDetail, SurfaceDetailRegion } from './render/surfaceDetail.ts';
 export { MAX_DETAIL_REGIONS } from './render/surfaceDetail.ts';
+export type { IridescentMaskMap, IridescentOverlay } from './render/iridescentOverlay.ts';
+export type { BaseDecal } from './render/baseDecals.ts';
+export { BASE_DECAL_TILE, MAX_BASE_DECALS } from './render/baseDecals.ts';
 export type { SurfaceLayerLook } from './render/surfaceLayerLooks.ts';
 export { compressedFormatName, isCompressedSource, levelBytes, uploadsCompressed, } from './render/compressedSource.ts';
 export type { BlockFormat, CompressedTextureFormat, CompressedTextureSource, SurfaceSource, } from './render/compressedSource.ts';

package/dist/index.js

@@ -288,6 +288,7 @@ export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.js'
 export { MAX_CLUSTERED_LIGHTS } from './render/clusteredLights.js';
 export { SurfaceTexture } from './render/surfaceTexture.js';
 export { MAX_DETAIL_REGIONS } from './render/surfaceDetail.js';
+export { BASE_DECAL_TILE, MAX_BASE_DECALS } from './render/baseDecals.js';
 /*
  * Compressed textures — BC, ETC2 and EAC, ASTC: the source `createSurfaceTexture` takes as blocks,
  * the one question to ask before handing one over — whether this device takes its format

package/dist/render/backend/api.d.ts

@@ -214,7 +214,7 @@ export interface MeshOptions {
 }
 export type RendererApi = Omit<{
     [K in keyof Renderer]: Renderer[K];
-}, 'gpuTimer' | 'createMesh' | 'createMeshIncremental' | 'updateMesh' | 'updateMeshColors' | 'drawMesh' | 'disposeMesh' | 'drawTranslucentMesh' | 'drawLightVolume' | 'drawFilm' | 'createScatter' | 'drawScatter' | 'uploadScatter' | 'disposeScatter' | 'createInstanced' | 'uploadInstanced' | 'drawInstanced' | 'drawTranslucentInstanced' | 'disposeInstanced' | 'createWater' | 'drawWater' | 'disposeWater' | 'createPlumes' | 'drawPlumes' | 'disposePlumes' | 'setPlumeScale' | 'createCaustics' | 'drawCaustics' | 'disposeCaustics' | 'createParticles' | 'drawParticles' | 'drawDeviceParticles' | 'disposeParticles' | 'createWindStreaks' | 'drawWindStreaks' | 'disposeWindStreaks' | 'createFlock' | 'drawFlock' | 'disposeFlock' | 'createBolts' | 'drawBolts' | 'disposeBolts' | 'createLines' | 'drawLines' | 'disposeLines' | 'createText' | 'setText' | 'setPlate' | 'drawText' | 'textWidth' | 'disposeText' | 'createSdfText' | 'setSdfText' | 'drawSdfText' | 'disposeSdfText' | 'createSurfaceTexture' | 'createSurfaceTextureArray' | 'createLightmap' | 'createSceneCapture' | 'captureScene' | 'updateSurfaceTexture' | 'disposeSurfaceTexture' | 'setSurfaceTexture' | 'setMaterial' | 'prepareMesh' | 'prepareInstanced' | 'setSurfaceOverlay' | 'createClothBinding' | 'createClothParticles' | 'updateClothParticles' | 'setCloth' | 'disposeClothBinding' | 'disposeClothParticles' | 'createPointSkin' | 'posePointSkin' | 'disposePointSkin'> & {
+}, 'gpuTimer' | 'createMesh' | 'createMeshIncremental' | 'updateMesh' | 'updateMeshColors' | 'drawMesh' | 'disposeMesh' | 'drawTranslucentMesh' | 'drawLightVolume' | 'drawFilm' | 'createScatter' | 'drawScatter' | 'uploadScatter' | 'disposeScatter' | 'createInstanced' | 'uploadInstanced' | 'drawInstanced' | 'drawTranslucentInstanced' | 'disposeInstanced' | 'createWater' | 'drawWater' | 'disposeWater' | 'createPlumes' | 'drawPlumes' | 'disposePlumes' | 'setPlumeScale' | 'createCaustics' | 'drawCaustics' | 'disposeCaustics' | 'createParticles' | 'drawParticles' | 'drawDeviceParticles' | 'disposeParticles' | 'createWindStreaks' | 'drawWindStreaks' | 'disposeWindStreaks' | 'createFlock' | 'drawFlock' | 'disposeFlock' | 'createBolts' | 'drawBolts' | 'disposeBolts' | 'createLines' | 'drawLines' | 'disposeLines' | 'createText' | 'setText' | 'setPlate' | 'drawText' | 'textWidth' | 'disposeText' | 'createSdfText' | 'setSdfText' | 'drawSdfText' | 'disposeSdfText' | 'createSurfaceTexture' | 'createSurfaceTextureArray' | 'createLightmap' | 'createSceneCapture' | 'captureScene' | 'updateSurfaceTexture' | 'disposeSurfaceTexture' | 'setSurfaceTexture' | 'setMaterial' | 'prepareMesh' | 'prepareInstanced' | 'setSurfaceOverlay' | 'createClothBinding' | 'createClothParticles' | 'updateClothParticles' | 'setCloth' | 'disposeClothBinding' | 'disposeClothParticles' | 'createPointSkin' | 'posePointSkin' | 'updatePointSkin' | 'disposePointSkin'> & {
     /**
      * A mesh's cloth binding: which simulation triangle each of its vertices follows, where on it and
      * by how much (`ClothBindingData`). The mesh must be skinned — a binding blends each vertex
@@ -260,6 +260,20 @@ export type RendererApi = Omit<{
      * as it moves without the posed vertices ever coming back to the CPU.
      */
     posePointSkin(skin: PointSkinHandle, matrices: Float32Array): void;
+    /**
+     * Rewrite part of a skin in place: vertices `first` onward, as many as `data` holds (its four
+     * arrays a range's worth, as `createPointSkin` takes them whole), their joints, weights, points and
+     * normals. **For a skin that changes shape a few hundred vertices at a time**, a hand closing or a
+     * face's picture taken away, which was made again whole for each change: the largest part of a
+     * character's drawing on the main thread in the report that asked for this.
+     *
+     * **The pose after it reads the rewrite, and a pose before it in the frame does not**, on both
+     * backends: WebGPU submits a pose it has already recorded before it writes. The mesh's bounds take
+     * in what the rewrite reaches and never shrink, since the vertices it replaced may have been the
+     * farthest; `createPointSkin` measures a skin afresh. A range outside the mesh, arrays of
+     * different lengths and a joint past 511 are refused in words, naming the mesh's own vertices.
+     */
+    updatePointSkin(skin: PointSkinHandle, first: number, data: PointSkinData): void;
     disposePointSkin(skin: PointSkinHandle): void;
     /**
      * What the following draws lay over their surfaces beyond their materials — a rim of light, a
@@ -660,8 +674,10 @@ export type RendererApi = Omit<{
      * depth, which is exactly right for anything that did not move and wrong in proportion to how
      * far a mover moved.
      *
-     * **Only a reconstruction reads it**, and only on WebGPU. A mover drawn twice in one frame is
-     * two objects wearing one identity: the second draw is warned about once and records no motion.
+     * **Read by a reconstruction on WebGPU, and by `temporalAa` on WebGL2**, which draws the movers
+     * again into a motion target at the end of the frame (`backend/webgl2/motionTarget.ts`). A mover
+     * drawn twice in one frame is two objects wearing one identity: the second draw is warned about
+     * once and records no motion.
      * Instanced batches and meshes rewritten with `updateMesh` need none — the batch and the mesh
      * are their own identity.
      */

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

@@ -0,0 +1,39 @@
+import type { Mesh } from '../../mesh.ts';
+export declare class GlMotionPass {
+    private readonly programs;
+    private texture;
+    private framebuffer;
+    private width;
+    private height;
+    private depth;
+    /** This frame's palette and last frame's, uploaded record by record. */
+    private readonly paletteNow;
+    private readonly paletteWas;
+    /** The frame's movers: mesh, kind, two matrices, two palettes. Grown, never shrunk. */
+    private readonly meshes;
+    private kinds;
+    private matrices;
+    private readonly palettes;
+    private readonly wasPalettes;
+    private count;
+    /** A frame states its movers afresh. */
+    reset(): void;
+    get recorded(): number;
+    /** A rigid mover under last frame's model. */
+    recordRigid(mesh: Mesh, model: ArrayLike<number>, wasModel: ArrayLike<number>): void;
+    /** A skinned mover under last frame's model and palette. */
+    recordSkinned(mesh: Mesh, model: ArrayLike<number>, wasModel: ArrayLike<number>, palette: Float32Array, wasPalette: Float32Array): void;
+    /** A mesh rewritten this frame, under last frame's positions and model. */
+    recordDynamic(mesh: Mesh, model: ArrayLike<number>, wasModel: ArrayLike<number>): void;
+    private take;
+    /**
+     * Draw the recorded movers into the motion target against `depth`, and return the target; null
+     * where nothing was recorded. Leaves the framebuffer, program and array unbound, the depth test on
+     * with the frame's compare and writes on, no offset, and the palette units holding its palettes.
+     */
+    draw(gl: WebGL2RenderingContext, depth: WebGLTexture, width: number, height: number, reversedDepth: boolean, jittered: Float32Array, viewProj: Float32Array, wasViewProj: Float32Array): WebGLTexture | null;
+    private programFor;
+    /** An `RGBA16F` target the frame's size, its depth the frame's own attachment. */
+    private ensureTarget;
+    dispose(gl: WebGL2RenderingContext): void;
+}

package/dist/render/backend/webgl2/motionTarget.js

@@ -0,0 +1,254 @@
+/**
+ * Where every mover was last frame, on WebGL2: the motion its temporal resolve follows.
+ *
+ * **What it is for.** The resolve reprojects last frame's picture by the camera's motion, read
+ * back from the depth, which is exact for a world standing still and wrong for whatever moved: a
+ * head turning or a boot in a kick leaves a trail of its earlier pixels. WebGPU's reconstruction
+ * follows each mover's own motion through `shaders/recon/motion.wgsl.ts`; this is the same idea
+ * for the other backend. The frame's movers are recorded as they are drawn and drawn again at the
+ * end of the frame into a target of their own, each texel saying where the surface it shows stood
+ * last frame: the offset to it on screen, its distance from last frame's eye, and that it is a
+ * mover's. The resolve reads it where a mover's texel is and the camera's reprojection everywhere
+ * else.
+ *
+ * **Three kinds**, as `recordDrawMotion` on WebGPU decides them: a rigid mesh under last frame's
+ * model; a skinned one under last frame's palette as well; and a mesh rewritten in place, whose
+ * last frame's positions `Mesh.keepPrevious` copied before the first rewrite of the frame. A cloth
+ * draw and an instanced batch keep the camera's motion here, which the renderer says once.
+ *
+ * **Drawn against the frame's own depth**, attached and never written, with the test passing at its
+ * own surface and a nudge toward the eye to forgive the last bit of arithmetic: rasterised through
+ * the frame's jittered matrix so it covers the pixels the surface did, its motion taken between the
+ * unjittered ones. **What it gives up**: a mover hidden behind glass or seen in a mirror keeps the
+ * camera's motion; a multisampled frame keeps it everywhere; and a morph target's change of shape
+ * is not followed.
+ */
+import { MORPH_DELTA_TEXTURE_UNIT, SKIN_PALETTE_TEXTURE_UNIT } from '../../lightBudget.js';
+import { compileProgram, uniformLocations } from '../../shader.js';
+import { SkinPaletteTexture } from './skinPaletteTexture.js';
+const RIGID = 0;
+const SKINNED = 1;
+const DYNAMIC = 2;
+/** The vertex stage for one kind, skinned with eight influences where `eight` says. */
+function vertexSource(kind, eight) {
+    return /* glsl */ `#version 300 es
+precision highp float;
+precision highp int;
+layout(location = 0) in vec3 aPosition;
+layout(location = 1) in vec3 aWas;
+layout(location = 11) in vec4 aJoints;
+layout(location = 12) in vec4 aWeights;
+layout(location = 14) in vec4 aJoints2;
+layout(location = 15) in vec4 aWeights2;
+uniform mat4 uModel;
+uniform mat4 uWasModel;
+uniform mat4 uJittered;
+uniform mat4 uViewProj;
+uniform mat4 uWasViewProj;
+uniform highp sampler2D uPaletteNow;
+uniform highp sampler2D uPaletteWas;
+out vec4 vNow;
+out vec4 vWas;
+
+mat4 joint(highp sampler2D palette, float index) {
+  int x = int(index) * 4;
+  return mat4(
+    texelFetch(palette, ivec2(x, 0), 0),
+    texelFetch(palette, ivec2(x + 1, 0), 0),
+    texelFetch(palette, ivec2(x + 2, 0), 0),
+    texelFetch(palette, ivec2(x + 3, 0), 0));
+}
+
+/* The same blend as skinning.ts, joint by joint, so a skinned mover lands where its draw did. */
+mat4 skin(highp sampler2D palette) {
+  mat4 m = joint(palette, aJoints.x) * aWeights.x + joint(palette, aJoints.y) * aWeights.y
+    + joint(palette, aJoints.z) * aWeights.z + joint(palette, aJoints.w) * aWeights.w;
+  ${eight
+        ? `m += joint(palette, aJoints2.x) * aWeights2.x + joint(palette, aJoints2.y) * aWeights2.y
+    + joint(palette, aJoints2.z) * aWeights2.z + joint(palette, aJoints2.w) * aWeights2.w;`
+        : ''}
+  return m;
+}
+
+void main() {
+  vec4 now = vec4(aPosition, 1.0);
+  vec4 was = now;
+  ${kind === SKINNED
+        ? 'was = skin(uPaletteWas) * now;\n  now = skin(uPaletteNow) * now;'
+        : kind === DYNAMIC
+            ? 'was = vec4(aWas, 1.0);'
+            : ''}
+  vec4 world = uModel * now;
+  gl_Position = uJittered * world;
+  vNow = uViewProj * world;
+  vWas = uWasViewProj * (uWasModel * was);
+}
+`;
+}
+const FRAGMENT = /* glsl */ `#version 300 es
+precision highp float;
+in vec4 vNow;
+in vec4 vWas;
+out vec4 motion;
+/* The offset on screen to where this surface stood, its distance from last frame's eye, and 1. */
+void main() {
+  vec2 now = vNow.xy / vNow.w * 0.5 + 0.5;
+  vec2 was = vWas.xy / max(vWas.w, 1e-6) * 0.5 + 0.5;
+  motion = vec4(was - now, vWas.w, 1.0);
+}
+`;
+export class GlMotionPass {
+    programs = new Map();
+    texture = null;
+    framebuffer = null;
+    width = 0;
+    height = 0;
+    depth = null;
+    /** This frame's palette and last frame's, uploaded record by record. */
+    paletteNow = new SkinPaletteTexture();
+    paletteWas = new SkinPaletteTexture();
+    /** The frame's movers: mesh, kind, two matrices, two palettes. Grown, never shrunk. */
+    meshes = [];
+    kinds = new Uint8Array(16);
+    matrices = new Float32Array(16 * 32);
+    palettes = [];
+    wasPalettes = [];
+    count = 0;
+    /** A frame states its movers afresh. */
+    reset() {
+        this.count = 0;
+    }
+    get recorded() {
+        return this.count;
+    }
+    /** A rigid mover under last frame's model. */
+    recordRigid(mesh, model, wasModel) {
+        this.take(mesh, RIGID, model, wasModel, null, null);
+    }
+    /** A skinned mover under last frame's model and palette. */
+    recordSkinned(mesh, model, wasModel, palette, wasPalette) {
+        this.take(mesh, SKINNED, model, wasModel, palette, wasPalette);
+    }
+    /** A mesh rewritten this frame, under last frame's positions and model. */
+    recordDynamic(mesh, model, wasModel) {
+        this.take(mesh, DYNAMIC, model, wasModel, null, null);
+    }
+    take(mesh, kind, model, wasModel, palette, wasPalette) {
+        const at = this.count;
+        if (at >= this.kinds.length) {
+            const kinds = new Uint8Array(this.kinds.length * 2);
+            kinds.set(this.kinds);
+            this.kinds = kinds;
+            const matrices = new Float32Array(this.matrices.length * 2);
+            matrices.set(this.matrices);
+            this.matrices = matrices;
+        }
+        this.meshes[at] = mesh;
+        this.kinds[at] = kind;
+        this.matrices.set(model, at * 32);
+        this.matrices.set(wasModel, at * 32 + 16);
+        this.palettes[at] = palette;
+        this.wasPalettes[at] = wasPalette;
+        this.count = at + 1;
+    }
+    /**
+     * Draw the recorded movers into the motion target against `depth`, and return the target; null
+     * where nothing was recorded. Leaves the framebuffer, program and array unbound, the depth test on
+     * with the frame's compare and writes on, no offset, and the palette units holding its palettes.
+     */
+    draw(gl, depth, width, height, reversedDepth, jittered, viewProj, wasViewProj) {
+        if (this.count === 0)
+            return null;
+        this.ensureTarget(gl, depth, width, height);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.viewport(0, 0, width, height);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.enable(gl.DEPTH_TEST);
+        gl.depthMask(false);
+        gl.depthFunc(reversedDepth ? gl.GEQUAL : gl.LEQUAL);
+        /* Toward the eye, which is a larger depth when depth is reversed. */
+        gl.enable(gl.POLYGON_OFFSET_FILL);
+        gl.polygonOffset(reversedDepth ? 1 : -1, reversedDepth ? 4 : -4);
+        gl.disable(gl.BLEND);
+        gl.disable(gl.CULL_FACE);
+        for (let i = 0; i < this.count; i++) {
+            const mesh = this.meshes[i];
+            const kind = this.kinds[i];
+            const eight = kind === SKINNED && mesh.isSkinnedEight;
+            const { program, uniforms } = this.programFor(gl, kind, eight);
+            gl.useProgram(program);
+            gl.uniformMatrix4fv(uniforms['uJittered'] ?? null, false, jittered);
+            gl.uniformMatrix4fv(uniforms['uViewProj'] ?? null, false, viewProj);
+            gl.uniformMatrix4fv(uniforms['uWasViewProj'] ?? null, false, wasViewProj);
+            gl.uniformMatrix4fv(uniforms['uModel'] ?? null, false, this.matrices, i * 32, 16);
+            gl.uniformMatrix4fv(uniforms['uWasModel'] ?? null, false, this.matrices, i * 32 + 16, 16);
+            if (kind === SKINNED) {
+                /* On the units a skinned draw binds its palette and morph on, which every one binds again
+                   for itself: nothing the lit pass keeps across frames is moved. */
+                gl.activeTexture(gl.TEXTURE0 + SKIN_PALETTE_TEXTURE_UNIT);
+                this.paletteNow.update(gl, this.palettes[i]);
+                gl.activeTexture(gl.TEXTURE0 + MORPH_DELTA_TEXTURE_UNIT);
+                this.paletteWas.update(gl, this.wasPalettes[i]);
+                gl.uniform1i(uniforms['uPaletteNow'] ?? null, SKIN_PALETTE_TEXTURE_UNIT);
+                gl.uniform1i(uniforms['uPaletteWas'] ?? null, MORPH_DELTA_TEXTURE_UNIT);
+            }
+            mesh.drawMotion(gl, kind === DYNAMIC);
+        }
+        gl.disable(gl.POLYGON_OFFSET_FILL);
+        gl.polygonOffset(0, 0);
+        gl.depthMask(true);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.useProgram(null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        return this.texture;
+    }
+    programFor(gl, kind, eight) {
+        const key = kind * 2 + (eight ? 1 : 0);
+        const held = this.programs.get(key);
+        if (held !== undefined)
+            return held;
+        const program = compileProgram(gl, vertexSource(kind, eight), FRAGMENT, `motion.${key}`);
+        const made = { program, uniforms: uniformLocations(gl, program, `motion.${key}`) };
+        this.programs.set(key, made);
+        return made;
+    }
+    /** An `RGBA16F` target the frame's size, its depth the frame's own attachment. */
+    ensureTarget(gl, depth, width, height) {
+        if (this.texture !== null && this.width === width && this.height === height) {
+            if (this.depth === depth)
+                return;
+        }
+        else {
+            if (this.texture !== null)
+                gl.deleteTexture(this.texture);
+            this.texture = gl.createTexture();
+            gl.bindTexture(gl.TEXTURE_2D, this.texture);
+            gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA16F, width, height);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+            gl.bindTexture(gl.TEXTURE_2D, null);
+            this.width = width;
+            this.height = height;
+        }
+        this.framebuffer ??= gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.texture, 0);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depth, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        this.depth = depth;
+    }
+    dispose(gl) {
+        for (const { program } of this.programs.values())
+            gl.deleteProgram(program);
+        this.programs.clear();
+        if (this.texture !== null)
+            gl.deleteTexture(this.texture);
+        if (this.framebuffer !== null)
+            gl.deleteFramebuffer(this.framebuffer);
+        this.texture = null;
+        this.framebuffer = null;
+    }
+}

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

@@ -8,13 +8,23 @@ export interface PointSkinPose {
 export declare function createPointSkinPose(gl: WebGL2RenderingContext): PointSkinPose;
 export declare class GlPointSkin {
     readonly mesh: Mesh;
-    readonly reach: PointSkinReach;
+    /** Widened by each rewrite, never narrowed: see `widenReach`. */
+    reach: PointSkinReach;
     private readonly count;
     private readonly vao;
+    /** Joints, weights, points and normals, in that order. */
     private readonly buffers;
-    private readonly joints;
-    private readonly width;
+    private joints;
+    private width;
     constructor(gl: WebGL2RenderingContext, mesh: Mesh, data: PointSkinData);
+    /**
+     * Rewrite vertices `first` onward, as many as `data` holds, in place: their four arrays sent at
+     * their offsets and nothing else. A command in the stream like a pose, so the pose after it reads
+     * the rewrite and one before it does not. A joint none of the skin named before grows the joint
+     * texture, which is made again for it; a skin settles at the joints its shapes name, so that is
+     * rare after its first changes.
+     */
+    rewrite(gl: WebGL2RenderingContext, first: number, data: PointSkinData): void;
     /** One buffer, read as each `[location, size, stride, offset]` says. */
     private attach;
     /** Pose every vertex into the mesh's buffers now, and undo every binding it made. */

package/dist/render/backend/webgl2/pointSkinFeedback.js

@@ -9,7 +9,7 @@
  * left bound for feedback while a draw reads it as vertices is an error WebGL2 raises at the draw.
  */
 import { POINT_SKIN_TEXTURE_UNIT } from '../../lightBudget.js';
-import { reachOf } from '../../pointSkin.js';
+import { reachOf, widenReach } from '../../pointSkin.js';
 import { compileProgram } from '../../shader.js';
 const POSE_VERT = /* glsl */ `#version 300 es
 precision highp float;
@@ -70,9 +70,11 @@ export function createPointSkinPose(gl) {
 }
 export class GlPointSkin {
     mesh;
+    /** Widened by each rewrite, never narrowed: see `widenReach`. */
     reach;
     count;
     vao;
+    /** Joints, weights, points and normals, in that order. */
     buffers = [];
     joints;
     width;
@@ -96,18 +98,36 @@ export class GlPointSkin {
         this.attach(gl, data.normals, [[6, 3, 12, 0]]);
         gl.bindVertexArray(null);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        /* One row, four texels a joint, as the skin palette is. */
         this.width = Math.max(1, this.reach.joints * 4);
-        const joints = gl.createTexture();
-        if (joints === null)
-            throw new Error('createTexture failed');
-        this.joints = joints;
-        gl.activeTexture(gl.TEXTURE0 + POINT_SKIN_TEXTURE_UNIT);
-        gl.bindTexture(gl.TEXTURE_2D, joints);
-        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, this.width, 1);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-        gl.bindTexture(gl.TEXTURE_2D, null);
+        this.joints = jointTexture(gl, this.width);
+    }
+    /**
+     * Rewrite vertices `first` onward, as many as `data` holds, in place: their four arrays sent at
+     * their offsets and nothing else. A command in the stream like a pose, so the pose after it reads
+     * the rewrite and one before it does not. A joint none of the skin named before grows the joint
+     * texture, which is made again for it; a skin settles at the joints its shapes name, so that is
+     * rare after its first changes.
+     */
+    rewrite(gl, first, data) {
+        const sent = [
+            [data.joints, 16],
+            [data.weights, 16],
+            [data.points, 48],
+            [data.normals, 12],
+        ];
+        for (let at = 0; at < sent.length; at++) {
+            const [values, stride] = sent[at];
+            gl.bindBuffer(gl.ARRAY_BUFFER, this.buffers[at]);
+            gl.bufferSubData(gl.ARRAY_BUFFER, first * stride, values);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.reach = widenReach(this.reach, data);
+        const width = Math.max(1, this.reach.joints * 4);
+        if (width > this.width) {
+            gl.deleteTexture(this.joints);
+            this.width = width;
+            this.joints = jointTexture(gl, width);
+        }
     }
     /** One buffer, read as each `[location, size, stride, offset]` says. */
     attach(gl, values, reads) {
@@ -157,3 +177,16 @@ export class GlPointSkin {
         gl.deleteVertexArray(this.vao);
     }
 }
+/** One row, four texels a joint, as the skin palette is. */
+function jointTexture(gl, width) {
+    const joints = gl.createTexture();
+    if (joints === null)
+        throw new Error('createTexture failed');
+    gl.activeTexture(gl.TEXTURE0 + POINT_SKIN_TEXTURE_UNIT);
+    gl.bindTexture(gl.TEXTURE_2D, joints);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, width, 1);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    return joints;
+}