@driftengine/core 4.8.5 → 4.8.7

package/dist/render/shaders/bloom.js

@@ -27,7 +27,9 @@
  * 3. **Upsample**, additively back up the chain through a tent filter.
  *
  * Deliberately absent, because they were asked against by name: lens dirt, anamorphic streaks
- * and ghosting. One threshold, one radius, one strength.
+ * and ghosting. One threshold, one radius, one strength — and, since 4.8.6, how a colour comes in
+ * past the threshold and a tint for each octave, which is how another engine's stage is matched
+ * rather than how this one looks: see `BloomResponse` in `bloomChain.ts`.
  */
 /**
  * The thirteen taps every downsampling stage shares, decomposed into five overlapping boxes.
@@ -125,6 +127,11 @@ uniform sampler2D uSource;
 uniform vec2 uTexel;
 /** In scene units. 1.0 is "brighter than white", which is the useful place to start. */
 uniform float uThreshold;
+/**
+ * Scene units over which a colour comes in past the threshold, or 0 to subtract the threshold
+ * instead. See \`BloomResponse.ramp\`.
+ */
+uniform float uRamp;
 
 out vec4 fragColor;
 
@@ -141,6 +148,8 @@ ${BLOOM_BRIGHTNESS}
 vec3 fetch(vec2 uv) {
   vec3 c = min(textureLod(uSource, uv, 0.0).rgb, vec3(BLOOM_CEILING));
   float bright = brightness(c);
+  /* A ramp keeps a share of the colour, all of it a ramp's width past the line. */
+  if (uRamp > 0.0) return c * clamp((bright - uThreshold) / uRamp, 0.0, 1.0);
   return c * (max(bright - uThreshold, 0.0) / max(bright, 1e-4));
 }
 
@@ -189,7 +198,9 @@ ${BLOOM_BOXES}
 /**
  * Stage three: a 3x3 tent, added into the level above.
  *
- * **Additive rather than a mix, and each octave counts the same.** A lone bright pixel arrives
+ * **Additive rather than a mix, and each octave counts the same** unless a tint says otherwise:
+ * the level being added onto is multiplied by its own tint as it is, by the blend, and the deepest
+ * by `uScale` on the first draw. White everywhere is exactly the sum. A lone bright pixel arrives
  * at level n divided by four to the n, spread over four to the n pixels, so summing the levels
  * lifts its own pixel by about a third and lays a long shallow tail around it. That falloff is
  * what a real glare looks like; a single gaussian gives a disc with an end to it.
@@ -204,6 +215,12 @@ precision highp float;
 in vec2 vUv;
 
 uniform sampler2D uSource;
+/**
+ * What the level being read is multiplied by: its tint, on the first draw up from the deepest
+ * level, and white on every other — each other level's tint is applied to the level below as it
+ * is added onto, by the blend. See \`BloomResponse.tints\`.
+ */
+uniform vec3 uScale;
 /** How far the tent reaches, in UV. One number for the whole chain. */
 uniform float uRadius;
 
