@meimu/mutracer 0.2.0 → 0.3.0

package/lib/renderer/wgsl/rayTrace.compute.js

@@ -1,3 +1,7 @@
+import { photonQuerySource } from './photonMap.compute.js';
+import backgroundWgsl from './chunks/background.wgsl.js';
+import { researchTransport } from '../researchTransport.js';
+import { causticPartitionWGSL } from './chunks/caustics.wgsl.js';
 import { MAX_PATH_EVENTS } from '../pathLimits.js';
 import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
 import reflectanceWGSL from './aovReflectance.wgsl.js';
@@ -18,12 +22,18 @@ import { createSampleMaterialWgsl } from './chunks/sampleMaterial.wgsl.js';
 import sampleLightWgsl from './chunks/sampleLight.wgsl.js';
 import { createOpenPbrBsdfWgsl } from './chunks/openPbrBsdf.wgsl.js';
 import samplingWgsl from './chunks/sampling.wgsl.js';
+import { spectrumWgsl } from '../spectrum.js';
 import sampleShadowCatcherWgsl from './chunks/sampleShadowCatcher.wgsl.js';
 import envMapWgsl from './chunks/envMap.wgsl.js';
 import uvProjectionWgsl from './chunks/uvProjection.wgsl.js';
 export const WORKGROUP_SIZE = 8;
 /** Generates the WebGPU megakernel path tracing compute shader. */
-export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections = false, hasCoatNormals = false, hasAlpha = true, hasSceneAlpha = true, blasLayoutMask = 1, spectral, sceneCapabilities, dynamicEnvironment = false, materialCapabilities = ALL_MATERIAL_SHADER_CAPABILITIES, lightCapabilities }, sceneIntersections = '', pathDiagnostic = false, inputHooks) {
+export default function rayTraceCompute(options, sceneIntersections = '', pathDiagnostic = false, inputHooks) {
+    const research = researchTransport()?.compute(options);
+    const enabled = research?.enabled ?? false;
+    const partitionDepth = research?.maxDepth ?? 20;
+    const debugGroup = research?.debugGroup ?? options.debugGroup ?? -1;
+    let { hasDisplacement, workgroupSize = WORKGROUP_SIZE, lightTracing = false, photonMapping = false, photonMaxDepth = 20, hasAnisotropyDirections = false, hasCoatNormals = false, hasAlpha = true, hasSceneAlpha = true, blasLayoutMask = 1, spectral, sceneCapabilities, dynamicEnvironment = false, materialCapabilities = ALL_MATERIAL_SHADER_CAPABILITIES, lightCapabilities } = options;
     hasAnisotropyDirections ||= hasCoatNormals;
     const deterministicPrimaryAlpha = hasAlpha;
     const hasShadowCatcher = sceneCapabilities === undefined || (sceneCapabilities & WGPU_SCENE_FEATURE_BITS.HAS_SHADOW_CATCHER) !== 0;
@@ -44,10 +54,10 @@ si.barycentrics = vec2f(0.0);
 
 (*outAux).albedo = vec3f(1.0);
 (*outAux).normal = select(si.normal, -si.normal, dot(si.normal, ray.d) > 0.0);
-var aa: Path;
-aa.ray = ray;
-aa.fromEye = true;
-(*outAux).shadowCounts = sampleShadowCatcher(si, 0, &aa);
+var path: Path;
+path.ray = ray;
+path.fromEye = true;
+(*outAux).shadowCounts = sampleShadowCatcher(si, 0, &path);
 
 
 return vec4f(1.0);
@@ -55,7 +65,7 @@ return vec4f(1.0);
 else {
 if (HAS_BEVEL && rtUniform.bevel != 0) {
 if (ma.bevel > 0.0) {
-si.normal = nj(si, ma.bevel);
+si.normal = mT(si, ma.bevel);
 }
 }
 
@@ -83,11 +93,12 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 
 ${commonWgsl}
 
-${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities })}
+${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities, caustics: enabled || lightTracing || photonMapping })}
 
 ${uvProjectionWgsl}
 
 ${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals,
+        caustics: enabled || lightTracing || photonMapping,
         hasTransmission: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.transmission) !== 0,
         hasMetalness: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.metal) !== 0 })}
 
@@ -97,57 +108,62 @@ ${randomWgsl}
 ${envMapWgsl}
 
 ${samplingWgsl}
+${spectrumWgsl}
 ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}${inputHooks?.declarations ?? ''}
 
 
-var<private> vg: u32 = 0u;
+var<private> vp: u32 = 0u;
 
 
 
