@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -1,11 +1,14 @@
 import { MAX_PATH_EVENTS } from '../pathLimits.js';
 import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
+import reflectanceWGSL from './aovReflectance.wgsl.js';
+import aovTraceWGSL from './aovTrace.wgsl.js';
 import depthQueryWGSL from './depthQuery.wgsl.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
 // (https://github.com/hoverinc/ray-tracing-renderer).
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
 import commonWgsl from './chunks/common.wgsl.js';
 import { WGPU_SCENE_FEATURE_BITS } from '../WGPUSceneFeatures.js';
+import { ALL_MATERIAL_SHADER_CAPABILITIES, MATERIAL_SHADER_CAPABILITIES } from '../shaderCapabilities.js';
 import rayTraceCoreWgsl from './chunks/rayTraceCore.wgsl.js';
 import { createMaterialBufferWgsl } from './chunks/materialBuffer.wgsl.js';
 import createIntersectionWgsl from './chunks/intersect.wgsl.js';
@@ -20,73 +23,128 @@ 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 }) {
+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) {
     hasAnisotropyDirections ||= hasCoatNormals;
     const deterministicPrimaryAlpha = hasAlpha;
+    const hasShadowCatcher = sceneCapabilities === undefined || (sceneCapabilities & WGPU_SCENE_FEATURE_BITS.HAS_SHADOW_CATCHER) !== 0;
+    const primaryVariables = /* wgsl */ `
+var si: SurfaceInteraction;
+var ma: OpenPbrResolvedMaterial;
+si.albedoSampled = false;
+si.mediumType = 0;
+si.mediumExtinction = vec3f(0.0);
+si.mediumScattering = vec3f(0.0);
+si.mediumAnisotropy = 0.0;
+si.barycentrics = vec2f(0.0);
+
+`;
+    const primaryGuides = /* wgsl */ `${inputHooks?.primarySurface ?? ''}  if (${hasShadowCatcher ? /* wgsl */ `si.hit && ma.materialType == SHADOW_CATCHER` : /* wgsl */ `false`}) {
+(*outAux).isShadowCatcher = true;
+
+
+(*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);
+
+
+return vec4f(1.0);
+}
+else {
+if (HAS_BEVEL && rtUniform.bevel != 0) {
+if (ma.bevel > 0.0) {
+si.normal = nj(si, ma.bevel);
+}
+}
+
+
+
+if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {
+(*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;
+}
+
+(*outAux).isShadowCatcher = false;
+
+
+}
+`;
     const source = /* wgsl */ `
 
 ${commonWgsl}
 
-${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}
+${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals, lightCapabilities })}
 
 ${uvProjectionWgsl}
 
-${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}
+${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals,
+        hasTransmission: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.transmission) !== 0,
+        hasMetalness: (materialCapabilities & MATERIAL_SHADER_CAPABILITIES.metal) !== 0 })}
 
-${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals })}
+${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals, sceneIntersections })}
 ${randWgsl}
 ${randomWgsl}
 ${envMapWgsl}
 
 ${samplingWgsl}
 ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
-${sampleLightWgsl}
+${sampleLightWgsl}${inputHooks?.declarations ?? ''}
 
 
-var<private> tL: u32 = 0u;
+var<private> vg: u32 = 0u;
 
 
 
-fn jX() -> u32 {
+fn kB() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn pK(wP: u32) -> f32 {
+fn qx(ys: u32) -> f32 {
 
 
 
 
 if (SAMPLING_PATTERN == 2) { _ = rand(); }
-let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let key = aq(aq(kd, bd), rtUniform.sequenceSeed);
-let dimension = aq(cF, wP) ^ 0xa511e9b3u;
-return f32(eg(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
+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);
 }
 
 
 
-fn tC(fg: f32, scatteringPdf: f32) -> f32 {
-let aV = jX();
-if (aV <= 1u) {
-return aG(fg, scatteringPdf);
+fn uS(fA: f32, scatteringPdf: f32) -> f32 {
+let candidateCount = kB();
+if (candidateCount <= 1u) {
+return aK(fA, scatteringPdf);
 }
-let iJ = f32(aV) * fg;
-return iJ /
-max(iJ + scatteringPdf, 1e-20);
+let jb = f32(candidateCount) * fA;
+return jb /
+max(jb + scatteringPdf, 1e-20);
 }
 
 
-fn fW(scatteringPdf: f32, fg: f32) -> f32 {
-let aV = jX();
-if (aV <= 1u) {
-return aG(scatteringPdf, fg);
+fn gj(scatteringPdf: f32, fA: f32) -> f32 {
+let candidateCount = kB();
+if (candidateCount <= 1u) {
+return aK(scatteringPdf, fA);
 }
-let iJ = f32(aV) * fg;
+let jb = f32(candidateCount) * fA;
 return scatteringPdf /
-max(scatteringPdf + iJ, 1e-20);
+max(scatteringPdf + jb, 1e-20);
 }
 
 ${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}
@@ -101,24 +159,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn hK(
-he: u32,
-vy: vec3f,
+fn ie(
+gv: u32,
+radiance: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
-let value = dot(vy, luminance);
-outNormal[he] += vec4f(value * value, 0.0, 0.0, 1.0);
+let value = dot(radiance, luminance);
+outNormal[gv] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[he] += vec4f(normal, 1.0);
+outNormal[gv] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iS(he: u32, value: f32) {
-outShadowCatcher[he].moments += vec4f(value, value * value, 0.0, 0.0);
+fn ji(gv: u32, value: f32) {
+outShadowCatcher[gv].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -128,118 +186,125 @@ albedo: vec3f,
 isShadowCatcher: bool,
 normal: vec3f,
 isBlank: bool,
+
+shadowCounts: vec2f,
 }
 
-fn dq(sN: vec3f, height: f32, radius: f32) -> f32 {
-let fQ = length(sN);
-if (fQ < 0.00001) {
+fn dK(point: vec3f, height: f32, radius: f32) -> f32 {
+let ge = length(point);
+if (ge < 0.00001) {
 return -radius;
 }
 
-let iG = radius * sN.y / fQ;
-let iq = -1.5 * height;
-var ev: f32;
-if (iG >= 0.0) {
-ev = radius;
+let iX = radius * point.y / ge;
+let iL = -1.5 * height;
+var eH: f32;
+if (iX >= 0.0) {
+eH = radius;
 }
-else if (iG < iq) {
-ev = -height * fQ / sN.y;
+else if (iX < iL) {
+eH = -height * ge / point.y;
 }
 else {
-let dW = 1.0
-- iG * iG / (3.0 * iq * iq);
-ev = radius * dW;
+let cL = 1.0
+- iX * iX / (3.0 * iL * iL);
+eH = radius * cL;
 }
-return fQ - ev;
+return ge - eH;
 }
 
-fn eT(origin: vec3f, direction: vec3f) -> vec3f {
+fn fd(origin: vec3f, direction: vec3f) -> vec3f {
 if (!USE_GROUNDED_BACKGROUND) {
 return direction;
 }
 let params = rtUniform.groundedBackgroundParams;
-let bY = normalize(direction);
+let cf = normalize(direction);
 let center = vec3f(
 rtUniform.groundedBackgroundCenter.x,
 params.z + params.x,
 rtUniform.groundedBackgroundCenter.y
 );
-let bB = origin - center;
-let eJ = dot(bB, bY);
-let ej = eJ * eJ
-- dot(bB, bB) + params.y * params.y;
+let bI = origin - center;
+let eT = dot(bI, cf);
+let br = eT * eT
+- dot(bI, bI) + params.y * params.y;
 if (
-ej <= 0.0
-|| dq(bB, params.x, params.y) > 0.0
+br <= 0.0
+|| dK(bI, params.x, params.y) > 0.0
 ) {
 return direction;
 }
 
-var cC = -eJ + sqrt(ej);
-if (cC <= 0.0) {
+var cM = -eT + sqrt(br);
+if (cM <= 0.0) {
 return direction;
 }
 
-let nP = bB + bY * cC;
-if (nP.y >= 0.0) {
-return normalize(nP);
+let oK = bI + cf * cM;
+if (oK.y >= 0.0) {
+return normalize(oK);
 }
 
-if (bY.y < -0.00001 && params.y > 1.5 * params.x) {
-let hT = (-params.x - bB.y) / bY.y;
-let nF = bB + bY * hT;
-let oo = (2.0 / 3.0)
+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 (hT > 0.0 && length(nF.xz) <= oo) {
-return normalize(nF);
+if (ir > 0.0 && length(oB.xz) <= pe) {
+return normalize(oB);
 }
 }
 
-var cN = 0.0;
+var cV = 0.0;
 for (var i = 0; i < 14; i++) {
-let fh = (cN + cC) * 0.5;
-let pL = bB + bY * fh;
-if (dq(pL, params.x, params.y) > 0.0) {
-cC = fh;
+let fB = (cV + cM) * 0.5;
+let qy = bI + cf * fB;
+if (dK(qy, params.x, params.y) > 0.0) {
+cM = fB;
 }
 else {
-cN = fh;
+cV = fB;
 }
 }
-let hit = bB + bY * ((cN + cC) * 0.5);
+let hit = bI + cf * ((cV + cM) * 0.5);
 return normalize(hit);
 }
 
-fn hH(ray: Ray) -> vec4f {
+fn hX(ray: Ray) -> vec4f {
 var bg = vec4f(0.0);
 if (USE_BACKGROUND_MAP) {
-let d = eT(ray.o, ray.d);
+let d = fd(ray.o, ray.d);
 let t = rtUniform.backgroundMapTransform;
-let qb = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
-let aW = textureLinear(backgroundMap, eL(qb));
-bg = vec4f(aW.rgb * t.z, aW.a);
+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, cY(ray.d));
+bg = textureLinear(envMap, dm(ray.d));
 }
 return bg;
 }
 
-fn cW(ray: Ray, wavelength: f32) -> vec4f {
-let bg = hH(ray);
+fn di(ray: Ray, wavelength: f32) -> vec4f {
+let bg = hX(ray);
 if (SPECTRAL) {
-return vec4f(ai(bg.rgb, wavelength), bg.a);
+return vec4f(aj(bg.rgb, wavelength), bg.a);
 }
 return bg;
 }
 
-fn bounce(uv: vec2f, aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, ad>, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) {
-cF = u32(max(*depth, 0));
+
+
+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));
 let matType = (*ma).materialType;
-let isShadowCatcher = matType == SHADOW_CATCHER;
+let isShadowCatcher = ${hasShadowCatcher ? /* wgsl */ `matType == SHADOW_CATCHER` : /* wgsl */ `false`};
 if (isShadowCatcher) {
 if ((*aa).fromEye) {
 (*si).hit = false;
@@ -252,28 +317,28 @@ if (USE_ENVMAP) {
 if ((*aa).isNextRefraction) {
 
 
-let bg = cW(
+let bg = di(
 (*aa).ray,
 (*si).wavelength
 );
-let cT = select(fW((*aa).scatteringPdf,
-iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
+let da = select(gj((*aa).scatteringPdf,
+iT(dm((*aa).ray.d)) * rtUniform.envLightPmf),
 1.0, (*aa).scatteringIsDelta);
-(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
+(*aa).li += da * (*aa).beta * bg.rgb * bg.a;
 (*aa).alpha = max((*aa).alpha, bg.a);
 }
 else {
-let tQ = cY((*aa).ray.d);
-var emission = textureLinear(envMap, tQ).rgb;
+let vo = dm((*aa).ray.d);
+var emission = textureLinear(envMap, vo).rgb;
 if (SPECTRAL) {
-emission = ai(emission, (*si).wavelength);
+emission = aj(emission, (*si).wavelength);
 }
 (*aa).li += (*aa).beta * emission *
-fW((*aa).scatteringPdf, iB(tQ));
+gj((*aa).scatteringPdf, iT(vo));
 }
 }
 else {
-let bg = cW(
+let bg = di(
 (*aa).ray,
 (*si).wavelength
 );
@@ -287,7 +352,7 @@ if (!(*si).hit) {
 
 
 
-let bg = cW(
+let bg = di(
 (*aa).ray,
 (*si).wavelength
 );
@@ -300,10 +365,10 @@ if ((*aa).fromEye) {
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = hC(uv);
-let mM = dot(cam.d, (*aa).ray.d) > 0.0;
+let cam = fj(uv);
+let nK = dot(cam.d, (*aa).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (mM) {
+if (nK) {
 (*aa).alpha = max((*aa).alpha, bg.a);
 } else {
 (*aa).alpha = 1.0;
@@ -312,11 +377,11 @@ if (mM) {
 if (!USE_ENVMAP) {
 
 
-if (mM) {
+if (nK) {
 
 
 (*aa).li += (*aa).beta *
-fW((*aa).scatteringPdf, 1.0) * bg.rgb;
+gj((*aa).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
@@ -324,26 +389,26 @@ fW((*aa).scatteringPdf, 1.0) * bg.rgb;
 return;
 }
 
-var cH = false;
+
 if ((matType == STANDARD || matType == UNLIT)) {
 let alpha = clamp((*ma).alpha, 0.0, 1.0);
 
 if (alpha < 1.0) {
 
 
-if (alpha <= 0.0 || eo(3u) > alpha) {
-cH = true;
+if (alpha <= 0.0 || eC(3u) > alpha) {
+(*fm) = true;
 }
 }
-if (!cH && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (!(*fm) && rtUniform.transmissiveOutputAlphaMin < 1.0) {
 
 
-let tW = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
-(*aa).alpha = max(tW, (*aa).alpha);
+let outputAlpha = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
+(*aa).alpha = max(outputAlpha, (*aa).alpha);
 }
-if (!cH) {
-tL = u32(max(*depth, 0));
-mc(si, ma, aa);
+if (!(*fm)) {
+vg = u32(max(*depth, 0));
+mL(si, ma, aa);
 }
 else {
 
@@ -352,7 +417,7 @@ else {
 }
 }
 
-if (!(*si).albedoSampled && !cH) {
+if (!(*si).albedoSampled && !(*fm)) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -377,12 +442,12 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !cH) {
-let oI = (*aa).beta;
+if (*depth >= RR_MAX && !(*fm)) {
+let pG = (*aa).beta;
 
-let oz = max(max(oI.x, oI.y), oI.z);
-let q: f32 = max(0.0, 1.0 - oz);
-if (dz(cw(RUSSIAN_ROULETTE)) < q) {
+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) {
 
 
 (*aa).alpha = 1.0;
@@ -397,13 +462,14 @@ if ((*aa).abort) {
 return;
 }
 
-cZ((*aa).ray, si, *depth, true, (*aa).isNextRefraction);
-eX(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 
+}
+
+fn kl(aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, aJ: bool) {
 if (SPECTRAL) {
 
 if ((*ma).transmissionWeight > 0.001) {
-(*ma).specularIor = eN(
+(*ma).specularIor = ee(
 (*si).wavelength,
 (*ma).specularIor,
 (*ma).transmissionDispersionScale,
@@ -412,62 +478,62 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (cH) {
+if (aJ) {
 return;
 }
 
 
 var lightSample: LightSampleRec;
-let hy = eo(3u) < (*ma).alpha;
+let hM = eC(3u) < (*ma).alpha;
 for (var i = 0; i < rtUniform.lightsCount; i++) {
 
 let light: Light = analyticLights[i];
-let d = mz((*aa).ray, light, &lightSample);
+let d = nr((*aa).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let mD = (*si).hit && d > distance((*si).position, (*aa).ray.o);
-if (d != INF && !(mD && hy)) {
-let fa = fW((*aa).scatteringPdf, lightSample.pdf);
+let lY = (*si).hit && d > distance((*si).position, (*aa).ray.o);
+if (d != INF && !(lY && hM)) {
+let fl = gj((*aa).scatteringPdf, lightSample.pdf);
 if (SPECTRAL) {
-lightSample.emission = ai(lightSample.emission, (*si).wavelength);
+lightSample.emission = aj(lightSample.emission, (*si).wavelength);
 }
-(*aa).li += fa * (*aa).beta * lightSample.emission;
+(*aa).li += fl * (*aa).beta * lightSample.emission;
 (*aa).alpha = 1.0;
 (*aa).abort = true;
 }
 }
 
 if (USE_ENVMAP) {
-if (!((*si).hit && hy)) {
+if (!((*si).hit && hM)) {
 if ((*aa).isNextRefraction) {
 
 
 
-let bg = cW(
+let bg = di(
 (*aa).ray,
 (*si).wavelength
 );
-let cT = select(fW((*aa).scatteringPdf,
-iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
+let da = select(gj((*aa).scatteringPdf,
+iT(dm((*aa).ray.d)) * rtUniform.envLightPmf),
 1.0, (*aa).scatteringIsDelta);
-(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
+(*aa).li += da * (*aa).beta * bg.rgb * bg.a;
 (*aa).alpha = max((*aa).alpha, bg.a);
 (*aa).abort = true;
 return;
 }
-let _uv = cY((*aa).ray.d);
+let _uv = dm((*aa).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let fa = fW(
+let fl = gj(
 (*aa).scatteringPdf,
-iB(_uv) * rtUniform.envLightPmf
+iT(_uv) * rtUniform.envLightPmf
 );
 if (SPECTRAL) {
-emission = ai(emission, (*si).wavelength);
+emission = aj(emission, (*si).wavelength);
 }
 
 if (!USE_BACKGROUND) {
 (*aa).alpha = 1.0;
 }
-(*aa).li += (*aa).beta * emission * fa;
+(*aa).li += (*aa).beta * emission * fl;
 (*aa).abort = true;
 }
 }
@@ -475,119 +541,119 @@ if (!USE_BACKGROUND) {
 *depth = *depth + 1;
 }
 
-fn hC(fG: vec2f) -> Ray {
-let origin = cameraUniform.viewProjectionInv * vec4f(fG * 2.0 - 1.0, -1.0, 1.0);
-let center = cameraUniform.viewProjectionInv * vec4f(fG * 2.0 - 1.0, 1.0, 1.0);
+fn fj(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;
-iC(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
+gC(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
 
 return cam;
 }
 
 
-fn kz(radius: f32, xi: f32) -> vec2f {
+fn ld(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var nH = 0; nH < 10; nH++) {
+for (var oD = 0; oD < 10; oD++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let kP = 1.0 - x;
+let lw = 1.0 - x;
 let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-let mk = 20.0 * x * kP * kP * kP;
-if (abs(value) < 1e-6 || mk == 0.0) { break; }
-x = clamp(x - value / mk, 0.0, 1.0);
+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 jo = x * radius;
-return vec2f(jo, sqrt(max(radius * radius - jo * jo, 0.0)));
+let jL = x * radius;
+return vec2f(jL, sqrt(max(radius * radius - jL * jL, 0.0)));
 }
 
-fn iT(radius: f32, gw: f32) -> f32 {
-if (gw >= radius) { return 0.0; }
-let oh = radius - gw;
-return oh * oh * oh;
+fn jj(radius: f32, gM: f32) -> f32 {
+if (gM >= radius) { return 0.0; }
+let pa = radius - gM;
+return pa * pa * pa;
 }
 
 
-fn mu(source: ad, radius: f32) -> vec3f {
+fn nj(source: SurfaceInteraction, radius: f32) -> vec3f {
 var geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) {
 geometricNormal = -geometricNormal;
 }
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(geometricNormal, &tangent, &bitangent);
-var iF = vec3f(0.0);
-
-for (var ig = 0; ig < BEVEL_SAMPLES; ig++) {
-let ph = fo(CAMERA_BEVEL_BASE + u32(ig));
-var cA = ph.x;
-let oG = ph.y;
-var dj = geometricNormal;
-var fH = tangent;
-var ek = bitangent;
-var ge = 0.5;
-var hY = 0.25;
-var gG = 0.25;
-if (cA < 0.5) {
-cA *= 2.0;
-}
-else if (cA < 0.75) {
-let mK = dj;
-dj = fH;
-fH = mK;
-ge = 0.25;
-hY = 0.5;
-cA = (cA - 0.5) * 4.0;
+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;
 }
 else {
-let mK = dj;
-dj = ek;
-ek = mK;
-ge = 0.25;
-gG = 0.5;
-cA = (cA - 0.75) * 4.0;
-}
-
-let gU = kz(radius, oG);
-let phi = TWOPI * cA;
-let qv = gU.x *
-(cos(phi) * fH + sin(phi) * ek);
+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);
 var ray: Ray;
-iC(
+gC(
 &ray,
-source.position + dj * gU.y + qv,
--dj
+source.position + dz * hj.y + rw,
+-dz
 );
-var hit: ad;
-iM(
+var hit: SurfaceInteraction;
+intersectSceneBevel(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gU.y, EPS)
+max(2.0 * hj.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-let kQ = ge * abs(dot(dj, hit.faceNormal));
-let mG = hY * abs(dot(fH, hit.faceNormal));
-let kb = gG * abs(dot(ek, hit.faceNormal));
-var weight = kQ / max(
-kQ * kQ + mG * mG +
-kb * kb,
+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,
 1e-8
 );
-weight *= iT(radius, distance(hit.position, source.position)) /
-max(iT(radius, gU.x), 1e-8);
-iF += weight * hit.vertexNormal;
+weight *= jj(radius, distance(hit.position, source.position)) /
+max(jj(radius, hj.x), 1e-8);
+iW += weight * hit.vertexNormal;
 }
 
-if (dot(iF, iF) <= 1e-12) { return source.normal; }
-let jH = normalize(iF);
-let result = source.normal + jH - source.vertexNormal;
+if (dot(iW, iW) <= 1e-12) { return source.normal; }
+let kg = normalize(iW);
+let result = source.normal + kg - source.vertexNormal;
 if (dot(result, result) > 1e-12) { return normalize(result); }
 return source.normal;
 }
 
-fn bw(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+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);
@@ -599,219 +665,361 @@ aa.scatteringIsDelta = false;
 aa.isNextRefraction = false;
 aa.abort = false;
 
-let rJ = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;
 let bounceLimit = max(rtUniform.bounces, 0);
+let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
 var depth = 0;
+var aJ = false;
+var bQ = false;
+
 
-for (var idx: i32 = 0; idx < min(bounceLimit * 3, ${MAX_PATH_EVENTS}); idx = idx + 1) {
-if (rJ && idx > bounceLimit) {
-aa.abort = true;
+
+
+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);
 }
-if (aa.abort) {
-break;
+if (event == 0) {
+if (sh & (*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);
 }
-bounce(uv, &aa, &depth, si, ma, outAux);
+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; }
 }
 
 return vec4f(aa.li, aa.alpha);
 }
 
-fn iD(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn iU(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);
-if (!(*si).hit || ((*ma).materialType != STANDARD && (*ma).materialType != UNLIT) || coverage >= 1.0) {
-return bw(uv, si, ray, ma, outAux);
-}
 
 
 
 
+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;
+if (split) {
+sB.o = (*si).position + ray.d * (EPS * 0.02);
+tr.albedoSampled = false;
+}
+var back: vec4f;
+var ez: RayTraceAuxiliary;
 
-var nY = ray;
-nY.o = (*si).position + ray.d * (EPS * 0.02);
-var dE = *si;
-dE.albedoSampled = false;
-cZ(nY, &dE, 0, false, false);
-var rr: J;
-eX(&rr, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
-var gm = *outAux;
-if (dE.hit && rr.materialType == STANDARD) {
-gm.albedo = select(
-rr.baseColor,
-vec3f(1.0),
-rr.transmissionWeight > 0.5
-);
-gm.normal = select(
-dE.normal,
--dE.normal,
-dot(
-dE.normal,
-dE.position - cameraUniform.viewInv[3].xyz
-) > 0.0
-);
-dE.albedoSampled = rr.transmissionWeight > 0.5;
+
+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;
+} 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);
+return mix(back, result, coverage);
 }
-let back = bw(
-uv, &dE, nY, &rr, &gm
-);
-if (coverage <= 0.0) {
-*outAux = gm;
-return back;
 }
-
-var tu = *si;
-var uI = *ma;
-uI.alpha = 1.0;
-var iW = *outAux;
-let qY = bw(
-uv, &tu, ray, &uI, &iW
-);
-(*outAux).albedo = mix(gm.albedo, iW.albedo, coverage);
-let fV = mix(gm.normal, iW.normal, coverage);
-(*outAux).normal = select(
-vec3f(0.0),
-normalize(fV),
-dot(fV, fV) > 1e-12
-);
-(*outAux).isBlank = gm.isBlank && iW.isBlank;
-(*outAux).isShadowCatcher = gm.isShadowCatcher && iW.isShadowCatcher;
-return mix(back, qY, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
+return vec4f(0.0);` : /* wgsl */ `return cT(uv, si, ray, ma, outAux, false);`}
 }
 
 
 