@@ -222,6 +239,6 @@ void main() {
   vec3 i = textureLod(uSource, vUv + vec2( r, -r), 0.0).rgb;
 
   vec3 sum = e * 4.0 + (b + d + f + h) * 2.0 + (a + c + g + i);
-  fragColor = vec4(sum * 0.0625, 1.0);
+  fragColor = vec4(sum * 0.0625 * uScale, 1.0);
 }
 `;

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

@@ -14,4 +14,4 @@
  * gives an arc its three-dimensionality is the path, and the path is world-space.
  */
 export declare const BOLT_VERT = "#version 300 es\nlayout(location = 0) in vec3 aFrom;\nlayout(location = 1) in vec3 aTo;\n/** Along the segment (0 or 1), and which side of it (-1 or +1). */\nlayout(location = 2) in vec2 aCorner;\n/** Where this segment sits along its arc, the arc's envelope, its seed, its gain. */\nlayout(location = 3) in vec4 aArc;\n\nuniform mat4 uViewProj;\nuniform vec3 uCameraPos;\n/** Core half-width in metres, and how much of a pixel a far arc must still cover. */\nuniform float uWidth;\nuniform float uMinWidthPerMetre;\n\nout float vSide;\nout float vAlong;\nout float vFade;\nout float vSeed;\nout float vGain;\nout vec3 vWorldPos;\n\nvoid main() {\n  vec3 mid = mix(aFrom, aTo, aCorner.x);\n  vec3 dir = aTo - aFrom;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec3(0.0, 1.0, 0.0);\n\n  vec3 view = mid - uCameraPos;\n  float dist = length(view);\n  view = dist > 1e-6 ? view / dist : vec3(0.0, 0.0, 1.0);\n\n  /*\n   * Across the segment and across the line of sight. Degenerate exactly when the\n   * segment points at the viewer, where any perpendicular is as good as another \u2014\n   * and where the segment covers almost no screen anyway.\n   */\n  vec3 across = cross(dir, view);\n  float span = length(across);\n  across = span > 1e-4 ? across / span : normalize(cross(dir, vec3(0.0, 1.0, 0.0)) + vec3(1e-3));\n\n  /*\n   * A floor on the world-space width that grows with distance, so a filament\n   * never thins below a pixel. Under a pixel a bright thin line does not get\n   * fainter, it *flickers* \u2014 the rasteriser catches it on some frames and not\n   * others \u2014 and a strobing artefact reads as a bug, not as lightning.\n   */\n  float halfWidth = max(uWidth, dist * uMinWidthPerMetre);\n  vec3 world = mid + across * aCorner.y * halfWidth;\n\n  vSide = aCorner.y;\n  vAlong = aArc.x;\n  vFade = aArc.y;\n  vSeed = aArc.z;\n  vGain = aArc.w;\n  vWorldPos = world;\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
-export declare const BOLT_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin float vAlong;\nin float vFade;\nin float vSeed;\nin float vGain;\nin vec3 vWorldPos;\n\nuniform float uTime;\n/** The saturating centre, and the glow it sits inside. */\nuniform vec3 uCoreColor;\nuniform vec3 uEdgeColor;\n/** How far past white the core is allowed to go. */\nuniform float uCoreGain;\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\nuniform vec3 uCameraPos;\n\nout vec4 outColor;\n\nfloat hash11(float p) {\n  return fract(sin(p * 12.9898) * 43758.5453123);\n}\n\nvoid main() {\n  /*\n   * Across the filament: 1 at the centre line, 0 at the quad's edge. Two powers\n   * of it are the entire look \u2014 a very tight one for the core and a loose one for\n   * the glow. A single falloff gives either a hard line with no atmosphere or a\n   * soft smudge with no filament.\n   */\n  float across = 1.0 - abs(vSide);\n  float core = pow(across, 10.0);\n  /*\n   * A *wide* halo, deliberately. This exponent is the single biggest control over\n   * whether the effect reads as lightning or as a drawn line: a tight falloff gives a\n   * crisp filament with nothing around it, which is a wire, while a broad one bleeds\n   * light into the air the way an over-exposed discharge does on film. It is the\n   * closest thing to bloom available without a second pass.\n   */\n  float glow = pow(across, 1.1);\n\n  /*\n   * Stutter. An arc is not a steady light: it is re-established many times a\n   * second, and the eye reads a *constant* bright line as neon. Two frequencies\n   * so the pattern does not read as a sine, and per-arc phase from the seed so\n   * several arcs never blink together.\n   */\n  /*\n   * Stutter, but shallow. An arc is re-established many times a second and a perfectly\n   * steady bright line reads as neon \u2014 but too *much* flicker reads as a broken effect\n   * rather than as a discharge, and at the brief lifetime these now have, deep flicker\n   * mostly hides the bolt. The path itself is already being redrawn (see 'BoltPool'),\n   * which carries most of the crackle; this only keeps the brightness alive.\n   */\n  float t = uTime * 47.0 + vSeed * 17.0;\n  float stutter = 0.78 + 0.22 * (hash11(floor(t)) * 0.6 + hash11(floor(t * 2.37)) * 0.4);\n\n  /*\n   * The tip tapers. An arc that ends in a squared-off quad reads as a drawn\n   * segment; thinning toward the far end is what makes it read as a discharge\n   * dissipating into the air.\n   */\n  float taper = 1.0 - vAlong * 0.55;\n\n  float energy = vFade * stutter * taper * vGain;\n  vec3 lit = uEdgeColor * glow + uCoreColor * core * uCoreGain;\n\n  /*\n   * Distance dims it rather than tinting it toward the fog. A discharge emits;\n   * mixing it into the medium's colour is what a *surface* does, and doing that\n   * here turned a far bolt grey instead of faint.\n   */\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  /*\n   * Alpha is 1, and the energy is already in the colour.\n   *\n   * The additive blend is 'SRC_ALPHA, ONE', so what reaches the framebuffer is\n   * 'rgb * a'. Putting the energy in both \u2014 which the first version did \u2014 squares it,\n   * and squaring a number below one is how an effect authored as blinding arrives as\n   * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.\n   * Every emissive material here has to pick one channel and mean it.\n   */\n  outColor = vec4(lit * energy * (1.0 - fog), 1.0);\n}\n";
+export declare const BOLT_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin float vAlong;\nin float vFade;\nin float vSeed;\nin float vGain;\nin vec3 vWorldPos;\n\nuniform float uTime;\n/** The saturating centre, and the glow it sits inside. */\nuniform vec3 uCoreColor;\nuniform vec3 uEdgeColor;\n/** How far past white the core is allowed to go. */\nuniform float uCoreGain;\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\nuniform vec3 uCameraPos;\n\nout vec4 outColor;\n\nfloat hash11(float p) {\n  return fract(sin(p * 12.9898) * 43758.5453123);\n}\n\nvoid main() {\n  /*\n   * Across the filament: 1 at the centre line, 0 at the quad's edge. Two powers\n   * of it are the entire look \u2014 a very tight one for the core and a loose one for\n   * the glow. A single falloff gives either a hard line with no atmosphere or a\n   * soft smudge with no filament.\n   */\n  /*\n   * Clamped, because a multisampled target shades a pixel on the quad's edge at its centre, which\n   * may lie outside the quad: there 'vSide' runs past one, 'across' goes negative, and 'pow' of a\n   * negative number is NaN. One NaN pixel is a dark speck; bloom then spreads it into a white disc\n   * the size of the blur. Found by a fight drawing short arcs at 4 samples.\n   */\n  float across = clamp(1.0 - abs(vSide), 0.0, 1.0);\n  float core = pow(across, 10.0);\n  /*\n   * A *wide* halo, deliberately. This exponent is the single biggest control over\n   * whether the effect reads as lightning or as a drawn line: a tight falloff gives a\n   * crisp filament with nothing around it, which is a wire, while a broad one bleeds\n   * light into the air the way an over-exposed discharge does on film. It is the\n   * closest thing to bloom available without a second pass.\n   */\n  float glow = pow(across, 1.1);\n\n  /*\n   * Stutter. An arc is not a steady light: it is re-established many times a\n   * second, and the eye reads a *constant* bright line as neon. Two frequencies\n   * so the pattern does not read as a sine, and per-arc phase from the seed so\n   * several arcs never blink together.\n   */\n  /*\n   * Stutter, but shallow. An arc is re-established many times a second and a perfectly\n   * steady bright line reads as neon \u2014 but too *much* flicker reads as a broken effect\n   * rather than as a discharge, and at the brief lifetime these now have, deep flicker\n   * mostly hides the bolt. The path itself is already being redrawn (see 'BoltPool'),\n   * which carries most of the crackle; this only keeps the brightness alive.\n   */\n  float t = uTime * 47.0 + vSeed * 17.0;\n  float stutter = 0.78 + 0.22 * (hash11(floor(t)) * 0.6 + hash11(floor(t * 2.37)) * 0.4);\n\n  /*\n   * The tip tapers. An arc that ends in a squared-off quad reads as a drawn\n   * segment; thinning toward the far end is what makes it read as a discharge\n   * dissipating into the air.\n   */\n  float taper = 1.0 - vAlong * 0.55;\n\n  float energy = vFade * stutter * taper * vGain;\n  vec3 lit = uEdgeColor * glow + uCoreColor * core * uCoreGain;\n\n  /*\n   * Distance dims it rather than tinting it toward the fog. A discharge emits;\n   * mixing it into the medium's colour is what a *surface* does, and doing that\n   * here turned a far bolt grey instead of faint.\n   */\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  /*\n   * Alpha is 1, and the energy is already in the colour.\n   *\n   * The additive blend is 'SRC_ALPHA, ONE', so what reaches the framebuffer is\n   * 'rgb * a'. Putting the energy in both \u2014 which the first version did \u2014 squares it,\n   * and squaring a number below one is how an effect authored as blinding arrives as\n   * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.\n   * Every emissive material here has to pick one channel and mean it.\n   */\n  outColor = vec4(lit * energy * (1.0 - fog), 1.0);\n}\n";

package/dist/render/shaders/bolt.js

@@ -104,7 +104,13 @@ void main() {
    * the glow. A single falloff gives either a hard line with no atmosphere or a
    * soft smudge with no filament.
    */
-  float across = 1.0 - abs(vSide);
+  /*
+   * Clamped, because a multisampled target shades a pixel on the quad's edge at its centre, which
+   * may lie outside the quad: there 'vSide' runs past one, 'across' goes negative, and 'pow' of a
+   * negative number is NaN. One NaN pixel is a dark speck; bloom then spreads it into a white disc
+   * the size of the blur. Found by a fight drawing short arcs at 4 samples.
+   */
+  float across = clamp(1.0 - abs(vSide), 0.0, 1.0);
   float core = pow(across, 10.0);
   /*
    * A *wide* halo, deliberately. This exponent is the single biggest control over

package/dist/render/shaders/depth.js

@@ -100,6 +100,12 @@ void main() {
 #endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
+  /* The bottom row is the instance's texture cell, rebuilt as the row it stands for: see flat. */
+  vec4 instanceCell = vec4(model[0].w, model[1].w, model[2].w, model[3].w);
+  model[0].w = 0.0;
+  model[1].w = 0.0;
+  model[2].w = 0.0;
+  model[3].w = 1.0;
 #else
   mat4 model = uModel;
 #endif
@@ -124,7 +130,12 @@ void main() {
   vLightPosition = uLightViewProj * vec4(bent, world.w);
   gl_Position = vLightPosition;
 #if CUTOUT
+#if INSTANCED
+  /* A cutout instance's shadow is cut by its own cell, as its picture is. */
+  vUv = vec3((aUv.xy * instanceCell.xy + instanceCell.zw) * uUvScale + uUvOffset, aUv.z);
+#else
   vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
+#endif
   vAlphaCutout = uAlphaCutout;
 #endif
 #if GLASS

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

@@ -12,4 +12,4 @@
  * 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";
+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  vec3 along = mTangent * turned.x + mBitangent * turned.y;\n  /*\n   * A mesh with neither tangents nor texture coordinates has no frame to take a direction from,\n   * and normalising the zero it gives was a NaN that drew the whole surface black. Any direction in\n   * the surface stands in, the one across the world's up, so the highlight is stretched somewhere.\n   */\n  if (dot(along, along) < 1e-12) {\n    along = cross(abs(mNormal.y) < 0.999 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0), mNormal);\n  }\n  aAlong = normalize(along);\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\n/**\n * The same stretch as GGX's own BRDF, `\u03C0 \u00B7 D \u00B7 Vis \u00B7 N\u00B7L`, for a surface whose highlight is\n * physical: the distribution normalised, and Smith's height-correlated masking stretched with it\n * (Heitz 2014, as Filament writes it). `anisotropicPhysicalLobe` in anisotropicLobe.ts.\n */\nfloat anisotropicPhysical(vec3 l, vec3 h, float ndl, 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 along = clamp(alongWidth + grow, alongWidth, 1.0);\n  float across = clamp(alpha + grow, alpha, 1.0);\n  float x = dot(aAlong, h) / along;\n  float y = dot(aAcross, h) / across;\n  float z = dot(mNormal, h);\n  float d = x * x + y * y + z * z;\n  float distribution = 1.0 / max(3.14159265 * along * across * d * d, 1e-8);\n  float ndv = max(dot(mNormal, mToEye), 1e-4);\n  float viewed = ndl * length(vec3(along * dot(aAlong, mToEye), across * dot(aAcross, mToEye), ndv));\n  float lit = ndv * length(vec3(along * dot(aAlong, l), across * dot(aAcross, l), ndl));\n  return 3.14159265 * distribution * (0.5 / max(viewed + lit, 1e-5)) * ndl;\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 = highlightTint(mSpecColor, max(dot(mToEye, h), 0.0), mMetal);\n  mDiffuse = mAlbedo * ndl * (1.0 - mMetal);\n  float lobe = physicalSpecular()\n    ? anisotropicPhysical(l, h, ndl, sourceRadius, dist)\n    : anisotropicLobe(h, sourceRadius, dist);\n  mSpecular = ndl > 0.0 ? tint * lobe : 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

@@ -30,7 +30,16 @@ void anisotropicSurface() {
     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);
+  vec3 along = mTangent * turned.x + mBitangent * turned.y;
+  /*
+   * A mesh with neither tangents nor texture coordinates has no frame to take a direction from,
+   * and normalising the zero it gives was a NaN that drew the whole surface black. Any direction in
+   * the surface stands in, the one across the world's up, so the highlight is stretched somewhere.
+   */
+  if (dot(along, along) < 1e-12) {
+    along = cross(abs(mNormal.y) < 0.999 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0), mNormal);
+  }
+  aAlong = normalize(along);
   aAcross = cross(mNormal, aAlong);
   aStrength = strength;
 }
@@ -50,12 +59,37 @@ float anisotropicLobe(vec3 h, float sourceRadius, float dist) {
   return energy / max(d * d, 1e-8);
 }
 
+/**
+ * The same stretch as GGX's own BRDF, \`π · D · Vis · N·L\`, for a surface whose highlight is
+ * physical: the distribution normalised, and Smith's height-correlated masking stretched with it
+ * (Heitz 2014, as Filament writes it). \`anisotropicPhysicalLobe\` in anisotropicLobe.ts.
+ */
+float anisotropicPhysical(vec3 l, vec3 h, float ndl, 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 along = clamp(alongWidth + grow, alongWidth, 1.0);
+  float across = clamp(alpha + grow, alpha, 1.0);
+  float x = dot(aAlong, h) / along;
+  float y = dot(aAcross, h) / across;
+  float z = dot(mNormal, h);
+  float d = x * x + y * y + z * z;
+  float distribution = 1.0 / max(3.14159265 * along * across * d * d, 1e-8);
+  float ndv = max(dot(mNormal, mToEye), 1e-4);
+  float viewed = ndl * length(vec3(along * dot(aAlong, mToEye), across * dot(aAcross, mToEye), ndv));
+  float lit = ndv * length(vec3(along * dot(aAlong, l), across * dot(aAcross, l), ndl));
+  return 3.14159265 * distribution * (0.5 / max(viewed + lit, 1e-5)) * ndl;
+}
+
 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);
+  vec3 tint = highlightTint(mSpecColor, max(dot(mToEye, h), 0.0), mMetal);
   mDiffuse = mAlbedo * ndl * (1.0 - mMetal);
-  mSpecular = ndl > 0.0 ? tint * anisotropicLobe(h, sourceRadius, dist) : vec3(0.0);
+  float lobe = physicalSpecular()
+    ? anisotropicPhysical(l, h, ndl, sourceRadius, dist)
+    : anisotropicLobe(h, sourceRadius, dist);
+  mSpecular = ndl > 0.0 ? tint * lobe : vec3(0.0);
 }
 
 /* The environment's normal, bent toward the stretch by its strength and the surface's roughness. */

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

@@ -0,0 +1,10 @@
+/**
+ * One rectangle's light on a fragment: its form factor, and what it adds once its occlusion is
+ * known. **The one statement of it**, called by the fixed loop over the first `maxAreaLights`
+ * rectangles and by the froxel table's for the rest, so the two arms shade a rectangle with one
+ * body rather than two transcriptions of it — the zero-pixel gate between them means something
+ * only if that is so.
+ *
+ * Depth zero and after the models, whose `modelLight` it calls; see `flatFrag`.
+ */
+export declare const AREA_LIGHT_GLSL = "\n/**\n * The rectangle's signed form factor at this fragment: its corners **wound so a surface on the\n * emitting side sees them counter-clockwise**, which is what makes it positive there. The natural\n * order \u2014 minus, plus, plus, minus \u2014 winds the other way, and every one-sided light then clamped to\n * zero and the frame was black. The sign is the sidedness: a one-sided rectangle takes the positive\n * part and a two-sided one the magnitude.\n */\nfloat areaSignedForm(vec3 n, vec3 centre, vec3 right, vec3 up, vec2 halfSize) {\n  vec3 c0 = centre - right * halfSize.x + up * halfSize.y;\n  vec3 c1 = centre + right * halfSize.x + up * halfSize.y;\n  vec3 c2 = centre + right * halfSize.x - up * halfSize.y;\n  vec3 c3 = centre - right * halfSize.x - up * halfSize.y;\n  return quadFormFactor(n, vWorldPos, c0, c1, c2, c3);\n}\n\n/**\n * How far along one of a rectangle's axes a fragment still sees it past the barn door on that axis's\n * positive edge: `p` the fragment's place along the axis, `height` its height above the\n * rectangle's plane, `halfSize` the rectangle's half extent, and the door's tip `tipOut` beyond\n * the edge and `tipUp` above the plane. Points of the rectangle past the answer are hidden.\n *\n * Above the tip, the tip's shadow on the plane as seen from the fragment is the limit. Below it, a\n * fragment beside the door and outside its line is hidden from all of it, and one inside the door's\n * reach is hidden from none of it.\n */\nfloat barnDoorLimit(float p, float height, float halfSize, float tipOut, float tipUp) {\n  float tipAt = halfSize + tipOut;\n  if (height > tipUp) return (height * tipAt - tipUp * p) / (height - tipUp);\n  if (p > halfSize && height * tipOut < tipUp * (p - halfSize)) return -1e9;\n  return 1e9;\n}\n\n/**\n * The part of a rectangle a fragment sees past its barn doors, written into `centre` and\n * `halfSize` as the smaller rectangle that is left, or false where the doors hide all of it.\n * `doors` is the cosine of their angle from the normal and their length; a length of 0 is no doors.\n * Each axis is clipped by its own two doors, which is what makes this four projections and a min.\n */\nbool areaBarnDoors(inout vec3 centre, vec3 right, vec3 up, inout vec2 halfSize, vec2 doors) {\n  if (doors.y <= 0.0) return true;\n  vec3 toFragment = vWorldPos - centre;\n  float height = dot(toFragment, cross(right, up));\n  /* Behind the emitting side: nothing to clip, and the form factor already answers it. */\n  if (height <= 0.0) return true;\n  float tipOut = doors.y * sqrt(max(1.0 - doors.x * doors.x, 0.0));\n  float tipUp = doors.y * doors.x;\n  vec2 p = vec2(dot(toFragment, right), dot(toFragment, up));\n  vec2 hi = vec2(\n    min(halfSize.x, barnDoorLimit(p.x, height, halfSize.x, tipOut, tipUp)),\n    min(halfSize.y, barnDoorLimit(p.y, height, halfSize.y, tipOut, tipUp))\n  );\n  vec2 lo = vec2(\n    max(-halfSize.x, -barnDoorLimit(-p.x, height, halfSize.x, tipOut, tipUp)),\n    max(-halfSize.y, -barnDoorLimit(-p.y, height, halfSize.y, tipOut, tipUp))\n  );\n  if (hi.x <= lo.x || hi.y <= lo.y) return false;\n  centre += right * (0.5 * (lo.x + hi.x)) + up * (0.5 * (lo.y + hi.y));\n  halfSize = 0.5 * (hi - lo);\n  return true;\n}\n\n/**\n * What one rectangle of colour `color` and form factor `form` adds to the lamps' two sums, open\n * and shadowed by `occl` and `glass`.\n *\n * **A model answers a rectangle as it answers a lamp at its centre**, carried at the rectangle's\n * own energy: the diffuse by the exact form factor over the centre's cosine, the specular by the\n * form factor. An approximation, stated: a model's lobe is not integrated over the rectangle as the\n * standard lobe is, so a glossy model under a large softbox shows a lobe from its centre rather than\n * its shape.\n *\n * **The standard lobe is integrated over the rectangle**, rather than sampled at one point on it.\n * What stood here once handed the closest point on the rectangle to `sphereLobe` and scaled it by\n * `form`, the *diffuse* form factor. Measured against a brute-force integral by\n * `scripts/areaSpecular.mjs`, that lost the reflection rather than blurring it: on polished metal\n * facing a softbox it returned 0.000233 where the integral is 0.9207, and head-on on a rough surface\n * it was 3.7 times too bright. Worst 287% either way; this is 40.1% where the light is what the\n * surface reflects and 79.0% for one overhead. `quadCoverage` says what fraction of the specular\n * lobe the rectangle covers and the environment BRDF says how much the surface returns, the split\n * the probe path uses. **`dfg.x + dfg.y` and not `envSpecularEnergy`**, deliberately: the\n * compensation returns the multiply-scattered share, and every direct lobe in this shader is\n * single-scattering, so adding it here returns energy the light never had. Measured at 211%\n * against 40.1%.\n */\nvoid areaLightAdd(\n  vec3 centre,\n  vec3 right,\n  vec3 up,\n  vec2 halfSize,\n  vec3 color,\n  float form,\n  float occl,\n  vec3 glass,\n  vec3 n,\n  vec3 albedo,\n  float metal,\n  vec3 specColor,\n  float roughness,\n  bool modelled,\n  inout vec3 lampOpen,\n  inout vec3 lampShadowed\n) {\n  if (modelled) {\n    vec3 areaL = normalize(centre - vWorldPos);\n    modelLight(areaL, 0.0, 0.0);\n    vec3 areaModel = (mDiffuse * (form / max(dot(n, areaL), 1e-3)) + mSpecular * form) * color;\n    lampOpen += areaModel;\n    lampShadowed += areaModel * occl * glass;\n    return;\n  }\n  /* Held back with the point lamps', and shadowed by the same term it always was. */\n  vec3 areaDiffuse = albedo * color * form * (1.0 - metal);\n  lampOpen += areaDiffuse;\n  lampShadowed += areaDiffuse * occl * glass;\n\n  if (vSpecular > 0.0 || metal > 0.0) {\n    vec3 c0 = centre - right * halfSize.x + up * halfSize.y;\n    vec3 c1 = centre + right * halfSize.x + up * halfSize.y;\n    vec3 c2 = centre + right * halfSize.x - up * halfSize.y;\n    vec3 c3 = centre - right * halfSize.x - up * halfSize.y;\n    vec3 toEyeArea = normalize(uCameraPos - vWorldPos);\n    float coverage = quadCoverage(n, vWorldPos, toEyeArea, roughness, c0, c1, c2, c3);\n    if (coverage > 0.0) {\n      vec2 areaDfg = envBrdfApprox(max(dot(n, toEyeArea), 0.0), roughness);\n      vec3 areaSpec = specColor * areaDfg.x + vec3(areaDfg.y);\n      vec3 areaHighlight = areaSpec * color * coverage;\n      lampOpen += areaHighlight;\n      lampShadowed += areaHighlight * occl * glass;\n    }\n  }\n}\n";

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

@@ -0,0 +1,142 @@
+/**
+ * One rectangle's light on a fragment: its form factor, and what it adds once its occlusion is
+ * known. **The one statement of it**, called by the fixed loop over the first `maxAreaLights`
+ * rectangles and by the froxel table's for the rest, so the two arms shade a rectangle with one
+ * body rather than two transcriptions of it — the zero-pixel gate between them means something
+ * only if that is so.
+ *
+ * Depth zero and after the models, whose `modelLight` it calls; see `flatFrag`.
+ */
+export const AREA_LIGHT_GLSL = /* glsl */ `
+/**
+ * The rectangle's signed form factor at this fragment: its corners **wound so a surface on the
+ * emitting side sees them counter-clockwise**, which is what makes it positive there. The natural
+ * order — minus, plus, plus, minus — winds the other way, and every one-sided light then clamped to
+ * zero and the frame was black. The sign is the sidedness: a one-sided rectangle takes the positive
+ * part and a two-sided one the magnitude.
+ */
+float areaSignedForm(vec3 n, vec3 centre, vec3 right, vec3 up, vec2 halfSize) {
+  vec3 c0 = centre - right * halfSize.x + up * halfSize.y;
+  vec3 c1 = centre + right * halfSize.x + up * halfSize.y;
+  vec3 c2 = centre + right * halfSize.x - up * halfSize.y;
+  vec3 c3 = centre - right * halfSize.x - up * halfSize.y;
+  return quadFormFactor(n, vWorldPos, c0, c1, c2, c3);
+}
+
+/**
+ * How far along one of a rectangle's axes a fragment still sees it past the barn door on that axis's
+ * positive edge: \`p\` the fragment's place along the axis, \`height\` its height above the
+ * rectangle's plane, \`halfSize\` the rectangle's half extent, and the door's tip \`tipOut\` beyond
+ * the edge and \`tipUp\` above the plane. Points of the rectangle past the answer are hidden.
+ *
+ * Above the tip, the tip's shadow on the plane as seen from the fragment is the limit. Below it, a
+ * fragment beside the door and outside its line is hidden from all of it, and one inside the door's
+ * reach is hidden from none of it.
+ */
+float barnDoorLimit(float p, float height, float halfSize, float tipOut, float tipUp) {
+  float tipAt = halfSize + tipOut;
+  if (height > tipUp) return (height * tipAt - tipUp * p) / (height - tipUp);
+  if (p > halfSize && height * tipOut < tipUp * (p - halfSize)) return -1e9;
+  return 1e9;
+}
+
+/**
+ * The part of a rectangle a fragment sees past its barn doors, written into \`centre\` and
+ * \`halfSize\` as the smaller rectangle that is left, or false where the doors hide all of it.
+ * \`doors\` is the cosine of their angle from the normal and their length; a length of 0 is no doors.
+ * Each axis is clipped by its own two doors, which is what makes this four projections and a min.
+ */
+bool areaBarnDoors(inout vec3 centre, vec3 right, vec3 up, inout vec2 halfSize, vec2 doors) {
+  if (doors.y <= 0.0) return true;
+  vec3 toFragment = vWorldPos - centre;
+  float height = dot(toFragment, cross(right, up));
+  /* Behind the emitting side: nothing to clip, and the form factor already answers it. */
+  if (height <= 0.0) return true;
+  float tipOut = doors.y * sqrt(max(1.0 - doors.x * doors.x, 0.0));
+  float tipUp = doors.y * doors.x;
+  vec2 p = vec2(dot(toFragment, right), dot(toFragment, up));
+  vec2 hi = vec2(
+    min(halfSize.x, barnDoorLimit(p.x, height, halfSize.x, tipOut, tipUp)),
+    min(halfSize.y, barnDoorLimit(p.y, height, halfSize.y, tipOut, tipUp))
+  );
+  vec2 lo = vec2(
+    max(-halfSize.x, -barnDoorLimit(-p.x, height, halfSize.x, tipOut, tipUp)),
+    max(-halfSize.y, -barnDoorLimit(-p.y, height, halfSize.y, tipOut, tipUp))
+  );
+  if (hi.x <= lo.x || hi.y <= lo.y) return false;
+  centre += right * (0.5 * (lo.x + hi.x)) + up * (0.5 * (lo.y + hi.y));
+  halfSize = 0.5 * (hi - lo);
+  return true;
+}
+
+/**
+ * What one rectangle of colour \`color\` and form factor \`form\` adds to the lamps' two sums, open
+ * and shadowed by \`occl\` and \`glass\`.
+ *
+ * **A model answers a rectangle as it answers a lamp at its centre**, carried at the rectangle's
+ * own energy: the diffuse by the exact form factor over the centre's cosine, the specular by the
+ * form factor. An approximation, stated: a model's lobe is not integrated over the rectangle as the
+ * standard lobe is, so a glossy model under a large softbox shows a lobe from its centre rather than
+ * its shape.
+ *
+ * **The standard lobe is integrated over the rectangle**, rather than sampled at one point on it.
+ * What stood here once handed the closest point on the rectangle to \`sphereLobe\` and scaled it by
+ * \`form\`, the *diffuse* form factor. Measured against a brute-force integral by
+ * \`scripts/areaSpecular.mjs\`, that lost the reflection rather than blurring it: on polished metal
+ * facing a softbox it returned 0.000233 where the integral is 0.9207, and head-on on a rough surface
+ * it was 3.7 times too bright. Worst 287% either way; this is 40.1% where the light is what the
+ * surface reflects and 79.0% for one overhead. \`quadCoverage\` says what fraction of the specular
+ * lobe the rectangle covers and the environment BRDF says how much the surface returns, the split
+ * the probe path uses. **\`dfg.x + dfg.y\` and not \`envSpecularEnergy\`**, deliberately: the
+ * compensation returns the multiply-scattered share, and every direct lobe in this shader is
+ * single-scattering, so adding it here returns energy the light never had. Measured at 211%
+ * against 40.1%.
+ */
+void areaLightAdd(
+  vec3 centre,
+  vec3 right,
+  vec3 up,
+  vec2 halfSize,
+  vec3 color,
+  float form,
+  float occl,
+  vec3 glass,
+  vec3 n,
+  vec3 albedo,
+  float metal,
+  vec3 specColor,
+  float roughness,
+  bool modelled,
+  inout vec3 lampOpen,
+  inout vec3 lampShadowed
+) {
+  if (modelled) {
+    vec3 areaL = normalize(centre - vWorldPos);
+    modelLight(areaL, 0.0, 0.0);
+    vec3 areaModel = (mDiffuse * (form / max(dot(n, areaL), 1e-3)) + mSpecular * form) * color;
+    lampOpen += areaModel;
+    lampShadowed += areaModel * occl * glass;
+    return;
+  }
+  /* Held back with the point lamps', and shadowed by the same term it always was. */
+  vec3 areaDiffuse = albedo * color * form * (1.0 - metal);
+  lampOpen += areaDiffuse;
+  lampShadowed += areaDiffuse * occl * glass;
+
+  if (vSpecular > 0.0 || metal > 0.0) {
+    vec3 c0 = centre - right * halfSize.x + up * halfSize.y;
+    vec3 c1 = centre + right * halfSize.x + up * halfSize.y;
+    vec3 c2 = centre + right * halfSize.x - up * halfSize.y;
+    vec3 c3 = centre - right * halfSize.x - up * halfSize.y;
+    vec3 toEyeArea = normalize(uCameraPos - vWorldPos);
+    float coverage = quadCoverage(n, vWorldPos, toEyeArea, roughness, c0, c1, c2, c3);
+    if (coverage > 0.0) {
+      vec2 areaDfg = envBrdfApprox(max(dot(n, toEyeArea), 0.0), roughness);
+      vec3 areaSpec = specColor * areaDfg.x + vec3(areaDfg.y);
+      vec3 areaHighlight = areaSpec * color * coverage;
+      lampOpen += areaHighlight;
+      lampShadowed += areaHighlight * occl * glass;
+    }
+  }
+}
+`;

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

@@ -8,7 +8,7 @@ export declare function glassTintGlsl(glassShadows: boolean): string;
  * The lit stage's switches, by the name of the constant each is: the decision both backends make
  * about which optional code a lit program carries. See `litSwitchesGlsl`.
  */
-export type LitSwitch = 'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT';
+export type LitSwitch = 'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT' | 'PHYSICAL_SPECULAR';
 /** Every switch off: what a renderer starts from before its profile and its content say otherwise. */
 export declare function noLitSwitches(): Record<LitSwitch, boolean>;
 /** Which of the lit stage's optional features a build reads. See `litSwitchesGlsl`. */
@@ -29,6 +29,7 @@ export interface LitSwitches {
  * first uses them — a measured profile or a cookie, a material with an effects table, a DriftLight
  * volume — and then on for good; see `PipelineCache.enable` and the WebGL2 renderer's rebuild.
  * Measured on RADV against the lit shader with glass already out: 6,852 instructions and 120
- * registers, 4,641 and 96 with all four out.
+ * registers, 4,641 and 96 with all four out. `PHYSICAL_SPECULAR` is a sixth, declared with the
+ * models so that theirs keep their ids (`modelsGlsl`).
  */
 export declare function litSwitchesGlsl(switches: LitSwitches): string;

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

@@ -31,6 +31,7 @@ export function noLitSwitches() {
         LIGHT_FIXTURES: false,
         SURFACE_EFFECTS: false,
         DRIFT_LIGHT: false,
+        PHYSICAL_SPECULAR: false,
     };
 }
 /**
@@ -44,7 +45,8 @@ export function noLitSwitches() {
  * first uses them — a measured profile or a cookie, a material with an effects table, a DriftLight
  * volume — and then on for good; see `PipelineCache.enable` and the WebGL2 renderer's rebuild.
  * Measured on RADV against the lit shader with glass already out: 6,852 instructions and 120
- * registers, 4,641 and 96 with all four out.
+ * registers, 4,641 and 96 with all four out. `PHYSICAL_SPECULAR` is a sixth, declared with the
+ * models so that theirs keep their ids (`modelsGlsl`).
  */
 export function litSwitchesGlsl(switches) {
     return /* glsl */ `

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

