@meimu/mutracer 0.2.0 → 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 ob {
+struct nR {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,32 +16,37 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn sd(
+fn rZ(
 si: ptr<function, SurfaceInteraction>,
 ma: OpenPbrResolvedMaterial,
-aa: ptr<function, Path>,
+path: ptr<function, Path>,
 ffnormal: vec3f,
-eM: bool,
+isSurface: bool,
 lightSample: LightSampleRec,
 f: vec3f,
 scatteringPdf: f32,
-gz: ptr<function, ob>
+gj: ptr<function, nR>
 ) -> bool {
-(*gz).valid = false;
-(*gz).lightSelectionPmf = 0.0;
-(*gz).risTarget = 0.0;
+(*gj).valid = false;
+(*gj).lightSelectionPmf = 0.0;
+(*gj).risTarget = 0.0;
 var Li = lightSample.emission;
 
-let lightDir = lightSample.direction;
-let qY = -(*aa).ray.d;
-let fA = 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 (eM && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
+if (isSurface && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
 
-if ((fA <= 0.0) | (lightSelectionPmf <= 0.0) |
+if ((lightPdf <= 0.0) | (lightSelectionPmf <= 0.0) |
 (max(max(Li.x, Li.y), Li.z) <= 0.0)) {
 return false;
 }
@@ -50,201 +55,209 @@ if ((scatteringPdf <= 0.0) | (max(max(f.x, f.y), f.z) <= 0.0)) {
 return false;
 }
 
-var ns: Ray;
-var hw = (*si).position + EPS * lightDir;
-if (eM) {
-hw = sR((*si).position, (*si).faceNormal, lightDir);
-let ch = 0.1;
-var dL = dot((*si).normal, lightDir);
-${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { dL = 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,
-dL < 0.0
+dj < 0.0
 );
-dL = abs(dL);
-let iq = dot(geometricNormal, lightDir);
-let pq = select(
-clamp(1.0 - iq / ch, 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 - (iq + dL) / ch,
+2.0 - (hO + dj) / shadowTerminatorCutoff,
 0.0,
 1.0
 ),
-dL < ch
+dj < shadowTerminatorCutoff
 );
-hw += (*si).shadowOffset * pq;
+eO += (*si).shadowOffset * pf;
 }
 
 
 
 
-var mA = lightDir;
-var nN = lightSample.dist - EPS;
+var mh = lightDir;
+var nC = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let uo =
+let us =
 (*si).position + lightSample.direction * lightSample.dist;
-let rc = uo + EPS * lightSample.normal;
-let rr = rc - hw;
-nN = length(rr);
-mA = normalize(rr);
+let qU = us + EPS * lightSample.normal;
+let rk = qU - eO;
+nC = length(rk);
+mh = normalize(rk);
 }
-gC(&ns, hw, mA);
+initRay(&mY, eO, mh);
 
 
 
 
-if (eM & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
-let background = hX(ns);
+if (isSurface & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
+let background = ft(mY);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
-Li = aj(Li, (*si).wavelength);
+Li = sampling_spectral_rgb_filter(Li, (*si).spectralChannel);
 }
 
 
 
-let fl = select(
-uS(fA, scatteringPdf),
+let misWeight = select(
+uY(lightPdf, scatteringPdf),
 1.0,
 lightSample.isDelta
 );
-if (fl > 0.0) {
-let kV = Li * f / fA * (*aa).beta;
-(*gz).risTarget = max(
-dot(max(kV * lightSelectionPmf, vec3f(0.0)), luminance),
+if (misWeight > 0.0) {
+let kB = Li * f / lightPdf * (*path).beta;
+(*gj).risTarget = max(
+dot(max(kB * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*gz).ray = ns;
-(*gz).maxDistance = nN;
-(*gz).triangleIndex = (*si).triangleIndex;
-(*gz).contribution = fl * kV;
-(*gz).lightSelectionPmf = lightSelectionPmf;
-(*gz).valid = true;
+(*gj).ray = mY;
+(*gj).maxDistance = nC;
+(*gj).triangleIndex = (*si).triangleIndex;
+(*gj).contribution = misWeight * kB;
+(*gj).lightSelectionPmf = lightSelectionPmf;
+(*gj).valid = true;
 return true;
 }
 return false;
 }
 
-struct qc {
+struct pX {
 direction: vec3f,
 response: vec3f,
 pdf: f32,
 transmission: bool,
 }
 
-fn sW(
+fn sV(
 si: ptr<function, SurfaceInteraction>,
 ma: OpenPbrResolvedMaterial,
-prepared: ag,
-aa: ptr<function, Path>,
+prepared: OpenPbrPreparedBsdf,
+path: ptr<function, Path>,
 ffnormal: vec3f,
-eM: bool
-) -> qc {
-let candidateCount = kB();
-var selected: ob;
+isSurface: bool
+) -> pX {
+let candidateCount = ke();
+var selected: nR;
 selected.valid = false;
-var nH = 0.0;
-var mq = 0.0;
-var result: qc;
+var nq = 0.0;
+var lW = 0.0;
+var result: pX;
 
 
 
 
 for (var event = 0u; event <= candidateCount; event++) {
-let rX = event == candidateCount;
+let continuation = event == candidateCount;
 var lightSample: LightSampleRec;
 var lightDir: vec3f;
 var scatteringPdf = 0.0;
 var response = vec3f(0.0);
-var tE = false;
-if (rX) {
-var rU = 1.0;
+var tF = false;
+if (continuation) {
+var oI = 1.0;
 var valid = selected.valid;
 if (candidateCount > 1u) {
-valid = valid & (nH > 0.0);
+valid = valid & (nq > 0.0);
 if (valid) {
-rU = selected.lightSelectionPmf * mq /
-(f32(candidateCount) * nH);
+oI = selected.lightSelectionPmf * lW /
+(f32(candidateCount) * nq);
 }
 }
-if (valid && !intersectSceneShadow(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * rU;
+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 (!eM) {
-result.direction = fH(-(*aa).ray.d,
-(*si).mediumAnisotropy, dZ(cE(PHASE_DIRECTION)));
-result.pdf = bL(
-dot(result.direction, -(*aa).ray.d), (*si).mediumAnisotropy);
+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 vR = vec3f(dZ(cE(BSDF_DIRECTION)), dp(cE(BSDF_LOBE)));
-tE = !prepared.material.thinWalled &
+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 (tE) {
+if (tF) {
 lightDir = openpbr_to_world(prepared.basis, -prepared.viewLocal);
-response = bh(prepared.material) * cF(prepared,
+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 jT = u32(OPENPBR_LOBE_DIFFUSE);
+var lobe = u32(OPENPBR_LOBE_DIFFUSE);
 
 var transmission = false;
-if (!jq(prepared, vR, &lightDir, &transmission,
-&roughness, &specular, &diffuse, &jT)) { return result; }
+if (!iW(prepared, wh, &lightDir, &transmission,
+&roughness, &specular, &diffuse, &lobe)) { return result; }
 result.transmission = transmission;
 }
 } else {
-let lV = vec3f(dZ(sl(event, 1u)), dp(sl(event, 0u)));
-nE((*si).position, lV, event, candidateCount, &lightSample);
+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 (eM & ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : /* wgsl */ `let cosThetaL = dot(ffnormal, lightDir);`}
-if (eM & (cosThetaL <= 0.0) & (ma.transmissionWeight <= 0.0) & (ma.subsurfaceWeight <= 0.0)) { continue; }
+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 (!tE) {
-if (eM) {
-response = bO(prepared, lightDir, &scatteringPdf);
+if (!tF) {
+if (isSurface) {
+response = openpbr_eval_prepared(prepared, lightDir, &scatteringPdf);
 } else {
-scatteringPdf = bL(
-dot(-(*aa).ray.d, lightDir), (*si).mediumAnisotropy);
+scatteringPdf = bB(
+dot(-(*path).ray.d, lightDir), (*si).mediumAnisotropy);
 response = vec3f(scatteringPdf);
 }
 }
-if (rX) {
+if (continuation) {
 result.direction = lightDir; result.response = response; result.pdf = scatteringPdf;
 return result;
 }
-var candidate: ob;
-let tv = sd(si, ma, aa, ffnormal, eM,
+var candidate: nR;
+let tv = rZ(si, ma, path, ffnormal, isSurface,
 lightSample, response, scatteringPdf, &candidate);
 if (!tv) { continue; }
 if (candidateCount == 1u) {
 selected = candidate;
 continue;
 }
-let kO = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
-if (!(kO > 0.0) | (kO != kO)) { continue; }
-mq += kO;
+let kt = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kt > 0.0) | (kt != kt)) { continue; }
+lW += kt;
 if (!selected.valid ||
-qx(event) * mq <= kO) {
+qp(event) * lW <= kt) {
 selected = candidate;
-nH = candidate.risTarget;
+nq = candidate.risTarget;
 }
 }
 return result;
 }
 
-fn qm(
+fn emissiveHitMisWeight(
 si: ptr<function, SurfaceInteraction>,
-aa: ptr<function, Path>
-) -> f32 {
-if ((*aa).fromEye | (rtUniform.lightWeightTotal <= 0.0) |
+path: ptr<function, Path>
+) -> f32 {${caustics ? /* wgsl */ `
+if (causticHitOwned(*path, true, true)) { return 0.0; }` : ''}
+
+
+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;
 }
@@ -252,54 +265,53 @@ let samplingLuminance = dot(
 materialsBuffer[(*si).materialIndex].emission,
 luminance
 );
-let qi = dot((*si).faceNormal, -(*aa).ray.d);
-if ((samplingLuminance <= 0.0) | (qi <= 0.0)) {
+if ((samplingLuminance <= 0.0) | (om <= 0.0)) {
 return 1.0;
 }
-let te = distance((*si).position, (*aa).ray.o);
-let fA = samplingLuminance / rtUniform.lightWeightTotal *
-te * te / max(qi, 1e-8);
-return gj((*aa).scatteringPdf, fA);
+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 fT(input: vec3f, face: vec3f, view: vec3f) -> vec3f {
+fn fE(input: vec3f, face: vec3f, view: vec3f) -> vec3f {
 let front = dot(face, view) >= 0.0;
-let vP = select(-face, face, front);
-let sc = select(-input, input, front);
-if ((dot(input, face) <= 0.0) | (dot(sc, view) <= 1e-6)) { return vP; }
-return sc;
+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 mL(
+fn mx(
 si: ptr<function, SurfaceInteraction>,
 ma: ptr<function, OpenPbrResolvedMaterial>,
-aa: ptr<function, Path>
+path: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
-let bK = (*si).faceNormal;
-let nB = (*si).normal;
+let bA = (*si).faceNormal;
+let ni = (*si).normal;
 ` : ''}
-var sO: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var tV: f32 = -dot((*si).normal, (*aa).ray.d);
+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 (sO < 0.0) {
+if (sL < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-sO = -sO;
+sL = -sL;
 }
-if (tV < 0.0) {
+if (tY < 0.0) {
 (*si).normal = -(*si).normal;
-tV = -tV;
+tY = -tY;
 }
 }
 
 
-var qM: bool = (sO >= 0.0) & (tV < 0.0);
-var ndv: f32 = select(tV, sO, qM);
-var N: vec3f = select((*si).normal, (*si).faceNormal, qM);
+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;
 
@@ -307,125 +319,130 @@ var N: vec3f = select((*si).normal, (*si).faceNormal, qM);
 var ffnormal = select(-N, N, ndv >= 0.0);
 ${hasCoatNormals ? /* wgsl */ `
 if ((*ma).coatNormalEnabled) {
-let view = -(*aa).ray.d;
-let gp = dot(bK, view);
-(*ma).geometricNormal = select(-bK, bK, gp >= 0.0);
-ffnormal = fT(nB, bK, view);
-(*ma).coatNormal = fT((*si).coatNormal, bK, view);
-(*ma).inside = (gp <= 0.0) & !(*ma).thinWalled;
-(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, (gp > 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 bs = false;
-var hC = false;
+(*path).scatteringIsDelta = false;
+var mediumSampled = false;
+var hj = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
-var dH: vec3f;
+var df: vec3f;
 
 if (HAS_MEDIUM) {
-let d = distance((*si).position, (*aa).ray.o);
-let os = (*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 tR = max(max(extinction.x, extinction.y), extinction.z);
-if ((mediumType > 0) & (tR > 0.0)) {
+let tU = max(max(extinction.x, extinction.y), extinction.z);
+if ((mediumType > 0) & (tU > 0.0)) {
 
 
-let oi = min(i32(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
-let fS = extinction[oi];
-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(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d),
-fS > 0.0
+min(-log(max(sample1D(bE(MEDIUM_DISTANCE)), 1e-7)) / fD, d),
+fD > 0.0
 );
-bs = iH < d;
-let transmittance = exp(-extinction * iH);
-let oU = select(
+mediumSampled = ij < d;
+let transmittance = exp(-extinction * ij);
+let oK = select(
 transmittance,
 extinction * transmittance,
-bs
+mediumSampled
 );
-let oE = max((oU.x + oU.y + oU.z) / 3.0, 1e-8);
-if (bs) {
-(*aa).beta *= transmittance * scattering / oE;
+let mediumPdf = max((oK.x + oK.y + oK.z) / 3.0, 1e-8);
+if (mediumSampled) {
+(*path).beta *= transmittance * scattering / mediumPdf;
 
-(*aa).ray.o = os + 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 *= transmittance / oE;
+(*path).beta *= transmittance / mediumPdf;
 }
 }
 }
 
-if (!bs) {
-(*aa).li += qm(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 (!bs) {
+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 = ds((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
+prepared = bV((*si).tangent, *ma, -(*path).ray.d, ffnormal);
 }
-let qW = sW(si, *ma, prepared, aa, ffnormal, !bs);
-dH = qW.direction;
-scatteringPdf = qW.pdf;
-if (!bs) {
-let f = qW.response;
-let isNextRefraction = qW.transmission;
+${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(dH, dH) < 0.5)) {
-(*aa).scatteringPdf = 0.0;
-(*aa).abort = true;
+(dot(df, df) < 0.5)) {
+(*path).scatteringPdf = 0.0;
+(*path).abort = true;
 return;
 }
 
 
-(*aa).scatteringIsDelta = !prepared.material.thinWalled &
+(*path).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;
+${caustics ? /* wgsl */ `    causticAdvance(path, *ma, isNextRefraction, true);
+` : ''}    (*path).beta *= f / scatteringPdf;
 
-hC = isNextRefraction & !(*ma).thinWalled;
-(*aa).isNextRefraction = isNextRefraction;
+hj = isNextRefraction & !(*ma).thinWalled;
+(*path).isNextRefraction = isNextRefraction;
 
 
-(*aa).ray.o = (*si).position + EPS * dH;
+(*path).ray.o = (*si).position + EPS * df;
 ${hasCoatNormals ? /* wgsl */ `
-if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bK, bK, dot(bK, dH) >= 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 = dH;
-if (bs) {
-(*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 (!bs & hC & ((*ma).mediumType > 0)) {
-if (sO >= 0.0) {
+if (!mediumSampled & hj & ((*ma).mediumType > 0)) {
+if (sL >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;