@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -1,27 +1,30 @@
-import { MAX_PATH_EVENTS } from '../pathLimits.js';
+import { spectralPrefixGlsl, prefixCheckpoint, prefixSave, prefixRestore, prefixRandomBindings } from './chunks/spectralPrefix.glsl.js';
+import { researchTransport } from '../researchTransport.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).
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
 import commonGlsl from './chunks/common.glsl.js';
-import rayTraceCore from './chunks/rayTraceCore.glsl.js';
+import { createRayTraceCoreGlsl } from './chunks/rayTraceCore.glsl.js';
 import textureLinear from './chunks/textureLinear.glsl.js';
-import materialBufferGlsl from './chunks/materialBuffer.glsl.js';
+import { createMaterialBufferGlsl } from './chunks/materialBuffer.glsl.js';
 import intersect from './chunks/intersect.glsl.js';
 import randGlsl from './chunks/rand.glsl.js';
 import random from './chunks/random.glsl.js';
 import envMap from './chunks/envMap.glsl.js';
-import sampleMaterialGlsl from './chunks/sampleMaterial.glsl.js';
+import { createSampleMaterialGlsl } from './chunks/sampleMaterial.glsl.js';
 import sampleLightGlsl from './chunks/sampleLight.glsl.js';
 import { FragmentShader, glsl, Shader } from '../shader.js';
 import openPbrBsdfGlsl from './chunks/openPbrBsdf.glsl.js';
 import samplingGlsl from './chunks/sampling.glsl.js';
+import { spectrumGlsl } from '../spectrum.js';
 import { isIntelMac } from '../util.js';
 import uvProjectionGlsl from './chunks/uvProjection.glsl.js';
 const doubleTransmissionCheckCode = glsl `
 #if defined(HAS_TRANSMISSION) || defined(HAS_ALPHA)
 if (!si.isTransparency && BOUNCES < 16 && depth * 2 > BOUNCES) {
-aa.abort = true;
+path.abort = true;
 return;
 }
 #endif
@@ -32,27 +35,40 @@ return;
 // So here the code are injected separately.
 const bounceCodeOnIntelMac = glsl `
 
