@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -1,14 +1,14 @@
 import { glsl } from '../../shader.js';
 export default glsl `
 #ifdef NUM_LIGHTS
-void eJ(
+void eM(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-vec3 nH = light.position - shadingPoint;
-float aj = length(nH);
+vec3 nR = light.position - shadingPoint;
+float aj = length(nR);
 if (light.radius <= 0.0) {
 if (aj <= 1e-6) {
 result.direction = vec3(0.0, 0.0, 1.0);
@@ -19,7 +19,7 @@ result.emission = vec3(0.0);
 result.isDelta = true;
 return;
 }
-result.direction = nH / aj;
+result.direction = nR / aj;
 result.normal = -result.direction;
 result.dist = aj;
 result.pdf = 1.0;
@@ -33,36 +33,36 @@ vec3 direction;
 
 if (aj <= radius) {
 float z = 1.0 - 2.0 * samplePoint.x;
-float fi = sqrt(max(0.0, 1.0 - z * z));
+float fl = sqrt(max(0.0, 1.0 - z * z));
 float br = TWOPI * samplePoint.y;
-direction = vec3(fi * cos(br), fi * sin(br), z);
+direction = vec3(fl * cos(br), fl * sin(br), z);
 result.pdf = INV4PI;
 }
 else {
-vec3 axis = nH / aj;
-float rL = min(
+vec3 axis = nR / aj;
+float rT = min(
 1.0,
 radius * radius / (aj * aj)
 );
-float rO = sqrt(max(0.0, 1.0 - rL));
-float au = mix(1.0, rO, samplePoint.x);
-float tW = sqrt(max(0.0, 1.0 - au * au));
+float rW = sqrt(max(0.0, 1.0 - rT));
+float au = mix(1.0, rW, samplePoint.x);
+float ud = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.y;
 vec3 tangent;
 vec3 bitangent;
 aL(axis, tangent, bitangent);
 direction = axis * au
-+ tangent * (tW * cos(br))
-+ bitangent * (tW * sin(br));
-result.pdf = 1.0 / max(TWOPI * (1.0 - rO), 1e-8);
++ tangent * (ud * cos(br))
++ bitangent * (ud * sin(br));
+result.pdf = 1.0 / max(TWOPI * (1.0 - rW), 1e-8);
 }
 
-float jb = dot(direction, nH);
-float ej = jb * jb
-- dot(nH, nH) + radius * radius;
-float wB = sqrt(max(0.0, ej));
-float cN = jb - wB;
-float cC = jb + wB;
+float jf = dot(direction, nR);
+float ej = jf * jf
+- dot(nR, nR) + radius * radius;
+float wK = sqrt(max(0.0, ej));
+float cN = jf - wK;
+float cC = jf + wK;
 result.dist = cN > 1e-6 ? cN : cC;
 result.direction = direction;
 vec3 surfacePoint = shadingPoint + direction * result.dist;
@@ -70,7 +70,7 @@ result.normal = normalize(surfacePoint - light.position);
 result.emission = light.emission;
 }
 
-void cZ(
+void da(
 in Light light,
 in vec3 surfacePoint,
 in vec3 lowerLeft,
@@ -80,17 +80,17 @@ inout LightSampleRec result
 if (light.textureIndex >= 0) {
 float width = length(light.u);
 float height = length(light.v);
-vec3 hX = surfacePoint - lowerLeft;
+vec3 ib = surfacePoint - lowerLeft;
 vec2 uv = vec2(
-dot(hX, light.u / width) / width,
-dot(hX, light.v / height) / height
+dot(ib, light.u / width) / width,
+dot(ib, light.v / height) / height
 );
 result.emission *= sampleMap(light.textureIndex, uv).rgb;
 }
 #endif
 }
 
-void jL(
+void jS(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -101,28 +101,28 @@ vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);
 float spread = clamp(light.spread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-float gb = dot(normal, shadingPoint - light.position);
-vec3 surfacePoint = shadingPoint - normal * gb;
-vec3 hX = surfacePoint - lowerLeft;
+float gg = dot(normal, shadingPoint - light.position);
+vec3 surfacePoint = shadingPoint - normal * gg;
+vec3 ib = surfacePoint - lowerLeft;
 float width = length(light.u);
 float height = length(light.v);
 vec2 uv = vec2(
-dot(hX, light.u / width) / width,
-dot(hX, light.v / height) / height
+dot(ib, light.u / width) / width,
+dot(ib, light.v / height) / height
 );
-if (gb <= 0.0 || any(lessThan(uv, vec2(0.0)))
+if (gg <= 0.0 || any(lessThan(uv, vec2(0.0)))
 || any(greaterThan(uv, vec2(1.0)))) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
 }
 result.direction = -normal;
-result.dist = gb;
+result.dist = gg;
 result.normal = normal;
 result.emission = light.emission;
 result.pdf = 1.0;
 result.isDelta = true;
-cZ(light, surfacePoint, lowerLeft, result);
+da(light, surfacePoint, lowerLeft, result);
 return;
 }
 
@@ -130,23 +130,23 @@ vec3 surfacePoint = lowerLeft
 + light.u * samplePoint.x
 + light.v * samplePoint.y;
 vec3 offset = surfacePoint - shadingPoint;
-float hl = dot(offset, offset);
-result.dist = sqrt(hl);
+float hq = dot(offset, offset);
+result.dist = sqrt(hq);
 result.direction = offset / result.dist;
 result.normal = normal;
-float fV = dot(-result.direction, normal);
-float oF = cos(0.5 * PI * spread);
-if (fV <= 0.0 || fV < oF) {
+float ga = dot(-result.direction, normal);
+float oN = cos(0.5 * PI * spread);
+if (ga <= 0.0 || ga < oN) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
 }
 result.emission = light.emission;
-result.pdf = hl / max(light.area * fV, 1e-8);
-cZ(light, surfacePoint, lowerLeft, result);
+result.pdf = hq / max(light.area * ga, 1e-8);
+da(light, surfacePoint, lowerLeft, result);
 }
 
-void fY(
+void gd(
 in Light light,
 in vec3 shadingPoint,
 inout LightSampleRec result
@@ -159,13 +159,13 @@ result.pdf = 1.0;
 result.isDelta = true;
 }
 
-void jM(
+void jT(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-eJ(light, shadingPoint, samplePoint, result);
+eM(light, shadingPoint, samplePoint, result);
 vec3 surfacePoint = shadingPoint + result.direction * result.dist;
 result.emission *= bL(
 light,
@@ -173,42 +173,42 @@ normalize(shadingPoint - surfacePoint)
 );
 }
 
-void iL(
+void iQ(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-int dO = int(light.type);
+int dP = int(light.type);
 #ifdef HAS_RECT_LIGHTS
-if (dO == RECT_LIGHT) {
-jL(light, shadingPoint, samplePoint, result);
+if (dP == RECT_LIGHT) {
+jS(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPHERE_LIGHTS
-if (dO == SPHERE_LIGHT) {
-eJ(light, shadingPoint, samplePoint, result);
+if (dP == SPHERE_LIGHT) {
+eM(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPOT_LIGHTS
-if (dO == SPOT_LIGHT) {
-jM(light, shadingPoint, samplePoint, result);
+if (dP == SPOT_LIGHT) {
+jT(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_DIRECTIONAL_LIGHTS
-if (dO == DIRECTIONAL_LIGHT) {
-fY(light, shadingPoint, result);
+if (dP == DIRECTIONAL_LIGHT) {
+gd(light, shadingPoint, result);
 }
 #endif
 }
 #endif
 
-void mx(in vec2 samplePoint, inout LightSampleRec result) {
+void mG(in vec2 samplePoint, inout LightSampleRec result) {
 vec2 uv;
-result.direction = oD(samplePoint, uv, result.pdf);
+result.direction = oL(samplePoint, uv, result.pdf);
 result.emission = textureLinear(envMap, uv).rgb;
 result.dist = INF;
 }
@@ -217,36 +217,36 @@ void sampleLight(
 in vec3 shadingPoint,
 in vec3 randomSampleValue,
 inout LightSampleRec result,
-bool rU
+bool sc
 ) {
 result.isDelta = false;
-float tV = randomSampleValue.z;
-bool kq = false;
+float uc = randomSampleValue.z;
+bool kA = false;
 #ifdef USE_ENVMAP
-kq = tV < envLightSelectionPmf;
-if (kq) {
-mx(randomSampleValue.xy, result);
+kA = uc < envLightSelectionPmf;
+if (kA) {
+mG(randomSampleValue.xy, result);
 result.pdf *= envLightSelectionPmf;
 }
 #endif
 
 #ifdef NUM_LIGHTS
-if (!kq) {
-int kT = NUM_LIGHTS - 1;
+if (!kA) {
+int lc = NUM_LIGHTS - 1;
 for (int index = 0; index < NUM_LIGHTS; index++) {
-if (tV < qp(index).selectionCdf) {
-kT = index;
+if (uc < qx(index).selectionCdf) {
+lc = index;
 break;
 }
 }
-Light qf = qp(kT);
-iL(
-qf,
+Light qn = qx(lc);
+iQ(
+qn,
 shadingPoint,
 randomSampleValue.xy,
 result
 );
-result.pdf *= qf.selectionPmf;
+result.pdf *= qn.selectionPmf;
 }
 #endif
 }

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 mT(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gF) {
+float mC = 1.0;
+vec3 ln = vec3(fp(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 oS = -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); }
+#ifdef USE_COAT_NORMAL_FRAMES
+if (gF && 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 (gF) {
 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(oS, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,97 +46,97 @@ 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 mz;
+vec3 hi = si.position + EPS * lightDir;
+if (gF) {
 const float bZ = 0.1;
 float dr = dot(si.normal, lightDir);
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 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 oB = 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 * oB;
 }
-iw(mp, hd, lightDir);
-if (ex(mp, lightSample.dist - EPS, si.triangleIndex)) {
+iC(mz, hi, lightDir);
+if (ex(mz, 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 (gF && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
+vec4 background = cx(mz.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;
+#ifdef USE_COAT_NORMAL_FRAMES
+vec3 fF(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)));
-#ifdef NUM_COAT_NORMAL_MAPS
+void mb(inout ad si, J mat, inout Path aa) {
+vec3 ur = vec3(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+#ifdef USE_COAT_NORMAL_FRAMES
 vec3 bC = si.faceNormal;
-vec3 mv = si.normal;
+vec3 mE = 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;
 
 mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;
 vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 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 gb = dot(bC, view);
+mat.geometricNormal = gb >= 0.0 ? bC : -bC;
+ffnormal = fF(mE, bC, view);
+mat.coatNormal = fF(si.coatNormal, bC, view);
+mat.inside = gb <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gb > 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 nu = 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 nj = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+float fE = extinction[nj];
+float ih = fE > 0.0
+? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d)
 : d;
-bl = ib < d;
-vec3 ew = exp(-extinction * ib);
-vec3 nP = bl
+bl = ih < d;
+vec3 ew = exp(-extinction * ih);
+vec3 nZ = bl
 ? extinction * ew
 : ew;
-float nA = max(
-(nP.x + nP.y + nP.z) / 3.0,
+float 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;
-aa.li += mJ(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += mT(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-cG = fl(
+cG = fq(
 -aa.ray.d,
 si.mediumAnisotropy,
-fk(cw(PHASE_DIRECTION))
+fp(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
 dot(cG, -aa.ray.d),
@@ -193,7 +193,7 @@ si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nA;
+aa.beta *= ew / nK;
 }
 }
 #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 += mT(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
 vec3 f = dv(
 prepared,
-uj,
+ur,
 cG,
 scatteringPdf,
 isNextRefraction
@@ -238,19 +238,19 @@ aa.abort = true;
 return;
 }
 aa.beta *= f / scatteringPdf;
-hj = !mat.thinWalled &&
+hn = !mat.thinWalled &&
 isNextRefraction;
 aa.isNextRefraction = isNextRefraction;
 
 
 aa.ray.o = si.position + EPS * cG;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 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, 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;