@@ -104,6 +104,11 @@ export interface FlatShaderOptions {
     readonly surfaceEffects?: boolean;
     /** Whether it reads a DriftLight volume. True when absent. See `litSwitchesGlsl`. */
     readonly driftLight?: boolean;
+    /**
+     * Whether it carries GGX's own highlight for a material that asks (`physicalSpecular`). True
+     * when absent. See `modelsGlsl`.
+     */
+    readonly physicalSpecular?: boolean;
     /**
      * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
      *

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

@@ -14,7 +14,9 @@ import { CLOTH_BINDING_GLSL } from '../clothBinding.js';
 import { SKINNING_GLSL } from '../skinning.js';
 import { SURFACE_GLSL } from './surface.js';
 import { MAIN_GLSL } from './main.js';
-import { MODELS_GLSL } from './models.js';
+import { modelsGlsl } from './models.js';
+import { AREA_LIGHT_GLSL } from './areaLight.js';
+import { NORMAL_MAP_GLSL } from './normalMap.js';
 import { DRIFT_LIGHT_GLSL } from './driftLight.js';
 import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.js';
@@ -106,7 +108,17 @@ layout(location = 11) in vec4 aInstanceModel0;
 layout(location = 12) in vec4 aInstanceModel1;
 layout(location = 13) in vec4 aInstanceModel2;
 layout(location = 14) in vec4 aInstanceModel3;
-layout(location = 15) in vec3 aInstanceTint;
+/**
+ * The instance's tint, and its opacity in w: \`MeshInstances.alphas\`, 1 where none was given — or,
+ * in a lightmapped batch's pipeline, its region of the page (\`MeshInstances.lightmapRegions\`).
+ */
+layout(location = 15) in vec4 aInstanceTint;
+/*
+ * On in the pipeline a lightmapped material draws an instanced batch with, where the lane above is
+ * a region and not a tint: the second coordinates leave scaled and offset by it, under a tint and an
+ * opacity of one. See lightmap.ts.
+ */
+const bool LIGHTMAP_REGIONS = false; // wgsl:override
 #else
 uniform mat4 uModel;
 /**
@@ -232,7 +244,17 @@ void main() {
 #endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
-  vec3 tint = aInstanceTint;
+  /*
+   * **The bottom row is the instance's texture cell** (\`MeshInstances.uvRegions\`), which an
+   * affine placement leaves free: read, and rebuilt as the \`[0, 0, 0, 1]\` it stands for.
+   */
+  vec4 instanceCell = vec4(model[0].w, model[1].w, model[2].w, model[3].w);
+  model[0].w = 0.0;
+  model[1].w = 0.0;
+  model[2].w = 0.0;
+  model[3].w = 1.0;
+  vec3 tint = aInstanceTint.rgb;
+  if (LIGHTMAP_REGIONS) tint = vec3(1.0);
 #else
   mat4 model = uModel;
   vec3 tint = uTint;
@@ -279,17 +301,31 @@ void main() {
   vColor = aColor * tint;
   vEmissive = aEmissive;
   vSpecular = aSpecular;
+#if INSTANCED
+  /* The instance's cell first, then the material's scale and offset. */
+  vUv = vec3((aUv.xy * instanceCell.xy + instanceCell.zw) * uUvScale + uUvOffset, aUv.z);
+#else
   vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
+#endif
   vEmissiveColor = aEmissiveColor;
   vRoughness = aRoughness;
   vGrain = aGrain;
   vRelief = aRelief;
   vTangent = vec4(worldTangent, aTangent.w);
 #if INSTANCED
-  /* No channel on this path; the neutral values are what every mesh read before it existed. */
+  /*
+   * No channel on this path; the neutral values are what every mesh read before it existed — but
+   * for the opacity, which an instance carries of its own, 1 where none was given.
+   */
   vSkyDirect = 1.0;
-  vAlpha = 1.0;
+  vAlpha = aInstanceTint.w;
   vThickness = 1.0;
+  if (LIGHTMAP_REGIONS) {
+    /* Out of the lane's \`-1 - uv\`, through the region, and back into it. See lightmap.ts. */
+    vGrain = -1.0 - ((-1.0 - aGrain) * aInstanceTint.x + aInstanceTint.z);
+    vRelief = -1.0 - ((-1.0 - aRelief) * aInstanceTint.y + aInstanceTint.w);
+    vAlpha = 1.0;
+  }
 #else
   vSkyDirect = aChannel.y;
   vAlpha = aChannel.z;
@@ -426,13 +462,17 @@ export function flatFrag(options) {
          * and `main` is unconditional by construction.
          */
         TANGENT_FRAME_GLSL,
+        /* After the frame it calls, unconditional for the same reason. See normalMap.ts. */
+        NORMAL_MAP_GLSL,
         /* Unconditional for the same reason, and called only where a cutoff was asked for. */
         CUTOUT_COVERAGE_GLSL,
         CUTOUT_DITHER_GLSL,
         DRIFT_LIGHT_GLSL,
         SURFACE_EFFECTS_GLSL,
         /* Depth zero and after the tangent frame and the lobes it calls; see models.ts. */
-        MODELS_GLSL,
+        modelsGlsl(options.physicalSpecular ?? true),
+        /* After the models, whose answer to a rectangle it asks for. See areaLight.ts. */
+        AREA_LIGHT_GLSL,
         MAIN_GLSL,
     ].join('\n'), {
         POINT_SHADOWS: options.pointShadows,

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

@@ -25,4 +25,10 @@ export declare const EMISSIVE_SHADOW_SHARE = 0.55;
  * deliberately not this.
  */
 export declare const MIN_LOBE_ALPHA = 0.01;
+/**
+ * Karis's fit to the split-sum environment BRDF, as GLSL: the lit stage's, and the screen-space
+ * reflection's when a surface asks for its Fresnel (`ReflectiveSurface.fresnel`). One text, so the
+ * two cannot drift.
+ */
+export declare const ENV_BRDF_GLSL = "/**\n * The other half of the split-sum approximation: what fraction of an environment a surface returns.\n *\n * The convolution decides *what* a surface reflects at a given roughness; this decides *how much*.\n * Before it the amount was fresnel times one-minus-roughness, which is a curve somebody chose\n * standing in for an integral.\n *\n * Karis's analytic fit to the environment BRDF, so there is **no lookup texture and no texture\n * unit**: a few multiply-adds against roughness and the view angle. x scales the surface's own\n * reflectance at normal incidence and y is the additive grazing term, so a smooth dielectric at\n * f0 0.04 returns about 0.046 head-on and approaches 1 at the edge, which is what a dielectric\n * does. At roughness 1 it returns about 0.016 rather than the zero one-minus-roughness gave, which\n * is the substantive difference: a fully rough dielectric does reflect its surroundings.\n *\n * **It replaces the Fresnel factor as well as the thinning**, because the fit already contains the\n * angular dependence; multiplying by a separate Fresnel term would apply it twice.\n *\n * **How much this is worth was measured, and it is worth less than it looks on a dark room.**\n * On demo/dev/ibl.html?ladder=1 the whole ladder moved by at most 0.2 of 255 when the old term was\n * replaced. That is not the term failing: at high roughness the surface reads the coarsest levels\n * of the chain, and in a room of five dark walls and one bright one those levels are dark, so a\n * weight three times larger against a near-zero radiance is still near zero. It is worth much more\n * against a bright environment, which is what a loaded sky is and what no captured room here is.\n *\n * **A warning about reading that page, paid for once.** The ladder falls about five-fold from\n * mirror to rough, and that reads as energy being lost. It is not: a mirror concentrates the one\n * bright wall into a sharp image and a rough surface averages it against five dark ones, so the\n * falloff is the room's own content. The normalised falloff also happens to track one-minus-\n * roughness closely, which made the old term look like the cause \u2014 and removing that term entirely\n * changed nothing, which is what settled it. Perturb before believing a match.\n *\n * **What it costs** is a fit rather than the integral: the published error is around one per cent\n * of the tabulated term, far below what an eight-bit frame can show. **What would make it wrong**\n * is a material model this shader does not have \u2014 a clearcoat or a sheen lobe carries its own BRDF\n * and its own integral, and this fit is Trowbridge-Reitz with Smith masking and nothing else.\n */\nvec2 envBrdfApprox(float ndv, float roughness) {\n  const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);\n  const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);\n  vec4 r = roughness * c0 + c1;\n  float a004 = min(r.x * r.x, exp2(-9.28 * ndv)) * r.x + r.y;\n  return vec2(-1.04, 1.04) * a004 + r.zw;\n}";
 export declare const LOBES_GLSL: string;