-fn kB() -> u32 {
+fn ke() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn qx(ys: u32) -> f32 {
+fn qp(yQ: u32) -> f32 {
 
 
 
 
 if (SAMPLING_PATTERN == 2) { _ = rand(); }
-let kI = aZ.x + aZ.y * u32(rtUniform.outputSize.x);
-let key = ar(ar(kI, aQ), rtUniform.sequenceSeed);
-let dimension = ar(bT, ys) ^ 0xa511e9b3u;
-return f32(dG(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
+let kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
+let key = ak(ak(kl, aC), rtUniform.sequenceSeed);
+let dimension = ak(samplingBounce, yQ) ^ 0xa511e9b3u;
+return f32(cB(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
 }
 
 
 
-fn uS(fA: f32, scatteringPdf: f32) -> f32 {
-let candidateCount = kB();
+fn uY(lightPdf: f32, scatteringPdf: f32) -> f32 {
+let candidateCount = ke();
 if (candidateCount <= 1u) {
-return aK(fA, scatteringPdf);
+return aF(lightPdf, scatteringPdf);
 }
-let jb = f32(candidateCount) * fA;
-return jb /
-max(jb + scatteringPdf, 1e-20);
+let weightedLightPdf = f32(candidateCount) * lightPdf;
+return weightedLightPdf /
+max(weightedLightPdf + scatteringPdf, 1e-20);
 }
 
 
-fn gj(scatteringPdf: f32, fA: f32) -> f32 {
-let candidateCount = kB();
+fn fV(scatteringPdf: f32, lightPdf: f32) -> f32 {
+let candidateCount = ke();
 if (candidateCount <= 1u) {
-return aK(scatteringPdf, fA);
+return aF(scatteringPdf, lightPdf);
 }
-let jb = f32(candidateCount) * fA;
+let weightedLightPdf = f32(candidateCount) * lightPdf;
 return scatteringPdf /
-max(scatteringPdf + jb, 1e-20);
+max(scatteringPdf + weightedLightPdf, 1e-20);
 }
 
-${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}
+${enabled || lightTracing || photonMapping ? causticPartitionWGSL(enabled, lightTracing, photonMapping, partitionDepth, debugGroup >= 30, photonMaxDepth) : ''}${research?.declarations ?? ''}${photonMapping ? `const CAUSTIC_LIGHT_TRACING=${lightTracing};
+const CAUSTIC_MNEE=${enabled};
+const CAUSTIC_MNEE_MAX_DEPTH=${partitionDepth}u;
+const CAUSTIC_PHOTON_MAX_DEPTH=${photonMaxDepth}u;
+` + photonQuerySource(debugGroup, !lightTracing && (options.photonDirectSubset ?? true)) : ''}${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals, enabled || lightTracing || photonMapping, research?.contribution, photonMapping)}
 ${sampleShadowCatcherWgsl}
 
 
@@ -159,24 +175,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn ie(
-gv: u32,
+fn hH(
+gf: u32,
 radiance: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
 let value = dot(radiance, luminance);
-outNormal[gv] += vec4f(value * value, 0.0, 0.0, 1.0);
+outNormal[gf] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[gv] += vec4f(normal, 1.0);
+outNormal[gf] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn ji(gv: u32, value: f32) {
-outShadowCatcher[gv].moments += vec4f(value, value * value, 0.0, 0.0);
+fn iP(gf: u32, value: f32) {
+outShadowCatcher[gf].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -190,123 +206,23 @@ isBlank: bool,
 shadowCounts: vec2f,
 }
 
-fn dK(point: vec3f, height: f32, radius: f32) -> f32 {
-let ge = length(point);
-if (ge < 0.00001) {
-return -radius;
-}
-
-let iX = radius * point.y / ge;
-let iL = -1.5 * height;
-var eH: f32;
-if (iX >= 0.0) {
-eH = radius;
-}
-else if (iX < iL) {
-eH = -height * ge / point.y;
-}
-else {
-let cL = 1.0
-- iX * iX / (3.0 * iL * iL);
-eH = radius * cL;
-}
-return ge - eH;
-}
-
-fn fd(origin: vec3f, direction: vec3f) -> vec3f {
-if (!USE_GROUNDED_BACKGROUND) {
-return direction;
-}
-let params = rtUniform.groundedBackgroundParams;
-let cf = normalize(direction);
-let center = vec3f(
-rtUniform.groundedBackgroundCenter.x,
-params.z + params.x,
-rtUniform.groundedBackgroundCenter.y
-);
-let bI = origin - center;
-let eT = dot(bI, cf);
-let br = eT * eT
-- dot(bI, bI) + params.y * params.y;
-if (
-br <= 0.0
-|| dK(bI, params.x, params.y) > 0.0
-) {
-return direction;
-}
-
-var cM = -eT + sqrt(br);
-if (cM <= 0.0) {
-return direction;
-}
-
-let oK = bI + cf * cM;
-if (oK.y >= 0.0) {
-return normalize(oK);
-}
-
-if (cf.y < -0.00001 && params.y > 1.5 * params.x) {
-let ir = (-params.x - bI.y) / cf.y;
-let oB = bI + cf * ir;
-let pe = (2.0 / 3.0)
-* sqrt(params.y * params.y - 2.25 * params.x * params.x);
-if (ir > 0.0 && length(oB.xz) <= pe) {
-return normalize(oB);
-}
-}
-
-var cV = 0.0;
-for (var i = 0; i < 14; i++) {
-let fB = (cV + cM) * 0.5;
-let qy = bI + cf * fB;
-if (dK(qy, params.x, params.y) > 0.0) {
-cM = fB;
-}
-else {
-cV = fB;
-}
-}
-let hit = bI + cf * ((cV + cM) * 0.5);
-return normalize(hit);
-}
-
-fn hX(ray: Ray) -> vec4f {
-var bg = vec4f(0.0);
-if (USE_BACKGROUND_MAP) {
-let d = fd(ray.o, ray.d);
-let t = rtUniform.backgroundMapTransform;
-let qZ = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
-let rotation = rtUniform.backgroundMapRotation;
-let hn = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * qZ;
-let bc = textureLinear(backgroundMap, eV(hn));
-bg = vec4f(bc.rgb * t.z, bc.a);
-}
-else if (USE_BACKGROUND) {
-bg = rtUniform.backgroundColor;
-}
-else if (USE_ENVMAP) {
-bg = textureLinear(envMap, dm(ray.d));
-}
-return bg;
-}
-
-fn di(ray: Ray, wavelength: f32) -> vec4f {
-let bg = hX(ray);
+${backgroundWgsl}fn cP(ray: Ray, channel: i32) -> vec4f {
+let bg = ft(ray);
 if (SPECTRAL) {
-return vec4f(aj(bg.rgb, wavelength), bg.a);
+return vec4f(sampling_spectral_rgb_filter(bg.rgb, channel), bg.a);
 }
 return bg;
 }
 
 
 
-fn nY(uv: vec2f, aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, fm: ptr<function, bool>) {
-*fm = false;
-bT = u32(max(*depth, 0));
+fn nO(uv: vec2f, path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, eV: ptr<function, bool>) {
+*eV = false;
+samplingBounce = u32(max(*depth, 0));
 let matType = (*ma).materialType;
 let isShadowCatcher = ${hasShadowCatcher ? /* wgsl */ `matType == SHADOW_CATCHER` : /* wgsl */ `false`};
 if (isShadowCatcher) {
-if ((*aa).fromEye) {
+if ((*path).fromEye) {
 (*si).hit = false;
 }
 else {
@@ -314,37 +230,37 @@ else {
 
 
 if (USE_ENVMAP) {
-if ((*aa).isNextRefraction) {
+if ((*path).isNextRefraction) {
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-let da = select(gj((*aa).scatteringPdf,
-iT(dm((*aa).ray.d)) * rtUniform.envLightPmf),
-1.0, (*aa).scatteringIsDelta);
-(*aa).li += da * (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = max((*aa).alpha, bg.a);
+let cM = select(fV((*path).scatteringPdf,
+envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).alpha = max((*path).alpha, bg.a);
 }
 else {
-let vo = dm((*aa).ray.d);
-var emission = textureLinear(envMap, vo).rgb;
+let vC = cT((*path).ray.d);
+var emission = textureLinear(envMap, vC).rgb;
 if (SPECTRAL) {
-emission = aj(emission, (*si).wavelength);
+emission = sampling_spectral_rgb_filter(emission, (*si).spectralChannel);
 }
-(*aa).li += (*aa).beta * emission *
-gj((*aa).scatteringPdf, iT(vo));
+(*path).li += (*path).beta * emission *
+fV((*path).scatteringPdf, envMapPdf(vC));
 }
 }
 else {
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-(*aa).li += (*aa).beta * bg.rgb * bg.a;
+(*path).li += (*path).beta * bg.rgb * bg.a;
 }
-(*aa).abort = true;
+(*path).abort = true;
 return;
 }
 }
@@ -352,40 +268,40 @@ if (!(*si).hit) {
 
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-if ((*aa).fromEye) {
+if ((*path).fromEye) {
 
-(*aa).li = (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = bg.a;
+(*path).li = (*path).beta * bg.rgb * bg.a;
+(*path).alpha = bg.a;
 
 (*outAux).isBlank = bg.a < 0.001 ||
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = fj(uv);
-let nK = dot(cam.d, (*aa).ray.d) > 0.0;
+let cam = eT(uv);
+let nt = dot(cam.d, (*path).ray.d) > 0.0;
 if (rtUniform.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 (!USE_ENVMAP) {
 
 
-if (nK) {
+if (nt) {
 
 
-(*aa).li += (*aa).beta *
-gj((*aa).scatteringPdf, 1.0) * bg.rgb;
+(*path).li += (*path).beta *
+fV((*path).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
-(*aa).abort = true;
+(*path).abort = true;
 return;
 }
 
@@ -396,28 +312,28 @@ let alpha = clamp((*ma).alpha, 0.0, 1.0);
 if (alpha < 1.0) {
 
 
-if (alpha <= 0.0 || eC(3u) > alpha) {
-(*fm) = true;
+if (alpha <= 0.0 || ek(3u) > alpha) {
+(*eV) = true;
 }
 }
-if (!(*fm) && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (!(*eV) && rtUniform.transmissiveOutputAlphaMin < 1.0) {
 
 
 let outputAlpha = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
-(*aa).alpha = max(outputAlpha, (*aa).alpha);
+(*path).alpha = max(outputAlpha, (*path).alpha);
 }
-if (!(*fm)) {
-vg = u32(max(*depth, 0));
-mL(si, ma, aa);
+if (!(*eV)) {
+vp = u32(max(*depth, 0));
+mx(si, ma, path);
 }
 else {
 
 
-(*aa).ray.o = (*si).position + (*aa).ray.d * EPS;
+(*path).ray.o = (*si).position + (*path).ray.d * EPS;
 }
 }
 
-if (!(*si).albedoSampled && !(*fm)) {
+if (!(*si).albedoSampled && !(*eV)) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -442,34 +358,34 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !(*fm)) {
-let pG = (*aa).beta;
+if (*depth >= RR_MAX && !(*eV)) {
+let pl = (*path).beta;
 
-let pn = max(max(pG.x, pG.y), pG.z);
-let q: f32 = max(0.0, 1.0 - pn);
-if (dp(cE(RUSSIAN_ROULETTE)) < q) {
+let pc = max(max(pl.x, pl.y), pl.z);
+let q: f32 = 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;
 }
 }
 }
-if ((*aa).abort) {
+if ((*path).abort) {
 return;
 }
 
 
 }
 
-fn kl(aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, aJ: bool) {
+fn jQ(path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, aJ: bool) {
 if (SPECTRAL) {
 
 if ((*ma).transmissionWeight > 0.001) {
-(*ma).specularIor = ee(
+(*ma).specularIor = sampling_cauchy_ior(
 (*si).wavelength,
 (*ma).specularIor,
 (*ma).transmissionDispersionScale,
@@ -484,298 +400,299 @@ return;
 
 
 var lightSample: LightSampleRec;
-let hM = eC(3u) < (*ma).alpha;
+let ht = ek(3u) < (*ma).alpha;
 for (var i = 0; i < rtUniform.lightsCount; i++) {
 
 let light: Light = analyticLights[i];
-let d = nr((*aa).ray, light, &lightSample);
+let d = mX((*path).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let lY = (*si).hit && d > distance((*si).position, (*aa).ray.o);
-if (d != INF && !(lY && hM)) {
-let fl = gj((*aa).scatteringPdf, lightSample.pdf);
+let lH = (*si).hit && d > distance((*si).position, (*path).ray.o);
+if (d != INF && !(lH && ht)) {
+let misWeight = fV((*path).scatteringPdf, lightSample.pdf);
 if (SPECTRAL) {
-lightSample.emission = aj(lightSample.emission, (*si).wavelength);
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, (*si).spectralChannel);
 }
-(*aa).li += fl * (*aa).beta * lightSample.emission;
-(*aa).alpha = 1.0;
-(*aa).abort = true;
+${enabled || lightTracing || photonMapping ? 'if (!causticHitOwned(*path, true, true)) { causticHotRecord(*path,misWeight*lightSample.emission,2u); ' : ''}(*path).li += misWeight * (*path).beta * lightSample.emission;${enabled || lightTracing || photonMapping ? ' }' : ''}
+(*path).alpha = 1.0;
+(*path).abort = true;
 }
 }
 
 if (USE_ENVMAP) {
-if (!((*si).hit && hM)) {
-if ((*aa).isNextRefraction) {
+if (!((*si).hit && ht)) {${lightTracing || photonMapping ? /* wgsl */ `
+if(causticHitOwned(*path,false,true)){(*path).abort=true;return;}` : ''}
+if ((*path).isNextRefraction) {
 
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-let da = select(gj((*aa).scatteringPdf,
-iT(dm((*aa).ray.d)) * rtUniform.envLightPmf),
-1.0, (*aa).scatteringIsDelta);
-(*aa).li += da * (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = max((*aa).alpha, bg.a);
-(*aa).abort = true;
+let cM = select(fV((*path).scatteringPdf,
+envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).alpha = max((*path).alpha, bg.a);
+(*path).abort = true;
 return;
 }
-let _uv = dm((*aa).ray.d);
+let _uv = cT((*path).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let fl = gj(
-(*aa).scatteringPdf,
-iT(_uv) * rtUniform.envLightPmf
+let misWeight = fV(
+(*path).scatteringPdf,
+envMapPdf(_uv) * rtUniform.envLightPmf
 );
 if (SPECTRAL) {
-emission = aj(emission, (*si).wavelength);
+emission = sampling_spectral_rgb_filter(emission, (*si).spectralChannel);
 }
 
 if (!USE_BACKGROUND) {
-(*aa).alpha = 1.0;
+(*path).alpha = 1.0;
 }
-(*aa).li += (*aa).beta * emission * fl;
-(*aa).abort = true;
+(*path).li += (*path).beta * emission * misWeight;
+(*path).abort = true;
 }
 }
 
 *depth = *depth + 1;
 }
 
-fn fj(coord: vec2f) -> Ray {
+fn eT(coord: vec2f) -> Ray {
 let origin = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, -1.0, 1.0);
 let center = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, 1.0, 1.0);
 var cam: Ray;
-gC(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
+initRay(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
 
 return cam;
 }
 
 
-fn ld(radius: f32, xi: f32) -> vec2f {
+fn kK(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var oD = 0; oD < 10; oD++) {
+for (var iteration = 0; iteration < 10; iteration++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let lw = 1.0 - x;
+let la = 1.0 - x;
 let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-let 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);
+let 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);
 }
-let jL = x * radius;
-return vec2f(jL, sqrt(max(radius * radius - jL * jL, 0.0)));
+let jr = x * radius;
+return vec2f(jr, sqrt(max(radius * radius - jr * jr, 0.0)));
 }
 
-fn jj(radius: f32, gM: f32) -> f32 {
-if (gM >= radius) { return 0.0; }
-let pa = radius - gM;
-return pa * pa * pa;
+fn bevelCubicPdf(radius: f32, gu: f32) -> f32 {
+if (gu >= radius) { return 0.0; }
+let falloff = radius - gu;
+return falloff * falloff * falloff;
 }
 
 
-fn nj(source: SurfaceInteraction, radius: f32) -> vec3f {
+fn mT(source: SurfaceInteraction, radius: f32) -> vec3f {
 var geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) {
 geometricNormal = -geometricNormal;
 }
 var tangent: vec3f;
 var bitangent: vec3f;
-aP(geometricNormal, &tangent, &bitangent);
-var iW = vec3f(0.0);
-
-for (var iG = 0; iG < BEVEL_SAMPLES; iG++) {
-let qf = dZ(CAMERA_BEVEL_BASE + u32(iG));
-var cJ = qf.x;
-let pv = qf.y;
-var dz = geometricNormal;
-var fW = tangent;
-var eA = bitangent;
-var gu = 0.5;
-var iB = 0.25;
-var gT = 0.25;
-if (cJ < 0.5) {
-cJ *= 2.0;
-}
-else if (cJ < 0.75) {
-let nI = dz;
-dz = fW;
-fW = nI;
-gu = 0.25;
-iB = 0.5;
-cJ = (cJ - 0.5) * 4.0;
+sampling_orthonormal_basis(geometricNormal, &tangent, &bitangent);
+var iE = vec3f(0.0);
+
+for (var ih = 0; ih < BEVEL_SAMPLES; ih++) {
+let qa = sample2D(CAMERA_BEVEL_BASE + u32(ih));
+var cr = qa.x;
+let pj = qa.y;
+var cZ = geometricNormal;
+var fI = tangent;
+var eh = bitangent;
+var ge = 0.5;
+var hW = 0.25;
+var gC = 0.25;
+if (cr < 0.5) {
+cr *= 2.0;
+}
+else if (cr < 0.75) {
+let nr = cZ;
+cZ = fI;
+fI = nr;
+ge = 0.25;
+hW = 0.5;
+cr = (cr - 0.5) * 4.0;
 }
 else {
-let nI = dz;
-dz = eA;
-eA = nI;
-gu = 0.25;
-gT = 0.5;
-cJ = (cJ - 0.75) * 4.0;
-}
-
-let hj = ld(radius, pv);
-let phi = TWOPI * cJ;
-let rw = hj.x *
-(cos(phi) * fW + sin(phi) * eA);
+let nr = cZ;
+cZ = eh;
+eh = nr;
+ge = 0.25;
+gC = 0.5;
+cr = (cr - 0.75) * 4.0;
+}
+
+let gQ = kK(radius, pj);
+let phi = TWOPI * cr;
+let rr = gQ.x *
+(cos(phi) * fI + sin(phi) * eh);
 var ray: Ray;
-gC(
+initRay(
 &ray,
-source.position + dz * hj.y + rw,
--dz
+source.position + cZ * gQ.y + rr,
+-cZ
 );
 var hit: SurfaceInteraction;
 intersectSceneBevel(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * hj.y, EPS)
+max(2.0 * gQ.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-let lA = gu * abs(dot(dz, hit.faceNormal));
-let nC = iB * abs(dot(fW, hit.faceNormal));
-let kG = gT * abs(dot(eA, hit.faceNormal));
-var weight = lA / max(
-lA * lA + nC * nC +
-kG * kG,
+let lc = ge * abs(dot(cZ, hit.faceNormal));
+let nj = hW * abs(dot(fI, hit.faceNormal));
+let kj = gC * abs(dot(eh, hit.faceNormal));
+var 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; }
-let kg = normalize(iW);
-let result = source.normal + kg - source.vertexNormal;
+if (dot(iE, iE) <= 1e-12) { return source.normal; }
+let jM = normalize(iE);
+let result = source.normal + jM - source.vertexNormal;
 if (dot(result, result) > 1e-12) { return normalize(result); }
 return source.normal;
 }
 
-fn cT(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, sh: bool) -> vec4f {
-var aa: Path;
-aa.ray = ray;
-aa.li = vec3f(0.0);
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
-aa.beta = vec3f(1.0);
-aa.fromEye = true;
-aa.scatteringPdf = 0.0;
-aa.scatteringIsDelta = false;
-aa.isNextRefraction = false;
-aa.abort = false;
+fn cG(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, sc: bool) -> vec4f {
+var path: Path;
+path.ray = ray;
+path.li = vec3f(0.0);
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path.beta = vec3f(1.0);
+path.fromEye = true;
+path.scatteringPdf = 0.0;
+path.scatteringIsDelta = false;
+path.isNextRefraction = false;
+path.abort = false;
 
 let bounceLimit = max(rtUniform.bounces, 0);
-let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
 var depth = 0;
 var aJ = false;
-var bQ = false;
+var bH = false;
 
 
 
 
-for (var event = 0; event <= ft; event++) {
-if ((event != 0) | sh) {
-intersectScene(aa.ray, si, depth, event != 0, aa.isNextRefraction);
-dg(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
+for (var event = 0; event <= eZ; event++) {
+if ((event != 0) | sc) {
+intersectScene(path.ray, si, depth, event != 0, path.isNextRefraction);
+getMaterial(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 }
 if (event == 0) {
-if (sh & (*si).hit & ((*ma).materialType == STANDARD)) {
+if (sc & (*si).hit & ((*ma).materialType == STANDARD)) {
 (*outAux).albedo = select((*ma).baseColor, vec3f(1.0), (*ma).transmissionWeight > 0.5);
 (*outAux).normal = select((*si).normal, -(*si).normal,
 dot((*si).normal, (*si).position - cameraUniform.viewInv[3].xyz) > 0.0);
 (*si).albedoSampled = (*ma).transmissionWeight > 0.5;
 }
-bQ = ((*ma).transmissionWeight < 0.001) & ((*ma).subsurfaceWeight < 0.001) & ((*ma).alpha > 0.99);
+bH = ((*ma).transmissionWeight < 0.001) & ((*ma).subsurfaceWeight < 0.001) & ((*ma).alpha > 0.99);
 } else {
-kl(&aa, &depth, si, ma, aJ);
+jQ(&path, &depth, si, ma, aJ);
 }
-if (bQ & (event > bounceLimit)) { aa.abort = true; }
-if (aa.abort | (event >= ft)) { break; }
-nY(uv, &aa, &depth, si, ma, outAux, &aJ);
-if (aa.abort) { break; }
+if (bH & (event > bounceLimit)) { path.abort = true; }
+if (path.abort | (event >= eZ)) { break; }
+nO(uv, &path, &depth, si, ma, outAux, &aJ);
+if (path.abort) { break; }
 }
 
-return vec4f(aa.li, aa.alpha);
+return vec4f(path.li, path.alpha);
 }
 
-fn iU(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn iC(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);
 
 
 
 
 let split = (*si).hit & (((*ma).materialType == STANDARD) | ((*ma).materialType == UNLIT)) & (coverage < 1.0);
-var sB = ray;
+var st = ray;
 var tr = *si;
 var tq = *ma;
-var iP = *outAux;
+var iw = *outAux;
 if (split) {
-sB.o = (*si).position + ray.d * (EPS * 0.02);
+st.o = (*si).position + ray.d * (EPS * 0.02);
 tr.albedoSampled = false;
 }
 var back: vec4f;
-var ez: RayTraceAuxiliary;
+var eg: RayTraceAuxiliary;
 
 
-let vh = select(1u, rtUniform.loopUnrollGuard >> 1u, split & (coverage > 0.0));
-for (var uI = 0u; uI < vh; uI++) {
-let result = cT(uv, &tr, sB, &tq, &iP, split & (uI == 0u));
-if (!split | (coverage <= 0.0)) { *outAux = iP; return result; }
-if (uI == 0u) {
-back = result; ez = iP;
+let vq = select(1u, rtUniform.loopUnrollGuard >> 1u, split & (coverage > 0.0));
+for (var uM = 0u; uM < vq; uM++) {
+let result = cG(uv, &tr, st, &tq, &iw, split & (uM == 0u));
+if (!split | (coverage <= 0.0)) { *outAux = iw; return result; }
+if (uM == 0u) {
+back = result; eg = iw;
 tr = *si; tq = *ma; tq.alpha = 1.0;
-sB = ray; iP = *outAux;
+st = ray; iw = *outAux;
 } else {
-(*outAux).albedo = mix(ez.albedo, iP.albedo, coverage);
-let dl = mix(ez.normal, iP.normal, coverage);
-(*outAux).normal = select(vec3f(0.0), normalize(dl), dot(dl, dl) > 1e-12);
-(*outAux).isBlank = ez.isBlank & iP.isBlank;
-(*outAux).isShadowCatcher = ez.isShadowCatcher & iP.isShadowCatcher;
-(*outAux).shadowCounts = mix(ez.shadowCounts, iP.shadowCounts, coverage);
+(*outAux).albedo = mix(eg.albedo, iw.albedo, coverage);
+let cS = mix(eg.normal, iw.normal, coverage);
+(*outAux).normal = select(vec3f(0.0), normalize(cS), dot(cS, cS) > 1e-12);
+(*outAux).isBlank = eg.isBlank & iw.isBlank;
+(*outAux).isShadowCatcher = eg.isShadowCatcher & iw.isShadowCatcher;
+(*outAux).shadowCounts = mix(eg.shadowCounts, iw.shadowCounts, coverage);
 return mix(back, result, coverage);
 }
 }
-return vec4f(0.0);` : /* wgsl */ `return cT(uv, si, ray, ma, outAux, false);`}
+return vec4f(0.0);` : /* wgsl */ `return cG(uv, si, ray, ma, outAux, false);`}
 }
 
 
 
-${spectral === false && deterministicPrimaryAlpha ? /* wgsl */ `fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+${spectral === false && deterministicPrimaryAlpha ? /* wgsl */ `fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
-var oI: SurfaceInteraction;
-var oH: OpenPbrResolvedMaterial;
-var ue: RayTraceAuxiliary;
-var iY = false;
+var oy: SurfaceInteraction;
+var ox: OpenPbrResolvedMaterial;
+var uh: RayTraceAuxiliary;
+var iH = false;
 var query = true;
 var split = false;
 var coverage = 1.0;
 var front = false;
 var back: vec4f;
-var ez: RayTraceAuxiliary;
-var aa: Path; aa.ray = ray;
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
-aa.beta = vec3f(1.0); aa.fromEye = true;
+var eg: RayTraceAuxiliary;
+var path: Path; path.ray = ray;
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path.beta = vec3f(1.0); path.fromEye = true;
 let bounceLimit = max(rtUniform.bounces, 0);
-let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
 var event = 0; var depth = 0; var aJ = false;
-var bQ = false;
+var bH = false;
 
 
 for (var step = 0; step < (${MAX_PATH_EVENTS} + 1) * 2 + 2; step++) {
 if (query) {
-intersectScene(aa.ray, &si, depth, event != 0, aa.isNextRefraction);
-dg(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+intersectScene(path.ray, &si, depth, event != 0, path.isNextRefraction);
+getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 }
 query = true;
-if (!iY) {
+if (!iH) {
 ${primaryGuides}
-oI = si; oH = ma; ue = *outAux;
-iY = true;
+oy = si; ox = ma; uh = *outAux;
+iH = true;
 coverage = clamp(ma.alpha, 0.0, 1.0);
 split = si.hit & ((ma.materialType == STANDARD) | (ma.materialType == UNLIT)) & (coverage < 1.0);
 if (split) {
-aa.ray.o = si.position + ray.d * (EPS * 0.02);
+path.ray.o = si.position + ray.d * (EPS * 0.02);
 si.albedoSampled = false;
 continue;
 }
@@ -788,146 +705,150 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 }
 }
 if (event == 0) {
-bQ = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
+bH = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
 } else {
-kl(&aa, &depth, &si, &ma, aJ);
+jQ(&path, &depth, &si, &ma, aJ);
 }
-if (bQ & (event > bounceLimit)) { aa.abort = true; }
-if (!aa.abort & (event < ft)) {
-nY(uv, &aa, &depth, &si, &ma, outAux, &aJ);
+if (bH & (event > bounceLimit)) { path.abort = true; }
+if (!path.abort & (event < eZ)) {
+nO(uv, &path, &depth, &si, &ma, outAux, &aJ);
 }
-if (aa.abort | (event >= ft)) {
-let result = vec4f(aa.li, aa.alpha);
+if (path.abort | (event >= eZ)) {
+let result = vec4f(path.li, path.alpha);
 if (!split | (coverage <= 0.0)) { return result; }
 if (front) {
-(*outAux).albedo = mix(ez.albedo, (*outAux).albedo, coverage);
-let dl = mix(ez.normal, (*outAux).normal, coverage);
-(*outAux).normal = select(vec3f(0.0), normalize(dl), dot(dl, dl) > 1e-12);
-(*outAux).isBlank = ez.isBlank & (*outAux).isBlank;
-(*outAux).isShadowCatcher = ez.isShadowCatcher & (*outAux).isShadowCatcher;
-(*outAux).shadowCounts = mix(ez.shadowCounts, (*outAux).shadowCounts, coverage);
+(*outAux).albedo = mix(eg.albedo, (*outAux).albedo, coverage);
+let cS = mix(eg.normal, (*outAux).normal, coverage);
+(*outAux).normal = select(vec3f(0.0), normalize(cS), dot(cS, cS) > 1e-12);
+(*outAux).isBlank = eg.isBlank & (*outAux).isBlank;
+(*outAux).isShadowCatcher = eg.isShadowCatcher & (*outAux).isShadowCatcher;
+(*outAux).shadowCounts = mix(eg.shadowCounts, (*outAux).shadowCounts, coverage);
 return mix(back, result, coverage);
 }
-back = result; ez = *outAux;
+back = result; eg = *outAux;
 front = true; query = false; event = 0; depth = 0; aJ = false;
-si = oI; ma = oH; ma.alpha = 1.0; *outAux = ue;
-aa = Path(); aa.ray = ray; aa.beta = vec3f(1.0); aa.fromEye = true;
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+si = oy; ma = ox; ma.alpha = 1.0; *outAux = uh;
+path = Path(); path.ray = ray; path.beta = vec3f(1.0); path.fromEye = true;
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
 } else { event++; }
 }
 return vec4f(0.0);
 }
-` : spectral === false && !deterministicPrimaryAlpha ? /* wgsl */ `fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+` : spectral === false && !deterministicPrimaryAlpha ? /* wgsl */ `fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
-var aa: Path;
-aa.ray = ray;
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
-aa.beta = vec3f(1.0);
-aa.fromEye = true;
+var path: Path;
+path.ray = ray;
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path.beta = vec3f(1.0);
+path.fromEye = true;
 let bounceLimit = max(rtUniform.bounces, 0);
-let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
-var bQ = false;
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+var bH = false;
 var depth = 0;
 var aJ = false;
 
 
 
-for (var event = 0; event <= ft; event++) {
-intersectScene(aa.ray, &si, depth, event != 0, aa.isNextRefraction);
-dg(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+for (var event = 0; event <= eZ; event++) {
+intersectScene(path.ray, &si, depth, event != 0, path.isNextRefraction);
+getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (event == 0) {
 ${primaryGuides}
-bQ = ma.transmissionWeight < 0.001 && ma.subsurfaceWeight < 0.001 && ma.alpha > 0.99;
+bH = ma.transmissionWeight < 0.001 && ma.subsurfaceWeight < 0.001 && ma.alpha > 0.99;
 } else {
-kl(&aa, &depth, &si, &ma, aJ);
+jQ(&path, &depth, &si, &ma, aJ);
 }
-if (bQ && event > bounceLimit) { aa.abort = true; }
-if (aa.abort || event >= ft) { break; }
-nY(uv, &aa, &depth, &si, &ma, outAux, &aJ);
-if (aa.abort) { break; }
+if (bH && event > bounceLimit) { path.abort = true; }
+if (path.abort || event >= eZ) { break; }
+nO(uv, &path, &depth, &si, &ma, outAux, &aJ);
+if (path.abort) { break; }
 }
-return vec4f(aa.li, aa.alpha);
+return vec4f(path.li, path.alpha);
 }
 ` : spectral === true && !deterministicPrimaryAlpha ? /* wgsl */ `
-fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
-var oI: SurfaceInteraction;
-var oH: OpenPbrResolvedMaterial;
-var iY = false;
-var aa: Path; aa.ray = ray;
+var oy: SurfaceInteraction;
+var ox: OpenPbrResolvedMaterial;
+var iH = false;
+var path: Path; path.ray = ray;
 let bounceLimit = max(rtUniform.bounces, 0);
-let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
 var depth = 0; var event = 0; var aJ = false;
-var bQ = false;
-var mx = 0;
-let bo = rtUniform.dispersionWavelengths == 1;
-var df = false;
-var eX = 0;
-var hz: vec4u;
-var eO = 0u;
-var ba: RayTraceAuxiliary;
-let wavelengths = array<f32, 3>(650.0, 510.0, 475.0);
+var bH = false;
+var mc = 0;
+let bi = rtUniform.dispersionWavelengths == 1;
+var ew = false;
+var eG = 0;
+var aZ = 0.0;
+var he: vec4u;
+var ey = 0u;
+var aU: RayTraceAuxiliary;
 var color = vec3f(0.0); var alpha = 0.0;
-var dO = vec3f(0.0);
-var dP = vec3f(0.0);
-var mN = true;
+var dw = vec3f(0.0);
+var dz = vec3f(0.0);
+var mz = true;
 
 
 
-let wF = min((${MAX_PATH_EVENTS} + 1) * 3, i32(rtUniform.loopUnrollGuard * ${Math.ceil((MAX_PATH_EVENTS + 1) * 3 / 4)}u));
-for (var step = 0; step < wF; step++) {
-if (!iY | ((event != 0) & !aa.abort)) {
-intersectScene(aa.ray, &si, depth, event != 0, aa.isNextRefraction);
-dg(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+let xf = min((${MAX_PATH_EVENTS} + 1) * 3, i32(rtUniform.loopUnrollGuard * ${Math.ceil((MAX_PATH_EVENTS + 1) * 3 / 4)}u));
+for (var step = 0; step < xf; step++) {
+if (!iH | ((event != 0) & !path.abort)) {
+intersectScene(path.ray, &si, depth, event != 0, path.isNextRefraction);
+getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 }
 if (event == 0) {
-if (!iY) {
+if (!iH) {
 ${primaryGuides}
-oI = si; oH = ma; iY = true;
-hz = s0; eO = cP;
-df = si.hit & (ma.transmissionWeight > 0.001) & (ma.transmissionDispersionScale > 0.001);
-if (bo & df) {
-eX = min(i32(floor(dp(CAMERA_WAVELENGTH) * 3.0)), 2);
-}
-}
-si = oI; ma = oH; ba = *outAux;
-if (!bo) {
-s0 = hz; cP = eO; bT = 0u;
-ba.isBlank = false; ba.isShadowCatcher = false;
-}
-si.wavelength = 0.0;
-if (!bo | df) {
-si.wavelength = wavelengths[select(mx, eX, bo)];
-ma.specularIor = ee(si.wavelength, ma.specularIor,
+oy = si; ox = ma; iH = true;
+ew = si.hit & (ma.transmissionWeight > 0.001) & (ma.transmissionDispersionScale > 0.001);
+aZ = sample1D(CAMERA_WAVELENGTH);
+if (bi) {
+eG = min(i32(floor(aZ * 3.0)), 2);
+aZ = fract(aZ * 3.0);
+}
+he = s0; ey = ca;
+}
+si = oy; ma = ox; aU = *outAux;
+if (!bi) {
+s0 = he; ca = ey; samplingBounce = 0u;
+aU.isBlank = false; aU.isShadowCatcher = false;
+}
+si.wavelength = 0.0; si.spectralChannel = 0;
+if (!bi | ew) {
+let channel = select(mc, eG, bi);
+si.spectralChannel = channel + 1;
+si.wavelength = cU(u32(channel), aZ);
+ma.specularIor = sampling_cauchy_ior(si.wavelength, ma.specularIor,
 ma.transmissionDispersionScale, ma.dispersionAbbeNumber);
 }
-aa = Path(); aa.ray = ray; aa.beta = vec3f(1.0); aa.fromEye = true;
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path = Path(); path.ray = ray; path.beta = vec3f(1.0); path.fromEye = true;
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
 depth = 0; aJ = false;
-bQ = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
-} else if (!aa.abort) {
-kl(&aa, &depth, &si, &ma, aJ);
-}
-if (bQ & (event > bounceLimit)) { aa.abort = true; }
-if (!aa.abort & (event < ft)) {
-nY(uv, &aa, &depth, &si, &ma, &ba, &aJ);
-}
-if (aa.abort | (event >= ft)) {
-let result = vec4f(aa.li, aa.alpha);
-if (bo) {
-*outAux = ba;
-let scale = select(1.0, 3.0, df);
+bH = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
+} else if (!path.abort) {
+jQ(&path, &depth, &si, &ma, aJ);
+}
+if (bH & (event > bounceLimit)) { path.abort = true; }
+if (!path.abort & (event < eZ)) {
+nO(uv, &path, &depth, &si, &ma, &aU, &aJ);
+}
+if (path.abort | (event >= eZ)) {
+let result = vec4f(path.li, path.alpha);
+if (bi) {
+*outAux = aU;
+let scale = select(1.0, 3.0, ew);
 return vec4f(result.rgb * scale, result.a);
 }
 color += result.rgb; alpha = max(alpha, result.a);
-dO += ba.albedo;
-dP += ba.normal;
-mN = mN & ba.isBlank;
-mx++;
-if (mx >= 3) {
-(*outAux).albedo = dO / 3.0;
-(*outAux).normal = dP / 3.0;
-(*outAux).isBlank = mN;
+dw += aU.albedo;
+dz += aU.normal;
+mz = mz & aU.isBlank;
+mc++;
+if (mc >= 3) {
+(*outAux).albedo = dw / 3.0;
+(*outAux).normal = dz / 3.0;
+(*outAux).isBlank = mz;
 return vec4f(color, alpha);
 }
 event = 0;
@@ -935,91 +856,95 @@ event = 0;
 }
 return vec4f(0.0);
 }
-` : /* wgsl */ `fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+` : /* wgsl */ `fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
 intersectScene(ray, &si, 0, false, false);
-dg(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 ${primaryGuides}
 if (SPECTRAL) {
 
 
 
 
-let ug = array<f32, 3>(650.0, 510.0, 475.0);
-var vl = vec3f(0.0);
+var vu = vec3f(0.0);
 var alpha = 0.0;
-var dO = vec3f(0.0);
-var dP = vec3f(0.0);
-var mN = true;
+var dw = vec3f(0.0);
+var dz = vec3f(0.0);
+var mz = true;
 var si2 = si;
 var ma2 = ma;
-let hz = s0;
-let eO = cP;
-let bo = rtUniform.dispersionWavelengths == 1;
-let df = si.hit &&
+var aZ = sample1D(CAMERA_WAVELENGTH);
+let he = s0;
+let ey = ca;
+let bi = rtUniform.dispersionWavelengths == 1;
+let ew = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let tm = select(3, 1, bo);
-var eX = 0;
-if (bo && df) {
+let tm = select(3, 1, bi);
+var eG = 0;
+if (bi) {
 
 
-eX = min(i32(floor(dp(CAMERA_WAVELENGTH) * 3.0)), 2);
+eG = min(i32(floor(aZ * 3.0)), 2);
+aZ = fract(aZ * 3.0);
 }
 for (var i = 0; i < tm; i++) {
 
 
 
-if (!bo) {
-s0 = hz;
-cP = eO;
-bT = 0u;
+if (!bi) {
+s0 = he;
+ca = ey;
+samplingBounce = 0u;
 }
 si.wavelength = 0.0;
-if (!bo || df) {
-si.wavelength = ug[select(i, eX, bo)];
-ma.specularIor = ee(
+si.spectralChannel = 0;
+if (!bi || ew) {
+let channel = select(i, eG, bi);
+si.spectralChannel = channel + 1;
+si.wavelength = cU(u32(channel), aZ);
+ma.specularIor = sampling_cauchy_ior(
 si.wavelength,
 ma.specularIor,
 ma.transmissionDispersionScale,
 ma.dispersionAbbeNumber
 );
 }
-var ba: RayTraceAuxiliary;
-if (bo) {
-ba = *outAux;
+var aU: RayTraceAuxiliary;
+if (bi) {
+aU = *outAux;
 } else {
-ba.albedo = (*outAux).albedo;
-ba.normal = (*outAux).normal;
-ba.isBlank = false;
-ba.isShadowCatcher = false;
-}
-let res = iU(uv, &si, ray, &ma, &ba);
-if (bo) {
-*outAux = ba;
-let scale = select(1.0, 3.0, df);
+aU.albedo = (*outAux).albedo;
+aU.normal = (*outAux).normal;
+aU.isBlank = false;
+aU.isShadowCatcher = false;
+}
+let res = iC(uv, &si, ray, &ma, &aU);
+if (bi) {
+*outAux = aU;
+let scale = select(1.0, 3.0, ew);
 return vec4f(res.rgb * scale, res.a);
 }
-vl += res.rgb;
+vu += res.rgb;
 alpha = max(alpha, res.a);
-dO += ba.albedo;
-dP += ba.normal;
-mN = mN && ba.isBlank;
+dw += aU.albedo;
+dz += aU.normal;
+mz = mz && aU.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = dO / 3.0;
-(*outAux).normal = dP / 3.0;
-(*outAux).isBlank = mN;
-return vec4f(vl, alpha);
+(*outAux).albedo = dw / 3.0;
+(*outAux).normal = dz / 3.0;
+(*outAux).isBlank = mz;
+return vec4f(vu, alpha);
 }
 else {
-return iU(uv, &si, ray, &ma, outAux);
+return iC(uv, &si, ray, &ma, outAux);
 }
 }
 `}
 
-fn kN(ip: vec2f) -> vec2f {
+fn kq(ip: vec2f) -> vec2f {
 let p = 2.0 * ip - 1.0;
 let greater = abs(p.x) > abs(p.y);
 let r = select(p.y, p.x, greater);
@@ -1028,7 +953,7 @@ return r * vec2f(cos(theta), sin(theta));
 }
 
 
-@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+@compute @workgroup_size(${workgroupSize}, ${workgroupSize}, 1)
 fn main(@builtin(global_invocation_id) globalId: vec3u) {
 let outputSize = rtUniform.outputSize;
 let scaleOffset = rtUniform.scaleOffset;
@@ -1058,24 +983,24 @@ return;
 
 let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;
 
-aZ = coord;
-aQ = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
-bT = 0u; cP = 0u;
+aI = coord;
+aC = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
+samplingBounce = 0u; ca = 0u;
 if (${inputHooks?.uniformJitter ? 'false' : 'SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1'}) {
-jitter = (dZ(CAMERA_PIXEL) - 0.5) / outputSize;
+jitter = (sample2D(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-gW(coord, i32(aQ ^ dG(rtUniform.sequenceSeed)));
-var cam = fj(uv + jitter);
+fi(coord, i32(aC ^ cB(rtUniform.sequenceSeed)));
+var cam = eT(uv + jitter);
 
 if (cameraUniform.apertureRadius > 0.0) {
 
 let eye = cameraUniform.viewInv[3].xyz;
 let forward = -normalize(cameraUniform.viewInv[2].xyz);
-let jN = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));
-let sK = cameraUniform.apertureRadius * kN(dZ(CAMERA_LENS));
-let origin = (cameraUniform.viewInv * vec4f(sK, 0.0, 1.0)).xyz;
-let dir = normalize(jN - origin);
-gC(&cam, origin, dir);
+let ju = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));
+let sH = cameraUniform.apertureRadius * kq(sample2D(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(sH, 0.0, 1.0)).xyz;
+let dir = normalize(ju - origin);
+initRay(&cam, origin, dir);
 }
 
 var outAux: RayTraceAuxiliary;
@@ -1083,39 +1008,40 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-${pathDiagnostic ? '  mtPathBegin(coord);\n' : ''}${inputHooks?.begin ?? ''}  var aW = iu(uv + jitter, cam, &outAux);
+${pathDiagnostic ? '  mtPathBegin(coord);\n' : ''}${inputHooks?.begin ?? ''}  var liAndAlpha = hR(uv + jitter, cam, &outAux);
 ${inputHooks?.unclampedColor ?? ''}
-
+${(enabled || lightTracing || photonMapping) && debugGroup >= 0 ? /* wgsl */ `  liAndAlpha=${debugGroup >= 50 ? `vec4f(photonQueryStats,1.0)` : debugGroup >= 30 ? `vec4f(causticHot[${debugGroup - 30}],1.0)` : research?.debugOutput ?? 'liAndAlpha'};
+` : ''}  
 
 if (rtUniform.clamping > 0.0) {
 let clamping = rtUniform.clamping;
-aW = vec4(clamp(aW.rgb, -vec3f(clamping), vec3f(clamping)), aW.a);
+liAndAlpha = vec4(clamp(liAndAlpha.rgb, -vec3f(clamping), vec3f(clamping)), liAndAlpha.a);
 }
-if (!(aW.x < INF && aW.x > -EPS)) {
-aW = vec4f(0.0, 0.0, 0.0, 1.0);
+if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {
+liAndAlpha = vec4f(0.0, 0.0, 0.0, 1.0);
 }
 
 if (outAux.isShadowCatcher) {
 
 
-let bc = hX(cam);
-let rh = select(0.0, 1.0, bc.a >= 0.01);
-let jW = vec4f(bc.rgb * bc.a, bc.a);
+let aW = ft(cam);
+let qX = select(0.0, 1.0, aW.a >= 0.01);
+let jC = vec4f(aW.rgb * aW.a, aW.a);
 
 
 
-outShadowCatcher[idx].mask += vec4f(1.0, bc.a, rh, 0.0);
+outShadowCatcher[idx].mask += vec4f(1.0, aW.a, qX, 0.0);
 outShadowCatcher[idx].moments += vec4f(0.0, 0.0, outAux.shadowCounts);
-outShadowCatcher[idx].background += jW;
-outColor[idx] += jW;
-outAlbedo[idx] += vec4f(outAux.albedo, rh);
-ie(idx, bc.rgb, outAux.normal);
+outShadowCatcher[idx].background += jC;
+outColor[idx] += jC;
+outAlbedo[idx] += vec4f(outAux.albedo, qX);
+hH(idx, aW.rgb, outAux.normal);
 
 
 let counts = outAux.shadowCounts;
 let visibility = 1.0 - select(0.0, counts.x / counts.y, counts.y > 0.0);
-ji(idx, visibility * select(
-1.0, dot(bc.rgb, luminance), bc.a >= 0.01
+iP(idx, visibility * select(
+1.0, dot(aW.rgb, luminance), aW.a >= 0.01
 ));
 }
 else {
@@ -1125,13 +1051,13 @@ if (HAS_SHADOW_CATCHER && outAux.isBlank && USE_BACKGROUND && !USE_BACKGROUND_MA
 
 
 
-outShadowCatcher[idx].background += aW;
-outShadowCatcher[idx].mask.g += aW.a;
+outShadowCatcher[idx].background += liAndAlpha;
+outShadowCatcher[idx].mask.g += liAndAlpha.a;
 }
-outColor[idx] += aW;
+outColor[idx] += liAndAlpha;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-ie(idx, aW.rgb, outAux.normal);
-ji(idx, dot(aW.rgb, luminance));
+hH(idx, liAndAlpha.rgb, outAux.normal);
+iP(idx, dot(liAndAlpha.rgb, luminance));
 }
 ${pathDiagnostic ? '  mtPathEnd(outAux.normal, outAux.albedo);\n' : ''}${inputHooks?.end ?? ''}}
 `;