reze-engine 0.66.5 → 0.67.0

package/src/shaders/materials/nodes.ts

@@ -471,9 +471,10 @@ fn _ag_ramp(slot: u32, uv: vec2f) -> vec4f {
  * Lamps and fog are the engine's, laid on after.
  */
 fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32, n: vec3f, l: vec3f,
-           row: f32, receive: f32, rimMask: f32, rimMid: f32, rimWidth: f32, rimTint: vec3f,
+           lightColor: vec3f, row: f32, receive: f32, rimMask: f32, rimMid: f32, rimWidth: f32, rimTint: vec3f,
            rimIntensity: f32, rimAlbedo: f32, rimInLight: f32, emissive: vec3f, reflection: f32,
-           shade: f32, face: f32, wp: vec3f, v: vec3f) -> vec3f {
+           studio: vec3f, studioBlend: f32, shade: f32, face: f32, faceSpec: f32, hair: f32, hairSpec: vec3f,
+           wp: vec3f, v: vec3f) -> vec3f {
   let diffuse = base * (1.0 - metallic);
   let f0 = mix(vec3f(0.04), base, metallic);
   let pr = clamp(roughness, 0.0, 1.0);
@@ -510,9 +511,15 @@ fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32
   let rim = tint * edge * (1.0 + rimInLight * (u - 1.0));
 
   // A face (FACE_MODE) takes no GGX: its light is the ramp, the rim and its
-  // optional SDF highlight (off unless _FaceSpecular).
+  // SDF highlight (ag_face_spec), grey, × (0.9u + 0.1).
   let isFace = face > 0.5;
-  let direct = (select(spec * f0, vec3f(0.0), isFace) + rim) * u + diffuse * ramp;
+  // Hair (_ANISOTROPIC_SPECULAR) takes its angel ring (ag_hair_ring) in place of
+  // GGX, not × F0: × (0.29u + 0.1/π).
+  let isHair = hair > 0.5;
+  var hl = select(spec * f0, hairSpec * (0.29 * u + 0.03183099), isHair);
+  hl = select(hl, vec3f(faceSpec * (0.9 * u + 0.1)), isFace);
+  // under the key light's colour, as the pass ends its direct term (× _LocalLightColor)
+  let direct = ((hl + rim) * u + diffuse * ramp) * lightColor;
 
   // the environment, with the game's fit of the split-sum
   let a004 = min((1.0 - pr) * (1.0 - pr), exp2(-9.28 * ndv)) * (1.0 - pr) + (0.0425 - 0.0275 * pr);
@@ -522,11 +529,33 @@ fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32
   let env = rzWorldSpecularLod(reflect(-v, n), pr, 1.0) * reflection;
 
   // ... and the environment at a flat 0.0157 rather than through the BRDF fit.
-  let envTerm = select((f0 * A + B) * env, env * 0.0157, isFace);
-  return emissive + rzObjectAmbient(n) * diffuse + envTerm + direct;
+  let envTerm = select((f0 * A + B) * env, env * 0.0157, isFace || isHair);
+  // the ambient: the scene's, blended toward the studio's by the material
+  let ambient = mix(rzObjectAmbient(n), studio, saturate(studioBlend));
+  return emissive + ambient * diffuse + envTerm + direct;
 }
 
 
