@meimu/mutracer 0.1.2 → 0.1.4

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

@@ -4,7 +4,7 @@
 export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 
-struct mO {
+struct nf {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,49 +16,49 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn qe(
+fn qq(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gw: bool,
+gE: bool,
 ca: u32,
-aW: u32,
-gd: ptr<function, mO>
+aV: u32,
+gi: ptr<function, nf>
 ) -> bool {
-(*gd).valid = false;
-(*gd).lightSelectionPmf = 0.0;
-(*gd).risTarget = 0.0;
-let kZ = vec3f(fk(qR(ca, 1u)), dz(qR(ca, 0u)));
+(*gi).valid = false;
+(*gi).lightSelectionPmf = 0.0;
+(*gi).risTarget = 0.0;
+let ln = vec3f(fo(rd(ca, 1u)), dz(rd(ca, 0u)));
 
 var lightSample: LightSampleRec;
-mv(
+mI(
 (*si).position,
-kZ,
+ln,
 ca,
-aW,
+aV,
 &lightSample
 );
 var Li = lightSample.emission;
 
 let lightDir = lightSample.direction;
-let oH = -(*aa).ray.d;
-let fd = lightSample.pdf;
+let oT = -(*aa).ray.d;
+let fg = lightSample.pdf;
 let lightSelectionPmf = lightSample.selectionPmf;
 
 
 ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
-if (gw && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
+if (gE && 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 (gw) {
+if (gE) {
 
 
 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(oH, lightDir),
+dot(oT, 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 ml: Ray;
-var hc = (*si).position + EPS * lightDir;
-if (gw) {
-hc = rD((*si).position, (*si).faceNormal, lightDir);
+var mA: Ray;
+var hi = (*si).position + EPS * lightDir;
+if (gE) {
+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 hP = dot(geometricNormal, lightDir);
-let oo = select(
-clamp(1.0 - hP / bZ, 0.0, 1.0),
+let hS = dot(geometricNormal, lightDir);
+let oC = select(
+clamp(1.0 - hS / bZ, 0.0, 1.0),
 clamp(
-2.0 - (hP + dr) / bZ,
+2.0 - (hS + dr) / bZ,
 0.0,
 1.0
 ),
 dr < bZ
 );
-hc += (*si).shadowOffset * oo;
+hi += (*si).shadowOffset * oC;
 }
 
 
 
 
-var lE = lightDir;
-var mC = lightSample.dist - EPS;
+var lR = lightDir;
+var mP = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let sM =
+let sY =
 (*si).position + lightSample.direction * lightSample.dist;
-let pS = sM + EPS * lightSample.normal;
-let qd = pS - hc;
-mC = length(qd);
-lE = normalize(qd);
+let qe = sY + EPS * lightSample.normal;
+let qp = qe - hi;
+mP = length(qp);
+lR = normalize(qp);
 }
-iw(&ml, hc, lE);
+iC(&mA, hi, lR);
 
 
 
 
-if (gw && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hE(ml);
+if (gE && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
+let background = hH(mA);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
@@ -132,78 +132,78 @@ Li = ai(Li, (*si).wavelength);
 
 
 
-let eW = select(
-tk(fd, scatteringPdf),
+let fa = select(
+tC(fg, scatteringPdf),
 1.0,
 lightSample.isDelta
 );
-if (eW > 0.0) {
-let kh = Li * f / fd * (*aa).beta;
-(*gd).risTarget = max(
-dot(max(kh * lightSelectionPmf, vec3f(0.0)), luminance),
+if (fa > 0.0) {
+let kq = Li * f / fg * (*aa).beta;
+(*gi).risTarget = max(
+dot(max(kq * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*gd).ray = ml;
-(*gd).maxDistance = mC;
-(*gd).triangleIndex = (*si).triangleIndex;
-(*gd).contribution = eW * kh;
-(*gd).lightSelectionPmf = lightSelectionPmf;
-(*gd).valid = true;
+(*gi).ray = mA;
+(*gi).maxDistance = mP;
+(*gi).triangleIndex = (*si).triangleIndex;
+(*gi).contribution = fa * kq;
+(*gi).lightSelectionPmf = lightSelectionPmf;
+(*gi).valid = true;
 return true;
 }
 return false;
 }
 
-fn mG(
+fn mU(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gw: bool
+gE: bool
 ) {
-let aW = jO();
-var selected: mO;
+let aV = jX();
+var selected: nf;
 selected.valid = false;
-var mw = 0.0;
-var ls = 0.0;
+var mJ = 0.0;
+var lI = 0.0;
 
 
-for (var ca = 0u; ca < aW; ca++) {
-var candidate: mO;
-let oW = qe(
-si, ma, prepared, aa, ffnormal, gw,
-ca, aW, &candidate);
-if (aW == 1u) {
-if (!oW) { return; }
+for (var ca = 0u; ca < aV; ca++) {
+var candidate: nf;
+let pj = qq(
+si, ma, prepared, aa, ffnormal, gE,
+ca, aV, &candidate);
+if (aV == 1u) {
+if (!pj) { return; }
 selected = candidate;
 break;
 }
-if (!oW) { continue; }
-let ka = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
-if (!(ka > 0.0) || ka != ka) { continue; }
-ls += ka;
+if (!pj) { continue; }
+let kj = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kj > 0.0) || kj != kj) { continue; }
+lI += kj;
 if (!selected.valid ||
-po(ca) * ls <= ka) {
+pK(ca) * lI <= kj) {
 selected = candidate;
-mw = candidate.risTarget;
+mJ = candidate.risTarget;
 }
 }
-var qC = 1.0;
-if (aW > 1u) {
-if (!selected.valid || mw <= 0.0) { return; }
+var qP = 1.0;
+if (aV > 1u) {
+if (!selected.valid || mJ <= 0.0) { return; }
 
 
-qC = selected.lightSelectionPmf * ls /
-(f32(aW) * mw);
+qP = selected.lightSelectionPmf * lI /
+(f32(aV) * mJ);
 }
 if (selected.valid &&
 !ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * qC;
+(*aa).li += selected.contribution * qP;
 }
 }
 
-fn pc(
+fn pp(
 si: ptr<function, ad>,
 aa: ptr<function, Path>
 ) -> f32 {
@@ -215,54 +215,54 @@ let samplingLuminance = dot(
 materialsBuffer[(*si).materialIndex].emission,
 luminance
 );
-let oZ = dot((*si).faceNormal, -(*aa).ray.d);
-if (samplingLuminance <= 0.0 || oZ <= 0.0) {
+let pm = dot((*si).faceNormal, -(*aa).ray.d);
+if (samplingLuminance <= 0.0 || pm <= 0.0) {
 return 1.0;
 }
-let rL = distance((*si).position, (*aa).ray.o);
-let fd = samplingLuminance / rtUniform.lightWeightTotal *
-rL * rL / max(oZ, 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 fW((*aa).scatteringPdf, fg);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fB(input: vec3f, tc: vec3f, view: vec3f) -> vec3f {
-let qL = dot(tc, view) >= 0.0;
-let uc = select(-tc, tc, qL);
-let qK = select(-input, input, qL);
-if (dot(input, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return uc; }
-return qK;
+fn fE(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 lO(
+fn mc(
 si: ptr<function, ad>,
 ma: ptr<function, J>,
 aa: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
 let bC = (*si).faceNormal;
-let mr = (*si).normal;
+let mF = (*si).normal;
 ` : ''}
-var rA: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var sq: 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 (rA < 0.0) {
+if (rN < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-rA = -rA;
+rN = -rN;
 }
-if (sq < 0.0) {
+if (sG < 0.0) {
 (*si).normal = -(*si).normal;
-sq = -sq;
+sG = -sG;
 }
 }
 
 
-var pI: bool = rA >= 0.0 && sq < 0.0;
-var ndv: f32 = select(sq, rA, pI);
-var N: vec3f = select((*si).normal, (*si).faceNormal, pI);
+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,61 +271,61 @@ 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(mr, 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 ga = dot(bC, view);
+(*ma).geometricNormal = select(-bC, bC, ga >= 0.0);
+ffnormal = fE(mF, bC, view);
+(*ma).coatNormal = fE((*si).coatNormal, bC, view);
+(*ma).inside = ga <= 0.0 && !(*ma).thinWalled;
+(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, ga > 0.0 || (*ma).thinWalled);
 }
 ` : ''}
 
 (*aa).scatteringIsDelta = false;
 var bl = false;
-var hj = false;
+var hn = false;
 let mediumType = (*si).mediumType;
 
 var scatteringPdf: f32;
-var cF: vec3f;
+var cG: vec3f;
 
 if (HAS_MEDIUM) {
 let d = distance((*si).position, (*aa).ray.o);
-let ne = (*aa).ray.o;
+let nv = (*aa).ray.o;
 let extinction = (*si).mediumExtinction;
 let scattering = min((*si).mediumScattering, extinction);
-let sl = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sl > 0.0) {
+let sC = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sC > 0.0) {
 
 
-let mT = min(i32(dz(cv(MEDIUM_CHANNEL)) * 3.0), 2);
-let fA = extinction[mT];
-let ic = select(
+let nk = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+let fD = extinction[nk];
+let ih = select(
 d,
-min(-log(max(dz(cv(MEDIUM_DISTANCE)), 1e-7)) / fA, d),
-fA > 0.0
+min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fD, d),
+fD > 0.0
 );
-bl = ic < d;
-let ew = exp(-extinction * ic);
-let nM = select(
+bl = ih < d;
+let ew = exp(-extinction * ih);
+let oa = select(
 ew,
 extinction * ew,
 bl
 );
-let nt = max((nM.x + nM.y + nM.z) / 3.0, 1e-8);
+let nL = max((oa.x + oa.y + oa.z) / 3.0, 1e-8);
 if (bl) {
-(*aa).beta *= ew * scattering / nt;
+(*aa).beta *= ew * scattering / nL;
 
-(*aa).ray.o = ne + ic * (*aa).ray.d;
+(*aa).ray.o = nv + ih * (*aa).ray.d;
 (*si).position = (*aa).ray.o;
 }
 else {
-(*aa).beta *= ew / nt;
+(*aa).beta *= ew / nL;
 }
 }
 }
 
 if (!bl) {
-(*aa).li += pc(si, aa) * (*ma).emission * (*aa).beta;
+(*aa).li += pp(si, aa) * (*ma).emission * (*aa).beta;
 }
 if ((*ma).materialType == UNLIT) {
 (*aa).abort = true;
@@ -341,18 +341,18 @@ ${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);
 }
-mG(si, *ma, prepared, aa, ffnormal, !bl);
+mU(si, *ma, prepared, aa, ffnormal, !bl);
 if (bl) {
 
-cF = fl(
+cG = fp(
 -(*aa).ray.d,
 (*si).mediumAnisotropy,
-fk(cv(PHASE_DIRECTION))
+fo(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
-dot(cF, -(*aa).ray.d),
+dot(cG, -(*aa).ray.d),
 (*si).mediumAnisotropy
 );
 }
@@ -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 qw = 0.0;
-let ue = vec3f(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
-var gR = vec3f(0.0);
+var qI = 0.0;
+let ur = vec3f(fo(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+var gX = vec3f(0.0);
 let f = dv(
 prepared,
-ue,
-&cF,
+ur,
+&cG,
 &scatteringPdf,
 &isNextRefraction,
 &aA,
-&aT,
+&aS,
 &bE,
 &aR,
-&qw,
-&gR
+&qI,
+&gX
 );
 
 
@@ -385,7 +385,7 @@ ue,
 
 if (!(scatteringPdf > 0.0) ||
 !all(f == f) || !all(abs(f) < vec3f(3.402823e38)) ||
-dot(cF, cF) < 0.5) {
+dot(cG, cG) < 0.5) {
 (*aa).scatteringPdf = 0.0;
 (*aa).abort = true;
 return;
@@ -397,17 +397,17 @@ 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;
 
 
-(*aa).ray.o = (*si).position + EPS * cF;
+(*aa).ray.o = (*si).position + EPS * cG;
 ${hasCoatNormals ? /* wgsl */ `
-if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bC, bC, dot(bC, cF) >= 0.0); }
+if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bC, bC, dot(bC, cG) >= 0.0); }
 ` : ''}
 }
 (*aa).scatteringPdf = scatteringPdf;
-(*aa).ray.d = cF;
+(*aa).ray.d = cG;
 if (bl) {
 (*aa).isNextRefraction = false;
 }
@@ -417,8 +417,8 @@ if (bl) {
 if (HAS_MEDIUM) {
 
 
-if (!bl && hj && (*ma).mediumType > 0) {
-if (rA >= 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 oH = -(*aa).ray.d;
+let oT = -(*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 kZ = vec3f(fk(qR(candidate, 1u)), dz(qR(candidate, 0u)));
-sampleLight(si.position, kZ, &lightSample, false);
+let ln = vec3f(fo(rd(candidate, 1u)), dz(rd(candidate, 0u)));
+sampleLight(si.position, ln, &lightSample, false);
 let lightDir = lightSample.direction;
 let cosThetaL = dot(si.normal, lightDir);
-let pq = dot(si.normal, oH) * cosThetaL;
-if (lightSample.pdf > 0.0 && pq >= 0.0) {
+let pM = dot(si.normal, oT) * 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;
 }