@driftengine/core 4.8.2 → 4.8.4

package/dist/render/sceneCoverage.js

@@ -0,0 +1,72 @@
+/**
+ * What a blended draw into the scene does to its alpha, which holds how much of each pixel is still
+ * the opaque surface — the share ambient occlusion is allowed to darken.
+ *
+ * **Occlusion is applied in the composite, from the depth the opaque world left**, after every
+ * translucent draw has landed, and a particle or a pane writes no depth: so a puff of smoke in front
+ * of a wall was darkened by the corner behind it. Reported from a game as walls and two figures
+ * standing behind a cloud showing through it as outlines, and nothing at all with occlusion off.
+ *
+ * So the scene's alpha is a running share. The frame clears it to 1 and an opaque draw writes 1,
+ * which is the whole of the surface; then each draw blended in front of it says which of three
+ * things it is, and the composite darkens `share` of the pixel and leaves the rest:
+ *
+ * - **It covers**: glass, smoke, water, a line, text in the world, a panel. The share falls by what
+ *   the draw lets through, `share * (1 - a)`.
+ * - **It transmits**: the medium, the order-independent composite. Its alpha already *is* what gets
+ *   through, `share * a`.
+ * - **It keeps**: light added to the surface or a layer of the surface itself — caustics, a light
+ *   volume, a bolt, a wet film, a decal, a reflection. The share is unchanged.
+ *
+ * **What it gives up** is added light in front of an occluded corner: a glow or a spark adds to the
+ * pixel and keeps the share, so the composite darkens what it added along with the surface — which
+ * is how every blended draw behaved before this, and one multiply cannot tell the two apart. **What
+ * would make it wrong** is an opaque pass writing an alpha below 1: its surface would then take less
+ * occlusion than it should, which is the safe direction, and is the lit shader's own case at a
+ * cutout's edge or under a per-vertex alpha lane.
+ *
+ * **It survives the temporal passes.** A temporal resolve passes the frame's alpha through, since
+ * it is a fact about this frame and takes no history; a reconstruction reads it from the scene it
+ * rebuilt into the picture it shows, and the blended draws that land after it cover that picture.
+ *
+ * **One pipeline does not take part**: the GPU-driven pass blends its own surfaces into a target
+ * whose alpha is the mask its blit reads to tell a drawn pixel from an undrawn one, and that blit
+ * writes the share back to 1. Its panes still take the occlusion of what they cover. What would
+ * close it is a channel for that mask other than alpha.
+ *
+ * A contributed pass drawing something blended into the scene states the same thing for its own
+ * pipeline with `SCENE_ALPHA_COVERS`, `SCENE_ALPHA_TRANSMITS` or `SCENE_ALPHA_KEEPS`.
+ */
+/** A blended draw that covers the surface by its alpha: `share * (1 - a)`. */
+export const SCENE_ALPHA_COVERS = {
+    srcFactor: 'zero',
+    dstFactor: 'one-minus-src-alpha',
+    operation: 'add',
+};
+/** A draw whose alpha is what gets through it, a transmittance or a revealage: `share * a`. */
+export const SCENE_ALPHA_TRANSMITS = {
+    srcFactor: 'zero',
+    dstFactor: 'src-alpha',
+    operation: 'add',
+};
+/** Light added to the surface, or a layer of it: the share unchanged. */
+export const SCENE_ALPHA_KEEPS = {
+    srcFactor: 'zero',
+    dstFactor: 'one',
+    operation: 'add',
+};
+/**
+ * The same three on WebGL2, as the alpha half of `blendFuncSeparate` beside the colour half a
+ * caller already had. `src` and `dst` are the colour factors.
+ */
+export function blendCovering(gl, src, dst) {
+    gl.blendFuncSeparate(src, dst, gl.ZERO, gl.ONE_MINUS_SRC_ALPHA);
+}
+/** `SCENE_ALPHA_TRANSMITS` on WebGL2, beside the colour factors `src` and `dst`. */
+export function blendTransmitting(gl, src, dst) {
+    gl.blendFuncSeparate(src, dst, gl.ZERO, gl.SRC_ALPHA);
+}
+/** `SCENE_ALPHA_KEEPS` on WebGL2, beside the colour factors `src` and `dst`. */
+export function blendKeeping(gl, src, dst) {
+    gl.blendFuncSeparate(src, dst, gl.ZERO, gl.ONE);
+}

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/sdfTextRenderer.js