+/**
+ * How much an albedo reads as skin, 0..1 — for a general look that has no
+ * game property mask to pick a surface's ramp row with. Skin across the game's
+ * newer characters (and the PMX textures ripped from them) is warm — red over
+ * green over blue, a hue within about 0..45 degrees — moderately saturated and
+ * fairly light; cloth, hair, metal and eyes are rarely all three.
+ */
+fn ag_skin(c: vec3f) -> f32 {
+  let s = clamp(c, vec3f(0.0), vec3f(1.0));
+  let mx = max(s.r, max(s.g, s.b));
+  let mn = min(s.r, min(s.g, s.b));
+  let sat = (mx - mn) / max(mx, 1e-4);
+  // hue in degrees for the red-to-yellow sextant, where skin lives
+  let hue = select(-1.0, 60.0 * (s.g - s.b) / max(mx - mn, 1e-4), s.r >= s.g && s.g >= s.b && mx - mn > 1e-4);
+  let warm = smoothstep(-2.0, 4.0, hue) * (1.0 - smoothstep(38.0, 52.0, hue));
+  let tinted = smoothstep(0.06, 0.14, sat) * (1.0 - smoothstep(0.55, 0.75, sat));
+  let light = smoothstep(0.35, 0.55, mx);
+  return warm * tinted * light;
+}
+
 /**
  * The face's shade from its SDF image (Uber FACE_MODE, _SDFType 0), in place of
  * N·L: the key light taken into the face's frame and flattened, the field read
@@ -560,11 +589,151 @@ fn ag_face_sdf(slot: u32, uv: vec2f, l: vec3f, n: vec3f, smoothness: f32, invert
   var m2 = max(saturate((b - th - 1.0) / k + 0.5), saturate((a - w) / k + 0.5));
   m2 = min(m2, min(saturate((a + w) / k + 0.5), saturate((b + w) / k + 0.5)));
   var r = flag * (m1 - m2) + m2;
-  r *= (1.0 - abs(lf.z)) * 0.5 + 0.5;
+  r *= (1.0 - abs(lf.y)) * 0.5 + 0.5;
   r *= saturate(dot(n, l)) * 0.5 + 0.5;
   return r;
 }
 
+/** The game's face frame (_World2Face) from the head bone: x to the face's
+ *  right, y up, z out of it — a vector in world space taken into it. */
+fn _ag_face_frame(d: vec3f) -> vec3f {
+  let hb = skinMats[u32(max(material.headBoneIndex, 0.0))];
+  return vec3f(dot(d, -normalize(hb[0].xyz)), dot(d, normalize(hb[1].xyz)), dot(d, -normalize(hb[2].xyz)));
+}
+
+/**
+ * The face's shade from its newer SDF image (Uber FACE_MODE, _SDFType 1), in
+ * place of N·L. The image paints, per texel, a normal in the face's level
+ * plane (alpha: its angle off the face's forward, toward the side the light
+ * is on) and how far it replaces the surface's own (red); three taps soften
+ * it. The painted normal yields to the real one as the light climbs, and the
+ * shade is a linear step of it against the light, _BlendSmoothness wide.
+ */
+fn ag_face_sdf_new(slot: u32, uv: vec2f, l: vec3f, n: vec3f, smoothness: f32, invert: f32) -> f32 {
+  let lf = normalize(_ag_face_frame(l));
+  let nf = normalize(_ag_face_frame(n));
+  let flip = lf.x > 0.0;
+  // Unity's v runs up: uv is the mesh's (PMX, v down)
+  let ub = vec2f(mix(uv.x, 1.0 - uv.x, invert), 1.0 - uv.y);
+  let x0 = select(ub.x, 1.0 - ub.x, flip);
+  let x1 = select(ub.x - 0.004, 1.0 - (ub.x - 0.004), flip);
+  let x2 = select(ub.x + 0.004, 1.0 - (ub.x + 0.004), flip);
+  let t0 = _ag_ramp(slot, vec2f(x0, ub.y));
+  let t1 = _ag_ramp(slot, vec2f(x1, ub.y - 0.004));
+  let t2 = _ag_ramp(slot, vec2f(x2, ub.y - 0.004));
+  let w = (t0.r + t1.r + t2.r) / 3.0;
+  let th = ((t0.a + t1.a + t2.a) / 3.0 * 2.0 - 1.0) * 1.5707964;
+  let side = select(vec3f(-1.0, 0.0, 0.0), vec3f(1.0, 0.0, 0.0), flip);
+  var ns = side * sin(th) + vec3f(0.0, 0.0, 1.0) * cos(th);
+  ns = normalize(mix(ns, nf, lf.y * lf.y));
+  ns = normalize(mix(nf, ns, w));
+  let sm = max(smoothness, 0.001);
+  let lo = -sm * w;
+  let hi = w * (sm - 1.0) + 1.0;
+  return (clamp(dot(ns, lf), lo, hi) - lo) / (hi - lo);
+}
+
+/**
+ * The face's highlight (Uber FACE_MODE with the newer SDF), its GGX: the
+ * SDF image's green and blue paint a nose and cheek glint per light angle, lit
+ * where both pass a threshold set by how far the light, swung 85% toward the
+ * camera, comes from the front; the painted band slides up with the view
+ * (_AnisotropyShift). × _Anisotropy/π, the light's frontality and N·V. The
+ * pass lays it on as u·(0.9u + 0.1)·this — ag_uber's face_spec.
+ */
+fn ag_face_spec(slot: u32, uv: vec2f, l: vec3f, n: vec3f, v: vec3f, anisotropy: f32, shift: f32) -> f32 {
+  let lf = _ag_face_frame(l);
+  let lxz = lf.xz * inverseSqrt(max(dot(lf.xz, lf.xz), 1.1754944e-38));
+  // unity_CameraToWorld column 2: OpenGL-style, the camera's BACK, toward the viewer
+  let cf = _ag_face_frame(vector_camera_to_world(vec3f(0.0, 0.0, 1.0))).xz;
+  let hd = normalize(mix(lxz, cf, 0.85));
+  let ub = vec2f(uv.x, 1.0 - uv.y);
+  let s = _ag_ramp(slot, vec2f(select(ub.x, 1.0 - ub.x, hd.x < 0.0), ub.y - v.y * shift));
+  let t = clamp(saturate(-hd.y - 0.70710677) * 3.4142134, 0.01, 0.99);
+  let on = select(0.0, 1.0, s.g >= 1.0 - t && s.b >= t);
+  return on * anisotropy / 3.14159265 * saturate((lxz.y * 0.5 + 0.5) * 4.0 - 3.0) * saturate(dot(n, v));
+}
+
+/**
+ * Aether Gazer's pupil (SimPipeline/Character/Eye, ForwardBase): unlit. The
+ * iris is a parallax-occlusion relief on the depth image (slot 0, red = height
+ * up from 1 − depth), marched in the eye's own tangent frame toward the eye of
+ * the viewer, _MinLayer..._MaxLayer layers as the view grazes; the material's
+ * picture is read where the march stops, brightened by its depth × _Intensity.
+ * A matcap (slot 2) on the normal map (slot 1, tangent normal as 0..1) scales
+ * it by (1 + matcap), and the sparkle mask (slot 3, blue / green) adds its
+ * glints, pulsing and wobbling with the clock. × level (_ProbeLightingBase).
+ */
+fn ag_eye(uv: vec2f, n: vec3f, v: vec3f, wp: vec3f, heightScale: f32, minLayer: f32, maxLayer: f32,
+          intensity: f32, mainColor: vec3f, matColor: vec3f, matPow: f32, maskScale: f32, maskSoft: f32,
+          mask2: f32, mask2Color: vec3f, mask3: f32, mask3Color: vec3f, blink: f32, blinkScale: f32,
+          scaleSpeed: f32, rotateSpeed: f32, blinkAngle: f32, level: f32) -> vec3f {
+  // the tangent frame of the mesh uvs, as the march walks them
+  let dp1 = dpdx(wp);
+  let dp2 = dpdy(wp);
+  let du1 = dpdx(uv);
+  let du2 = dpdy(uv);
+  let det = du1.x * du2.y - du2.x * du1.y;
+  let inv = select(0.0, 1.0 / det, abs(det) > 1e-12);
+  let tu = (dp1 * du2.y - dp2 * du1.y) * inv;
+  let tv = (dp2 * du1.x - dp1 * du2.x) * inv;
+  let vt = vec3f(dot(v, safe_normal(tu)), dot(v, safe_normal(tv)), dot(v, n));
+  let vz = max(abs(vt.z), 1e-3);
+  let layers = mix(ceil(maxLayer), ceil(minLayer), saturate(abs(vt.z)));
+  // against the view, both ways in these uvs: measured, the iris error 48 -> 10 of 255
+  let stp = vec3f(-vt.xy * heightScale, vz) / (layers * vz);
+  var p = vec3f(uv, 0.0) + stp;
+  var prev = vec3f(uv, 0.0);
+  var depth = 1.0 - textureSampleLevel(groupTexture0, diffuseSampler, p.xy, 0.0).r;
+  var prevDepth = 0.0;
+  for (var i = 0; i < 16; i++) {
+    if (p.z >= depth) { break; }
+    prev = p;
+    prevDepth = depth;
+    p += stp;
+    depth = 1.0 - textureSampleLevel(groupTexture0, diffuseSampler, p.xy, 0.0).r;
+  }
+  // between the last two layers, where the ray crossed the relief
+  let after = depth - p.z;
+  let before = prevDepth - prev.z;
+  let w = select(0.0, after / (after - before), abs(after - before) > 1e-6);
+  let uvP = mix(p.xy, prev.xy, w);
+  let dLast = depth;
+  var alb = textureSampleLevel(diffuseTexture, diffuseSampler, uvP, 0.0).rgb * mainColor;
+  alb += alb * dLast * intensity;
+  // the matcap, multiplied in
+  let nm = node_normal_map(textureSampleLevel(groupTexture1, diffuseSampler, uv, 0.0).rgb, 1.0, n, wp, uv);
+  let vn = (camera.view * vec4f(nm, 0.0)).xy;
+  let mc = textureSampleLevel(groupTexture2, diffuseSampler, vn * 0.5 + 0.5, 0.0).rgb * matColor * matPow;
+  var col = alb + alb * mc;
+  // the glints: the mask wobbled about the eye's centre, pulsing
+  let t = camera.time;
+  let a = sin(radians(cos(t * rotateSpeed) * blinkAngle));
+  let c = cos(a);
+  let d = uv - vec2f(0.5);
+  let uvR = select(uv, vec2f(c * d.x - a * d.y, a * d.x + c * d.y) + 0.5, blink > 0.5);
+  let m = textureSampleLevel(groupTexture3, diffuseSampler, uvR, 0.0);
+  let lo = saturate(maskScale - maskSoft);
+  let hi = saturate(maskScale + maskSoft);
+  let s1 = select(0.0, smoothstep(lo, hi, m.g), mask2 > 0.5);
+  let s2 = select(0.0, smoothstep(lo, hi, m.b), mask3 > 0.5);
+  let k = select(1.0, (sin(12.0 * t * scaleSpeed) * 0.5 + 0.7) * blinkScale, blink > 0.5);
+  col += saturate(k * s1 * mask2Color + k * s2 * mask3Color);
+  return col * level;
+}
+
+/**
+ * Aether Gazer's hair highlight, its angel ring (Uber _ANISOTROPIC_SPECULAR,
+ * _HairLightingMode 0): a band painted in the hair's uvs (the slot's image),
+ * sliding up the strands as the view climbs (_AnisotropyShift), × the ring's
+ * colour and N·V·_Anisotropy. ag_uber's hair_spec; it lays on the u factor.
+ */
+fn ag_hair_ring(slot: u32, uv: vec2f, n: vec3f, v: vec3f, color: vec3f, anisotropy: f32, shift: f32) -> vec3f {
+  let ub = vec2f(uv.x, 1.0 - uv.y);
+  let b = _ag_ramp(slot, vec2f(ub.x, ub.y - v.y * shift)).rgb;
+  return b * color * (saturate(dot(n, v)) * anisotropy);
+}
+
 fn group_tex0(uv: vec2f) -> vec4f { return textureSample(groupTexture0, diffuseSampler, uv); }
 fn group_tex1(uv: vec2f) -> vec4f { return textureSample(groupTexture1, diffuseSampler, uv); }
 fn group_tex2(uv: vec2f) -> vec4f { return textureSample(groupTexture2, diffuseSampler, uv); }

