@meimu/mutracer 0.1.2 → 0.1.3

package/lib/renderer/WebGLJNLMDenoiser.js

@@ -45,27 +45,27 @@ void main() {
 ivec2 p = ivec2(gl_FragCoord.xy);
 ivec2 size = rawGuideTexRegion();
 vec2 center = load_rawGuideTex(p, 0).xy;
-float lg = 0.0;
-float iX = 0.0;
-float mL = 0.0;
-float iR = 0.0;
+float lk = 0.0;
+float iY = 0.0;
+float mO = 0.0;
+float iS = 0.0;
 for (int dy = -1; dy <= 1; dy++) {
 for (int dx = -1; dx <= 1; dx++) {
 vec2 value = load_rawGuideTex(clamp(p + ivec2(dx, dy), ivec2(0), size - 1), 0).xy;
-mL += value.x;
-iR += value.x * value.x;
+mO += value.x;
+iS += value.x * value.x;
 if (value.y >= 0.0) {
-lg += value.y;
-iX += 1.0;
+lk += value.y;
+iY += 1.0;
 }
 }
 }
 float variance;
 if (center.y >= 0.0) {
-variance = lg / iX;
+variance = lk / iY;
 } else {
-float lf = mL / 9.0;
-variance = max(iR / 9.0 - lf * lf, 0.0) * 9.0 / 8.0;
+float lj = mO / 9.0;
+variance = max(iS / 9.0 - lj * lj, 0.0) * 9.0 / 8.0;
 }
 out_guide = vec4(center.x, variance, 0.0, 1.0);
 }`
@@ -105,29 +105,29 @@ const filterFragment = new FragmentShader({
 
 ivec2 imageSize;
 
-vec2 nq(ivec2 p) {
+vec2 nt(ivec2 p) {
 return load_guideTex(clamp(p, ivec2(0), imageSize - 1), 0).xy;
 }
 
 
-vec4 rv(ivec2 p) {
+vec4 rD(ivec2 p) {
 vec4 c = load_colorTex(p, 0);
 if (decodeInput) c.rgb = pow(max(c.rgb, 0.0), vec3(2.2));
 return vec4(c.rgb * c.a, c.a);
 }
 
-float lk(ivec2 q, vec4 bs, vec3 gM) {
+float ln(ivec2 q, vec4 bs, vec3 gO) {
 vec4 albedo = load_albedoTex(q, 0);
 
 
-vec3 oS = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 kR = (albedo.rgb - bs.rgb) / oS;
-float iO = albedo.a - bs.a;
-vec3 lb = load_normalTex(q, 0).rgb - gM;
+vec3 oW = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 kU = (albedo.rgb - bs.rgb) / oW;
+float iP = albedo.a - bs.a;
+vec3 le = load_normalTex(q, 0).rgb - gO;
 return max(
-dot(kR, kR) * INV_ALBEDO_BANDWIDTH2
-+ iO * iO * INV_COVERAGE_BANDWIDTH2,
-dot(lb, lb) * INV_NORMAL_BANDWIDTH2
+dot(kU, kU) * INV_ALBEDO_BANDWIDTH2
++ iP * iP * INV_COVERAGE_BANDWIDTH2,
+dot(le, le) * INV_NORMAL_BANDWIDTH2
 );
 }
 
@@ -136,37 +136,37 @@ imageSize = guideTexRegion();
 ivec2 p = ivec2(gl_FragCoord.xy);
 vec4 bs = load_albedoTex(p, 0);
 vec4 fw = load_normalTex(p, 0);
-vec3 gM = fw.rgb;
+vec3 gO = fw.rgb;
 
 
 if (fw.a <= 0.0 && load_shadowCatcherTex(p, 0).r <= 0.0) {
-vec4 c = rv(p);
+vec4 c = rD(p);
 vec3 rgb = c.rgb / max(c.a, 1e-6);
 if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
 out_color = vec4(rgb, c.a);
-out_guide = vec4(nq(p), 0.0, 1.0);
+out_guide = vec4(nt(p), 0.0, 1.0);
 return;
 }
 
-vec2 kT[PATCH_SIZE];
+vec2 kW[PATCH_SIZE];
 int k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-kT[k] = nq(p + ivec2(dx, dy) * dilation);
+kW[k] = nt(p + ivec2(dx, dy) * dilation);
 k++;
 }
 }
 float k2 = colorSensitivity * colorSensitivity;
 
 vec4 sum = vec4(0.0);
-vec3 gP = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 mb = vec3(0.0);
-vec3 gs = vec3(0.0);
+vec3 gR = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 mf = vec3(0.0);
+vec3 gt = vec3(0.0);
 vec3 hn = vec3(0.0);
-float pg = 0.0;
-float gu = 0.0;
-float nH = 0.0;
-float kA = 0.0;
+float pk = 0.0;
+float gv = 0.0;
+float nK = 0.0;
+float kD = 0.0;
 for (int sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
 for (int sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
 ivec2 q = p + ivec2(sx, sy) * dilation;
@@ -174,17 +174,17 @@ if (
 (sx == 0 && sy == 0) ||
 q.x < 0 || q.y < 0 || q.x >= imageSize.x || q.y >= imageSize.y
 ) continue;
-float features = lk(q, bs, gM);
+float features = ln(q, bs, gO);
 if (features > 16.0) continue;
 
 float fT = 0.0;
 k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-vec2 a = kT[k];
-vec2 b = nq(q + ivec2(dx, dy) * dilation);
-float qH = a.x - b.x;
-fT += (qH * qH
+vec2 a = kW[k];
+vec2 b = nt(q + ivec2(dx, dy) * dilation);
+float qL = a.x - b.x;
+fT += (qL * qL
 - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
 / (1e-10 + k2 * (a.y + b.y));
 k++;
@@ -193,49 +193,49 @@ k++;
 fT /= float(PATCH_SIZE);
 
 float weight = exp(-max(max(fT, 0.0), features));
-vec2 g = nq(q);
+vec2 g = nt(q);
 
-vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gP;
-vec4 value = rv(q);
+vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gR;
+vec4 value = rD(q);
 sum += value * weight;
-mb += a * weight;
-gs += a * a * weight;
+mf += a * weight;
+gt += a * a * weight;
 hn += a * value.rgb * weight;
-pg += g.x * weight;
-gu += g.y * weight * weight;
-nH += weight;
-kA = max(kA, weight);
+pk += g.x * weight;
+gv += g.y * weight * weight;
+nK += weight;
+kD = max(kD, weight);
 }
 }
 
 
 
-vec4 center = rv(p);
-vec2 kS = nq(p);
-float dF = max(kA, CENTER_WEIGHT_MIN);
-float totalWeight = nH + dF;
+vec4 center = rD(p);
+vec2 kV = nt(p);
+float dF = max(kD, CENTER_WEIGHT_MIN);
+float totalWeight = nK + dF;
 vec4 mean = (sum + center * dF) / totalWeight;
 
 
-vec3 ez = mb / totalWeight;
-vec3 ll = max(gs / totalWeight - ez * ez, vec3(0.0));
-vec3 qi = hn / totalWeight - ez * mean.rgb;
+vec3 ez = mf / totalWeight;
+vec3 lo = max(gt / totalWeight - ez * ez, vec3(0.0));
+vec3 qm = hn / totalWeight - ez * mean.rgb;
 
 
 
-vec3 qs = bs.rgb + ez * gP;
-vec3 ol = mean.rgb * gP / max(qs, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 vm = clamp(qi / (ll + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), ol);
-vec3 rn = mean.rgb - vm * ez;
-vec4 filtered = vec4(max(rn, vec3(0.0)), max(mean.a, 0.0));
+vec3 qw = bs.rgb + ez * gR;
+vec3 oq = mean.rgb * gR / max(qw, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 vs = clamp(qm / (lo + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), oq);
+vec3 rs = mean.rgb - vs * ez;
+vec4 filtered = vec4(max(rs, vec3(0.0)), max(mean.a, 0.0));
 vec3 rgb = filtered.a > 1e-6
 ? filtered.rgb / max(filtered.a, 1e-6)
 : center.rgb / max(center.a, 1e-6);
 if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
 out_color = vec4(rgb, filtered.a);
 out_guide = vec4(
-(pg + kS.x * dF) / totalWeight,
-(gu + kS.y * dF * dF)
+(pk + kV.x * dF) / totalWeight,
+(gv + kV.y * dF * dF)
 / (totalWeight * totalWeight),
 0.0,
 1.0

package/lib/renderer/WebGLRayTraceOutputPass.js

@@ -42,11 +42,11 @@ vec4 mask = sample_shadowCatcherTex(v_Texcoord);
 vec4 background = sample_catcherBackgroundTex(v_Texcoord);
 float hit = sample_albedoTex(v_Texcoord).a;
 
-float pW = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
-float iP = max(hit - mask.b * pW, 0.0);
+float qa = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
+float iQ = max(hit - mask.b * qa, 0.0);
 out_foreground = vec4(
-(light.rgb - background.rgb * pW)
-/ (iP > 0.0 ? iP : sampleCount),
+(light.rgb - background.rgb * qa)
+/ (iQ > 0.0 ? iQ : sampleCount),
 clamp((light.a - background.a) / sampleCount, 0.0, 1.0)
 );
 out_catcherBackground = background / sampleCount;

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

@@ -3,7 +3,7 @@
 // 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 hz(vec2 fD) {
+Ray hy(vec2 fD) {
 vec4 origin = viewProjectionInv * vec4(fD * 2.0 - 1.0, -1.0, 1.0);
 vec4 target = viewProjectionInv * vec4(fD * 2.0 - 1.0, 1.0, 1.0);
 Ray cam;
@@ -12,7 +12,7 @@ iw(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * ta
 return cam;
 }
 
-vec2 oz(vec2 p) {
+vec2 oC(vec2 p) {
 p = 2.0 * p - 1.0;
 bool greater = abs(p.x) > abs(p.y);
 float r = greater ? p.x : p.y;
@@ -20,16 +20,16 @@ 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 nv() {
-Ray cam = hz(v_Texcoord + rN());
+Ray nC() {
+Ray cam = hy(v_Texcoord + rS());
 if (cameraApertureRadius > 0.0) {
 
 vec3 eye = viewInv[3].xyz;
-vec3 nV = -normalize(viewInv[2].xyz);
-vec3 qm = eye + cam.d * (cameraFocusDistance / dot(cam.d, nV));
-vec2 ru = cameraApertureRadius * oz(fk(CAMERA_LENS));
-vec3 origin = vec3(viewInv * vec4(ru, 0.0, 1.0));
-iw(cam, origin, normalize(qm - origin));
+vec3 nY = -normalize(viewInv[2].xyz);
+vec3 qq = eye + cam.d * (cameraFocusDistance / dot(cam.d, nY));
+vec2 rC = cameraApertureRadius * oC(fk(CAMERA_LENS));
+vec3 origin = vec3(viewInv * vec4(rC, 0.0, 1.0));
+iw(cam, origin, normalize(qq - origin));
 }
 return cam;
 }

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

@@ -13,13 +13,13 @@ export default createShaderMixin({
         groundedBackgroundCenter: Shader.uniform('vec2')
     },
     main: glsl `
