@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -26,10 +26,10 @@ const uint BOUNCE_STRIDE = 64u;
 
 uvec2 bc;
 uint bd;
-uint cE = 0u;
+uint cF = 0u;
 uint em = 0u;
-uint eg(uint ki) {
-uint x = ki;
+uint eg(uint kk) {
+uint x = kk;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
@@ -37,28 +37,28 @@ return x ^ (x >> 16u);
 uint aq(uint a, uint b) {
 return eg(a ^ eg(b + 0x9e3779b9u));
 }
-uint iA(uint ki, uint ie) {
-uint x = ki + ie;
+uint iA(uint kk, uint ic) {
+uint x = kk + ic;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-uint sv(uint x, uint ie) {
-return reverseBits(iA(reverseBits(x), ie));
+uint sC(uint x, uint ic) {
+return reverseBits(iA(reverseBits(x), ic));
 }
 
-uint qX(uint ki) {
-uint r = reverseBits(ki);
+uint rb(uint kk) {
+uint r = reverseBits(kk);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 vC(uint index, uint ie) {
-uint i = sv(index, aq(ie, 0u));
-uint x = reverseBits(iA(i, aq(ie, 1u)));
-uint y = sv(qX(i), aq(ie, 2u));
+vec2 vI(uint index, uint ic) {
+uint i = sC(index, aq(ic, 0u));
+uint x = reverseBits(iA(i, aq(ic, 1u)));
+uint y = sC(rb(i), aq(ic, 2u));
 return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
 }
-uint tj(uvec2 p) {
+uint tp(uvec2 p) {
 uvec2 v = p & uvec2(255u);
 v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);
 v = (v | (v << uvec2(2u))) & uvec2(0x3333u);
@@ -66,35 +66,35 @@ v = (v | (v << uvec2(1u))) & uvec2(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const uint Z_PERM_${i} = ${v}u;`).join("\n")}
-uint kk(uint tm) {
-uint group = tm >> 2u;
+uint km(uint tu) {
+uint group = tu >> 2u;
 uint word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = group == ${i}u ? Z_PERM_${i} : word;`).join("\n  ")}
-return (word >> ((tm & 3u) * 8u)) & 255u;
+return (word >> ((tu & 3u) * 8u)) & 255u;
 }
-uint pK(uint kB, uint dim, uint logSPP) {
+uint pO(uint kE, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint tZ = 8u + ((logSPP + 1u) >> 1u);
+uint uf = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(tZ) - 1; digit >= int(odd); digit--) {
+for (int digit = int(uf) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
-uint sd = 0u;
-if (shift < 30u) { sd = kB >> (shift + 2u); }
-uint tm = (eg(sd ^ (0x55555555u * dim)) >> 24u) % 24u;
-uint d = (kB >> shift) & 3u;
-result |= ((kk(tm) >> (2u*d)) & 3u) << shift;
+uint sj = 0u;
+if (shift < 30u) { sj = kE >> (shift + 2u); }
+uint tu = (eg(sj ^ (0x55555555u * dim)) >> 24u) % 24u;
+uint d = (kE >> shift) & 3u;
+result |= ((km(tu) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kB & 1u) ^ (eg((kB >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kE & 1u) ^ (eg((kE >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-uint cv(uint slot) {
-return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cE * BOUNCE_STRIDE + slot;
+uint cw(uint slot) {
+return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
 }
 
 uvec4 hh;
@@ -102,41 +102,41 @@ uint hi;
 bool fv = false;
 bool df = false;
 uint dE;
-uint gp;
+uint gq;
 vec2 eN;
 void dw(uint dim) {
 
-uint jU = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uvec4 key = uvec4(dim, bd, jU, uint(sequenceSeed));
+uint jW = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uvec4 key = uvec4(dim, bd, jW, uint(sequenceSeed));
 if (fv && all(equal(hh, key)) && hi == uint(zSobolLogSPP)) { return; }
 hh = key; hi = uint(zSobolLogSPP);
 fv = true; df = false;
-uint ie = aq(aq(jU, dim), uint(sequenceSeed));
+uint ic = aq(aq(jW, dim), uint(sequenceSeed));
 uint index = bd;
 if (samplingPattern == 1) {
 uint logSPP = uint(zSobolLogSPP);
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-uint iV = index >> logSPP;
+uint iW = index >> logSPP;
 uint mask = (1u << logSPP) - 1u;
-uint kB = (tj(bc) << logSPP) | (index & mask);
-index = pK(kB, dim, logSPP);
+uint kE = (tp(bc) << logSPP) | (index & mask);
+index = pO(kE, dim, logSPP);
 uvec2 tile = bc >> uvec2(8u);
-ie = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
+ic = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
 
-if (bd != 0u) { iV += 1u; }
-ie = aq(ie, iV);
+if (bd != 0u) { iW += 1u; }
+ic = aq(ic, iW);
 }
-dE = sv(index, aq(ie, 0u));
-gp = ie;
-uint x = reverseBits(iA(dE, aq(ie, 1u)));
+dE = sC(index, aq(ic, 0u));
+gq = ic;
+uint x = reverseBits(iA(dE, aq(ic, 1u)));
 eN.x = float(x >> 8u) * (1.0 / 16777216.0);
 }
-vec2 kG(uint dim) {
+vec2 kJ(uint dim) {
 dw(dim);
 if (!df) {
-uint y = sv(qX(dE), aq(gp, 2u));
+uint y = sC(rb(dE), aq(gq, 2u));
 eN.y = float(y >> 8u) * (1.0 / 16777216.0);
 df = true;
 }
@@ -152,18 +152,18 @@ if (samplingPattern == 2) {
 float x = dz(dim); float y = dz(dim);
 return vec2(x,y);
 }
-return kG(dim);
+return kJ(dim);
 }
 
 float eo(uint slot) {
-uint dim = aq(aq(cE, slot), em) | 0x80000000u;
+uint dim = aq(aq(cF, slot), em) | 0x80000000u;
 em += 1u;
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-uint jU = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uint ie = aq(aq(jU, dim), uint(sequenceSeed));
-uint i = sv(bd, aq(ie, 0u));
-uint x = reverseBits(iA(i, aq(ie, 1u)));
+uint jW = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uint ic = aq(aq(jW, dim), uint(sequenceSeed));
+uint i = sC(bd, aq(ic, 0u));
+uint x = reverseBits(iA(i, aq(ic, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -9,16 +9,16 @@ vec4 textureLinear(sampler2D map, vec2 uv) {
 return texture(map, uv);
 #else
 vec2 size = vec2(textureSize(map, 0));
-vec2 pO = 1.0 / size;
+vec2 pS = 1.0 / size;
 
 uv = uv * size - 0.5;
 vec2 f = fract(uv);
 uv = floor(uv) + 0.5;
 
-vec4 s1 = texture(map, (uv + vec2(0, 0)) * pO);
-vec4 s2 = texture(map, (uv + vec2(1, 0)) * pO);
-vec4 s3 = texture(map, (uv + vec2(0, 1)) * pO);
-vec4 s4 = texture(map, (uv + vec2(1, 1)) * pO);
+vec4 s1 = texture(map, (uv + vec2(0, 0)) * pS);
+vec4 s2 = texture(map, (uv + vec2(1, 0)) * pS);
+vec4 s3 = texture(map, (uv + vec2(0, 1)) * pS);
+vec4 s4 = texture(map, (uv + vec2(1, 1)) * pS);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 #endif

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

@@ -8,7 +8,7 @@ float phi = acos(n.y) / PI;
 return vec2(theta, 1.0 - phi);
 }
 
-vec2 iL(vec3 pos, vec3 normal, vec2 uvScale) {
+vec2 iM(vec3 pos, vec3 normal, vec2 uvScale) {
 vec3 dm = abs(normal);
 vec2 uv = vec2(0.0);
 if (dm.x > dm.y && dm.x > dm.z) {
@@ -53,18 +53,18 @@ return fract(uv * uvScale);
 
 
 
-vec2 hA(vec3 pos, vec3 normal) {
+vec2 hz(vec3 pos, vec3 normal) {
 float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gz(int fh, vec3 pos, vec3 normal, vec2 uvScale) {
+vec2 gC(int fh, vec3 pos, vec3 normal, vec2 uvScale) {
 if (fh == ${uvProjectionConstants.triplanar + ''}) {
-return iL(pos, normal, uvScale);
+return iM(pos, normal, uvScale);
 } else if (fh == ${uvProjectionConstants.spherical + ''}) {
 return sphericalProjection(pos) * uvScale;
 } else if (fh == ${uvProjectionConstants.cylindrical + ''}) {
-return hA(pos, normal) * uvScale;
+return hz(pos, normal) * uvScale;
 }
 return vec2(0.0);
 }

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

@@ -35,7 +35,7 @@ vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
 Ray ray;
 iw(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 vec3 eye = viewInv[3].xyz;
-vec3 nV = -normalize(viewInv[2].xyz);
+vec3 nY = -normalize(viewInv[2].xyz);
 ad si;
 si.triangleIndex = -1;
 for (int layer = 0; layer < 32; layer++) {
@@ -44,7 +44,7 @@ if (!si.hit) return;
 J material;
 eT(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-out_depth.r = max(dot(si.position - eye, nV), 0.0);
+out_depth.r = max(dot(si.position - eye, nY), 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

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

@@ -16,22 +16,22 @@ const normalizeRayTraceOutput = new FragmentShader({
     main: glsl `
 void main() {
 vec2 uv = lightScale * v_Texcoord;
-vec4 rI = sample_albedoTex(uv);
-float hit = rI.a;
-vec4 rM = sample_normalTex(uv);
+vec4 rN = sample_albedoTex(uv);
+float hit = rN.a;
+vec4 rR = sample_normalTex(uv);
 
 
 
-float sc = max(rM.a, 1.0);
-vec3 albedo = rI.rgb / sc;
-vec3 normal = rM.rgb / sc;
+float sh = max(rR.a, 1.0);
+vec3 albedo = rN.rgb / sh;
+vec3 normal = rR.rgb / sh;
 vec4 shadowCatcher= sample_shadowCatcherTex(uv) / sampleCount;
-vec4 sk = sample_colorTex(uv);
+vec4 sq = sample_colorTex(uv);
 
 
 
 
-vec4 light = vec4(sk.rgb / (hit > 0.0 ? hit : sampleCount), sk.a / sampleCount);
+vec4 light = vec4(sq.rgb / (hit > 0.0 ? hit : sampleCount), sq.a / sampleCount);