@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -4,7 +4,7 @@
 export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 
-struct ne {
+struct ob {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,316 +16,353 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn qq(
-si: ptr<function, ad>,
-ma: J,
-prepared: ag,
+fn sd(
+si: ptr<function, SurfaceInteraction>,
+ma: OpenPbrResolvedMaterial,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gF: bool,
-ca: u32,
-aV: u32,
-gj: ptr<function, ne>
+eM: bool,
+lightSample: LightSampleRec,
+f: vec3f,
+scatteringPdf: f32,
+gz: ptr<function, ob>
 ) -> 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
-);
+(*gz).valid = false;
+(*gz).lightSelectionPmf = 0.0;
+(*gz).risTarget = 0.0;
 var Li = lightSample.emission;
 
 let lightDir = lightSample.direction;
-let oS = -(*aa).ray.d;
-let fg = lightSample.pdf;
+let qY = -(*aa).ray.d;
+let fA = 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 (eM && 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) {
+if ((fA <= 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 (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 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 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); }` : ''}
 let geometricNormal = select(
 (*si).faceNormal,
 -(*si).faceNormal,
-dr < 0.0
+dL < 0.0
 );
-dr = abs(dr);
-let hS = dot(geometricNormal, lightDir);
-let oB = select(
-clamp(1.0 - hS / bZ, 0.0, 1.0),
+dL = abs(dL);
+let iq = dot(geometricNormal, lightDir);
+let pq = select(
+clamp(1.0 - iq / ch, 0.0, 1.0),
 clamp(
-2.0 - (hS + dr) / bZ,
+2.0 - (iq + dL) / ch,
 0.0,
 1.0
 ),
-dr < bZ
+dL < ch
 );
-hi += (*si).shadowOffset * oB;
+hw += (*si).shadowOffset * pq;
 }
 
 
 
 
-var lQ = lightDir;
-var mO = lightSample.dist - EPS;
+var mA = lightDir;
+var nN = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let sY =
+let uo =
 (*si).position + lightSample.direction * lightSample.dist;
-let qe = sY + EPS * lightSample.normal;
-let qp = qe - hi;
-mO = length(qp);
-lQ = normalize(qp);
+let rc = uo + EPS * lightSample.normal;
+let rr = rc - hw;
+nN = length(rr);
+mA = normalize(rr);
 }
-iC(&mz, hi, lQ);
+gC(&ns, hw, mA);
 
 
 
 
-if (gF && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hH(mz);
+if (eM & (cosThetaL < 0.0) & (lightSample.sourceType == 0u)) {
+let background = hX(ns);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
-Li = ai(Li, (*si).wavelength);
+Li = aj(Li, (*si).wavelength);
 }
 
 
 
-let fa = select(
-tC(fg, scatteringPdf),
+let fl = select(
+uS(fA, scatteringPdf),
 1.0,
 lightSample.isDelta
 );
-if (fa > 0.0) {
-let kq = Li * f / fg * (*aa).beta;
-(*gj).risTarget = max(
-dot(max(kq * lightSelectionPmf, vec3f(0.0)), luminance),
+if (fl > 0.0) {
+let kV = Li * f / fA * (*aa).beta;
+(*gz).risTarget = max(
+dot(max(kV * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*gj).ray = mz;
-(*gj).maxDistance = mO;
-(*gj).triangleIndex = (*si).triangleIndex;
-(*gj).contribution = fa * kq;
-(*gj).lightSelectionPmf = lightSelectionPmf;
-(*gj).valid = true;
+(*gz).ray = ns;
+(*gz).maxDistance = nN;
+(*gz).triangleIndex = (*si).triangleIndex;
+(*gz).contribution = fl * kV;
+(*gz).lightSelectionPmf = lightSelectionPmf;
+(*gz).valid = true;
 return true;
 }
 return false;
 }
 
-fn mT(
-si: ptr<function, ad>,
-ma: J,
+struct qc {
+direction: vec3f,
+response: vec3f,
+pdf: f32,
+transmission: bool,
+}
+
+fn sW(
+si: ptr<function, SurfaceInteraction>,
+ma: OpenPbrResolvedMaterial,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gF: bool
-) {
-let aV = jX();
-var selected: ne;
+eM: bool
+) -> qc {
+let candidateCount = kB();
+var selected: ob;
 selected.valid = false;
-var mI = 0.0;
-var lH = 0.0;
+var nH = 0.0;
+var mq = 0.0;
+var result: qc;
 
 
-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 rX = 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 valid = selected.valid;
+if (candidateCount > 1u) {
+valid = valid & (nH > 0.0);
+if (valid) {
+rU = selected.lightSelectionPmf * mq /
+(f32(candidateCount) * nH);
+}
+}
+if (valid && !intersectSceneShadow(selected.ray, selected.maxDistance, selected.triangleIndex)) {
+(*aa).li += selected.contribution * rU;
+}
+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);
+return result;
+}
+let vR = vec3f(dZ(cE(BSDF_DIRECTION)), dp(cE(BSDF_LOBE)));
+tE = !prepared.material.thinWalled &
+(abs(prepared.material.relativeIor - 1.0) <= 1e-6) &
+(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6);
+if (tE) {
+lightDir = openpbr_to_world(prepared.basis, -prepared.viewLocal);
+response = bh(prepared.material) * cF(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 transmission = false;
+if (!jq(prepared, vR, &lightDir, &transmission,
+&roughness, &specular, &diffuse, &jT)) { return result; }
+result.transmission = transmission;
+}
+} else {
+let lV = vec3f(dZ(sl(event, 1u)), dp(sl(event, 0u)));
+nE((*si).position, lV, 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 (!tE) {
+if (eM) {
+response = bO(prepared, lightDir, &scatteringPdf);
+} else {
+scatteringPdf = bL(
+dot(-(*aa).ray.d, lightDir), (*si).mediumAnisotropy);
+response = vec3f(scatteringPdf);
+}
+}
+if (rX) {
+result.direction = lightDir; result.response = response; result.pdf = scatteringPdf;
+return result;
+}
+var candidate: ob;
+let tv = sd(si, ma, aa, ffnormal, eM,
+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 kO = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kO > 0.0) | (kO != kO)) { continue; }
+mq += kO;
 if (!selected.valid ||
-pK(ca) * lH <= kj) {
+qx(event) * mq <= kO) {
 selected = candidate;
-mI = candidate.risTarget;
-}
-}
-var qP = 1.0;
-if (aV > 1u) {
-if (!selected.valid || mI <= 0.0) { return; }
-
-
-qP = selected.lightSelectionPmf * lH /
-(f32(aV) * mI);
+nH = candidate.risTarget;
 }
-if (selected.valid &&
-!ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * qP;
 }
+return result;
 }
 
-fn pp(
-si: ptr<function, ad>,
+fn qm(
+si: ptr<function, SurfaceInteraction>,
 aa: ptr<function, Path>
 ) -> f32 {
-if ((*aa).fromEye || rtUniform.lightWeightTotal <= 0.0 ||
-i32(materialsBuffer[(*si).materialIndex].matType) == UNLIT) {
+if ((*aa).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) {
+let qi = dot((*si).faceNormal, -(*aa).ray.d);
+if ((samplingLuminance <= 0.0) | (qi <= 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 te = distance((*si).position, (*aa).ray.o);
+let fA = samplingLuminance / rtUniform.lightWeightTotal *
+te * te / max(qi, 1e-8);
+return gj((*aa).scatteringPdf, fA);
 }
 
 ${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 fT(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;
 }
 ` : ''}
-fn mb(
-si: ptr<function, ad>,
-ma: ptr<function, J>,
+fn mL(
+si: ptr<function, SurfaceInteraction>,
+ma: ptr<function, OpenPbrResolvedMaterial>,
 aa: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
-let bC = (*si).faceNormal;
-let mE = (*si).normal;
+let bK = (*si).faceNormal;
+let nB = (*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 sO: f32 = -dot((*si).faceNormal, (*aa).ray.d);
+var tV: f32 = -dot((*si).normal, (*aa).ray.d);
+if ((((*ma).transmissionWeight > 0.0) | ((*ma).subsurfaceWeight > 0.0)) & (*ma).thinWalled) {
 
-if (rN < 0.0) {
+if (sO < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-rN = -rN;
+sO = -sO;
 }
-if (sG < 0.0) {
+if (tV < 0.0) {
 (*si).normal = -(*si).normal;
-sG = -sG;
+tV = -tV;
 }
 }
 
 
-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 qM: bool = (sO >= 0.0) & (tV < 0.0);
+var ndv: f32 = select(tV, sO, qM);
+var N: vec3f = select((*si).normal, (*si).faceNormal, qM);
 
-(*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 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);
 }
 ` : ''}
 
 (*aa).scatteringIsDelta = false;
-var bl = false;
-var hn = false;
+var bs = false;
+var hC = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
-var cG: vec3f;
+var dH: vec3f;
 
 if (HAS_MEDIUM) {
 let d = distance((*si).position, (*aa).ray.o);
-let nu = (*aa).ray.o;
+let os = (*aa).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 tR = max(max(extinction.x, extinction.y), extinction.z);
+if ((mediumType > 0) & (tR > 0.0)) {
 
 
-let nj = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-let fE = extinction[nj];
-let ih = select(
+let oi = min(i32(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
+let fS = extinction[oi];
+let iH = select(
 d,
-min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d),
-fE > 0.0
+min(-log(max(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d),
+fS > 0.0
 );
-bl = ih < d;
-let ew = exp(-extinction * ih);
-let nZ = select(
-ew,
-extinction * ew,
-bl
+bs = iH < d;
+let transmittance = exp(-extinction * iH);
+let oU = select(
+transmittance,
+extinction * transmittance,
+bs
 );
-let nK = max((nZ.x + nZ.y + nZ.z) / 3.0, 1e-8);
-if (bl) {
-(*aa).beta *= ew * scattering / nK;
+let oE = max((oU.x + oU.y + oU.z) / 3.0, 1e-8);
+if (bs) {
+(*aa).beta *= transmittance * scattering / oE;
 
-(*aa).ray.o = nu + ih * (*aa).ray.d;
+(*aa).ray.o = os + iH * (*aa).ray.d;
 (*si).position = (*aa).ray.o;
 }
 else {
-(*aa).beta *= ew / nK;
+(*aa).beta *= transmittance / oE;
 }
 }
 }
 
-if (!bl) {
-(*aa).li += pp(si, aa) * (*ma).emission * (*aa).beta;
+if (!bs) {
+(*aa).li += qm(si, aa) * (*ma).emission * (*aa).beta;
 }
 if ((*ma).materialType == UNLIT) {
 (*aa).abort = true;
@@ -334,81 +371,51 @@ return;
 
 
 var prepared: ag;
-if (!bl) {
+if (!bs) {
 ${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 = ds((*si).tangent, *ma, -(*aa).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
-);
+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;
 
 
 
 
-if (!(scatteringPdf > 0.0) ||
-!all(f == f) || !all(abs(f) < vec3f(3.402823e38)) ||
-dot(cG, cG) < 0.5) {
+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;
 return;
 }
 
 
-(*aa).scatteringIsDelta = !prepared.material.thinWalled &&
-abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
+(*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;
 
-hn = isNextRefraction && !(*ma).thinWalled;
+hC = isNextRefraction & !(*ma).thinWalled;
 (*aa).isNextRefraction = isNextRefraction;
 
 
-(*aa).ray.o = (*si).position + EPS * cG;
+(*aa).ray.o = (*si).position + EPS * dH;
 ${hasCoatNormals ? /* wgsl */ `
-if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bC, bC, dot(bC, cG) >= 0.0); }
+if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bK, bK, dot(bK, dH) >= 0.0); }
 ` : ''}
 }
 (*aa).scatteringPdf = scatteringPdf;
-(*aa).ray.d = cG;
-if (bl) {
+(*aa).ray.d = dH;
+if (bs) {
 (*aa).isNextRefraction = false;
 }
 
@@ -417,8 +424,8 @@ if (bl) {
 if (HAS_MEDIUM) {
 
 
-if (!bl && hn && (*ma).mediumType > 0) {
-if (rN >= 0.0) {
+if (!bs & hC & ((*ma).mediumType > 0)) {
+if (sO >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;