@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/wgsl/chunks/sampleMaterial.wgsl.js

@@ -1,10 +1,10 @@
 // Next-event estimation with resampled importance sampling over the light
 // candidates, followed by BSDF (or phase function) sampling, as described in
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
-export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
+export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false, caustics = false, researchContribution = '', photonMapping = false) {
     return /* wgsl */ `
 
-struct ne {
+struct nR {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,137 +16,114 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn qq(
-si: ptr<function, ad>,
-ma: J,
-prepared: ag,
-aa: ptr<function, Path>,
+fn rZ(
+si: ptr<function, SurfaceInteraction>,
+ma: OpenPbrResolvedMaterial,
+path: ptr<function, Path>,
 ffnormal: vec3f,
-gF: bool,
-ca: u32,
-aV: u32,
-gj: ptr<function, ne>
+isSurface: bool,
+lightSample: LightSampleRec,
+f: vec3f,
+scatteringPdf: f32,
+gj: ptr<function, nR>
 ) -> bool {
 (*gj).valid = false;
 (*gj).lightSelectionPmf = 0.0;
 (*gj).risTarget = 0.0;
-let ln = vec3f(fp(rd(ca, 1u)), dz(rd(ca, 0u)));
-
-var lightSample: LightSampleRec;
-mH(
-(*si).position,
-ln,
-ca,
-aV,
-&lightSample
-);
 var Li = lightSample.emission;
 
-let lightDir = lightSample.direction;
-let oS = -(*aa).ray.d;
-let fg = lightSample.pdf;
+let lightDir = lightSample.direction;${caustics ? /* wgsl */ `
+if(isSurface&&isCausticSpecular(ma)){
+var connection=*path;
+causticAdvance(&connection,ma,dot(ffnormal,lightDir)<0.0,true);
+if(causticHitOwned(connection,lightSample.sourceType!=0u,true)){return false;}
+}` : ''}
+let qR = -(*path).ray.d;
+let lightPdf = lightSample.pdf;
 let lightSelectionPmf = lightSample.selectionPmf;
 
 
 ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
-if (gF && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
-
-if (fg <= 0.0 || lightSelectionPmf <= 0.0 ||
-max(max(Li.x, Li.y), Li.z) <= 0.0) {
-return false;
-}
-
-var scatteringPdf = 0.0;
-var f = vec3f(0.0);
-if (gF) {
+if (isSurface && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
 
-
-if (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 0.0) {
+if ((lightPdf <= 0.0) | (lightSelectionPmf <= 0.0) |
+(max(max(Li.x, Li.y), Li.z) <= 0.0)) {
 return false;
 }
-f = bI(prepared, lightDir, &scatteringPdf);
-}
-else {
-scatteringPdf = bD(
-dot(oS, lightDir),
-(*si).mediumAnisotropy
-);
-f = vec3f(scatteringPdf);
-}
 
-if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
+if ((scatteringPdf <= 0.0) | (max(max(f.x, f.y), f.z) <= 0.0)) {
 return false;
 }
 
-var mz: Ray;
-var hi = (*si).position + EPS * lightDir;
-if (gF) {
-hi = rQ((*si).position, (*si).faceNormal, lightDir);
-let bZ = 0.1;
-var dr = dot((*si).normal, lightDir);
-${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { dr = dot((*si).faceNormal, lightDir); }` : ''}
+var mY: Ray;
+var eO = (*si).position + EPS * lightDir;
+if (isSurface) {
+eO = sO((*si).position, (*si).faceNormal, lightDir);
+let shadowTerminatorCutoff = 0.1;
+var dj = dot((*si).normal, lightDir);
+${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { dj = dot((*si).faceNormal, lightDir); }` : ''}
 let geometricNormal = select(
 (*si).faceNormal,
 -(*si).faceNormal,
-dr < 0.0
+dj < 0.0
 );
-dr = abs(dr);
-let hS = dot(geometricNormal, lightDir);
-let oB = select(
-clamp(1.0 - hS / bZ, 0.0, 1.0),
+dj = abs(dj);
+let hO = dot(geometricNormal, lightDir);
+let pf = select(
+clamp(1.0 - hO / shadowTerminatorCutoff, 0.0, 1.0),
 clamp(
-2.0 - (hS + dr) / bZ,
+2.0 - (hO + dj) / shadowTerminatorCutoff,
 0.0,
 1.0
 ),
-dr < bZ
+dj < shadowTerminatorCutoff
 );
-hi += (*si).shadowOffset * oB;
+eO += (*si).shadowOffset * pf;
 }
 
 
 
 
-var lQ = lightDir;
-var mO = lightSample.dist - EPS;
+var mh = lightDir;
+var nC = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let sY =
+let us =
 (*si).position + lightSample.direction * lightSample.dist;
-let qe = sY + EPS * lightSample.normal;
-let qp = qe - hi;
-mO = length(qp);
-lQ = normalize(qp);
+let qU = us + EPS * lightSample.normal;
+let rk = qU - eO;
+nC = length(rk);
+mh = normalize(rk);
 }
-iC(&mz, hi, lQ);
+initRay(&mY, eO, mh);
 
 
 
 
-if (gF && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hH(mz);
+if (isSurface & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
+let background = ft(mY);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
-Li = ai(Li, (*si).wavelength);
+Li = sampling_spectral_rgb_filter(Li, (*si).spectralChannel);
 }
 
 
 
-let fa = select(
-tC(fg, scatteringPdf),
+let misWeight = select(
+uY(lightPdf, scatteringPdf),
 1.0,
 lightSample.isDelta
 );
-if (fa > 0.0) {
-let kq = Li * f / fg * (*aa).beta;
+if (misWeight > 0.0) {
+let kB = Li * f / lightPdf * (*path).beta;
 (*gj).risTarget = max(
-dot(max(kq * lightSelectionPmf, vec3f(0.0)), luminance),
+dot(max(kB * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*gj).ray = mz;
-(*gj).maxDistance = mO;
+(*gj).ray = mY;
+(*gj).maxDistance = nC;
 (*gj).triangleIndex = (*si).triangleIndex;
-(*gj).contribution = fa * kq;
+(*gj).contribution = misWeight * kB;
 (*gj).lightSelectionPmf = lightSelectionPmf;
 (*gj).valid = true;
 return true;
@@ -154,271 +131,318 @@ return true;
 return false;
 }
 
-fn mT(
-si: ptr<function, ad>,
-ma: J,
-prepared: ag,
-aa: ptr<function, Path>,
+struct pX {
+direction: vec3f,
+response: vec3f,
+pdf: f32,
+transmission: bool,
+}
+
+fn sV(
+si: ptr<function, SurfaceInteraction>,
+ma: OpenPbrResolvedMaterial,
+prepared: OpenPbrPreparedBsdf,
+path: ptr<function, Path>,
 ffnormal: vec3f,
-gF: bool
-) {
-let aV = jX();
-var selected: ne;
+isSurface: bool
+) -> pX {
+let candidateCount = ke();
+var selected: nR;
 selected.valid = false;
-var mI = 0.0;
-var lH = 0.0;
+var nq = 0.0;
+var lW = 0.0;
+var result: pX;
 
 
-for (var ca = 0u; ca < aV; ca++) {
-var candidate: ne;
-let pj = qq(
-si, ma, prepared, aa, ffnormal, gF,
-ca, aV, &candidate);
-if (aV == 1u) {
-if (!pj) { return; }
+
+
+for (var event = 0u; event <= candidateCount; event++) {
+let continuation = event == candidateCount;
+var lightSample: LightSampleRec;
+var lightDir: vec3f;
+var scatteringPdf = 0.0;
+var response = vec3f(0.0);
+var tF = false;
+if (continuation) {
+var oI = 1.0;
+var valid = selected.valid;
+if (candidateCount > 1u) {
+valid = valid & (nq > 0.0);
+if (valid) {
+oI = selected.lightSelectionPmf * lW /
+(f32(candidateCount) * nq);
+}
+}
+if (valid && !intersectSceneShadow(selected.ray, selected.maxDistance, selected.triangleIndex, (*si).instanceIndex)) {
+${caustics ? `        var connection=*path;
+if(isSurface&&isCausticSpecular(ma)){causticAdvance(&connection,ma,dot(ffnormal,selected.ray.d)<0.0,true);}
+connection.beta=vec3f(1.0);causticHotRecord(connection,selected.contribution*oI,0u);
+` : ''}        (*path).li += selected.contribution * oI;
+}
+if (!isSurface) {
+result.direction = fj(-(*path).ray.d,
+(*si).mediumAnisotropy, sample2D(bE(PHASE_DIRECTION)));
+result.pdf = bB(
+dot(result.direction, -(*path).ray.d), (*si).mediumAnisotropy);
+return result;
+}
+let wh = vec3f(sample2D(bE(BSDF_DIRECTION)), sample1D(bE(BSDF_LOBE)));
+tF = !prepared.material.thinWalled &
+(abs(prepared.material.relativeIor - 1.0) <= 1e-6) &
+(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6);
+if (tF) {
+lightDir = openpbr_to_world(prepared.basis, -prepared.viewLocal);
+response = ba(prepared.material) * cm(prepared,
+${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, lightDir), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
+scatteringPdf = 1.0;
+result.transmission = true;
+} else {
+var roughness = 1.0; var specular = false; var diffuse = true;
+var lobe = u32(OPENPBR_LOBE_DIFFUSE);
+
+var transmission = false;
+if (!iW(prepared, wh, &lightDir, &transmission,
+&roughness, &specular, &diffuse, &lobe)) { return result; }
+result.transmission = transmission;
+}
+} else {
+let mZ = vec3f(sample2D(sf(event, 1u)), sample1D(sf(event, 0u)));
+nk((*si).position, mZ, event, candidateCount, &lightSample);
+lightDir = lightSample.direction;
+if ((lightSample.pdf <= 0.0) | (lightSample.selectionPmf <= 0.0) |
+(max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0)) { continue; }
+${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
+if (isSurface & ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : /* wgsl */ `let cosThetaL = dot(ffnormal, lightDir);`}
+if (isSurface & (cosThetaL <= 0.0) & (ma.transmissionWeight <= 0.0) & (ma.subsurfaceWeight <= 0.0)) { continue; }
+}
+if (!tF) {
+if (isSurface) {
+response = openpbr_eval_prepared(prepared, lightDir, &scatteringPdf);
+} else {
+scatteringPdf = bB(
+dot(-(*path).ray.d, lightDir), (*si).mediumAnisotropy);
+response = vec3f(scatteringPdf);
+}
+}
+if (continuation) {
+result.direction = lightDir; result.response = response; result.pdf = scatteringPdf;
+return result;
+}
+var candidate: nR;
+let tv = rZ(si, ma, path, ffnormal, isSurface,
+lightSample, response, scatteringPdf, &candidate);
+if (!tv) { continue; }
+if (candidateCount == 1u) {
 selected = candidate;
-break;
+continue;
 }
-if (!pj) { continue; }
-let kj = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
-if (!(kj > 0.0) || kj != kj) { continue; }
-lH += kj;
+let kt = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kt > 0.0) | (kt != kt)) { continue; }
+lW += kt;
 if (!selected.valid ||
-pK(ca) * lH <= kj) {
+qp(event) * lW <= kt) {
 selected = candidate;
-mI = candidate.risTarget;
+nq = candidate.risTarget;
+}
 }
+return result;
 }
-var qP = 1.0;
-if (aV > 1u) {
-if (!selected.valid || mI <= 0.0) { return; }
 
+fn emissiveHitMisWeight(
+si: ptr<function, SurfaceInteraction>,
+path: ptr<function, Path>
+) -> f32 {${caustics ? /* wgsl */ `
+if (causticHitOwned(*path, true, true)) { return 0.0; }` : ''}
 
-qP = selected.lightSelectionPmf * lH /
-(f32(aV) * mI);
-}
-if (selected.valid &&
-!ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * qP;
-}
-}
 
-fn pp(
-si: ptr<function, ad>,
-aa: ptr<function, Path>
-) -> f32 {
-if ((*aa).fromEye || rtUniform.lightWeightTotal <= 0.0 ||
-i32(materialsBuffer[(*si).materialIndex].matType) == UNLIT) {
+let om = dot((*si).faceNormal, -(*path).ray.d);
+if (om <= 0.0 && materialsBuffer[(*si).materialIndex].doubleSided < 0.5) { return 0.0; }
+if ((*path).fromEye | (rtUniform.lightWeightTotal <= 0.0) |
+(i32(materialsBuffer[(*si).materialIndex].matType) == UNLIT)) {
 return 1.0;
 }
 let samplingLuminance = dot(
 materialsBuffer[(*si).materialIndex].emission,
 luminance
 );
-let pm = dot((*si).faceNormal, -(*aa).ray.d);
-if (samplingLuminance <= 0.0 || pm <= 0.0) {
+if ((samplingLuminance <= 0.0) | (om <= 0.0)) {
 return 1.0;
 }
-let rY = distance((*si).position, (*aa).ray.o);
-let fg = samplingLuminance / rtUniform.lightWeightTotal *
-rY * rY / max(pm, 1e-8);
-return fX((*aa).scatteringPdf, fg);
+let tc = distance((*si).position, (*path).ray.o);
+let lightPdf = samplingLuminance / rtUniform.lightWeightTotal *
+tc * tc / max(om, 1e-8);
+return fV((*path).scatteringPdf, lightPdf);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fF(input: vec3f, tq: vec3f, view: vec3f) -> vec3f {
-let qY = dot(tq, view) >= 0.0;
-let uo = select(-tq, tq, qY);
-let qX = select(-input, input, qY);
-if (dot(input, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
-return qX;
+fn fE(input: vec3f, face: vec3f, view: vec3f) -> vec3f {
+let front = dot(face, view) >= 0.0;
+let wd = select(-face, face, front);
+let rY = select(-input, input, front);
+if ((dot(input, face) <= 0.0) | (dot(rY, view) <= 1e-6)) { return wd; }
+return rY;
 }
 ` : ''}
-fn mb(
-si: ptr<function, ad>,
-ma: ptr<function, J>,
-aa: ptr<function, Path>
+fn mx(
+si: ptr<function, SurfaceInteraction>,
+ma: ptr<function, OpenPbrResolvedMaterial>,
+path: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
-let bC = (*si).faceNormal;
-let mE = (*si).normal;
+let bA = (*si).faceNormal;
+let ni = (*si).normal;
 ` : ''}
-var rN: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var sG: f32 = -dot((*si).normal, (*aa).ray.d);
-if (((*ma).transmissionWeight > 0.0 || (*ma).subsurfaceWeight > 0.0) && (*ma).thinWalled) {
+var sL: f32 = -dot((*si).faceNormal, (*path).ray.d);
+var tY: f32 = -dot((*si).normal, (*path).ray.d);
+if ((((*ma).transmissionWeight > 0.0) | ((*ma).subsurfaceWeight > 0.0)) & (*ma).thinWalled) {
 
-if (rN < 0.0) {
+if (sL < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-rN = -rN;
+sL = -sL;
 }
-if (sG < 0.0) {
+if (tY < 0.0) {
 (*si).normal = -(*si).normal;
-sG = -sG;
+tY = -tY;
 }
 }
 
 
-var pU: bool = rN >= 0.0 && sG < 0.0;
-var ndv: f32 = select(sG, rN, pU);
-var N: vec3f = select((*si).normal, (*si).faceNormal, pU);
+var qE: bool = (sL >= 0.0) & (tY < 0.0);
+var ndv: f32 = select(tY, sL, qE);
+var N: vec3f = select((*si).normal, (*si).faceNormal, qE);
 
-(*ma).inside = ndv <= 0.0 && !(*ma).thinWalled;
+(*ma).inside = (ndv <= 0.0) & !(*ma).thinWalled;
 
 (*ma).relativeIor = select((*ma).specularIor, (1.0 / (*ma).specularIor), ndv > 0.0);
 var ffnormal = select(-N, N, ndv >= 0.0);
 ${hasCoatNormals ? /* wgsl */ `
 if ((*ma).coatNormalEnabled) {
-let view = -(*aa).ray.d;
-let gb = dot(bC, view);
-(*ma).geometricNormal = select(-bC, bC, gb >= 0.0);
-ffnormal = fF(mE, bC, view);
-(*ma).coatNormal = fF((*si).coatNormal, bC, view);
-(*ma).inside = gb <= 0.0 && !(*ma).thinWalled;
-(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, gb > 0.0 || (*ma).thinWalled);
+let view = -(*path).ray.d;
+let fZ = dot(bA, view);
+(*ma).geometricNormal = select(-bA, bA, fZ >= 0.0);
+ffnormal = fE(ni, bA, view);
+(*ma).coatNormal = fE((*si).coatNormal, bA, view);
+(*ma).inside = (fZ <= 0.0) & !(*ma).thinWalled;
+(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, (fZ > 0.0) | (*ma).thinWalled);
 }
 ` : ''}
 
-(*aa).scatteringIsDelta = false;
-var bl = false;
-var hn = false;
+(*path).scatteringIsDelta = false;
+var mediumSampled = false;
+var hj = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
-var cG: vec3f;
+var df: vec3f;
 
 if (HAS_MEDIUM) {
-let d = distance((*si).position, (*aa).ray.o);
-let nu = (*aa).ray.o;
+let d = distance((*si).position, (*path).ray.o);
+let od = (*path).ray.o;
 let extinction = (*si).mediumExtinction;
 let scattering = min((*si).mediumScattering, extinction);
-let sC = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sC > 0.0) {
+let tU = max(max(extinction.x, extinction.y), extinction.z);
+if ((mediumType > 0) & (tU > 0.0)) {
 
 
-let nj = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-let fE = extinction[nj];
-let ih = select(
+let nX = min(i32(sample1D(bE(MEDIUM_CHANNEL)) * 3.0), 2);
+let fD = extinction[nX];
+let ij = select(
 d,
-min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d),
-fE > 0.0
+min(-log(max(sample1D(bE(MEDIUM_DISTANCE)), 1e-7)) / fD, d),
+fD > 0.0
 );
-bl = ih < d;
-let ew = exp(-extinction * ih);
-let nZ = select(
-ew,
-extinction * ew,
-bl
+mediumSampled = ij < d;
+let transmittance = exp(-extinction * ij);
+let oK = select(
+transmittance,
+extinction * transmittance,
+mediumSampled
 );
-let nK = max((nZ.x + nZ.y + nZ.z) / 3.0, 1e-8);
-if (bl) {
-(*aa).beta *= ew * scattering / nK;
+let mediumPdf = max((oK.x + oK.y + oK.z) / 3.0, 1e-8);
+if (mediumSampled) {
+(*path).beta *= transmittance * scattering / mediumPdf;
 
-(*aa).ray.o = nu + ih * (*aa).ray.d;
-(*si).position = (*aa).ray.o;
+(*path).ray.o = od + ij * (*path).ray.d;
+(*si).position = (*path).ray.o;
 }
 else {
-(*aa).beta *= ew / nK;
+(*path).beta *= transmittance / mediumPdf;
 }
 }
 }
 
-if (!bl) {
-(*aa).li += pp(si, aa) * (*ma).emission * (*aa).beta;
+if (!mediumSampled) {
+${caustics ? `    let mM=emissiveHitMisWeight(si,path);
+causticHotRecord(*path,mM*(*ma).emission,1u);causticEmitterRecord(*si,*path,mM,(*ma).emission);
+(*path).li+=mM*(*ma).emission*(*path).beta;` : '    (*path).li += emissiveHitMisWeight(si, path) * (*ma).emission * (*path).beta;'}
 }
 if ((*ma).materialType == UNLIT) {
-(*aa).abort = true;
+(*path).abort = true;
 return;
 }
 
 
-var prepared: ag;
-if (!bl) {
+var prepared: OpenPbrPreparedBsdf;
+if (!mediumSampled) {
 ${hasAnisotropyDirections ? /* wgsl */ `
 (*ma).directionTangent = (*si).directionTangent;
 (*ma).directionBitangent = (*si).directionBitangent;
 (*ma).geometryTangent = (*si).geometryTangent;
 (*ma).geometryBitangent = (*si).geometryBitangent;
 ` : /* wgsl */ ``}
-prepared = eH((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
-}
-mT(si, *ma, prepared, aa, ffnormal, !bl);
-if (bl) {
-
-cG = fq(
--(*aa).ray.d,
-(*si).mediumAnisotropy,
-fp(cw(PHASE_DIRECTION))
-);
-scatteringPdf = bD(
-dot(cG, -(*aa).ray.d),
-(*si).mediumAnisotropy
-);
+prepared = bV((*si).tangent, *ma, -(*path).ray.d, ffnormal);
 }
-else {
-
-var isNextRefraction: bool;
-var aA = 1.0;
-var aS = false;
-var bE = true;
-var aR = u32(OPENPBR_LOBE_DIFFUSE);
-var qI = 0.0;
-let ur = vec3f(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
-var gY = vec3f(0.0);
-let f = dv(
-prepared,
-ur,
-&cG,
-&scatteringPdf,
-&isNextRefraction,
-&aA,
-&aS,
-&bE,
-&aR,
-&qI,
-&gY
-);
+${researchContribution}${photonMapping ? /* wgsl */ `  if(!mediumSampled){let value=(*path).beta*rI(*si,prepared,(*path).fromEye,!(*path).causticHasReceiver);causticEstimateRecord(value,1u);(*path).li+=value;}
+` : ''}  let qP = sV(si, *ma, prepared, path, ffnormal, !mediumSampled);
+df = qP.direction;
+scatteringPdf = qP.pdf;
+if (!mediumSampled) {
+let f = qP.response;
+let isNextRefraction = qP.transmission;
 
 
 
 
-if (!(scatteringPdf > 0.0) ||
-!all(f == f) || !all(abs(f) < vec3f(3.402823e38)) ||
-dot(cG, cG) < 0.5) {
-(*aa).scatteringPdf = 0.0;
-(*aa).abort = true;
+if (!(scatteringPdf > 0.0) |
+!all(f == f) | !all(abs(f) < vec3f(3.402823e38)) |
+(dot(df, df) < 0.5)) {
+(*path).scatteringPdf = 0.0;
+(*path).abort = true;
 return;
 }
 
 
-(*aa).scatteringIsDelta = !prepared.material.thinWalled &&
-abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
-(*aa).beta *= f / scatteringPdf;
+(*path).scatteringIsDelta = !prepared.material.thinWalled &
+(abs(prepared.material.relativeIor - 1.0) <= 1e-6) &
+(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6);
+${caustics ? /* wgsl */ `    causticAdvance(path, *ma, isNextRefraction, true);
+` : ''}    (*path).beta *= f / scatteringPdf;
 
-hn = isNextRefraction && !(*ma).thinWalled;
-(*aa).isNextRefraction = isNextRefraction;
+hj = isNextRefraction & !(*ma).thinWalled;
+(*path).isNextRefraction = isNextRefraction;
 
 
-(*aa).ray.o = (*si).position + EPS * cG;
+(*path).ray.o = (*si).position + EPS * df;
 ${hasCoatNormals ? /* wgsl */ `
-if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bC, bC, dot(bC, cG) >= 0.0); }
+if ((*ma).coatNormalEnabled) { (*path).ray.o = (*si).position + EPS * select(-bA, bA, dot(bA, df) >= 0.0); }
 ` : ''}
 }
-(*aa).scatteringPdf = scatteringPdf;
-(*aa).ray.d = cG;
-if (bl) {
-(*aa).isNextRefraction = false;
+(*path).scatteringPdf = scatteringPdf;
+(*path).ray.d = df;
+if (mediumSampled) {${caustics ? /* wgsl */ `
+causticAdvance(path, *ma, false, false);` : ''}
+(*path).isNextRefraction = false;
 }
 
-(*aa).fromEye = false;
+(*path).fromEye = false;
 
 if (HAS_MEDIUM) {
 
 
-if (!bl && hn && (*ma).mediumType > 0) {
-if (rN >= 0.0) {
+if (!mediumSampled & hj & ((*ma).mediumType > 0)) {
+if (sL >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;