phoria2 1.0.0 → 1.1.0

package/src/webgl/shaders.js

@@ -10,6 +10,8 @@ export const ATTRIBUTES = {
   color: 3,
   instanceMatrix: 4, // 4-7, a mat4 takes four slots
   instanceColor: 8,
+  tangent: 9, // brushed metal's direction: along the UVs' u, and which way their v runs
+  uv2: 10, // a second UV set, for baked occlusion and light maps
   // lines: per-segment endpoints and colours, and the corner of the quad being drawn
   segmentStart: 0,
   segmentEnd: 1,
@@ -62,16 +64,30 @@ vec3 fogged(vec3 c) { return c; }
 // depth or stencil only - of what isn't cut away
 // How a map is read: by UV, or projected from the mesh's three axes (triplanar) - the same in every pass
 // that reads one, so a cut-out's shadow has the holes it is drawn with. Needs vUv declared first.
+// the samplers a mesh's maps are read through
+const MAP_SAMPLERS = ['uMap', 'uRoughnessMap', 'uMetalnessMap', 'uNormalMap', 'uBumpMap', 'uAoMap', 'uEmissiveMap', 'uLightMap']
+
 const SAMPLING = /* glsl */ `
+#ifdef UV2
+in vec2 vUv2;
+#endif
+// each map's own transform - repeat, rotation and offset - and the UV set it reads: the first
+// unless the renderer defines its set as vUv2. uMapCoord is where uMap is read and uMapTexel what
+// it holds there - spelled out per map, as WebGL's GLSL has no token pasting
+${MAP_SAMPLERS.map((m) => `uniform mat3 ${m}Uv;
+#ifndef ${m}Set
+#define ${m}Set vUv
+#endif
+#define ${m}Coord (${m}Uv * vec3(${m}Set, 1.0)).xy`).join('\n')}
 #ifdef TRIPLANAR
 in vec3 vObjectPosition;
 in vec3 vObjectNormal;
 in mat3 vObjectToWorld;
 uniform float uTriplanar; // repeats per unit of the mesh's own space
-uniform vec4 uUvTransform; // the map's repeat xy and offset zw, applied to each projection as to UVs
 
-vec2 projected(vec2 p) {
-  return p * uUvTransform.xy + uUvTransform.zw;
+// a projection's coordinates through the map's transform, as UVs would be
+vec2 projected(vec2 p, mat3 t) {
+  return (t * vec3(p, 1.0)).xy;
 }
 
 // how much each axis's projection counts: mostly the one the surface faces, blended at the turns
@@ -80,13 +96,13 @@ vec3 triplanarWeights(vec3 n) {
   return w / (w.x + w.y + w.z);
 }
 // a map seen from the three axes and blended - for meshes with no UVs, scans and CAD models
-vec4 triplanar(sampler2D s) {
+vec4 triplanar(sampler2D s, mat3 t) {
   vec3 p = vObjectPosition * uTriplanar, w = triplanarWeights(normalize(vObjectNormal));
-  return texture(s, projected(p.zy)) * w.x + texture(s, projected(p.xz)) * w.y + texture(s, projected(p.xy)) * w.z;
+  return texture(s, projected(p.zy, t)) * w.x + texture(s, projected(p.xz, t)) * w.y + texture(s, projected(p.xy, t)) * w.z;
 }
-#define SAMPLE(s) triplanar(s)
+${MAP_SAMPLERS.map((m) => `#define ${m}Texel triplanar(${m}, ${m}Uv)`).join('\n')}
 #else
-#define SAMPLE(s) texture(s, vUv)
+${MAP_SAMPLERS.map((m) => `#define ${m}Texel texture(${m}, ${m}Coord)`).join('\n')}
 #endif
 `
 
@@ -110,7 +126,7 @@ void main() {
 #ifdef ALPHA_TEST
   float alpha = uOpacity;
 #ifdef MAP
-  alpha *= SAMPLE(uMap).a;
+  alpha *= uMapTexel.a;
 #endif
   if (alpha < uAlphaTest) discard;
 #endif
@@ -186,11 +202,18 @@ layout(location = 3) in vec3 color;
 layout(location = 4) in mat4 instanceMatrix;
 layout(location = 8) in vec3 instanceColor;
 #endif
+#ifdef ANISOTROPY
+layout(location = 9) in vec4 tangent;
+out vec4 vTangent;
+#endif
+#ifdef UV2
+layout(location = 10) in vec2 uv2;
+out vec2 vUv2;
+#endif
 
 uniform mat4 uModel;
 uniform mat3 uNormalMatrix;
 uniform mat4 uViewProjection;
-uniform vec4 uUvTransform; // repeat xy, offset zw
 uniform int uHighlightIndex; // -2 none, -1 the whole node, otherwise the instance
 #ifdef FOG
 uniform mat4 uView;
@@ -238,7 +261,18 @@ void main() {
   vec4 world = uModel * local;
   vWorldPosition = world.xyz;
   vNormal = uNormalMatrix * n;
-  vUv = uv * uUvTransform.xy + uUvTransform.zw;
+  vUv = uv;
+#ifdef UV2
+  vUv2 = uv2;
+#endif
+#ifdef ANISOTROPY
+  // a direction along the surface, so it turns as the model does
+#ifdef INSTANCED
+  vTangent = vec4(mat3(uModel) * (m * tangent.xyz), tangent.w);
+#else
+  vTangent = vec4(mat3(uModel) * tangent.xyz, tangent.w);
+#endif
+#endif
 #ifdef TRIPLANAR
   vObjectPosition = position;
   vObjectNormal = normal;
@@ -306,6 +340,38 @@ uniform float uBumpScale;
 uniform sampler2D uAoMap;
 uniform float uAoMapIntensity;
 #endif
+#ifdef LIGHT_MAP
+uniform sampler2D uLightMap;
+uniform float uLightMapIntensity;
+#endif
+uniform float uEnvStrength;  // this material's share of the environment's light and reflections
+#ifdef TRANSMISSION
+uniform float uTransmission;
+#endif
+#ifdef CLEARCOAT
+uniform float uClearcoat;
+uniform float uClearcoatRoughness;
+#endif
+uniform vec4 uSpecular;      // a non-metal's reflectance face on (from its ior), and at grazing angles
+#ifdef MATCAP
+uniform sampler2D uMatcap;
+uniform mat4 uView;
+#endif
+#ifdef TOON
+uniform float uToon;         // how many tones, 2 or more
+#endif
+#ifdef SHEEN
+uniform vec3 uSheenColor;    // linear, sheen applied
+uniform float uSheenRoughness;
+#endif
+#ifdef ANISOTROPY
+uniform float uAnisotropy;
+uniform vec2 uAnisotropyDirection; // cos, sin of the brushing's turn from the UVs' u
+in vec4 vTangent;
+#endif
+#ifdef TRANSLUCENCY
+uniform vec4 uTranslucency;  // the light let through: linear colour with the amount applied, and the amount
+#endif
 
 uniform vec3 uAmbient;
 uniform vec3 uHemisphereSky;
@@ -377,25 +443,110 @@ float V_SmithGGXCorrelated(float NoV, float NoL, float a) {
   return 0.5 / max(gv + gl, 1e-5);
 }
 
-vec3 F_Schlick(float VoH, vec3 f0) {
-  return f0 + (1.0 - f0) * pow(1.0 - VoH, 5.0);
+vec3 F_Schlick(float VoH, vec3 f0, float f90) {
+  return f0 + (f90 - f0) * pow(1.0 - VoH, 5.0);
+}
+
+#ifdef ANISOTROPY
+// brushed metal: the brushing's direction, the way across it, and roughness along and across it
+vec3 brushT, brushB;
+float brushAT, brushAB;
+
+// GGX stretched along the brushing (KHR_materials_anisotropy): distribution and visibility together
+float anisotropicDV(vec3 v, vec3 l, vec3 h, float NoV, float NoL, float NoH) {
+  float a2 = brushAT * brushAB;
+  vec3 f = vec3(brushAB * dot(brushT, h), brushAT * dot(brushB, h), a2 * NoH);
+  float w2 = a2 / dot(f, f);
+  float gv = NoL * length(vec3(brushAT * dot(brushT, v), brushAB * dot(brushB, v), NoV));
+  float gl = NoV * length(vec3(brushAT * dot(brushT, l), brushAB * dot(brushB, l), NoL));
+  return a2 * w2 * w2 / PI * 0.5 / max(gv + gl, 1e-5);
 }
+#endif
 
 // Light intensity 1 on a white surface facing it gives white: the Lambert term isn't divided by
 // PI, so the specular term is multiplied by it to keep the balance. (glTF intensities in lux and
 // candela are divided by PI when loaded.)
-vec3 shade(vec3 n, vec3 v, vec3 l, vec3 radiance, vec3 diffuse, vec3 f0, float a) {
+#ifdef TOON
+// the highlight's colour: white on a non-metal, the surface's colour on a metal, fading as it roughens
+vec3 toonHighlight;
+
+// light in flat tones, antialiased where they meet: a step up a little before each tone's middle,
+// so more of a surface is lit than dark
+float toonTone(float x) {
+  float steps = uToon - 1.0;
+  float b = x * steps + 0.6;
+  float w = fwidth(b);
+  return min(floor(b) + smoothstep(1.0 - w, 1.0, fract(b)), steps) / steps;
+}
+
+// a cartoon's shading: flat tones of the colour, and one hard-edged highlight where GGX's is over
+// half its peak
+vec3 toonShade(vec3 n, vec3 v, vec3 l, vec3 radiance, vec3 diffuse, float a) {
+  float lit = toonTone(clamp(dot(n, l), 0.0, 1.0));
+  float s = D_GGX(clamp(dot(n, normalize(l + v)), 0.0, 1.0), a) * PI * a * a;
+  float w = fwidth(s);
+  float spot = smoothstep(0.5 - w, 0.5 + w, s) * step(0.001, lit);
+  return (diffuse * lit + toonHighlight * spot) * radiance;
+}
+#endif
+
+vec3 shade(vec3 n, vec3 v, vec3 l, vec3 radiance, vec3 diffuse, vec3 f0, float f90, float a) {
+#ifdef TOON
+  return toonShade(n, v, l, radiance, diffuse, a);
+#endif
   float NoL = clamp(dot(n, l), 0.0, 1.0);
   if (NoL <= 0.0) return vec3(0.0);
   vec3 h = normalize(l + v);
   float NoV = clamp(abs(dot(n, v)), 1e-4, 1.0);
   float NoH = clamp(dot(n, h), 0.0, 1.0);
   float VoH = clamp(dot(v, h), 0.0, 1.0);
-  vec3 F = F_Schlick(VoH, f0);
+  vec3 F = F_Schlick(VoH, f0, f90);
+#ifdef ANISOTROPY
+  vec3 specular = anisotropicDV(v, l, h, NoV, NoL, NoH) * F * PI;
+#else
   vec3 specular = D_GGX(NoH, a) * V_SmithGGXCorrelated(NoV, NoL, a) * F * PI;
+#endif
   return (diffuse * (1.0 - F) + specular) * radiance * NoL;
 }
 
+#ifdef SHEEN
+// cloth's sheen: the Charlie distribution (Estevez and Kulla) with Neubelt's visibility
+vec3 sheenShade(vec3 n, vec3 v, vec3 l, vec3 radiance, float a) {
+  float NoL = clamp(dot(n, l), 0.0, 1.0);
+  if (NoL <= 0.0) return vec3(0.0);
+  vec3 h = normalize(l + v);
+  float NoV = clamp(abs(dot(n, v)), 1e-4, 1.0);
+  float NoH = clamp(dot(n, h), 0.0, 1.0);
+  float invA = 1.0 / a;
+  float sin2h = max(1.0 - NoH * NoH, 0.0078125);
+  float D = (2.0 + invA) * pow(sin2h, invA * 0.5) / (2.0 * PI);
+  float V = clamp(1.0 / (4.0 * (NoL + NoV - NoL * NoV)), 0.0, 1.0);
+  return uSheenColor * D * V * PI * radiance * NoL;
+}
+
+// how much of the surroundings' light the sheen sends back: a fit to its integral (from three.js)
+float sheenEnvironment(float NoV, float r) {
+  float r2 = r * r;
+  float a = r < 0.25 ? -339.2 * r2 + 161.4 * r - 25.9 : -8.48 * r2 + 14.3 * r - 9.95;
+  float b = r < 0.25 ? 44.0 * r2 - 23.7 * r + 3.26 : 1.97 * r2 - 3.27 * r + 0.72;
+  return min(exp(a * NoV + b) + (r < 0.25 ? 0.0 : 0.1 * (r - 0.25)), PI);
+}
+#endif
+
+#ifdef CLEARCOAT
+// a clear coat's highlight: a glossy dielectric layer (f0 0.04) on the surface's own normal, so
+// normal and bump maps show beneath it, under a smooth coat
+vec3 coatShade(vec3 n, vec3 v, vec3 l, vec3 radiance, float a) {
+  float NoL = clamp(dot(n, l), 0.0, 1.0);
+  if (NoL <= 0.0) return vec3(0.0);
+  vec3 h = normalize(l + v);
+  float NoV = clamp(abs(dot(n, v)), 1e-4, 1.0);
+  float NoH = clamp(dot(n, h), 0.0, 1.0);
+  float VoH = clamp(dot(v, h), 0.0, 1.0);
+  return D_GGX(NoH, a) * V_SmithGGXCorrelated(NoV, NoL, a) * F_Schlick(VoH, vec3(0.04), 1.0) * PI * radiance * NoL;
+}
+#endif
+
 // The built-in 'studio' environment: a soft, bright overhead box over a darker floor, as a
 // function of direction - no texture needed.
 vec3 studio(vec3 d) {
@@ -406,13 +557,13 @@ vec3 studio(vec3 d) {
 }
 
 // Karis' analytic approximation of the split-sum environment BRDF.
-vec3 envBRDF(vec3 f0, float roughness, float NoV) {
+vec3 envBRDF(vec3 f0, float f90, float roughness, float NoV) {
   vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
   vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
   vec4 r = roughness * c0 + c1;
   float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
   vec2 ab = vec2(-1.04, 1.04) * a004 + r.zw;
-  return f0 * ab.x + ab.y;
+  return f0 * ab.x + ab.y * f90;
 }
 
 #ifdef ENV_MAP
@@ -429,7 +580,7 @@ vec3 envIrradiance(vec3 n) {
 // A height map as bumps: the normal tilted by how the height changes across the pixel, from
 // screen-space derivatives (Mikkelsen) - no tangents, and it works with UVs or triplanar alike
 vec3 bumpNormal(vec3 n) {
-  float h = SAMPLE(uBumpMap).r * uBumpScale;
+  float h = uBumpMapTexel.r * uBumpScale;
   vec2 dh = vec2(dFdx(h), dFdy(h));
   vec3 sx = dFdx(vWorldPosition), sy = dFdy(vWorldPosition);
   vec3 r1 = cross(sy, n), r2 = cross(n, sx);
@@ -444,9 +595,9 @@ vec3 bumpNormal(vec3 n) {
 // 'whiteout' blend), blended, then turned into the world - no tangents and no UVs needed
 vec3 triplanarNormal(float strength) {
   vec3 n = normalize(vObjectNormal), p = vObjectPosition * uTriplanar, w = triplanarWeights(n);
-  vec3 tx = texture(uNormalMap, projected(p.zy)).xyz * 2.0 - 1.0;
-  vec3 ty = texture(uNormalMap, projected(p.xz)).xyz * 2.0 - 1.0;
-  vec3 tz = texture(uNormalMap, projected(p.xy)).xyz * 2.0 - 1.0;
+  vec3 tx = texture(uNormalMap, projected(p.zy, uNormalMapUv)).xyz * 2.0 - 1.0;
+  vec3 ty = texture(uNormalMap, projected(p.xz, uNormalMapUv)).xyz * 2.0 - 1.0;
+  vec3 tz = texture(uNormalMap, projected(p.xy, uNormalMapUv)).xyz * 2.0 - 1.0;
   tx.xy *= strength; ty.xy *= strength; tz.xy *= strength;
   tx = vec3(tx.xy + n.zy, abs(tx.z) * n.x);
   ty = vec3(ty.xy + n.xz, abs(ty.z) * n.y);
@@ -455,12 +606,23 @@ vec3 triplanarNormal(float strength) {
 }
 #endif
 
+#ifdef ANISOTROPY
+// The brushing's direction: the vertices' tangents (along the UVs' u), smooth across the mesh,
+// laid onto the shading normal and turned by the rotation
+vec3 brushDirection(vec3 n) {
+  vec3 t = vTangent.xyz - n * dot(n, vTangent.xyz);
+  float len = length(t);
+  t = len > 1e-6 ? t / len : normalize(cross(abs(n.y) < 0.999 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0), n));
+  return t * uAnisotropyDirection.x + cross(n, t) * (vTangent.w < 0.0 ? -1.0 : 1.0) * uAnisotropyDirection.y;
+}
+#endif
+
 #ifdef NORMAL_MAP
 // Tangent space from screen-space derivatives (Schüler's cotangent frame), so geometry needs no
 // tangents. UVs run down the image (glTF) while normal maps point +Y up it, hence -b.
-vec3 perturbNormal(vec3 n, vec3 m) {
+vec3 perturbNormal(vec3 n, vec3 m, vec2 uv) {
   vec3 dp1 = dFdx(vWorldPosition), dp2 = dFdy(vWorldPosition);
-  vec2 duv1 = dFdx(vUv), duv2 = dFdy(vUv);
+  vec2 duv1 = dFdx(uv), duv2 = dFdy(uv);
   vec3 dp2perp = cross(dp2, n), dp1perp = cross(n, dp1);
   vec3 t = dp2perp * duv1.x + dp1perp * duv2.x;
   vec3 b = dp2perp * duv1.y + dp1perp * duv2.y;
@@ -526,21 +688,60 @@ float pointShadowAt(vec3 light, vec3 n, float distance) {
   return lit / 9.0;
 }
 #endif
+
+#ifdef MATCAP
+// A matcap - a picture of a lit sphere - looked up by the normal as the camera sees it, turned to
+// face along the line of sight so it doesn't stretch towards the edges of the view
+vec3 matcapAt(vec3 n, vec3 v) {
+  vec3 nv = normalize(mat3(uView) * n), vv = normalize(mat3(uView) * v);
+  vec3 x = normalize(vec3(vv.z, 0.0, -vv.x));
+  vec3 y = cross(vv, x);
+  vec2 uv = vec2(dot(x, nv), dot(y, nv)) * 0.495 + 0.5;
+  // the picture's top is up
+  return texture(uMatcap, vec2(uv.x, 1.0 - uv.y)).rgb;
+}
+#endif
+
+// light arriving from all round, on a surface facing n: flat, hemisphere and environment light
+vec3 irradianceAt(vec3 n) {
+  vec3 e = uAmbient + mix(uHemisphereGround, uHemisphereSky, n.y * 0.5 + 0.5);
+#ifdef ENV_MAP
+  e += envIrradiance(n) * uEnvIntensity * uEnvStrength;
+#elif defined(STUDIO)
+  e += studio(n) * 0.35 * uEnvStrength;
+#endif
+  return e;
+}
+
+// what a surface reflects of its surroundings along r - blurrier the rougher it is
+vec3 reflected(vec3 r, vec3 n, float roughness, vec3 irradiance) {
+#ifdef ENV_MAP
+  // a lower mip, convolved for that roughness
+  return textureLod(uEnvMap, equirectUv(r), roughness * uEnvMaxLod).rgb * uEnvIntensity * uEnvStrength;
+#elif defined(STUDIO)
+  // leaned towards the surface normal
+  return mix(studio(r), studio(n), roughness * roughness) * uEnvStrength;
+#else
+  return irradiance * 0.5;
+#endif
+}
 #endif
 
 void main() {
   clipAway(vWorldPosition);
   vec4 base = vec4(uColor * vColor, uOpacity);
 #ifdef MAP
-  base *= SAMPLE(uMap); // sRGB textures are decoded to linear by the hardware
+  base *= uMapTexel; // sRGB textures are decoded to linear by the hardware
 #endif
 #ifdef ALPHA_TEST
   if (base.a < uAlphaTest) discard;
   base.a = 1.0;
 #endif
+  // how much of what is behind it this hides: its opacity - less for glass, which lets light through
+  float coverage = base.a;
   vec3 emissive = uEmissive;
 #ifdef EMISSIVE_MAP
-  emissive *= SAMPLE(uEmissiveMap).rgb;
+  emissive *= uEmissiveMapTexel.rgb;
 #endif
 
 #ifdef LIT
@@ -561,27 +762,64 @@ void main() {
   if (!gl_FrontFacing) n = -n;
 #endif
 #else
-  vec3 m = texture(uNormalMap, vUv).xyz * 2.0 - 1.0;
+  // tangent space from the map's own UVs, so it turns with a rotated map
+  vec2 normalUv = uNormalMapCoord;
+  vec3 m = texture(uNormalMap, normalUv).xyz * 2.0 - 1.0;
   m.xy *= uNormalScale;
-  n = perturbNormal(n, m);
+  n = perturbNormal(n, m, normalUv);
 #endif
 #endif
 #ifdef BUMP_MAP
   n = bumpNormal(n);
 #endif
   vec3 v = normalize(uCameraPosition - vWorldPosition);
+#ifdef MATCAP
+  // its look from the picture, by the normal: no lights, and its colours kept as they are, as unlit ones are
+  vec3 color = base.rgb * matcapAt(n, v) + emissive;
+#else
   float roughness = uRoughness;
   float metalness = uMetalness;
 #ifdef ROUGHNESS_MAP
-  roughness *= SAMPLE(uRoughnessMap).g;
+  roughness *= uRoughnessMapTexel.g;
 #endif
 #ifdef METALNESS_MAP
-  metalness *= SAMPLE(uMetalnessMap).b;
+  metalness *= uMetalnessMapTexel.b;
 #endif
   roughness = clamp(roughness, 0.04, 1.0);
   float a = roughness * roughness;
   vec3 diffuse = base.rgb * (1.0 - metalness);
-  vec3 f0 = mix(vec3(0.04), base.rgb, metalness);
+  vec3 f0 = mix(uSpecular.rgb, base.rgb, metalness);
+  float f90 = mix(uSpecular.a, 1.0, metalness);
+#ifdef TOON
+  // a cartoon's metal is its colour too, with a highlight of that colour
+  diffuse = base.rgb;
+  toonHighlight = mix(vec3(uSpecular.a), base.rgb, metalness) * (1.0 - roughness);
+#endif
+#ifdef TRANSMISSION
+  // glass: what passes through isn't scattered back, so less diffuse colour - and the reflections
+  // stay whole, however clear it is
+  diffuse *= 1.0 - uTransmission;
+#endif
+#ifdef CLEARCOAT
+  float coatRoughness = clamp(uClearcoatRoughness, 0.04, 1.0);
+  float coatA = coatRoughness * coatRoughness;
+  vec3 coat = vec3(0.0);
+#endif
+#ifdef SHEEN
+  float sheenRoughness = clamp(uSheenRoughness, 0.07, 1.0);
+  vec3 sheen = vec3(0.0);
+#endif
+#ifdef ANISOTROPY
+  brushT = brushDirection(n);
+  brushB = cross(n, brushT);
+  brushAT = mix(a, 1.0, uAnisotropy * uAnisotropy);
+  brushAB = max(a, 0.001);
+#endif
+#ifdef TRANSLUCENCY
+  // thin surfaces: what isn't scattered back comes through, lit from the far side
+  vec3 through = diffuse * uTranslucency.rgb;
+  diffuse *= 1.0 - uTranslucency.a;
+#endif
 
   vec3 color = vec3(0.0);
 #if NUM_DIRECTIONAL > 0
@@ -591,7 +829,24 @@ void main() {
     // the shadow-casting light always comes first
     if (i == 0) radiance *= shadowAt(surfaceNormal, uDirectionalDirection[0]);
 #endif
-    color += shade(n, v, uDirectionalDirection[i], radiance, diffuse, f0, a);
+    color += shade(n, v, uDirectionalDirection[i], radiance, diffuse, f0, f90, a);
+#ifdef CLEARCOAT
+    coat += coatShade(surfaceNormal, v, uDirectionalDirection[i], radiance, coatA);
+#endif
+#ifdef SHEEN
+    sheen += sheenShade(n, v, uDirectionalDirection[i], radiance, sheenRoughness * sheenRoughness);
+#endif
+#ifdef TRANSLUCENCY
+    float behind = clamp(-dot(n, uDirectionalDirection[i]), 0.0, 1.0);
+    if (behind > 0.0) {
+      vec3 light = uDirectionalColor[i];
+#ifdef SHADOW
+      // shadowed as the far side is: what lights it comes through
+      if (i == 0) light *= shadowAt(-surfaceNormal, uDirectionalDirection[0]);
+#endif
+      color += through * light * behind;
+    }
+#endif
   }
 #endif
 #if NUM_PUNCTUAL > 0
@@ -613,42 +868,89 @@ void main() {
 #ifdef POINT_SHADOW
     if (float(i) == uPointShadowIndex) radiance *= pointShadowAt(uPunctualPosition[i], surfaceNormal, d);
 #endif
-    color += shade(n, v, l, radiance, diffuse, f0, a);
+    color += shade(n, v, l, radiance, diffuse, f0, f90, a);
+#ifdef CLEARCOAT
+    coat += coatShade(surfaceNormal, v, l, radiance, coatA);
+#endif
+#ifdef SHEEN
+    sheen += sheenShade(n, v, l, radiance, sheenRoughness * sheenRoughness);
+#endif
+#ifdef TRANSLUCENCY
+    float behind = clamp(-dot(n, l), 0.0, 1.0);
+    if (behind > 0.0) {
+      vec3 light = uPunctualColor[i] * falloff * cone;
+#ifdef SPOT_SHADOWS
+      if (tile >= 0.0 && cone > 0.0) light *= spotShadowAt(int(tile), -surfaceNormal, d);
+#endif
+#ifdef POINT_SHADOW
+      if (float(i) == uPointShadowIndex) light *= pointShadowAt(uPunctualPosition[i], -surfaceNormal, d);
+#endif
+      color += through * light * behind;
+    }
+#endif
   }
 #endif
 
   // ambient: flat, hemisphere and environment light
-  vec3 irradiance = uAmbient + mix(uHemisphereGround, uHemisphereSky, n.y * 0.5 + 0.5);
+  vec3 irradiance = irradianceAt(n);
   float NoV = clamp(abs(dot(n, v)), 1e-4, 1.0);
-  vec3 brdf = envBRDF(f0, roughness, NoV);
-  vec3 ambientSpecular;
-#ifdef ENV_MAP
-  irradiance += envIrradiance(n) * uEnvIntensity;
-  vec3 r = reflect(-v, n);
-  // rougher surfaces see a blurrier reflection: a lower mip, convolved for that roughness
-  ambientSpecular = textureLod(uEnvMap, equirectUv(r), roughness * uEnvMaxLod).rgb * uEnvIntensity * brdf;
-#elif defined(STUDIO)
-  irradiance += studio(n) * 0.35;
-  vec3 r = reflect(-v, n);
-  // rougher surfaces see a blurrier reflection: lean it towards the surface normal
-  ambientSpecular = mix(studio(r), studio(n), roughness * roughness) * brdf;
+  vec3 brdf = envBRDF(f0, f90, roughness, NoV);
+#ifdef ANISOTROPY
+  // reflections drawn out along the brushing: off a normal bent across it (KHR_materials_anisotropy)
+  vec3 brushNormal = cross(cross(brushB, v), brushB);
+  float bend = 1.0 - uAnisotropy * (1.0 - roughness);
+  bend *= bend;
+  vec3 r = reflect(-v, normalize(mix(brushNormal, n, bend * bend)));
 #else
-  ambientSpecular = irradiance * brdf * 0.5;
+  vec3 r = reflect(-v, n);
 #endif
+#ifdef TOON
+  // a flat fill, so the tones stay flat: the light from all round, averaged over up and down
+  vec3 indirect = diffuse * 0.5 * (irradianceAt(vec3(0.0, 1.0, 0.0)) + irradianceAt(vec3(0.0, -1.0, 0.0)));
+#else
+  vec3 ambientSpecular = reflected(r, n, roughness, irradiance) * brdf;
   vec3 indirect = diffuse * irradiance + ambientSpecular;
+#endif
+#ifdef TRANSLUCENCY
+  indirect += through * irradianceAt(-n);
+#endif
+#ifdef LIGHT_MAP
+  // light baked into a texture, as more light from all round
+  indirect += diffuse * uLightMapTexel.rgb * uLightMapIntensity;
+#endif
 #ifdef AO_MAP
-  indirect *= mix(1.0, SAMPLE(uAoMap).r, uAoMapIntensity);
+  indirect *= mix(1.0, uAoMapTexel.r, uAoMapIntensity);
 #endif
   color += indirect + emissive;
+#ifdef SHEEN
+  // over the base, which loses a little of its light to it
+  sheen += irradiance * uSheenColor * sheenEnvironment(NoV, sheenRoughness);
+  color = color * (1.0 - 0.157 * max(uSheenColor.r, max(uSheenColor.g, uSheenColor.b))) + sheen;
+#endif
+#ifdef CLEARCOAT
+  // the coat's reflection, over the base - which loses the light the coat reflects away
+  float coatNoV = clamp(abs(dot(surfaceNormal, v)), 1e-4, 1.0);
+  coat += reflected(reflect(-v, surfaceNormal), surfaceNormal, coatRoughness, irradiance) * envBRDF(vec3(0.04), 1.0, coatRoughness, coatNoV);
+  color = color * (1.0 - uClearcoat * F_Schlick(coatNoV, vec3(0.04), 1.0).x) + coat * uClearcoat;
+#endif
+#ifdef TRANSMISSION
+  // most of what is behind glass shows through face on; towards its edges, where it reflects nearly
+  // everything (Fresnel), less and less
+  coverage *= mix(1.0, clamp(max(brdf.r, max(brdf.g, brdf.b)), 0.0, 1.0), uTransmission);
+#endif
   color = toneMap(color);
+#endif
 #else
   vec3 color = base.rgb + emissive;
 #endif
   color = mix(color, uHighlight.rgb, vHighlight * uHighlight.a);
+  // a highlight shows on glass as on anything else
+  coverage = mix(coverage, base.a, vHighlight * uHighlight.a);
   color = fogged(color);
 
-  // premultiplied alpha, so the canvas composites correctly over the page
-  fragColor = vec4(linearToSrgb(color) * base.a, base.a);
+  // premultiplied alpha, so the canvas composites correctly over the page. The colour is the light
+  // the surface sends back - faded with its opacity; coverage is how much of what is behind it hides
+  fragColor = vec4(linearToSrgb(color) * base.a, coverage);
 }
 `