three-realtime-rt 0.3.2 → 0.4.2

package/src/RTLightingPass.js

@@ -26,6 +26,7 @@ ${SKY_GLSL}
 #define PI 3.14159265358979
 
 layout(location = 0) out vec4 outIrradiance;
+layout(location = 1) out vec4 outSpecular; // dielectric direct specular (fresh, this frame)
 
 in vec2 vUv;
 
@@ -60,8 +61,10 @@ uniform vec4 uLightColorRadius[MAX_LIGHTS]; // rgb color*intensity, w radius
 uniform vec4 uLightDirCone[MAX_LIGHTS];     // spot: direction.xyz + cos(outer angle)
 uniform int uLightCount;
 uniform int uEmissiveCount; // NEE area-light triangles in row 1 of uMaterialsTex
+uniform bool uEmissiveCDF;  // importance-sample tris by the power CDF (row 66)
 uniform bool uReflEnabled;  // traced reflections on metallic surfaces
 uniform bool uRefrEnabled;  // traced refraction on transmissive surfaces
+uniform bool uBlendEnabled; // straight-through view continuation on blend surfaces
 uniform float uIor;         // index of refraction for transmissive materials
 uniform bool uLightStochastic; // 1 direct shadow ray/pixel/frame instead of 1/light
 uniform bool uRestirEnabled;   // shade the reservoir winner instead of sampling
@@ -176,6 +179,57 @@ void fetchMaterial(float matIndex, out vec3 albedo, out float roughness,
   metalness = t1.a;
 }
 
+// ---------- PBR specular (Cook-Torrance GGX) ----------
+// A separate specular radiance is accumulated for the primary surface's DIRECT
+// lighting alongside the demodulated diffuse irradiance. Because CompositePass
+// multiplies the irradiance by albedo, a white dielectric highlight (F0 ~= 0.04)
+// cannot ride in that buffer — it is emitted into gSpec and written to a second
+// MRT attachment (added by the composite WITHOUT the albedo multiply). Metals'
+// specular is albedo-tinted (F0 = albedo), so it stays in the reflection path
+// where the composite's albedo multiply supplies the tint; gSpec is therefore
+// scaled by (1 - metal)(1 - transmission) at output. Net effective Fresnel
+// across both buffers is mix(0.04, albedo, metal) without the lighting pass ever
+// sampling albedo (that would push it past the 16-sampler minimum).
+vec3 gSpec;        // accumulated dielectric direct specular radiance
+vec3 gViewDir;     // unit vector from the primary surface toward the camera
+float gSpecRough;  // primary surface roughness (drives the GGX lobe width)
+bool gWantSpec;    // true only while shading the PRIMARY surface's direct light
+
+float D_GGX(float NoH, float a) {
+  float a2 = a * a;
+  float d = NoH * NoH * (a2 - 1.0) + 1.0;
+  return a2 / max(PI * d * d, 1e-8);
+}
+// Height-correlated Smith visibility (already folds in the 1/(4 NoL NoV) term).
+float V_SmithGGX(float NoV, float NoL, float a) {
+  float a2 = a * a;
+  float gv = NoL * sqrt(NoV * NoV * (1.0 - a2) + a2);
+  float gl = NoV * sqrt(NoL * NoL * (1.0 - a2) + a2);
+  return 0.5 / max(gv + gl, 1e-5);
+}
+vec3 F_Schlick(float VoH, vec3 f0) {
+  return f0 + (1.0 - f0) * pow(clamp(1.0 - VoH, 0.0, 1.0), 5.0);
+}
+// Specular BRDF value (without the incoming NoL*radiance factor). F0 fixed at
+// the dielectric 0.04 — metals are handled in the reflection path.
+float ggxSpec(vec3 N, vec3 L) {
+  vec3 H = normalize(gViewDir + L);
+  float NoH = max(dot(N, H), 0.0);
+  float NoV = max(dot(N, gViewDir), 1e-4);
+  float NoL = max(dot(N, L), 1e-4);
+  float VoH = max(dot(gViewDir, H), 0.0);
+  // Clamp alpha off zero so a mirror-smooth dielectric does not produce an
+  // infinite spike the temporal buffer cannot resolve.
+  float a = max(gSpecRough * gSpecRough, 2e-3);
+  return D_GGX(NoH, a) * V_SmithGGX(NoV, NoL, a) * F_Schlick(VoH, vec3(0.04)).x;
+}
+// Add the dielectric specular for one light: li is the incoming radiance
+// factor (light colour * cone / dist^2), NoL the geometric cosine.
+void addSpec(vec3 N, vec3 L, vec3 li, float NoL) {
+  if (!gWantSpec) return;
+  gSpec += li * (NoL * ggxSpec(N, L));
+}
+
 // ---------- lighting ----------
 // Direct irradiance (demodulated: no albedo) at point P with normal N,
 // from light i, with one shadow ray. Area-samples point lights for soft shadows.
