@driftengine/core 4.8.3 → 4.8.5

package/dist/render/lightBudget.d.ts

@@ -213,6 +213,28 @@ export declare const POINT_GLASS_TINT_TEXTURE_UNIT: number;
  * to free the sampler this takes, so the lit stage still keeps one of its sixteen spare.
  */
 export declare const SURFACE_EFFECTS_TEXTURE_UNIT: number;
+/**
+ * A cloth binding's three vertex-stage textures — the binding, the particles now, the particles at
+ * rest (`clothBinding.ts`). Vertex samplers, so they count against the vertex stage's own sixteen
+ * beside the palette and the morph deltas, not the lit stage's; numbered past every fragment unit,
+ * inside the combined pool of thirty-two.
+ */
+export declare const CLOTH_BINDING_TEXTURE_UNIT: number;
+export declare const CLOTH_PARTICLES_TEXTURE_UNIT: number;
+export declare const CLOTH_REST_TEXTURE_UNIT: number;
+/**
+ * A shading model's own channels (`shaders/flat/models.ts`), the lit stage's **sixteenth** fragment
+ * sampler — exactly what WebGL2 guarantees a stage, which `textureUnitBudget.test.ts` counts from
+ * the source. Numbered past the cloth's vertex units, inside the combined pool of thirty-two.
+ */
+export declare const MODEL_MAP_TEXTURE_UNIT: number;
+/**
+ * The two units skin's screen-space blur reads on WebGL2 — its target and the frame's depth — past
+ * every unit a lit program binds, so spreading skin in the middle of a frame unbinds nothing the
+ * draws after it sample. WebGL2 guarantees thirty-two.
+ */
+export declare const SKIN_BLUR_TEXTURE_UNIT: number;
+export declare const SKIN_BLUR_DEPTH_UNIT: number;
 /**
  * A cookie's tile, in texels a side.
  *

package/dist/render/lightBudget.js

@@ -211,6 +211,28 @@ export const POINT_GLASS_TINT_TEXTURE_UNIT = SUN_GLASS_TINT_TEXTURE_UNIT + 1;
  * to free the sampler this takes, so the lit stage still keeps one of its sixteen spare.
  */
 export const SURFACE_EFFECTS_TEXTURE_UNIT = POINT_GLASS_TINT_TEXTURE_UNIT + 1;
+/**
+ * A cloth binding's three vertex-stage textures — the binding, the particles now, the particles at
+ * rest (`clothBinding.ts`). Vertex samplers, so they count against the vertex stage's own sixteen
+ * beside the palette and the morph deltas, not the lit stage's; numbered past every fragment unit,
+ * inside the combined pool of thirty-two.
+ */
+export const CLOTH_BINDING_TEXTURE_UNIT = SURFACE_EFFECTS_TEXTURE_UNIT + 1;
+export const CLOTH_PARTICLES_TEXTURE_UNIT = CLOTH_BINDING_TEXTURE_UNIT + 1;
+export const CLOTH_REST_TEXTURE_UNIT = CLOTH_PARTICLES_TEXTURE_UNIT + 1;
+/**
+ * A shading model's own channels (`shaders/flat/models.ts`), the lit stage's **sixteenth** fragment
+ * sampler — exactly what WebGL2 guarantees a stage, which `textureUnitBudget.test.ts` counts from
+ * the source. Numbered past the cloth's vertex units, inside the combined pool of thirty-two.
+ */
+export const MODEL_MAP_TEXTURE_UNIT = CLOTH_REST_TEXTURE_UNIT + 1;
+/**
+ * The two units skin's screen-space blur reads on WebGL2 — its target and the frame's depth — past
+ * every unit a lit program binds, so spreading skin in the middle of a frame unbinds nothing the
+ * draws after it sample. WebGL2 guarantees thirty-two.
+ */
+export const SKIN_BLUR_TEXTURE_UNIT = MODEL_MAP_TEXTURE_UNIT + 1;
+export const SKIN_BLUR_DEPTH_UNIT = SKIN_BLUR_TEXTURE_UNIT + 1;
 /**
  * A cookie's tile, in texels a side.
  *

package/dist/render/mesh.d.ts

@@ -56,8 +56,15 @@ export declare class Mesh {
     readonly bounds: Bounds;
     /** Whether this mesh carries a rig, which decides which flat program draws it. */
     readonly isSkinned: boolean;
+    /**
+     * Whether its rig moves a vertex by eight influences rather than four, which decides whether the
+     * skinned program it takes is built with `SKIN_EIGHT` on. See `skinning.ts`.
+     */
+    readonly isSkinnedEight: boolean;
     /** Whether it has texture coordinates, without which a material's maps read one texel. */
     readonly hasUvs: boolean;
