@meimu/mutracer 0.1.3 → 0.1.4

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

@@ -2,33 +2,33 @@
 // 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 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)));
+vec3 mU(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gE) {
+float mD = 1.0;
+vec3 ln = vec3(fo(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, lc, lightSample, false);
+sampleLight(si.position, ln, lightSample, false);
 lightSample.emission = ai(lightSample.emission, bf);
 
 vec3 lightDir = lightSample.direction;
-vec3 oK = -aa.ray.d;
-float fd = lightSample.pdf;
+vec3 oT = -aa.ray.d;
+float fg = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
 #ifdef NUM_COAT_NORMAL_MAPS
-if (gy && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+if (gE && 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) {
+if (fg <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
 return vec3(0.0);
 }
 
 float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
-if (gy) {
+if (gE) {
 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(oK, lightDir),
+dot(oT, 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 mp;
-vec3 hd = si.position + EPS * lightDir;
-if (gy) {
+Ray mA;
+vec3 hi = si.position + EPS * lightDir;
+if (gE) {
 const float bZ = 0.1;
 float dr = dot(si.normal, lightDir);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -56,73 +56,73 @@ if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
 #endif
 vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
 dr = abs(dr);
-float hO = dot(geometricNormal, lightDir);
-float ot = dr < bZ
+float hS = dot(geometricNormal, lightDir);
+float oC = dr < bZ
 ? clamp(
-2.0 - (hO + dr) / bZ,
+2.0 - (hS + dr) / bZ,
 0.0,
 1.0
 )
-: clamp(1.0 - hO / bZ, 0.0, 1.0);
-hd += si.shadowOffset * ot;
+: clamp(1.0 - hS / bZ, 0.0, 1.0);
+hi += si.shadowOffset * oC;
 }
-iw(mp, hd, lightDir);
-if (ex(mp, lightSample.dist - EPS, si.triangleIndex)) {
+iC(mA, hi, lightDir);
+if (ex(mA, lightSample.dist - EPS, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (gy && cosThetaL < 0.0 && lc.z < envLightSelectionPmf) {
-vec4 background = cx(mp.o, lightDir);
+if (gE && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
+vec4 background = cx(mA.o, lightDir);
 lightSample.emission = ai(background.rgb * background.a, bf);
 }
 #endif
 
 
 
-float eW = lightSample.isDelta
+float fa = lightSample.isDelta
 ? 1.0
-: aG(fd, scatteringPdf);
-return eW > 0.0
-? eW * lightSample.emission * f / fd
+: aG(fg, scatteringPdf);
+return fa > 0.0
+? fa * lightSample.emission * f / fg
 : vec3(0.0);
 }
 
 #ifdef NUM_COAT_NORMAL_MAPS
-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;
+vec3 fE(vec3 pG, vec3 tq, vec3 view) {
+bool qY = dot(tq, view) >= 0.0;
+vec3 uo = qY ? tq : -tq;
+vec3 qX = qY ? pG : -pG;
+if (dot(pG, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
+return qX;
 }
 #endif
-void lR(inout ad si, J mat, inout Path aa) {
-vec3 uj = vec3(fk(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+void mc(inout ad si, J mat, inout Path aa) {
+vec3 ur = vec3(fo(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
 #ifdef NUM_COAT_NORMAL_MAPS
 vec3 bC = si.faceNormal;
-vec3 mv = si.normal;
+vec3 mF = si.normal;
 #endif
-float rF = -dot(si.faceNormal, aa.ray.d);
-float sw = -dot(si.normal, aa.ray.d);
+float rN = -dot(si.faceNormal, aa.ray.d);
+float sG = -dot(si.normal, aa.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.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;
 }
 }
 
 
-bool pM = rF >= 0.0 && sw < 0.0;
-float ndv = pM ? rF : sw;
-vec3 normal = pM ? si.faceNormal : si.normal;
+bool pU = rN >= 0.0 && sG < 0.0;
+float ndv = pU ? rN : sG;
+vec3 normal = pU ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -131,12 +131,12 @@ vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
 #ifdef NUM_COAT_NORMAL_MAPS
 if (mat.coatNormalEnabled) {
 vec3 view = -aa.ray.d;
-float fW = dot(bC, view);
-mat.geometricNormal = fW >= 0.0 ? bC : -bC;
-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;
+float ga = dot(bC, view);
+mat.geometricNormal = ga >= 0.0 ? bC : -bC;
+ffnormal = fE(mF, bC, view);
+mat.coatNormal = fE(si.coatNormal, bC, view);
+mat.inside = ga <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (ga > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
@@ -145,47 +145,47 @@ float scatteringPdf;
 vec3 cG;
 aa.scatteringIsDelta = false;
 bool bl = false;
-bool hj = false;
+bool hn = false;
 ag prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, aa.ray.o);
-vec3 nh = aa.ray.o;
+vec3 nv = aa.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float sr = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sr > 0.0) {
+float sC = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sC > 0.0) {
 
 
 
 
-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)
+int nk = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+float fD = extinction[nk];
+float ih = fD > 0.0
+? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fD, d)
 : d;
-bl = ib < d;
-vec3 ew = exp(-extinction * ib);
-vec3 nP = bl
+bl = ih < d;
+vec3 ew = exp(-extinction * ih);
+vec3 oa = bl
 ? extinction * ew
 : ew;
-float nA = max(
-(nP.x + nP.y + nP.z) / 3.0,
+float nL = max(
+(oa.x + oa.y + oa.z) / 3.0,
 1e-8
 );
 if (bl) {
-aa.beta *= ew * scattering / nA;
+aa.beta *= ew * scattering / nL;
 
-aa.ray.o = nh + ib * aa.ray.d;
+aa.ray.o = nv + ih * aa.ray.d;
 si.position = aa.ray.o;
-aa.li += mJ(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += mU(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-cG = fl(
+cG = fp(
 -aa.ray.d,
 si.mediumAnisotropy,
-fk(cw(PHASE_DIRECTION))
+fo(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
 dot(cG, -aa.ray.d),
@@ -193,7 +193,7 @@ si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nA;
+aa.beta *= ew / nL;
 }
 }
 #endif
@@ -205,21 +205,21 @@ if (mat.materialType == UNLIT) {
 aa.abort = true;
 return;
 }
-vec3 pK = vec3(0.0);
+vec3 pS = vec3(0.0);
 #ifdef USE_TANGENT
-pK = si.tangent;
+pS = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = eG(pK, mat, -aa.ray.d, ffnormal);
-aa.li += mJ(si, mat, prepared, aa, ffnormal, true) * aa.beta;
+prepared = eH(pS, mat, -aa.ray.d, ffnormal);
+aa.li += mU(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
 vec3 f = dv(
 prepared,
-uj,
+ur,
 cG,
 scatteringPdf,
 isNextRefraction
@@ -238,7 +238,7 @@ aa.abort = true;
 return;
 }
 aa.beta *= f / scatteringPdf;
-hj = !mat.thinWalled &&
+hn = !mat.thinWalled &&
 isNextRefraction;
 aa.isNextRefraction = isNextRefraction;
 
@@ -250,7 +250,7 @@ if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0
 }
 
 aa.scatteringPdf = scatteringPdf;
-iw(aa.ray, aa.ray.o, cG);
+iC(aa.ray, aa.ray.o, cG);
 if (bl) {
 aa.isNextRefraction = false;
 }
@@ -259,8 +259,8 @@ aa.fromEye = false;
 #ifdef HAS_MEDIUM
 
 
-if (!bl && hj && mat.mediumType > 0) {
-if (rF >= 0.0) {
+if (!bl && hn && mat.mediumType > 0) {
+if (rN >= 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 ko(uint candidate, uint slot) {
+uint ky(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 oK = -aa.ray.d;
+vec3 oT = -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 lc = vec3(
-fk(ko(candidate, LIGHT_POSITION)),
-dz(ko(candidate, LIGHT_SELECT))
+vec3 ln = vec3(
+fo(ky(candidate, LIGHT_POSITION)),
+dz(ky(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, lc, lightSample, false);
+sampleLight(si.position, ln, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pv = dot(si.normal, oK) * cosThetaL;
-bool mt = false;
-if (pv >= 0.0) {
+float pM = dot(si.normal, oT) * cosThetaL;
+bool mD = false;
+if (pM >= 0.0) {
 Ray ray;
-iw(ray, si.position + EPS * lightDir, lightDir);
-mt = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+iC(ray, si.position + EPS * lightDir, lightDir);
+mD = ex(ray, lightSample.dist - EPS, si.triangleIndex);
 }
-visibility += mt ? 0.0 : 1.0;
+visibility += mD ? 0.0 : 1.0;
 }
 
 aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);

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

@@ -5,70 +5,70 @@ export default glsl `
 
 
 vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
-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));
+vec3 rm = vec3(alpha, 1.0);
+vec3 gj = normalize(rm * view);
+float uh = min(gj.z, 1.0);
+float qQ = 1.0 + uh;
+float rh = (1.0 - samplePoint.y) * qQ;
+float rR = samplePoint.y * qQ;
+float sI = rh + (1.0 - uh);
+float fl = sqrt(max(0.0, sI * rR));
 float br = TWOPI * samplePoint.x;
-vec3 lw = vec3(
-gf.x + fi * cos(br),
-gf.y + fi * sin(br),
-qX
+vec3 lJ = vec3(
+gj.x + fl * cos(br),
+gj.y + fl * sin(br),
+rh
 );
-return normalize(rc * lw);
+return normalize(rm * lJ);
 }
 
-float gG(vec3 od, vec2 alpha) {
-vec3 hm = vec3(
-od.x / alpha.x,
-od.y / alpha.y,
-od.z
+float gK(vec3 oq, vec2 alpha) {
+vec3 hr = vec3(
+oq.x / alpha.x,
+oq.y / alpha.y,
+oq.z
 );
-float ap = dot(hm, hm);
+float ap = dot(hr, hr);
 return 1.0 / (
 PI * alpha.x * alpha.y * ap * ap
 );
 }
 
 float bk(vec3 direction, vec2 alpha) {
-float eE = abs(direction.z);
-if (eE <= 1e-8) {
+float eF = abs(direction.z);
+if (eF <= 1e-8) {
 return 0.0;
 }
-vec2 hY = alpha * direction.xy;
-float lA = dot(hY, hY)
-/ (eE * eE);
-return 2.0 / (1.0 + sqrt(1.0 + lA));
+vec2 ic = alpha * direction.xy;
+float lK = dot(ic, ic)
+/ (eF * eF);
+return 2.0 / (1.0 + sqrt(1.0 + lK));
 }
 
 float aE(float au) {
-float dg = clamp(1.0 - au, 0.0, 1.0);
-return pow(dg, 5.0);
+float di = clamp(1.0 - au, 0.0, 1.0);
+return pow(di, 5.0);
 }
 
 float cu(float L, float cJ) {
-float iu = clamp(abs(L), 0.0, 1.0);
-float ke = cJ * cJ
-* max(0.0, 1.0 - iu * iu);
-if (ke >= 1.0) {
+float iA = clamp(abs(L), 0.0, 1.0);
+float kl = cJ * cJ
+* max(0.0, 1.0 - iA * iA);
+if (kl >= 1.0) {
 return 1.0;
 }
 
-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);
+float lU = sqrt(max(0.0, 1.0 - kl));
+float ba = (iA - cJ * lU)
+/ max(iA + cJ * lU, 1e-8);
+float pN = (cJ * iA - lU)
+/ max(cJ * iA + lU, 1e-8);
 return 0.5 * (
-ba * ba + pw * pw
+ba * ba + pN * pN
 );
 }
 
-vec2 gd(vec2 samplePoint) {
+vec2 gh(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 kx = gd(samplePoint);
+vec2 kF = gh(samplePoint);
 return vec3(
-kx,
-sqrt(max(0.0, 1.0 - dot(kx, kx)))
+kF,
+sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-float aG(float pi, float nD) {
-float scale = max(pi, nD);
+float aG(float pr, float nO) {
+float scale = max(pr, nO);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(pi, nD) / scale;
-vec2 oG = normalized * normalized;
-return oG.x / (oG.x + oG.y);
+vec2 normalized = vec2(pr, nO) / scale;
+vec2 oP = normalized * normalized;
+return oP.x / (oP.x + oP.y);
 }
 
 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 ik = normal.z >= 0.0 ? 1.0 : -1.0;
+float dW = -1.0 / (ik + normal.z);
 float xy = normal.x * normal.y * dW;
 tangent = vec3(
-1.0 + ie * normal.x * normal.x * dW,
-ie * xy,
--ie * normal.x
+1.0 + ik * normal.x * normal.x * dW,
+ik * xy,
+-ik * normal.x
 );
 bitangent = vec3(
 xy,
-ie + normal.y * normal.y * dW,
+ik + normal.y * normal.y * dW,
 -normal.y
 );
 }
@@ -125,40 +125,40 @@ vec3 ai(vec3 rgb, float wavelength) {
 if (wavelength == 0.0) {
 return rgb;
 }
-vec3 tG = wavelength > 600.0
+vec3 tN = 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 * tG;
+return rgb * tN;
 }
 
-float eK(
+float eN(
 float wavelength,
-float hb,
-float hk,
-float qk
+float hg,
+float hp,
+float qs
 ) {
-if (wavelength == 0.0 || hk <= 0.0) {
-return hb;
+if (wavelength == 0.0 || hp <= 0.0) {
+return hg;
 }
 
 const float FRAUNHOFER_C = 656.3;
 const float FRAUNHOFER_D = 587.6;
 const float FRAUNHOFER_F = 486.1;
-float jK = 1.0 / (
+float jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-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);
+float nh = max(qs / hp, 1e-6);
+float qR = (hg - 1.0) * jR / nh;
+float tl = hg
+- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
+return tl + qR / (wavelength * wavelength);
 }
 
-vec3 fl(
-vec3 gu,
+vec3 fp(
+vec3 gy,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -167,21 +167,21 @@ if (abs(anisotropy) < 0.001) {
 au = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float iV = (1.0 - anisotropy * anisotropy)
+float ja = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 au = (
-iV * iV - 1.0 - anisotropy * anisotropy
+ja * ja - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float tW = sqrt(max(0.0, 1.0 - au * au));
+float ud = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aL(gu, tangent, bitangent);
-return tangent * (tW * cos(br))
-+ bitangent * (tW * sin(br))
-+ gu * au;
+aL(gy, tangent, bitangent);
+return tangent * (ud * cos(br))
++ bitangent * (ud * sin(br))
++ gy * au;
 }
 
 float bD(float au, float anisotropy) {