@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -4,71 +4,71 @@ export default glsl `
 
 
 
-vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
-vec3 rm = vec3(alpha, 1.0);
-vec3 gk = normalize(rm * view);
-float uh = min(gk.z, 1.0);
-float qQ = 1.0 + uh;
-float rh = (1.0 - samplePoint.y) * qQ;
-float rR = samplePoint.y * qQ;
-float sI = rh + (1.0 - uh);
-float fl = sqrt(max(0.0, sI * rR));
-float br = TWOPI * samplePoint.x;
-vec3 lI = vec3(
-gk.x + fl * cos(br),
-gk.y + fl * sin(br),
-rh
+vec3 aD(vec3 view, vec2 alpha, vec2 samplePoint) {
+vec3 sv = vec3(alpha, 1.0);
+vec3 cr = normalize(sv * view);
+float qP = min(cr.z, 1.0);
+float kh = 1.0 + qP;
+float kC = (1.0 - samplePoint.y) * kh;
+float sU = samplePoint.y * kh;
+float tY = kC + (1.0 - qP);
+float ex = sqrt(max(0.0, tY * sU));
+float azimuth = TWOPI * samplePoint.x;
+vec3 mr = vec3(
+cr.x + ex * cos(azimuth),
+cr.y + ex * sin(azimuth),
+kC
 );
-return normalize(rm * lI);
+return normalize(sv * mr);
 }
 
-float gL(vec3 oo, vec2 alpha) {
-vec3 hr = vec3(
-oo.x / alpha.x,
-oo.y / alpha.y,
-oo.z
+float cW(vec3 pf, vec2 alpha) {
+vec3 hF = vec3(
+pf.x / alpha.x,
+pf.y / alpha.y,
+pf.z
 );
-float ap = dot(hr, hr);
+float aq = dot(hF, hF);
 return 1.0 / (
-PI * alpha.x * alpha.y * ap * ap
+PI * alpha.x * alpha.y * aq * aq
 );
 }
 
-float bk(vec3 direction, vec2 alpha) {
-float eF = abs(direction.z);
-if (eF <= 1e-8) {
+float aF(vec3 direction, vec2 alpha) {
+float eQ = abs(direction.z);
+if (eQ <= 1e-8) {
 return 0.0;
 }
-vec2 ic = alpha * direction.xy;
-float lJ = dot(ic, ic)
-/ (eF * eF);
-return 2.0 / (1.0 + sqrt(1.0 + lJ));
+vec2 iE = alpha * direction.xy;
+float mt = dot(iE, iE)
+/ (eQ * eQ);
+return 2.0 / (1.0 + sqrt(1.0 + mt));
 }
 
-float aE(float au) {
-float di = clamp(1.0 - au, 0.0, 1.0);
-return pow(di, 5.0);
+float aI(float cosine) {
+float dw = clamp(1.0 - cosine, 0.0, 1.0);
+return pow(dw, 5.0);
 }
 
-float cu(float L, float cJ) {
-float iA = clamp(abs(L), 0.0, 1.0);
-float kl = cJ * cJ
-* max(0.0, 1.0 - iA * iA);
-if (kl >= 1.0) {
+float cC(float J, float cR) {
+float iS = clamp(abs(J), 0.0, 1.0);
+float kQ = cR * cR
+* max(0.0, 1.0 - iS * iS);
+if (kQ >= 1.0) {
 return 1.0;
 }
 
-float lT = sqrt(max(0.0, 1.0 - kl));
-float ba = (iA - cJ * lT)
-/ max(iA + cJ * lT, 1e-8);
-float pN = (cJ * iA - lT)
-/ max(cJ * iA + lT, 1e-8);
+float mD = sqrt(max(0.0, 1.0 - kQ));
+float bk = (iS - cR * mD)
+/ max(iS + cR * mD, 1e-8);
+float qC = (cR * iS - mD)
+/ max(cR * iS + mD, 1e-8);
 return 0.5 * (
-ba * ba + pN * pN
+bk * bk + qC * qC
 );
 }
 
-vec2 gi(vec2 samplePoint) {
+vec2 gy(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -87,108 +87,108 @@ angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);
 return radius * vec2(cos(angle), sin(angle));
 }
 
-vec3 bi(vec2 samplePoint) {
-vec2 kF = gi(samplePoint);
+vec3 aO(vec2 samplePoint) {
+vec2 lk = gy(samplePoint);
 return vec3(
-kF,
-sqrt(max(0.0, 1.0 - dot(kF, kF)))
+lk,
+sqrt(max(0.0, 1.0 - dot(lk, lk)))
 );
 }
 
-float aG(float pr, float nN) {
-float scale = max(pr, nN);
+float aK(float qo, float oJ) {
+float scale = max(qo, oJ);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(pr, nN) / scale;
-vec2 oO = normalized * normalized;
-return oO.x / (oO.x + oO.y);
+vec2 normalized = vec2(qo, oJ) / scale;
+vec2 pL = normalized * normalized;
+return pL.x / (pL.x + pL.y);
 }
 
-void aL(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
-float ik = normal.z >= 0.0 ? 1.0 : -1.0;
-float dW = -1.0 / (ik + normal.z);
-float xy = normal.x * normal.y * dW;
+void aP(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
+float iI = normal.z >= 0.0 ? 1.0 : -1.0;
+float cL = -1.0 / (iI + normal.z);
+float xy = normal.x * normal.y * cL;
 tangent = vec3(
-1.0 + ik * normal.x * normal.x * dW,
-ik * xy,
--ik * normal.x
+1.0 + iI * normal.x * normal.x * cL,
+iI * xy,
+-iI * normal.x
 );
 bitangent = vec3(
 xy,
-ik + normal.y * normal.y * dW,
+iI + normal.y * normal.y * cL,
 -normal.y
 );
 }
 
-vec3 ai(vec3 rgb, float wavelength) {
+vec3 aj(vec3 rgb, float wavelength) {
 if (wavelength == 0.0) {
 return rgb;
 }
-vec3 tN = wavelength > 600.0
+vec3 vk = wavelength > 600.0
 ? vec3(1.0, 0.0, 0.0)
 : wavelength > 500.0
 ? vec3(0.0, 1.0, 0.0)
 : vec3(0.0, 0.0, 1.0);
-return rgb * tN;
+return rgb * vk;
 }
 
-float eN(
+float ee(
 float wavelength,
-float hh,
-float hp,
-float qs
+float hu,
+float hD,
+float rt
 ) {
-if (wavelength == 0.0 || hp <= 0.0) {
-return hh;
+if (wavelength == 0.0 || hD <= 0.0) {
+return hu;
 }
 
 const float FRAUNHOFER_C = 656.3;
 const float FRAUNHOFER_D = 587.6;
 const float FRAUNHOFER_F = 486.1;
-float jR = 1.0 / (
+float kv = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float ng = max(qs / hp, 1e-6);
-float qR = (hh - 1.0) * jR / ng;
-float tl = hh
-- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
-return tl + qR / (wavelength * wavelength);
+float oe = max(rt / hD, 1e-6);
+float rV = (hu - 1.0) * kv / oe;
+float uK = hu
+- rV / (FRAUNHOFER_D * FRAUNHOFER_D);
+return uK + rV / (wavelength * wavelength);
 }
 
-vec3 fq(
-vec3 gz,
+vec3 fH(
+vec3 gO,
 float anisotropy,
 vec2 samplePoint
 ) {
-float au;
+float cosine;
 if (abs(anisotropy) < 0.001) {
-au = 1.0 - 2.0 * samplePoint.y;
+cosine = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float ja = (1.0 - anisotropy * anisotropy)
+float ju = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
-au = (
-ja * ja - 1.0 - anisotropy * anisotropy
+cosine = (
+ju * ju - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float ud = sqrt(max(0.0, 1.0 - au * au));
-float br = TWOPI * samplePoint.x;
+float vF = sqrt(max(0.0, 1.0 - cosine * cosine));
+float azimuth = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aL(gz, tangent, bitangent);
-return tangent * (ud * cos(br))
-+ bitangent * (ud * sin(br))
-+ gz * au;
+aP(gO, tangent, bitangent);
+return tangent * (vF * cos(azimuth))
++ bitangent * (vF * sin(azimuth))
++ gO * cosine;
 }
 
-float bD(float au, float anisotropy) {
-float ap = 1.0 + anisotropy * anisotropy
-+ 2.0 * anisotropy * au;
+float bL(float cosine, float anisotropy) {
+float aq = 1.0 + anisotropy * anisotropy
++ 2.0 * anisotropy * cosine;
 return INV4PI * (1.0 - anisotropy * anisotropy)
-/ (ap * sqrt(ap));
+/ (aq * sqrt(aq));
 }
 `;
 //# sourceMappingURL=sampling.glsl.js.map

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

