@meimu/mutracer 0.1.2 → 0.1.4

package/lib/renderer/glsl/rayTrace.frag.js

@@ -32,7 +32,7 @@ return;
 // So here the code are injected separately.
 const bounceCodeOnIntelMac = glsl `
 
-for(int vI = 0; vI < BOUNCES; vI++) {{
+for(int vU = 0; vU < BOUNCES; vU++) {{
 if (aa.abort) {
 return vec4(aa.li, aa.alpha);
 }
@@ -40,10 +40,10 @@ bounce(aa, depth, si, mat, outAux);
 }}
 `;
 const bounceCodeOnOther = glsl `
-bool uT = !si.isTransparency;
-int qB = min(BOUNCES, bounceLimit);
+bool vg = !si.isTransparency;
+int qO = min(BOUNCES, bounceLimit);
 for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {
-if (uT && idx > qB) {
+if (vg && idx > qO) {
 aa.abort = true;
 }
 if (aa.abort) {
@@ -93,7 +93,7 @@ ${envMap.main}
 ${samplingGlsl}
 ${openPbrBsdfGlsl}
 
-float mh;
+float mw;
 float bf;
 
 ${sampleLightGlsl}
@@ -110,7 +110,7 @@ bool isShadowCatcher;
 };
 
 void bounce(inout Path aa, inout int depth, inout ad si, inout J mat, inout RayTraceAuxiliary outAux) {
-cE = uint(max(depth, 0));
+cF = uint(max(depth, 0));
 
 
 
@@ -135,26 +135,26 @@ if (aa.isNextRefraction) {
 
 
 
-vec4 bg = cw(aa.ray.o, aa.ray.d);
+vec4 bg = cx(aa.ray.o, aa.ray.d);
 bg.rgb = ai(bg.rgb, bf);
 float cT = aa.scatteringIsDelta ? 1.0
-: aF(aa.scatteringPdf,
-iv(aS(aa.ray.d)) * envLightSelectionPmf);
+: aG(aa.scatteringPdf,
+iB(cY(aa.ray.d)) * envLightSelectionPmf);
 aa.li += cT * aa.beta * bg.rgb * bg.a;
 aa.alpha = max(aa.alpha, bg.a);
 }
 else {
-vec2 tE = aS(aa.ray.d);
-vec3 emission = textureLinear(envMap, tE).rgb;
+vec2 tQ = cY(aa.ray.d);
+vec3 emission = textureLinear(envMap, tQ).rgb;
 emission = ai(emission, bf);
 aa.li += aa.beta * emission *
-aF(
+aG(
 aa.scatteringPdf,
-iv(tE) * envLightSelectionPmf
+iB(tQ) * envLightSelectionPmf
 );
 }
 #else
-vec4 bg = cw(aa.ray.o, aa.ray.d);
+vec4 bg = cx(aa.ray.o, aa.ray.d);
 bg.rgb = ai(bg.rgb, bf);
 aa.li += aa.beta * bg.rgb * bg.a;
 #endif
@@ -165,7 +165,7 @@ return;
 
 if (!si.hit) {
 
-vec4 bg = cw(aa.ray.o, aa.ray.d);
+vec4 bg = cx(aa.ray.o, aa.ray.d);
 
 
 
@@ -177,10 +177,10 @@ aa.alpha = bg.a;
 outAux.isBlank = bg.a < 0.01;
 }
 else {
-Ray cam = hz(v_Texcoord + rN());
-bool mz = dot(cam.d, aa.ray.d) > 0.0;
+Ray cam = hC(v_Texcoord + sa());
+bool mM = dot(cam.d, aa.ray.d) > 0.0;
 if (transmissiveOutputAlphaMin < 1.0) {
-if (mz) {
+if (mM) {
 aa.alpha = max(aa.alpha, bg.a);
 } else {
 aa.alpha = 1.0;
@@ -188,8 +188,8 @@ aa.alpha = 1.0;
 }
 #if !defined(USE_ENVMAP)
 
-if (mz) {
-aa.li = aa.beta * aF(aa.scatteringPdf, 1.0) * bg.rgb;
+if (mM) {
+aa.li = aa.beta * aG(aa.scatteringPdf, 1.0) * bg.rgb;
 }
 #endif
 }
@@ -197,7 +197,7 @@ aa.abort = true;
 return;
 }
 
-bool cG = false;
+bool cH = false;
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT)) {
 if (transmissiveOutputAlphaMin < 1.0) {
 
@@ -210,18 +210,18 @@ if (alpha < 1.0) {
 
 aa.alpha = max(aa.alpha, alpha);
 if (eo(3u) > alpha) {
-cG = true;
+cH = true;
 }
 }
-if (!cG) {
-lO(si, mat, aa);
+if (!cH) {
+mc(si, mat, aa);
 }
 else {
 aa.ray.o = si.position + aa.ray.d * EPS;
 }
 }
 
-if (!si.albedoSampled && !cG) {
+if (!si.albedoSampled && !cH) {
 
 if ((mat.materialType == STANDARD || mat.materialType == UNLIT) &&
 !(mat.transmissionWeight > 0.5 ||
@@ -243,11 +243,11 @@ si.albedoSampled = true;
 
 
 #ifdef USE_RR
-if (depth >= RR_MAX && !cG) {
+if (depth >= RR_MAX && !cH) {
 
-float oj = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
-float q = max(0.0, 1.0 - oj);
-if (dz(cv(RUSSIAN_ROULETTE)) < q) {
+float oz = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
+float q = max(0.0, 1.0 - oz);
+if (dz(cw(RUSSIAN_ROULETTE)) < q) {
 
 
 aa.alpha = 1.0;
@@ -264,18 +264,18 @@ return;
 }
 
 
-cY(aa.ray, si, true);
-eT(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+cZ(aa.ray, si, true);
+eX(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;
 
 
 
 
 if (dispersionWavelengths == 1 && si.hit && mat.transmissionWeight > 0.001 && mat.transmissionDispersionScale > 0.001) {
-bf = mh;
+bf = mw;
 }
 if (mat.transmissionWeight > 0.001 && bf > 0.0) {
-mat.specularIor = eK(
+mat.specularIor = eN(
 bf,
 mat.specularIor,
 mat.transmissionDispersionScale,
@@ -283,24 +283,24 @@ mat.dispersionAbbeNumber
 );
 }
 
-if (cG) {
+if (cH) {
 return;
 }
 
-bool hu = eo(3u) < mat.alpha;
+bool hy = eo(3u) < mat.alpha;
 #ifdef NUM_LIGHTS
 
 LightSampleRec lightSample;
 for (int i = 0; i < NUM_LIGHTS; i++) {
 
-Light light = ql(i);
-float d = mk(aa.ray, light, lightSample);
-bool mp = si.hit && d > distance(si.position, aa.ray.o);
-if (d != INF && !(mp && hu)) {
+Light light = qx(i);
+float d = mz(aa.ray, light, lightSample);
+bool mD = si.hit && d > distance(si.position, aa.ray.o);
+if (d != INF && !(mD && hy)) {
 lightSample.pdf *= light.selectionPmf;
-float eW = aF(aa.scatteringPdf, lightSample.pdf);
+float fa = aG(aa.scatteringPdf, lightSample.pdf);
 lightSample.emission = ai(lightSample.emission, bf);
-aa.li += eW * aa.beta * lightSample.emission;
+aa.li += fa * aa.beta * lightSample.emission;
 
 aa.alpha = 1.0;
 aa.abort = true;
@@ -309,28 +309,28 @@ aa.abort = true;
 #endif
 
 #ifdef USE_ENVMAP
-if (!(si.hit && hu)) {
+if (!(si.hit && hy)) {
 if (aa.isNextRefraction) {
 
 
-vec4 bg = cw(aa.ray.o, aa.ray.d);
+vec4 bg = cx(aa.ray.o, aa.ray.d);
 bg.rgb = ai(bg.rgb, bf);
 float cT = aa.scatteringIsDelta ? 1.0
-: aF(aa.scatteringPdf,
-iv(aS(aa.ray.d)) * envLightSelectionPmf);
+: aG(aa.scatteringPdf,
+iB(cY(aa.ray.d)) * envLightSelectionPmf);
 aa.li += cT * aa.beta * bg.rgb * bg.a;
 aa.alpha = max(aa.alpha, bg.a);
 aa.abort = true;
 return;
 }
-vec2 uv = aS(aa.ray.d);
+vec2 uv = cY(aa.ray.d);
 vec3 emission = textureLinear(envMap, uv).rgb;
-float eW = aF(
+float fa = aG(
 aa.scatteringPdf,
-iv(uv) * envLightSelectionPmf
+iB(uv) * envLightSelectionPmf
 );
 emission = ai(emission, bf);
-aa.li += aa.beta * emission * eW;
+aa.li += aa.beta * emission * fa;
 
 
 #if !defined(USE_BACKGROUND)
@@ -345,105 +345,105 @@ depth++;
 }
 
 
-vec2 kn(float radius, float xi) {
+vec2 kz(float radius, float xi) {
 float x = 0.25;
-for (int np = 0; np < 10; np++) {
+for (int nH = 0; nH < 10; nH++) {
 float x2 = x * x;
 float x3 = x2 * x;
-float kD = 1.0 - x;
+float kP = 1.0 - x;
 float value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-float lV = 20.0 * x * kD * kD * kD;
-if (abs(value) < 1e-6 || lV == 0.0) break;
-x = clamp(x - value / lV, 0.0, 1.0);
+float mk = 20.0 * x * kP * kP * kP;
+if (abs(value) < 1e-6 || mk == 0.0) break;
+x = clamp(x - value / mk, 0.0, 1.0);
 }
-float jh = x * radius;
+float jo = x * radius;
 return vec2(
-jh,
-sqrt(max(radius * radius - jh * jh, 0.0))
+jo,
+sqrt(max(radius * radius - jo * jo, 0.0))
 );
 }
 
-float iN(float radius, float gr) {
-if (gr >= radius) return 0.0;
-float nS = radius - gr;
-return nS * nS * nS;
+float iT(float radius, float gw) {
+if (gw >= radius) return 0.0;
+float oh = radius - gw;
+return oh * oh * oh;
 }
 
 
-vec3 mf(ad source, float radius) {
+vec3 mu(ad source, float radius) {
 vec3 geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) geometricNormal = -geometricNormal;
 vec3 tangent;
 vec3 bitangent;
-aK(geometricNormal, tangent, bitangent);
-vec3 iB = vec3(0.0);
-
-for (int ib = 0; ib < BEVEL_SAMPLES; ib++) {
-vec2 oU = fk(CAMERA_BEVEL_BASE + uint(ib));
-float cz = oU.x;
-float ou = oU.y;
-vec3 di = geometricNormal;
-vec3 fE = tangent;
+aL(geometricNormal, tangent, bitangent);
+vec3 iF = vec3(0.0);
+
+for (int ig = 0; ig < BEVEL_SAMPLES; ig++) {
+vec2 ph = fo(CAMERA_BEVEL_BASE + uint(ig));
+float cA = ph.x;
+float oG = ph.y;
+vec3 dj = geometricNormal;
+vec3 fH = tangent;
 vec3 ek = bitangent;
-float fZ = 0.5;
-float hV = 0.25;
-float gy = 0.25;
-if (cz < 0.5) {
-cz *= 2.0;
-}
-else if (cz < 0.75) {
-vec3 mx = di;
-di = fE;
-fE = mx;
-fZ = 0.25;
-hV = 0.5;
-cz = (cz - 0.5) * 4.0;
+float ge = 0.5;
+float hY = 0.25;
+float gG = 0.25;
+if (cA < 0.5) {
+cA *= 2.0;
+}
+else if (cA < 0.75) {
+vec3 mK = dj;
+dj = fH;
+fH = mK;
+ge = 0.25;
+hY = 0.5;
+cA = (cA - 0.5) * 4.0;
 }
 else {
-vec3 mx = di;
-di = ek;
-ek = mx;
-fZ = 0.25;
-gy = 0.5;
-cz = (cz - 0.75) * 4.0;
-}
-
-vec2 gO = kn(radius, ou);
-float phi = TWOPI * cz;
-vec3 qj = gO.x *
-(cos(phi) * fE + sin(phi) * ek);
+vec3 mK = dj;
+dj = ek;
+ek = mK;
+ge = 0.25;
+gG = 0.5;
+cA = (cA - 0.75) * 4.0;
+}
+
+vec2 gU = kz(radius, oG);
+float phi = TWOPI * cA;
+vec3 qv = gU.x *
+(cos(phi) * fH + sin(phi) * ek);
 Ray ray;
-iw(
+iC(
 ray,
-source.position + di * gO.y + qj,
--di
+source.position + dj * gU.y + qv,
+-dj
 );
 ad hit;
-iG(
+iM(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * gO.y, EPS)
+max(2.0 * gU.y, EPS)
 );
 if (!hit.hit) continue;
 
-float kE = fZ * abs(dot(di, hit.faceNormal));
-float mt = hV * abs(dot(fE, hit.faceNormal));
-float jS = gy * abs(dot(ek, hit.faceNormal));
-float weight = kE / max(
-kE * kE + mt * mt +
-jS * jS,
+float kQ = ge * abs(dot(dj, hit.faceNormal));
+float mG = hY * abs(dot(fH, hit.faceNormal));
+float kb = gG * abs(dot(ek, hit.faceNormal));
+float weight = kQ / max(
+kQ * kQ + mG * mG +
+kb * kb,
 1e-8
 );
-weight *= iN(radius, distance(hit.position, source.position)) /
-max(iN(radius, gO.x), 1e-8);
-iB += weight * hit.vertexNormal;
+weight *= iT(radius, distance(hit.position, source.position)) /
+max(iT(radius, gU.x), 1e-8);
+iF += weight * hit.vertexNormal;
 }
 
-if (dot(iB, iB) <= 1e-12) return source.normal;
-vec3 jA = normalize(iB);
-vec3 result = source.normal + jA - source.vertexNormal;
+if (dot(iF, iF) <= 1e-12) return source.normal;
+vec3 jH = normalize(iF);
+vec3 result = source.normal + jH - source.vertexNormal;
 return dot(result, result) > 1e-12 ? normalize(result) : source.normal;
 }
 
@@ -463,7 +463,7 @@ ${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}
 return vec4(aa.li, aa.alpha);
 }
 
-vec4 iz(ad si, Ray ray, J mat, inout RayTraceAuxiliary outAux) {
+vec4 iD(ad si, Ray ray, J mat, inout RayTraceAuxiliary outAux) {
 float coverage = clamp(mat.alpha, 0.0, 1.0);
 if (!si.hit || (mat.materialType != STANDARD && mat.materialType != UNLIT) || coverage >= 1.0) {
 return bw(si, ray, mat, outAux);
@@ -473,49 +473,49 @@ return bw(si, ray, mat, outAux);
 
 
 
-Ray nK = ray;
-nK.o = si.position + ray.d * (EPS * 0.02);
-ad dU = si;
-dU.albedoSampled = false;
-cY(nK, dU, false);
-J nJ;
-eT(nJ, dU.materialIndex, dU.uv, dU.uv1, dU.instanceIndex);
-RayTraceAuxiliary gg = outAux;
-if (dU.hit && (nJ.materialType == STANDARD || nJ.materialType == UNLIT)) {
-gg.albedo = nJ.transmissionWeight > 0.5
+Ray nY = ray;
+nY.o = si.position + ray.d * (EPS * 0.02);
+ad dE = si;
+dE.albedoSampled = false;
+cZ(nY, dE, false);
+J nX;
+eX(nX, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
+RayTraceAuxiliary gm = outAux;
+if (dE.hit && (nX.materialType == STANDARD || nX.materialType == UNLIT)) {
+gm.albedo = nX.transmissionWeight > 0.5
 ? vec3(1.0)
-: nJ.baseColor;
-gg.normal = dot(
-dU.normal,
-dU.position - vec3(viewInv[3])
+: nX.baseColor;
+gm.normal = dot(
+dE.normal,
+dE.position - vec3(viewInv[3])
 ) > 0.0
-? -dU.normal
-: dU.normal;
-dU.albedoSampled = nJ.transmissionWeight > 0.5;
+? -dE.normal
+: dE.normal;
+dE.albedoSampled = nX.transmissionWeight > 0.5;
 }
-vec4 back = bw(dU, nK, nJ, gg);
+vec4 back = bw(dE, nY, nX, gm);
 if (coverage <= 0.0) {
-outAux = gg;
+outAux = gm;
 return back;
 }
 
-ad te = si;
-J tF = mat;
-tF.alpha = 1.0;
-RayTraceAuxiliary iQ = outAux;
-vec4 qL = bw(te, ray, tF, iQ);
-outAux.albedo = mix(gg.albedo, iQ.albedo, coverage);
-vec3 fR = mix(gg.normal, iQ.normal, coverage);
-outAux.normal = dot(fR, fR) > 1e-12
-? normalize(fR)
+ad tu = si;
+J tR = mat;
+tR.alpha = 1.0;
+RayTraceAuxiliary iW = outAux;
+vec4 qY = bw(tu, ray, tR, iW);
+outAux.albedo = mix(gm.albedo, iW.albedo, coverage);
+vec3 fV = mix(gm.normal, iW.normal, coverage);
+outAux.normal = dot(fV, fV) > 1e-12
+? normalize(fV)
 : vec3(0.0);
-outAux.isBlank = gg.isBlank && iQ.isBlank;
-return mix(back, qL, coverage);
+outAux.isBlank = gm.isBlank && iW.isBlank;
+return mix(back, qY, coverage);
 }
 
 
 
-vec4 mj(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 my(Ray ray, out RayTraceAuxiliary outAux) {
 
 ad si;
 J mat;
@@ -528,13 +528,13 @@ si.mediumScattering = vec3(0.0);
 si.mediumAnisotropy = 0.0;
 #endif
 
-cY(ray, si, false);
-eT(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+cZ(ray, si, false);
+eX(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;
 
 #ifdef HAS_BEVEL
 if (bevelEnabled && mat.bevel > 0.0) {
-si.normal = mf(si, mat.bevel);
+si.normal = mu(si, mat.bevel);
 }
 #endif
 
@@ -551,32 +551,32 @@ si.albedoSampled = mat.transmissionWeight > 0.5;
 }
 
 if (mat.transmissionDispersionScale > 0.001) {
-mat.specularIor = eK(
+mat.specularIor = eN(
 bf,
 mat.specularIor,
 mat.transmissionDispersionScale,
 mat.dispersionAbbeNumber
 );
 }
-return iz(si, ray, mat, outAux);
+return iD(si, ray, mat, outAux);
 }
 
 void main() {
 
-se();
-jY(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
+su();
+kh(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
 
 
 bf = dispersionWavelengths == 1 ? 0.0 : wavelength;
-mh = wavelength;
+mw = wavelength;
 if (dispersionWavelengths == 1 && wavelength > 0.0) {
 float channel = floor(dz(CAMERA_WAVELENGTH) * 3.0);
-mh = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;
+mw = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;
 }
 
 
 
-Ray cam = nv();
+Ray cam = nN();
 
 RayTraceAuxiliary outAux;
 outAux.albedo = vec3(0.0);
@@ -584,38 +584,38 @@ outAux.normal = vec3(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
 
-vec4 aN = mj(cam, outAux);
+vec4 aF = my(cam, outAux);
 
 
 
 #ifdef CLAMPING
 float clamping = float(CLAMPING);
-aN.rgb = clamp(aN.rgb, -clamping, clamping);
+aF.rgb = clamp(aF.rgb, -clamping, clamping);
 #endif
 
 
 if (bf > 0.0) {
 
-aN.rgb *= 3.0;
+aF.rgb *= 3.0;
 if (dispersionWavelengths != 1) {
 
 
-aN.a /= 3.0;
+aF.a /= 3.0;
 }
 }
-if (!(aN.x < INF && aN.x > -EPS)) {
-aN = vec4(0, 0, 0, 1);
+if (!(aF.x < INF && aF.x > -EPS)) {
+aF = vec4(0, 0, 0, 1);
 }
 
-out_color = aN;
+out_color = aF;
 out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);
 out_normal = vec4(outAux.normal, 1.0);
 
 
-float jj = dot(aN.rgb, vec3(0.2126, 0.7152, 0.0722));
+float jq = dot(aF.rgb, vec3(0.2126, 0.7152, 0.0722));
 out_moments = outAux.isShadowCatcher
 ? vec4(0.0)
-: vec4(jj, jj * jj, 1.0, 0.0);
+: vec4(jq, jq * jq, 1.0, 0.0);
 
 }`
     });