@meimu/mutracer 0.3.0 → 0.3.1

package/lib/renderer/glsl/rayTrace.frag.js

@@ -1,5 +1,6 @@
+import { spectralPrefixGlsl, prefixCheckpoint, prefixSave, prefixRestore, prefixRandomBindings } from './chunks/spectralPrefix.glsl.js';
 import { researchTransport } from '../researchTransport.js';
-import { MAX_PATH_EVENTS } from '../pathLimits.js';
+import { MAX_PATH_EVENTS_WEBGL } from '../pathLimits.js';
 import cameraRayGlsl from './chunks/cameraRay.glsl.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
 // (https://github.com/hoverinc/ray-tracing-renderer).
@@ -34,7 +35,7 @@ return;
 // So here the code are injected separately.
 const bounceCodeOnIntelMac = glsl `
 
-for(int yl = 0; yl < BOUNCES; yl++) {{
+for(int Aj = 0; Aj < BOUNCES; Aj++) {{
 if (path.abort) {
 return vec4(path.li, path.alpha);
 }
@@ -42,10 +43,10 @@ bounce(path, depth, si, mat, outAux);
 }}
 `;
 const bounceCodeOnOther = glsl `
-bool xB = !si.isTransparency;
-int rQ = min(BOUNCES, bounceLimit);
-for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {
-if (xB && idx > rQ) {
+bool isOpaque = !si.isTransparency;
+int activeBounceLimit = min(BOUNCES, bounceLimit);
+for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS_WEBGL}); idx++) {
+if (isOpaque && idx > activeBounceLimit) {
 path.abort = true;
 }
 if (path.abort) {
@@ -55,12 +56,19 @@ bounce(path, depth, si, mat, outAux);
 }
 `;
 export default function createRayTraceFragmentShader(...options) {
-    const research = researchTransport()?.fragment(options);
+    const channelIndependentLight = options[0]?.channelIndependentLight ?? false;
+    const sharePrefix = options[0]?.shareSpectralPrefix ?? false;
+    const surfacePrefix = {
+        path: ['Path', 'path'], si: ['SurfaceInteraction', 'si'], mat: ['OpenPbrResolvedMaterial', 'mat'],
+        aux: ['RayTraceAuxiliary', 'outAux'], depth: ['int', 'depth'], event: ['int', 'idx'],
+        ignored: ['bool', 'sampleIgnored'], opaque: ['bool', 'isOpaque'], ...prefixRandomBindings
+    };
+    const research = researchTransport()?.fragment(typeof options[0] === 'object' ? [] : options);
     const enabled = research?.enabled ?? false;
     const fragments = research?.fragments;
     const materialBufferGlsl = createMaterialBufferGlsl(fragments);
     const rayTraceCore = createRayTraceCoreGlsl(fragments);
-    const sampleMaterialGlsl = createSampleMaterialGlsl(fragments);
+    const sampleMaterialGlsl = createSampleMaterialGlsl(fragments, channelIndependentLight);
     const intelMac = isIntelMac();
     return new FragmentShader({
         name: 'rayTraceFrag',
@@ -75,6 +83,7 @@ export default function createRayTraceFragmentShader(...options) {
             cameraApertureRadius: Shader.uniform('float', 0),
             cameraFocusDistance: Shader.uniform('float', 10),
             viewProjectionInv: Shader.uniform('mat4'),
+            projectionInv: Shader.uniform('mat4'),
             viewInv: Shader.uniform('mat4'),
             transmissiveOutputAlphaMin: Shader.uniform('float'),
             openPbrEnergyLut: Shader.uniform('sampler2D'),
@@ -105,9 +114,9 @@ ${samplingGlsl}
 ${spectrumGlsl}
 ${openPbrBsdfGlsl}
 
-float qh;
+float rq;
 float pathWavelength;
-int qg;
+int rp;
 int pathChannel;
 
 ${sampleLightGlsl}
@@ -123,7 +132,7 @@ bool isBlank;
 bool isShadowCatcher;
 };
 
-void bounce(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+${sharePrefix ? spectralPrefixGlsl + prefixCheckpoint('spSurface', surfacePrefix) : ''}void ${sharePrefix ? 'shadeSurfaceVertex' : 'bounce'}(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux${sharePrefix ? ', out bool sampleIgnored' : ''}) {${sharePrefix ? '\n  sampleIgnored = false;' : ''}
 samplingBounce = uint(max(depth, 0));
 
 
@@ -149,26 +158,26 @@ if (path.isNextRefraction) {
 
 
 
-vec4 bg = cn(path.ray.o, path.ray.d);
+vec4 bg = cq(path.ray.o, path.ray.d);
 bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
-float cM = path.scatteringIsDelta ? 1.0
-: aF(path.scatteringPdf,
-envMapPdf(cT(path.ray.d)) * envLightSelectionPmf);
-path.li += cM * path.beta * bg.rgb * bg.a;
+float cP = path.scatteringIsDelta ? 1.0
+: aG(path.scatteringPdf,
+envMapPdf(cU(path.ray.d)) * envLightSelectionPmf);
+path.li += cP * path.beta * bg.rgb * bg.a;
 path.alpha = max(path.alpha, bg.a);
 }
 else {
-vec2 vC = cT(path.ray.d);
-vec3 emission = textureLinear(envMap, vC).rgb;
+vec2 xp = cU(path.ray.d);
+vec3 emission = textureLinear(envMap, xp).rgb;
 emission = sampling_spectral_rgb_filter(emission, pathChannel);
 path.li += path.beta * emission *
-aF(
+aG(
 path.scatteringPdf,
-envMapPdf(vC) * envLightSelectionPmf
+envMapPdf(xp) * envLightSelectionPmf
 );
 }
 #else
-vec4 bg = cn(path.ray.o, path.ray.d);
+vec4 bg = cq(path.ray.o, path.ray.d);
 bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
 path.li += path.beta * bg.rgb * bg.a;
 #endif
@@ -179,7 +188,7 @@ return;
 
 if (!si.hit) {
 
-vec4 bg = cn(path.ray.o, path.ray.d);
+vec4 bg = cq(path.ray.o, path.ray.d);
 
 
 
@@ -191,10 +200,10 @@ path.alpha = bg.a;
 outAux.isBlank = bg.a < 0.01;
 }
 else {
-Ray cam = eT(v_Texcoord + te());
-bool nt = dot(cam.d, path.ray.d) > 0.0;
+Ray cam = cV(v_Texcoord + uH());
+bool ou = dot(cam.d, path.ray.d) > 0.0;
 if (transmissiveOutputAlphaMin < 1.0) {
-if (nt) {
+if (ou) {
 path.alpha = max(path.alpha, bg.a);
 } else {
 path.alpha = 1.0;
@@ -202,8 +211,8 @@ path.alpha = 1.0;
 }
 #if !defined(USE_ENVMAP)
 
-if (nt) {
-path.li += path.beta * aF(path.scatteringPdf, 1.0) * bg.rgb;
+if (ou) {
+path.li += path.beta * aG(path.scatteringPdf, 1.0) * bg.rgb;
 }
 #endif
 }
@@ -211,7 +220,7 @@ path.abort = true;
 return;
 }
 
-bool aJ = false;
+${sharePrefix ? '  sampleIgnored = false;' : '  bool sampleIgnored = false;'}
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT)) {
 if (transmissiveOutputAlphaMin < 1.0) {
 
@@ -223,19 +232,19 @@ if (alpha < 1.0) {
 
 
 path.alpha = max(path.alpha, alpha);
-if (ek(3u) > alpha) {
-aJ = true;
+if (cm(3u) > alpha) {
+sampleIgnored = true;
 }
 }
-if (!aJ) {
-mx(si, mat, path);
+if (!sampleIgnored) {
+nB(si, mat, path);
 }
 else {
 path.ray.o = si.position + path.ray.d * EPS;
 }
 }
 
-if (!si.albedoSampled && !aJ) {
+if (!si.albedoSampled && !sampleIgnored) {
 
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT) &&
 !(mat.transmissionWeight > 0.5 ||
@@ -257,11 +266,12 @@ si.albedoSampled = true;
 
 
 #ifdef USE_RR
-if (depth >= RR_MAX && !aJ) {
+int wj = path.scatteringMediumEntered ? RR_MAX : 2;
+if (depth >= wj && !sampleIgnored) {
 
-float pc = max(max(path.beta.x, path.beta.y), path.beta.z);
-float q = max(0.0, 1.0 - pc);
-if (sample1D(bE(RUSSIAN_ROULETTE)) < q) {
+float ql = max(max(path.beta.x, path.beta.y), path.beta.z);
+float q = max(0.0, 1.0 - ql);
+if (sample1D(aX(RUSSIAN_ROULETTE)) < q) {
 
 
 path.alpha = 1.0;
@@ -277,17 +287,20 @@ if (path.abort) {
 return;
 }
 
-
-intersectScene(path.ray, si, true);
+${sharePrefix ? /* glsl */ `  return;
+}
+void qU(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, bool sampleIgnored) {
+` : ''}  
+${sharePrefix ? '' : /* glsl */ `  intersectScene(path.ray, si, true);
 getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;
-
+`}
 
 
 
 if (dispersionWavelengths == 1 && si.hit && mat.transmissionWeight > 0.001 && mat.transmissionDispersionScale > 0.001) {
-pathWavelength = qh;
-pathChannel = qg;
+pathWavelength = rq;
+pathChannel = rp;
 }
 if (mat.transmissionWeight > 0.001 && pathWavelength > 0.0) {
 mat.specularIor = sampling_cauchy_ior(
@@ -298,22 +311,22 @@ mat.dispersionAbbeNumber
 );
 }
 
-if (aJ) {
+if (sampleIgnored) {
 return;
 }
 
-bool ht = ek(3u) < mat.alpha;
+bool hN = cm(3u) < mat.alpha;
 #ifdef NUM_LIGHTS
 
 LightSampleRec lightSample;
 for (int i = 0; i < NUM_LIGHTS; i++) {
 
 Light light = fetchLight(i);
-float d = mX(path.ray, light, lightSample);
-bool lH = si.hit && d > distance(si.position, path.ray.o);
-if (d != INF && !(lH && ht)) {
+float d = iB(path.ray, light, lightSample);
+bool mz = si.hit && d > distance(si.position, path.ray.o);
+if (d != INF && !(mz && hN)) {
 lightSample.pdf *= light.selectionPmf;
-float misWeight = aF(path.scatteringPdf, lightSample.pdf);
+float misWeight = aG(path.scatteringPdf, lightSample.pdf);
 lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
 ${enabled ? 'if (!causticHitOwned(path)) { ' : ''}path.li += misWeight * path.beta * lightSample.emission;${enabled ? ' }' : ''}
 
@@ -324,23 +337,23 @@ path.abort = true;
 #endif
 
 #ifdef USE_ENVMAP
-if (!(si.hit && ht)) {
+if (!(si.hit && hN)) {
 if (path.isNextRefraction) {
 
 
-vec4 bg = cn(path.ray.o, path.ray.d);
+vec4 bg = cq(path.ray.o, path.ray.d);
 bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
-float cM = path.scatteringIsDelta ? 1.0
-: aF(path.scatteringPdf,
-envMapPdf(cT(path.ray.d)) * envLightSelectionPmf);
-path.li += cM * path.beta * bg.rgb * bg.a;
+float cP = path.scatteringIsDelta ? 1.0
+: aG(path.scatteringPdf,
+envMapPdf(cU(path.ray.d)) * envLightSelectionPmf);
+path.li += cP * path.beta * bg.rgb * bg.a;
 path.alpha = max(path.alpha, bg.a);
 path.abort = true;
 return;
 }
-vec2 uv = cT(path.ray.d);
+vec2 uv = cU(path.ray.d);
 vec3 emission = textureLinear(envMap, uv).rgb;
-float misWeight = aF(
+float misWeight = aG(
 path.scatteringPdf,
 envMapPdf(uv) * envLightSelectionPmf
 );
@@ -360,110 +373,110 @@ depth++;
 }
 
 
-vec2 kK(float radius, float xi) {
+vec2 lD(float radius, float xi) {
 float x = 0.25;
 for (int iteration = 0; iteration < 10; iteration++) {
 float x2 = x * x;
 float x3 = x2 * x;
-float la = 1.0 - x;
+float lU = 1.0 - x;
 float value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-float mJ = 20.0 * x * la * la * la;
-if (abs(value) < 1e-6 || mJ == 0.0) break;
-x = clamp(x - value / mJ, 0.0, 1.0);
+float nL = 20.0 * x * lU * lU * lU;
+if (abs(value) < 1e-6 || nL == 0.0) break;
+x = clamp(x - value / nL, 0.0, 1.0);
 }
-float jr = x * radius;
+float jW = x * radius;
 return vec2(
-jr,
-sqrt(max(radius * radius - jr * jr, 0.0))
+jW,
+sqrt(max(radius * radius - jW * jW, 0.0))
 );
 }
 
-float bevelCubicPdf(float radius, float gu) {
-if (gu >= radius) return 0.0;
-float falloff = radius - gu;
+float bevelCubicPdf(float radius, float gO) {
+if (gO >= radius) return 0.0;
+float falloff = radius - gO;
 return falloff * falloff * falloff;
 }
 
 
-vec3 mT(SurfaceInteraction source, float radius) {
+vec3 kB(SurfaceInteraction source, float radius) {
 vec3 geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) geometricNormal = -geometricNormal;
 vec3 tangent;
 vec3 bitangent;
 sampling_orthonormal_basis(geometricNormal, tangent, bitangent);
-vec3 iE = vec3(0.0);
-
-for (int ih = 0; ih < BEVEL_SAMPLES; ih++) {
-vec2 qa = sample2D(CAMERA_BEVEL_BASE + uint(ih));
-float cr = qa.x;
-float pj = qa.y;
-vec3 cZ = geometricNormal;
-vec3 fI = tangent;
-vec3 eh = bitangent;
-float ge = 0.5;
-float hW = 0.25;
-float gC = 0.25;
-if (cr < 0.5) {
-cr *= 2.0;
-}
-else if (cr < 0.75) {
-vec3 nr = cZ;
-cZ = fI;
-fI = nr;
-ge = 0.25;
-hW = 0.5;
-cr = (cr - 0.5) * 4.0;
+vec3 jd = vec3(0.0);
+
+for (int iN = 0; iN < BEVEL_SAMPLES; iN++) {
+vec2 rh = sample2D(CAMERA_BEVEL_BASE + uint(iN));
+float cu = rh.x;
+float qt = rh.y;
+vec3 dc = geometricNormal;
+vec3 fU = tangent;
+vec3 eo = bitangent;
+float gw = 0.5;
+float iH = 0.25;
+float gV = 0.25;
+if (cu < 0.5) {
+cu *= 2.0;
+}
+else if (cu < 0.75) {
+vec3 os = dc;
+dc = fU;
+fU = os;
+gw = 0.25;
+iH = 0.5;
+cu = (cu - 0.5) * 4.0;
 }
 else {
-vec3 nr = cZ;
-cZ = eh;
-eh = nr;
-ge = 0.25;
-gC = 0.5;
-cr = (cr - 0.75) * 4.0;
-}
-
-vec2 gQ = kK(radius, pj);
-float phi = TWOPI * cr;
-vec3 rr = gQ.x *
-(cos(phi) * fI + sin(phi) * eh);
+vec3 os = dc;
+dc = eo;
+eo = os;
+gw = 0.25;
+gV = 0.5;
+cu = (cu - 0.75) * 4.0;
+}
+
+vec2 hm = lD(radius, qt);
+float phi = TWOPI * cu;
+vec3 sI = hm.x *
+(cos(phi) * fU + sin(phi) * eo);
 Ray ray;
 initRay(
 ray,
-source.position + cZ * gQ.y + rr,
--cZ
+source.position + dc * hm.y + sI,
+-dc
 );
 SurfaceInteraction hit;
 intersectSceneBevel(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * gQ.y, EPS)
+max(2.0 * hm.y, EPS)
 );
 if (!hit.hit) continue;
 
-float lc = ge * abs(dot(cZ, hit.faceNormal));
-float nj = hW * abs(dot(fI, hit.faceNormal));
-float kj = gC * abs(dot(eh, hit.faceNormal));
-float weight = lc / max(
-lc * lc + nj * nj +
-kj * kj,
+float lV = gw * abs(dot(dc, hit.faceNormal));
+float oi = iH * abs(dot(fU, hit.faceNormal));
+float kR = gV * abs(dot(eo, hit.faceNormal));
+float weight = lV / max(
+lV * lV + oi * oi +
+kR * kR,
 1e-8
 );
 weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
-max(bevelCubicPdf(radius, gQ.x), 1e-8);
-iE += weight * hit.vertexNormal;
+max(bevelCubicPdf(radius, hm.x), 1e-8);
+jd += weight * hit.vertexNormal;
 }
 
-if (dot(iE, iE) <= 1e-12) return source.normal;
-vec3 jM = normalize(iE);
-vec3 result = source.normal + jM - source.vertexNormal;
+if (dot(jd, jd) <= 1e-12) return source.normal;
+vec3 kt = normalize(jd);
+vec3 result = source.normal + kt - source.vertexNormal;
 return dot(result, result) > 1e-12 ? normalize(result) : source.normal;
 }
 
-vec4 cG(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
-Path path;
+vec4 cJ(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+Path path; path.scatteringMediumEntered = false;
 path.ray = ray;
 path.li = vec3(0);
 path.alpha = transmissiveOutputAlphaMin < 1.0 ? 0.0 : 1.0;
@@ -476,63 +489,94 @@ path.scatteringIsDelta = false;
 path.isNextRefraction = false;
 path.abort = false;
 int depth = 0;
-${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}
-return vec4(path.li, path.alpha);
+${sharePrefix ? /* glsl */ `  int spSlot = qz++;
+if (spActive && spChannel > 1 && eB[spSlot].ready) return rN(spSlot, outAux);
+bool isOpaque = !si.isTransparency;
+bool sampleIgnored = false, spResume = false;
+int spEvent = 0;
+if (spActive && spChannel > 1 && fC == spSlot) {
+int idx = 0;
+${prefixRestore('spSurface', surfacePrefix)}
+spEvent = idx; spResume = true; qA(path);
+}
+int activeBounceLimit = min(BOUNCES, bounceLimit);
+for (int idx = ${intelMac ? '0' : 'spEvent'}; idx < ${intelMac ? 'BOUNCES' : `min(BOUNCES * 3, ${MAX_PATH_EVENTS_WEBGL})`}; idx++) {
+${intelMac ? '    if (idx < spEvent) continue;' : '    if (isOpaque && idx > activeBounceLimit) path.abort = true;'}
+if (path.abort) break;
+if (!spResume) {
+shadeSurfaceVertex(path, depth, si, mat, outAux, sampleIgnored);
+if (!path.abort) {
+intersectScene(path.ray, si, true);
+getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;
+}
+}
+spResume = false;
+if (!path.abort) {
+if (spActive && mat.transmissionWeight > 0.001 && gf(mat)) {
+${prefixSave('spSurface', surfacePrefix)}
+fC = spSlot; qA(path);
+}
+qU(path, depth, si, mat, sampleIgnored);
+}
+}
+return spFinish(spSlot, vec4(path.li, path.alpha), outAux);` : /* glsl */ `${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}
+return vec4(path.li, path.alpha);`}
 }
 
-vec4 iC(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+vec4 jb(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
 float coverage = clamp(mat.alpha, 0.0, 1.0);
 if (!si.hit || (mat.materialType != STANDARD && mat.materialType != UNLIT) || coverage >= 1.0) {
-return cG(si, ray, mat, outAux);
+return cJ(si, ray, mat, outAux);
 }
 
 
 
 
 
-Ray uK = ray;
-uK.o = si.position + ray.d * (EPS * 0.02);
-SurfaceInteraction jL = si;
-jL.albedoSampled = false;
-intersectScene(uK, jL, false);
-OpenPbrResolvedMaterial oH;
-getMaterial(oH, jL.materialIndex, jL.uv, jL.uv1, jL.instanceIndex, jL.vertexColor);
-RayTraceAuxiliary eg = outAux;
-if (jL.hit && (oH.materialType == STANDARD || oH.materialType == UNLIT)) {
-eg.albedo = oH.transmissionWeight > 0.5
+Ray wt = ray;
+wt.o = si.position + ray.d * (EPS * 0.02);
+SurfaceInteraction kq = si;
+kq.albedoSampled = false;
+intersectScene(wt, kq, false);
+OpenPbrResolvedMaterial pN;
+getMaterial(pN, kq.materialIndex, kq.uv, kq.uv1, kq.instanceIndex, kq.vertexColor);
+RayTraceAuxiliary backAux = outAux;
+if (kq.hit && (pN.materialType == STANDARD || pN.materialType == UNLIT)) {
+backAux.albedo = pN.transmissionWeight > 0.5
 ? vec3(1.0)
-: oH.baseColor;
-eg.normal = dot(
-jL.normal,
-jL.position - vec3(viewInv[3])
+: pN.baseColor;
+backAux.normal = dot(
+kq.normal,
+kq.position - vec3(viewInv[3])
 ) > 0.0
-? -jL.normal
-: jL.normal;
-jL.albedoSampled = oH.transmissionWeight > 0.5;
+? -kq.normal
+: kq.normal;
+kq.albedoSampled = pN.transmissionWeight > 0.5;
 }
-vec4 back = cG(jL, uK, oH, eg);
+vec4 back = cJ(kq, wt, pN, backAux);
 if (coverage <= 0.0) {
-outAux = eg;
+outAux = backAux;
 return back;
 }
 
-SurfaceInteraction yc = si;
-OpenPbrResolvedMaterial vD = mat;
-vD.alpha = 1.0;
-RayTraceAuxiliary sa = outAux;
-vec4 front = cG(yc, ray, vD, sa);
-outAux.albedo = mix(eg.albedo, sa.albedo, coverage);
-vec3 cS = mix(eg.normal, sa.normal, coverage);
-outAux.normal = dot(cS, cS) > 1e-12
-? normalize(cS)
+SurfaceInteraction zY = si;
+OpenPbrResolvedMaterial xq = mat;
+xq.alpha = 1.0;
+RayTraceAuxiliary tA = outAux;
+vec4 front = cJ(zY, ray, xq, tA);
+outAux.albedo = mix(backAux.albedo, tA.albedo, coverage);
+vec3 aS = mix(backAux.normal, tA.normal, coverage);
+outAux.normal = dot(aS, aS) > 1e-12
+? normalize(aS)
 : vec3(0.0);
-outAux.isBlank = eg.isBlank && sa.isBlank;
+outAux.isBlank = backAux.isBlank && tA.isBlank;
 return mix(back, front, coverage);
 }
 
 
 
-vec4 hR(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 hq(Ray ray, out RayTraceAuxiliary outAux) {
 
 SurfaceInteraction si;
 OpenPbrResolvedMaterial mat;
@@ -545,13 +589,13 @@ si.mediumScattering = vec3(0.0);
 si.mediumAnisotropy = 0.0;
 #endif
 
-intersectScene(ray, si, false);
+${sharePrefix ? '  if (spChannel == 1) {\n' : ''}  intersectScene(ray, si, false);
 getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;
 
 #ifdef HAS_BEVEL
 if (bevelEnabled && mat.bevel > 0.0) {
-si.normal = mT(si, mat.bevel);
+si.normal = kB(si, mat.bevel);
 }
 #endif
 
@@ -567,7 +611,15 @@ outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0
 si.albedoSampled = mat.transmissionWeight > 0.5;
 }
 
-if (mat.transmissionDispersionScale > 0.001) {
+${sharePrefix ? /* glsl */ `    lY = qI(si, mat, outAux, s0, hashedCounter, samplingBounce);
+} else {
+si = lY.si; mat = lY.mat; outAux = lY.aux;
+s0 = lY.rng; hashedCounter = lY.counter; samplingBounce = lY.bounce;
+}
+spActive = ${enabled ? 'false' : '!(mat.transmissionDispersionScale > 0.001 && mat.specularIor != 1.0)'};
+pathChannel = spActive ? 0 : spChannel;
+qz = 0;
+` : ''}  if (mat.transmissionDispersionScale > 0.001) {
 mat.specularIor = sampling_cauchy_ior(
 pathWavelength,
 mat.specularIor,
@@ -575,31 +627,31 @@ mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
-return iC(si, ray, mat, outAux);
+return jb(si, ray, mat, outAux);
 }
 
-void main() {
+void ${sharePrefix ? 'traceSpectralWavelength' : 'main'}(${sharePrefix ? 'int channel' : ''}) {
 
-${fragments?.debugInit ?? ''}  rA();
-fi(v_Texcoord * viewportSize, int(uint(sampleCount) ^ cB(uint(sequenceSeed))));
+${fragments?.debugInit ?? ''}  sP();
+fA(v_Texcoord * viewportSize, int(uint(sampleCount) ^ cD(uint(sequenceSeed))));
 
 
-pathWavelength = 0.0;
+${sharePrefix ? '  spChannel = channel;\n' : ''}  pathWavelength = 0.0;
 pathChannel = 0;
 if (spectralChannel > 0) {
-float aZ = sample1D(CAMERA_WAVELENGTH);
+float aE = sample1D(CAMERA_WAVELENGTH);
 if (dispersionWavelengths == 1) {
-qg = min(int(aZ * 3.0), 2) + 1;
-qh = cU(qg - 1, fract(aZ * 3.0));
+rp = min(int(aE * 3.0), 2) + 1;
+rq = ce(rp - 1, fract(aE * 3.0));
 } else {
-pathChannel = spectralChannel;
-pathWavelength = cU(spectralChannel - 1, aZ);
+pathChannel = ${sharePrefix ? 'spChannel' : 'spectralChannel'};
+pathWavelength = ce(${sharePrefix ? 'spChannel' : 'spectralChannel'} - 1, aE);
 }
 }
 
 
 
-Ray cam = ow();
+Ray cam = pq();
 
 RayTraceAuxiliary outAux;
 outAux.albedo = vec3(0.0);
@@ -607,7 +659,7 @@ outAux.normal = vec3(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
 
-vec4 liAndAlpha = hR(cam, outAux);
+vec4 liAndAlpha = hq(cam, outAux);
 
 
 
@@ -635,12 +687,23 @@ out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);
 out_normal = vec4(outAux.normal, 1.0);
 
 
-float jw = dot(liAndAlpha.rgb, vec3(0.2126, 0.7152, 0.0722));
+float jZ = dot(liAndAlpha.rgb, vec3(0.2126, 0.7152, 0.0722));
 out_moments = outAux.isShadowCatcher
 ? vec4(0.0)
-: vec4(jw, jw * jw, 1.0, 0.0);
+: vec4(jZ, jZ * jZ, 1.0, 0.0);
+
+}${sharePrefix ? /* glsl */ `
+void main() {
+eB[0].ready = false; eB[1].ready = false;
+vec4 color = vec4(0.0), albedo = vec4(0.0), normal = vec4(0.0), moments = vec4(0.0);
 
-}`
+for (int channel = 1; channel <= dispersionWavelengths; channel++) {
+traceSpectralWavelength(channel);
+color += out_color; albedo += out_albedo; normal += out_normal; moments += out_moments;
+}
+out_color = color; out_albedo = albedo; out_normal = normal; out_moments = moments;
+}
+` : ''}`
     });
 }
 //# sourceMappingURL=rayTrace.frag.js.map