-for(int xK = 0; xK < BOUNCES; xK++) {{
-if (aa.abort) {
-return vec4(aa.li, aa.alpha);
+for(int Aj = 0; Aj < BOUNCES; Aj++) {{
+if (path.abort) {
+return vec4(path.li, path.alpha);
 }
-bounce(aa, depth, si, mat, outAux);
+bounce(path, depth, si, mat, outAux);
 }}
 `;
 const bounceCodeOnOther = glsl `
-bool wY = !si.isTransparency;
-int rT = min(BOUNCES, bounceLimit);
-for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {
-if (wY && idx > rT) {
-aa.abort = true;
+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 (aa.abort) {
-return vec4(aa.li, aa.alpha);
+if (path.abort) {
+return vec4(path.li, path.alpha);
 }
-bounce(aa, depth, si, mat, outAux);
+bounce(path, depth, si, mat, outAux);
 }
 `;
-export default function createRayTraceFragmentShader() {
+export default function createRayTraceFragmentShader(...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, channelIndependentLight);
     const intelMac = isIntelMac();
     return new FragmentShader({
         name: 'rayTraceFrag',
@@ -61,19 +77,23 @@ export default function createRayTraceFragmentShader() {
             BOUNCES: 2
         },
         uniforms: {
+            emissiveLightData: Shader.uniform('sampler2D'), emissiveLightColumns: Shader.uniform('int'),
+            emissiveChoiceOffset: Shader.uniform('int'), emissiveChoiceCount: Shader.uniform('int'), emissivePmfOffset: Shader.uniform('int'),
+            emissiveWeightTotal: Shader.uniform('float', 0),
             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'),
             viewportSize: Shader.uniform('vec2'),
-            wavelength: Shader.uniform('float', 0),
+            spectralChannel: Shader.uniform('int', 0),
             bevelEnabled: Shader.uniform('bool', true),
             dispersionWavelengths: Shader.uniform('int', 3),
             bounceLimit: Shader.uniform('int', 8)
         },
-        includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap],
+        includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap, ...(research?.mixin ? [research.mixin] : [])],
         main: glsl `
 ${commonGlsl}
 
@@ -91,13 +111,16 @@ ${intersect.main}
 ${envMap.main}
 
 ${samplingGlsl}
+${spectrumGlsl}
 ${openPbrBsdfGlsl}
 
-float nl;
-float bp;
+float rq;
+float pathWavelength;
+int rp;
+int pathChannel;
 
 ${sampleLightGlsl}
-${sampleMaterialGlsl}
+${research?.declarations ?? ''}${sampleMaterialGlsl}
 
 ${cameraRayGlsl}
 struct RayTraceAuxiliary {
@@ -109,8 +132,8 @@ bool isBlank;
 bool isShadowCatcher;
 };
 
-void bounce(inout Path aa, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
-bT = uint(max(depth, 0));
+${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));
 
 
 
@@ -119,11 +142,11 @@ ${intelMac ? doubleTransmissionCheckCode : ''}
 
 bool isShadowCatcher = mat.materialType == SHADOW_CATCHER;
 if (isShadowCatcher) {
-if (aa.fromEye) {
+if (path.fromEye) {
 
 
 outAux.albedo = vec3(1.0);
-outAux.normal = dot(si.normal, aa.ray.d) > 0.0 ? -si.normal : si.normal;
+outAux.normal = dot(si.normal, path.ray.d) > 0.0 ? -si.normal : si.normal;
 si.hit = false;
 outAux.isShadowCatcher = true;
 }
@@ -131,97 +154,97 @@ else {
 
 
 #ifdef USE_ENVMAP
-if (aa.isNextRefraction) {
+if (path.isNextRefraction) {
 
 
 
-vec4 bg = cG(aa.ray.o, aa.ray.d);
-bg.rgb = aj(bg.rgb, bp);
-float da = aa.scatteringIsDelta ? 1.0
-: aK(aa.scatteringPdf,
-iT(dm(aa.ray.d)) * envLightSelectionPmf);
-aa.li += da * aa.beta * bg.rgb * bg.a;
-aa.alpha = max(aa.alpha, bg.a);
+vec4 bg = cq(path.ray.o, path.ray.d);
+bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
+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 vo = dm(aa.ray.d);
-vec3 emission = textureLinear(envMap, vo).rgb;
-emission = aj(emission, bp);
-aa.li += aa.beta * emission *
-aK(
-aa.scatteringPdf,
-iT(vo) * envLightSelectionPmf
+vec2 xp = cU(path.ray.d);
+vec3 emission = textureLinear(envMap, xp).rgb;
+emission = sampling_spectral_rgb_filter(emission, pathChannel);
+path.li += path.beta * emission *
+aG(
+path.scatteringPdf,
+envMapPdf(xp) * envLightSelectionPmf
 );
 }
 #else
-vec4 bg = cG(aa.ray.o, aa.ray.d);
-bg.rgb = aj(bg.rgb, bp);
-aa.li += aa.beta * bg.rgb * bg.a;
+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
-aa.abort = true;
+path.abort = true;
 return;
 }
 }
 
 if (!si.hit) {
 
-vec4 bg = cG(aa.ray.o, aa.ray.d);
+vec4 bg = cq(path.ray.o, path.ray.d);
 
 
 
-bg.rgb = aj(bg.rgb, bp);
-if (aa.fromEye) {
-aa.li = bg.rgb * bg.a;
-aa.alpha = bg.a;
+bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
+if (path.fromEye) {
+path.li = bg.rgb * bg.a;
+path.alpha = bg.a;
 
 outAux.isBlank = bg.a < 0.01;
 }
 else {
-Ray cam = fj(v_Texcoord + tg());
-bool nK = dot(cam.d, aa.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 (nK) {
-aa.alpha = max(aa.alpha, bg.a);
+if (ou) {
+path.alpha = max(path.alpha, bg.a);
 } else {
-aa.alpha = 1.0;
+path.alpha = 1.0;
 }
 }
 #if !defined(USE_ENVMAP)
 
-if (nK) {
-aa.li = aa.beta * aK(aa.scatteringPdf, 1.0) * bg.rgb;
+if (ou) {
+path.li += path.beta * aG(path.scatteringPdf, 1.0) * bg.rgb;
 }
 #endif
 }
-aa.abort = true;
+path.abort = true;
 return;
 }
 
-bool aJ = false;
+${sharePrefix ? '  sampleIgnored = false;' : '  bool sampleIgnored = false;'}
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT)) {
 if (transmissiveOutputAlphaMin < 1.0) {
 
 float alpha = max(1.0 - mat.transmissionWeight, 1.0 - pow(1.0 - transmissiveOutputAlphaMin, float(depth)));
-aa.alpha = max(alpha, aa.alpha);
+path.alpha = max(alpha, path.alpha);
 }
 float alpha = mat.alpha;
 if (alpha < 1.0) {
 
 
-aa.alpha = max(aa.alpha, alpha);
-if (eC(3u) > alpha) {
-aJ = true;
+path.alpha = max(path.alpha, alpha);
+if (cm(3u) > alpha) {
+sampleIgnored = true;
 }
 }
-if (!aJ) {
-mL(si, mat, aa);
+if (!sampleIgnored) {
+nB(si, mat, path);
 }
 else {
-aa.ray.o = si.position + aa.ray.d * EPS;
+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 ||
@@ -243,100 +266,105 @@ si.albedoSampled = true;
 
 
 #ifdef USE_RR
-if (depth >= RR_MAX && !aJ) {
+int wj = path.scatteringMediumEntered ? RR_MAX : 2;
+if (depth >= wj && !sampleIgnored) {
 
-float pn = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
-float q = max(0.0, 1.0 - pn);
-if (dp(cE(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) {
 
 
-aa.alpha = 1.0;
-aa.abort = true;
+path.alpha = 1.0;
+path.abort = true;
 }
 else {
-aa.beta /= 1.0 - q;
+path.beta /= 1.0 - q;
 }
 }
 #endif
 
-if (aa.abort) {
+if (path.abort) {
 return;
 }
 
-
-intersectScene(aa.ray, si, true);
-dg(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+${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) {
-bp = nl;
+pathWavelength = rq;
+pathChannel = rp;
 }
-if (mat.transmissionWeight > 0.001 && bp > 0.0) {
-mat.specularIor = ee(
-bp,
+if (mat.transmissionWeight > 0.001 && pathWavelength > 0.0) {
+mat.specularIor = sampling_cauchy_ior(
+pathWavelength,
 mat.specularIor,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
 
-if (aJ) {
+if (sampleIgnored) {
 return;
 }
 
-bool hM = eC(3u) < mat.alpha;
+bool hN = cm(3u) < mat.alpha;
 #ifdef NUM_LIGHTS
 
 LightSampleRec lightSample;
 for (int i = 0; i < NUM_LIGHTS; i++) {
 
-Light light = rB(i);
-float d = nr(aa.ray, light, lightSample);
-bool lY = si.hit && d > distance(si.position, aa.ray.o);
-if (d != INF && !(lY && hM)) {
+Light light = fetchLight(i);
+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 fl = aK(aa.scatteringPdf, lightSample.pdf);
-lightSample.emission = aj(lightSample.emission, bp);
-aa.li += fl * aa.beta * lightSample.emission;
+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 ? ' }' : ''}
 
-aa.alpha = 1.0;
-aa.abort = true;
+path.alpha = 1.0;
+path.abort = true;
 }
 }
 #endif
 
 #ifdef USE_ENVMAP
-if (!(si.hit && hM)) {
-if (aa.isNextRefraction) {
-
-
-vec4 bg = cG(aa.ray.o, aa.ray.d);
-bg.rgb = aj(bg.rgb, bp);
-float da = aa.scatteringIsDelta ? 1.0
-: aK(aa.scatteringPdf,
-iT(dm(aa.ray.d)) * envLightSelectionPmf);
-aa.li += da * aa.beta * bg.rgb * bg.a;
-aa.alpha = max(aa.alpha, bg.a);
-aa.abort = true;
+if (!(si.hit && hN)) {
+if (path.isNextRefraction) {
+
+
+vec4 bg = cq(path.ray.o, path.ray.d);
+bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathChannel);
+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 = dm(aa.ray.d);
+vec2 uv = cU(path.ray.d);
 vec3 emission = textureLinear(envMap, uv).rgb;
-float fl = aK(
-aa.scatteringPdf,
-iT(uv) * envLightSelectionPmf
+float misWeight = aG(
+path.scatteringPdf,
+envMapPdf(uv) * envLightSelectionPmf
 );
-emission = aj(emission, bp);
-aa.li += aa.beta * emission * fl;
+emission = sampling_spectral_rgb_filter(emission, pathChannel);
+path.li += path.beta * emission * misWeight;
 
 
 #if !defined(USE_BACKGROUND)
-aa.alpha = 1.0;
+path.alpha = 1.0;
 #endif
-aa.abort = true;
+path.abort = true;
 return;
 }
 #endif
@@ -345,177 +373,210 @@ depth++;
 }
 
 
-vec2 ld(float radius, float xi) {
+vec2 lD(float radius, float xi) {
 float x = 0.25;
-for (int oD = 0; oD < 10; oD++) {
+for (int iteration = 0; iteration < 10; iteration++) {
 float x2 = x * x;
 float x3 = x2 * x;
-float lw = 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 mX = 20.0 * x * lw * lw * lw;
-if (abs(value) < 1e-6 || mX == 0.0) break;
-x = clamp(x - value / mX, 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 jL = x * radius;
+float jW = x * radius;
 return vec2(
-jL,
-sqrt(max(radius * radius - jL * jL, 0.0))
+jW,
+sqrt(max(radius * radius - jW * jW, 0.0))
 );
 }
 
-float jj(float radius, float gM) {
-if (gM >= radius) return 0.0;
-float pa = radius - gM;
-return pa * pa * pa;
+float bevelCubicPdf(float radius, float gO) {
+if (gO >= radius) return 0.0;
+float falloff = radius - gO;
+return falloff * falloff * falloff;
 }
 
 
-vec3 nj(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;
-aP(geometricNormal, tangent, bitangent);
-vec3 iW = vec3(0.0);
-
-for (int iG = 0; iG < BEVEL_SAMPLES; iG++) {
-vec2 qf = dZ(CAMERA_BEVEL_BASE + uint(iG));
-float cJ = qf.x;
-float pv = qf.y;
-vec3 dz = geometricNormal;
-vec3 fW = tangent;
-vec3 eA = bitangent;
-float gu = 0.5;
-float iB = 0.25;
-float gT = 0.25;
-if (cJ < 0.5) {
-cJ *= 2.0;
-}
-else if (cJ < 0.75) {
-vec3 nI = dz;
-dz = fW;
-fW = nI;
-gu = 0.25;
-iB = 0.5;
-cJ = (cJ - 0.5) * 4.0;
+sampling_orthonormal_basis(geometricNormal, tangent, bitangent);
+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 nI = dz;
-dz = eA;
-eA = nI;
-gu = 0.25;
-gT = 0.5;
-cJ = (cJ - 0.75) * 4.0;
-}
-
-vec2 hj = ld(radius, pv);
-float phi = TWOPI * cJ;
-vec3 rw = hj.x *
-(cos(phi) * fW + sin(phi) * eA);
+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;
-gC(
+initRay(
 ray,
-source.position + dz * hj.y + rw,
--dz
+source.position + dc * hm.y + sI,
+-dc
 );
 SurfaceInteraction hit;
 intersectSceneBevel(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * hj.y, EPS)
+max(2.0 * hm.y, EPS)
 );
 if (!hit.hit) continue;
 
-float lA = gu * abs(dot(dz, hit.faceNormal));
-float nC = iB * abs(dot(fW, hit.faceNormal));
-float kG = gT * abs(dot(eA, hit.faceNormal));
-float weight = lA / max(
-lA * lA + nC * nC +
-kG * kG,
+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 *= jj(radius, distance(hit.position, source.position)) /
-max(jj(radius, hj.x), 1e-8);
-iW += weight * hit.vertexNormal;
+weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
+max(bevelCubicPdf(radius, hm.x), 1e-8);
+jd += weight * hit.vertexNormal;
 }
 
-if (dot(iW, iW) <= 1e-12) return source.normal;
-vec3 kg = normalize(iW);
-vec3 result = source.normal + kg - 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 cT(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
-Path aa;
-aa.ray = ray;
-aa.li = vec3(0);
-aa.alpha = transmissiveOutputAlphaMin < 1.0 ? 0.0 : 1.0;
-aa.beta = vec3(1.0);
-aa.fromEye = true;
-aa.scatteringPdf = 0.0;
-aa.scatteringIsDelta = false;
-aa.isNextRefraction = false;
-aa.abort = false;
+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;
+path.beta = vec3(1.0);
+path.fromEye = true;${enabled ? /* glsl */ `
+path.causticK = 0; path.causticSingleT = false;
+path.causticReceiverPrimary = false; path.causticHasReceiver = false; path.causticMneeReceiver=false;` : ''}
+path.scatteringPdf = 0.0;
+path.scatteringIsDelta = false;
+path.isNextRefraction = false;
+path.abort = false;
 int depth = 0;
-${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}
-return vec4(aa.li, aa.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 iU(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 cT(si, ray, mat, outAux);
+return cJ(si, ray, mat, outAux);
 }
 
 
 
 
 
-Ray uG = ray;
-uG.o = si.position + ray.d * (EPS * 0.02);
-SurfaceInteraction kf = si;
-kf.albedoSampled = false;
-intersectScene(uG, kf, false);
-OpenPbrResolvedMaterial oS;
-dg(oS, kf.materialIndex, kf.uv, kf.uv1, kf.instanceIndex, kf.vertexColor);
-RayTraceAuxiliary ez = outAux;
-if (kf.hit && (oS.materialType == STANDARD || oS.materialType == UNLIT)) {
-ez.albedo = oS.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)
-: oS.baseColor;
-ez.normal = dot(
-kf.normal,
-kf.position - vec3(viewInv[3])
+: pN.baseColor;
+backAux.normal = dot(
+kq.normal,
+kq.position - vec3(viewInv[3])
 ) > 0.0
-? -kf.normal
-: kf.normal;
-kf.albedoSampled = oS.transmissionWeight > 0.5;
+? -kq.normal
+: kq.normal;
+kq.albedoSampled = pN.transmissionWeight > 0.5;
 }
-vec4 back = cT(kf, uG, oS, ez);
+vec4 back = cJ(kq, wt, pN, backAux);
 if (coverage <= 0.0) {
-outAux = ez;
+outAux = backAux;
 return back;
 }
 
-SurfaceInteraction xA = si;
-OpenPbrResolvedMaterial vp = mat;
-vp.alpha = 1.0;
-RayTraceAuxiliary se = outAux;
-vec4 front = cT(xA, ray, vp, se);
-outAux.albedo = mix(ez.albedo, se.albedo, coverage);
-vec3 dl = mix(ez.normal, se.normal, coverage);
-outAux.normal = dot(dl, dl) > 1e-12
-? normalize(dl)
+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 = ez.isBlank && se.isBlank;
+outAux.isBlank = backAux.isBlank && tA.isBlank;
 return mix(back, front, coverage);
 }
 
 
 
-vec4 iu(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 hq(Ray ray, out RayTraceAuxiliary outAux) {
 
 SurfaceInteraction si;
 OpenPbrResolvedMaterial mat;
@@ -528,13 +589,13 @@ si.mediumScattering = vec3(0.0);
 si.mediumAnisotropy = 0.0;
 #endif
 
-intersectScene(ray, si, false);
-dg(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+${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 = nj(si, mat.bevel);
+si.normal = kB(si, mat.bevel);
 }
 #endif
 
@@ -550,33 +611,47 @@ outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0
 si.albedoSampled = mat.transmissionWeight > 0.5;
 }
 
-if (mat.transmissionDispersionScale > 0.001) {
-mat.specularIor = ee(
-bp,
+${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,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
-return iU(si, ray, mat, outAux);
+return jb(si, ray, mat, outAux);
 }
 
-void main() {
+void ${sharePrefix ? 'traceSpectralWavelength' : 'main'}(${sharePrefix ? 'int channel' : ''}) {
 
-rG();
-gW(v_Texcoord * viewportSize, int(uint(sampleCount) ^ dG(uint(sequenceSeed))));
+${fragments?.debugInit ?? ''}  sP();
+fA(v_Texcoord * viewportSize, int(uint(sampleCount) ^ cD(uint(sequenceSeed))));
 
 
-bp = dispersionWavelengths == 1 ? 0.0 : wavelength;
-nl = wavelength;
-if (dispersionWavelengths == 1 && wavelength > 0.0) {
-float channel = floor(dp(CAMERA_WAVELENGTH) * 3.0);
-nl = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;
+${sharePrefix ? '  spChannel = channel;\n' : ''}  pathWavelength = 0.0;
+pathChannel = 0;
+if (spectralChannel > 0) {
+float aE = sample1D(CAMERA_WAVELENGTH);
+if (dispersionWavelengths == 1) {
+rp = min(int(aE * 3.0), 2) + 1;
+rq = ce(rp - 1, fract(aE * 3.0));
+} else {
+pathChannel = ${sharePrefix ? 'spChannel' : 'spectralChannel'};
+pathWavelength = ce(${sharePrefix ? 'spChannel' : 'spectralChannel'} - 1, aE);
+}
 }
 
 
 
-Ray cam = oG();
+Ray cam = pq();
 
 RayTraceAuxiliary outAux;
 outAux.albedo = vec3(0.0);
@@ -584,40 +659,51 @@ outAux.normal = vec3(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
 
-vec4 aW = iu(cam, outAux);
+vec4 liAndAlpha = hq(cam, outAux);
 
 
 
 #ifdef CLAMPING
 float clamping = float(CLAMPING);
-aW.rgb = clamp(aW.rgb, -clamping, clamping);
+liAndAlpha.rgb = clamp(liAndAlpha.rgb, -clamping, clamping);
 #endif
 
 
-if (bp > 0.0) {
+if (pathWavelength > 0.0) {
 
-aW.rgb *= 3.0;
+liAndAlpha.rgb *= 3.0;
 if (dispersionWavelengths != 1) {
 
 
-aW.a /= 3.0;
+liAndAlpha.a /= 3.0;
 }
 }
-if (!(aW.x < INF && aW.x > -EPS)) {
-aW = vec4(0, 0, 0, 1);
+if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {
+liAndAlpha = vec4(0, 0, 0, 1);
 }
 
-out_color = aW;
+out_color = ${research?.debugOutput || 'liAndAlpha'};
 out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);
 out_normal = vec4(outAux.normal, 1.0);
 
 
-float jP = dot(aW.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(jP, jP * jP, 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