@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -1,11 +1,13 @@
+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 } from '../pathLimits.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).
@@ -29,14 +31,28 @@ import uvProjectionWgsl from './chunks/uvProjection.wgsl.js';
 export const WORKGROUP_SIZE = 8;
 /** Generates the WebGPU megakernel path tracing compute shader. */
 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 { 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;
+    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;
@@ -65,7 +81,7 @@ return vec4f(1.0);
 else {
 if (HAS_BEVEL && rtUniform.bevel != 0) {
 if (ma.bevel > 0.0) {
-si.normal = mT(si, ma.bevel);
+si.normal = kB(si, ma.bevel);
 }
 }
 
@@ -93,16 +109,16 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 
 ${commonWgsl}
 
-${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities, caustics: enabled || lightTracing || photonMapping })}
+${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}
@@ -113,35 +129,35 @@ ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}${inputHooks?.declarations ?? ''}
 
 
-var<private> vp: u32 = 0u;
+var<private> bounceIndex: u32 = 0u;
 
 
 
-fn ke() -> u32 {
+fn kL() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn qp(yQ: u32) -> f32 {
+fn rA(AT: u32) -> f32 {
 
 
 
 
 if (SAMPLING_PATTERN == 2) { _ = rand(); }
-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);
+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 uY(lightPdf: f32, scatteringPdf: f32) -> f32 {
-let candidateCount = ke();
+fn wM(lightPdf: f32, scatteringPdf: f32) -> f32 {
+let candidateCount = kL();
 if (candidateCount <= 1u) {
-return aF(lightPdf, scatteringPdf);
+return aG(lightPdf, scatteringPdf);
 }
 let weightedLightPdf = f32(candidateCount) * lightPdf;
 return weightedLightPdf /
@@ -149,10 +165,10 @@ max(weightedLightPdf + scatteringPdf, 1e-20);
 }
 
 
-fn fV(scatteringPdf: f32, lightPdf: f32) -> f32 {
-let candidateCount = ke();
+fn gm(scatteringPdf: f32, lightPdf: f32) -> f32 {
+let candidateCount = kL();
 if (candidateCount <= 1u) {
-return aF(scatteringPdf, lightPdf);
+return aG(scatteringPdf, lightPdf);
 }
 let weightedLightPdf = f32(candidateCount) * lightPdf;
 return scatteringPdf /
@@ -163,7 +179,7 @@ ${enabled || lightTracing || photonMapping ? causticPartitionWGSL(enabled, light
 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)}
+` + photonQuerySource(debugGroup, !lightTracing && (options.photonDirectSubset ?? true)) : ''}${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals, enabled || lightTracing || photonMapping, research?.contribution, photonMapping, options.channelIndependentRis)}
 ${sampleShadowCatcherWgsl}
 
 
@@ -175,24 +191,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn hH(
-gf: u32,
+fn ij(
+gx: u32,
 radiance: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
 let value = dot(radiance, luminance);
-outNormal[gf] += vec4f(value * value, 0.0, 0.0, 1.0);
+outNormal[gx] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[gf] += vec4f(normal, 1.0);
+outNormal[gx] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iP(gf: u32, value: f32) {
-outShadowCatcher[gf].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);
 }
 
 
@@ -206,8 +222,8 @@ isBlank: bool,
 shadowCounts: vec2f,
 }
 
-${backgroundWgsl}fn cP(ray: Ray, channel: i32) -> vec4f {
-let bg = ft(ray);
+${backgroundWgsl}fn cS(ray: Ray, channel: i32) -> vec4f {
+let bg = fI(ray);
 if (SPECTRAL) {
 return vec4f(sampling_spectral_rgb_filter(bg.rgb, channel), bg.a);
 }
@@ -216,8 +232,8 @@ return bg;
 
 
 
-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;
+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`};
@@ -233,28 +249,28 @@ if (USE_ENVMAP) {
 if ((*path).isNextRefraction) {
 
 
-let bg = cP(
+let bg = cS(
 (*path).ray,
 (*si).spectralChannel
 );
-let cM = select(fV((*path).scatteringPdf,
-envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+let cP = select(gm((*path).scatteringPdf,
+envMapPdf(cU((*path).ray.d)) * rtUniform.envLightPmf),
 1.0, (*path).scatteringIsDelta);
-(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).li += cP * (*path).beta * bg.rgb * bg.a;
 (*path).alpha = max((*path).alpha, bg.a);
 }
 else {
-let vC = cT((*path).ray.d);
-var emission = textureLinear(envMap, vC).rgb;
+let xp = cU((*path).ray.d);
+var emission = textureLinear(envMap, xp).rgb;
 if (SPECTRAL) {
 emission = sampling_spectral_rgb_filter(emission, (*si).spectralChannel);
 }
 (*path).li += (*path).beta * emission *
-fV((*path).scatteringPdf, envMapPdf(vC));
+gm((*path).scatteringPdf, envMapPdf(xp));
 }
 }
 else {
-let bg = cP(
+let bg = cS(
 (*path).ray,
 (*si).spectralChannel
 );
@@ -268,7 +284,7 @@ if (!(*si).hit) {
 
 
 
-let bg = cP(
+let bg = cS(
 (*path).ray,
 (*si).spectralChannel
 );
@@ -281,10 +297,10 @@ if ((*path).fromEye) {
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = eT(uv);
-let nt = dot(cam.d, (*path).ray.d) > 0.0;
+let cam = cV(uv);
+let ou = dot(cam.d, (*path).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (nt) {
+if (ou) {
 (*path).alpha = max((*path).alpha, bg.a);
 } else {
 (*path).alpha = 1.0;
@@ -293,11 +309,11 @@ if (nt) {
 if (!USE_ENVMAP) {
 
 
-if (nt) {
+if (ou) {
 
 
 (*path).li += (*path).beta *
-fV((*path).scatteringPdf, 1.0) * bg.rgb;
+gm((*path).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
@@ -312,19 +328,19 @@ let alpha = clamp((*ma).alpha, 0.0, 1.0);
 if (alpha < 1.0) {
 
 
-if (alpha <= 0.0 || ek(3u) > alpha) {
-(*eV) = true;
+if (alpha <= 0.0 || cm(3u) > alpha) {
+(*fg) = true;
 }
 }
-if (!(*eV) && 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)));
 (*path).alpha = max(outputAlpha, (*path).alpha);
 }
-if (!(*eV)) {
-vp = u32(max(*depth, 0));
-mx(si, ma, path);
+if (!(*fg)) {
+bounceIndex = u32(max(*depth, 0));
+nB(si, ma, path);
 }
 else {
 
@@ -333,7 +349,7 @@ else {
 }
 }
 
-if (!(*si).albedoSampled && !(*eV)) {
+if (!(*si).albedoSampled && !(*fg)) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -358,12 +374,12 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !(*eV)) {
-let pl = (*path).beta;
+if (*depth >= select(2, RR_MAX, (*path).scatteringMediumEntered) && !(*fg)) {
+let qv = (*path).beta;
 
-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) {
+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) {
 
 
 (*path).alpha = 1.0;
@@ -381,7 +397,7 @@ return;
 
 }
 
-fn jQ(path: 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) {
@@ -394,21 +410,21 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (aJ) {
+if (sampleIgnored) {
 return;
 }
 
 
 var lightSample: LightSampleRec;
-let ht = ek(3u) < (*ma).alpha;
+let hN = cm(3u) < (*ma).alpha;
 for (var i = 0; i < rtUniform.lightsCount; i++) {
 
 let light: Light = analyticLights[i];
-let d = mX((*path).ray, light, &lightSample);
+let d = iB((*path).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let lH = (*si).hit && d > distance((*si).position, (*path).ray.o);
-if (d != INF && !(lH && ht)) {
-let misWeight = fV((*path).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 = sampling_spectral_rgb_filter(lightSample.emission, (*si).spectralChannel);
 }
@@ -419,27 +435,27 @@ ${enabled || lightTracing || photonMapping ? 'if (!causticHitOwned(*path, true,
 }
 
 if (USE_ENVMAP) {
-if (!((*si).hit && ht)) {${lightTracing || photonMapping ? /* wgsl */ `
+if (!((*si).hit && hN)) {${lightTracing || photonMapping ? /* wgsl */ `
 if(causticHitOwned(*path,false,true)){(*path).abort=true;return;}` : ''}
 if ((*path).isNextRefraction) {
 
 
 
-let bg = cP(
+let bg = cS(
 (*path).ray,
 (*si).spectralChannel
 );
-let cM = select(fV((*path).scatteringPdf,
-envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+let cP = select(gm((*path).scatteringPdf,
+envMapPdf(cU((*path).ray.d)) * rtUniform.envLightPmf),
 1.0, (*path).scatteringIsDelta);
-(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).li += cP * (*path).beta * bg.rgb * bg.a;
 (*path).alpha = max((*path).alpha, bg.a);
 (*path).abort = true;
 return;
 }
-let _uv = cT((*path).ray.d);
+let _uv = cU((*path).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let misWeight = fV(
+let misWeight = gm(
 (*path).scatteringPdf,
 envMapPdf(_uv) * rtUniform.envLightPmf
 );
@@ -458,40 +474,52 @@ if (!USE_BACKGROUND) {
 *depth = *depth + 1;
 }
 
-fn eT(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;
 initRay(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
 
 return cam;
-}
+}`}
 
 
-fn kK(radius: f32, xi: f32) -> vec2f {
+fn lD(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
 for (var iteration = 0; iteration < 10; iteration++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let la = 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 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 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 jr = x * radius;
-return vec2f(jr, sqrt(max(radius * radius - jr * jr, 0.0)));
+let jW = x * radius;
+return vec2f(jW, sqrt(max(radius * radius - jW * jW, 0.0)));
 }
 
-fn bevelCubicPdf(radius: f32, gu: f32) -> f32 {
-if (gu >= radius) { return 0.0; }
-let falloff = radius - gu;
+fn bevelCubicPdf(radius: f32, gO: f32) -> f32 {
+if (gO >= radius) { return 0.0; }
+let falloff = radius - gO;
 return falloff * falloff * falloff;
 }
 
 
-fn mT(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;
@@ -499,78 +527,78 @@ geometricNormal = -geometricNormal;
 var tangent: vec3f;
 var bitangent: vec3f;
 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;
+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 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);
+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;
 initRay(
 &ray,
-source.position + cZ * gQ.y + rr,
--cZ
+source.position + dc * hm.y + sI,
+-dc
 );
 var hit: SurfaceInteraction;
 intersectSceneBevel(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gQ.y, EPS)
+max(2.0 * hm.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-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,
+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 *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
-max(bevelCubicPdf(radius, gQ.x), 1e-8);
-iE += weight * hit.vertexNormal;
+max(bevelCubicPdf(radius, hm.x), 1e-8);
+jd += weight * hit.vertexNormal;
 }
 
-if (dot(iE, iE) <= 1e-12) { return source.normal; }
-let jM = normalize(iE);
-let result = source.normal + jM - 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 cG(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, sc: bool) -> vec4f {
+${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);
@@ -583,112 +611,124 @@ path.isNextRefraction = false;
 path.abort = false;
 
 let bounceLimit = max(rtUniform.bounces, 0);
-let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+let fj = min(bounceLimit * 3, ${maxPathEvents});
 var depth = 0;
-var aJ = false;
-var bH = 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 <= eZ; event++) {
-if ((event != 0) | sc) {
+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 (sc & (*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;
 }
-bH = ((*ma).transmissionWeight < 0.001) & ((*ma).subsurfaceWeight < 0.001) & ((*ma).alpha > 0.99);
-} else {
-jQ(&path, &depth, si, ma, aJ);
-}
-if (bH & (event > bounceLimit)) { path.abort = true; }
-if (path.abort | (event >= eZ)) { break; }
-nO(uv, &path, &depth, si, ma, outAux, &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);
+}
+${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(path.li, path.alpha);
+return ${sharePrefix ? 'spFinish(spSlot, vec4f(path.li, path.alpha), *outAux)' : 'vec4f(path.li, path.alpha)'};
 }
 
-fn iC(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 st = ray;
-var tr = *si;
-var tq = *ma;
-var iw = *outAux;
+var tT = ray;
+var uW = *si;
+var uV = *ma;
+var iX = *outAux;
 if (split) {
-st.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 eg: RayTraceAuxiliary;
+var backAux: RayTraceAuxiliary;
 
 
-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;
-st = ray; iw = *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(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);
+(*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 cG(uv, si, ray, ma, outAux, false);`}
+return vec4f(0.0);` : /* wgsl */ `return cJ(uv, si, ray, ma, outAux, false);`}
 }
 
 
 
-${spectral === false && deterministicPrimaryAlpha ? /* wgsl */ `fn hR(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 oy: SurfaceInteraction;
-var ox: OpenPbrResolvedMaterial;
-var uh: RayTraceAuxiliary;
-var iH = 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 eg: RayTraceAuxiliary;
+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 eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
-var event = 0; var depth = 0; var aJ = false;
-var bH = 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(path.ray, &si, depth, event != 0, path.isNextRefraction);
 getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 }
 query = true;
-if (!iH) {
+if (!jg) {
 ${primaryGuides}
-oy = si; ox = ma; uh = *outAux;
-iH = 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) {
@@ -705,36 +745,36 @@ si.albedoSampled = ma.transmissionWeight > 0.5;
 }
 }
 if (event == 0) {
-bH = (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 {
-jQ(&path, &depth, &si, &ma, aJ);
+gN(&path, &depth, &si, &ma, sampleIgnored);
 }
-if (bH & (event > bounceLimit)) { path.abort = true; }
-if (!path.abort & (event < eZ)) {
-nO(uv, &path, &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 (path.abort | (event >= eZ)) {
+if (path.abort | (event >= fj)) {
 let result = vec4f(path.li, path.alpha);
 if (!split | (coverage <= 0.0)) { return result; }
 if (front) {
-(*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);
+(*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; eg = *outAux;
-front = true; query = false; event = 0; depth = 0; aJ = false;
-si = oy; ma = ox; ma.alpha = 1.0; *outAux = uh;
+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 hR(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 path: Path;
 path.ray = ray;
@@ -742,113 +782,133 @@ 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 eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
-var bH = false;
+let fj = min(bounceLimit * 3, ${maxPathEvents});
+var isNotTransparent = false;
 var depth = 0;
-var aJ = false;
+var sampleIgnored = false;
 
 
 
-for (var event = 0; event <= eZ; event++) {
+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}
-bH = 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 {
-jQ(&path, &depth, &si, &ma, aJ);
+gN(&path, &depth, &si, &ma, sampleIgnored);
 }
-if (bH && event > bounceLimit) { path.abort = true; }
-if (path.abort || event >= eZ) { break; }
-nO(uv, &path, &depth, &si, &ma, outAux, &aJ);
+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(path.li, path.alpha);
 }
 ` : spectral === true && !deterministicPrimaryAlpha ? /* wgsl */ `
-fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn hq(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${primaryVariables}
-var oy: SurfaceInteraction;
-var ox: OpenPbrResolvedMaterial;
-var iH = false;
+var primarySi: SurfaceInteraction;
+var primaryMa: OpenPbrResolvedMaterial;
+var jg = false;
 var path: Path; path.ray = ray;
 let bounceLimit = max(rtUniform.bounces, 0);
-let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
-var depth = 0; var event = 0; var aJ = false;
-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;
+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 dw = vec3f(0.0);
-var dz = vec3f(0.0);
-var mz = true;
+var dD = vec3f(0.0);
+var dE = vec3f(0.0);
+var ik = true;
 
 
 
-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)) {
+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 (!iH) {
+if (!jg) {
 ${primaryGuides}
-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);
+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);
 }
-he = s0; ey = ca;
+wavelengthRngState = s0; eH = hashedCounter;
 }
-si = oy; ma = ox; aU = *outAux;
-if (!bi) {
-s0 = he; ca = ey; samplingBounce = 0u;
-aU.isBlank = false; aU.isShadowCatcher = false;
+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 (!bi | ew) {
-let channel = select(mc, eG, bi);
+if (!bj | eG) {
+let channel = select(jR, eQ, bj);
 si.spectralChannel = channel + 1;
-si.wavelength = cU(u32(channel), aZ);
-ma.specularIor = sampling_cauchy_ior(si.wavelength, ma.specularIor,
+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);
 }
 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;
-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)) {
+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 (bi) {
-*outAux = aU;
-let scale = select(1.0, 3.0, ew);
+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);
-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;
+${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;
@@ -856,7 +916,7 @@ event = 0;
 }
 return vec4f(0.0);
 }
-` : /* wgsl */ `fn hR(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);
 getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
@@ -866,85 +926,87 @@ if (SPECTRAL) {
 
 
 
-var vu = vec3f(0.0);
+var xl = vec3f(0.0);
 var alpha = 0.0;
-var dw = vec3f(0.0);
-var dz = vec3f(0.0);
-var mz = true;
+var dD = vec3f(0.0);
+var dE = vec3f(0.0);
+var ik = true;
 var si2 = si;
 var ma2 = ma;
-var aZ = sample1D(CAMERA_WAVELENGTH);
-let he = s0;
-let ey = ca;
-let bi = rtUniform.dispersionWavelengths == 1;
-let ew = 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, bi);
-var eG = 0;
-if (bi) {
+let uR = select(3, 1, bj);
+var eQ = 0;
+if (bj) {
 
 
-eG = min(i32(floor(aZ * 3.0)), 2);
-aZ = fract(aZ * 3.0);
+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 (!bi) {
-s0 = he;
-ca = ey;
+if (!bj) {
+s0 = wavelengthRngState;
+hashedCounter = eH;
 samplingBounce = 0u;
 }
 si.wavelength = 0.0;
 si.spectralChannel = 0;
-if (!bi || ew) {
-let channel = select(i, eG, bi);
+if (!bj || eG) {
+let channel = select(i, eQ, bj);
 si.spectralChannel = channel + 1;
-si.wavelength = cU(u32(channel), aZ);
-ma.specularIor = sampling_cauchy_ior(
+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 aU: RayTraceAuxiliary;
-if (bi) {
-aU = *outAux;
+var wavelengthAux: RayTraceAuxiliary;
+if (bj) {
+wavelengthAux = *outAux;
 } else {
-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);
+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);
 }
-vu += res.rgb;
+xl += res.rgb;
 alpha = max(alpha, res.a);
-dw += aU.albedo;
-dz += aU.normal;
-mz = mz && aU.isBlank;
+dD += wavelengthAux.albedo;
+dE += wavelengthAux.normal;
+ik = ik && wavelengthAux.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = dw / 3.0;
-(*outAux).normal = dz / 3.0;
-(*outAux).isBlank = mz;
-return vec4f(vu, alpha);
+(*outAux).albedo = dD / 3.0;
+(*outAux).normal = dE / 3.0;
+(*outAux).isBlank = ik;
+return vec4f(xl, alpha);
 }
 else {
-return iC(uv, &si, ray, &ma, outAux);
+return jb(uv, &si, ray, &ma, outAux);
 }
 }
 `}
 
-fn kq(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);
@@ -983,23 +1045,23 @@ return;
 
 let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;
 
-aI = coord;
+aJ = coord;
 aC = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
-samplingBounce = 0u; ca = 0u;
+samplingBounce = 0u; hashedCounter = 0u;
 if (${inputHooks?.uniformJitter ? 'false' : 'SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1'}) {
 jitter = (sample2D(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-fi(coord, i32(aC ^ cB(rtUniform.sequenceSeed)));
-var cam = eT(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 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);
+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);
 }
 
@@ -1008,7 +1070,7 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-${pathDiagnostic ? '  mtPathBegin(coord);\n' : ''}${inputHooks?.begin ?? ''}  var liAndAlpha = hR(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'};
 ` : ''}  
@@ -1024,23 +1086,23 @@ liAndAlpha = vec4f(0.0, 0.0, 0.0, 1.0);
 if (outAux.isShadowCatcher) {
 
 
-let aW = ft(cam);
-let qX = select(0.0, 1.0, aW.a >= 0.01);
-let jC = vec4f(aW.rgb * aW.a, aW.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, aW.a, qX, 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 += jC;
-outColor[idx] += jC;
-outAlbedo[idx] += vec4f(outAux.albedo, qX);
-hH(idx, aW.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);
-iP(idx, visibility * select(
+ju(idx, visibility * select(
 1.0, dot(aW.rgb, luminance), aW.a >= 0.01
 ));
 }
@@ -1056,8 +1118,8 @@ outShadowCatcher[idx].mask.g += liAndAlpha.a;
 }
 outColor[idx] += liAndAlpha;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-hH(idx, liAndAlpha.rgb, outAux.normal);
-iP(idx, dot(liAndAlpha.rgb, luminance));
+ij(idx, liAndAlpha.rgb, outAux.normal);
+ju(idx, dot(liAndAlpha.rgb, luminance));
 }
 ${pathDiagnostic ? '  mtPathEnd(outAux.normal, outAux.albedo);\n' : ''}${inputHooks?.end ?? ''}}
 `;
@@ -1065,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,