@@ -2,6 +2,7 @@ import { SdfTextLayout } from './sdfTextLayout.js';
 import { compileProgram, uniformLocations } from './shader.js';
 import { SDF_TEXT_FRAG, SDF_TEXT_VERT } from './shaders/sdfText.js';
 import { SDF_TEXT_TEXTURE_UNIT } from './lightBudget.js';
+import { blendCovering } from './sceneCoverage.js';
 /**
  * Text from a signed distance field, on WebGL2.
  *
@@ -126,7 +127,7 @@ export class SdfTextRenderer {
          */
         gl.depthMask(false);
         gl.enable(gl.BLEND);
-        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+        blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
         this.atlas.bind(gl, SDF_TEXT_TEXTURE_UNIT);
         const u = this.uniforms;
         gl.uniform1i(u['uOutputTransform'] ?? null, outputTransform);

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;
@@ -59,20 +66,22 @@ ${CHANNEL_BEND}
 
 #if CUTOUT
 /*
- * **What a cutout caster adds, and where.** The UV at location 5, where every mesh carries it; two
+ * **What a cutout caster adds, and where.** The UV at location 5, where every mesh carries it; three
  * uniforms declared after every other, so no field of the plain variant moves and a binder written
  * against it stays right for this one; and two outputs after vLightPosition, which keeps location 0.
  */
 layout(location = 5) in vec3 aUv;
 uniform vec2 uUvScale;
-uniform float uAlphaCutout;
+uniform vec2 uUvOffset;
+/* 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
@@ -99,11 +108,23 @@ 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;
 #if CUTOUT
-  vUv = vec3(aUv.xy * uUvScale, aUv.z);
+  vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
   vAlphaCutout = uAlphaCutout;
 #endif
 #if GLASS
@@ -170,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));
@@ -186,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;
+  }
 }
 `;
 /**
@@ -240,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() {
@@ -254,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;

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

@@ -0,0 +1,81 @@
+/**
+ * The eye model in GLSL: `eyeRefraction.ts` is the refraction's arithmetic, and its tests hold it
+ * to no shift head-on, the refracted crossing at 30°, a bounded shift edge-on and the map-less iris.
+ *
+ * **The iris is moved before any map is read** (`modelSurfaceAt`), by how far the eye's ray crosses
+ * the iris plane after the cornea bends it, so the whole iris — colour, relief, the model's own
+ * channels — moves as one. The crossing is turned into texture coordinates by the tangent frame and
+ * by how many of them a metre spans here, which the screen's derivatives say: so it is in uniform
+ * control flow, as `modelSurfaceAt` is. **What it gives up** is an anisotropic mapping — a texture
+ * stretched one way more than the other moves by the average of the two.
+ *
+ * **The model map**: red is the iris (1 inside), green the cornea's height above the iris plane as a
+ * share of `irisDepth`. Without one, the iris is a disc of `irisRadius` about the texture's centre
+ * and the height is `irisDepth` throughout.
+ *
+ * **Lit as an eye is**: the iris by a normal mirrored about the axis — concave where the cornea is
+ * convex, so light pools on the side away from it — and the sclera by the surface's own; and over
+ * both, the cornea's highlight, normalised GGX at `corneaRoughness` with the Fresnel of index 1.336,
+ * in lamp units like skin's. The environment is reflected at the cornea's split-sum share.
+ */
+import { CORNEA_F0, EYE_MIN_DESCENT } from '../../eyeRefraction.js';
+export const EYE_GLSL = /* glsl */ `
+const float CORNEA_F0 = ${CORNEA_F0.toFixed(9)};
+const float EYE_MIN_DESCENT = ${EYE_MIN_DESCENT.toFixed(4)};
+
+/* How much of this texel is iris, gathered with the surface. */
+float eIris;
+
+/** Where the iris is without a map: a disc of the model's radius about the centre, a soft limbus. */
+float eyeIrisDisc(vec2 uv) {
+  float r = length(uv - 0.5);
+  return 1.0 - smoothstep(uModelParams[0].x - 0.01, uModelParams[0].x + 0.01, r);
+}
+
+/** The iris's texture coordinate, moved by the cornea: \`eyeRefraction.ts\`. Before any map is read. */
+vec3 eyeRefract(vec3 at) {
+  vec3 n = normalize(vNormal);
+  vec3 axis = uModelParams[1].xyz;
+  vec4 map = texture(uModelMap, at);
+  bool mapped = uModelParams[1].w > 0.0;
+  float iris = mapped ? map.r : eyeIrisDisc(at.xy);
+  float height = uModelParams[0].y * (mapped ? map.g : 1.0);
+  vec3 ray = refract(-normalize(uCameraPos - vWorldPos), n, 1.0 / uModelParams[0].z);
+  float descent = max(-dot(ray, axis), EYE_MIN_DESCENT);
+  vec3 travel = ray * (height / descent);
+  vec3 across = travel - axis * dot(travel, axis);
+  mat3 frame = tangentFrame(n, vWorldPos, vUv.xy, vTangent, vHasTangents);
+  /* How many texture coordinates a metre spans here, from the screen's two derivatives. */
+  float perMetre = length(fwidth(vUv.xy)) / max(length(fwidth(vWorldPos)), 1e-9);
+  vec2 shift = vec2(dot(across, frame[0]), dot(across, frame[1])) * (perMetre * iris);
+  return vec3(at.xy + shift, at.z);
+}
+
+void eyeSurface(vec3 at) {
+  eIris = uModelParams[1].w > 0.0 ? mMap.r : eyeIrisDisc(at.xy);
+  mRoughness = uModelParams[0].w;
+}
+
+void eyeLight(vec3 l, float sourceRadius, float dist) {
+  vec3 axis = uModelParams[1].xyz;
+  /* The iris is concave where the cornea over it is convex: the surface's normal mirrored about the axis. */
+  vec3 irisNormal = normalize(2.0 * dot(mNormal, axis) * axis - mNormal);
+  vec3 lit = normalize(mix(mNormal, irisNormal, eIris));
+  mDiffuse = mAlbedo * max(dot(lit, l), 0.0) * (1.0 - mMetal);
+
+  float ndl = max(dot(mNormal, l), 0.0);
+  vec3 h = normalize(l + mToEye);
+  float ndh = max(dot(mNormal, h), 0.0);
+  float ndv = max(dot(mNormal, mToEye), 1e-4);
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float alpha = min(max(mRoughness * mRoughness, MIN_LOBE_ALPHA) + grow, 1.0);
+  float f = CORNEA_F0 + (1.0 - CORNEA_F0) * pow(1.0 - max(dot(mToEye, h), 0.0), 5.0);
+  mSpecular = vec3(3.14159265 * f * smithMasking(ndl, ndv, alpha) * ggxLobe(ndh, alpha) * ndl);
+}
+
+/** The environment at the cornea's Fresnel, by the split sum's share at its own roughness. */
+float eyeReflectance() {
+  vec2 dfg = envBrdfApprox(max(dot(mNormal, mToEye), 0.0), uModelParams[0].w);
+  return CORNEA_F0 * dfg.x + dfg.y;
+}
+`;

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

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

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

