@meimu/mutracer 0.1.3 → 0.1.5

package/lib/renderer/wgsl/chunks/sampling.wgsl.js

@@ -4,70 +4,70 @@ export default /*wgsl*/ `
 
 
 fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
-let rc = vec3f(alpha, 1.0);
-let gf = normalize(rc * view);
-let ua = min(gf.z, 1.0);
-let qH = 1.0 + ua;
-let qX = (1.0 - samplePoint.y) * qH;
-let rJ = samplePoint.y * qH;
-let sA = qX + (1.0 - ua);
-let fi = sqrt(max(0.0, sA * rJ));
+let rm = vec3f(alpha, 1.0);
+let gk = normalize(rm * view);
+let uh = min(gk.z, 1.0);
+let qQ = 1.0 + uh;
+let rh = (1.0 - samplePoint.y) * qQ;
+let rR = samplePoint.y * qQ;
+let sI = rh + (1.0 - uh);
+let fl = sqrt(max(0.0, sI * rR));
 let br = TWOPI * samplePoint.x;
-let lw = vec3f(
-gf.x + fi * cos(br),
-gf.y + fi * sin(br),
-qX
+let lI = vec3f(
+gk.x + fl * cos(br),
+gk.y + fl * sin(br),
+rh
 );
-return normalize(rc * lw);
+return normalize(rm * lI);
 }
 
-fn gG(od: vec3f, alpha: vec2f) -> f32 {
-let hm = vec3f(
-od.x / alpha.x,
-od.y / alpha.y,
-od.z
+fn gL(oo: vec3f, alpha: vec2f) -> f32 {
+let hr = vec3f(
+oo.x / alpha.x,
+oo.y / alpha.y,
+oo.z
 );
-let ap = dot(hm, hm);
+let ap = dot(hr, hr);
 return 1.0 / (
 PI * alpha.x * alpha.y * ap * ap
 );
 }
 
 fn bk(direction: vec3f, alpha: vec2f) -> f32 {
-let eE = abs(direction.z);
-if (eE <= 1e-8) {
+let eF = abs(direction.z);
+if (eF <= 1e-8) {
 return 0.0;
 }
-let hY = alpha * direction.xy;
-let lA = dot(hY, hY)
-/ (eE * eE);
-return 2.0 / (1.0 + sqrt(1.0 + lA));
+let ic = alpha * direction.xy;
+let lJ = dot(ic, ic)
+/ (eF * eF);
+return 2.0 / (1.0 + sqrt(1.0 + lJ));
 }
 
 fn aE(au: f32) -> f32 {
-let dg = clamp(1.0 - au, 0.0, 1.0);
-return pow(dg, 5.0);
+let di = clamp(1.0 - au, 0.0, 1.0);
+return pow(di, 5.0);
 }
 
 fn cu(L: f32, cJ: f32) -> f32 {
-let iu = clamp(abs(L), 0.0, 1.0);
-let ke = cJ * cJ
-* max(0.0, 1.0 - iu * iu);
-if (ke >= 1.0) {
+let iA = clamp(abs(L), 0.0, 1.0);
+let kl = cJ * cJ
+* max(0.0, 1.0 - iA * iA);
+if (kl >= 1.0) {
 return 1.0;
 }
 
-let lK = sqrt(max(0.0, 1.0 - ke));
-let ba = (iu - cJ * lK)
-/ max(iu + cJ * lK, 1e-8);
-let pw = (cJ * iu - lK)
-/ max(cJ * iu + lK, 1e-8);
+let lT = sqrt(max(0.0, 1.0 - kl));
+let ba = (iA - cJ * lT)
+/ max(iA + cJ * lT, 1e-8);
+let pN = (cJ * iA - lT)
+/ max(cJ * iA + lT, 1e-8);
 return 0.5 * (
-ba * ba + pw * pw
+ba * ba + pN * pN
 );
 }
 
-fn gd(samplePoint: vec2f) -> vec2f {
+fn gi(samplePoint: vec2f) -> vec2f {
 let offset = 2.0 * samplePoint - vec2f(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2f(0.0);
@@ -87,21 +87,21 @@ return radius * vec2f(cos(angle), sin(angle));
 }
 
 fn bi(samplePoint: vec2f) -> vec3f {
-let kx = gd(samplePoint);
+let kF = gi(samplePoint);
 return vec3f(
-kx,
-sqrt(max(0.0, 1.0 - dot(kx, kx)))
+kF,
+sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-fn aG(pi: f32, nD: f32) -> f32 {
-let scale = max(pi, nD);
+fn aG(pr: f32, nN: f32) -> f32 {
+let scale = max(pr, nN);
 if (scale <= 0.0) {
 return 0.0;
 }
-let normalized = vec2f(pi, nD) / scale;
-let oG = normalized * normalized;
-return oG.x / (oG.x + oG.y);
+let normalized = vec2f(pr, nN) / scale;
+let oO = normalized * normalized;
+return oO.x / (oO.x + oO.y);
 }
 
 fn aL(
@@ -109,17 +109,17 @@ normal: vec3f,
 tangent: ptr<function, vec3f>,
 bitangent: ptr<function, vec3f>
 ) {
-let ie = select(-1.0, 1.0, normal.z >= 0.0);
-let dW = -1.0 / (ie + normal.z);
+let ik = select(-1.0, 1.0, normal.z >= 0.0);
+let dW = -1.0 / (ik + normal.z);
 let xy = normal.x * normal.y * dW;
 *tangent = vec3f(
-1.0 + ie * normal.x * normal.x * dW,
-ie * xy,
--ie * normal.x
+1.0 + ik * normal.x * normal.x * dW,
+ik * xy,
+-ik * normal.x
 );
 *bitangent = vec3f(
 xy,
-ie + normal.y * normal.y * dW,
+ik + normal.y * normal.y * dW,
 -normal.y
 );
 }
@@ -137,32 +137,32 @@ return vec3f(0.0, rgb.g, 0.0);
 return vec3f(0.0, 0.0, rgb.b);
 }
 
-fn eK(
+fn eN(
 wavelength: f32,
-hb: f32,
-hk: f32,
-qk: f32
+hh: f32,
+hp: f32,
+qs: f32
 ) -> f32 {
-if (wavelength == 0.0 || hk <= 0.0) {
-return hb;
+if (wavelength == 0.0 || hp <= 0.0) {
+return hh;
 }
 
 let FRAUNHOFER_C = 656.3;
 let FRAUNHOFER_D = 587.6;
 let FRAUNHOFER_F = 486.1;
-let jK = 1.0 / (
+let jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-let mT = max(qk / hk, 1e-6);
-let qI = (hb - 1.0) * jK / mT;
-let td = hb
-- qI / (FRAUNHOFER_D * FRAUNHOFER_D);
-return td + qI / (wavelength * wavelength);
+let ng = max(qs / hp, 1e-6);
+let qR = (hh - 1.0) * jR / ng;
+let tl = hh
+- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
+return tl + qR / (wavelength * wavelength);
 }
 
-fn fl(
-gu: vec3f,
+fn fq(
+gz: vec3f,
 anisotropy: f32,
 samplePoint: vec2f
 ) -> vec3f {
@@ -171,21 +171,21 @@ if (abs(anisotropy) < 0.001) {
 au = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-let iV = (1.0 - anisotropy * anisotropy)
+let ja = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 au = (
-iV * iV - 1.0 - anisotropy * anisotropy
+ja * ja - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-let tW = sqrt(max(0.0, 1.0 - au * au));
+let ud = sqrt(max(0.0, 1.0 - au * au));
 let br = TWOPI * samplePoint.x;
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(gu, &tangent, &bitangent);
-return tangent * (tW * cos(br))
-+ bitangent * (tW * sin(br))
-+ gu * au;
+aL(gz, &tangent, &bitangent);
+return tangent * (ud * cos(br))
++ bitangent * (ud * sin(br))
++ gz * au;
 }
 
 fn bD(au: f32, anisotropy: f32) -> f32 {

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

@@ -20,8 +20,8 @@ var<private> bc: vec2u;
 var<private> bd: u32;
 var<private> cF: u32 = 0u;
 var<private> em: u32 = 0u;
-fn eg(kk: u32) -> u32 {
-var x = kk;
+fn eg(kt: u32) -> u32 {
+var x = kt;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
@@ -29,28 +29,28 @@ return x ^ (x >> 16u);
 fn aq(a: u32, b: u32) -> u32 {
 return eg(a ^ eg(b + 0x9e3779b9u));
 }
-fn iA(kk: u32, ic: u32) -> u32 {
-var x = kk + ic;
+fn iE(kt: u32, ij: u32) -> u32 {
+var x = kt + ij;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-fn sC(x: u32, ic: u32) -> u32 {
-return reverseBits(iA(reverseBits(x), ic));
+fn sK(x: u32, ij: u32) -> u32 {
+return reverseBits(iE(reverseBits(x), ij));
 }
 
-fn rb(kk: u32) -> u32 {
-var r = reverseBits(kk);
+fn rl(kt: u32) -> u32 {
+var r = reverseBits(kt);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn vI(index: u32, ic: u32) -> vec2f {
-let i = sC(index, aq(ic, 0u));
-let x = reverseBits(iA(i, aq(ic, 1u)));
-let y = sC(rb(i), aq(ic, 2u));
+fn vP(index: u32, ij: u32) -> vec2f {
+let i = sK(index, aq(ij, 0u));
+let x = reverseBits(iE(i, aq(ij, 1u)));
+let y = sK(rl(i), aq(ij, 2u));
 return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
 }
-fn tp(p: vec2u) -> u32 {
+fn tB(p: vec2u) -> u32 {
 var v = p & vec2u(255u);
 v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);
 v = (v | (v << vec2u(2u))) & vec2u(0x3333u);
@@ -58,27 +58,27 @@ v = (v | (v << vec2u(1u))) & vec2u(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const Z_PERM_${i} = ${v}u;`).join("\n")}
-fn km(tu: u32) -> u32 {
-let group = tu >> 2u;
+fn kw(tE: u32) -> u32 {
+let group = tE >> 2u;
 var word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = select(word, Z_PERM_${i}, group == ${i}u);`).join("\n  ")}
-return (word >> ((tu & 3u) * 8u)) & 255u;
+return (word >> ((tE & 3u) * 8u)) & 255u;
 }
-fn pO(kE: u32, dim: u32, logSPP: u32) -> u32 {
+fn pW(kN: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let uf = 8u + ((logSPP + 1u) >> 1u);
+let um = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(uf) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(um) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
-var sj = 0u;
-if (shift < 30u) { sj = kE >> (shift + 2u); }
-let tu = (eg(sj ^ (0x55555555u * dim)) >> 24u) % 24u;
-let d = (kE >> shift) & 3u;
-result |= ((km(tu) >> (2u*d)) & 3u) << shift;
+var st = 0u;
+if (shift < 30u) { st = kN >> (shift + 2u); }
+let tE = (eg(st ^ (0x55555555u * dim)) >> 24u) % 24u;
+let d = (kN >> shift) & 3u;
+result |= ((kw(tE) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kE & 1u) ^ (eg((kE >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kN & 1u) ^ (eg((kN >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
@@ -88,7 +88,7 @@ return result;
 fn cw(slot: u32) -> u32 {
 return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
 }
-fn qV(candidate: u32, slot: u32) -> u32 {
+fn rd(candidate: u32, slot: u32) -> u32 {
 if (candidate == 0u) {
 if (slot == 2u) { return cw(8u); }
 return cw(slot);
@@ -97,62 +97,62 @@ return cw(9u + (candidate - 1u) * 3u + slot);
 }
 
 
-var<private> hh: vec4u;
-var<private> hi: u32;
-var<private> fv: bool = false;
-var<private> df: bool = false;
-var<private> dE: u32;
-var<private> gq: u32;
-var<private> eN: vec2f;
+var<private> hl: vec4u;
+var<private> hm: u32;
+var<private> fC: bool = false;
+var<private> dg: bool = false;
+var<private> dF: u32;
+var<private> gv: u32;
+var<private> eQ: vec2f;
 fn dw(dim: u32) {
 
-let jW = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let key = vec4u(dim, bd, jW, rtUniform.sequenceSeed);
-if (fv && all(hh == key) && hi == rtUniform.zSobolLogSPP) { return; }
-hh = key; hi = rtUniform.zSobolLogSPP;
-fv = true; df = false;
-var ic = aq(aq(jW, dim), rtUniform.sequenceSeed);
+let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let key = vec4u(dim, bd, kd, rtUniform.sequenceSeed);
+if (fC && all(hl == key) && hm == rtUniform.zSobolLogSPP) { return; }
+hl = key; hm = rtUniform.zSobolLogSPP;
+fC = true; dg = false;
+var ij = aq(aq(kd, dim), rtUniform.sequenceSeed);
 var index = bd;
 if (SAMPLING_PATTERN == 1) {
 var logSPP = rtUniform.zSobolLogSPP;
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-var iW = index >> logSPP;
+var jb = index >> logSPP;
 let mask = (1u << logSPP) - 1u;
-let kE = (tp(bc) << logSPP) | (index & mask);
-index = pO(kE, dim, logSPP);
+let kN = (tB(bc) << logSPP) | (index & mask);
+index = pW(kN, dim, logSPP);
 let tile = bc >> vec2u(8u);
-ic = aq(aq(dim, rtUniform.sequenceSeed), aq(tile.x, tile.y));
+ij = aq(aq(dim, rtUniform.sequenceSeed), aq(tile.x, tile.y));
 
-if (bd != 0u) { iW += 1u; }
-ic = aq(ic, iW);
+if (bd != 0u) { jb += 1u; }
+ij = aq(ij, jb);
 }
-dE = sC(index, aq(ic, 0u));
-gq = ic;
-let x = reverseBits(iA(dE, aq(ic, 1u)));
-eN.x = f32(x >> 8u) * (1.0 / 16777216.0);
+dF = sK(index, aq(ij, 0u));
+gv = ij;
+let x = reverseBits(iE(dF, aq(ij, 1u)));
+eQ.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
-fn kJ(dim: u32) -> vec2f {
+fn kS(dim: u32) -> vec2f {
 dw(dim);
-if (!df) {
-let y = sC(rb(dE), aq(gq, 2u));
-eN.y = f32(y >> 8u) * (1.0 / 16777216.0);
-df = true;
+if (!dg) {
+let y = sK(rl(dF), aq(gv, 2u));
+eQ.y = f32(y >> 8u) * (1.0 / 16777216.0);
+dg = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eN;
+return EPS + (1.0 - 2.0*EPS) * eQ;
 }
 fn dz(dim: u32) -> f32 {
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 dw(dim);
-return EPS + (1.0 - 2.0*EPS) * eN.x;
+return EPS + (1.0 - 2.0*EPS) * eQ.x;
 }
-fn fk(dim: u32) -> vec2f {
+fn fp(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
 let x = dz(dim); let y = dz(dim);
 return vec2f(x,y);
 }
-return kJ(dim);
+return kS(dim);
 }
 
 fn eo(slot: u32) -> f32 {
@@ -160,10 +160,10 @@ let dim = aq(aq(cF, slot), em) | 0x80000000u;
 em += 1u;
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-let jW = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let ic = aq(aq(jW, dim), rtUniform.sequenceSeed);
-let i = sC(bd, aq(ic, 0u));
-let x = reverseBits(iA(i, aq(ic, 1u)));
+let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let ij = aq(aq(kd, dim), rtUniform.sequenceSeed);
+let i = sK(bd, aq(ij, 0u));
+let x = reverseBits(iE(i, aq(ij, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -7,12 +7,12 @@ let theta = atan2(n.x, n.z) / (2.0 * PI) + 0.5;
 let phi = acos(n.y) / PI;
 return vec2f(theta, 1.0 - phi);
 }
-fn iM(pos: vec3f, normal: vec3f) -> vec2f {
-let dm = abs(normal);
+fn iR(pos: vec3f, normal: vec3f) -> vec2f {
+let dn = abs(normal);
 var uv = vec2f(0.0);
-if (dm.x > dm.y && dm.x > dm.z) {
+if (dn.x > dn.y && dn.x > dn.z) {
 uv = pos.yz;
-} else if (dm.y > dm.x && dm.y > dm.z) {
+} else if (dn.y > dn.x && dn.y > dn.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -23,18 +23,18 @@ return uv;
 
 
 
-fn hz(pos: vec3f, normal: vec3f) -> vec2f {
+fn hD(pos: vec3f, normal: vec3f) -> vec2f {
 let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2f(theta, pos.y);
 }
 
-fn gC(fh: i32, pos: vec3f, normal: vec3f) -> vec2f {
-if (fh == ${uvProjectionConstants.triplanar}) {
-return iM(pos, normal);
-} else if (fh == ${uvProjectionConstants.spherical}) {
+fn gI(fk: i32, pos: vec3f, normal: vec3f) -> vec2f {
+if (fk == ${uvProjectionConstants.triplanar}) {
+return iR(pos, normal);
+} else if (fk == ${uvProjectionConstants.spherical}) {
 return sphericalProjection(pos);
-} else if (fh == ${uvProjectionConstants.cylindrical}) {
-return hz(pos, normal);
+} else if (fk == ${uvProjectionConstants.cylindrical}) {
+return hD(pos, normal);
 }
 return vec2f(0.0);
 }