@meimu/mutracer 0.1.4 → 0.1.5

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

@@ -3,16 +3,16 @@
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
 // Shared primary-ray construction keeps beauty and catcher coverage aligned.
 export default /* glsl */ `
-Ray hC(vec2 fG) {
-vec4 origin = viewProjectionInv * vec4(fG * 2.0 - 1.0, -1.0, 1.0);
-vec4 target = viewProjectionInv * vec4(fG * 2.0 - 1.0, 1.0, 1.0);
+Ray hC(vec2 fH) {
+vec4 origin = viewProjectionInv * vec4(fH * 2.0 - 1.0, -1.0, 1.0);
+vec4 target = viewProjectionInv * vec4(fH * 2.0 - 1.0, 1.0, 1.0);
 Ray cam;
 iC(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 
 return cam;
 }
 
-vec2 oL(vec2 p) {
+vec2 oK(vec2 p) {
 p = 2.0 * p - 1.0;
 bool greater = abs(p.x) > abs(p.y);
 float r = greater ? p.x : p.y;
@@ -20,14 +20,14 @@ float theta = greater ? 0.25 * PI * p.y / p.x : PI * (0.5 - 0.25 * p.x / p.y);
 return r * vec2(cos(theta), sin(theta));
 }
 
-Ray nN() {
+Ray nM() {
 Ray cam = hC(v_Texcoord + sa());
 if (cameraApertureRadius > 0.0) {
 
 vec3 eye = viewInv[3].xyz;
-vec3 ol = -normalize(viewInv[2].xyz);
-vec3 qy = eye + cam.d * (cameraFocusDistance / dot(cam.d, ol));
-vec2 rK = cameraApertureRadius * oL(fo(CAMERA_LENS));
+vec3 oj = -normalize(viewInv[2].xyz);
+vec3 qy = eye + cam.d * (cameraFocusDistance / dot(cam.d, oj));
+vec2 rK = cameraApertureRadius * oK(fp(CAMERA_LENS));
 vec3 origin = vec3(viewInv * vec4(rK, 0.0, 1.0));
 iC(cam, origin, normalize(qy - origin));
 }

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

@@ -15,14 +15,14 @@ export default createShaderMixin({
         groundedBackgroundCenter: Shader.uniform('vec2')
     },
     main: glsl `
-vec2 eL(vec3 gg) {
-float phi = mod(atan(-gg.z, -gg.x), TWOPI);
-float theta = acos(clamp(gg.y, -1.0, 1.0));
+vec2 eL(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 cY(vec3 mQ) {
-return eL(transpose(environmentRotation) * mQ);
+vec2 cY(vec3 mP) {
+return eL(transpose(environmentRotation) * mP);
 }
 
 float qB(float u, out int vOffset, out float pdf) {
@@ -65,25 +65,25 @@ left = mid + 1;
 right = mid;
 }
 }
-int oS = left - 1;
+int oR = left - 1;
 
 
 
-vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oS, vOffset), 0).xy;
-vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oS + 1, vOffset), 0).xy;
+vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oR, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oR + 1, vOffset), 0).xy;
 
 pdf = s0.y;
 
-return (float(oS) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+return (float(oR) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
 }
 
 
-vec3 oM(vec2 random, out vec2 uv, out float pdf) {
-vec2 hd;
+vec3 oL(vec2 random, out vec2 uv, out float pdf) {
+vec2 he;
 int vOffset;
 
-uv.y = qB(random.x, vOffset, hd.y);
-uv.x = qA(random.y, vOffset, hd.x);
+uv.y = qB(random.x, vOffset, he.y);
+uv.x = qA(random.y, vOffset, he.x);
 
 float phi = uv.x * TWOPI;
 float theta = uv.y * PI;
@@ -94,7 +94,7 @@ float uw = sin(phi);
 
 vec3 dir = vec3(-sinTheta * ul, cc, -sinTheta * uw);
 
-pdf = hd.x * hd.y * INVPI2 / (2.0 * sinTheta);
+pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
 
 return environmentRotation * dir;
 }
@@ -113,24 +113,24 @@ return sL * sM * INVPI2 / (2.0 * sinTheta);
 }
 
 float dq(vec3 sN, float height, float radius) {
-float fQ = length(sN);
-if (fQ < 0.00001) {
+float fR = length(sN);
+if (fR < 0.00001) {
 return -radius;
 }
 
-float iG = radius * sN.y / fQ;
+float iG = radius * sN.y / fR;
 float iq = -1.5 * height;
 float ev;
 if (iG >= 0.0) {
 ev = radius;
 } else if (iG < iq) {
-ev = -height * fQ / sN.y;
+ev = -height * fR / sN.y;
 } else {
 float dW = 1.0
 - iG * iG / (3.0 * iq * iq);
 ev = radius * dW;
 }
-return fQ - ev;
+return fR - ev;
 }
 
 vec3 eT(vec3 origin, vec3 d) {
@@ -156,18 +156,18 @@ if (
 cC > 0.0
 && dq(bB, height, radius) <= 0.0
 ) {
-vec3 nP = bB + bY * cC;
-if (nP.y >= 0.0) {
-return normalize(nP);
+vec3 nO = bB + bY * cC;
+if (nO.y >= 0.0) {
+return normalize(nO);
 }
 
 if (bY.y < -0.00001 && radius > 1.5 * height) {
 float hT = (-height - bB.y) / bY.y;
-vec3 nF = bB + bY * hT;
-float oo = (2.0 / 3.0)
+vec3 nE = bB + bY * hT;
+float om = (2.0 / 3.0)
 * sqrt(radius * radius - 2.25 * height * height);
-if (hT > 0.0 && length(nF.xz) <= oo) {
-return normalize(nF);
+if (hT > 0.0 && length(nE.xz) <= om) {
+return normalize(nE);
 }
 }