@meimu/mutracer 0.1.5 → 0.3.0

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

@@ -1,11 +1,18 @@
+import { photonQuerySource } from './photonMap.compute.js';
+import backgroundWgsl from './chunks/background.wgsl.js';
+import { researchTransport } from '../researchTransport.js';
+import { causticPartitionWGSL } from './chunks/caustics.wgsl.js';
 import { MAX_PATH_EVENTS } from '../pathLimits.js';
 import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
+import reflectanceWGSL from './aovReflectance.wgsl.js';
+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';
@@ -15,81 +22,148 @@ 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 }) {
+export default function rayTraceCompute(options, sceneIntersections = '', pathDiagnostic = false, inputHooks) {
+    const research = researchTransport()?.compute(options);
+    const enabled = research?.enabled ?? false;
+    const partitionDepth = research?.maxDepth ?? 20;
+    const debugGroup = research?.debugGroup ?? options.debugGroup ?? -1;
+    let { hasDisplacement, workgroupSize = WORKGROUP_SIZE, lightTracing = false, photonMapping = false, photonMaxDepth = 20, hasAnisotropyDirections = false, hasCoatNormals = false, hasAlpha = true, hasSceneAlpha = true, blasLayoutMask = 1, spectral, sceneCapabilities, dynamicEnvironment = false, materialCapabilities = ALL_MATERIAL_SHADER_CAPABILITIES, lightCapabilities } = options;
     hasAnisotropyDirections ||= hasCoatNormals;
     const deterministicPrimaryAlpha = hasAlpha;
+    const hasShadowCatcher = sceneCapabilities === undefined || (sceneCapabilities & WGPU_SCENE_FEATURE_BITS.HAS_SHADOW_CATCHER) !== 0;
+    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 path: Path;
+path.ray = ray;
+path.fromEye = true;
+(*outAux).shadowCounts = sampleShadowCatcher(si, 0, &path);
+
+
+return vec4f(1.0);
+}
+else {
+if (HAS_BEVEL && rtUniform.bevel != 0) {
+if (ma.bevel > 0.0) {
+si.normal = mT(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, caustics: enabled || lightTracing || photonMapping })}
 
 ${uvProjectionWgsl}
 
-${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}
+${createMaterialBufferWgsl({ 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 })}
+${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals, sceneIntersections })}
 ${randWgsl}
 ${randomWgsl}
 ${envMapWgsl}
 
 ${samplingWgsl}
+${spectrumWgsl}
 ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
-${sampleLightWgsl}
+${sampleLightWgsl}${inputHooks?.declarations ?? ''}
 
 
-var<private> tL: u32 = 0u;
+var<private> vp: u32 = 0u;
 
 
 
