@meimu/mutracer 0.1.2 → 0.1.3

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

@@ -1,56 +1,56 @@
 const displacementCommon = /*wgsl*/ `
 
 
-struct jv {
+struct jx {
 barycentric: vec3f,
 t: f32,
 normal: vec3f,
 
 }
 
-fn uL(
+fn uQ(
 uu: f32,
-tL: vec3f, tM: vec3f,
+tQ: vec3f, tR: vec3f,
 eAC: vec3f, eBD: vec3f,
-iI: vec3f,
-pL: f32,
-pN: ptr<function, f32>
+iJ: vec3f,
+pP: f32,
+pR: ptr<function, f32>
 ) -> bool {
 if (uu >= 0.0 && uu <= 1.0) {
-let pAB = mix(tL, tM, uu);
+let pAB = mix(tQ, tR, uu);
 let pCD = mix(eAC, eBD, uu);
-var n = cross(iI, pCD);
-let vl = 1.0 / dot(n, n);
+var n = cross(iJ, pCD);
+let vq = 1.0 / dot(n, n);
 n = cross(n, pAB);
-let tt = dot(n, pCD) * vl;
-let vv = dot(n, iI) * vl;
-if (vv >= 0.0 && vv <= 1.0 && tt > pL && tt < *pN) {
-*pN = tt;
+let tt = dot(n, pCD) * vq;
+let vv = dot(n, iJ) * vq;
+if (vv >= 0.0 && vv <= 1.0 && tt > pP && tt < *pR) {
+*pR = tt;
 return true;
 }
 }
 return false;
 }
 
-fn hd(
-pt: vec3f, iI: vec3f, pL: f32, ta: f32,
+fn he(
+pH: vec3f, iJ: vec3f, pP: f32, tf: f32,
 pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,
-pN: ptr<function, f32>
+pR: ptr<function, f32>
 ) -> bool {
 let eAB = pB - pA;
 let eAC = pC - pA;
 let eBD = pD - pB;
 let eCD = pD - pC;
-let tL = pA - pt;
-let tM = pB - pt;
+let tQ = pA - pH;
+let tR = pB - pH;
 
 var u1: f32;
 var u2: f32;
 {
 let qN = cross(eAB, -eCD);
-let a = dot(qN, iI);
-var b = dot(cross(tM, iI), eBD);
-let c = dot(cross(tL, iI), eAC);
+let a = dot(qN, iJ);
+var b = dot(cross(tR, iJ), eBD);
+let c = dot(cross(tQ, iJ), eAC);
 b -= a + c;
 
 let det = b * b - 4.0 * a * c;
@@ -62,19 +62,19 @@ if (a == 0.0) {
 u1 = -c / b;
 u2 = -1.0;
 } else {
-let vE = sqrt(det);
-let wv = -0.5 * (b + sign(b) * vE);
-u1 = wv / a;
-u2 = c / wv;
+let vJ = sqrt(det);
+let wC = -0.5 * (b + sign(b) * vJ);
+u1 = wC / a;
+u2 = c / wC;
 }
 }
 
-*pN = ta;
+*pR = tf;
 
 var hit = false;
 
-hit = uL(u1, tL, tM, eAC, eBD, iI, pL, pN) || 
-uL(u2, tL, tM, eAC, eBD, iI, pL, pN);
+hit = uQ(u1, tQ, tR, eAC, eBD, iJ, pP, pR) || 
+uQ(u2, tQ, tR, eAC, eBD, iJ, pP, pR);
 if (!hit) {
 return false;
 }
@@ -82,8 +82,8 @@ return false;
 return true;
 }
 
-fn sf(
-pt: vec3f, iI: vec3f, pL: f32, ta: f32,
+fn sl(
+pH: vec3f, iJ: vec3f, pP: f32, tf: f32,
 pA: vec3f, pB: vec3f, pC: vec3f,
 pD: vec3f, pE: vec3f, pF: vec3f,
 
@@ -93,50 +93,50 @@ bS: ptr<function, f32>
 *bT = INF;
 *bS = -INF;
 
-let vR = maxDimension(abs(iI));
-let gJ = mg(iI, vR);
+let vW = maxDimension(abs(iJ));
+let gL = mj(iJ, vW);
 var tt: f32;
 
 tt = fI(
-pt, iI,
-fu(pC, pB, pA), vR, gJ, INF
+pH, iJ,
+fu(pC, pB, pA), vW, gL, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
 tt = fI(
-pt, iI,
-fu(pD, pE, pF), vR, gJ, INF
+pH, iJ,
+fu(pD, pE, pF), vW, gL, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (hd(
-pt, iI, -INF, INF,
+if (he(
+pH, iJ, -INF, INF,
 pA, pB, pD, pE,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (hd(
-pt, iI, -INF, INF,
+if (he(
+pH, iJ, -INF, INF,
 pB, pC, pE, pF,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (hd(
-pt, iI, -INF, INF,
+if (he(
+pH, iJ, -INF, INF,
 pC, pA, pF, pD,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
 
-*bT = max(*bT, pL);
-*bS = min(*bS, ta);
+*bT = max(*bT, pP);
+*bS = min(*bS, tf);
 
 return *bT <= *bS && *bS > 0.0;
 }
@@ -145,7 +145,7 @@ export default /* wgsl */ `
 
 ${displacementCommon}
 