+    /** How many vertices it has, which a cloth binding is checked against. */
+    readonly vertexCount: number;
     /**
      * This mesh's morph deltas, or null for geometry that does not deform.
      *

package/dist/render/mesh.js

@@ -48,6 +48,12 @@ const ATTR_JOINTS = 11;
  */
 const ATTR_CHANNEL = 13;
 const ATTR_WEIGHTS = 12;
+/*
+ * The second four influences, at the last two locations: a skinned draw spends 11, 12 and 13 and an
+ * instanced one cannot skin, so 14 and 15 are free exactly where they are read. See skinning.ts.
+ */
+const ATTR_JOINTS2 = 14;
+const ATTR_WEIGHTS2 = 15;
 /**
  * One absent attribute's constant, at the width the table gave it.
  *
@@ -123,8 +129,15 @@ export class Mesh {
     bounds = createBounds();
     /** Whether this mesh carries a rig, which decides which flat program draws it. */
     isSkinned;
+    /**
+     * Whether its rig moves a vertex by eight influences rather than four, which decides whether the
+     * skinned program it takes is built with `SKIN_EIGHT` on. See `skinning.ts`.
+     */
+    isSkinnedEight;
     /** Whether it has texture coordinates, without which a material's maps read one texel. */
     hasUvs;
+    /** How many vertices it has, which a cloth binding is checked against. */
+    vertexCount;
     /**
      * This mesh's morph deltas, or null for geometry that does not deform.
      *
@@ -260,6 +273,7 @@ export class Mesh {
          * takes; see `WebGL2Renderer.drawMesh`.
          */
         this.isSkinned = data.joints !== undefined;
+        this.vertexCount = data.positions.length / 3;
         this.morph =
             data.morphTargets === undefined || data.morphTargetCount === undefined
                 ? null
@@ -272,6 +286,16 @@ export class Mesh {
             this.attachAttribute(gl, ATTR_JOINTS, data.joints, 4);
             this.attachAttribute(gl, ATTR_WEIGHTS, data.weights, 4);
         }