-vec2 aS(vec3 gb) {
-float phi = mod(atan(-gb.z, -gb.x), TWOPI);
-float theta = acos(gb.y);
+vec2 aS(vec3 gc) {
+float phi = mod(atan(-gc.z, -gc.x), TWOPI);
+float theta = acos(gc.y);
 return vec2(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-float qp(float u, out int vOffset, out float pdf) {
+float qt(float u, out int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -45,7 +45,7 @@ pdf = s0.y;
 return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);
 }
 
-float qo(float u, int vOffset, out float pdf) {
+float qs(float u, int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -59,36 +59,36 @@ left = mid + 1;
 right = mid;
 }
 }
-int oG = left - 1;
+int oJ = left - 1;
 
 
 
-vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oG, vOffset), 0).xy;
-vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oG + 1, vOffset), 0).xy;
+vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oJ, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oJ + 1, vOffset), 0).xy;
 
 pdf = s0.y;
 
-return (float(oG) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+return (float(oJ) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
 }
 
 
-vec3 oA(vec2 random, out vec2 uv, out float pdf) {
-vec2 gY;
+vec3 oD(vec2 random, out vec2 uv, out float pdf) {
+vec2 gZ;
 int vOffset;
 
-uv.y = qp(random.x, vOffset, gY.y);
-uv.x = qo(random.y, vOffset, gY.x);
+uv.y = qt(random.x, vOffset, gZ.y);
+uv.x = qs(random.y, vOffset, gZ.x);
 
 float phi = uv.x * TWOPI;
 float theta = uv.y * PI;
 float cc = cos(theta);
 float sinTheta = sin(theta);
-float tZ = cos(phi);
-float uh = sin(phi);
+float ue = cos(phi);
+float um = sin(phi);
 
-vec3 dir = vec3(-sinTheta * tZ, cc, -sinTheta * uh);
+vec3 dir = vec3(-sinTheta * ue, cc, -sinTheta * um);
 
-pdf = gY.x * gY.y * INVPI2 / (2.0 * sinTheta);
+pdf = gZ.x * gZ.y * INVPI2 / (2.0 * sinTheta);
 
 return dir;
 }
@@ -100,28 +100,28 @@ float sinTheta = sin(uv.y * PI);
 
 uv *= size;
 
-float sw = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;
-float sz = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;
+float sD = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;
+float sE = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;
 
-return sw * sz * INVPI2 / (2.0 * sinTheta);
+return sD * sE * INVPI2 / (2.0 * sinTheta);
 }
 
-float dq(vec3 sA, float height, float radius) {
-float fN = length(sA);
+float dq(vec3 sF, float height, float radius) {
+float fN = length(sF);
 if (fN < 0.00001) {
 return -radius;
 }
 
-float iC = radius * sA.y / fN;
-float ik = -1.5 * height;
+float iC = radius * sF.y / fN;
+float ij = -1.5 * height;
 float ev;
 if (iC >= 0.0) {
 ev = radius;
-} else if (iC < ik) {
-ev = -height * fN / sA.y;
+} else if (iC < ij) {
+ev = -height * fN / sF.y;
 } else {
 float dW = 1.0
-- iC * iC / (3.0 * ik * ik);
+- iC * iC / (3.0 * ij * ij);
 ev = radius * dW;
 }
 return fN - ev;
@@ -131,11 +131,11 @@ vec3 eQ(vec3 origin, vec3 d) {
 #ifdef USE_GROUNDED_BACKGROUND
 float height = groundedBackgroundParams.x;
 float radius = groundedBackgroundParams.y;
-float vB = groundedBackgroundParams.z;
+float vG = groundedBackgroundParams.z;
 vec3 bY = normalize(d);
 vec3 bB = origin - vec3(
 groundedBackgroundCenter.x,
-vB + height,
+vG + height,
 groundedBackgroundCenter.y
 );
 
@@ -145,37 +145,37 @@ float eI = dot(bB, bY);
 float ej = eI * eI
 - dot(bB, bB) + radius * radius;
 if (ej > 0.0) {
-float cB = -eI + sqrt(ej);
+float cC = -eI + sqrt(ej);
 if (
-cB > 0.0
+cC > 0.0
 && dq(bB, height, radius) <= 0.0
 ) {
-vec3 nB = bB + bY * cB;
-if (nB.y >= 0.0) {
-return normalize(nB);
+vec3 nE = bB + bY * cC;
+if (nE.y >= 0.0) {
+return normalize(nE);
 }
 
 if (bY.y < -0.00001 && radius > 1.5 * height) {
-float hQ = (-height - bB.y) / bY.y;
-vec3 nk = bB + bY * hQ;
-float nZ = (2.0 / 3.0)
+float hP = (-height - bB.y) / bY.y;
+vec3 nq = bB + bY * hP;
+float oc = (2.0 / 3.0)
 * sqrt(radius * radius - 2.25 * height * height);
-if (hQ > 0.0 && length(nk.xz) <= nZ) {
-return normalize(nk);
+if (hP > 0.0 && length(nq.xz) <= oc) {
+return normalize(nq);
 }
 }
 
 float cN = 0.0;
 for (int i = 0; i < 14; i++) {
-float fe = (cN + cB) * 0.5;
-vec3 pp = bB + bY * fe;
-if (dq(pp, height, radius) > 0.0) {
-cB = fe;
+float fe = (cN + cC) * 0.5;
+vec3 pt = bB + bY * fe;
+if (dq(pt, height, radius) > 0.0) {
+cC = fe;
 } else {
 cN = fe;
 }
 }
-vec3 hit = bB + bY * ((cN + cB) * 0.5);
+vec3 hit = bB + bY * ((cN + cC) * 0.5);
 return normalize(hit);
 }
 }
@@ -183,7 +183,7 @@ return normalize(hit);
 return d;
 }
 
-vec4 cw(vec3 origin, vec3 d) {
+vec4 cx(vec3 origin, vec3 d) {
 d = eQ(origin, d);
 vec2 uv = aS(d);
 return textureLinear(backgroundMap, uv);