@@ -24,41 +24,41 @@ const uint BOUNCE_STRIDE = 64u;
 
 
 
-uvec2 bc;
-uint bd;
-uint cF = 0u;
-uint em = 0u;
-uint eg(uint kt) {
-uint x = kt;
+uvec2 aZ;
+uint aQ;
+uint bT = 0u;
+uint cP = 0u;
+uint dG(uint kW) {
+uint x = kW;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
-uint aq(uint a, uint b) {
-return eg(a ^ eg(b + 0x9e3779b9u));
+uint ar(uint a, uint b) {
+return dG(a ^ dG(b + 0x9e3779b9u));
 }
-uint iE(uint kt, uint ij) {
-uint x = kt + ij;
+uint iV(uint kW, uint seed) {
+uint x = kW + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-uint sK(uint x, uint ij) {
-return reverseBits(iE(reverseBits(x), ij));
+uint ua(uint x, uint seed) {
+return reverseBits(iV(reverseBits(x), seed));
 }
 
-uint rl(uint kt) {
-uint r = reverseBits(kt);
+uint su(uint kW) {
+uint r = reverseBits(kW);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 vP(uint index, uint ij) {
-uint i = sK(index, aq(ij, 0u));
-uint x = reverseBits(iE(i, aq(ij, 1u)));
-uint y = sK(rl(i), aq(ij, 2u));
+vec2 xE(uint index, uint seed) {
+uint i = ua(index, ar(seed, 0u));
+uint x = reverseBits(iV(i, ar(seed, 1u)));
+uint y = ua(su(i), ar(seed, 2u));
 return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
 }
-uint tB(uvec2 p) {
+uint uR(uvec2 p) {
 uvec2 v = p & uvec2(255u);
 v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);
 v = (v | (v << uvec2(2u))) & uvec2(0x3333u);
@@ -66,104 +66,104 @@ 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 kw(uint tE) {
-uint group = tE >> 2u;
+uint la(uint uU) {
+uint group = uU >> 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 >> ((tE & 3u) * 8u)) & 255u;
+return (word >> ((uU & 3u) * 8u)) & 255u;
 }
-uint pW(uint kN, uint dim, uint logSPP) {
+uint qS(uint lu, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint um = 8u + ((logSPP + 1u) >> 1u);
+uint vN = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(um) - 1; digit >= int(odd); digit--) {
+for (int digit = int(vN) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
-uint st = 0u;
-if (shift < 30u) { st = kN >> (shift + 2u); }
-uint tE = (eg(st ^ (0x55555555u * dim)) >> 24u) % 24u;
-uint d = (kN >> shift) & 3u;
-result |= ((kw(tE) >> (2u*d)) & 3u) << shift;
+uint tL = 0u;
+if (shift < 30u) { tL = lu >> (shift + 2u); }
+uint uU = (dG(tL ^ (0x55555555u * dim)) >> 24u) % 24u;
+uint d = (lu >> shift) & 3u;
+result |= ((la(uU) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kN & 1u) ^ (eg((kN >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (lu & 1u) ^ (dG((lu >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-uint cw(uint slot) {
-return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
+uint cE(uint slot) {
+return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + bT * BOUNCE_STRIDE + slot;
 }
 
-uvec4 hl;
-uint hm;
-bool fC = false;
-bool dg = false;
-uint dF;
-uint gv;
-vec2 eQ;
-void dw(uint dim) {
+uvec4 hA;
+uint hB;
+bool fQ = false;
+bool dv = false;
+uint dQ;
+uint gK;
+vec2 fa;
+void dN(uint dim) {
 
-uint kd = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uvec4 key = uvec4(dim, bd, kd, uint(sequenceSeed));
-if (fC && all(equal(hl, key)) && hm == uint(zSobolLogSPP)) { return; }
-hl = key; hm = uint(zSobolLogSPP);
-fC = true; dg = false;
-uint ij = aq(aq(kd, dim), uint(sequenceSeed));
-uint index = bd;
+uint kI = aZ.x + aZ.y * uint(round(1.0 / pixelSize.x));
+uvec4 key = uvec4(dim, aQ, kI, uint(sequenceSeed));
+if (fQ && all(equal(hA, key)) && hB == uint(zSobolLogSPP)) { return; }
+hA = key; hB = uint(zSobolLogSPP);
+fQ = true; dv = false;
+uint seed = ar(ar(kI, dim), uint(sequenceSeed));
+uint index = aQ;
 if (samplingPattern == 1) {
 uint logSPP = uint(zSobolLogSPP);
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-uint jb = index >> logSPP;
+uint jw = index >> logSPP;
 uint mask = (1u << logSPP) - 1u;
-uint kN = (tB(bc) << logSPP) | (index & mask);
-index = pW(kN, dim, logSPP);
-uvec2 tile = bc >> uvec2(8u);
-ij = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
+uint lu = (uR(aZ) << logSPP) | (index & mask);
+index = qS(lu, dim, logSPP);
+uvec2 tile = aZ >> uvec2(8u);
+seed = ar(ar(dim, uint(sequenceSeed)), ar(tile.x, tile.y));
 
-if (bd != 0u) { jb += 1u; }
-ij = aq(ij, jb);
+if (aQ != 0u) { jw += 1u; }
+seed = ar(seed, jw);
 }
-dF = sK(index, aq(ij, 0u));
-gv = ij;
-uint x = reverseBits(iE(dF, aq(ij, 1u)));
-eQ.x = float(x >> 8u) * (1.0 / 16777216.0);
+dQ = ua(index, ar(seed, 0u));
+gK = seed;
+uint x = reverseBits(iV(dQ, ar(seed, 1u)));
+fa.x = float(x >> 8u) * (1.0 / 16777216.0);
 }
-vec2 kS(uint dim) {
-dw(dim);
-if (!dg) {
-uint y = sK(rl(dF), aq(gv, 2u));
-eQ.y = float(y >> 8u) * (1.0 / 16777216.0);
-dg = true;
+vec2 lC(uint dim) {
+dN(dim);
+if (!dv) {
+uint y = ua(su(dQ), ar(gK, 2u));
+fa.y = float(y >> 8u) * (1.0 / 16777216.0);
+dv = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eQ;
+return EPS + (1.0 - 2.0*EPS) * fa;
 }
-float dz(uint dim) {
+float dp(uint dim) {
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dw(dim);
-return EPS + (1.0 - 2.0*EPS) * eQ.x;
+dN(dim);
+return EPS + (1.0 - 2.0*EPS) * fa.x;
 }
-vec2 fp(uint dim) {
+vec2 dZ(uint dim) {
 if (samplingPattern == 2) {
-float x = dz(dim); float y = dz(dim);
+float x = dp(dim); float y = dp(dim);
 return vec2(x,y);
 }
-return kS(dim);
+return lC(dim);
 }
 
-float eo(uint slot) {
-uint dim = aq(aq(cF, slot), em) | 0x80000000u;
-em += 1u;
+float eC(uint slot) {
+uint dim = ar(ar(bT, slot), cP) | 0x80000000u;
+cP += 1u;
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-uint kd = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uint ij = aq(aq(kd, dim), uint(sequenceSeed));
-uint i = sK(bd, aq(ij, 0u));
-uint x = reverseBits(iE(i, aq(ij, 1u)));
+uint kI = aZ.x + aZ.y * uint(round(1.0 / pixelSize.x));
+uint seed = ar(ar(kI, dim), uint(sequenceSeed));
+uint i = ua(aQ, ar(seed, 0u));
+uint x = reverseBits(iV(i, ar(seed, 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 qa = 1.0 / size;
+vec2 qX = 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)) * qa);
-vec4 s2 = texture(map, (uv + vec2(1, 0)) * qa);
-vec4 s3 = texture(map, (uv + vec2(0, 1)) * qa);
-vec4 s4 = texture(map, (uv + vec2(1, 1)) * qa);
+vec4 s1 = texture(map, (uv + vec2(0, 0)) * qX);
+vec4 s2 = texture(map, (uv + vec2(1, 0)) * qX);
+vec4 s3 = texture(map, (uv + vec2(0, 1)) * qX);
+vec4 s4 = texture(map, (uv + vec2(1, 1)) * qX);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 #endif

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

@@ -1,5 +1,5 @@
 import { glsl } from '../../shader.js';
-import { uvProjectionConstants } from '../../MaterialTable.js';
+import { uvProjectionConstants } from '../../materialConstants.js';
 export default glsl `
 vec2 sphericalProjection(vec3 pos) {
 vec3 n = normalize(pos);
@@ -8,12 +8,12 @@ float phi = acos(n.y) / PI;
 return vec2(theta, 1.0 - phi);
 }
 
-vec2 iR(vec3 pos, vec3 normal, vec2 uvScale) {
-vec3 dn = abs(normal);
+vec2 jh(vec3 pos, vec3 normal, vec2 uvScale) {
+vec3 dI = abs(normal);
 vec2 uv = vec2(0.0);
-if (dn.x > dn.y && dn.x > dn.z) {
+if (dI.x > dI.y && dI.x > dI.z) {
 uv = pos.yz;
-} else if (dn.y > dn.x && dn.y > dn.z) {
+} else if (dI.y > dI.x && dI.y > dI.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -53,18 +53,18 @@ return fract(uv * uvScale);
 
 
 
-vec2 hD(vec3 pos, vec3 normal) {
+vec2 hT(vec3 pos, vec3 normal) {
 float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gI(int fk, vec3 pos, vec3 normal, vec2 uvScale) {
-if (fk == ${uvProjectionConstants.triplanar + ''}) {
-return iR(pos, normal, uvScale);
-} else if (fk == ${uvProjectionConstants.spherical + ''}) {
+vec2 gU(int fE, vec3 pos, vec3 normal, vec2 uvScale) {
+if (fE == ${uvProjectionConstants.triplanar + ''}) {
+return jh(pos, normal, uvScale);
+} else if (fE == ${uvProjectionConstants.spherical + ''}) {
 return sphericalProjection(pos) * uvScale;
-} else if (fk == ${uvProjectionConstants.cylindrical + ''}) {
-return hD(pos, normal) * uvScale;
+} else if (fE == ${uvProjectionConstants.cylindrical + ''}) {
+return hT(pos, normal) * uvScale;
 }
 return vec2(0.0);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"uvProjection.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/uvProjection.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2DO,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAE7B,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAEpC,qBAAqB,CAAC,WAAW,GAAG,EAAE;;;;;CAKtE,CAAC","sourcesContent":["import { glsl } from '../../shader.js';\nimport { uvProjectionConstants } from '../../MaterialTable.js';\n\nexport default glsl`\nvec2 sphericalProjection(vec3 pos) {\n  vec3 n = normalize(pos);\n  float theta = atan(n.x, n.z) / (2.0 * PI) + 0.5;\n  float phi = acos(n.y) / PI;\n  return vec2(theta, 1.0 - phi);\n}\n\nvec2 triplanarProjection(vec3 pos, vec3 normal, vec2 uvScale) {\n  vec3 absNormal = abs(normal);\n  vec2 uv = vec2(0.0);\n  if (absNormal.x > absNormal.y && absNormal.x > absNormal.z) {\n    uv = pos.yz;\n  } else if (absNormal.y > absNormal.x && absNormal.y > absNormal.z) {\n    uv = pos.xz;\n  } else {\n    uv = pos.xy;\n  }\n  return fract(uv * uvScale);\n}\n\n// vec4 triplanarProjectionSample(\n//   sampler2DArray _map, vec2 mapSize, int index,\n//   vec3 pos, vec3 normal, vec2 uvScale, float blending\n// ) {\n//   vec3 absNormal = abs(normal);\n//   // Calculate blending power - higher expo means sharper transitions\n//   float expo = (1.0 - blending) * 125.0 + blending * 3.0;\n  \n//   // Weight each axis by its normal component raised to expo power\n//   vec3 weights = pow(absNormal, vec3(expo));\n  \n//   // Normalize weights so they sum to 1\n//   weights = weights / (weights.x + weights.y + weights.z);\n  \n//   // Project UVs on each axis plane (yz, xz, xy)\n//   vec2 yzPlane = pos.yz * uvScale;\n//   vec2 xzPlane = pos.xz * uvScale;\n//   vec2 xyPlane = pos.xy * uvScale;\n//   // Wrap\n//   yzPlane = fract(yzPlane);\n//   xzPlane = fract(xzPlane);\n//   xyPlane = fract(xyPlane);\n\n//   // Sample maps\n//   vec4 yz = texture(_map, vec3(yzPlane * mapSize, float(index)));\n//   vec4 xz = texture(_map, vec3(xzPlane * mapSize, float(index)));\n//   vec4 xy = texture(_map, vec3(xyPlane * mapSize, float(index)));\n  \n//   // Blend the projected coordinates using the weights\n//   return weights.x * yz + weights.y * xz + weights.z * xy;\n// }\n\nvec2 cylindricalProjection(vec3 pos, vec3 normal) {\n  float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;\n  return vec2(theta, pos.y);\n}\n\nvec2 projectUV(int projectionType, vec3 pos, vec3 normal, vec2 uvScale) {\n  if (projectionType == ${uvProjectionConstants.triplanar + ''}) {\n    return triplanarProjection(pos, normal, uvScale);\n  } else if (projectionType == ${uvProjectionConstants.spherical + ''}) {\n    return sphericalProjection(pos) * uvScale;\n  } else if (projectionType == ${uvProjectionConstants.cylindrical + ''}) {\n    return cylindricalProjection(pos, normal) * uvScale;\n  }\n  return vec2(0.0);\n}\n`;\n"]}
+{"version":3,"file":"uvProjection.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/uvProjection.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2DO,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAE7B,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAEpC,qBAAqB,CAAC,WAAW,GAAG,EAAE;;;;;CAKtE,CAAC","sourcesContent":["import { glsl } from '../../shader.js';\nimport { uvProjectionConstants } from '../../materialConstants.js';\n\nexport default glsl`\nvec2 sphericalProjection(vec3 pos) {\n  vec3 n = normalize(pos);\n  float theta = atan(n.x, n.z) / (2.0 * PI) + 0.5;\n  float phi = acos(n.y) / PI;\n  return vec2(theta, 1.0 - phi);\n}\n\nvec2 triplanarProjection(vec3 pos, vec3 normal, vec2 uvScale) {\n  vec3 absNormal = abs(normal);\n  vec2 uv = vec2(0.0);\n  if (absNormal.x > absNormal.y && absNormal.x > absNormal.z) {\n    uv = pos.yz;\n  } else if (absNormal.y > absNormal.x && absNormal.y > absNormal.z) {\n    uv = pos.xz;\n  } else {\n    uv = pos.xy;\n  }\n  return fract(uv * uvScale);\n}\n\n// vec4 triplanarProjectionSample(\n//   sampler2DArray _map, vec2 mapSize, int index,\n//   vec3 pos, vec3 normal, vec2 uvScale, float blending\n// ) {\n//   vec3 absNormal = abs(normal);\n//   // Calculate blending power - higher expo means sharper transitions\n//   float expo = (1.0 - blending) * 125.0 + blending * 3.0;\n  \n//   // Weight each axis by its normal component raised to expo power\n//   vec3 weights = pow(absNormal, vec3(expo));\n  \n//   // Normalize weights so they sum to 1\n//   weights = weights / (weights.x + weights.y + weights.z);\n  \n//   // Project UVs on each axis plane (yz, xz, xy)\n//   vec2 yzPlane = pos.yz * uvScale;\n//   vec2 xzPlane = pos.xz * uvScale;\n//   vec2 xyPlane = pos.xy * uvScale;\n//   // Wrap\n//   yzPlane = fract(yzPlane);\n//   xzPlane = fract(xzPlane);\n//   xyPlane = fract(xyPlane);\n\n//   // Sample maps\n//   vec4 yz = texture(_map, vec3(yzPlane * mapSize, float(index)));\n//   vec4 xz = texture(_map, vec3(xzPlane * mapSize, float(index)));\n//   vec4 xy = texture(_map, vec3(xyPlane * mapSize, float(index)));\n  \n//   // Blend the projected coordinates using the weights\n//   return weights.x * yz + weights.y * xz + weights.z * xy;\n// }\n\nvec2 cylindricalProjection(vec3 pos, vec3 normal) {\n  float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;\n  return vec2(theta, pos.y);\n}\n\nvec2 projectUV(int projectionType, vec3 pos, vec3 normal, vec2 uvScale) {\n  if (projectionType == ${uvProjectionConstants.triplanar + ''}) {\n    return triplanarProjection(pos, normal, uvScale);\n  } else if (projectionType == ${uvProjectionConstants.spherical + ''}) {\n    return sphericalProjection(pos) * uvScale;\n  } else if (projectionType == ${uvProjectionConstants.cylindrical + ''}) {\n    return cylindricalProjection(pos, normal) * uvScale;\n  }\n  return vec2(0.0);\n}\n`;\n"]}

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

@@ -33,18 +33,18 @@ if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) return;
 vec4 origin = viewProjectionInv * vec4(uv * 2.0 - 1.0, -1.0, 1.0);
 vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
 Ray ray;
-iC(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+gC(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 vec3 eye = viewInv[3].xyz;
-vec3 oj = -normalize(viewInv[2].xyz);
-ad si;
+vec3 forward = -normalize(viewInv[2].xyz);
+SurfaceInteraction si;
 si.triangleIndex = -1;
 for (int layer = 0; layer < 32; layer++) {
-cZ(ray, si, false);
+intersectScene(ray, si, false);
 if (!si.hit) return;
-J material;
-eX(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+OpenPbrResolvedMaterial material;
+dg(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-out_depth.r = max(dot(si.position - eye, oj), 0.0);
+out_depth.r = max(dot(si.position - eye, forward), 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

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

@@ -10,28 +10,36 @@ const normalizeRayTraceOutput = new FragmentShader({
         albedoTex: Shader.uniform('sampler2D'),
         normalTex: Shader.uniform('sampler2D'),
         shadowCatcherTex: Shader.uniform('sampler2D'),
+        catcherMomentsTex: Shader.uniform('sampler2D'),
         sampleCount: Shader.uniform('float', 1),
         lightScale: Shader.uniform('vec2', [1, 1])
     },
     main: glsl `
 void main() {
 vec2 uv = lightScale * v_Texcoord;
-vec4 rV = sample_albedoTex(uv);
-float hit = rV.a;
-vec4 rZ = sample_normalTex(uv);
+vec4 tb = sample_albedoTex(uv);
+float hit = tb.a;
+vec4 tf = sample_normalTex(uv);
 
 
 
-float sr = max(rZ.a, 1.0);
-vec3 albedo = rV.rgb / sr;
-vec3 normal = rZ.rgb / sr;
-vec4 shadowCatcher= sample_shadowCatcherTex(uv) / sampleCount;
-vec4 sB = sample_colorTex(uv);
+float tK = max(tf.a, 1.0);
+vec3 albedo = tb.rgb / tK;
+vec3 normal = tf.rgb / tK;
+vec4 shadowCatcher = sample_shadowCatcherTex(uv);
 
 
 
+float tj = sample_catcherMomentsTex(uv).w;
+float opacity = tj > 0.0 ? shadowCatcher.a / tj : 0.0;
+shadowCatcher /= sampleCount;
+shadowCatcher.a = 1.0 - shadowCatcher.r * opacity;
+vec4 tQ = sample_colorTex(uv);
 
-vec4 light = vec4(sB.rgb / (hit > 0.0 ? hit : sampleCount), sB.a / sampleCount);
+
+
+
+vec4 light = vec4(tQ.rgb / (hit > 0.0 ? hit : sampleCount), tQ.a / sampleCount);