+        /* The fifth to eighth influences, or zeros, which add nothing. See `isSkinnedEight`. */
+        this.isSkinnedEight = this.isSkinned && data.joints2 !== undefined;
+        if (data.joints2 === undefined || data.weights2 === undefined) {
+            this.constants.push({ location: ATTR_JOINTS2, value: ABSENT_ATTRIBUTE['joints2'] });
+            this.constants.push({ location: ATTR_WEIGHTS2, value: ABSENT_ATTRIBUTE['weights2'] });
+        }
+        else {
+            this.attachAttribute(gl, ATTR_JOINTS2, data.joints2, 4);
+            this.attachAttribute(gl, ATTR_WEIGHTS2, data.weights2, 4);
+        }
         this.hasTangents = data.tangents !== undefined;
         if (data.tangents === undefined) {
             gl.disableVertexAttribArray(ATTR_TANGENT);

package/dist/render/recon/motionVectors.d.ts

@@ -42,9 +42,11 @@ export declare function cameraMotion(reprojection: ArrayLike<number>, u: number,
  */
 export declare function objectMotion(currentClip: ArrayLike<number>, previousClip: ArrayLike<number>, out: Float32Array): boolean;
 /**
- * A vertex through a skin palette: the four joints' matrices weighted and summed, then applied —
+ * A vertex through a skin palette: the joints' matrices weighted and summed, then applied —
  * `SKINNING_GLSL`'s `skinMatrix()` times the position, in model space, before the model matrix.
- * `palette` is sixteen floats a joint, column-major. Written into `out`, four values.
+ * `palette` is sixteen floats a joint, column-major. `joints` and `weights` hold four influences, or
+ * eight for a mesh with a second set (the first set then the second, as the shader reads them with
+ * `SKIN_EIGHT` on). Written into `out`, four values.
  */
 export declare function skinVertex(palette: ArrayLike<number>, joints: ArrayLike<number>, weights: ArrayLike<number>, position: ArrayLike<number>, out: Float64Array): void;
 /**

package/dist/render/recon/motionVectors.js

@@ -68,9 +68,11 @@ export function objectMotion(currentClip, previousClip, out) {
     return true;
 }
 /**
- * A vertex through a skin palette: the four joints' matrices weighted and summed, then applied —
+ * A vertex through a skin palette: the joints' matrices weighted and summed, then applied —
  * `SKINNING_GLSL`'s `skinMatrix()` times the position, in model space, before the model matrix.
- * `palette` is sixteen floats a joint, column-major. Written into `out`, four values.
+ * `palette` is sixteen floats a joint, column-major. `joints` and `weights` hold four influences, or
+ * eight for a mesh with a second set (the first set then the second, as the shader reads them with
+ * `SKIN_EIGHT` on). Written into `out`, four values.
  */
 export function skinVertex(palette, joints, weights, position, out) {
     const px = position[0];
@@ -80,7 +82,8 @@ export function skinVertex(palette, joints, weights, position, out) {
     out[1] = 0;
     out[2] = 0;
     out[3] = 0;
-    for (let influence = 0; influence < 4; influence += 1) {
+    const influences = Math.min(joints.length, weights.length, 8);
+    for (let influence = 0; influence < influences; influence += 1) {
         const weight = weights[influence];
         if (weight === 0)
             continue;

package/dist/render/renderQuality.d.ts

@@ -37,6 +37,8 @@ export type DirectionalShadowDepthLayers = 1 | 2;
 export type WaterReflectionFilterTaps = 1 | 5 | 9;
 /** How light through glass is coloured: see `RenderQuality.glassShadows`. */
 export type GlassShadows = 'full' | 'half' | 'off';
+/** How light scattered beneath skin is drawn: see `RenderQuality.skinScattering`. */
+export type SkinScattering = 'pre-integrated' | 'screen-space';
 export interface RenderQuality {
     /**
      * The transfer curve applied at the end of every shaded pass.
@@ -201,6 +203,24 @@ export interface RenderQuality {
      * lot of glass; that is what `'half'` is for. See `glassShadow.ts`.
      */
     readonly glassShadows: GlassShadows;
+    /**
+     * How light that scatters beneath skin is drawn, for a material whose model is `skinModel`.
+     *
+     * **`'pre-integrated'`, the default**: the lit stage's fit alone — a terminator softened and
+     * reddened by the surface's curvature, light through thin parts, a penumbra each channel crosses
+     * as far as it travels — at no cost beyond the skin pipeline itself. **`'screen-space'`** adds
+     * Burley's blur in the picture as well: a skin draw writes its diffuse to a target of its own (it
+     * is drawn twice to do so), which is spread across the pixels its scatter distance covers and
+     * added back before anything blended is drawn, so light crosses a shadow's edge and a nostril's
+     * rim in the picture rather than in a fit. See `skinBlur.ts`.
+     *
+     * Construction-time: two half-float targets the size of the frame, and a multisampled one under
+     * multisampling, made at the first skin draw. It needs the composite (`screenEffects`), which is
+     * where the frame is still linear light to add to; without one, skin is pre-integrated and the
+     * renderer says so once. What would make the default wrong is a close-up face that reads as wax
+     * at a shadow's edge — that is what the blur is for.
+     */
+    readonly skinScattering: SkinScattering;
     /** Horizontal world-space reach over which a directional shadow dissolves. */
     readonly directionalShadowMaxDistance: number;
     /** Maximum horizontal projection per vertical metre before low-angle shadows vanish. */

package/dist/render/renderQuality.js

@@ -63,6 +63,7 @@ export const DEFAULT_RENDER_QUALITY = Object.freeze({
     lightVolumeSamples: 32,
     directionalShadowDepthLayers: 2,
     glassShadows: 'full',
+    skinScattering: 'pre-integrated',
     directionalShadowMaxDistance: 6,
     directionalShadowMaxSlope: 3,
     pointShadowRebakeDistance: 0.001,
@@ -215,6 +216,7 @@ export function resolveRenderQuality(options = {}) {
         lightVolumeSamples: options.lightVolumeSamples ?? DEFAULT_RENDER_QUALITY.lightVolumeSamples,
         directionalShadowDepthLayers: options.directionalShadowDepthLayers ?? DEFAULT_RENDER_QUALITY.directionalShadowDepthLayers,
         glassShadows: options.glassShadows ?? DEFAULT_RENDER_QUALITY.glassShadows,
+        skinScattering: options.skinScattering ?? DEFAULT_RENDER_QUALITY.skinScattering,
         directionalShadowMaxDistance: options.directionalShadowMaxDistance ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxDistance,
         directionalShadowMaxSlope: options.directionalShadowMaxSlope ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxSlope,
         pointShadowRebakeDistance: options.pointShadowRebakeDistance ?? DEFAULT_RENDER_QUALITY.pointShadowRebakeDistance,
@@ -312,6 +314,9 @@ export function resolveRenderQuality(options = {}) {
         quality.glassShadows !== 'off') {
         throw new Error(`RenderQuality.glassShadows must be 'full', 'half' or 'off', got ${String(quality.glassShadows)}`);
     }
+    if (quality.skinScattering !== 'pre-integrated' && quality.skinScattering !== 'screen-space') {
+        throw new Error(`RenderQuality.skinScattering must be 'pre-integrated' or 'screen-space', got ${String(quality.skinScattering)}`);
+    }
     if (quality.plumeNoiseOctaves > 3) {
         throw new Error(`RenderQuality.plumeNoiseOctaves must be <= 3, got ${quality.plumeNoiseOctaves}`);
     }

package/dist/render/rendererHarness.js

@@ -61,6 +61,10 @@ export function recordingGl(options = {}) {
         NONE: 0,
         ALWAYS: 0x0207,
         LESS: 0x0201,
+        EQUAL: 0x0202,
+        GREATER: 0x0204,
+        GEQUAL: 0x0206,
+        LEQUAL: 0x0203,
         TEXTURE_MIN_FILTER: 0x2801,
         TEXTURE_MAG_FILTER: 0x2800,
         TEXTURE_WRAP_S: 0x2802,

package/dist/render/sceneTarget.d.ts

@@ -195,6 +195,18 @@ export declare class SceneTarget {
      * must reject it in the same place or the accumulation and the revealage cover different
      * fragments.
      */
+    /**
+     * The depth the frame draws against, for a second framebuffer to share: skin's diffuse half,
+     * which tests against it and writes none. The multisampled renderbuffer where the frame is
+     * multisampled, the texture otherwise, with the size and sample count a colour beside it needs.
+     */
+    sharedDepth(): {
+        texture: WebGLTexture | null;
+        renderbuffer: WebGLRenderbuffer | null;
+        samples: number;
+        width: number;
+        height: number;
+    };
     depthAttachment(): WebGLTexture | null;
     /**
      * The colour the frame has drawn so far, for a pass that reads the picture rather than the depth.

package/dist/render/sceneTarget.js

@@ -432,6 +432,20 @@ export class SceneTarget {
      * must reject it in the same place or the accumulation and the revealage cover different
      * fragments.
      */
+    /**
+     * The depth the frame draws against, for a second framebuffer to share: skin's diffuse half,
+     * which tests against it and writes none. The multisampled renderbuffer where the frame is
+     * multisampled, the texture otherwise, with the size and sample count a colour beside it needs.
+     */
+    sharedDepth() {
+        return {
+            texture: this.msaaDepth === null ? this.depth : null,
+            renderbuffer: this.msaaDepth,
+            samples: this.samples,
+            width: this.width,
+            height: this.height,
+        };
+    }
     depthAttachment() {
         return this.depth;
     }

package/dist/render/shaders/clothBinding.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The vertex-stage cloth binding: a skinned vertex moved toward the cloth simulation's triangle it
+ * is bound to, by a weight painted per vertex — the GLSL of `clothPlacement.ts`, line for line.
+ *
+ * **Textures read by vertex index, not attributes**, for the reason morph targets are: the skinned
+ * variants already use all sixteen attribute locations once eight influences are in. Three
+ * textures, each wrapped onto rows at its own width (read back with `textureSize`, so no uniform
+ * joins the vertex block and no shared field moves):
+ *
+ * - **the binding**, two texels a render vertex: the three particle indices and the weight, then
+ *   the barycentric (u, v) for the second and third particle and the offset along the normal;
+ * - **the particles now**, one texel a particle, world space — the simulation's output;
+ * - **the particles at rest**, one texel a particle, model space — the rest frames are built from
+ *   these, so a vertex's own bind-pose normal turns as its triangle has turned.
+ *
+ * **A pipeline constant, not a permutation**, as `SKIN_EIGHT` is: declared in the skinned variants
+ * and folded away where a draw binds no cloth. The textures are bound either way, to stand-ins
+ * where there is no cloth.
+ */
+export declare const CLOTH_BINDING_GLSL = "\n/** Whether this pipeline places vertices by a cloth binding. */\nconst bool CLOTH_BOUND = false; // wgsl:override\nuniform highp sampler2D uClothBinding;\nuniform highp sampler2D uClothParticles;\nuniform highp sampler2D uClothRest;\n\n/** Texel i of a texture wrapped onto rows of the given width. */\nivec2 clothTexel(int i, int width) {\n  return ivec2(i % width, i / width);\n}\n\n/** A triangle's frame: its first edge, the normal crossed with it, and its normal. */\nmat3 clothFrame(vec3 a, vec3 b, vec3 c) {\n  vec3 edge = b - a;\n  vec3 n = normalize(cross(edge, c - a));\n  vec3 t = normalize(edge);\n  return mat3(t, cross(n, t), n);\n}\n\n/**\n * Where this vertex's triangle puts it, the turn its normal takes, and how far it follows (the\n * painted weight: 0 skinned, 1 cloth). One particle named three times is a vertex bound to that\n * particle alone: on it, with no turn.\n */\nfloat clothPlace(out vec3 position, out mat3 turn) {\n  int bindingWidth = textureSize(uClothBinding, 0).x;\n  int particleWidth = textureSize(uClothParticles, 0).x;\n  int restWidth = textureSize(uClothRest, 0).x;\n  vec4 indices = texelFetch(uClothBinding, clothTexel(gl_VertexID * 2, bindingWidth), 0);\n  vec4 at = texelFetch(uClothBinding, clothTexel(gl_VertexID * 2 + 1, bindingWidth), 0);\n  int a = int(indices.x);\n  int b = int(indices.y);\n  int c = int(indices.z);\n  vec3 pa = texelFetch(uClothParticles, clothTexel(a, particleWidth), 0).xyz;\n  if (a == b && b == c) {\n    position = pa;\n    turn = mat3(1.0);\n    return indices.w;\n  }\n  vec3 pb = texelFetch(uClothParticles, clothTexel(b, particleWidth), 0).xyz;\n  vec3 pc = texelFetch(uClothParticles, clothTexel(c, particleWidth), 0).xyz;\n  mat3 now = clothFrame(pa, pb, pc);\n  mat3 rest = clothFrame(\n    texelFetch(uClothRest, clothTexel(a, restWidth), 0).xyz,\n    texelFetch(uClothRest, clothTexel(b, restWidth), 0).xyz,\n    texelFetch(uClothRest, clothTexel(c, restWidth), 0).xyz\n  );\n  position = pa * (1.0 - at.x - at.y) + pb * at.x + pc * at.y + now[2] * at.z;\n  turn = now * transpose(rest);\n  return indices.w;\n}\n";
+/** A skinned vertex stage with the cloth binding on: the same source, the constant flipped. */
+export declare function clothBound(source: string): string;

package/dist/render/shaders/clothBinding.js

@@ -0,0 +1,80 @@
+/**
+ * The vertex-stage cloth binding: a skinned vertex moved toward the cloth simulation's triangle it
+ * is bound to, by a weight painted per vertex — the GLSL of `clothPlacement.ts`, line for line.
+ *
+ * **Textures read by vertex index, not attributes**, for the reason morph targets are: the skinned
+ * variants already use all sixteen attribute locations once eight influences are in. Three
+ * textures, each wrapped onto rows at its own width (read back with `textureSize`, so no uniform
+ * joins the vertex block and no shared field moves):
+ *
+ * - **the binding**, two texels a render vertex: the three particle indices and the weight, then
+ *   the barycentric (u, v) for the second and third particle and the offset along the normal;
+ * - **the particles now**, one texel a particle, world space — the simulation's output;
+ * - **the particles at rest**, one texel a particle, model space — the rest frames are built from
+ *   these, so a vertex's own bind-pose normal turns as its triangle has turned.
+ *
+ * **A pipeline constant, not a permutation**, as `SKIN_EIGHT` is: declared in the skinned variants
+ * and folded away where a draw binds no cloth. The textures are bound either way, to stand-ins
+ * where there is no cloth.
+ */
+export const CLOTH_BINDING_GLSL = `
+/** Whether this pipeline places vertices by a cloth binding. */
+const bool CLOTH_BOUND = false; // wgsl:override
+uniform highp sampler2D uClothBinding;
+uniform highp sampler2D uClothParticles;
+uniform highp sampler2D uClothRest;
+
+/** Texel i of a texture wrapped onto rows of the given width. */
+ivec2 clothTexel(int i, int width) {
+  return ivec2(i % width, i / width);
+}
+
+/** A triangle's frame: its first edge, the normal crossed with it, and its normal. */
+mat3 clothFrame(vec3 a, vec3 b, vec3 c) {
+  vec3 edge = b - a;
+  vec3 n = normalize(cross(edge, c - a));
+  vec3 t = normalize(edge);
+  return mat3(t, cross(n, t), n);
+}
+
+/**
+ * Where this vertex's triangle puts it, the turn its normal takes, and how far it follows (the
+ * painted weight: 0 skinned, 1 cloth). One particle named three times is a vertex bound to that
+ * particle alone: on it, with no turn.
+ */
+float clothPlace(out vec3 position, out mat3 turn) {
+  int bindingWidth = textureSize(uClothBinding, 0).x;
+  int particleWidth = textureSize(uClothParticles, 0).x;
+  int restWidth = textureSize(uClothRest, 0).x;
+  vec4 indices = texelFetch(uClothBinding, clothTexel(gl_VertexID * 2, bindingWidth), 0);
+  vec4 at = texelFetch(uClothBinding, clothTexel(gl_VertexID * 2 + 1, bindingWidth), 0);
+  int a = int(indices.x);
+  int b = int(indices.y);
+  int c = int(indices.z);
+  vec3 pa = texelFetch(uClothParticles, clothTexel(a, particleWidth), 0).xyz;
+  if (a == b && b == c) {
+    position = pa;
+    turn = mat3(1.0);
+    return indices.w;
+  }
+  vec3 pb = texelFetch(uClothParticles, clothTexel(b, particleWidth), 0).xyz;
+  vec3 pc = texelFetch(uClothParticles, clothTexel(c, particleWidth), 0).xyz;
+  mat3 now = clothFrame(pa, pb, pc);
+  mat3 rest = clothFrame(
+    texelFetch(uClothRest, clothTexel(a, restWidth), 0).xyz,
+    texelFetch(uClothRest, clothTexel(b, restWidth), 0).xyz,
+    texelFetch(uClothRest, clothTexel(c, restWidth), 0).xyz
+  );
+  position = pa * (1.0 - at.x - at.y) + pb * at.x + pc * at.y + now[2] * at.z;
+  turn = now * transpose(rest);
+  return indices.w;
+}
+`;
+/** A skinned vertex stage with the cloth binding on: the same source, the constant flipped. */
+export function clothBound(source) {
+    const off = 'const bool CLOTH_BOUND = false;';
+    if (!source.includes(off)) {
+        throw new Error('clothBound: this vertex stage declares no CLOTH_BOUND constant');
+    }
+    return source.replace(off, 'const bool CLOTH_BOUND = true;');
+}

package/dist/render/shaders/depth.js

@@ -1,7 +1,9 @@
 import { resolveConditionals } from './conditionals.js';
 import { SUN_STATIC_LAYER } from '../shadowMap.js';
 import { CUTOUT_COVERAGE_GLSL } from './cutoutCoverage.js';
+import { CUTOUT_DITHER_GLSL } from '../cutoutDither.js';
 import { SKINNING_GLSL } from './skinning.js';
+import { CLOTH_BINDING_GLSL } from './clothBinding.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from './vertexChannel.js';
 /**
  * Depth-only shadow pass. Its optional peel mode rejects the first recorded
@@ -20,6 +22,11 @@ const DEPTH_VERT_SOURCE = `#version 300 es
 layout(location = 0) in vec3 aPosition;
 #if SKINNED
 ${SKINNING_GLSL}
+/* Not in the glass-tint caster: a garment is not glass, and its layout keeps its bindings. */
+#if GLASS
+#else
+${CLOTH_BINDING_GLSL}
+#endif
 #endif
 
 uniform mat4 uLightViewProj;
@@ -66,14 +73,15 @@ ${CHANNEL_BEND}
 layout(location = 5) in vec3 aUv;
 uniform vec2 uUvScale;
 uniform vec2 uUvOffset;
-uniform float uAlphaCutout;
+/* x the cutoff, y 1 for a dithered edge: see the cutout fragment stages below. */
+uniform vec2 uAlphaCutout;
 #endif
 
 out vec4 vLightPosition;
 #if CUTOUT
 /* The texture coordinate and, in z, the texture-array layer the face wears. */
 out vec3 vUv;
-flat out float vAlphaCutout;
+flat out vec2 vAlphaCutout;
 #endif
 #if GLASS
 /* Where on the pane this is, for the tint's own normal and its angle to the light. Last, so the
@@ -100,6 +108,18 @@ void main() {
   vec3 bent = world.xyz;
 #else
   vec3 bent = channelBend(world.xyz, aChannel.x);
+#endif
+#if SKINNED
+#if GLASS
+#else
+  /* Toward the cloth exactly as the colour pass moves it, or the shadow parts from the garment. */
+  if (CLOTH_BOUND) {
+    vec3 clothPosition;
+    mat3 turn;
+    float follow = clothPlace(clothPosition, turn);
+    bent = mix(bent, clothPosition, follow);
+  }
+#endif
 #endif
   vLightPosition = uLightViewProj * vec4(bent, world.w);
   gl_Position = vLightPosition;
@@ -171,12 +191,13 @@ export const DEPTH_CUTOUT_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
 in vec3 vUv;
-flat in float vAlphaCutout;
+flat in vec2 vAlphaCutout;
 
 uniform highp sampler2DArray uPreviousShadowMap;
 uniform int uPeelShadowLayer;
 uniform highp sampler2DArray uCutoutMap;
 ${CUTOUT_COVERAGE_GLSL}
+${CUTOUT_DITHER_GLSL}
 void main() {
   /* Credited for its mip level as the surface's own test is, so a leaf casts the shape it draws. */
   vec3 at = vec3(vUv.xy, floor(vUv.z + 0.5));
@@ -187,7 +208,16 @@ void main() {
     float previousDepth = textureLod(uPreviousShadowMap, vec3(uv, ${SUN_STATIC_LAYER}.0), 0.0).r;
     if (gl_FragCoord.z <= previousDepth + 0.00001) discard;
   }
-  if (alpha < vAlphaCutout) discard;
+  /*
+   * A dithered edge casts the share it covers, with a pattern that does not move: a shadow map has
+   * no temporal resolve of its own and a static layer keeps whatever it was drawn with, so a moving
+   * pattern would shimmer there. The map's filter averages it into a soft edge.
+   */
+  if (vAlphaCutout.y > 0.5) {
+    if (!cutoutKeeps(cutoutShare(alpha, vAlphaCutout.x), gl_FragCoord.xy, 0.0)) discard;
+  } else if (alpha < vAlphaCutout.x) {
+    discard;
+  }
 }
 `;
 /**
@@ -241,13 +271,14 @@ export const GLASS_TINT_CUTOUT_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
 in vec3 vUv;
-flat in float vAlphaCutout;
+flat in vec2 vAlphaCutout;
 in vec3 vGlassWorld;
 
 uniform vec4 uGlassPane;
 uniform vec4 uGlassLight;
 uniform highp sampler2DArray uCutoutMap;
 ${CUTOUT_COVERAGE_GLSL}
+${CUTOUT_DITHER_GLSL}
 out vec4 outTint;
 
 void main() {
@@ -255,6 +286,11 @@ void main() {
   vec3 at = vec3(vUv.xy, floor(vUv.z + 0.5));
   float alpha = cutoutAlpha(texture(uCutoutMap, at).a, vUv.xy * vec2(textureSize(uCutoutMap, 0).xy));
 ${GLASS_TINT_BODY}
-  if (alpha < vAlphaCutout) discard;
+  /* The depth cutout's own test, so the colour lands exactly where the depth does. */
+  if (vAlphaCutout.y > 0.5) {
+    if (!cutoutKeeps(cutoutShare(alpha, vAlphaCutout.x), gl_FragCoord.xy, 0.0)) discard;
+  } else if (alpha < vAlphaCutout.x) {
+    discard;
+  }
 }
 `;

package/dist/render/shaders/flat/anisotropic.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The anisotropic model in GLSL: GGX stretched along a direction in the surface, after glTF's
+ * `KHR_materials_anisotropy` — `anisotropicLobe.ts` is the same arithmetic, and its tests hold it to
+ * the standard lobe at strength 0 and to the widths' ratio at its half maximum.
+ *
+ * **The direction** is the tangent frame's, turned by the material's rotation, and by the model
+ * map's red and green where one is bound (a direction encoded −1 to 1, glTF's packing), its blue
+ * scaling the strength. **The environment** is reflected about a normal bent toward the stretch, as
+ * Filament and three.js do: a streak of sky across a brushed disc rather than a round spot, at the
+ * cost of a reflection that is not the exact anisotropic integral.
+ *
+ * Lamps widen both of the lobe's widths by the source's angle, as `sphereLobe` widens the standard
+ * lobe, with the energy kept; at strength 0 that is `sphereLobe` exactly.
+ */
+export declare const ANISOTROPIC_GLSL = "\n/* The stretch's frame and strength, gathered once with the surface. */\nvec3 aAlong;\nvec3 aAcross;\nfloat aStrength;\n\nvoid anisotropicSurface() {\n  vec2 direction = vec2(1.0, 0.0);\n  float strength = uModelParams[0].x;\n  if (uModelParams[1].w > 0.0) {\n    vec2 mapped = mMap.rg * 2.0 - 1.0;\n    direction = dot(mapped, mapped) > 1e-8 ? normalize(mapped) : direction;\n    strength *= mMap.b;\n  }\n  vec2 turned = vec2(\n    direction.x * uModelParams[0].y - direction.y * uModelParams[0].z,\n    direction.x * uModelParams[0].z + direction.y * uModelParams[0].y\n  );\n  aAlong = normalize(mTangent * turned.x + mBitangent * turned.y);\n  aAcross = cross(mNormal, aAlong);\n  aStrength = strength;\n}\n\n/** The stretched lobe at a half vector, 1 at the mirror direction: anisotropicLobe.ts. */\nfloat anisotropicLobe(vec3 h, float sourceRadius, float dist) {\n  float alpha = max(mRoughness * mRoughness, MIN_LOBE_ALPHA);\n  float alongWidth = alpha + (1.0 - alpha) * aStrength * aStrength;\n  float grow = sourceRadius / max(2.0 * dist, 1e-3);\n  float alongWide = clamp(alongWidth + grow, alongWidth, 1.0);\n  float acrossWide = clamp(alpha + grow, alpha, 1.0);\n  float energy = (alongWidth / alongWide) * (alpha / acrossWide);\n  float x = dot(aAlong, h) / alongWide;\n  float y = dot(aAcross, h) / acrossWide;\n  float z = dot(mNormal, h);\n  float d = x * x + y * y + z * z;\n  return energy / max(d * d, 1e-8);\n}\n\nvoid anisotropicLight(vec3 l, float sourceRadius, float dist) {\n  float ndl = max(dot(mNormal, l), 0.0);\n  vec3 h = normalize(l + mToEye);\n  vec3 tint = mix(mSpecColor, vec3(1.0), pow(1.0 - max(dot(mToEye, h), 0.0), 5.0) * mMetal);\n  mDiffuse = mAlbedo * ndl * (1.0 - mMetal);\n  mSpecular = ndl > 0.0 ? tint * anisotropicLobe(h, sourceRadius, dist) : vec3(0.0);\n}\n\n/* The environment's normal, bent toward the stretch by its strength and the surface's roughness. */\nvec3 anisotropicReflectNormal(vec3 n) {\n  vec3 across = cross(aAcross, mToEye);\n  vec3 bent = cross(across, aAcross);\n  float bend = aStrength * clamp(5.0 * mRoughness, 0.0, 1.0);\n  return normalize(mix(n, bent, bend));\n}\n";

package/dist/render/shaders/flat/anisotropic.js

@@ -0,0 +1,68 @@
+/**
+ * The anisotropic model in GLSL: GGX stretched along a direction in the surface, after glTF's
+ * `KHR_materials_anisotropy` — `anisotropicLobe.ts` is the same arithmetic, and its tests hold it to
+ * the standard lobe at strength 0 and to the widths' ratio at its half maximum.
+ *
+ * **The direction** is the tangent frame's, turned by the material's rotation, and by the model
+ * map's red and green where one is bound (a direction encoded −1 to 1, glTF's packing), its blue
+ * scaling the strength. **The environment** is reflected about a normal bent toward the stretch, as
+ * Filament and three.js do: a streak of sky across a brushed disc rather than a round spot, at the
+ * cost of a reflection that is not the exact anisotropic integral.
+ *
+ * Lamps widen both of the lobe's widths by the source's angle, as `sphereLobe` widens the standard
+ * lobe, with the energy kept; at strength 0 that is `sphereLobe` exactly.
+ */
+export const ANISOTROPIC_GLSL = /* glsl */ `
+/* The stretch's frame and strength, gathered once with the surface. */
+vec3 aAlong;
+vec3 aAcross;
+float aStrength;
+
+void anisotropicSurface() {
+  vec2 direction = vec2(1.0, 0.0);
+  float strength = uModelParams[0].x;
+  if (uModelParams[1].w > 0.0) {
+    vec2 mapped = mMap.rg * 2.0 - 1.0;
+    direction = dot(mapped, mapped) > 1e-8 ? normalize(mapped) : direction;
+    strength *= mMap.b;
+  }
+  vec2 turned = vec2(
+    direction.x * uModelParams[0].y - direction.y * uModelParams[0].z,
+    direction.x * uModelParams[0].z + direction.y * uModelParams[0].y
+  );
+  aAlong = normalize(mTangent * turned.x + mBitangent * turned.y);
+  aAcross = cross(mNormal, aAlong);
+  aStrength = strength;
+}
+
+/** The stretched lobe at a half vector, 1 at the mirror direction: anisotropicLobe.ts. */
+float anisotropicLobe(vec3 h, float sourceRadius, float dist) {
+  float alpha = max(mRoughness * mRoughness, MIN_LOBE_ALPHA);
+  float alongWidth = alpha + (1.0 - alpha) * aStrength * aStrength;
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float alongWide = clamp(alongWidth + grow, alongWidth, 1.0);
+  float acrossWide = clamp(alpha + grow, alpha, 1.0);
+  float energy = (alongWidth / alongWide) * (alpha / acrossWide);
+  float x = dot(aAlong, h) / alongWide;
+  float y = dot(aAcross, h) / acrossWide;
+  float z = dot(mNormal, h);
+  float d = x * x + y * y + z * z;
+  return energy / max(d * d, 1e-8);
+}
+
+void anisotropicLight(vec3 l, float sourceRadius, float dist) {
+  float ndl = max(dot(mNormal, l), 0.0);
+  vec3 h = normalize(l + mToEye);
+  vec3 tint = mix(mSpecColor, vec3(1.0), pow(1.0 - max(dot(mToEye, h), 0.0), 5.0) * mMetal);
+  mDiffuse = mAlbedo * ndl * (1.0 - mMetal);
+  mSpecular = ndl > 0.0 ? tint * anisotropicLobe(h, sourceRadius, dist) : vec3(0.0);
+}
+
+/* The environment's normal, bent toward the stretch by its strength and the surface's roughness. */
+vec3 anisotropicReflectNormal(vec3 n) {
+  vec3 across = cross(aAcross, mToEye);
+  vec3 bent = cross(across, aAcross);
+  float bend = aStrength * clamp(5.0 * mRoughness, 0.0, 1.0);
+  return normalize(mix(n, bent, bend));
+}
+`;

package/dist/render/shaders/flat/eye.d.ts

@@ -0,0 +1 @@
+export declare const EYE_GLSL: string;