@@ -218,7 +272,9 @@ vec3 lightContribution(int i, vec3 P, vec3 N) {
   if (NdotL <= 0.0) return vec3(0.0);
 
   if (occluded(P + N * uEps, L, maxDist)) return vec3(0.0);
-  return colRad.rgb * (cone * NdotL / dist2);
+  vec3 li = colRad.rgb * (cone / dist2);
+  addSpec(N, L, li, NdotL); // same shadow ray shadows the highlight
+  return li * NdotL;
 }
 
 // Direct light at a GI bounce hit: sample ONE random light (weighted by count).
@@ -232,9 +288,44 @@ vec3 sampleOneLight(vec3 P, vec3 N) {
 // pick one triangle, sample a point on it, cast one shadow ray, convert the
 // area pdf to solid angle. Turns emitters into proper soft area lights instead
 // of surfaces a GI ray has to hit by luck.
+//
+// NOISE CAVEAT: emissive NEE is the highest-variance direct-light path in the
+// engine — one triangle sample per pixel per frame, and the area-to-solid-angle
+// conversion carries a 1/dist^2 that spikes into fireflies when a shading point
+// sits close to a small emitter. Two mitigations stack here:
+//  1. uEmissiveCDF (default on): the triangle is IMPORTANCE-SAMPLED by
+//     area x emitted luminance via the power CDF in the scene-data texture
+//     (row 2 + 64 — see SceneCompiler's layout comment). A big bright panel is
+//     picked proportionally more often than a tiny dim strip, and each sample
+//     is weighted by its true pick probability — same mean, far less variance
+//     than the uniform 1-of-N pick.
+//  2. ReSTIR reservoirs converge each pixel onto the emitter that matters
+//     (the demo keeps restir on whenever emissive NEE is on;
+//     RealtimeRaytracer.compileScene logs a hint otherwise).
+// fireflyClamp and the denoiser absorb the residual tail. Distance-aware
+// selection and solid-angle triangle sampling remain future work.
 vec3 sampleEmissiveTri(vec3 P, vec3 N) {
   if (uEmissiveCount == 0) return vec3(0.0);
-  int i = min(int(rand() * float(uEmissiveCount)), uEmissiveCount - 1) * 4;
+  int idx;
+  float invProb; // 1 / P(picked this triangle)
+  if (uEmissiveCDF) {
+    // Binary search the power CDF: 8 steps covers MAX_EMISSIVE_TRIS = 256.
+    float u = rand();
+    int lo = 0;
+    int hi = uEmissiveCount - 1;
+    for (int s = 0; s < 8; s++) {
+      if (lo >= hi) break;
+      int mid = (lo + hi) >> 1;
+      if (u > texelFetch(uMaterialsTex, ivec2(mid, 66), 0).x) lo = mid + 1;
+      else hi = mid;
+    }
+    idx = lo;
+    invProb = 1.0 / max(texelFetch(uMaterialsTex, ivec2(idx, 66), 0).y, 1e-8);
+  } else {
+    idx = min(int(rand() * float(uEmissiveCount)), uEmissiveCount - 1);
+    invProb = float(uEmissiveCount);
+  }
+  int i = idx * 4;
   vec4 t0 = texelFetch(uMaterialsTex, ivec2(i, 1), 0);     // v0 | area
   vec4 t1 = texelFetch(uMaterialsTex, ivec2(i + 1, 1), 0); // e1 | emit.r
   vec4 t2 = texelFetch(uMaterialsTex, ivec2(i + 2, 1), 0); // e2 | emit.g
@@ -256,9 +347,14 @@ vec3 sampleEmissiveTri(vec3 P, vec3 N) {
   if (cosS <= 0.0 || cosL < 1e-4) return vec3(0.0);
   if (occluded(P + N * uEps, wi, dist)) return vec3(0.0);
 
-  // Uniform pick of 1-of-count tris + uniform point: pdf_area = 1/(count·area).
-  // Solid-angle conversion gives irradiance Le · cosS · cosL / (d² · pdf_area).
-  vec3 e = vec3(t1.w, t2.w, t3.w) * (cosS * cosL * float(uEmissiveCount) * t0.w / max(d2, 1e-6));
+  // Pick of one tri (probability 1/invProb) + uniform point on it:
+  // pdf_area = 1/(invProb·area). Solid-angle conversion gives irradiance
+  // Le · cosS · cosL / (d² · pdf_area).
+  vec3 e = vec3(t1.w, t2.w, t3.w) * (cosS * cosL * invProb * t0.w / max(d2, 1e-6));
+
+  // Dielectric highlight from this emitter: e already folds in cosS, so the
+  // specular is e * (GGX BRDF) toward the sampled point (wi).
+  if (gWantSpec) gSpec += e * ggxSpec(N, wi);
 
   // Uniform-area sampling has huge single-sample variance for receivers close
   // to a big emitter (sampled point can land almost on top of P, d² → 0);
@@ -336,6 +432,9 @@ vec3 shadeReservoir(vec3 P, vec3 N) {
   }
 
   if (occluded(P + N * uEps, wi, maxDist)) return vec3(0.0);
+  // Dielectric highlight from the reservoir winner (C = li * cos, shared with
+  // the diffuse term; W = res.a is applied to both).
+  if (gWantSpec) gSpec += C * (ggxSpec(N, wi) * res.a);
   vec3 e = C * res.a;
   // Safety clamp, same budget as the emissive direct clamp elsewhere.
   float l = dot(e, vec3(0.299, 0.587, 0.114));
@@ -401,11 +500,52 @@ vec3 glossyReflect(vec3 V, vec3 N, float rough) {
   return refl;
 }
 
+// Analytic lights live in uniform arrays, not the BVH, so a traced reflection
+// ray never sees them — a mirror under a spotlight would show no glint. Evaluate
+// each light as a small area source along the (roughness-jittered) reflection
+// direction: if refl points within the light's angular radius, the light's disc
+// is reflected, so add its radiance. The jitter in refl (from glossyReflect)
+// softens the disc over temporal accumulation, widening the glint with
+// roughness. Shadowed with the same any-hit occluder as direct lighting.
+vec3 analyticGlint(vec3 P, vec3 refl) {
+  vec3 sum = vec3(0.0);
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= uLightCount) break;
+    vec4 posType = uLightPosType[i];
+    vec4 colRad = uLightColorRadius[i];
+    if (posType.w < 0.5 || posType.w >= 1.5) {
+      // point / spot
+      vec3 d = posType.xyz - P;
+      float dl = length(d);
+      if (dl < 1e-4) continue;
+      vec3 toL = d / dl;
+      float cone = spotFalloff(i, -toL);
+      if (cone <= 0.0) continue;
+      // Angular radius of the sphere light + a small floor so a zero-radius
+      // light still shows a pin-point glint.
+      float ang = atan(max(colRad.w, 1e-3) / dl) + 0.01;
+      if (dot(refl, toL) < cos(ang)) continue;
+      if (occluded(P + refl * uEps, refl, dl)) continue;
+      sum += colRad.rgb * (cone / (dl * dl));
+    } else {
+      // directional: fixed small angular size (colRad.w = sun softness)
+      vec3 toL = normalize(-posType.xyz);
+      float ang = max(colRad.w, 0.02) + 0.01;
+      if (dot(refl, toL) < cos(ang)) continue;
+      if (occluded(P + refl * uEps, refl, 1e7)) continue;
+      sum += colRad.rgb;
+    }
+  }
+  return sum;
+}
+
 // Glass: Fresnel-weighted blend of a surface reflection and a two-interface
 // refraction (enter at P, march to the exit surface, refract again).
 vec3 glassRadiance(vec3 P, vec3 N, vec3 V, float rough) {
   vec3 refl = glossyReflect(V, N, rough);
-  vec3 reflRad = dot(refl, N) > 0.0 ? traceRadiance(P + N * uEps, refl, true) : vec3(0.0);
+  vec3 reflRad = dot(refl, N) > 0.0
+    ? traceRadiance(P + N * uEps, refl, true) + analyticGlint(P, refl)
+    : vec3(0.0);
 
   float eta = 1.0 / uIor;
   vec3 rd = refract(V, N, eta);
@@ -438,6 +578,7 @@ void main() {
   vec4 wp = texture(uGWorldPos, vUv);
   if (wp.w < 0.5) {
     outIrradiance = vec4(0.0);
+    outSpecular = vec4(0.0);
     return;
   }
 
@@ -450,11 +591,23 @@ void main() {
   vec3 P = wp.xyz;
   vec4 nmSample = texture(uGNormalMetal, vUv);
   vec3 N = normalize(nmSample.xyz);
-  // Decode the packed material word (see GBufferPass): >= 2 → glass, else metal.
-  float transmission = nmSample.w >= 2.0 ? clamp(nmSample.w - 2.0, 0.0, 1.0) : 0.0;
-  float metal = nmSample.w >= 2.0 ? 0.0 : nmSample.w;
+  // Decode the packed material word (see GBufferPass): [4,5] → alpha blend
+  // (w - 4 = opacity), [2,4) → glass (w - 2 = transmission), else metalness.
+  float matW = nmSample.w;
+  bool blend = matW >= 4.0;
+  float opacity = blend ? clamp(matW - 4.0, 0.0, 1.0) : 1.0;
+  float transmission = (matW >= 2.0 && matW < 4.0) ? clamp(matW - 2.0, 0.0, 1.0) : 0.0;
+  float metal = matW < 2.0 ? matW : 0.0;
   float rough = clamp(wp.w - 1.0, 0.0, 1.0);
 
+  // Cook-Torrance specular state for this primary surface. gWantSpec gates the
+  // GGX term to PRIMARY direct lighting only (GI-bounce direct light, below,
+  // reuses the same functions but must not pollute the highlight buffer).
+  gSpec = vec3(0.0);
+  gViewDir = normalize(uCameraPos - P);
+  gSpecRough = rough;
+  gWantSpec = true;
+
   // --- direct lighting ---
   // ReSTIR: shade the reservoir's winner with one visibility ray (flat cost in
   // light count). Stochastic: one blind random sample. Full: one shadow ray
@@ -480,11 +633,30 @@ void main() {
   // DOUBLED — the temporal average converges to the same brightness
   // (unbiased) while GI's ray cost halves; accumulation + denoise absorb
   // the alternation.
+  gWantSpec = false; // secondary bounces contribute to diffuse GI only
+  // BLEND pixels reuse THIS call site as their straight-through view
+  // continuation instead of a GI bounce (their behind-image rides the specular
+  // attachment; the pane forgoes its own GI bounce — visually negligible, and
+  // it saves a ray). CRITICAL CALL-SITE BUDGET: traceRadiance may appear at
+  // most THREE times in this shader (glass refraction exit, this unified
+  // secondary site, the metal-reflection path). WebKit's GLSL->Metal
+  // translation silently emits a broken program at a FOURTH inlined call site
+  // (clean compile, black output on every iOS browser) — bisected live on an
+  // iPad, 2026-07-22. Never add a call site; extend this one.
   vec3 indirect = vec3(0.0);
-  if (uGIEnabled) {
-    bool trace = !uGIHalfRate || (((px.x + px.y + int(uFrame)) & 1) == 0);
-    if (trace) {
-      indirect = traceRadiance(P + N * uEps, cosineSampleHemisphere(N, rand2()), false);
+  vec3 blendBehind = vec3(0.0);
+  bool wantBehind = uBlendEnabled && blend;
+  bool wantGI = uGIEnabled && !wantBehind
+    && (!uGIHalfRate || (((px.x + px.y + int(uFrame)) & 1) == 0));
+  if (wantBehind || wantGI) {
+    vec3 Vv = normalize(P - uCameraPos);
+    vec3 dir = wantBehind ? Vv : cosineSampleHemisphere(N, rand2());
+    vec3 org = wantBehind ? P + Vv * uEps : P + N * uEps;
+    vec3 r = traceRadiance(org, dir, wantBehind);
+    if (wantBehind) {
+      blendBehind = r;
+    } else {
+      indirect = r;
       if (uGIHalfRate) indirect *= 2.0;
     }
   }
@@ -503,7 +675,10 @@ void main() {
     if (dot(refl, N) > 0.0) {
       // Metals have no diffuse term: replace by metalness. The composite's
       // albedo multiply then tints the reflection (F0 = albedo for metals).
-      sampleIrr = mix(sampleIrr, traceRadiance(P + N * uEps, refl, true), metal);
+      // analyticGlint adds the direct lights the reflection ray cannot see, so
+      // a metal under a spotlight shows a proper (albedo-tinted) glint.
+      vec3 reflRad = traceRadiance(P + N * uEps, refl, true) + analyticGlint(P, refl);
+      sampleIrr = mix(sampleIrr, reflRad, metal);
     }
   }
 
@@ -513,10 +688,45 @@ void main() {
     sampleIrr = mix(sampleIrr, glassRadiance(P, N, V, rough), transmission);
   }
 
+  // --- alpha blend: straight-through view continuation ---
+  // A transparent surface is primary-visible in the G-buffer but was kept out of
+  // the BVH, so a ray along the view direction passes THROUGH it to whatever is
+  // behind. Trace that continuation and shade it like a glass/GI hit (emitters
+  // keep their emission — this is direct visibility through the pane — sky/env on
+  // a miss). The two quantities live at DIFFERENT scales: sampleIrr is the
+  // pane's own demodulated surface light (composite re-applies albedo), while
+  // the behind trace is final outgoing radiance — mixing them in one slot makes
+  // the pane term drown out what shows through. So the behind image rides the
+  // SPECULAR attachment instead (composite adds that buffer without the albedo
+  // multiply, and its short-history accumulation suits behind-content that
+  // parallaxes against the pane), and CompositePass performs the opacity blend
+  // where the pane's albedo is actually available. sampleIrr keeps only the
+  // pane's own surface lighting, which is static on the surface and accumulates
+  // with normal full-length history.
+  // (The straight-through trace itself happens at the unified secondary-ray
+  // call site above — see the Metal call-site-count note there.)
+
   // A single NaN/Inf sample would poison the EMA history for good (mix() with
   // NaN stays NaN until a disocclusion resets the pixel) — sanitize first.
   if (any(isnan(sampleIrr)) || any(isinf(sampleIrr))) sampleIrr = vec3(0.0);
 
+  // Fresh dielectric direct specular for this frame. Metals/glass carry their
+  // (albedo-tinted) specular in the reflection path above, so scale their share
+  // out of the white buffer — the effective F0 is mix(0.04, albedo, metal),
+  // split across the two buffers. The separate SpecularAccumPass reprojects and
+  // temporally accumulates this with a short (near-mirror) history.
+  // Blend pixels repurpose this attachment for the straight-through behind
+  // radiance (see above) — their dielectric highlight is dropped, a fair trade
+  // for a correct-scale see-through image.
+  vec3 spec = blend ? blendBehind : gSpec * ((1.0 - metal) * (1.0 - transmission));
+  if (any(isnan(spec)) || any(isinf(spec))) spec = vec3(0.0);
+  if (!blend) {
+    float specLum = dot(spec, vec3(0.299, 0.587, 0.114));
+    float specCap = uFireflyClamp * 4.0; // narrow lobes spike; keep the EMA stable
+    if (specLum > specCap) spec *= specCap / specLum;
+  }
+  outSpecular = vec4(spec, 1.0);
+
   // --- temporal reprojection: pull validated history from last frame ---
   float count = 1.0;
   vec3 history = vec3(0.0);
@@ -546,6 +756,10 @@ void main() {
           // reflection under camera motion — and specular rays are nearly
           // deterministic, so they don't need the accumulation anyway.
           float specHist = max(metal, transmission) * (1.0 - rough);
+          // (Blend pixels need no shortening here: this slot holds only the
+          // pane's own surface light, which is static on the surface. The
+          // parallaxing behind-image rides the specular attachment, whose
+          // accumulation is short-history by design.)
           float histCap = mix(uMaxHistory, min(uMaxHistory, 10.0), specHist);
           count = clamp(h.a, 0.0, histCap) + 1.0;
           history = h.rgb;
@@ -561,20 +775,125 @@ void main() {
 }
 `;
 
+// Specular accumulation: the lighting pass emits FRESH dielectric specular in
+// MRT attachment 1 (it has no spare sampler to read its own specular history).
+// This second, cheap program reprojects that fresh sample against the previous
+// accumulated specular and EMA-blends it — the same temporal scheme as the
+// irradiance buffer, but with the SHORT (near-mirror) history a view-dependent
+// highlight needs so it tracks moving lights and the camera without smearing.
+const specAccumFrag = /* glsl */ `
+precision highp float;
+
+layout(location = 0) out vec4 outSpec;
+
+in vec2 vUv;
+
+uniform sampler2D uFreshSpec;
+uniform sampler2D uPrevSpec;
+uniform sampler2D uGWorldPos;
+uniform sampler2D uGNormalMetal;
+uniform sampler2D uPrevGWorldPos;
+uniform mat4 uPrevViewProj;
+uniform mat4 uViewProj;
+uniform vec3 uCameraPos;
+uniform float uEps;
+uniform float uMaxHistory;
+uniform bool uTemporalReprojection;
+
+void main() {
+  vec4 wp = texture(uGWorldPos, vUv);
+  if (wp.w < 0.5) { outSpec = vec4(0.0); return; }
+  vec3 P = wp.xyz;
+  vec3 N = normalize(texture(uGNormalMetal, vUv).xyz);
+  float rough = clamp(wp.w - 1.0, 0.0, 1.0);
+  vec3 fresh = texture(uFreshSpec, vUv).rgb;
+
+  float count = 1.0;
+  vec3 history = vec3(0.0);
+  if (uTemporalReprojection) {
+    vec4 clip = uPrevViewProj * vec4(P, 1.0);
+    vec4 clipC = uViewProj * vec4(P, 1.0);
+    if (clip.w > 0.0 && clipC.w > 0.0) {
+      vec2 prevUv = (clip.xy / clip.w) * 0.5 + 0.5;
+      vec2 currUv = (clipC.xy / clipC.w) * 0.5 + 0.5;
+      prevUv -= currUv - vUv; // cancel the G-buffer texel sub-pixel offset
+      if (prevUv.x >= 0.0 && prevUv.x <= 1.0 && prevUv.y >= 0.0 && prevUv.y <= 1.0) {
+        vec4 prevPos = texture(uPrevGWorldPos, prevUv);
+        float tol = 0.005 * distance(P, uCameraPos) + 20.0 * uEps;
+        if (prevPos.w > 0.5 && abs(dot(P - prevPos.xyz, N)) < tol) {
+          vec4 h = texture(uPrevSpec, prevUv);
+          // Short history: specular is view-dependent, so a long EMA smears the
+          // highlight under motion. Smoother (sharper) highlights react fastest.
+          float specHist = 1.0 - rough;
+          float histCap = mix(min(uMaxHistory, 32.0), min(uMaxHistory, 8.0), specHist);
+          count = clamp(h.a, 0.0, histCap) + 1.0;
+          history = h.rgb;
+        }
+      }
+    }
+  }
+
+  vec3 blended = mix(history, fresh, 1.0 / count);
+  if (any(isnan(blended)) || any(isinf(blended))) blended = vec3(0.0);
+  outSpec = vec4(blended, count);
+}
+`;
+
+// Irradiance-history carry for renderScale/canvas resizes. The shared CopyPass
+// writes ONE output; rendering it into the 2-attachment MRT is a draw-buffer
+// mismatch that some drivers (ANGLE/D3D11) reject with INVALID_OPERATION. This
+// 2-output copy matches the MRT: attachment 0 = resampled history (alpha/count
+// clamped), attachment 1 = 0 (fresh-written next frame anyway).
+const mrtCarryFrag = /* glsl */ `
+precision highp float;
+layout(location = 0) out vec4 o0;
+layout(location = 1) out vec4 o1;
+in vec2 vUv;
+uniform sampler2D uTex;
+uniform float uCountClamp;
+void main() {
+  vec4 c = texture(uTex, vUv);
+  if (uCountClamp >= 0.0) c.a = min(c.a, uCountClamp);
+  o0 = c;
+  o1 = vec4(0.0);
+}
+`;
+
 /**
  * Fullscreen pass: for every G-buffer pixel, trace shadow rays to every light and
  * one cosine-weighted GI bounce against the BVH. Outputs demodulated irradiance,
  * progressively accumulated into a ping-pong float target while the camera is still.
+ *
+ * The target is a 2-attachment MRT: [0] demodulated diffuse irradiance,
+ * [1] FRESH dielectric direct specular (temporally accumulated by specAccumFrag
+ * into a second ping-pong pair, specA/specB).
  */
 export class RTLightingPass {
-  constructor(width, height) {
+  // `specMRT: false` is the WebKit fallback: iOS Safari (every iOS browser)
+  // silently fails the 2-attachment half-float MRT draw — the whole lighting
+  // pass renders black. RealtimeRaytracer probes this functionally at
+  // construction; in fallback mode this pass allocates a single-attachment
+  // target exactly like 0.3.x, the shader's second output collapses to a dead
+  // local variable, and render() returns { specular: null } (the caller then
+  // runs with specular off; blend surfaces degrade to opaque as documented).
+  constructor(width, height, { specMRT = true } = {}) {
+    this.specMRT = specMRT;
     this.targetA = this._makeTarget(width, height);
     this.targetB = this._makeTarget(width, height);
+    // Accumulated specular history (ping-pong), fed by the fresh specular in
+    // targetA/B attachment 1.
+    this.specA = specMRT ? this._makeSpecTarget(width, height) : null;
+    this.specB = specMRT ? this._makeSpecTarget(width, height) : null;
 
     this.material = new THREE.ShaderMaterial({
       glslVersion: THREE.GLSL3,
       vertexShader: fullscreenVert,
-      fragmentShader: rtLightingFrag,
+      fragmentShader: specMRT
+        ? rtLightingFrag
+        : rtLightingFrag.replace(
+            "layout(location = 1) out vec4 outSpecular;",
+            "vec4 outSpecular; // single-target fallback: dead store"
+          ),
       uniforms: {
         bvhStatic: { value: null },
         bvhDynamic: { value: null },
@@ -599,8 +918,10 @@ export class RTLightingPass {
         uLightDirCone: { value: [] },
         uLightCount: { value: 0 },
         uEmissiveCount: { value: 0 },
+        uEmissiveCDF: { value: true },
         uReflEnabled: { value: true },
         uRefrEnabled: { value: true },
+        uBlendEnabled: { value: true },
         uIor: { value: 1.5 },
         uLightStochastic: { value: false },
         uGIHalfRate: { value: false },
@@ -620,6 +941,46 @@ export class RTLightingPass {
       depthWrite: false,
     });
 
+    // Specular temporal accumulation program (its own sampler budget — well
+    // clear of the lighting pass's 16-sampler ceiling).
+    this.specMaterial = new THREE.ShaderMaterial({
+      glslVersion: THREE.GLSL3,
+      vertexShader: fullscreenVert,
+      fragmentShader: specAccumFrag,
+      uniforms: {
+        uFreshSpec: { value: null },
+        uPrevSpec: { value: null },
+        uGWorldPos: { value: null },
+        uGNormalMetal: { value: null },
+        uPrevGWorldPos: { value: null },
+        uPrevViewProj: { value: new THREE.Matrix4() },
+        uViewProj: { value: new THREE.Matrix4() },
+        uCameraPos: { value: new THREE.Vector3() },
+        uEps: { value: 1e-3 },
+        uMaxHistory: { value: 128 },
+        uTemporalReprojection: { value: true },
+      },
+      depthTest: false,
+      depthWrite: false,
+    });
+
+    // 2-output history carry (see mrtCarryFrag) — matches the MRT's draw
+    // buffers. In single-target fallback the second output collapses the same
+    // way as the lighting shader's.
+    this.carryMaterial = new THREE.ShaderMaterial({
+      glslVersion: THREE.GLSL3,
+      vertexShader: fullscreenVert,
+      fragmentShader: specMRT
+        ? mrtCarryFrag
+        : mrtCarryFrag.replace(
+            "layout(location = 1) out vec4 o1;",
+            "vec4 o1; // single-target fallback: dead store"
+          ),
+      uniforms: { uTex: { value: null }, uCountClamp: { value: -1 } },
+      depthTest: false,
+      depthWrite: false,
+    });
+
     this.scene = new THREE.Scene();
     this.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
     this.quad = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), this.material);
@@ -630,7 +991,33 @@ export class RTLightingPass {
   _makeTarget(width, height) {
     // Half-float + linear: history is sampled bilinearly at reprojected UVs,
     // and fp16 halves the bandwidth (EMA blending never accumulates a raw sum,
-    // so fp16 precision is sufficient).
+    // so fp16 precision is sufficient). Two attachments: [0] irradiance,
+    // [1] fresh dielectric specular — or a single attachment in the WebKit
+    // fallback (see the constructor note).
+    const opts = {
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.LinearFilter,
+      format: THREE.RGBAFormat,
+      type: THREE.HalfFloatType,
+      depthBuffer: false,
+      stencilBuffer: false,
+    };
+    if (!this.specMRT) {
+      const t = new THREE.WebGLRenderTarget(width, height, opts);
+      t.texture.generateMipmaps = false;
+      return t;
+    }
+    const t = new THREE.WebGLMultipleRenderTargets(width, height, 2, opts);
+    for (const tex of t.texture) tex.generateMipmaps = false;
+    return t;
+  }
+
+  // The accumulated-irradiance texture of a history target, either layout.
+  _irrTex(target) {
+    return this.specMRT ? target.texture[0] : target.texture;
+  }
+
+  _makeSpecTarget(width, height) {
     const t = new THREE.WebGLRenderTarget(width, height, {
       minFilter: THREE.LinearFilter,
       magFilter: THREE.LinearFilter,
@@ -650,7 +1037,8 @@ export class RTLightingPass {
     renderer.getClearColor(prevColor);
     const prevAlpha = renderer.getClearAlpha();
     renderer.setClearColor(0x000000, 0);
-    for (const t of [this.targetA, this.targetB]) {
+    for (const t of [this.targetA, this.targetB, this.specA, this.specB]) {
+      if (!t) continue; // spec pair is absent in the single-target fallback
       renderer.setRenderTarget(t);
       renderer.clear(true, false, false);
     }
@@ -661,6 +1049,8 @@ export class RTLightingPass {
   setSize(width, height) {
     this.targetA.setSize(width, height);
     this.targetB.setSize(width, height);
+    if (this.specA) this.specA.setSize(width, height);
+    if (this.specB) this.specB.setSize(width, height);
   }
 
   /**
@@ -679,11 +1069,33 @@ export class RTLightingPass {
   resizeCarry(renderer, copyPass, width, height, carryFrames) {
     const newA = this._makeTarget(width, height);
     const newB = this._makeTarget(width, height);
-    copyPass.blit(renderer, this.targetB.texture, newB, carryFrames);
+    // Carry the irradiance history (attachment 0) with the 2-output carry
+    // material so the draw matches the MRT's draw buffers (a 1-output CopyPass
+    // blit here is INVALID_OPERATION on ANGLE/D3D11). Attachment 1 is fresh-
+    // written every frame, so it needs no carry.
+    this.carryMaterial.uniforms.uTex.value = this._irrTex(this.targetB);
+    this.carryMaterial.uniforms.uCountClamp.value = carryFrames;
+    this.quad.material = this.carryMaterial;
+    const prev = renderer.getRenderTarget();
+    renderer.setRenderTarget(newB);
+    renderer.render(this.scene, this.camera);
+    renderer.setRenderTarget(prev);
+    this.quad.material = this.material;
     this.targetA.dispose();
     this.targetB.dispose();
     this.targetA = newA;
     this.targetB = newB;
+
+    // Specular history carries the same way (freshest is specB — see render()).
+    if (this.specMRT) {
+      const newSpecA = this._makeSpecTarget(width, height);
+      const newSpecB = this._makeSpecTarget(width, height);
+      copyPass.blit(renderer, this.specB.texture, newSpecB, carryFrames);
+      this.specA.dispose();
+      this.specB.dispose();
+      this.specA = newSpecA;
+      this.specB = newSpecB;
+    }
   }
 
   setCompiledScene(compiled) {
@@ -701,30 +1113,67 @@ export class RTLightingPass {
     u.uEmissiveCount.value = compiled.emissiveTriCount;
   }
 
-  /** Renders into targetA (reading targetB as history), then swaps. Returns the fresh accum texture. */
+  /**
+   * Renders lighting into targetA (reading targetB as irradiance history), then
+   * accumulates the fresh specular (targetA attachment 1) into specA (reading
+   * specB as history). Swaps both ping-pong pairs. Returns { irradiance,
+   * specular } textures for this frame.
+   */
   render(renderer, gbuffer, frame, reservoirTexture = null) {
     const u = this.material.uniforms;
     u.uGWorldPos.value = gbuffer.worldPos;
     u.uGNormalMetal.value = gbuffer.normalMetal;
     u.uPrevGWorldPos.value = gbuffer.prevWorldPos;
-    u.uPrevAccum.value = this.targetB.texture;
+    u.uPrevAccum.value = this._irrTex(this.targetB);
     u.uReservoir.value = reservoirTexture;
     u.uRestirEnabled.value = reservoirTexture !== null;
     u.uFrame.value = frame;
 
+    // 1. lighting (MRT): [0] accumulated irradiance, [1] fresh specular.
+    this.quad.material = this.material;
     renderer.setRenderTarget(this.targetA);
     renderer.render(this.scene, this.camera);
+
+    // 2. specular temporal accumulation: fresh (targetA[1]) + history (specB).
+    // Skipped entirely in the single-target fallback — there is no fresh
+    // specular attachment to accumulate.
+    let outSpec = null;
+    if (this.specMRT) {
+      const su = this.specMaterial.uniforms;
+      su.uFreshSpec.value = this.targetA.texture[1];
+      su.uPrevSpec.value = this.specB.texture;
+      su.uGWorldPos.value = gbuffer.worldPos;
+      su.uGNormalMetal.value = gbuffer.normalMetal;
+      su.uPrevGWorldPos.value = gbuffer.prevWorldPos;
+      su.uPrevViewProj.value.copy(u.uPrevViewProj.value);
+      su.uViewProj.value.copy(u.uViewProj.value);
+      su.uCameraPos.value.copy(u.uCameraPos.value);
+      su.uEps.value = u.uEps.value;
+      su.uMaxHistory.value = u.uMaxHistory.value;
+      su.uTemporalReprojection.value = u.uTemporalReprojection.value;
+      this.quad.material = this.specMaterial;
+      renderer.setRenderTarget(this.specA);
+      renderer.render(this.scene, this.camera);
+      outSpec = this.specA.texture;
+    }
+
+    this.quad.material = this.material; // restore for the next caller
     renderer.setRenderTarget(null);
 
-    const out = this.targetA;
+    const outIrr = this._irrTex(this.targetA);
     [this.targetA, this.targetB] = [this.targetB, this.targetA];
-    return out.texture;
+    if (this.specMRT) [this.specA, this.specB] = [this.specB, this.specA];
+    return { irradiance: outIrr, specular: outSpec };
   }
 
   dispose() {
     this.targetA.dispose();
     this.targetB.dispose();
+    if (this.specA) this.specA.dispose();
+    if (this.specB) this.specB.dispose();
     this.material.dispose();
+    this.specMaterial.dispose();
+    this.carryMaterial.dispose();
     this.quad.geometry.dispose();
   }
 }