@meimu/mutracer 0.2.0 → 0.3.1

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, channelIndependentRis = false) {
     return /* wgsl */ `
 
-struct ob {
+struct oQ {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,32 +16,37 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn sd(
+fn tw(
 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>
+eO: ptr<function, oQ>
 ) -> bool {
-(*gz).valid = false;
-(*gz).lightSelectionPmf = 0.0;
-(*gz).risTarget = 0.0;
+(*eO).valid = false;
+(*eO).lightSelectionPmf = 0.0;
+(*eO).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 sg = -(*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,215 @@ 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 oa: Ray;
+var eY = (*si).position + EPS * lightDir;
+if (isSurface) {
+eY = un((*si).position, (*si).faceNormal, lightDir);
+let shadowTerminatorCutoff = 0.1;
+var dl = dot((*si).normal, lightDir);
+${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { dl = dot((*si).faceNormal, lightDir); }` : ''}
 let geometricNormal = select(
 (*si).faceNormal,
 -(*si).faceNormal,
-dL < 0.0
+dl < 0.0
 );
-dL = abs(dL);
-let iq = dot(geometricNormal, lightDir);
-let pq = select(
-clamp(1.0 - iq / ch, 0.0, 1.0),
+dl = abs(dl);
+let iw = dot(geometricNormal, lightDir);
+let qo = select(
+clamp(1.0 - iw / shadowTerminatorCutoff, 0.0, 1.0),
 clamp(
-2.0 - (iq + dL) / ch,
+2.0 - (iw + dl) / shadowTerminatorCutoff,
 0.0,
 1.0
 ),
-dL < ch
+dl < shadowTerminatorCutoff
 );
-hw += (*si).shadowOffset * pq;
+eY += (*si).shadowOffset * qo;
 }
 
 
 
 
-var mA = lightDir;
-var nN = lightSample.dist - EPS;
+var mZ = lightDir;
+var oy = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let uo =
+let wc =
 (*si).position + lightSample.direction * lightSample.dist;
-let rc = uo + EPS * lightSample.normal;
-let rr = rc - hw;
-nN = length(rr);
-mA = normalize(rr);
+let sk = wc + EPS * lightSample.normal;
+let sB = sk - eY;
+oy = length(sB);
+mZ = normalize(sB);
 }
