@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -16,17 +16,17 @@ export default createShaderMixin({
         groundedBackgroundCenter: Shader.uniform('vec2')
     },
     main: glsl `
-vec2 eV(vec3 gx) {
-float phi = mod(atan(-gx.z, -gx.x), TWOPI);
-float theta = acos(clamp(gx.y, -1.0, 1.0));
+vec2 eF(vec3 gh) {
+float phi = mod(atan(-gh.z, -gh.x), TWOPI);
+float theta = acos(clamp(gh.y, -1.0, 1.0));
 return vec2(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-vec2 dm(vec3 nO) {
-return eV(transpose(environmentRotation) * nO);
+vec2 cT(vec3 nD) {
+return eF(transpose(environmentRotation) * nD);
 }
 
-float rE(float u, out int vOffset, out float pdf) {
+float rv(float u, out int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -52,7 +52,7 @@ pdf = s0.y;
 return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);
 }
 
-float rD(float u, int vOffset, out float pdf) {
+float ru(float u, int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -66,128 +66,128 @@ left = mid + 1;
 right = mid;
 }
 }
-int pO = left - 1;
+int pw = left - 1;
 
 
 
-vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + pO, vOffset), 0).xy;
-vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + pO + 1, vOffset), 0).xy;
+vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + pw, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + pw + 1, vOffset), 0).xy;
 
 pdf = s0.y;
 
-return (float(pO) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+return (float(pw) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
 }
 
 
-float eW(vec2 ew, float v) {
+float envMapSolidAnglePdf(vec2 partialPdf, float v) {
 if (!(v > 0.0 && v < 1.0)) { return 0.0; }
 float sinTheta = sin(min(v, 1.0 - v) * PI);
-return ew.x * ew.y * INVPI2 / (2.0 * sinTheta);
+return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);
 }
 
 
-vec3 pI(vec2 random, out vec2 uv, out float pdf) {
-vec2 ew;
+vec3 pn(vec2 random, out vec2 uv, out float pdf) {
+vec2 partialPdf;
 int vOffset;
 
-uv.y = rE(random.x, vOffset, ew.y);
-uv.x = rD(random.y, vOffset, ew.x);
+uv.y = rv(random.x, vOffset, partialPdf.y);
+uv.x = ru(random.y, vOffset, partialPdf.x);
 
 float phi = uv.x * TWOPI;
 float theta = uv.y * PI;
-float ci = cos(theta);
+float ct = cos(theta);
 float sinTheta = sin(theta);
-float vM = cos(phi);
-float vX = sin(phi);
+float vZ = cos(phi);
+float wr = sin(phi);
 
-vec3 dir = vec3(-sinTheta * vM, ci, -sinTheta * vX);
+vec3 dir = vec3(-sinTheta * vZ, ct, -sinTheta * wr);
 
-pdf = eW(ew, uv.y);
+pdf = envMapSolidAnglePdf(partialPdf, uv.y);
 
 return environmentRotation * dir;
 }
 
-float iT(vec2 uv) {
+float envMapPdf(vec2 uv) {
 vec2 size = vec2(textureSize(envMap, 0));
 
 ivec2 pixel = clamp(ivec2(uv * size), ivec2(0), ivec2(size) - ivec2(1));
 
-float ub = texelFetch(envMapDistribution, ivec2(1 + pixel.x, pixel.y), 0).y;
-float uc = texelFetch(envMapDistribution, ivec2(0, pixel.y), 0).y;
+float ue = texelFetch(envMapDistribution, ivec2(1 + pixel.x, pixel.y), 0).y;
+float uf = texelFetch(envMapDistribution, ivec2(0, pixel.y), 0).y;
 
-return eW(vec2(ub, uc), uv.y);
+return envMapSolidAnglePdf(vec2(ue, uf), uv.y);
 }
 
-float dK(vec3 point, float height, float radius) {
-float ge = length(point);
-if (ge < 0.00001) {
+float di(vec3 point, float height, float radius) {
+float fQ = length(point);
+if (fQ < 0.00001) {
 return -radius;
 }
 
-float iX = radius * point.y / ge;
-float iL = -1.5 * height;
-float eH;
-if (iX >= 0.0) {
-eH = radius;
-} else if (iX < iL) {
-eH = -height * ge / point.y;
+float iG = radius * point.y / fQ;
+float iq = -1.5 * height;
+float eq;
+if (iG >= 0.0) {
+eq = radius;
+} else if (iG < iq) {
+eq = -height * fQ / point.y;
 } else {
-float cL = 1.0
-- iX * iX / (3.0 * iL * iL);
-eH = radius * cL;
+float cv = 1.0
+- iG * iG / (3.0 * iq * iq);
+eq = radius * cv;
 }
-return ge - eH;
+return fQ - eq;
 }
 
-vec3 fd(vec3 origin, vec3 d) {
+vec3 eM(vec3 origin, vec3 d) {
 #ifdef USE_GROUNDED_BACKGROUND
 float height = groundedBackgroundParams.x;
 float radius = groundedBackgroundParams.y;
-float xB = groundedBackgroundParams.z;
-vec3 cf = normalize(d);
-vec3 bI = origin - vec3(
+float yd = groundedBackgroundParams.z;
+vec3 bS = normalize(d);
+vec3 bs = origin - vec3(
 groundedBackgroundCenter.x,
-xB + height,
+yd + height,
 groundedBackgroundCenter.y
 );
 
 
 
-float eT = dot(bI, cf);
-float br = eT * eT
-- dot(bI, bI) + radius * radius;
-if (br > 0.0) {
-float cM = -eT + sqrt(br);
+float eE = dot(bs, bS);
+float bj = eE * eE
+- dot(bs, bs) + radius * radius;
+if (bj > 0.0) {
+float cw = -eE + sqrt(bj);
 if (
-cM > 0.0
-&& dK(bI, height, radius) <= 0.0
+cw > 0.0
+&& di(bs, height, radius) <= 0.0
 ) {
-vec3 oK = bI + cf * cM;
-if (oK.y >= 0.0) {
-return normalize(oK);
+vec3 oA = bs + bS * cw;
+if (oA.y >= 0.0) {
+return normalize(oA);
 }
 
-if (cf.y < -0.00001 && radius > 1.5 * height) {
-float ir = (-height - bI.y) / cf.y;
-vec3 oB = bI + cf * ir;
-float pe = (2.0 / 3.0)
+if (bS.y < -0.00001 && radius > 1.5 * height) {
+float hP = (-height - bs.y) / bS.y;
+vec3 ot = bs + bS * hP;
+float oT = (2.0 / 3.0)
 * sqrt(radius * radius - 2.25 * height * height);
-if (ir > 0.0 && length(oB.xz) <= pe) {
-return normalize(oB);
+if (hP > 0.0 && length(ot.xz) <= oT) {
+return normalize(ot);
 }
 }
 
-float cV = 0.0;
+float cI = 0.0;
 for (int i = 0; i < 14; i++) {
-float fB = (cV + cM) * 0.5;
-vec3 qy = bI + cf * fB;
-if (dK(qy, height, radius) > 0.0) {
-cM = fB;
+float fd = (cI + cw) * 0.5;
+vec3 qq = bs + bS * fd;
+if (di(qq, height, radius) > 0.0) {
+cw = fd;
 } else {
-cV = fB;
+cI = fd;
 }
 }
-vec3 hit = bI + cf * ((cV + cM) * 0.5);
+vec3 hit = bs + bS * ((cI + cw) * 0.5);
 return normalize(hit);
 }
 }
@@ -195,15 +195,15 @@ return normalize(hit);
 return d;
 }
 
-vec4 cG(vec3 origin, vec3 d) {
-d = fd(origin, d);
+vec4 cn(vec3 origin, vec3 d) {
+d = eM(origin, d);
 #ifdef USE_BACKGROUND
 vec4 t = backgroundMapTransform;
 d = vec3(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
-vec4 bc = textureLinear(backgroundMap, eV(transpose(backgroundMapRotation) * d));
-return vec4(bc.rgb * t.z, bc.a);
+vec4 aW = textureLinear(backgroundMap, eF(transpose(backgroundMapRotation) * d));
+return vec4(aW.rgb * t.z, aW.a);
 #else
-return textureLinear(backgroundMap, dm(d));
+return textureLinear(backgroundMap, cT(d));
 #endif
 }`
 });