-fn lD(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
+fn lG(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
 let v0 = p1 - p0;
 let v1 = p2 - p0;
 let v2 = p - p0;
@@ -156,72 +156,72 @@ let d11 = dot(v1, v1);
 let d20 = dot(v2, v0);
 let d21 = dot(v2, v1);
 
-let tH = 1.0 / (d00 * d11 - d01 * d01);
-let v = clamp((d11 * d20 - d01 * d21) * tH, 0.0, 1.0);
-let w = clamp((d00 * d21 - d01 * d20) * tH, 0.0, 1.0);
+let tM = 1.0 / (d00 * d11 - d01 * d01);
+let v = clamp((d11 * d20 - d01 * d21) * tM, 0.0, 1.0);
+let w = clamp((d00 * d21 - d01 * d20) * tM, 0.0, 1.0);
 let u = 1.0 - v - w;
 
 return vec3f(u, v, w);
 }
 
-fn sJ(uv: vec2f) -> vec2f {
+fn sO(uv: vec2f) -> vec2f {
 return (uv % 1.0 + 1.0) % 1.0;
 }
 
 
-fn oP(
-qf: vec3f, qA: vec3f, wC: f32,
+fn oT(
+qj: vec3f, qE: vec3f, wJ: f32,
 _pA: vec3f, _pB: vec3f, _pC: vec3f,
 _nA: vec3f, _nB: vec3f, _nC: vec3f,
-vs: vec2f, vt: vec2f, vu: vec2f,
+vy: vec2f, vA: vec2f, vB: vec2f,
 
-jH: i32,
-vq: vec2f,
+jJ: i32,
+vx: vec2f,
 
-vX: f32, vW: f32,
+wc: f32, wb: f32,
 hScale: f32,
-ux: f32,
-tT: f32,
+uC: f32,
+tY: f32,
 uvProjection: i32,
 uvScale: vec2f,
-vJ: bool,
-qQ: bool
-) -> jv {
+vO: bool,
+qU: bool
+) -> jx {
 
 
 
-let DT = select(max(abs(hScale) / 32.0, 1e-12), tT, tT > 0.0);
-let dt = DT / length(qA);
+let DT = select(max(abs(hScale) / 32.0, 1e-12), tY, tY > 0.0);
+let dt = DT / length(qE);
 let dbx = 0.001;
 let dby = 0.001;
 
-var result: jv;
+var result: jx;
 result.t = INF;
 
 var bT = INF;
 var bS = -INF;
 
-let qO = sign(hScale);
-let uD = abs(hScale);
+let qS = sign(hScale);
+let uI = abs(hScale);
 
-let sS = qO * normalize(cross(_pB - _pA, _pC - _pA));
+let sX = qS * normalize(cross(_pB - _pA, _pC - _pA));
 
 
-let dA = dot(_nA, sS);
-let dB = dot(_nB, sS);
-let dC = dot(_nC, sS);
+let dA = dot(_nA, sX);
+let dB = dot(_nB, sX);
+let dC = dot(_nC, sX);
 
-var minH = vX * hScale * min(min(dA, dB), dC);
-var maxH = vW * hScale * max(max(dA, dB), dC);
+var minH = wc * hScale * min(min(dA, dB), dC);
+var maxH = wb * hScale * max(max(dA, dB), dC);
 
 
 
 
-let tN = abs(maxH) - abs(minH);
+let tS = abs(maxH) - abs(minH);
 
 
 minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);
-if (tN < DT * 2.0) {
+if (tS < DT * 2.0) {
 maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));
 }
 
@@ -233,8 +233,8 @@ let pD = _pA + _nA * maxH / dA;
 let pE = _pB + _nB * maxH / dB;
 let pF = _pC + _nC * maxH / dC;
 
-if (!sf(
-qf, qA, 0.0, INF,
+if (!sl(
+qj, qE, 0.0, INF,
 pA, pB, pC,
 pD, pE, pF,
 
@@ -243,59 +243,59 @@ pD, pE, pF,
 return result;
 }
 
-var ww = false;
+var wE = false;
 
 if (bS == bT) {
 bT = 0.0;
 }
 
 var t = bT + dt * eo(2u);
-var s = qf + qA * t;
-var tG = dot(s - _pA, sS);
-var uR = select(0.0, INF, qO < 0.0);
+var s = qj + qE * t;
+var tL = dot(s - _pA, sX);
+var uW = select(0.0, INF, qS < 0.0);
 
-var c0 = _pA + _nA * tG / dA;
-var c1 = _pB + _nB * tG / dB;
-var c2 = _pC + _nC * tG / dC;
+var c0 = _pA + _nA * tL / dA;
+var c1 = _pB + _nB * tL / dB;
+var c2 = _pC + _nC * tL / dC;
 
-var tn: vec3f;
+var tv: vec3f;
 
-tG = abs(tG);
+tL = abs(tL);
 
-var qM = tG - uR;
-var pM = qM;
+var qR = tL - uW;
+var pQ = qR;
 var step = 0;
 
 while (true) {
 
-let b = lD(s, c0, c1, c2);
+let b = lG(s, c0, c1, c2);
 
-tn = _pA * b.x + _pB * b.y + _pC * b.z;
+tv = _pA * b.x + _pB * b.y + _pC * b.z;
 
-tG = distance(tn, s);
+tL = distance(tv, s);
 
 var uv: vec2f;
 if (uvProjection > 0) {
 let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
-uv = sJ(gz(uvProjection, tn - (_nA * b.x + _nB * b.y + _nC * b.z) * ux, n) * uvScale);
+uv = sO(gC(uvProjection, tv - (_nA * b.x + _nB * b.y + _nC * b.z) * uC, n) * uvScale);
 }
 else {
-uv = sJ(vs * b.x + vt * b.y + vu * b.z);
+uv = sO(vy * b.x + vA * b.y + vB * b.z);
 }
-let h = sampleMap(jH, uv).x;
+let h = sampleMap(jJ, uv).x;
 
-uR = max(uD * h, DT);
+uW = max(uI * h, DT);
 
 
-let dh = dot(sS, s - c0);
+let dh = dot(sX, s - c0);
 c0 = c0 + _nA * dh / dA;
 c1 = c1 + _nB * dh / dB;
 c2 = c2 + _nC * dh / dC;
 
-pM = qM;
-qM = tG - uR;
+pQ = qR;
+qR = tL - uW;
 
-if (!(select(qM * qO, qM * pM, qQ) > 0.0
+if (!(select(qR * qS, qR * pQ, qU) > 0.0
 && t < bS + dt) 
 
 && step > 0) {
@@ -304,15 +304,15 @@ break;
 
 step++;
 t = t + dt;
-s = s + qA * dt;
+s = s + qE * dt;
 }
 
-if (select(qM * qO, qM * pM, qQ) <= 0.0) {
-let dtt = dt * (abs(qM) / (abs(pM) + abs(qM) + EPS));
+if (select(qR * qS, qR * pQ, qU) <= 0.0) {
+let dtt = dt * (abs(qR) / (abs(pQ) + abs(qR) + EPS));
 t = t - dtt;
 
-let wy = qf + qA * t;
-let b = lD(wy, c0, c1, c2);
+let wG = qj + qE * t;
+let b = lG(wG, c0, c1, c2);
 
 let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 
@@ -320,33 +320,33 @@ let p_a = _pA * b.x + _pB * b.y + _pC * b.z;
 let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);
 let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);
 
-var vT: vec2f;
-var vU: vec2f;
-var vV: vec2f;
+var vY: vec2f;
+var vZ: vec2f;
+var wa: vec2f;
 
 if (uvProjection > 0) {
 let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));
 let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  
-vT = gz(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * ux, NA) * uvScale;
-vU = gz(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * ux, NB) * uvScale;
-vV = gz(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * ux, NC) * uvScale;
+vY = gC(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * uC, NA) * uvScale;
+vZ = gC(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * uC, NB) * uvScale;
+wa = gC(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * uC, NC) * uvScale;
 }
 else {
-vT = vs * b.x + vt * b.y + vu * b.z;
-vU = vs * (b.x + dbx) + vt * b.y + vu * (b.z - dbx);
-vV = vs * b.x + vt * (b.y + dby) + vu * (b.z - dby);
+vY = vy * b.x + vA * b.y + vB * b.z;
+vZ = vy * (b.x + dbx) + vA * b.y + vB * (b.z - dbx);
+wa = vy * b.x + vA * (b.y + dby) + vB * (b.z - dby);
 }
 
-let s_a = p_a + qO * N * sampleMap(jH, sJ(vT)).x * hScale;
-let s_b = p_b + qO * N * sampleMap(jH, sJ(vU)).x * hScale;
-let s_c = p_c + qO * N * sampleMap(jH, sJ(vV)).x * hScale;
+let s_a = p_a + qS * N * sampleMap(jJ, sO(vY)).x * hScale;
+let s_b = p_b + qS * N * sampleMap(jJ, sO(vZ)).x * hScale;
+let s_c = p_c + qS * N * sampleMap(jJ, sO(wa)).x * hScale;
 
-let N_s = -qO * normalize(cross(s_c - s_a, s_b - s_a));
+let N_s = -qS * normalize(cross(s_c - s_a, s_b - s_a));
 
 result.t = t;
 result.barycentric = b;
-result.normal = normalize(N_s - sS + qO * N);
+result.normal = normalize(N_s - sX + qS * N);
 }
 
 return result;

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

@@ -4,13 +4,13 @@
 export default /* wgsl */ `
 var<private> s0: vec4u;
 
-fn jY(p: vec2u, frame: i32) {
+fn ka(p: vec2u, frame: i32) {
 
 s0 = vec4u(p, u32(frame), u32(p.x) + u32(p.y));
 }
 
 
-fn vj() {
+fn vo() {
 s0 = s0 * 1664525u + 1013904223u;
 s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 s0 = s0 ^ (s0>>vec4(16u));
@@ -18,7 +18,7 @@ s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 }
 
 fn rand() -> f32 {
-vj(); return f32(s0.x)/f32(0xffffffffu);
+vo(); return f32(s0.x)/f32(0xffffffffu);
 }
 
 `;

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

@@ -202,7 +202,7 @@ secondaryUv1: vec2f,
 secondaryUv2: vec2f,
 };
 
-struct oR {
+struct oV {
 probability: f32,
 aliasIndex: i32,
 sourceType: i32,
@@ -270,14 +270,14 @@ sampleSequenceOffset: u32,
 @group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;
 @group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;
 
-fn cL(dV: i32, le: i32) -> f32 {
-let ij = dV + le / 4;
+fn cL(dV: i32, lh: i32) -> f32 {
+let ih = dV + lh / 4;
 let width = rtUniform.lightSamplingTextureWidth;
-let packed = textureLoad(lightSamplingData, vec2i(ij % width, ij / width), 0);
-return packed[le % 4];
+let packed = textureLoad(lightSamplingData, vec2i(ih % width, ih / width), 0);
+return packed[lh % 4];
 }
 
-fn kF(dV: i32, uv: vec2f) -> f32 {
+fn kI(dV: i32, uv: vec2f) -> f32 {
 if (dV < 0) { return 1.0; }
 let fM = fract(uv) * 128.0 - vec2f(0.5);
 let x0 = i32(floor(fM.x));
@@ -298,16 +298,16 @@ return mix(mix(a, b, fx), mix(c, d, fx), fy);
 fn bL(light: Light, dJ: vec3f) -> f32 {
 let axis = normalize(light.u);
 let cc = dot(axis, dJ);
-var tD = select(0.0, 1.0, cc >= light.v.x);
+var tI = select(0.0, 1.0, cc >= light.v.x);
 if (light.v.y > 1e-6) {
-tD = smoothstep(light.v.x, light.v.x + light.v.y, cc);
+tI = smoothstep(light.v.x, light.v.x + light.v.y, cc);
 }
-if (tD <= 0.0 || light.textureIndex < 0.0) { return tD; }
-let tX = light.iesReference;
-let vo = cross(axis, tX);
+if (tI <= 0.0 || light.textureIndex < 0.0) { return tI; }
+let uc = light.iesReference;
+let vu = cross(axis, uc);
 let vertical = acos(clamp(cc, -1.0, 1.0));
-let horizontal = atan2(dot(dJ, vo), dot(dJ, tX));
-return tD * kF(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
+let horizontal = atan2(dot(dJ, vu), dot(dJ, uc));
+return tI * kI(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
 }