-gC(&ns, hw, mA);
+initRay(&oa, eY, mZ);
 
 
 
 
-if (eM & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
-let background = hX(ns);
+if (isSurface & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
+let background = fI(oa);
 Li = background.rgb * background.a;
 }
-if (SPECTRAL) {
-Li = aj(Li, (*si).wavelength);
+if (SPECTRAL${channelIndependentRis ? ' && rtUniform.dispersionWavelengths == 1' : ''}) {
+Li = sampling_spectral_rgb_filter(Li, (*si).spectralChannel);
 }
 
 
 
-let fl = select(
-uS(fA, scatteringPdf),
+let misWeight = select(
+wM(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 ll = Li * f / lightPdf * (*path).beta;
+(*eO).risTarget = max(
+dot(max(ll * lightSelectionPmf, vec3f(0.0)), ${channelIndependentRis ? 'select(luminance, vec3f(1.0 / 3.0), SPECTRAL && rtUniform.dispersionWavelengths != 1)' : 'luminance'}),
 0.0
 );
-(*gz).ray = ns;
-(*gz).maxDistance = nN;
-(*gz).triangleIndex = (*si).triangleIndex;
-(*gz).contribution = fl * kV;
-(*gz).lightSelectionPmf = lightSelectionPmf;
-(*gz).valid = true;
+(*eO).ray = oa;
+(*eO).maxDistance = oy;
+(*eO).triangleIndex = (*si).triangleIndex;
+(*eO).contribution = misWeight * ll;${channelIndependentRis ? /* wgsl */ `
+
+
+
+if (SPECTRAL && rtUniform.dispersionWavelengths != 1) {
+(*eO).contribution = sampling_spectral_rgb_filter((*eO).contribution, (*si).spectralChannel);
+}` : ''}
+(*eO).lightSelectionPmf = lightSelectionPmf;
+(*eO).valid = true;
 return true;
 }
 return false;
 }
 
-struct qc {
+struct rb {
 direction: vec3f,
 response: vec3f,
 pdf: f32,
 transmission: bool,
 }
 
-fn sW(
+fn ps(
 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
+) -> rb {
+let candidateCount = kL();
+var selected: oQ;
 selected.valid = false;
-var nH = 0.0;
-var mq = 0.0;
-var result: qc;
+var oo = 0.0;
+var mQ = 0.0;
+var result: rb;
 
 
 
 
 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 vg = false;
+if (continuation) {
+var pP = 1.0;
 var valid = selected.valid;
 if (candidateCount > 1u) {
-valid = valid & (nH > 0.0);
+valid = valid & (oo > 0.0);
 if (valid) {
-rU = selected.lightSelectionPmf * mq /
-(f32(candidateCount) * nH);
+pP = selected.lightSelectionPmf * mQ /
+(f32(candidateCount) * oo);
 }
 }
-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*pP,0u);
+` : ''}        (*path).li += selected.contribution * pP;
 }
-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 = dQ(-(*path).ray.d,
+(*si).mediumAnisotropy, sample2D(aX(PHASE_DIRECTION)));
+result.pdf = ba(
+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 yh = vec3f(sample2D(aX(BSDF_DIRECTION)), sample1D(aX(BSDF_LOBE)));
+vg = !prepared.material.thinWalled &
 (abs(prepared.material.relativeIor - 1.0) <= 1e-6) &
 (prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6);
-if (tE) {
+if (vg) {
 lightDir = openpbr_to_world(prepared.basis, -prepared.viewLocal);
-response = bh(prepared.material) * cF(prepared,
+response = bb(prepared.material) * cp(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 (!jC(prepared, yh, &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 ob = vec3f(sample2D(tF(event, 1u)), sample1D(tF(event, 0u)));
+oj((*si).position, ob, 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 (!vg) {
+if (isSurface) {
+response = openpbr_eval_prepared(prepared, lightDir, &scatteringPdf);
 } else {
-scatteringPdf = bL(
-dot(-(*aa).ray.d, lightDir), (*si).mediumAnisotropy);
+scatteringPdf = ba(
+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: oQ;
+let uY = tw(si, ma, path, ffnormal, isSurface,
 lightSample, response, scatteringPdf, &candidate);
-if (!tv) { continue; }
+if (!uY) { 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 kZ = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kZ > 0.0) | (kZ != kZ)) { continue; }
+mQ += kZ;
 if (!selected.valid ||
-qx(event) * mq <= kO) {
+rA(event) * mQ <= kZ) {
 selected = candidate;
-nH = candidate.risTarget;
+oo = 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 pi = dot((*si).faceNormal, -(*path).ray.d);
+if (pi <= 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 +271,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) | (pi <= 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 uF = distance((*si).position, (*path).ray.o);
+let lightPdf = samplingLuminance / rtUniform.lightWeightTotal *
+uF * uF / max(pi, 1e-8);
+return gm((*path).scatteringPdf, lightPdf);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fT(input: vec3f, face: vec3f, view: vec3f) -> vec3f {
+fn fQ(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 yc = select(-face, face, front);
+let tv = select(-input, input, front);
+if ((dot(input, face) <= 0.0) | (dot(tv, view) <= 1e-6)) { return yc; }
+return tv;
 }
 ` : ''}
-fn mL(
+fn nB(
 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 bC = (*si).faceNormal;
+let oh = (*si).normal;
 ` : ''}
-var sO: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var tV: f32 = -dot((*si).normal, (*aa).ray.d);
+var uk: f32 = -dot((*si).faceNormal, (*path).ray.d);
+var vH: f32 = -dot((*si).normal, (*path).ray.d);
 if ((((*ma).transmissionWeight > 0.0) | ((*ma).subsurfaceWeight > 0.0)) & (*ma).thinWalled) {
 
-if (sO < 0.0) {
+if (uk < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-sO = -sO;
+uk = -uk;
 }
-if (tV < 0.0) {
+if (vH < 0.0) {
 (*si).normal = -(*si).normal;
-tV = -tV;
+vH = -vH;
 }
 }
 
 
-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 rS: bool = (uk >= 0.0) & (vH < 0.0);
+var ndv: f32 = select(vH, uk, rS);
+var N: vec3f = select((*si).normal, (*si).faceNormal, rS);
 
 (*ma).inside = (ndv <= 0.0) & !(*ma).thinWalled;
 
@@ -307,128 +325,149 @@ 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 gr = dot(bC, view);
+(*ma).geometricNormal = select(-bC, bC, gr >= 0.0);
+ffnormal = fQ(oh, bC, view);
+(*ma).coatNormal = fQ((*si).coatNormal, bC, view);
+(*ma).inside = (gr <= 0.0) & !(*ma).thinWalled;
+(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, (gr > 0.0) | (*ma).thinWalled);
 }
 ` : ''}
 
-(*aa).scatteringIsDelta = false;
-var bs = false;
-var hC = false;
+(*path).scatteringIsDelta = false;
+var mediumSampled = false;
+var hE = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
-var dH: vec3f;
+var di: 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 pd = (*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 vD = max(max(extinction.x, extinction.y), extinction.z);
+if ((mediumType > 0) & (vD > 0.0)) {
 
 
-let oi = min(i32(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
-let fS = extinction[oi];
-let iH = select(
+let oW = min(i32(sample1D(aX(MEDIUM_CHANNEL)) * 3.0), 2);
+let fP = extinction[oW];
+let iO = select(
 d,
-min(-log(max(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d),
-fS > 0.0
+min(-log(max(sample1D(aX(MEDIUM_DISTANCE)), 1e-7)) / fP, d),
+fP > 0.0
 );
-bs = iH < d;
-let transmittance = exp(-extinction * iH);
-let oU = select(
+mediumSampled = iO < d;
+let transmittance = exp(-extinction * iO);
+let density = 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((density.x + density.y + density.z) / 3.0, 1e-8);
+if (mediumSampled) {
+(*path).beta *= transmittance * scattering / mediumPdf;
+
+if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }
 
-(*aa).ray.o = os + iH * (*aa).ray.d;
-(*si).position = (*aa).ray.o;
+(*path).ray.o = pd + iO * (*path).ray.d;
+(*si).position = (*path).ray.o;
+
+(*si).triangleIndex = -1;
+(*si).instanceIndex = -1;
 }
 else {
-(*aa).beta *= transmittance / oE;
+(*path).beta *= transmittance / mediumPdf;
+
+if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }
 }
 }
 }
 
-if (!bs) {
-(*aa).li += qm(si, aa) * (*ma).emission * (*aa).beta;
+if (!mediumSampled) {
+
+
+var surfaceEmission = (*ma).emission;
+if (SPECTRAL) {
+surfaceEmission = sampling_spectral_rgb_filter(surfaceEmission, (*si).spectralChannel);
+}
+${caustics ? `    let nO=emissiveHitMisWeight(si,path);
+causticHotRecord(*path,nO*surfaceEmission,1u);causticEmitterRecord(*si,*path,nO,surfaceEmission);
+(*path).li+=nO*surfaceEmission*(*path).beta;` : '    (*path).li += emissiveHitMisWeight(si, path) * surfaceEmission * (*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 = bX((*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*sY(*si,prepared,(*path).fromEye,!(*path).causticHasReceiver);causticEstimateRecord(value,1u);(*path).li+=value;}
+` : ''}  let lX = ps(si, *ma, prepared, path, ffnormal, !mediumSampled);
+di = lX.direction;
+scatteringPdf = lX.pdf;
+if (!mediumSampled) {
+let f = lX.response;
+let isNextRefraction = lX.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(di, di) < 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;
+
+if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }
 
-hC = isNextRefraction & !(*ma).thinWalled;
-(*aa).isNextRefraction = isNextRefraction;
+hE = isNextRefraction & !(*ma).thinWalled;
+(*path).isNextRefraction = isNextRefraction;
 
 
-(*aa).ray.o = (*si).position + EPS * dH;
+(*path).ray.o = (*si).position + EPS * di;
 ${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(-bC, bC, dot(bC, di) >= 0.0); }
 ` : ''}
 }
-(*aa).scatteringPdf = scatteringPdf;
-(*aa).ray.d = dH;
-if (bs) {
-(*aa).isNextRefraction = false;
+(*path).scatteringPdf = scatteringPdf;
+(*path).ray.d = di;
+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 & hE & ((*ma).mediumType > 0)) {
+if (uk >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;
+(*path).scatteringMediumEntered = (*path).scatteringMediumEntered || any((*ma).mediumScattering > vec3f(0.0));
 (*si).mediumAnisotropy = (*ma).mediumAnisotropy;
 }
 else {