-fn jX() -> u32 {
+fn ke() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn pK(wP: u32) -> f32 {
+fn qp(yQ: 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 kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
+let key = ak(ak(kl, aC), rtUniform.sequenceSeed);
+let dimension = ak(samplingBounce, yQ) ^ 0xa511e9b3u;
+return f32(cB(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
 }
 
 
 
-fn tC(fg: f32, scatteringPdf: f32) -> f32 {
-let aV = jX();
-if (aV <= 1u) {
-return aG(fg, scatteringPdf);
+fn uY(lightPdf: f32, scatteringPdf: f32) -> f32 {
+let candidateCount = ke();
+if (candidateCount <= 1u) {
+return aF(lightPdf, scatteringPdf);
 }
-let iJ = f32(aV) * fg;
-return iJ /
-max(iJ + scatteringPdf, 1e-20);
+let weightedLightPdf = f32(candidateCount) * lightPdf;
+return weightedLightPdf /
+max(weightedLightPdf + scatteringPdf, 1e-20);
 }
 
 
-fn fX(scatteringPdf: f32, fg: f32) -> f32 {
-let aV = jX();
-if (aV <= 1u) {
-return aG(scatteringPdf, fg);
+fn fV(scatteringPdf: f32, lightPdf: f32) -> f32 {
+let candidateCount = ke();
+if (candidateCount <= 1u) {
+return aF(scatteringPdf, lightPdf);
 }
-let iJ = f32(aV) * fg;
+let weightedLightPdf = f32(candidateCount) * lightPdf;
 return scatteringPdf /
-max(scatteringPdf + iJ, 1e-20);
+max(scatteringPdf + weightedLightPdf, 1e-20);
 }
 
-${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}
+${enabled || lightTracing || photonMapping ? causticPartitionWGSL(enabled, lightTracing, photonMapping, partitionDepth, debugGroup >= 30, photonMaxDepth) : ''}${research?.declarations ?? ''}${photonMapping ? `const CAUSTIC_LIGHT_TRACING=${lightTracing};
+const CAUSTIC_MNEE=${enabled};
+const CAUSTIC_MNEE_MAX_DEPTH=${partitionDepth}u;
+const CAUSTIC_PHOTON_MAX_DEPTH=${photonMaxDepth}u;
+` + photonQuerySource(debugGroup, !lightTracing && (options.photonDirectSubset ?? true)) : ''}${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals, enabled || lightTracing || photonMapping, research?.contribution, photonMapping)}
 ${sampleShadowCatcherWgsl}
 
 
@@ -101,24 +175,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn hK(
-hg: u32,
-vy: vec3f,
+fn hH(
+gf: u32,
+radiance: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
-let value = dot(vy, luminance);
-outNormal[hg] += vec4f(value * value, 0.0, 0.0, 1.0);
+let value = dot(radiance, luminance);
+outNormal[gf] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[hg] += vec4f(normal, 1.0);
+outNormal[gf] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iS(hg: u32, value: f32) {
-outShadowCatcher[hg].moments += vec4f(value, value * value, 0.0, 0.0);
+fn iP(gf: u32, value: f32) {
+outShadowCatcher[gf].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -128,120 +202,27 @@ albedo: vec3f,
 isShadowCatcher: bool,
 normal: vec3f,
 isBlank: bool,
-}
-
-fn dq(sN: vec3f, height: f32, radius: f32) -> f32 {
-let fR = length(sN);
-if (fR < 0.00001) {
-return -radius;
-}
-
-let iG = radius * sN.y / fR;
-let iq = -1.5 * height;
-var ev: f32;
-if (iG >= 0.0) {
-ev = radius;
-}
-else if (iG < iq) {
-ev = -height * fR / sN.y;
-}
-else {
-let dW = 1.0
-- iG * iG / (3.0 * iq * iq);
-ev = radius * dW;
-}
-return fR - ev;
-}
-
-fn eT(origin: vec3f, direction: vec3f) -> vec3f {
-if (!USE_GROUNDED_BACKGROUND) {
-return direction;
-}
-let params = rtUniform.groundedBackgroundParams;
-let bY = 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;
-if (
-ej <= 0.0
-|| dq(bB, params.x, params.y) > 0.0
-) {
-return direction;
-}
-
-var cC = -eJ + sqrt(ej);
-if (cC <= 0.0) {
-return direction;
-}
-
-let nO = bB + bY * cC;
-if (nO.y >= 0.0) {
-return normalize(nO);
-}
-
-if (bY.y < -0.00001 && params.y > 1.5 * params.x) {
-let hT = (-params.x - bB.y) / bY.y;
-let nE = bB + bY * hT;
-let om = (2.0 / 3.0)
-* sqrt(params.y * params.y - 2.25 * params.x * params.x);
-if (hT > 0.0 && length(nE.xz) <= om) {
-return normalize(nE);
-}
-}
 
-var cN = 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;
-}
-else {
-cN = fh;
-}
-}
-let hit = bB + bY * ((cN + cC) * 0.5);
-return normalize(hit);
-}
-
-fn hH(ray: Ray) -> vec4f {
-var bg = vec4f(0.0);
-if (USE_BACKGROUND_MAP) {
-let d = eT(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);
-}
-else if (USE_BACKGROUND) {
-bg = rtUniform.backgroundColor;
-}
-else if (USE_ENVMAP) {
-bg = textureLinear(envMap, cY(ray.d));
-}
-return bg;
+shadowCounts: vec2f,
 }
 
-fn cW(ray: Ray, wavelength: f32) -> vec4f {
-let bg = hH(ray);
+${backgroundWgsl}fn cP(ray: Ray, channel: i32) -> vec4f {
+let bg = ft(ray);
 if (SPECTRAL) {
-return vec4f(ai(bg.rgb, wavelength), bg.a);
+return vec4f(sampling_spectral_rgb_filter(bg.rgb, channel), 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 nO(uv: vec2f, path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, eV: ptr<function, bool>) {
+*eV = false;
+samplingBounce = u32(max(*depth, 0));
 let matType = (*ma).materialType;
-let isShadowCatcher = matType == SHADOW_CATCHER;
+let isShadowCatcher = ${hasShadowCatcher ? /* wgsl */ `matType == SHADOW_CATCHER` : /* wgsl */ `false`};
 if (isShadowCatcher) {
-if ((*aa).fromEye) {
+if ((*path).fromEye) {
 (*si).hit = false;
 }
 else {
@@ -249,37 +230,37 @@ else {
 
 
 if (USE_ENVMAP) {
-if ((*aa).isNextRefraction) {
+if ((*path).isNextRefraction) {
 
 
-let bg = cW(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-let cT = select(fX((*aa).scatteringPdf,
-iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
-1.0, (*aa).scatteringIsDelta);
-(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = max((*aa).alpha, bg.a);
+let cM = select(fV((*path).scatteringPdf,
+envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).alpha = max((*path).alpha, bg.a);
 }
 else {
-let tQ = cY((*aa).ray.d);
-var emission = textureLinear(envMap, tQ).rgb;
+let vC = cT((*path).ray.d);
+var emission = textureLinear(envMap, vC).rgb;
 if (SPECTRAL) {
-emission = ai(emission, (*si).wavelength);
+emission = sampling_spectral_rgb_filter(emission, (*si).spectralChannel);
 }
-(*aa).li += (*aa).beta * emission *
-fX((*aa).scatteringPdf, iB(tQ));
+(*path).li += (*path).beta * emission *
+fV((*path).scatteringPdf, envMapPdf(vC));
 }
 }
 else {
-let bg = cW(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-(*aa).li += (*aa).beta * bg.rgb * bg.a;
+(*path).li += (*path).beta * bg.rgb * bg.a;
 }
-(*aa).abort = true;
+(*path).abort = true;
 return;
 }
 }
@@ -287,72 +268,72 @@ if (!(*si).hit) {
 
 
 
-let bg = cW(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-if ((*aa).fromEye) {
+if ((*path).fromEye) {
 
-(*aa).li = (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = bg.a;
+(*path).li = (*path).beta * bg.rgb * bg.a;
+(*path).alpha = bg.a;
 
 (*outAux).isBlank = bg.a < 0.001 ||
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = hC(uv);
-let mL = dot(cam.d, (*aa).ray.d) > 0.0;
+let cam = eT(uv);
+let nt = dot(cam.d, (*path).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (mL) {
-(*aa).alpha = max((*aa).alpha, bg.a);
+if (nt) {
+(*path).alpha = max((*path).alpha, bg.a);
 } else {
-(*aa).alpha = 1.0;
+(*path).alpha = 1.0;
 }
 }
 if (!USE_ENVMAP) {
 
 
-if (mL) {
+if (nt) {
 
 
-(*aa).li += (*aa).beta *
-fX((*aa).scatteringPdf, 1.0) * bg.rgb;
+(*path).li += (*path).beta *
+fV((*path).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
-(*aa).abort = true;
+(*path).abort = true;
 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 || ek(3u) > alpha) {
+(*eV) = true;
 }
 }
-if (!cH && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (!(*eV) && 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)));
+(*path).alpha = max(outputAlpha, (*path).alpha);
 }
-if (!cH) {
-tL = u32(max(*depth, 0));
-mb(si, ma, aa);
+if (!(*eV)) {
+vp = u32(max(*depth, 0));
+mx(si, ma, path);
 }
 else {
 
 
-(*aa).ray.o = (*si).position + (*aa).ray.d * EPS;
+(*path).ray.o = (*si).position + (*path).ray.d * EPS;
 }
 }
 
-if (!(*si).albedoSampled && !cH) {
+if (!(*si).albedoSampled && !(*eV)) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -377,33 +358,34 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !cH) {
-let oH = (*aa).beta;
+if (*depth >= RR_MAX && !(*eV)) {
+let pl = (*path).beta;
 
-let oy = max(max(oH.x, oH.y), oH.z);
-let q: f32 = max(0.0, 1.0 - oy);
-if (dz(cw(RUSSIAN_ROULETTE)) < q) {
+let pc = max(max(pl.x, pl.y), pl.z);
+let q: f32 = max(0.0, 1.0 - pc);
+if (sample1D(bE(RUSSIAN_ROULETTE)) < q) {
 
 
-(*aa).alpha = 1.0;
-(*aa).abort = true;
+(*path).alpha = 1.0;
+(*path).abort = true;
 }
 else {
-(*aa).beta /= 1.0 - q;
+(*path).beta /= 1.0 - q;
 }
 }
 }
-if ((*aa).abort) {
+if ((*path).abort) {
 return;
 }
 
-cZ((*aa).ray, si, *depth, true, (*aa).isNextRefraction);
-eX(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 
+}
+
+fn jQ(path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, aJ: bool) {
 if (SPECTRAL) {
 
 if ((*ma).transmissionWeight > 0.001) {
-(*ma).specularIor = eN(
+(*ma).specularIor = sampling_cauchy_ior(
 (*si).wavelength,
 (*ma).specularIor,
 (*ma).transmissionDispersionScale,
@@ -412,406 +394,557 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (cH) {
+if (aJ) {
 return;
 }
 
 
 var lightSample: LightSampleRec;
-let hy = eo(3u) < (*ma).alpha;
+let ht = ek(3u) < (*ma).alpha;
 for (var i = 0; i < rtUniform.lightsCount; i++) {
 
 let light: Light = analyticLights[i];
-let d = my((*aa).ray, light, &lightSample);
+let d = mX((*path).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let mC = (*si).hit && d > distance((*si).position, (*aa).ray.o);
-if (d != INF && !(mC && hy)) {
-let fa = fX((*aa).scatteringPdf, lightSample.pdf);
+let lH = (*si).hit && d > distance((*si).position, (*path).ray.o);
+if (d != INF && !(lH && ht)) {
+let misWeight = fV((*path).scatteringPdf, lightSample.pdf);
 if (SPECTRAL) {
-lightSample.emission = ai(lightSample.emission, (*si).wavelength);
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, (*si).spectralChannel);
 }
-(*aa).li += fa * (*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 && hy)) {
-if ((*aa).isNextRefraction) {
+if (!((*si).hit && ht)) {${lightTracing || photonMapping ? /* wgsl */ `
+if(causticHitOwned(*path,false,true)){(*path).abort=true;return;}` : ''}
+if ((*path).isNextRefraction) {
 
 
 
-let bg = cW(
-(*aa).ray,
-(*si).wavelength
+let bg = cP(
+(*path).ray,
+(*si).spectralChannel
 );
-let cT = select(fX((*aa).scatteringPdf,
-iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
-1.0, (*aa).scatteringIsDelta);
-(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
-(*aa).alpha = max((*aa).alpha, bg.a);
-(*aa).abort = true;
+let cM = select(fV((*path).scatteringPdf,
+envMapPdf(cT((*path).ray.d)) * rtUniform.envLightPmf),
+1.0, (*path).scatteringIsDelta);
+(*path).li += cM * (*path).beta * bg.rgb * bg.a;
+(*path).alpha = max((*path).alpha, bg.a);
+(*path).abort = true;
 return;
 }
-let _uv = cY((*aa).ray.d);
+let _uv = cT((*path).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let fa = fX(
-(*aa).scatteringPdf,
-iB(_uv) * rtUniform.envLightPmf
+let misWeight = fV(
+(*path).scatteringPdf,
+envMapPdf(_uv) * rtUniform.envLightPmf
 );
 if (SPECTRAL) {
-emission = ai(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 * fa;
-(*aa).abort = true;
+(*path).li += (*path).beta * emission * misWeight;
+(*path).abort = true;
 }
 }
 
 *depth = *depth + 1;
 }
 
-fn hC(fH: vec2f) -> Ray {
-let origin = cameraUniform.viewProjectionInv * vec4f(fH * 2.0 - 1.0, -1.0, 1.0);
-let center = cameraUniform.viewProjectionInv * vec4f(fH * 2.0 - 1.0, 1.0, 1.0);
+fn eT(coord: vec2f) -> Ray {
+let origin = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, -1.0, 1.0);
+let center = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, 1.0, 1.0);
 var cam: Ray;
-iC(&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 kz(radius: f32, xi: f32) -> vec2f {
+fn kK(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var nG = 0; nG < 10; nG++) {
+for (var iteration = 0; iteration < 10; iteration++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let kP = 1.0 - x;
+let la = 1.0 - x;
 let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-let mj = 20.0 * x * kP * kP * kP;
-if (abs(value) < 1e-6 || mj == 0.0) { break; }
-x = clamp(x - value / mj, 0.0, 1.0);
+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 jo = x * radius;
-return vec2f(jo, sqrt(max(radius * radius - jo * jo, 0.0)));
+let jr = x * radius;
+return vec2f(jr, sqrt(max(radius * radius - jr * jr, 0.0)));
 }
 
-fn iT(radius: f32, gx: f32) -> f32 {
-if (gx >= radius) { return 0.0; }
-let og = radius - gx;
-return og * og * og;
+fn bevelCubicPdf(radius: f32, gu: f32) -> f32 {
+if (gu >= radius) { return 0.0; }
+let falloff = radius - gu;
+return falloff * falloff * falloff;
 }
 
 
-fn mt(source: ad, radius: f32) -> vec3f {
+fn mT(source: SurfaceInteraction, radius: f32) -> vec3f {
 var geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) {
 geometricNormal = -geometricNormal;
 }
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(geometricNormal, &tangent, &bitangent);
-var iF = vec3f(0.0);
-
-for (var ig = 0; ig < BEVEL_SAMPLES; ig++) {
-let ph = fp(CAMERA_BEVEL_BASE + u32(ig));
-var cA = ph.x;
-let oF = ph.y;
-var dj = geometricNormal;
+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 ek = bitangent;
-var gf = 0.5;
-var hY = 0.25;
-var gH = 0.25;
-if (cA < 0.5) {
-cA *= 2.0;
-}
-else if (cA < 0.75) {
-let mJ = dj;
-dj = fI;
-fI = mJ;
-gf = 0.25;
-hY = 0.5;
-cA = (cA - 0.5) * 4.0;
+var eh = bitangent;
+var ge = 0.5;
+var hW = 0.25;
+var gC = 0.25;
+if (cr < 0.5) {
+cr *= 2.0;
+}
+else if (cr < 0.75) {
+let nr = cZ;
+cZ = fI;
+fI = nr;
+ge = 0.25;
+hW = 0.5;
+cr = (cr - 0.5) * 4.0;
 }
 else {
-let mJ = dj;
-dj = ek;
-ek = mJ;
-gf = 0.25;
-gH = 0.5;
-cA = (cA - 0.75) * 4.0;
-}
-
-let gV = kz(radius, oF);
-let phi = TWOPI * cA;
-let qv = gV.x *
-(cos(phi) * fI + sin(phi) * ek);
+let nr = cZ;
+cZ = eh;
+eh = nr;
+ge = 0.25;
+gC = 0.5;
+cr = (cr - 0.75) * 4.0;
+}
+
+let gQ = kK(radius, pj);
+let phi = TWOPI * cr;
+let rr = gQ.x *
+(cos(phi) * fI + sin(phi) * eh);
 var ray: Ray;
-iC(
+initRay(
 &ray,
-source.position + dj * gV.y + qv,
--dj
+source.position + cZ * gQ.y + rr,
+-cZ
 );
-var hit: ad;
-iM(
+var hit: SurfaceInteraction;
+intersectSceneBevel(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gV.y, EPS)
+max(2.0 * gQ.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-let kQ = gf * abs(dot(dj, hit.faceNormal));
-let mF = hY * abs(dot(fI, hit.faceNormal));
-let kb = gH * abs(dot(ek, hit.faceNormal));
-var weight = kQ / max(
-kQ * kQ + mF * mF +
-kb * kb,
+let lc = ge * abs(dot(cZ, hit.faceNormal));
+let nj = hW * abs(dot(fI, hit.faceNormal));
+let kj = gC * abs(dot(eh, hit.faceNormal));
+var weight = lc / max(
+lc * lc + nj * nj +
+kj * kj,
 1e-8
 );
-weight *= iT(radius, distance(hit.position, source.position)) /
-max(iT(radius, gV.x), 1e-8);
-iF += weight * hit.vertexNormal;
+weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /
+max(bevelCubicPdf(radius, gQ.x), 1e-8);
+iE += weight * hit.vertexNormal;
 }
 
-if (dot(iF, iF) <= 1e-12) { return source.normal; }
-let jH = normalize(iF);
-let result = source.normal + jH - source.vertexNormal;
+if (dot(iE, iE) <= 1e-12) { return source.normal; }
+let jM = normalize(iE);
+let result = source.normal + jM - source.vertexNormal;
 if (dot(result, result) > 1e-12) { return normalize(result); }
 return source.normal;
 }
 
-fn bw(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
-var aa: Path;
-aa.ray = ray;
-aa.li = vec3f(0.0);
-aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
-aa.beta = vec3f(1.0);
-aa.fromEye = true;
-aa.scatteringPdf = 0.0;
-aa.scatteringIsDelta = false;
-aa.isNextRefraction = false;
-aa.abort = false;
+fn cG(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>, sc: bool) -> vec4f {
+var path: Path;
+path.ray = ray;
+path.li = vec3f(0.0);
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path.beta = vec3f(1.0);
+path.fromEye = true;
+path.scatteringPdf = 0.0;
+path.scatteringIsDelta = false;
+path.isNextRefraction = false;
+path.abort = false;
 
-let rJ = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;
 let bounceLimit = max(rtUniform.bounces, 0);
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
 var depth = 0;
+var aJ = false;
+var bH = 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 <= eZ; event++) {
+if ((event != 0) | sc) {
+intersectScene(path.ray, si, depth, event != 0, path.isNextRefraction);
+getMaterial(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 }
-if (aa.abort) {
-break;
+if (event == 0) {
+if (sc & (*si).hit & ((*ma).materialType == STANDARD)) {
+(*outAux).albedo = select((*ma).baseColor, vec3f(1.0), (*ma).transmissionWeight > 0.5);
+(*outAux).normal = select((*si).normal, -(*si).normal,
+dot((*si).normal, (*si).position - cameraUniform.viewInv[3].xyz) > 0.0);
+(*si).albedoSampled = (*ma).transmissionWeight > 0.5;
 }
-bounce(uv, &aa, &depth, si, ma, outAux);
+bH = ((*ma).transmissionWeight < 0.001) & ((*ma).subsurfaceWeight < 0.001) & ((*ma).alpha > 0.99);
+} else {
+jQ(&path, &depth, si, ma, aJ);
 }
-
-return vec4f(aa.li, aa.alpha);
+if (bH & (event > bounceLimit)) { path.abort = true; }
+if (path.abort | (event >= eZ)) { break; }
+nO(uv, &path, &depth, si, ma, outAux, &aJ);
+if (path.abort) { break; }
 }
 
-fn iD(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, 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);
+return vec4f(path.li, path.alpha);
 }
 
+fn iC(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);
 
 
 
 
-var nX = ray;
-nX.o = (*si).position + ray.d * (EPS * 0.02);
-var dE = *si;
-dE.albedoSampled = false;
-cZ(nX, &dE, 0, false, false);
-var rr: J;
-eX(&rr, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
-var gn = *outAux;
-if (dE.hit && rr.materialType == STANDARD) {
-gn.albedo = select(
-rr.baseColor,
-vec3f(1.0),
-rr.transmissionWeight > 0.5
-);
-gn.normal = select(
-dE.normal,
--dE.normal,
-dot(
-dE.normal,
-dE.position - cameraUniform.viewInv[3].xyz
-) > 0.0
-);
-dE.albedoSampled = rr.transmissionWeight > 0.5;
-}
-let back = bw(
-uv, &dE, nX, &rr, &gn
-);
-if (coverage <= 0.0) {
-*outAux = gn;
-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(gn.albedo, iW.albedo, coverage);
-let fW = mix(gn.normal, iW.normal, coverage);
-(*outAux).normal = select(
-vec3f(0.0),
-normalize(fW),
-dot(fW, fW) > 1e-12
-);
-(*outAux).isBlank = gn.isBlank && iW.isBlank;
-(*outAux).isShadowCatcher = gn.isShadowCatcher && iW.isShadowCatcher;
-return mix(back, qY, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
+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;
+if (split) {
+st.o = (*si).position + ray.d * (EPS * 0.02);
+tr.albedoSampled = false;
 }
+var back: vec4f;
+var eg: RayTraceAuxiliary;
 
 
-
-fn mx(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
-var si: ad;
-var ma: J;
+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;
+} 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);
+return mix(back, result, coverage);
+}
+}
+return vec4f(0.0);` : /* wgsl */ `return cG(uv, si, ray, ma, outAux, false);`}
+}
+
+
+
+${spectral === false && deterministicPrimaryAlpha ? /* wgsl */ `fn hR(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+${primaryVariables}
+var oy: SurfaceInteraction;
+var ox: OpenPbrResolvedMaterial;
+var uh: RayTraceAuxiliary;
+var iH = false;
+var query = true;
+var split = false;
+var coverage = 1.0;
+var front = false;
+var back: vec4f;
+var eg: RayTraceAuxiliary;
+var path: Path; path.ray = ray;
+path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+path.beta = vec3f(1.0); path.fromEye = true;
+let bounceLimit = max(rtUniform.bounces, 0);
+let eZ = min(bounceLimit * 3, ${MAX_PATH_EVENTS});
+var event = 0; var depth = 0; var aJ = false;
+var bH = false;
+
+
+for (var step = 0; step < (${MAX_PATH_EVENTS} + 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) {
+${primaryGuides}
+oy = si; ox = ma; uh = *outAux;
+iH = true;
+coverage = clamp(ma.alpha, 0.0, 1.0);
+split = si.hit & ((ma.materialType == STANDARD) | (ma.materialType == UNLIT)) & (coverage < 1.0);
+if (split) {
+path.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);
-var aa: Path;
-aa.ray = ray;
-aa.fromEye = true;
-sampleShadowCatcher(si, 0, &aa);
-
-
-
-return vec4f(vec3f(1.0), aa.alpha);
-}
-else {
-if (HAS_BEVEL && rtUniform.bevel != 0) {
-if (ma.bevel > 0.0) {
-si.normal = mt(si, ma.bevel);
-}
+continue;
 }
-
-
-
-if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {
+} 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
-);
-
-
-
+(*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) {
+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)) {
+nO(uv, &path, &depth, &si, &ma, outAux, &aJ);
+}
+if (path.abort | (event >= eZ)) {
+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);
+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;
+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 {
+${primaryVariables}
+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 bH = false;
+var depth = 0;
+var aJ = false;
+
 
-(*outAux).isShadowCatcher = false;
 
+for (var event = 0; event <= eZ; event++) {
+intersectScene(path.ray, &si, depth, event != 0, path.isNextRefraction);
+getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+if (event == 0) {
+${primaryGuides}
+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);
+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 {
+${primaryVariables}
+var oy: SurfaceInteraction;
+var ox: OpenPbrResolvedMaterial;
+var iH = 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;
+var color = vec3f(0.0); var alpha = 0.0;
+var dw = vec3f(0.0);
+var dz = vec3f(0.0);
+var mz = 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)) {
+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) {
+${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);
+}
+he = s0; ey = ca;
+}
+si = oy; ma = ox; aU = *outAux;
+if (!bi) {
+s0 = he; ca = ey; samplingBounce = 0u;
+aU.isBlank = false; aU.isShadowCatcher = false;
+}
+si.wavelength = 0.0; si.spectralChannel = 0;
+if (!bi | ew) {
+let channel = select(mc, eG, bi);
+si.spectralChannel = channel + 1;
+si.wavelength = cU(u32(channel), aZ);
+ma.specularIor = sampling_cauchy_ior(si.wavelength, ma.specularIor,
+ma.transmissionDispersionScale, ma.dispersionAbbeNumber);
+}
+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)) {
+let result = vec4f(path.li, path.alpha);
+if (bi) {
+*outAux = aU;
+let scale = select(1.0, 3.0, ew);
+return vec4f(result.rgb * scale, result.a);
+}
+color += result.rgb; alpha = max(alpha, result.a);
+dw += aU.albedo;
+dz += aU.normal;
+mz = mz & aU.isBlank;
+mc++;
+if (mc >= 3) {
+(*outAux).albedo = dw / 3.0;
+(*outAux).normal = dz / 3.0;
+(*outAux).isBlank = mz;
+return vec4f(color, alpha);
+}
+event = 0;
+} else { event++; }
+}
+return vec4f(0.0);
+}
+` : /* wgsl */ `fn hR(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);
+${primaryGuides}
 if (SPECTRAL) {
 
 
 
 
-let sQ = array<f32, 3>(650.0, 510.0, 475.0);
-var tO = vec3f(0.0);
+var vu = vec3f(0.0);
 var alpha = 0.0;
-var jE = vec3f(0.0);
-var jF = vec3f(0.0);
-var sf = true;
+var dw = vec3f(0.0);
+var dz = vec3f(0.0);
+var mz = true;
 var si2 = si;
 var ma2 = ma;
-let qL = s0;
-let nT = em;
-let eh = rtUniform.dispersionWavelengths == 1;
-let jM = si.hit &&
+var aZ = sample1D(CAMERA_WAVELENGTH);
+let he = s0;
+let ey = ca;
+let bi = rtUniform.dispersionWavelengths == 1;
+let ew = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let se = select(3, 1, eh);
-var lO = 0;
-if (eh && jM) {
+let tm = select(3, 1, bi);
+var eG = 0;
+if (bi) {
 
 
-lO = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+eG = min(i32(floor(aZ * 3.0)), 2);
+aZ = fract(aZ * 3.0);
 }
-for (var i = 0; i < se; i++) {
+for (var i = 0; i < tm; i++) {
 
 
 
-if (!eh) {
-s0 = qL;
-em = nT;
-cF = 0u;
+if (!bi) {
+s0 = he;
+ca = ey;
+samplingBounce = 0u;
 }
 si.wavelength = 0.0;
-if (!eh || jM) {
-si.wavelength = sQ[select(i, lO, eh)];
-ma.specularIor = eN(
+si.spectralChannel = 0;
+if (!bi || ew) {
+let channel = select(i, eG, bi);
+si.spectralChannel = channel + 1;
+si.wavelength = cU(u32(channel), aZ);
+ma.specularIor = sampling_cauchy_ior(
 si.wavelength,
 ma.specularIor,
 ma.transmissionDispersionScale,
 ma.dispersionAbbeNumber
 );
 }
-var dD: RayTraceAuxiliary;
-if (eh) {
-dD = *outAux;
+var aU: RayTraceAuxiliary;
+if (bi) {
+aU = *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);
+aU.albedo = (*outAux).albedo;
+aU.normal = (*outAux).normal;
+aU.isBlank = false;
+aU.isShadowCatcher = false;
+}
+let res = iC(uv, &si, ray, &ma, &aU);
+if (bi) {
+*outAux = aU;
+let scale = select(1.0, 3.0, ew);
 return vec4f(res.rgb * scale, res.a);
 }
-tO += res.rgb;
+vu += res.rgb;
 alpha = max(alpha, res.a);
-jE += dD.albedo;
-jF += dD.normal;
-sf = sf && dD.isBlank;
+dw += aU.albedo;
+dz += aU.normal;
+mz = mz && aU.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = jE / 3.0;
-(*outAux).normal = jF / 3.0;
-(*outAux).isBlank = sf;
-return vec4f(tO, alpha);
+(*outAux).albedo = dw / 3.0;
+(*outAux).normal = dz / 3.0;
+(*outAux).isBlank = mz;
+return vec4f(vu, alpha);
 }
 else {
-return iD(uv, &si, ray, &ma, outAux);
-}
+return iC(uv, &si, ray, &ma, outAux);
 }
 }
+`}
 
-fn oK(ip: vec2f) -> vec2f {
+fn kq(ip: vec2f) -> vec2f {
 let p = 2.0 * ip - 1.0;
 let greater = abs(p.x) > abs(p.y);
 let r = select(p.y, p.x, greater);
@@ -820,23 +953,25 @@ 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;
 var jitter = rtUniform.jitter;
 
-let fH = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
-if (fH.x >= u32(outputSize.x) || fH.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 = fH.x + fH.y * u32(outputSize.x);
+let idx = coord.x + coord.y * u32(outputSize.x);
 
 if (
 rtUniform.adaptiveSampling != 0 &&
 outNormal[idx].a >= textureLoad(
 adaptiveSampleTargets,
-vec2i(fH),
+vec2i(coord),
 0
 ).r
 ) {
@@ -846,26 +981,26 @@ return;
 
 
 
-let uv = (vec2<f32>(f32(fH.x), f32(fH.y)) + vec2f(0.5)) / outputSize;
+let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;
 
-bc = fH;
-bd = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
-cF = 0u; em = 0u;
-if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {
-jitter = (fp(CAMERA_PIXEL) - 0.5) / outputSize;
+aI = coord;
+aC = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
+samplingBounce = 0u; ca = 0u;
+if (${inputHooks?.uniformJitter ? 'false' : 'SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1'}) {
+jitter = (sample2D(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-kh(fH, i32(bd ^ eg(rtUniform.sequenceSeed)));
-var cam = hC(uv + jitter);
+fi(coord, i32(aC ^ cB(rtUniform.sequenceSeed)));
+var cam = eT(uv + jitter);
 
 if (cameraUniform.apertureRadius > 0.0) {
 
 let eye = cameraUniform.viewInv[3].xyz;
-let oj = -normalize(cameraUniform.viewInv[2].xyz);
-let qy = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, oj));
-let rK = cameraUniform.apertureRadius * oK(fp(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 ju = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));
+let sH = cameraUniform.apertureRadius * kq(sample2D(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(sH, 0.0, 1.0)).xyz;
+let dir = normalize(ju - origin);
+initRay(&cam, origin, dir);
 }
 
 var outAux: RayTraceAuxiliary;
@@ -873,35 +1008,39 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-var aF = mx(uv + jitter, cam, &outAux);
-
-
+${pathDiagnostic ? '  mtPathBegin(coord);\n' : ''}${inputHooks?.begin ?? ''}  var liAndAlpha = hR(uv + jitter, cam, &outAux);
+${inputHooks?.unclampedColor ?? ''}
+${(enabled || lightTracing || photonMapping) && debugGroup >= 0 ? /* wgsl */ `  liAndAlpha=${debugGroup >= 50 ? `vec4f(photonQueryStats,1.0)` : debugGroup >= 30 ? `vec4f(causticHot[${debugGroup - 30}],1.0)` : research?.debugOutput ?? 'liAndAlpha'};
+` : ''}  
 
 if (rtUniform.clamping > 0.0) {
 let clamping = rtUniform.clamping;
-aF = vec4(clamp(aF.rgb, -vec3f(clamping), vec3f(clamping)), aF.a);
+liAndAlpha = vec4(clamp(liAndAlpha.rgb, -vec3f(clamping), vec3f(clamping)), liAndAlpha.a);
 }
-if (!(aF.x < INF && aF.x > -EPS)) {
-aF = 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 aW = hH(cam);
-let qg = select(0.0, 1.0, aW.a >= 0.01);
-let jw = vec4f(aW.rgb * aW.a, aW.a);
+let aW = ft(cam);
+let qX = select(0.0, 1.0, aW.a >= 0.01);
+let jC = vec4f(aW.rgb * aW.a, aW.a);
 
 
-outShadowCatcher[idx].mask += vec4f(1.0, 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, aW.a, qX, 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);
 
-let visibility = 1.0 - aF.a;
-iS(idx, visibility * select(
+
+let counts = outAux.shadowCounts;
+let visibility = 1.0 - select(0.0, counts.x / counts.y, counts.y > 0.0);
+iP(idx, visibility * select(
 1.0, dot(aW.rgb, luminance), aW.a >= 0.01
 ));
 }
@@ -912,28 +1051,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 += liAndAlpha;
+outShadowCatcher[idx].mask.g += liAndAlpha.a;
 }
-outColor[idx] += aF;
+outColor[idx] += liAndAlpha;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-hK(idx, aF.rgb, outAux.normal);
-iS(idx, dot(aF.rgb, luminance));
-}
+hH(idx, liAndAlpha.rgb, outAux.normal);
+iP(idx, dot(liAndAlpha.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