@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -4,7 +4,7 @@
 export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 
-struct mO {
+struct mR {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -16,26 +16,26 @@ lightSelectionPmf: f32,
 valid: bool,
 }
 
-fn qe(
+fn qi(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gw: bool,
+gy: bool,
 ca: u32,
 aW: u32,
-gd: ptr<function, mO>
+ge: ptr<function, mR>
 ) -> bool {
-(*gd).valid = false;
-(*gd).lightSelectionPmf = 0.0;
-(*gd).risTarget = 0.0;
-let kZ = vec3f(fk(qR(ca, 1u)), dz(qR(ca, 0u)));
+(*ge).valid = false;
+(*ge).lightSelectionPmf = 0.0;
+(*ge).risTarget = 0.0;
+let lc = vec3f(fk(qV(ca, 1u)), dz(qV(ca, 0u)));
 
 var lightSample: LightSampleRec;
-mv(
+my(
 (*si).position,
-kZ,
+lc,
 ca,
 aW,
 &lightSample
@@ -43,13 +43,13 @@ aW,
 var Li = lightSample.emission;
 
 let lightDir = lightSample.direction;
-let oH = -(*aa).ray.d;
+let oK = -(*aa).ray.d;
 let fd = 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 (gy && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
 
 if (fd <= 0.0 || lightSelectionPmf <= 0.0 ||
 max(max(Li.x, Li.y), Li.z) <= 0.0) {
@@ -58,7 +58,7 @@ return false;
 
 var scatteringPdf = 0.0;
 var f = vec3f(0.0);
-if (gw) {
+if (gy) {
 
 
 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(oK, 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 mp: Ray;
+var hd = (*si).position + EPS * lightDir;
+if (gy) {
+hd = rI((*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 hO = dot(geometricNormal, lightDir);
+let ot = select(
+clamp(1.0 - hO / bZ, 0.0, 1.0),
 clamp(
-2.0 - (hP + dr) / bZ,
+2.0 - (hO + dr) / bZ,
 0.0,
 1.0
 ),
 dr < bZ
 );
-hc += (*si).shadowOffset * oo;
+hd += (*si).shadowOffset * ot;
 }
 
 
 
 
-var lE = lightDir;
-var mC = lightSample.dist - EPS;
+var lH = lightDir;
+var mF = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
-let sM =
+let sR =
 (*si).position + lightSample.direction * lightSample.dist;
-let pS = sM + EPS * lightSample.normal;
-let qd = pS - hc;
-mC = length(qd);
-lE = normalize(qd);
+let pW = sR + EPS * lightSample.normal;
+let qh = pW - hd;
+mF = length(qh);
+lH = normalize(qh);
 }
-iw(&ml, hc, lE);
+iw(&mp, hd, lH);
 
 
 
 
-if (gw && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hE(ml);
+if (gy && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
+let background = hD(mp);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
@@ -133,77 +133,77 @@ Li = ai(Li, (*si).wavelength);
 
 
 let eW = select(
-tk(fd, scatteringPdf),
+tq(fd, 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),
+let kj = Li * f / fd * (*aa).beta;
+(*ge).risTarget = max(
+dot(max(kj * 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;
+(*ge).ray = mp;
+(*ge).maxDistance = mF;
+(*ge).triangleIndex = (*si).triangleIndex;
+(*ge).contribution = eW * kj;
+(*ge).lightSelectionPmf = lightSelectionPmf;
+(*ge).valid = true;
 return true;
 }
 return false;
 }
 
-fn mG(
+fn mJ(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gw: bool
+gy: bool
 ) {
-let aW = jO();
-var selected: mO;
+let aW = jQ();
+var selected: mR;
 selected.valid = false;
-var mw = 0.0;
-var ls = 0.0;
+var mz = 0.0;
+var lv = 0.0;
 
 
 for (var ca = 0u; ca < aW; ca++) {
-var candidate: mO;
-let oW = qe(
-si, ma, prepared, aa, ffnormal, gw,
+var candidate: mR;
+let pa = qi(
+si, ma, prepared, aa, ffnormal, gy,
 ca, aW, &candidate);
 if (aW == 1u) {
-if (!oW) { return; }
+if (!pa) { 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 (!pa) { continue; }
+let kc = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(kc > 0.0) || kc != kc) { continue; }
+lv += kc;
 if (!selected.valid ||
-po(ca) * ls <= ka) {
+ps(ca) * lv <= kc) {
 selected = candidate;
-mw = candidate.risTarget;
+mz = candidate.risTarget;
 }
 }
-var qC = 1.0;
+var qG = 1.0;
 if (aW > 1u) {
-if (!selected.valid || mw <= 0.0) { return; }
+if (!selected.valid || mz <= 0.0) { return; }
 
 
-qC = selected.lightSelectionPmf * ls /
-(f32(aW) * mw);
+qG = selected.lightSelectionPmf * lv /
+(f32(aW) * mz);
 }
 if (selected.valid &&
 !ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
-(*aa).li += selected.contribution * qC;
+(*aa).li += selected.contribution * qG;
 }
 }
 
-fn pc(
+fn pg(
 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 pd = dot((*si).faceNormal, -(*aa).ray.d);
+if (samplingLuminance <= 0.0 || pd <= 0.0) {
 return 1.0;
 }
-let rL = distance((*si).position, (*aa).ray.o);
+let rQ = distance((*si).position, (*aa).ray.o);
 let fd = samplingLuminance / rtUniform.lightWeightTotal *
-rL * rL / max(oZ, 1e-8);
+rQ * rQ / max(pd, 1e-8);
 return fS((*aa).scatteringPdf, fd);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fB(input: vec3f, tc: vec3f, view: vec3f) -> vec3f {
-let qL = dot(tc, view) >= 0.0;
-let ub = select(-tc, tc, qL);
-let qK = select(-input, input, qL);
-if (dot(input, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
-return qK;
+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 lO(
+fn lR(
 si: ptr<function, ad>,
 ma: ptr<function, J>,
 aa: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
 let bC = (*si).faceNormal;
-let mr = (*si).normal;
+let mv = (*si).normal;
 ` : ''}
-var rA: f32 = -dot((*si).faceNormal, (*aa).ray.d);
-var sq: f32 = -dot((*si).normal, (*aa).ray.d);
+var rF: f32 = -dot((*si).faceNormal, (*aa).ray.d);
+var sw: f32 = -dot((*si).normal, (*aa).ray.d);
 if (((*ma).transmissionWeight > 0.0 || (*ma).subsurfaceWeight > 0.0) && (*ma).thinWalled) {
 
-if (rA < 0.0) {
+if (rF < 0.0) {
 (*si).faceNormal = -(*si).faceNormal;
-rA = -rA;
+rF = -rF;
 }
-if (sq < 0.0) {
+if (sw < 0.0) {
 (*si).normal = -(*si).normal;
-sq = -sq;
+sw = -sw;
 }
 }
 
 
-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 pM: bool = rF >= 0.0 && sw < 0.0;
+var ndv: f32 = select(sw, rF, pM);
+var N: vec3f = select((*si).normal, (*si).faceNormal, pM);
 
 (*ma).inside = ndv <= 0.0 && !(*ma).thinWalled;
 
@@ -273,7 +273,7 @@ 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);
+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);
@@ -286,46 +286,46 @@ var hj = 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 nh = (*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 sr = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sr > 0.0) {
 
 
-let mT = min(i32(dz(cv(MEDIUM_CHANNEL)) * 3.0), 2);
-let fA = extinction[mT];
-let ic = select(
+let mW = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+let fA = extinction[mW];
+let ib = select(
 d,
-min(-log(max(dz(cv(MEDIUM_DISTANCE)), 1e-7)) / fA, d),
+min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fA, d),
 fA > 0.0
 );
-bl = ic < d;
-let ew = exp(-extinction * ic);
-let nM = select(
+bl = ib < d;
+let ew = exp(-extinction * ib);
+let nP = select(
 ew,
 extinction * ew,
 bl
 );
-let nt = max((nM.x + nM.y + nM.z) / 3.0, 1e-8);
+let nA = max((nP.x + nP.y + nP.z) / 3.0, 1e-8);
 if (bl) {
-(*aa).beta *= ew * scattering / nt;
+(*aa).beta *= ew * scattering / nA;
 
-(*aa).ray.o = ne + ic * (*aa).ray.d;
+(*aa).ray.o = nh + ib * (*aa).ray.d;
 (*si).position = (*aa).ray.o;
 }
 else {
-(*aa).beta *= ew / nt;
+(*aa).beta *= ew / nA;
 }
 }
 }
 
 if (!bl) {
-(*aa).li += pc(si, aa) * (*ma).emission * (*aa).beta;
+(*aa).li += pg(si, aa) * (*ma).emission * (*aa).beta;
 }
 if ((*ma).materialType == UNLIT) {
 (*aa).abort = true;
@@ -343,16 +343,16 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 ` : /* wgsl */ ``}
 prepared = eG((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
 }
-mG(si, *ma, prepared, aa, ffnormal, !bl);
+mJ(si, *ma, prepared, aa, ffnormal, !bl);
 if (bl) {
 
-cF = fl(
+cG = fl(
 -(*aa).ray.d,
 (*si).mediumAnisotropy,
-fk(cv(PHASE_DIRECTION))
+fk(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
-dot(cF, -(*aa).ray.d),
+dot(cG, -(*aa).ray.d),
 (*si).mediumAnisotropy
 );
 }
@@ -363,21 +363,21 @@ var aA = 1.0;
 var aT = false;
 var bE = true;
 var aR = u32(OPENPBR_LOBE_DIFFUSE);
-var qw = 0.0;
-let ud = vec3f(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
-var gR = vec3f(0.0);
+var qA = 0.0;
+let uj = vec3f(fk(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+var gT = vec3f(0.0);
 let f = dv(
 prepared,
-ud,
-&cF,
+uj,
+&cG,
 &scatteringPdf,
 &isNextRefraction,
 &aA,
 &aT,
 &bE,
 &aR,
-&qw,
-&gR
+&qA,
+&gT
 );
 
 
@@ -385,7 +385,7 @@ ud,
 
 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;
@@ -401,13 +401,13 @@ hj = 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;
 }
@@ -418,7 +418,7 @@ if (HAS_MEDIUM) {
 
 
 if (!bl && hj && (*ma).mediumType > 0) {
-if (rA >= 0.0) {
+if (rF >= 0.0) {
 (*si).mediumType = (*ma).mediumType;
 (*si).mediumExtinction = (*ma).mediumExtinction;
 (*si).mediumScattering = (*ma).mediumScattering;

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

@@ -11,19 +11,19 @@ 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 oK = -(*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 lc = vec3f(fk(qV(candidate, 1u)), dz(qV(candidate, 0u)));
+sampleLight(si.position, lc, &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 pv = dot(si.normal, oK) * cosThetaL;
+if (lightSample.pdf > 0.0 && pv >= 0.0) {
 var ray: Ray;
 iw(&ray, si.position + EPS * lightDir, lightDir);
 if (ex(ray, lightSample.dist - EPS, si.triangleIndex)) {