@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -1,27 +1,29 @@
+import { researchTransport } from '../researchTransport.js';
 import { MAX_PATH_EVENTS } 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 +34,33 @@ 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 yl = 0; yl < BOUNCES; yl++) {{
+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);
+bool xB = !si.isTransparency;
+int rQ = min(BOUNCES, bounceLimit);
 for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {
-if (wY && idx > rT) {
-aa.abort = true;
+if (xB && idx > rQ) {
+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 research = researchTransport()?.fragment(options);
+    const enabled = research?.enabled ?? false;
+    const fragments = research?.fragments;
+    const materialBufferGlsl = createMaterialBufferGlsl(fragments);
+    const rayTraceCore = createRayTraceCoreGlsl(fragments);
+    const sampleMaterialGlsl = createSampleMaterialGlsl(fragments);
     const intelMac = isIntelMac();
     return new FragmentShader({
         name: 'rayTraceFrag',
@@ -61,6 +69,9 @@ 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'),
@@ -68,12 +79,12 @@ export default function createRayTraceFragmentShader() {
             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 +102,16 @@ ${intersect.main}
 ${envMap.main}
 
 ${samplingGlsl}
+${spectrumGlsl}
 ${openPbrBsdfGlsl}
 
-float nl;
-float bp;
+float qh;
+float pathWavelength;
+int qg;
+int pathChannel;
 
 ${sampleLightGlsl}
-${sampleMaterialGlsl}
+${research?.declarations ?? ''}${sampleMaterialGlsl}
 
 ${cameraRayGlsl}
 struct RayTraceAuxiliary {
@@ -109,8 +123,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));
+void bounce(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+samplingBounce = uint(max(depth, 0));
 
 
 
@@ -119,11 +133,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,69 +145,69 @@ 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 = cn(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;
+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 vC = cT(path.ray.d);
+vec3 emission = textureLinear(envMap, vC).rgb;
+emission = sampling_spectral_rgb_filter(emission, pathChannel);
+path.li += path.beta * emission *
+aF(
+path.scatteringPdf,
+envMapPdf(vC) * 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 = cn(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 = cn(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 = eT(v_Texcoord + te());
+bool nt = dot(cam.d, path.ray.d) > 0.0;
 if (transmissiveOutputAlphaMin < 1.0) {
-if (nK) {
-aa.alpha = max(aa.alpha, bg.a);
+if (nt) {
+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 (nt) {
+path.li += path.beta * aF(path.scatteringPdf, 1.0) * bg.rgb;
 }
 #endif
 }
-aa.abort = true;
+path.abort = true;
 return;
 }
 
@@ -202,22 +216,22 @@ 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) {
+path.alpha = max(path.alpha, alpha);
+if (ek(3u) > alpha) {
 aJ = true;
 }
 }
 if (!aJ) {
-mL(si, mat, aa);
+mx(si, mat, path);
 }
 else {
-aa.ray.o = si.position + aa.ray.d * EPS;
+path.ray.o = si.position + path.ray.d * EPS;
 }
 }
 
@@ -245,38 +259,39 @@ si.albedoSampled = true;
 #ifdef USE_RR
 if (depth >= RR_MAX && !aJ) {
 
-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 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) {
 
 
-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);
+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 = qh;
+pathChannel = qg;
 }
-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
@@ -287,56 +302,56 @@ if (aJ) {
 return;
 }
 
-bool hM = eC(3u) < mat.alpha;
+bool ht = ek(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 = mX(path.ray, light, lightSample);
+bool lH = si.hit && d > distance(si.position, path.ray.o);
+if (d != INF && !(lH && ht)) {
 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 = aF(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 && ht)) {
+if (path.isNextRefraction) {
+
+
+vec4 bg = cn(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;
+path.alpha = max(path.alpha, bg.a);
+path.abort = true;
 return;
 }
-vec2 uv = dm(aa.ray.d);
+vec2 uv = cT(path.ray.d);
 vec3 emission = textureLinear(envMap, uv).rgb;
-float fl = aK(
-aa.scatteringPdf,
-iT(uv) * envLightSelectionPmf
+float misWeight = aF(
+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 +360,179 @@ depth++;
 }
 
 
-vec2 ld(float radius, float xi) {
+vec2 kK(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 la = 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 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 jL = x * radius;
+float jr = x * radius;
 return vec2(
-jL,
-sqrt(max(radius * radius - jL * jL, 0.0))
+jr,
+sqrt(max(radius * radius - jr * jr, 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 gu) {
+if (gu >= radius) return 0.0;
+float falloff = radius - gu;
+return falloff * falloff * falloff;
 }
 
 
-vec3 nj(SurfaceInteraction source, float radius) {
+vec3 mT(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 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;
 }
 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 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);
 Ray ray;
-gC(
+initRay(
 ray,
-source.position + dz * hj.y + rw,
--dz
+source.position + cZ * gQ.y + rr,
+-cZ
 );
 SurfaceInteraction hit;
 intersectSceneBevel(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * hj.y, EPS)
+max(2.0 * gQ.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 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,
 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, gQ.x), 1e-8);
+iE += 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(iE, iE) <= 1e-12) return source.normal;
+vec3 jM = normalize(iE);
+vec3 result = source.normal + jM - 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 cG(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+Path path;
+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);
+return vec4(path.li, path.alpha);
 }
 
-vec4 iU(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {
+vec4 iC(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 cG(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 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
 ? vec3(1.0)
-: oS.baseColor;
-ez.normal = dot(
-kf.normal,
-kf.position - vec3(viewInv[3])
+: oH.baseColor;
+eg.normal = dot(
+jL.normal,
+jL.position - vec3(viewInv[3])
 ) > 0.0
-? -kf.normal
-: kf.normal;
-kf.albedoSampled = oS.transmissionWeight > 0.5;
+? -jL.normal
+: jL.normal;
+jL.albedoSampled = oH.transmissionWeight > 0.5;
 }
-vec4 back = cT(kf, uG, oS, ez);
+vec4 back = cG(jL, uK, oH, eg);
 if (coverage <= 0.0) {
-outAux = ez;
+outAux = eg;
 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 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)
 : vec3(0.0);
-outAux.isBlank = ez.isBlank && se.isBlank;
+outAux.isBlank = eg.isBlank && sa.isBlank;
 return mix(back, front, coverage);
 }
 
 
 
-vec4 iu(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 hR(Ray ray, out RayTraceAuxiliary outAux) {
 
 SurfaceInteraction si;
 OpenPbrResolvedMaterial mat;
@@ -529,12 +546,12 @@ si.mediumAnisotropy = 0.0;
 #endif
 
 intersectScene(ray, si, false);
-dg(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+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 = mT(si, mat.bevel);
 }
 #endif
 
@@ -551,32 +568,38 @@ si.albedoSampled = mat.transmissionWeight > 0.5;
 }
 
 if (mat.transmissionDispersionScale > 0.001) {
-mat.specularIor = ee(
-bp,
+mat.specularIor = sampling_cauchy_ior(
+pathWavelength,
 mat.specularIor,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
-return iU(si, ray, mat, outAux);
+return iC(si, ray, mat, outAux);
 }
 
 void main() {
 
-rG();
-gW(v_Texcoord * viewportSize, int(uint(sampleCount) ^ dG(uint(sequenceSeed))));
+${fragments?.debugInit ?? ''}  rA();
+fi(v_Texcoord * viewportSize, int(uint(sampleCount) ^ cB(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;
+pathWavelength = 0.0;
+pathChannel = 0;
+if (spectralChannel > 0) {
+float aZ = sample1D(CAMERA_WAVELENGTH);
+if (dispersionWavelengths == 1) {
+qg = min(int(aZ * 3.0), 2) + 1;
+qh = cU(qg - 1, fract(aZ * 3.0));
+} else {
+pathChannel = spectralChannel;
+pathWavelength = cU(spectralChannel - 1, aZ);
+}
 }
 
 
 
-Ray cam = oG();
+Ray cam = ow();
 
 RayTraceAuxiliary outAux;
 outAux.albedo = vec3(0.0);
@@ -584,38 +607,38 @@ outAux.normal = vec3(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
 
-vec4 aW = iu(cam, outAux);
+vec4 liAndAlpha = hR(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 jw = 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(jw, jw * jw, 1.0, 0.0);
 
 }`
     });