@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -4,7 +4,7 @@
 export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 
-struct mR {
+struct ne {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,49 +16,49 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn qi(
+fn qq(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gy: bool,
+gF: bool,
 ca: u32,
-aW: u32,
-ge: ptr<function, mR>
+aV: u32,
+gj: ptr<function, ne>
 ) -> bool {
-(*ge).valid = false;
-(*ge).lightSelectionPmf = 0.0;
-(*ge).risTarget = 0.0;
-let lc = vec3f(fk(qV(ca, 1u)), dz(qV(ca, 0u)));
+(*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;
-my(
+mH(
 (*si).position,
-lc,
+ln,
 ca,
-aW,
+aV,
 &lightSample
 );
 var Li = lightSample.emission;
 
 let lightDir = lightSample.direction;
-let oK = -(*aa).ray.d;
-let fd = lightSample.pdf;
+let oS = -(*aa).ray.d;
+let fg = lightSample.pdf;
 let lightSelectionPmf = lightSample.selectionPmf;
 
 
 ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
-if (gy && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
+if (gF && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
 
-if (fd <= 0.0 || lightSelectionPmf <= 0.0 ||
+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 (gy) {
+if (gF) {
 
 
 if (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 0.0) {
@@ -68,7 +68,7 @@ f = bI(prepared, lightDir, &scatteringPdf);
 }
 else {
 scatteringPdf = bD(
-dot(oK, lightDir),
+dot(oS, lightDir),
 (*si).mediumAnisotropy
 );
 f = vec3f(scatteringPdf);
@@ -78,10 +78,10 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return false;
 }
 
-var mp: Ray;
-var hd = (*si).position + EPS * lightDir;
-if (gy) {
-hd = rI((*si).position, (*si).faceNormal, lightDir);
+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); }` : ''}
@@ -91,39 +91,39 @@ let geometricNormal = select(
 dr < 0.0
 );
 dr = abs(dr);
-let hO = dot(geometricNormal, lightDir);
-let ot = select(
-clamp(1.0 - hO / bZ, 0.0, 1.0),
+let hS = dot(geometricNormal, lightDir);
+let oB = select(
+clamp(1.0 - hS / bZ, 0.0, 1.0),
 clamp(
-2.0 - (hO + dr) / bZ,
+2.0 - (hS + dr) / bZ,
 0.0,
 1.0
 ),
 dr < bZ
 );
-hd += (*si).shadowOffset * ot;
+hi += (*si).shadowOffset * oB;
 }
 
 
 
 
-var lH = lightDir;
-var mF = lightSample.dist - EPS;
+var lQ = lightDir;
+var mO = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let sR =
+let sY =
 (*si).position + lightSample.direction * lightSample.dist;
-let pW = sR + EPS * lightSample.normal;
-let qh = pW - hd;
-mF = length(qh);
-lH = normalize(qh);
+let qe = sY + EPS * lightSample.normal;
+let qp = qe - hi;
+mO = length(qp);
+lQ = normalize(qp);
 }
-iw(&mp, hd, lH);
+iC(&mz, hi, lQ);
 
 
 
 
-if (gy && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hD(mp);
+if (gF && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
+let background = hH(mz);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
@@ -132,78 +132,78 @@ Li = ai(Li, (*si).wavelength);
 
 
 
-let eW = select(
-tq(fd, scatteringPdf),
+let fa = select(
+tC(fg, scatteringPdf),
 1.0,
 lightSample.isDelta
 );
-if (eW > 0.0) {
-let kj = Li * f / fd * (*aa).beta;
-(*ge).risTarget = max(
-dot(max(kj * lightSelectionPmf, vec3f(0.0)), luminance),
+if (fa > 0.0) {
+let kq = Li * f / fg * (*aa).beta;
+(*gj).risTarget = max(
+dot(max(kq * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*ge).ray = mp;
-(*ge).maxDistance = mF;
-(*ge).triangleIndex = (*si).triangleIndex;
-(*ge).contribution = eW * kj;
-(*ge).lightSelectionPmf = lightSelectionPmf;
-(*ge).valid = true;
+(*gj).ray = mz;
+(*gj).maxDistance = mO;
+(*gj).triangleIndex = (*si).triangleIndex;
+(*gj).contribution = fa * kq;
+(*gj).lightSelectionPmf = lightSelectionPmf;
+(*gj).valid = true;
 return true;
 }
 return false;
 }
 
-fn mJ(
+fn mT(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gy: bool
+gF: bool
 ) {
-let aW = jQ();
-var selected: mR;
+let aV = jX();
+var selected: ne;
 selected.valid = false;
-var mz = 0.0;
-var lv = 0.0;
+var mI = 0.0;
+var lH = 0.0;
 
 
-for (var ca = 0u; ca < aW; ca++) {
-var candidate: mR;
-let pa = qi(
-si, ma, prepared, aa, ffnormal, gy,
-ca, aW, &candidate);
-if (aW == 1u) {
-if (!pa) { return; }
+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; }
 selected = candidate;
 break;
 }
-if (!pa) { continue; }
-let kc = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
-if (!(kc > 0.0) || kc != kc) { continue; }
-lv += kc;
+if (!pj) { continue; }
+let kj = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kj > 0.0) || kj != kj) { continue; }
+lH += kj;
 if (!selected.valid ||
-ps(ca) * lv <= kc) {
+pK(ca) * lH <= kj) {
 selected = candidate;
-mz = candidate.risTarget;
+mI = candidate.risTarget;
 }
 }
-var qG = 1.0;
-if (aW > 1u) {
-if (!selected.valid || mz <= 0.0) { return; }
+var qP = 1.0;
+if (aV > 1u) {
+if (!selected.valid || mI <= 0.0) { return; }
 
 
-qG = selected.lightSelectionPmf * lv /
-(f32(aW) * mz);
+qP = selected.lightSelectionPmf * lH /
+(f32(aV) * mI);
 }
 if (selected.valid &&
 !ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * qG;
+(*aa).li += selected.contribution * qP;
 }
 }
 
-fn pg(
+fn pp(
 si: ptr<function, ad>,
 aa: ptr<function, Path>
 ) -> f32 {
@@ -215,54 +215,54 @@ let samplingLuminance = dot(
 materialsBuffer[(*si).materialIndex].emission,
 luminance
 );
-let pd = dot((*si).faceNormal, -(*aa).ray.d);
-if (samplingLuminance <= 0.0 || pd <= 0.0) {
+let pm = dot((*si).faceNormal, -(*aa).ray.d);
+if (samplingLuminance <= 0.0 || pm <= 0.0) {
 return 1.0;
 }
-let rQ = distance((*si).position, (*aa).ray.o);
-let fd = samplingLuminance / rtUniform.lightWeightTotal *
-rQ * rQ / max(pd, 1e-8);
-return fS((*aa).scatteringPdf, fd);
+let rY = distance((*si).position, (*aa).ray.o);
+let fg = samplingLuminance / rtUniform.lightWeightTotal *
+rY * rY / max(pm, 1e-8);
+return fX((*aa).scatteringPdf, fg);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fB(input: vec3f, th: vec3f, view: vec3f) -> vec3f {
-let qQ = dot(th, view) >= 0.0;
-let uh = select(-th, th, qQ);
-let qP = select(-input, input, qQ);
-if (dot(input, th) <= 0.0 || dot(qP, view) <= 1e-6) { return uh; }
-return qP;
+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 lR(
+fn mb(
 si: ptr<function, ad>,
 ma: ptr<function, J>,
 aa: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
 let bC = (*si).faceNormal;
-let mv = (*si).normal;
+let mE = (*si).normal;
 ` : ''}
-var rF: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var sw: f32 = -dot((*si).normal, (*aa).ray.d);
+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) {
 
-if (rF < 0.0) {
+if (rN < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-rF = -rF;
+rN = -rN;
 }
-if (sw < 0.0) {
+if (sG < 0.0) {
 (*si).normal = -(*si).normal;
-sw = -sw;
+sG = -sG;
 }
 }
 
 
-var pM: bool = rF >= 0.0 && sw < 0.0;
-var ndv: f32 = select(sw, rF, pM);
-var N: vec3f = select((*si).normal, (*si).faceNormal, pM);
+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);
 
 (*ma).inside = ndv <= 0.0 && !(*ma).thinWalled;
 
@@ -271,18 +271,18 @@ var ffnormal = select(-N, N, ndv >= 0.0);
 ${hasCoatNormals ? /* wgsl */ `
 if ((*ma).coatNormalEnabled) {
 let view = -(*aa).ray.d;
-let fW = dot(bC, view);
-(*ma).geometricNormal = select(-bC, bC, fW >= 0.0);
-ffnormal = fB(mv, bC, view);
-(*ma).coatNormal = fB((*si).coatNormal, bC, view);
-(*ma).inside = fW <= 0.0 && !(*ma).thinWalled;
-(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, fW > 0.0 || (*ma).thinWalled);
+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);
 }
 ` : ''}
 
 (*aa).scatteringIsDelta = false;
 var bl = false;
-var hj = false;
+var hn = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
@@ -290,42 +290,42 @@ var cG: vec3f;
 
 if (HAS_MEDIUM) {
 let d = distance((*si).position, (*aa).ray.o);
-let nh = (*aa).ray.o;
+let nu = (*aa).ray.o;
 let extinction = (*si).mediumExtinction;
 let scattering = min((*si).mediumScattering, extinction);
-let sr = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sr > 0.0) {
+let sC = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sC > 0.0) {
 
 
-let mW = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-let fA = extinction[mW];
-let ib = select(
+let nj = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+let fE = extinction[nj];
+let ih = select(
 d,
-min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fA, d),
-fA > 0.0
+min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d),
+fE > 0.0
 );
-bl = ib < d;
-let ew = exp(-extinction * ib);
-let nP = select(
+bl = ih < d;
+let ew = exp(-extinction * ih);
+let nZ = select(
 ew,
 extinction * ew,
 bl
 );
-let nA = max((nP.x + nP.y + nP.z) / 3.0, 1e-8);
+let nK = max((nZ.x + nZ.y + nZ.z) / 3.0, 1e-8);
 if (bl) {
-(*aa).beta *= ew * scattering / nA;
+(*aa).beta *= ew * scattering / nK;
 
-(*aa).ray.o = nh + ib * (*aa).ray.d;
+(*aa).ray.o = nu + ih * (*aa).ray.d;
 (*si).position = (*aa).ray.o;
 }
 else {
-(*aa).beta *= ew / nA;
+(*aa).beta *= ew / nK;
 }
 }
 }
 
 if (!bl) {
-(*aa).li += pg(si, aa) * (*ma).emission * (*aa).beta;
+(*aa).li += pp(si, aa) * (*ma).emission * (*aa).beta;
 }
 if ((*ma).materialType == UNLIT) {
 (*aa).abort = true;
@@ -341,15 +341,15 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 (*ma).geometryTangent = (*si).geometryTangent;
 (*ma).geometryBitangent = (*si).geometryBitangent;
 ` : /* wgsl */ ``}
-prepared = eG((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
+prepared = eH((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
 }
-mJ(si, *ma, prepared, aa, ffnormal, !bl);
+mT(si, *ma, prepared, aa, ffnormal, !bl);
 if (bl) {
 
-cG = fl(
+cG = fq(
 -(*aa).ray.d,
 (*si).mediumAnisotropy,
-fk(cw(PHASE_DIRECTION))
+fp(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
 dot(cG, -(*aa).ray.d),
@@ -360,24 +360,24 @@ else {
 
 var isNextRefraction: bool;
 var aA = 1.0;
-var aT = false;
+var aS = false;
 var bE = true;
 var aR = u32(OPENPBR_LOBE_DIFFUSE);
-var qA = 0.0;
-let uj = vec3f(fk(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
-var gT = vec3f(0.0);
+var qI = 0.0;
+let ur = vec3f(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+var gY = vec3f(0.0);
 let f = dv(
 prepared,
-uj,
+ur,
 &cG,
 &scatteringPdf,
 &isNextRefraction,
 &aA,
-&aT,
+&aS,
 &bE,
 &aR,
-&qA,
-&gT
+&qI,
+&gY
 );
 
 
@@ -397,7 +397,7 @@ abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 (*aa).beta *= f / scatteringPdf;
 
-hj = isNextRefraction && !(*ma).thinWalled;
+hn = isNextRefraction && !(*ma).thinWalled;
 (*aa).isNextRefraction = isNextRefraction;
 
 
@@ -417,8 +417,8 @@ if (bl) {
 if (HAS_MEDIUM) {
 
 
-if (!bl && hj && (*ma).mediumType > 0) {
-if (rF >= 0.0) {
+if (!bl && hn && (*ma).mediumType > 0) {
+if (rN >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;

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

@@ -11,21 +11,21 @@ export default /*wgsl*/ `
 const SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
 fn sampleShadowCatcher(si: ad, bounce: i32, aa: ptr<function, Path>) {
-let oK = -(*aa).ray.d;
+let oS = -(*aa).ray.d;
 
 
 if (rtUniform.lightChoiceCount > 0) {
 var shadow = 0.0;
 for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 var lightSample: LightSampleRec;
-let lc = vec3f(fk(qV(candidate, 1u)), dz(qV(candidate, 0u)));
-sampleLight(si.position, lc, &lightSample, false);
+let ln = vec3f(fp(rd(candidate, 1u)), dz(rd(candidate, 0u)));
+sampleLight(si.position, ln, &lightSample, false);
 let lightDir = lightSample.direction;
 let cosThetaL = dot(si.normal, lightDir);
-let pv = dot(si.normal, oK) * cosThetaL;
-if (lightSample.pdf > 0.0 && pv >= 0.0) {
+let pM = dot(si.normal, oS) * cosThetaL;
+if (lightSample.pdf > 0.0 && pM >= 0.0) {
 var ray: Ray;
-iw(&ray, si.position + EPS * lightDir, lightDir);
+iC(&ray, si.position + EPS * lightDir, lightDir);
 if (ex(ray, lightSample.dist - EPS, si.triangleIndex)) {
 shadow += 1.0;
 }