@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -2,16 +2,16 @@
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
 import { glsl } from '../../shader.js';
 export default glsl `
-vec3 mG(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gw) {
-float mp = 1.0;
-vec3 kZ = vec3(fk(cv(LIGHT_POSITION)), dz(cv(LIGHT_SELECT)));
+vec3 mJ(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gy) {
+float mt = 1.0;
+vec3 lc = vec3(fk(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, kZ, lightSample, false);
+sampleLight(si.position, lc, lightSample, false);
 lightSample.emission = ai(lightSample.emission, bf);
 
 vec3 lightDir = lightSample.direction;
-vec3 oH = -aa.ray.d;
+vec3 oK = -aa.ray.d;
 float fd = lightSample.pdf;
 
 
@@ -19,7 +19,7 @@ float fd = lightSample.pdf;
 
 float cosThetaL = dot(ffnormal, lightDir);
 #ifdef NUM_COAT_NORMAL_MAPS
-if (gw && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+if (gy && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
 #endif
 
 if (fd <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
@@ -28,7 +28,7 @@ return vec3(0.0);
 
 float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
-if (gw) {
+if (gy) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
@@ -36,7 +36,7 @@ f = bI(prepared, lightDir, scatteringPdf);
 }
 else {
 scatteringPdf = bD(
-dot(oH, lightDir),
+dot(oK, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,9 +46,9 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray ml;
-vec3 hc = si.position + EPS * lightDir;
-if (gw) {
+Ray mp;
+vec3 hd = si.position + EPS * lightDir;
+if (gy) {
 const float bZ = 0.1;
 float dr = dot(si.normal, lightDir);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -56,26 +56,26 @@ if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
 #endif
 vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
 dr = abs(dr);
-float hP = dot(geometricNormal, lightDir);
-float oo = dr < bZ
+float hO = dot(geometricNormal, lightDir);
+float ot = dr < bZ
 ? clamp(
-2.0 - (hP + dr) / bZ,
+2.0 - (hO + dr) / bZ,
 0.0,
 1.0
 )
-: clamp(1.0 - hP / bZ, 0.0, 1.0);
-hc += si.shadowOffset * oo;
+: clamp(1.0 - hO / bZ, 0.0, 1.0);
+hd += si.shadowOffset * ot;
 }
-iw(ml, hc, lightDir);
-if (ex(ml, lightSample.dist - EPS, si.triangleIndex)) {
+iw(mp, hd, lightDir);
+if (ex(mp, lightSample.dist - EPS, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (gw && cosThetaL < 0.0 && kZ.z < envLightSelectionPmf) {
-vec4 background = cw(ml.o, lightDir);
+if (gy && cosThetaL < 0.0 && lc.z < envLightSelectionPmf) {
+vec4 background = cx(mp.o, lightDir);
 lightSample.emission = ai(background.rgb * background.a, bf);
 }
 #endif
@@ -84,45 +84,45 @@ lightSample.emission = ai(background.rgb * background.a, bf);
 
 float eW = lightSample.isDelta
 ? 1.0
-: aF(fd, scatteringPdf);
+: aG(fd, scatteringPdf);
 return eW > 0.0
 ? eW * lightSample.emission * f / fd
 : vec3(0.0);
 }
 
 #ifdef NUM_COAT_NORMAL_MAPS
-vec3 fB(vec3 pk, vec3 tc, vec3 view) {
-bool qL = dot(tc, view) >= 0.0;
-vec3 ub = qL ? tc : -tc;
-vec3 qK = qL ? pk : -pk;
-if (dot(pk, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
-return qK;
+vec3 fB(vec3 po, vec3 th, vec3 view) {
+bool qQ = dot(th, view) >= 0.0;
+vec3 uh = qQ ? th : -th;
+vec3 qP = qQ ? po : -po;
+if (dot(po, th) <= 0.0 || dot(qP, view) <= 1e-6) { return uh; }
+return qP;
 }
 #endif
-void lO(inout ad si, J mat, inout Path aa) {
-vec3 ud = vec3(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
+void lR(inout ad si, J mat, inout Path aa) {
+vec3 uj = vec3(fk(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
 #ifdef NUM_COAT_NORMAL_MAPS
 vec3 bC = si.faceNormal;
-vec3 mr = si.normal;
+vec3 mv = si.normal;
 #endif
-float rA = -dot(si.faceNormal, aa.ray.d);
-float sq = -dot(si.normal, aa.ray.d);
+float rF = -dot(si.faceNormal, aa.ray.d);
+float sw = -dot(si.normal, aa.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.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;
 }
 }
 
 
-bool pI = rA >= 0.0 && sq < 0.0;
-float ndv = pI ? rA : sq;
-vec3 normal = pI ? si.faceNormal : si.normal;
+bool pM = rF >= 0.0 && sw < 0.0;
+float ndv = pM ? rF : sw;
+vec3 normal = pM ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -133,7 +133,7 @@ if (mat.coatNormalEnabled) {
 vec3 view = -aa.ray.d;
 float fW = dot(bC, view);
 mat.geometricNormal = fW >= 0.0 ? bC : -bC;
-ffnormal = fB(mr, bC, view);
+ffnormal = fB(mv, bC, view);
 mat.coatNormal = fB(si.coatNormal, bC, view);
 mat.inside = fW <= 0.0 && !mat.thinWalled;
 mat.relativeIor = (fW > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
@@ -142,7 +142,7 @@ mat.relativeIor = (fW > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.spe
 
 
 float scatteringPdf;
-vec3 cF;
+vec3 cG;
 aa.scatteringIsDelta = false;
 bool bl = false;
 bool hj = false;
@@ -151,49 +151,49 @@ ag prepared;
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, aa.ray.o);
-vec3 ne = aa.ray.o;
+vec3 nh = aa.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float sl = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sl > 0.0) {
+float sr = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sr > 0.0) {
 
 
 
 
-int mT = min(int(dz(cv(MEDIUM_CHANNEL)) * 3.0), 2);
-float fA = extinction[mT];
-float ic = fA > 0.0
-? min(-log(max(dz(cv(MEDIUM_DISTANCE)), 1e-7)) / fA, d)
+int mW = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+float fA = extinction[mW];
+float ib = fA > 0.0
+? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fA, d)
 : d;
-bl = ic < d;
-vec3 ew = exp(-extinction * ic);
-vec3 nM = bl
+bl = ib < d;
+vec3 ew = exp(-extinction * ib);
+vec3 nP = bl
 ? extinction * ew
 : ew;
-float nt = max(
-(nM.x + nM.y + nM.z) / 3.0,
+float 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;
-aa.li += mG(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += mJ(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-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
 );
 }
 else {
-aa.beta *= ew / nt;
+aa.beta *= ew / nA;
 }
 }
 #endif
@@ -205,22 +205,22 @@ if (mat.materialType == UNLIT) {
 aa.abort = true;
 return;
 }
-vec3 pG = vec3(0.0);
+vec3 pK = vec3(0.0);
 #ifdef USE_TANGENT
-pG = si.tangent;
+pK = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = eG(pG, mat, -aa.ray.d, ffnormal);
-aa.li += mG(si, mat, prepared, aa, ffnormal, true) * aa.beta;
+prepared = eG(pK, mat, -aa.ray.d, ffnormal);
+aa.li += mJ(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
 vec3 f = dv(
 prepared,
-ud,
-cF,
+uj,
+cG,
 scatteringPdf,
 isNextRefraction
 );
@@ -232,7 +232,7 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 
 
 if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||
-dot(cF, cF) < 0.5) {
+dot(cG, cG) < 0.5) {
 aa.scatteringPdf = 0.0;
 aa.abort = true;
 return;
@@ -243,14 +243,14 @@ isNextRefraction;
 aa.isNextRefraction = isNextRefraction;
 
 
-aa.ray.o = si.position + EPS * cF;
+aa.ray.o = si.position + EPS * cG;
 #ifdef NUM_COAT_NORMAL_MAPS
-if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cF) >= 0.0 ? bC : -bC); }
+if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0 ? bC : -bC); }
 #endif
 }
 
 aa.scatteringPdf = scatteringPdf;
-iw(aa.ray, aa.ray.o, cF);
+iw(aa.ray, aa.ray.o, cG);
 if (bl) {
 aa.isNextRefraction = false;
 }
@@ -260,7 +260,7 @@ aa.fromEye = false;
 
 
 if (!bl && hj && mat.mediumType > 0) {
-if (rA >= 0.0) {
+if (rF >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;

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

@@ -11,33 +11,33 @@ export default glsl `
 
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint km(uint candidate, uint slot) {
-return candidate == 0u ? cv(slot) : cv(9u + (candidate - 1u) * 3u + slot);
+uint ko(uint candidate, uint slot) {
+return candidate == 0u ? cw(slot) : cw(9u + (candidate - 1u) * 3u + slot);
 }
 
 void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
-vec3 oH = -aa.ray.d;
+vec3 oK = -aa.ray.d;
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
 float visibility = 0.0;
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 kZ = vec3(
-fk(km(candidate, LIGHT_POSITION)),
-dz(km(candidate, LIGHT_SELECT))
+vec3 lc = vec3(
+fk(ko(candidate, LIGHT_POSITION)),
+dz(ko(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, kZ, lightSample, false);
+sampleLight(si.position, lc, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pq = dot(si.normal, oH) * cosThetaL;
-bool mp = false;
-if (pq >= 0.0) {
+float pv = dot(si.normal, oK) * cosThetaL;
+bool mt = false;
+if (pv >= 0.0) {
 Ray ray;
 iw(ray, si.position + EPS * lightDir, lightDir);
-mp = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+mt = ex(ray, lightSample.dist - EPS, si.triangleIndex);
 }
-visibility += mp ? 0.0 : 1.0;
+visibility += mt ? 0.0 : 1.0;
 }
 
 aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);

package/lib/renderer/glsl/chunks/sampling.glsl.js

@@ -5,28 +5,28 @@ export default glsl `
 
 
 vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
-vec3 qY = vec3(alpha, 1.0);
-vec3 ge = normalize(qY * view);
-float tU = min(ge.z, 1.0);
-float qD = 1.0 + tU;
-float qT = (1.0 - samplePoint.y) * qD;
-float rE = samplePoint.y * qD;
-float st = qT + (1.0 - tU);
-float fi = sqrt(max(0.0, st * rE));
+vec3 rc = vec3(alpha, 1.0);
+vec3 gf = normalize(rc * view);
+float ua = min(gf.z, 1.0);
+float qH = 1.0 + ua;
+float qX = (1.0 - samplePoint.y) * qH;
+float rJ = samplePoint.y * qH;
+float sA = qX + (1.0 - ua);
+float fi = sqrt(max(0.0, sA * rJ));
 float br = TWOPI * samplePoint.x;
-vec3 lt = vec3(
-ge.x + fi * cos(br),
-ge.y + fi * sin(br),
-qT
+vec3 lw = vec3(
+gf.x + fi * cos(br),
+gf.y + fi * sin(br),
+qX
 );
-return normalize(qY * lt);
+return normalize(rc * lw);
 }
 
-float gE(vec3 oa, vec2 alpha) {
+float gG(vec3 od, vec2 alpha) {
 vec3 hm = vec3(
-oa.x / alpha.x,
-oa.y / alpha.y,
-oa.z
+od.x / alpha.x,
+od.y / alpha.y,
+od.z
 );
 float ap = dot(hm, hm);
 return 1.0 / (
@@ -39,10 +39,10 @@ float eE = abs(direction.z);
 if (eE <= 1e-8) {
 return 0.0;
 }
-vec2 hZ = alpha * direction.xy;
-float lu = dot(hZ, hZ)
+vec2 hY = alpha * direction.xy;
+float lA = dot(hY, hY)
 / (eE * eE);
-return 2.0 / (1.0 + sqrt(1.0 + lu));
+return 2.0 / (1.0 + sqrt(1.0 + lA));
 }
 
 float aE(float au) {
@@ -50,25 +50,25 @@ float dg = clamp(1.0 - au, 0.0, 1.0);
 return pow(dg, 5.0);
 }
 
-float ct(float L, float cJ) {
+float cu(float L, float cJ) {
 float iu = clamp(abs(L), 0.0, 1.0);
-float kc = cJ * cJ
+float ke = cJ * cJ
 * max(0.0, 1.0 - iu * iu);
-if (kc >= 1.0) {
+if (ke >= 1.0) {
 return 1.0;
 }
 
-float lH = sqrt(max(0.0, 1.0 - kc));
-float ba = (iu - cJ * lH)
-/ max(iu + cJ * lH, 1e-8);
-float pr = (cJ * iu - lH)
-/ max(cJ * iu + lH, 1e-8);
+float lK = sqrt(max(0.0, 1.0 - ke));
+float ba = (iu - cJ * lK)
+/ max(iu + cJ * lK, 1e-8);
+float pw = (cJ * iu - lK)
+/ max(cJ * iu + lK, 1e-8);
 return 0.5 * (
-ba * ba + pr * pr
+ba * ba + pw * pw
 );
 }
 
-vec2 gc(vec2 samplePoint) {
+vec2 gd(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -88,35 +88,35 @@ return radius * vec2(cos(angle), sin(angle));
 }
 
 vec3 bi(vec2 samplePoint) {
-vec2 kv = gc(samplePoint);
+vec2 kx = gd(samplePoint);
 return vec3(
-kv,
-sqrt(max(0.0, 1.0 - dot(kv, kv)))
+kx,
+sqrt(max(0.0, 1.0 - dot(kx, kx)))
 );
 }
 
-float aF(float pe, float nA) {
-float scale = max(pe, nA);
+float aG(float pi, float nD) {
+float scale = max(pi, nD);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(pe, nA) / scale;
-vec2 oD = normalized * normalized;
-return oD.x / (oD.x + oD.y);
+vec2 normalized = vec2(pi, nD) / scale;
+vec2 oG = normalized * normalized;
+return oG.x / (oG.x + oG.y);
 }
 
-void aK(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
-float ig = normal.z >= 0.0 ? 1.0 : -1.0;
-float dW = -1.0 / (ig + normal.z);
+void aL(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
+float ie = normal.z >= 0.0 ? 1.0 : -1.0;
+float dW = -1.0 / (ie + normal.z);
 float xy = normal.x * normal.y * dW;
 tangent = vec3(
-1.0 + ig * normal.x * normal.x * dW,
-ig * xy,
--ig * normal.x
+1.0 + ie * normal.x * normal.x * dW,
+ie * xy,
+-ie * normal.x
 );
 bitangent = vec3(
 xy,
-ig + normal.y * normal.y * dW,
+ie + normal.y * normal.y * dW,
 -normal.y
 );
 }
@@ -125,40 +125,40 @@ vec3 ai(vec3 rgb, float wavelength) {
 if (wavelength == 0.0) {
 return rgb;
 }
-vec3 tB = wavelength > 600.0
+vec3 tG = wavelength > 600.0
 ? vec3(1.0, 0.0, 0.0)
 : wavelength > 500.0
 ? vec3(0.0, 1.0, 0.0)
 : vec3(0.0, 0.0, 1.0);
-return rgb * tB;
+return rgb * tG;
 }
 
 float eK(
 float wavelength,
-float ha,
+float hb,
 float hk,
-float qg
+float qk
 ) {
 if (wavelength == 0.0 || hk <= 0.0) {
-return ha;
+return hb;
 }
 
 const float FRAUNHOFER_C = 656.3;
 const float FRAUNHOFER_D = 587.6;
 const float FRAUNHOFER_F = 486.1;
-float jI = 1.0 / (
+float jK = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float mQ = max(qg / hk, 1e-6);
-float qE = (ha - 1.0) * jI / mQ;
-float sY = ha
-- qE / (FRAUNHOFER_D * FRAUNHOFER_D);
-return sY + qE / (wavelength * wavelength);
+float mT = max(qk / hk, 1e-6);
+float qI = (hb - 1.0) * jK / mT;
+float td = hb
+- qI / (FRAUNHOFER_D * FRAUNHOFER_D);
+return td + qI / (wavelength * wavelength);
 }
 
 vec3 fl(
-vec3 gt,
+vec3 gu,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -167,21 +167,21 @@ if (abs(anisotropy) < 0.001) {
 au = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float iU = (1.0 - anisotropy * anisotropy)
+float iV = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 au = (
-iU * iU - 1.0 - anisotropy * anisotropy
+iV * iV - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float tR = sqrt(max(0.0, 1.0 - au * au));
+float tW = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aK(gt, tangent, bitangent);
-return tangent * (tR * cos(br))
-+ bitangent * (tR * sin(br))
-+ gt * au;
+aL(gu, tangent, bitangent);
+return tangent * (tW * cos(br))
++ bitangent * (tW * sin(br))
++ gu * au;
 }
 
 float bD(float au, float anisotropy) {