@meimu/mutracer 0.2.0 → 0.3.1

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 eP(vec3 gz) {
+float phi = mod(atan(-gz.z, -gz.x), TWOPI);
+float theta = acos(clamp(gz.y, -1.0, 1.0));
 return vec2(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-vec2 dm(vec3 nO) {
-return eV(transpose(environmentRotation) * nO);
+vec2 cU(vec3 oA) {
+return eP(transpose(environmentRotation) * oA);
 }
 
-float rE(float u, out int vOffset, out float pdf) {
+float sN(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 sM(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 qG = 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 + qG, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + qG + 1, vOffset), 0).xy;
 
 pdf = s0.y;
 
-return (float(pO) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+return (float(qG) + (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 qx(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 = sN(random.x, vOffset, partialPdf.y);
+uv.x = sM(random.y, vOffset, partialPdf.x);
 
 float phi = uv.x * TWOPI;
 float theta = uv.y * PI;
-float ci = cos(theta);
+float cv = cos(theta);
 float sinTheta = sin(theta);
-float vM = cos(phi);
-float vX = sin(phi);
+float xV = cos(phi);
+float yo = sin(phi);
 
-vec3 dir = vec3(-sinTheta * vM, ci, -sinTheta * vX);
+vec3 dir = vec3(-sinTheta * xV, cv, -sinTheta * yo);
 
-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 vO = texelFetch(envMapDistribution, ivec2(1 + pixel.x, pixel.y), 0).y;
+float vP = texelFetch(envMapDistribution, ivec2(0, pixel.y), 0).y;
 
-return eW(vec2(ub, uc), uv.y);
+return envMapSolidAnglePdf(vec2(vO, vP), uv.y);
 }
 
-float dK(vec3 point, float height, float radius) {
-float ge = length(point);
-if (ge < 0.00001) {
+float dk(vec3 point, float height, float radius) {
+float gc = length(point);
+if (gc < 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 jf = radius * point.y / gc;
+float iS = -1.5 * height;
+float ez;
+if (jf >= 0.0) {
+ez = radius;
+} else if (jf < iS) {
+ez = -height * gc / point.y;
 } else {
-float cL = 1.0
-- iX * iX / (3.0 * iL * iL);
-eH = radius * cL;
+float cA = 1.0
+- jf * jf / (3.0 * iS * iS);
+ez = radius * cA;
 }
-return ge - eH;
+return gc - ez;
 }
 
-vec3 fd(vec3 origin, vec3 d) {
+vec3 eW(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 zZ = groundedBackgroundParams.z;
+vec3 bT = normalize(d);
+vec3 bA = origin - vec3(
 groundedBackgroundCenter.x,
-xB + height,
+zZ + 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 eN = dot(bA, bT);
+float bk = eN * eN
+- dot(bA, bA) + radius * radius;
+if (bk > 0.0) {
+float cB = -eN + sqrt(bk);
 if (
-cM > 0.0
-&& dK(bI, height, radius) <= 0.0
+cB > 0.0
+&& dk(bA, height, radius) <= 0.0
 ) {
-vec3 oK = bI + cf * cM;
-if (oK.y >= 0.0) {
-return normalize(oK);
+vec3 pw = bA + bT * cB;
+if (pw.y >= 0.0) {
+return normalize(pw);
 }
 
-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 (bT.y < -0.00001 && radius > 1.5 * height) {
+float iz = (-height - bA.y) / bT.y;
+vec3 pm = bA + bT * iz;
+float qb = (2.0 / 3.0)
 * sqrt(radius * radius - 2.25 * height * height);
-if (ir > 0.0 && length(oB.xz) <= pe) {
-return normalize(oB);
+if (iz > 0.0 && length(pm.xz) <= qb) {
+return normalize(pm);
 }
 }
 
-float cV = 0.0;
+float cK = 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 fp = (cK + cB) * 0.5;
+vec3 rD = bA + bT * fp;
+if (dk(rD, height, radius) > 0.0) {
+cB = fp;
 } else {
-cV = fB;
+cK = fp;
 }
 }
-vec3 hit = bI + cf * ((cV + cM) * 0.5);
+vec3 hit = bA + bT * ((cK + cB) * 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 cq(vec3 origin, vec3 d) {
+d = eW(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, eP(transpose(backgroundMapRotation) * d));
+return vec4(aW.rgb * t.z, aW.a);
 #else
-return textureLinear(backgroundMap, dm(d));
+return textureLinear(backgroundMap, cU(d));
 #endif
 }`
 });