package/src/shaders/passes/composite.ts

@@ -131,7 +131,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 15>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 16>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -153,6 +153,8 @@ override APPLY_GAMMA: bool = true;
 // viewU[9] = (grade slope.rgb, grade flags) — bit 0 the CDL grade(), bit 1 the
 //            scene's own LUT (setStageGrade) — see _rzGradeScene() below.
 // viewU[10] = (camera world position, _) — refreshed with the basis above.
+// viewU[11..14] = the cast's positions (effects; count in viewU[10].w).
+// viewU[15] = (soft curve contrast, _, _, _).
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
 // The scene pass's own MSAA depth buffer, bound depth-only. NOT an extra
@@ -251,7 +253,7 @@ fn srgb_encode(x: f32) -> f32 {
  * The game's ACES branch is off in every scene measured.
  */
 fn softTransform(c: vec3f) -> vec3f {
-  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(1.4));
+  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(viewU[15].x));
   return vec3f(srgb_encode(t.r), srgb_encode(t.g), srgb_encode(t.b));
 }
 

package/src/shaders/passes/outline.ts

@@ -33,6 +33,13 @@ export const RZ_OUTLINE_WIDTH_OFFSET = 24
 /** Where the scene-wide colour override sits, in bytes: rgb and a weight, 0
  *  for the material's own edge colour (Engine.setOutlineColor). */
 export const RZ_OUTLINE_COLOR_OFFSET = 32
