@meimu/mutracer 0.1.5 → 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 vU = 0; vU < BOUNCES; vU++) {{
-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 vg = !si.isTransparency;
-int qO = 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 (vg && idx > qO) {
-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 mv;
-float bf;
+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 ad si, inout J mat, inout RayTraceAuxiliary outAux) {
-cF = 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,97 +145,97 @@ else {
 
 
 #ifdef USE_ENVMAP
-if (aa.isNextRefraction) {
+if (path.isNextRefraction) {
 
 
 
-vec4 bg = cx(aa.ray.o, aa.ray.d);
-bg.rgb = ai(bg.rgb, bf);
-float cT = aa.scatteringIsDelta ? 1.0
-: aG(aa.scatteringPdf,
-iB(cY(aa.ray.d)) * envLightSelectionPmf);
-aa.li += cT * 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 tQ = cY(aa.ray.d);
-vec3 emission = textureLinear(envMap, tQ).rgb;
-emission = ai(emission, bf);
-aa.li += aa.beta * emission *
-aG(
-aa.scatteringPdf,
-iB(tQ) * 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 = cx(aa.ray.o, aa.ray.d);
-bg.rgb = ai(bg.rgb, bf);
-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 = cx(aa.ray.o, aa.ray.d);
+vec4 bg = cn(path.ray.o, path.ray.d);
 
 
 
-bg.rgb = ai(bg.rgb, bf);
-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 = hC(v_Texcoord + sa());
-bool mL = 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 (mL) {
-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 (mL) {
-aa.li = aa.beta * aG(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;
 }
 
-bool cH = false;
+bool aJ = 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 (eo(3u) > alpha) {
-cH = true;
+path.alpha = max(path.alpha, alpha);
+if (ek(3u) > alpha) {
+aJ = true;
 }
 }
-if (!cH) {
-mb(si, mat, aa);
+if (!aJ) {
+mx(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 && !cH) {
+if (!si.albedoSampled && !aJ) {
 
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT) &&
 !(mat.transmissionWeight > 0.5 ||
@@ -243,100 +257,101 @@ si.albedoSampled = true;
 
 
 #ifdef USE_RR
-if (depth >= RR_MAX && !cH) {
+if (depth >= RR_MAX && !aJ) {
 
-float oy = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
-float q = max(0.0, 1.0 - oy);
-if (dz(cw(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;
 }
 
 
-cZ(aa.ray, si, true);
-eX(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) {
-bf = mv;
+pathWavelength = qh;
+pathChannel = qg;
 }
-if (mat.transmissionWeight > 0.001 && bf > 0.0) {
-mat.specularIor = eN(
-bf,
+if (mat.transmissionWeight > 0.001 && pathWavelength > 0.0) {
+mat.specularIor = sampling_cauchy_ior(
+pathWavelength,
 mat.specularIor,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
 
-if (cH) {
+if (aJ) {
 return;
 }
 
-bool hy = eo(3u) < mat.alpha;
+bool ht = ek(3u) < mat.alpha;
 #ifdef NUM_LIGHTS
 
 LightSampleRec lightSample;
 for (int i = 0; i < NUM_LIGHTS; i++) {
 
-Light light = qx(i);
-float d = my(aa.ray, light, lightSample);
-bool mC = si.hit && d > distance(si.position, aa.ray.o);
-if (d != INF && !(mC && hy)) {
+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 fa = aG(aa.scatteringPdf, lightSample.pdf);
-lightSample.emission = ai(lightSample.emission, bf);
-aa.li += fa * 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 && hy)) {
-if (aa.isNextRefraction) {
-
-
-vec4 bg = cx(aa.ray.o, aa.ray.d);
-bg.rgb = ai(bg.rgb, bf);
-float cT = aa.scatteringIsDelta ? 1.0
-: aG(aa.scatteringPdf,
-iB(cY(aa.ray.d)) * envLightSelectionPmf);
-aa.li += cT * 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 = cY(aa.ray.d);
+vec2 uv = cT(path.ray.d);
 vec3 emission = textureLinear(envMap, uv).rgb;
-float fa = aG(
-aa.scatteringPdf,
-iB(uv) * envLightSelectionPmf
+float misWeight = aF(
+path.scatteringPdf,
+envMapPdf(uv) * envLightSelectionPmf
 );
-emission = ai(emission, bf);
-aa.li += aa.beta * emission * fa;
+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,180 +360,182 @@ depth++;
 }
 
 
-vec2 kz(float radius, float xi) {
+vec2 kK(float radius, float xi) {
 float x = 0.25;
-for (int nG = 0; nG < 10; nG++) {
+for (int iteration = 0; iteration < 10; iteration++) {
 float x2 = x * x;
 float x3 = x2 * x;
-float kP = 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 mj = 20.0 * x * kP * kP * kP;
-if (abs(value) < 1e-6 || mj == 0.0) break;
-x = clamp(x - value / mj, 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 jo = x * radius;
+float jr = x * radius;
 return vec2(
-jo,
-sqrt(max(radius * radius - jo * jo, 0.0))
+jr,
+sqrt(max(radius * radius - jr * jr, 0.0))
 );
 }
 
-float iT(float radius, float gx) {
-if (gx >= radius) return 0.0;
-float og = radius - gx;
-return og * og * og;
+float bevelCubicPdf(float radius, float gu) {
+if (gu >= radius) return 0.0;
+float falloff = radius - gu;
+return falloff * falloff * falloff;
 }
 
 
-vec3 mt(ad 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;
-aL(geometricNormal, tangent, bitangent);
-vec3 iF = vec3(0.0);
-
-for (int ig = 0; ig < BEVEL_SAMPLES; ig++) {
-vec2 ph = fp(CAMERA_BEVEL_BASE + uint(ig));
-float cA = ph.x;
-float oF = ph.y;
-vec3 dj = geometricNormal;
+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 ek = bitangent;
-float gf = 0.5;
-float hY = 0.25;
-float gH = 0.25;
-if (cA < 0.5) {
-cA *= 2.0;
-}
-else if (cA < 0.75) {
-vec3 mJ = dj;
-dj = fI;
-fI = mJ;
-gf = 0.25;
-hY = 0.5;
-cA = (cA - 0.5) * 4.0;
+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 mJ = dj;
-dj = ek;
-ek = mJ;
-gf = 0.25;
-gH = 0.5;
-cA = (cA - 0.75) * 4.0;
-}
-
-vec2 gV = kz(radius, oF);
-float phi = TWOPI * cA;
-vec3 qv = gV.x *
-(cos(phi) * fI + sin(phi) * ek);
+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;
-iC(
+initRay(
 ray,
-source.position + dj * gV.y + qv,
--dj
+source.position + cZ * gQ.y + rr,
+-cZ
 );
-ad hit;
-iM(
+SurfaceInteraction hit;
+intersectSceneBevel(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * gV.y, EPS)
+max(2.0 * gQ.y, EPS)
 );
 if (!hit.hit) continue;
 
-float kQ = gf * abs(dot(dj, hit.faceNormal));
-float mF = hY * abs(dot(fI, hit.faceNormal));
-float kb = gH * abs(dot(ek, hit.faceNormal));
-float weight = kQ / max(
-kQ * kQ + mF * mF +
-kb * kb,
+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 *= iT(radius, distance(hit.position, source.position)) /
-max(iT(radius, gV.x), 1e-8);
-iF += weight * hit.vertexNormal;
+weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
+max(bevelCubicPdf(radius, gQ.x), 1e-8);
+iE += weight * hit.vertexNormal;
 }
 
-if (dot(iF, iF) <= 1e-12) return source.normal;
-vec3 jH = normalize(iF);
-vec3 result = source.normal + jH - 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 bw(ad si, Ray ray, J 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 iD(ad si, Ray ray, J 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 bw(si, ray, mat, outAux);
+return cG(si, ray, mat, outAux);
 }
 
 
 
 
 
-Ray nX = ray;
-nX.o = si.position + ray.d * (EPS * 0.02);
-ad dE = si;
-dE.albedoSampled = false;
-cZ(nX, dE, false);
-J nW;
-eX(nW, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
-RayTraceAuxiliary gn = outAux;
-if (dE.hit && (nW.materialType == STANDARD || nW.materialType == UNLIT)) {
-gn.albedo = nW.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)
-: nW.baseColor;
-gn.normal = dot(
-dE.normal,
-dE.position - vec3(viewInv[3])
+: oH.baseColor;
+eg.normal = dot(
+jL.normal,
+jL.position - vec3(viewInv[3])
 ) > 0.0
-? -dE.normal
-: dE.normal;
-dE.albedoSampled = nW.transmissionWeight > 0.5;
+? -jL.normal
+: jL.normal;
+jL.albedoSampled = oH.transmissionWeight > 0.5;
 }
-vec4 back = bw(dE, nX, nW, gn);
+vec4 back = cG(jL, uK, oH, eg);
 if (coverage <= 0.0) {
-outAux = gn;
+outAux = eg;
 return back;
 }
 
-ad tu = si;
-J tR = mat;
-tR.alpha = 1.0;
-RayTraceAuxiliary iW = outAux;
-vec4 qY = bw(tu, ray, tR, iW);
-outAux.albedo = mix(gn.albedo, iW.albedo, coverage);
-vec3 fW = mix(gn.normal, iW.normal, coverage);
-outAux.normal = dot(fW, fW) > 1e-12
-? normalize(fW)
+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 = gn.isBlank && iW.isBlank;
-return mix(back, qY, coverage);
+outAux.isBlank = eg.isBlank && sa.isBlank;
+return mix(back, front, coverage);
 }
 
 
 
-vec4 mx(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 hR(Ray ray, out RayTraceAuxiliary outAux) {
 
-ad si;
-J mat;
+SurfaceInteraction si;
+OpenPbrResolvedMaterial mat;
 
 si.albedoSampled = false;
 #ifdef HAS_MEDIUM
@@ -528,13 +545,13 @@ si.mediumScattering = vec3(0.0);
 si.mediumAnisotropy = 0.0;
 #endif
 
-cZ(ray, si, false);
-eX(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+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 = mT(si, mat.bevel);
 }
 #endif
 
@@ -551,32 +568,38 @@ si.albedoSampled = mat.transmissionWeight > 0.5;
 }
 
 if (mat.transmissionDispersionScale > 0.001) {
-mat.specularIor = eN(
-bf,
+mat.specularIor = sampling_cauchy_ior(
+pathWavelength,
 mat.specularIor,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
-return iD(si, ray, mat, outAux);
+return iC(si, ray, mat, outAux);
 }
 
 void main() {
 
-su();
-kh(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
+${fragments?.debugInit ?? ''}  rA();
+fi(v_Texcoord * viewportSize, int(uint(sampleCount) ^ cB(uint(sequenceSeed))));
 
 
-bf = dispersionWavelengths == 1 ? 0.0 : wavelength;
-mv = wavelength;
-if (dispersionWavelengths == 1 && wavelength > 0.0) {
-float channel = floor(dz(CAMERA_WAVELENGTH) * 3.0);
-mv = 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 = nM();
+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 aF = mx(cam, outAux);
+vec4 liAndAlpha = hR(cam, outAux);
 
 
 
 #ifdef CLAMPING
 float clamping = float(CLAMPING);
-aF.rgb = clamp(aF.rgb, -clamping, clamping);
+liAndAlpha.rgb = clamp(liAndAlpha.rgb, -clamping, clamping);
 #endif
 
 
-if (bf > 0.0) {
+if (pathWavelength > 0.0) {
 
-aF.rgb *= 3.0;
+liAndAlpha.rgb *= 3.0;
 if (dispersionWavelengths != 1) {
 
 
-aF.a /= 3.0;
+liAndAlpha.a /= 3.0;
 }
 }
-if (!(aF.x < INF && aF.x > -EPS)) {
-aF = vec4(0, 0, 0, 1);
+if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {
+liAndAlpha = vec4(0, 0, 0, 1);
 }
 
-out_color = aF;
+out_color = ${research?.debugOutput || 'liAndAlpha'};
 out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);
 out_normal = vec4(outAux.normal, 1.0);
 
 
-float jq = dot(aF.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(jq, jq * jq, 1.0, 0.0);
+: vec4(jw, jw * jw, 1.0, 0.0);
 
 }`
     });