@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -1,7 +1,13 @@
-import { MAX_PATH_EVENTS } from '../pathLimits.js';
+import { spectralPrefixWgsl, prefixCheckpoint, prefixSave, prefixRestore, prefixRandomBindings } from './chunks/spectralPrefix.wgsl.js';
+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_WEBGL } from '../pathLimits.js';
 import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
 import reflectanceWGSL from './aovReflectance.wgsl.js';
 import aovTraceWGSL from './aovTrace.wgsl.js';
+import aovTraceDisplayWGSL from './aovTraceDisplay.wgsl.js';
 import depthQueryWGSL from './depthQuery.wgsl.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
 // (https://github.com/hoverinc/ray-tracing-renderer).
@@ -18,15 +24,35 @@ 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 maxPathEvents = options.maxPathEvents ?? MAX_PATH_EVENTS_WEBGL;
+    const research = researchTransport()?.compute(options);
+    const enabled = research?.enabled ?? false;
+    const partitionDepth = research?.maxDepth ?? 20;
+    const debugGroup = research?.debugGroup ?? options.debugGroup ?? -1;
+    let { compactVertices = false, 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;
+    // MNEE can refract a wavelength-dependent connection at an ordinary receiver,
+    // before the camera path reaches any Cauchy boundary. Preserve its independent
+    // wavelength paths until a connection-solver checkpoint is available.
+    const sharePrefix = options.shareSpectralPrefix ?? false;
+    const surfacePrefix = {
+        path: ['Path', 'path'], si: ['SurfaceInteraction', '*si'], ma: ['OpenPbrResolvedMaterial', '*ma'],
+        aux: ['RayTraceAuxiliary', '*outAux'], depth: ['i32', 'depth'], event: ['i32', 'event'],
+        ignored: ['bool', 'sampleIgnored'], opaque: ['bool', 'isNotTransparent'], ...prefixRandomBindings
+    };
+    const flatPrefix = {
+        ...surfacePrefix, si: ['SurfaceInteraction', 'si'], ma: ['OpenPbrResolvedMaterial', 'ma'],
+        aux: ['RayTraceAuxiliary', 'wavelengthAux']
+    };
     const primaryVariables = /* wgsl */ `
 var si: SurfaceInteraction;
 var ma: OpenPbrResolvedMaterial;
@@ -44,10 +70,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 +81,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 = kB(si, ma.bevel);
 }
 }
 
@@ -83,71 +109,77 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 
 ${commonWgsl}
 
-${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities })}
+${rayTraceCoreWgsl({ independentTextures: options.independentTextures, compactVertices, cameraProjectionInverse: options.cameraProjectionInverse, hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities, caustics: enabled || lightTracing || photonMapping })}
 
 ${uvProjectionWgsl}
 
-${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals,
+${createMaterialBufferWgsl({ independentTextures: options.independentTextures, hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals,
+        caustics: enabled || lightTracing || photonMapping,
         hasTransmission: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.transmission) !== 0,
         hasMetalness: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.metal) !== 0 })}
 
-${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals, sceneIntersections })}
+${createIntersectionWgsl({ compactVertices, perInstanceBounds: options.perInstanceBounds, hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals, sceneIntersections })}
 ${randWgsl}
 ${randomWgsl}
 ${envMapWgsl}
 
 ${samplingWgsl}
+${spectrumWgsl}
 ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}${inputHooks?.declarations ?? ''}
 
 
-var<private> vg: u32 = 0u;
+var<private> bounceIndex: u32 = 0u;
 
 
 
-fn kB() -> u32 {
+fn kL() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn qx(ys: u32) -> f32 {
+fn rA(AT: 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 kT = aJ.x + aJ.y * u32(rtUniform.outputSize.x);
+let key = ak(ak(kT, aC), rtUniform.sequenceSeed);
+let dimension = ak(samplingBounce, AT) ^ 0xa511e9b3u;
+return f32(cD(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
 }
 
 
 
-fn uS(fA: f32, scatteringPdf: f32) -> f32 {
-let candidateCount = kB();
+fn wM(lightPdf: f32, scatteringPdf: f32) -> f32 {
+let candidateCount = kL();
 if (candidateCount <= 1u) {
-return aK(fA, scatteringPdf);
+return aG(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 gm(scatteringPdf: f32, lightPdf: f32) -> f32 {
+let candidateCount = kL();
 if (candidateCount <= 1u) {
-return aK(scatteringPdf, fA);
+return aG(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, options.channelIndependentRis)}
 ${sampleShadowCatcherWgsl}
 
 
@@ -159,24 +191,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn ie(
-gv: u32,
+fn ij(
+gx: 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[gx] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[gv] += vec4f(normal, 1.0);
+outNormal[gx] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn ji(gv: u32, value: f32) {
-outShadowCatcher[gv].moments += vec4f(value, value * value, 0.0, 0.0);
+fn ju(gx: u32, value: f32) {
+outShadowCatcher[gx].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -190,123 +222,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 cS(ray: Ray, channel: i32) -> vec4f {
+let bg = fI(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 mD(uv: vec2f, path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, fg: ptr<function, bool>) {
+*fg = 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 +246,37 @@ else {
 
 
 if (USE_ENVMAP) {
-if ((*aa).isNextRefraction) {
+if ((*path).isNextRefraction) {
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cS(
+(*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 cP = select(gm((*path).scatteringPdf,
+envMapPdf(cU((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cP * (*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 xp = cU((*path).ray.d);
+var emission = textureLinear(envMap, xp).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 *
+gm((*path).scatteringPdf, envMapPdf(xp));
 }
 }
 else {
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cS(
+(*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 +284,40 @@ if (!(*si).hit) {
 
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cS(
+(*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 = cV(uv);
+let ou = dot(cam.d, (*path).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (nK) {
-(*aa).alpha = max((*aa).alpha, bg.a);
+if (ou) {
+(*path).alpha = max((*path).alpha, bg.a);
 } else {
-(*aa).alpha = 1.0;
+(*path).alpha = 1.0;
 }
 }
 if (!USE_ENVMAP) {
 
 
-if (nK) {
+if (ou) {
 
 
-(*aa).li += (*aa).beta *
-gj((*aa).scatteringPdf, 1.0) * bg.rgb;
+(*path).li += (*path).beta *
+gm((*path).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
-(*aa).abort = true;
+(*path).abort = true;
 return;
 }
 
@@ -396,28 +328,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 || cm(3u) > alpha) {
+(*fg) = true;
 }
 }
-if (!(*fm) && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (!(*fg) && 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 (!(*fg)) {
+bounceIndex = u32(max(*depth, 0));
+nB(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 && !(*fg)) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -442,34 +374,34 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !(*fm)) {
-let pG = (*aa).beta;
+if (*depth >= select(2, RR_MAX, (*path).scatteringMediumEntered) && !(*fg)) {
+let qv = (*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 ql = max(max(qv.x, qv.y), qv.z);
+let q: f32 = max(0.0, 1.0 - ql);
+if (sample1D(aX(RUSSIAN_ROULETTE)) < q) {
 
 
-(*aa).alpha = 1.0;
-(*aa).abort = true;
+(*path).alpha = 1.0;
+(*path).abort = true;
 }
 else {
-(*aa).beta /= 1.0 - q;
+(*path).beta /= 1.0 - q;
 }
 }
 }
-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 gN(path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, sampleIgnored: bool) {
 if (SPECTRAL) {
 
 if ((*ma).transmissionWeight > 0.001) {
-(*ma).specularIor = ee(
+(*ma).specularIor = sampling_cauchy_ior(
 (*si).wavelength,
 (*ma).specularIor,
 (*ma).transmissionDispersionScale,
@@ -478,304 +410,329 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (aJ) {
+if (sampleIgnored) {
 return;
 }
 
 
 var lightSample: LightSampleRec;
-let hM = eC(3u) < (*ma).alpha;
+let hN = cm(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 = iB((*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 mz = (*si).hit && d > distance((*si).position, (*path).ray.o);
+if (d != INF && !(mz && hN)) {
+let misWeight = gm((*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 && hN)) {${lightTracing || photonMapping ? /* wgsl */ `
+if(causticHitOwned(*path,false,true)){(*path).abort=true;return;}` : ''}
+if ((*path).isNextRefraction) {
 
 
 
-let bg = di(
-(*aa).ray,
-(*si).wavelength
+let bg = cS(
+(*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 cP = select(gm((*path).scatteringPdf,
+envMapPdf(cU((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cP * (*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 = cU((*path).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let fl = gj(
-(*aa).scatteringPdf,
-iT(_uv) * rtUniform.envLightPmf
+let misWeight = gm(
+(*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 {
+${options.cameraProjectionInverse ? /* wgsl */ `
+fn cV(coord: vec2f) -> Ray {
+
+
+let origin = cameraUniform.projectionInv * vec4f(coord * 2.0 - 1.0, -1.0, 1.0);
+let center = cameraUniform.projectionInv * vec4f(coord * 2.0 - 1.0, 1.0, 1.0);
+let direction = center.xyz * origin.w - origin.xyz * center.w;
+var cam: Ray;
+initRay(&cam, (cameraUniform.viewInv * vec4f(origin.xyz / origin.w, 1.0)).xyz,
+normalize((cameraUniform.viewInv * vec4f(direction, 0.0)).xyz));
+return cam;
+}
+` : /* wgsl */ `fn cV(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 lD(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 lU = 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 nL = 20.0 * x * lU * lU * lU;
+if (abs(value) < 1e-6 || nL == 0.0) { break; }
+x = clamp(x - value / nL, 0.0, 1.0);
 }
-let jL = x * radius;
-return vec2f(jL, sqrt(max(radius * radius - jL * jL, 0.0)));
+let jW = x * radius;
+return vec2f(jW, sqrt(max(radius * radius - jW * jW, 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, gO: f32) -> f32 {
+if (gO >= radius) { return 0.0; }
+let falloff = radius - gO;
+return falloff * falloff * falloff;
 }
 
 
-fn nj(source: SurfaceInteraction, radius: f32) -> vec3f {
+fn kB(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 jd = vec3f(0.0);
+
+for (var iN = 0; iN < BEVEL_SAMPLES; iN++) {
+let rh = sample2D(CAMERA_BEVEL_BASE + u32(iN));
+var cu = rh.x;
+let qt = rh.y;
+var dc = geometricNormal;
+var fU = tangent;
+var eo = bitangent;
+var gw = 0.5;
+var iH = 0.25;
+var gV = 0.25;
+if (cu < 0.5) {
+cu *= 2.0;
+}
+else if (cu < 0.75) {
+let os = dc;
+dc = fU;
+fU = os;
+gw = 0.25;
+iH = 0.5;
+cu = (cu - 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 os = dc;
+dc = eo;
+eo = os;
+gw = 0.25;
+gV = 0.5;
+cu = (cu - 0.75) * 4.0;
+}
+
+let hm = lD(radius, qt);
+let phi = TWOPI * cu;
+let sI = hm.x *
+(cos(phi) * fU + sin(phi) * eo);
 var ray: Ray;
-gC(
+initRay(
 &ray,
-source.position + dz * hj.y + rw,
--dz
+source.position + dc * hm.y + sI,
+-dc
 );
 var hit: SurfaceInteraction;
 intersectSceneBevel(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * hj.y, EPS)
+max(2.0 * hm.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 lV = gw * abs(dot(dc, hit.faceNormal));
+let oi = iH * abs(dot(fU, hit.faceNormal));
+let kR = gV * abs(dot(eo, hit.faceNormal));
+var weight = lV / max(
+lV * lV + oi * oi +
+kR * kR,
 1e-8
 );
-weight *= jj(radius, distance(hit.position, source.position)) /
-max(jj(radius, hj.x), 1e-8);
-iW += weight * hit.vertexNormal;
+weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
+max(bevelCubicPdf(radius, hm.x), 1e-8);
+jd += weight * hit.vertexNormal;
 }
 
-if (dot(iW, iW) <= 1e-12) { return source.normal; }
-let kg = normalize(iW);
-let result = source.normal + kg - source.vertexNormal;
+if (dot(jd, jd) <= 1e-12) { return source.normal; }
+let kt = normalize(jd);
+let result = source.normal + kt - 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;
+${sharePrefix ? spectralPrefixWgsl(!enabled) + prefixCheckpoint('spSurface', surfacePrefix) + prefixCheckpoint('spFlat', flatPrefix) : ''}fn cJ(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, initialQuery: 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 fj = min(bounceLimit * 3, ${maxPathEvents});
 var depth = 0;
-var aJ = false;
-var bQ = false;
-
+var sampleIgnored = false;
+var isNotTransparent = false;
+${sharePrefix ? /* wgsl */ `  let spSlot = qz; qz++;
+if (spActive && spChannel > 1 && eB[spSlot].ready) { return rN(spSlot, outAux); }
+var spEvent = 0; var spResume = false;
+if (spActive && spChannel > 1 && fC == spSlot) {
+var event = 0;
+${prefixRestore('spSurface', surfacePrefix)}
+spEvent = event; spResume = true; qA(&path, si);
+} else if (sd) { (*si).spectralChannel = select(spChannel, 0, spActive); (*si).wavelength = lg; }
+` : ''}  
 
 
 
-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 = ${sharePrefix ? 'spEvent' : '0'}; event <= fj; event++) {
+if (${sharePrefix ? '!spResume && ((event != 0) | initialQuery)' : '(event != 0) | initialQuery'}) {
+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 (initialQuery & (*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);
-} else {
-kl(&aa, &depth, si, ma, aJ);
+isNotTransparent = ((*ma).transmissionWeight < 0.001) & ((*ma).subsurfaceWeight < 0.001) & ((*ma).alpha > 0.99);
+} else {${sharePrefix ? /* wgsl */ `
+if (spActive && (*ma).transmissionWeight > 0.001 && gf(*ma)) {
+${prefixSave('spSurface', surfacePrefix)}
+fC = spSlot; qA(&path, si);
+}` : ''}
+gN(&path, &depth, si, ma, sampleIgnored);
 }
-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; }
+${sharePrefix ? '    spResume = false;\n' : ''}    if (isNotTransparent & (event > bounceLimit)) { path.abort = true; }
+if (path.abort | (event >= fj)) { break; }
+mD(uv, &path, &depth, si, ma, outAux, &sampleIgnored);
+if (path.abort) { break; }
 }
 
-return vec4f(aa.li, aa.alpha);
+return ${sharePrefix ? 'spFinish(spSlot, vec4f(path.li, path.alpha), *outAux)' : '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 jb(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 tr = *si;
-var tq = *ma;
-var iP = *outAux;
+var tT = ray;
+var uW = *si;
+var uV = *ma;
+var iX = *outAux;
 if (split) {
-sB.o = (*si).position + ray.d * (EPS * 0.02);
-tr.albedoSampled = false;
+tT.o = (*si).position + ray.d * (EPS * 0.02);
+uW.albedoSampled = false;
 }
 var back: vec4f;
-var ez: RayTraceAuxiliary;
+var backAux: 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;
-tr = *si; tq = *ma; tq.alpha = 1.0;
-sB = ray; iP = *outAux;
+let xh = select(1u, rtUniform.loopUnrollGuard >> 1u, split & (coverage > 0.0));
+for (var wv = 0u; wv < xh; wv++) {
+let result = cJ(uv, &uW, tT, &uV, &iX, split & (wv == 0u));
+if (!split | (coverage <= 0.0)) { *outAux = iX; return result; }
+if (wv == 0u) {
+back = result; backAux = iX;
+uW = *si; uV = *ma; uV.alpha = 1.0;
+tT = ray; iX = *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(backAux.albedo, iX.albedo, coverage);
+let aS = mix(backAux.normal, iX.normal, coverage);
+(*outAux).normal = select(vec3f(0.0), normalize(aS), dot(aS, aS) > 1e-12);
+(*outAux).isBlank = backAux.isBlank & iX.isBlank;
+(*outAux).isShadowCatcher = backAux.isShadowCatcher & iX.isShadowCatcher;
+(*outAux).shadowCounts = mix(backAux.shadowCounts, iX.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 cJ(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 hq(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
-var oI: SurfaceInteraction;
-var oH: OpenPbrResolvedMaterial;
-var ue: RayTraceAuxiliary;
-var iY = false;
+var primarySi: SurfaceInteraction;
+var primaryMa: OpenPbrResolvedMaterial;
+var vR: RayTraceAuxiliary;
+var jg = 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 backAux: 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});
-var event = 0; var depth = 0; var aJ = false;
-var bQ = false;
+let fj = min(bounceLimit * 3, ${maxPathEvents});
+var event = 0; var depth = 0; var sampleIgnored = false;
+var isNotTransparent = false;
 
 
-for (var step = 0; step < (${MAX_PATH_EVENTS} + 1) * 2 + 2; step++) {
+for (var step = 0; step < (${maxPathEvents} + 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 (!jg) {
 ${primaryGuides}
-oI = si; oH = ma; ue = *outAux;
-iY = true;
+primarySi = si; primaryMa = ma; vR = *outAux;
+jg = 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 +745,170 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 }
 }
 if (event == 0) {
-bQ = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
+isNotTransparent = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
 } else {
-kl(&aa, &depth, &si, &ma, aJ);
+gN(&path, &depth, &si, &ma, sampleIgnored);
 }
-if (bQ & (event > bounceLimit)) { aa.abort = true; }
-if (!aa.abort & (event < ft)) {
-nY(uv, &aa, &depth, &si, &ma, outAux, &aJ);
+if (isNotTransparent & (event > bounceLimit)) { path.abort = true; }
+if (!path.abort & (event < fj)) {
+mD(uv, &path, &depth, &si, &ma, outAux, &sampleIgnored);
 }
-if (aa.abort | (event >= ft)) {
-let result = vec4f(aa.li, aa.alpha);
+if (path.abort | (event >= fj)) {
+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(backAux.albedo, (*outAux).albedo, coverage);
+let aS = mix(backAux.normal, (*outAux).normal, coverage);
+(*outAux).normal = select(vec3f(0.0), normalize(aS), dot(aS, aS) > 1e-12);
+(*outAux).isBlank = backAux.isBlank & (*outAux).isBlank;
+(*outAux).isShadowCatcher = backAux.isShadowCatcher & (*outAux).isShadowCatcher;
+(*outAux).shadowCounts = mix(backAux.shadowCounts, (*outAux).shadowCounts, coverage);
 return mix(back, result, coverage);
 }
-back = result; ez = *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);
+back = result; backAux = *outAux;
+front = true; query = false; event = 0; depth = 0; sampleIgnored = false;
+si = primarySi; ma = primaryMa; ma.alpha = 1.0; *outAux = vR;
+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 hq(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 fj = min(bounceLimit * 3, ${maxPathEvents});
+var isNotTransparent = false;
 var depth = 0;
-var aJ = false;
+var sampleIgnored = 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 <= fj; 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;
+isNotTransparent = ma.transmissionWeight < 0.001 && ma.subsurfaceWeight < 0.001 && ma.alpha > 0.99;
 } else {
-kl(&aa, &depth, &si, &ma, aJ);
+gN(&path, &depth, &si, &ma, sampleIgnored);
 }
-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 (isNotTransparent && event > bounceLimit) { path.abort = true; }
+if (path.abort || event >= fj) { break; }
+mD(uv, &path, &depth, &si, &ma, outAux, &sampleIgnored);
+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 hq(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 primarySi: SurfaceInteraction;
+var primaryMa: OpenPbrResolvedMaterial;
+var jg = false;
+var path: Path; path.ray = ray;
 let bounceLimit = max(rtUniform.bounces, 0);
-let ft = 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);
+let fj = min(bounceLimit * 3, ${maxPathEvents});
+var depth = 0; var event = 0; var sampleIgnored = false;
+var isNotTransparent = false;
+var jR = 0;
+let bj = rtUniform.dispersionWavelengths == 1;
+var eG = false;
+var eQ = 0;
+var aE = 0.0;
+var wavelengthRngState: vec4u;
+var eH = 0u;
+var wavelengthAux: RayTraceAuxiliary;
 var color = vec3f(0.0); var alpha = 0.0;
-var dO = vec3f(0.0);
-var dP = vec3f(0.0);
-var mN = true;
+var dD = vec3f(0.0);
+var dE = vec3f(0.0);
+var ik = 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 zh = min((${maxPathEvents} + 1) * 3, i32(rtUniform.loopUnrollGuard * ${Math.ceil((maxPathEvents + 1) * 3 / 4)}u));
+for (var step = 0; step < zh; step++) {
+if (!jg | ((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 (!jg) {
 ${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,
+primarySi = si; primaryMa = ma; jg = true;
+eG = si.hit & (ma.transmissionWeight > 0.001) & (ma.transmissionDispersionScale > 0.001);
+aE = sample1D(CAMERA_WAVELENGTH);
+if (bj) {
+eQ = min(i32(floor(aE * 3.0)), 2);
+aE = fract(aE * 3.0);
+}
+wavelengthRngState = s0; eH = hashedCounter;
+}
+si = primarySi; ma = primaryMa; wavelengthAux = *outAux;
+if (!bj) {
+s0 = wavelengthRngState; hashedCounter = eH; samplingBounce = 0u;
+wavelengthAux.isBlank = false; wavelengthAux.isShadowCatcher = false;
+}
+si.wavelength = 0.0; si.spectralChannel = 0;
+if (!bj | eG) {
+let channel = select(jR, eQ, bj);
+si.spectralChannel = channel + 1;
+si.wavelength = ce(u32(channel), aE);
+${sharePrefix ? /* wgsl */ `        wY(channel + 1, si.wavelength, gf(ma));
+if (spActive) { si.spectralChannel = 0; }
+` : ''}        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);
-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);
+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; sampleIgnored = false;
+isNotTransparent = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
+${sharePrefix ? /* wgsl */ `      if (spActive && jR > 0 && fC == 0) {
+${prefixRestore('spFlat', flatPrefix)}
+qA(&path, &si);
+}
+}
+if (event > 0 && !path.abort) {
+if (spActive && ma.transmissionWeight > 0.001 && gf(ma)) {
+${prefixSave('spFlat', flatPrefix)}
+fC = 0; qA(&path, &si);
+}
+gN(&path, &depth, &si, &ma, sampleIgnored);
+}` : /* wgsl */ `    } else if (!path.abort) {
+gN(&path, &depth, &si, &ma, sampleIgnored);
+}`}
+if (isNotTransparent & (event > bounceLimit)) { path.abort = true; }
+if (!path.abort & (event < fj)) {
+mD(uv, &path, &depth, &si, &ma, &wavelengthAux, &sampleIgnored);
+}
+if (path.abort | (event >= fj)) {
+let result = vec4f(path.li, path.alpha);
+if (bj) {
+*outAux = wavelengthAux;
+let scale = select(1.0, 3.0, eG);
 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;
+${sharePrefix ? /* wgsl */ `      if (spActive) {
+(*outAux).isBlank = wavelengthAux.isBlank;
+
+(*outAux).albedo = (wavelengthAux.albedo + wavelengthAux.albedo + wavelengthAux.albedo) / 3.0;
+(*outAux).normal = (wavelengthAux.normal + wavelengthAux.normal + wavelengthAux.normal) / 3.0;
+return result;
+}
+` : ''}      color += result.rgb; alpha = max(alpha, result.a);
+dD += wavelengthAux.albedo;
+dE += wavelengthAux.normal;
+ik = ik & wavelengthAux.isBlank;
+jR++;
+if (jR >= 3) {
+(*outAux).albedo = dD / 3.0;
+(*outAux).normal = dE / 3.0;
+(*outAux).isBlank = ik;
 return vec4f(color, alpha);
 }
 event = 0;
@@ -935,91 +916,97 @@ event = 0;
 }
 return vec4f(0.0);
 }
-` : /* wgsl */ `fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+` : /* wgsl */ `fn hq(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 xl = vec3f(0.0);
 var alpha = 0.0;
-var dO = vec3f(0.0);
-var dP = vec3f(0.0);
-var mN = true;
+var dD = vec3f(0.0);
+var dE = vec3f(0.0);
+var ik = true;
 var si2 = si;
 var ma2 = ma;
-let hz = s0;
-let eO = cP;
-let bo = rtUniform.dispersionWavelengths == 1;
-let df = si.hit &&
+var aE = sample1D(CAMERA_WAVELENGTH);
+let wavelengthRngState = s0;
+let eH = hashedCounter;
+let bj = rtUniform.dispersionWavelengths == 1;
+let eG = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let tm = select(3, 1, bo);
-var eX = 0;
-if (bo && df) {
+let uR = select(3, 1, bj);
+var eQ = 0;
+if (bj) {
 
 
-eX = min(i32(floor(dp(CAMERA_WAVELENGTH) * 3.0)), 2);
+eQ = min(i32(floor(aE * 3.0)), 2);
+aE = fract(aE * 3.0);
 }
-for (var i = 0; i < tm; i++) {
+for (var i = 0; i < uR; i++) {
 
 
 
-if (!bo) {
-s0 = hz;
-cP = eO;
-bT = 0u;
+if (!bj) {
+s0 = wavelengthRngState;
+hashedCounter = eH;
+samplingBounce = 0u;
 }
 si.wavelength = 0.0;
-if (!bo || df) {
-si.wavelength = ug[select(i, eX, bo)];
-ma.specularIor = ee(
+si.spectralChannel = 0;
+if (!bj || eG) {
+let channel = select(i, eQ, bj);
+si.spectralChannel = channel + 1;
+si.wavelength = ce(u32(channel), aE);
+${sharePrefix ? /* wgsl */ `          wY(channel + 1, si.wavelength, gf(ma));
+if (spActive) { si.spectralChannel = 0; }
+` : ''}          ma.specularIor = sampling_cauchy_ior(
 si.wavelength,
 ma.specularIor,
 ma.transmissionDispersionScale,
 ma.dispersionAbbeNumber
 );
 }
-var ba: RayTraceAuxiliary;
-if (bo) {
-ba = *outAux;
+var wavelengthAux: RayTraceAuxiliary;
+if (bj) {
+wavelengthAux = *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);
+wavelengthAux.albedo = (*outAux).albedo;
+wavelengthAux.normal = (*outAux).normal;
+wavelengthAux.isBlank = false;
+wavelengthAux.isShadowCatcher = false;
+}
+let res = jb(uv, &si, ray, &ma, &wavelengthAux);
+if (bj) {
+*outAux = wavelengthAux;
+let scale = select(1.0, 3.0, eG);
 return vec4f(res.rgb * scale, res.a);
 }
-vl += res.rgb;
+xl += res.rgb;
 alpha = max(alpha, res.a);
-dO += ba.albedo;
-dP += ba.normal;
-mN = mN && ba.isBlank;
+dD += wavelengthAux.albedo;
+dE += wavelengthAux.normal;
+ik = ik && wavelengthAux.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = dO / 3.0;
-(*outAux).normal = dP / 3.0;
-(*outAux).isBlank = mN;
-return vec4f(vl, alpha);
+(*outAux).albedo = dD / 3.0;
+(*outAux).normal = dE / 3.0;
+(*outAux).isBlank = ik;
+return vec4f(xl, alpha);
 }
 else {
-return iU(uv, &si, ray, &ma, outAux);
+return jb(uv, &si, ray, &ma, outAux);
 }
 }
 `}
 
-fn kN(ip: vec2f) -> vec2f {
+fn kX(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 +1015,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 +1045,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;
+aJ = coord;
+aC = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
+samplingBounce = 0u; hashedCounter = 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);
+fA(coord, i32(aC ^ cD(rtUniform.sequenceSeed)));
+var cam = cV(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 jY = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));
+let uh = cameraUniform.apertureRadius * kX(sample2D(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(uh, 0.0, 1.0)).xyz;
+let dir = normalize(jY - origin);
+initRay(&cam, origin, dir);
 }
 
 var outAux: RayTraceAuxiliary;
@@ -1083,39 +1070,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 = hq(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 = fI(cam);
+let sn = select(0.0, 1.0, aW.a >= 0.01);
+let kg = 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, sn, 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 += kg;
+outColor[idx] += kg;
+outAlbedo[idx] += vec4f(outAux.albedo, sn);
+ij(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
+ju(idx, visibility * select(
+1.0, dot(aW.rgb, luminance), aW.a >= 0.01
 ));
 }
 else {
@@ -1125,13 +1113,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));
+ij(idx, liAndAlpha.rgb, outAux.normal);
+ju(idx, dot(liAndAlpha.rgb, luminance));
 }
 ${pathDiagnostic ? '  mtPathEnd(outAux.normal, outAux.albedo);\n' : ''}${inputHooks?.end ?? ''}}
 `;
@@ -1139,7 +1127,7 @@ ${pathDiagnostic ? '  mtPathEnd(outAux.normal, outAux.albedo);\n' : ''}${inputHo
     // It has no effect on the beauty entry point or its bindings.
     // Gate optional material layers on scene-level feature flags so drivers can
     // skip the unused BSDF lobes.
-    let specializedSource = source + depthQueryWGSL + reflectanceWGSL + aovTraceWGSL;
+    let specializedSource = source + depthQueryWGSL + reflectanceWGSL + (options.displayAovStorage ? aovTraceDisplayWGSL : aovTraceWGSL);
     const backgroundBits = {
         USE_BACKGROUND: 1,
         USE_BACKGROUND_MAP: 2,