+/** Where a style graph's outline (ShaderGraph.outline) sits, in bytes: the
+ *  textured flag at 28, then its shadow colour at 48. Unset, a hull draws its
+ *  PMX edge colour flat, as MMD does. */
+export const RZ_OUTLINE_TEXTURED_OFFSET = 28
+export const RZ_OUTLINE_SHADOW_OFFSET = 48
+/** The hull's own block, in floats. */
+export const RZ_OUTLINE_UNIFORM_FLOATS = 16
 
 export function outlineShaderWgsl(): string {
   return /* wgsl */ `
@@ -63,17 +70,30 @@ struct MaterialUniforms {
    *  scales the author's edgeSize rather than replacing it, so a model's thin
    *  and thick lines keep their proportion. */
   widthScale: f32,
-  _padding3: f32,
+  /** 1: a style graph's outline, the game's (Uber pass "Outline"): edgeSize is
+   *  a world width, held between 1.2 and 3 px of a 1920-wide frame, and the
+   *  colour is the picture × lerp(shadowColor, edgeColor, the key's
+   *  half-Lambert). 0: the PMX edge, flat. */
+  textured: f32,
   /** The scene's colour in place of edgeColor.rgb, by .a (0 or 1). The
    *  material's own alpha still holds — a line its author made sheer stays so. */
   colorOverride: vec4f,
+  shadowColor: vec4f,
 };
 
+struct OutlineLight { direction: vec4f, color: vec4f, };
+/** The head of the scene's light block: the key is lights[0]. */
+struct OutlineLights { ambientColor: vec4f, lights: array<OutlineLight, 4>, };
+
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var edgeSampler: sampler;
+@group(0) @binding(2) var<uniform> light: OutlineLights;
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 @group(2) @binding(0) var<uniform> material: MaterialUniforms;
 @group(2) @binding(1) var diffuseTexture: texture_2d<f32>;
+/** A look's outline tint (ShaderGraph.outline.tint): one of its images, white
+ *  when it names none. */
+@group(2) @binding(2) var tintTexture: texture_2d<f32>;
 
 struct VertexOutput {
   @builtin(position) position: vec4f,
@@ -88,6 +108,7 @@ struct VertexOutput {
   /** How much of a pixel-wide line this one really is (1 = all of it): a line
    *  held at the minimum width fades by what it was short. */
   @location(3) coverage: f32,
+  @location(4) normal: vec3f,
 };
 
 /**
@@ -110,6 +131,11 @@ const RZ_OUTLINE_FULL_FIGURE = 12.5;
  *  the shortfall, so far lines thin out without aliasing into dashes. */
 const RZ_OUTLINE_MIN_PX = 1.5;
 
+fn safe_normal2(v: vec2f) -> vec2f {
+  let l = length(v);
+  return select(vec2f(0.0), v / l, l > 1e-6);
+}
+
 @vertex fn vs(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
@@ -169,21 +195,40 @@ const RZ_OUTLINE_MIN_PX = 1.5;
   // once the frame is taller than a figure. The PMX per-vertex edge scale
   // multiplies it all, as vertex colour alpha does in the game.
   let w = max(clipPos.w, 1e-4);
-  let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
-  let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
-  var ndc = nearNdc * (min(w, breakDepth) / w);
-
-  // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
-  // width and faded by the shortfall, never thinner. The game fades by
-  // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
-  // itself.
-  let px = length(ndc * deviceViewport * 0.5);
-  let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+  var ndc: vec2f;
   var coverage = 1.0;
-  if (px < minPx) {
-    coverage = px / minPx;
-    ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+  if (material.textured > 0.5) {
+    // The game's: a view-space offset of edgeSize world units along the view
+    // normal, projected, then each axis held between 1.2 px and 1.2 px ×
+    // (1 + _OutlineMaxOffsetMultiplier, 1.5) of a 1920-wide frame; a line the
+    // minimum had to push fades by how far it was pushed.
+    let off = viewNormal.xy * material.edgeSize * material.widthScale * outlineNormal.w;
+    let d1 = vec2f(off.x * camera.projection[0][0], off.y * camera.projection[1][1]) / w;
+    // the minimum along the push direction (the game's dir · 2/screen · 1.2)
+    let pxNdc = 2.0 / refViewport * 1.2 * safe_normal2(viewNormal.xy);
+    let mx = abs(pxNdc) * 2.5;
+    let o = min(mx, max(abs(d1), abs(pxNdc)));
+    // fadeOut = min(length(saturate(off − |d1|))·75, 1), on clip offsets (× w)
+    // in game units: w here is MMD units, 8 to the game's metre
+    coverage = 1.0 - min(length(saturate((o - abs(d1)) * w / 8.0)) * 75.0, 1.0);
+    ndc = o * select(vec2f(1.0), sign(d1), abs(d1) > vec2f(0.0));
+  } else {
+    let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
+    let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
+    ndc = nearNdc * (min(w, breakDepth) / w);
+
+    // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
+    // width and faded by the shortfall, never thinner. The game fades by
+    // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
+    // itself.
+    let px = length(ndc * deviceViewport * 0.5);
+    let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+    if (px < minPx) {
+      coverage = px / minPx;
+      ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+    }
   }
+  output.normal = worldNormal;
   output.coverage = coverage;
   output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);
   output.uv = uv;
@@ -215,7 +260,8 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // bind-pose position — three passes, one rule, or they disagree about which
   // pieces are still there.
   if (material.dissolve < 0.9995 && input.faceT > material.dissolve) { discard; }
-  let texA = textureSample(diffuseTexture, edgeSampler, input.uv).a;
+  let tex = textureSample(diffuseTexture, edgeSampler, input.uv);
+  let texA = tex.a;
   if (texA < 0.05) {
     discard;
   }
@@ -224,7 +270,12 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // alpha above), it is drawn right after the surface it traces so what lies
   // under a faded line is already there, and 4× MSAA would quantize a fade to
   // four steps.
-  let rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  var rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  if (material.textured > 0.5) {
+    let lit = dot(-light.lights[0].direction.xyz, normalize(input.normal)) * 0.5 + 0.5;
+    let tint = textureSample(tintTexture, edgeSampler, input.uv).rgb;
+    rgb = tex.rgb * tint * mix(material.shadowColor.rgb, rgb, lit);
+  }
   out.color = vec4f(rgb, material.edgeColor.a * texA * input.coverage);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${sceneIdPadWgsl("out")}  return out;