@@ -0,0 +1,101 @@
+/**
+ * The hair model in GLSL: `hairLobes.ts` is the same arithmetic, and its tests hold the lobes to
+ * their tilted peaks, the transmitted lobe to the backlight, the sum to what a white strand
+ * receives, and every term to a finite answer where the geometry degenerates.
+ *
+ * **The strand is the tangent, root to tip.** The model map's green turns each strand's tilt by up
+ * to half of it either way (0.5 is none) and its blue is occlusion, which the sky, DriftLight and
+ * the environment's reflection take and the lamps do not — their shadows are theirs to cast. The
+ * red is not read: a colour from root to tip is the albedo map's to carry.
+ *
+ * **The environment** is the reflected lobe's: mirrored about a normal turned toward the eye across
+ * the strand, which is the cone R lies on, at the strand's own Fresnel — the lobe integrates to it
+ * over every direction of arrival. **What it gives up** is the two transmitted lobes against the
+ * sky, which a head of hair lit from behind by an open sky would show as a rim; the lamps carry
+ * them.
+ */
+import { HAIR_F0, HAIR_MIN_BETA, HAIR_SCATTER_SPHERE } from '../../hairLobes.js';
+export const HAIR_GLSL = /* glsl */ `
+const float HAIR_F0 = ${HAIR_F0.toFixed(9)};
+const float HAIR_MIN_BETA = ${HAIR_MIN_BETA.toFixed(3)};
+const float HAIR_SCATTER_SPHERE = ${HAIR_SCATTER_SPHERE.toFixed(3)};
+
+/* This texel's tilt, gathered once with the surface. */
+float hShift;
+
+void hairSurface() {
+  hShift = uModelParams[0].x * (0.5 + mMap.g);
+}
+
+/** A longitudinal lobe: a normalised Gaussian of width \`beta\` at \`x\` from its centre. */
+float hairLongitudinal(float beta, float x) {
+  return exp(-0.5 * x * x / (beta * beta)) / (2.5066283 * beta);
+}
+
+float hairFresnel(float cosine) {
+  float c = 1.0 - clamp(cosine, 0.0, 1.0);
+  return HAIR_F0 + (1.0 - HAIR_F0) * c * c * c * c * c;
+}
+
+/** The normal turned toward the eye across the strand: the scatter's and the environment's. */
+vec3 hairAcross() {
+  vec3 across = mToEye - mTangent * dot(mTangent, mToEye);
+  float length2 = dot(across, across);
+  return length2 > 1e-8 ? across * inversesqrt(length2) : mNormal;
+}
+
+void hairLight(vec3 l, float sourceRadius, float dist) {
+  vec3 t = mTangent;
+  float sinI = clamp(dot(t, l), -1.0, 1.0);
+  float sinO = clamp(dot(t, mToEye), -1.0, 1.0);
+  /* Floored for the half angle's limit, whose single-precision cosine is negative: hairLobes.ts. */
+  float cosD = max(cos(0.5 * abs(asin(sinO) - asin(sinI))), 1e-3);
+  vec3 lp = l - sinI * t;
+  vec3 vp = mToEye - sinO * t;
+  float cosPhi = dot(lp, vp) * inversesqrt(dot(lp, lp) * dot(vp, vp) + 1e-4);
+  float cosHalfPhi = sqrt(clamp(0.5 + 0.5 * cosPhi, 0.0, 1.0));
+  float beta = max(mRoughness * mRoughness, HAIR_MIN_BETA);
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float x = sinI + sinO;
+
+  float r = hairLongitudinal(beta + grow, x + 2.0 * hShift) * 0.25 * cosHalfPhi
+    * hairFresnel(sqrt(clamp(0.5 + 0.5 * dot(l, mToEye), 0.0, 1.0)));
+
+  float a = 1.0 / (1.19 / cosD + 0.36 * cosD);
+  float h = cosHalfPhi * (1.0 + a * (0.6 - 0.8 * cosPhi));
+  float fTT = hairFresnel(cosD * sqrt(clamp(1.0 - h * h, 0.0, 1.0)));
+  float tt = hairLongitudinal(0.5 * beta + grow, x - hShift) * exp(-3.65 * cosPhi - 3.98)
+    * (1.0 - fTT) * (1.0 - fTT) * uModelParams[0].z;
+  float ttPower = 0.5 * sqrt(clamp(1.0 - h * h * a * a, 0.0, 1.0)) / cosD;
+
+  float fTRT = hairFresnel(0.5 * cosD);
+  float trt = hairLongitudinal(2.0 * beta + grow, x - 3.0 * hShift) * exp(17.0 * cosPhi - 16.78)
+    * (1.0 - fTRT) * (1.0 - fTRT) * fTRT;
+
+  /* Above zero, so pow never takes the logarithm of nothing: hairLobes.ts. */
+  vec3 fibre = max(mAlbedo, vec3(1e-4));
+  /* π: the published lobes are per unit irradiance, and a lamp here is π of that. */
+  mSpecular = 3.14159265 * (vec3(r) + tt * pow(fibre, vec3(ttPower)) + trt * pow(fibre, vec3(0.8 / cosD)));
+  float wrapped = clamp((dot(hairAcross(), l) + 1.0) * 0.25, 0.0, 1.0);
+  mDiffuse = sqrt(mAlbedo) * uModelParams[0].y * mix(wrapped, 1.0 - abs(sinI), 0.33);
+}
+
+/**
+ * A shadow on the scatter: light that reaches a strand in another's shadow has passed through
+ * hair to get there, so a penumbra deepens toward the fibre's own hue.
+ */
+vec3 hairShade(float shadow) {
+  vec3 hue = mAlbedo / max(dot(mAlbedo, vec3(0.2126, 0.7152, 0.0722)), 1e-4);
+  return shadow * pow(max(hue, vec3(1e-4)), vec3(1.0 - shadow));
+}
+
+/** Light from every side, through the scatter term: \`HAIR_SCATTER_SPHERE\` says why that number. */
+vec3 hairAround(vec3 light) {
+  return sqrt(mAlbedo) * (uModelParams[0].y * HAIR_SCATTER_SPHERE * mMap.b) * light;
+}
+
+/** The reflected lobe's share of the environment: its Fresnel, which is what it integrates to. */
+float hairReflectance() {
+  return hairFresnel(dot(hairAcross(), mToEye)) * mMap.b;
+}
+`;