-fn my(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
-var si: ad;
-var ma: J;
+${spectral === false && deterministicPrimaryAlpha ? /* wgsl */ `fn iu(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+${primaryVariables}
+var oI: SurfaceInteraction;
+var oH: OpenPbrResolvedMaterial;
+var ue: RayTraceAuxiliary;
+var iY = 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;
+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;
+
+
+for (var step = 0; step < (${MAX_PATH_EVENTS} + 1) * 2 + 2; step++) {
+if (query) {
+intersectScene(aa.ray, &si, depth, event != 0, aa.isNextRefraction);
+dg(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+}
+query = true;
+if (!iY) {
+${primaryGuides}
+oI = si; oH = ma; ue = *outAux;
+iY = 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);
 si.albedoSampled = false;
-si.mediumType = 0;
-si.mediumExtinction = vec3f(0.0);
-si.mediumScattering = vec3f(0.0);
-si.mediumAnisotropy = 0.0;
-si.barycentrics = vec2f(0.0);
-
-
-cZ(ray, &si, 0, false, false);
-eX(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
-
-if (si.hit && ma.materialType == SHADOW_CATCHER) {
-(*outAux).isShadowCatcher = true;
-
-
-(*outAux).albedo = vec3f(1.0);
-(*outAux).normal = select(si.normal, -si.normal, dot(si.normal, ray.d) > 0.0);
+continue;
+}
+} else if ((event == 0) & !front & split) {
+if (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;
+}
+}
+if (event == 0) {
+bQ = (ma.transmissionWeight < 0.001) & (ma.subsurfaceWeight < 0.001) & (ma.alpha > 0.99);
+} else {
+kl(&aa, &depth, &si, &ma, aJ);
+}
+if (bQ & (event > bounceLimit)) { aa.abort = true; }
+if (!aa.abort & (event < ft)) {
+nY(uv, &aa, &depth, &si, &ma, outAux, &aJ);
+}
+if (aa.abort | (event >= ft)) {
+let result = vec4f(aa.li, aa.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);
+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);
+} else { event++; }
+}
+return vec4f(0.0);
+}
+` : spectral === false && !deterministicPrimaryAlpha ? /* wgsl */ `fn iu(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;
-sampleShadowCatcher(si, 0, &aa);
+let bounceLimit = max(rtUniform.bounces, 0);
+let ft = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+var bQ = false;
+var depth = 0;
+var aJ = false;
 
 
 
-return vec4f(vec3f(1.0), aa.alpha);
+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);
+if (event == 0) {
+${primaryGuides}
+bQ = ma.transmissionWeight < 0.001 && ma.subsurfaceWeight < 0.001 && ma.alpha > 0.99;
+} else {
+kl(&aa, &depth, &si, &ma, aJ);
 }
-else {
-if (HAS_BEVEL && rtUniform.bevel != 0) {
-if (ma.bevel > 0.0) {
-si.normal = mu(si, ma.bevel);
+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; }
 }
+return vec4f(aa.li, aa.alpha);
 }
-
-
-
-if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {
-(*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;
+` : spectral === true && !deterministicPrimaryAlpha ? /* wgsl */ `
+fn iu(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;
+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);
+var color = vec3f(0.0); var alpha = 0.0;
+var dO = vec3f(0.0);
+var dP = vec3f(0.0);
+var mN = 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);
+}
+if (event == 0) {
+if (!iY) {
+${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;
 }
-
-(*outAux).isShadowCatcher = false;
-
+si.wavelength = 0.0;
+if (!bo | df) {
+si.wavelength = wavelengths[select(mx, eX, bo)];
+ma.specularIor = ee(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);
+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;
+return vec4f(color, alpha);
+}
+event = 0;
+} else { event++; }
+}
+return vec4f(0.0);
+}
+` : /* wgsl */ `fn iu(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);
+${primaryGuides}
 if (SPECTRAL) {
 
 
 
 
-let sQ = array<f32, 3>(650.0, 510.0, 475.0);
-var tO = vec3f(0.0);
+let ug = array<f32, 3>(650.0, 510.0, 475.0);
+var vl = vec3f(0.0);
 var alpha = 0.0;
-var jE = vec3f(0.0);
-var jF = vec3f(0.0);
-var sf = true;
+var dO = vec3f(0.0);
+var dP = vec3f(0.0);
+var mN = true;
 var si2 = si;
 var ma2 = ma;
-let qL = s0;
-let nU = em;
-let eh = rtUniform.dispersionWavelengths == 1;
-let jM = si.hit &&
+let hz = s0;
+let eO = cP;
+let bo = rtUniform.dispersionWavelengths == 1;
+let df = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let se = select(3, 1, eh);
-var lP = 0;
-if (eh && jM) {
+let tm = select(3, 1, bo);
+var eX = 0;
+if (bo && df) {
 
 
-lP = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+eX = min(i32(floor(dp(CAMERA_WAVELENGTH) * 3.0)), 2);
 }
-for (var i = 0; i < se; i++) {
+for (var i = 0; i < tm; i++) {
 
 
 
-if (!eh) {
-s0 = qL;
-em = nU;
-cF = 0u;
+if (!bo) {
+s0 = hz;
+cP = eO;
+bT = 0u;
 }
 si.wavelength = 0.0;
-if (!eh || jM) {
-si.wavelength = sQ[select(i, lP, eh)];
-ma.specularIor = eN(
+if (!bo || df) {
+si.wavelength = ug[select(i, eX, bo)];
+ma.specularIor = ee(
 si.wavelength,
 ma.specularIor,
 ma.transmissionDispersionScale,
 ma.dispersionAbbeNumber
 );
 }
-var dD: RayTraceAuxiliary;
-if (eh) {
-dD = *outAux;
+var ba: RayTraceAuxiliary;
+if (bo) {
+ba = *outAux;
 } else {
-dD.albedo = (*outAux).albedo;
-dD.normal = (*outAux).normal;
-dD.isBlank = false;
-dD.isShadowCatcher = false;
-}
-let res = iD(uv, &si, ray, &ma, &dD);
-if (eh) {
-*outAux = dD;
-let scale = select(1.0, 3.0, jM);
+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);
 return vec4f(res.rgb * scale, res.a);
 }
-tO += res.rgb;
+vl += res.rgb;
 alpha = max(alpha, res.a);
-jE += dD.albedo;
-jF += dD.normal;
-sf = sf && dD.isBlank;
+dO += ba.albedo;
+dP += ba.normal;
+mN = mN && ba.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = jE / 3.0;
-(*outAux).normal = jF / 3.0;
-(*outAux).isBlank = sf;
-return vec4f(tO, alpha);
+(*outAux).albedo = dO / 3.0;
+(*outAux).normal = dP / 3.0;
+(*outAux).isBlank = mN;
+return vec4f(vl, alpha);
 }
 else {
-return iD(uv, &si, ray, &ma, outAux);
-}
+return iU(uv, &si, ray, &ma, outAux);
 }
 }
+`}
 
-fn oL(ip: vec2f) -> vec2f {
+fn kN(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);
@@ -826,17 +1034,19 @@ let outputSize = rtUniform.outputSize;
 let scaleOffset = rtUniform.scaleOffset;
 var jitter = rtUniform.jitter;
 
-let fG = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
-if (fG.x >= u32(outputSize.x) || fG.y >= u32(outputSize.y)) {
+${pathDiagnostic ? `  if (globalId.y >= mtPathParameters.y) { return; }
+let pathId = vec2u(globalId.x, globalId.y + mtPathParameters.x);
+` : ''}  let coord = ${pathDiagnostic ? 'pathId' : 'globalId.xy'} * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
+if (coord.x >= u32(outputSize.x) || coord.y >= u32(outputSize.y)) {
 return;
 }
-let idx = fG.x + fG.y * u32(outputSize.x);
+let idx = coord.x + coord.y * u32(outputSize.x);
 
 if (
 rtUniform.adaptiveSampling != 0 &&
 outNormal[idx].a >= textureLoad(
 adaptiveSampleTargets,
-vec2i(fG),
+vec2i(coord),
 0
 ).r
 ) {
@@ -846,26 +1056,26 @@ return;
 
 
 
-let uv = (vec2<f32>(f32(fG.x), f32(fG.y)) + vec2f(0.5)) / outputSize;
+let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;
 
-bc = fG;
-bd = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
-cF = 0u; em = 0u;
-if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {
-jitter = (fo(CAMERA_PIXEL) - 0.5) / outputSize;
+aZ = coord;
+aQ = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
+bT = 0u; cP = 0u;
+if (${inputHooks?.uniformJitter ? 'false' : 'SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1'}) {
+jitter = (dZ(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-kh(fG, i32(bd ^ eg(rtUniform.sequenceSeed)));
-var cam = hC(uv + jitter);
+gW(coord, i32(aQ ^ dG(rtUniform.sequenceSeed)));
+var cam = fj(uv + jitter);
 
 if (cameraUniform.apertureRadius > 0.0) {
 
 let eye = cameraUniform.viewInv[3].xyz;
-let ol = -normalize(cameraUniform.viewInv[2].xyz);
-let qy = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, ol));
-let rK = cameraUniform.apertureRadius * oL(fo(CAMERA_LENS));
-let origin = (cameraUniform.viewInv * vec4f(rK, 0.0, 1.0)).xyz;
-let dir = normalize(qy - origin);
-iC(&cam, origin, dir);
+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);
 }
 
 var outAux: RayTraceAuxiliary;
@@ -873,36 +1083,39 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-var aF = my(uv + jitter, cam, &outAux);
-
+${pathDiagnostic ? '  mtPathBegin(coord);\n' : ''}${inputHooks?.begin ?? ''}  var aW = iu(uv + jitter, cam, &outAux);
+${inputHooks?.unclampedColor ?? ''}
 
 
 if (rtUniform.clamping > 0.0) {
 let clamping = rtUniform.clamping;
-aF = vec4(clamp(aF.rgb, -vec3f(clamping), vec3f(clamping)), aF.a);
+aW = vec4(clamp(aW.rgb, -vec3f(clamping), vec3f(clamping)), aW.a);
 }
-if (!(aF.x < INF && aF.x > -EPS)) {
-aF = vec4f(0.0, 0.0, 0.0, 1.0);
+if (!(aW.x < INF && aW.x > -EPS)) {
+aW = vec4f(0.0, 0.0, 0.0, 1.0);
 }
 
 if (outAux.isShadowCatcher) {
 
 
-let aW = hH(cam);
-let qg = select(0.0, 1.0, aW.a >= 0.01);
-let jw = vec4f(aW.rgb * aW.a, aW.a);
+let bc = hX(cam);
+let rh = select(0.0, 1.0, bc.a >= 0.01);
+let jW = vec4f(bc.rgb * bc.a, bc.a);
+
 
 
-outShadowCatcher[idx].mask += vec4f(1.0, aW.a, qg, aF.a);
-outShadowCatcher[idx].background += jw;
-outColor[idx] += jw;
-outAlbedo[idx] += vec4f(outAux.albedo, qg);
-hK(idx, aW.rgb, outAux.normal);
+outShadowCatcher[idx].mask += vec4f(1.0, bc.a, rh, 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);
 
 
-let visibility = 1.0 - aF.a;
-iS(idx, visibility * select(
-1.0, dot(aW.rgb, luminance), aW.a >= 0.01
+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
 ));
 }
 else {
@@ -912,28 +1125,34 @@ if (HAS_SHADOW_CATCHER && outAux.isBlank && USE_BACKGROUND && !USE_BACKGROUND_MA
 
 
 
-outShadowCatcher[idx].background += aF;
-outShadowCatcher[idx].mask.g += aF.a;
+outShadowCatcher[idx].background += aW;
+outShadowCatcher[idx].mask.g += aW.a;
 }
-outColor[idx] += aF;
+outColor[idx] += aW;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-hK(idx, aF.rgb, outAux.normal);
-iS(idx, dot(aF.rgb, luminance));
-}
+ie(idx, aW.rgb, outAux.normal);
+ji(idx, dot(aW.rgb, luminance));
 }
+${pathDiagnostic ? '  mtPathEnd(outAux.normal, outAux.albedo);\n' : ''}${inputHooks?.end ?? ''}}
 `;
     // The query entry point shares the exact BVH and material implementation.
     // 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;
+    let specializedSource = source + depthQueryWGSL + reflectanceWGSL + aovTraceWGSL;
     const backgroundBits = {
         USE_BACKGROUND: 1,
         USE_BACKGROUND_MAP: 2,
         USE_GROUNDED_BACKGROUND: 4
     };
     specializedSource = specializedSource.replace(/\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\b/g, (name) => `((rtUniform.backgroundFlags & ${backgroundBits[name]}) != 0)`);
-    specializedSource = specializedSource.replace(new RegExp(`\\b(?:${Object.keys(WGPU_SCENE_FEATURE_BITS).join('|')})\\b`, 'g'), name => `((rtUniform.sceneFeatureFlags & ${WGPU_SCENE_FEATURE_BITS[name]}u) != 0u)`);
+    specializedSource = specializedSource.replace(new RegExp(`\\b(?:${Object.keys(WGPU_SCENE_FEATURE_BITS).join('|')})\\b`, 'g'), 
+    // Material weights and absent texture indices already disable retained
+    // material capabilities. Environment presence also changes background/MIS
+    // behavior, so its active flag must remain dynamic when support is retained.
+    name => sceneCapabilities === undefined || dynamicEnvironment && name === 'USE_ENVMAP' && (sceneCapabilities & WGPU_SCENE_FEATURE_BITS[name]) !== 0
+        ? /* wgsl */ `((rtUniform.sceneFeatureFlags & ${WGPU_SCENE_FEATURE_BITS[name]}u) != 0u)`
+        : (sceneCapabilities & WGPU_SCENE_FEATURE_BITS[name]) !== 0 ? /* wgsl */ `true` : /* wgsl */ `false`);
     return specializedSource;
 }
 //# sourceMappingURL=rayTrace.compute.js.map