@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -16,41 +16,41 @@ const BOUNCE_STRIDE = 64u;
 
 
 
-var<private> aZ: vec2u;
-var<private> aQ: u32;
-var<private> bT: u32 = 0u;
-var<private> cP: u32 = 0u;
-fn dG(kW: u32) -> u32 {
-var x = kW;
+var<private> aI: vec2u;
+var<private> aC: u32;
+var<private> samplingBounce: u32 = 0u;
+var<private> ca: u32 = 0u;
+fn cB(kC: u32) -> u32 {
+var x = kC;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
-fn ar(a: u32, b: u32) -> u32 {
-return dG(a ^ dG(b + 0x9e3779b9u));
+fn ak(a: u32, b: u32) -> u32 {
+return cB(a ^ cB(b + 0x9e3779b9u));
 }
-fn iV(kW: u32, seed: u32) -> u32 {
-var x = kW + seed;
+fn iD(kC: u32, seed: u32) -> u32 {
+var x = kC + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-fn ua(x: u32, seed: u32) -> u32 {
-return reverseBits(iV(reverseBits(x), seed));
+fn ud(x: u32, seed: u32) -> u32 {
+return reverseBits(iD(reverseBits(x), seed));
 }
 
-fn su(kW: u32) -> u32 {
-var r = reverseBits(kW);
+fn sm(kC: u32) -> u32 {
+var r = reverseBits(kC);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn xE(index: u32, seed: u32) -> vec2f {
-let i = ua(index, ar(seed, 0u));
-let x = reverseBits(iV(i, ar(seed, 1u)));
-let y = ua(su(i), ar(seed, 2u));
+fn yf(index: u32, seed: u32) -> vec2f {
+let i = ud(index, ak(seed, 0u));
+let x = reverseBits(iD(i, ak(seed, 1u)));
+let y = ud(sm(i), ak(seed, 2u));
 return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
 }
-fn uR(p: vec2u) -> u32 {
+fn uX(p: vec2u) -> u32 {
 var v = p & vec2u(255u);
 v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);
 v = (v | (v << vec2u(2u))) & vec2u(0x3333u);
@@ -58,112 +58,112 @@ 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 la(uU: u32) -> u32 {
-let group = uU >> 2u;
+fn kG(va: u32) -> u32 {
+let group = va >> 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 >> ((uU & 3u) * 8u)) & 255u;
+return (word >> ((va & 3u) * 8u)) & 255u;
 }
-fn qS(lu: u32, dim: u32, logSPP: u32) -> u32 {
+fn qJ(kY: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let vN = 8u + ((logSPP + 1u) >> 1u);
+let wb = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(vN) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(wb) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
-var tL = 0u;
-if (shift < 30u) { tL = lu >> (shift + 2u); }
-let uU = (dG(tL ^ (0x55555555u * dim)) >> 24u) % 24u;
-let d = (lu >> shift) & 3u;
-result |= ((la(uU) >> (2u*d)) & 3u) << shift;
+var tN = 0u;
+if (shift < 30u) { tN = kY >> (shift + 2u); }
+let va = (cB(tN ^ (0x55555555u * dim)) >> 24u) % 24u;
+let d = (kY >> shift) & 3u;
+result |= ((kG(va) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (lu & 1u) ^ (dG((lu >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kY & 1u) ^ (cB((kY >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-fn cE(slot: u32) -> u32 {
-return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + bT * BOUNCE_STRIDE + slot;
+fn bE(slot: u32) -> u32 {
+return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;
 }
-fn sl(candidate: u32, slot: u32) -> u32 {
+fn sf(candidate: u32, slot: u32) -> u32 {
 if (candidate == 0u) {
-if (slot == 2u) { return cE(8u); }
-return cE(slot);
+if (slot == 2u) { return bE(8u); }
+return bE(slot);
 }
-return cE(9u + (candidate - 1u) * 3u + slot);
+return bE(9u + (candidate - 1u) * 3u + slot);
 }
 
 
-var<private> hA: vec4u;
-var<private> hB: u32;
-var<private> fQ: bool = false;
-var<private> dv: bool = false;
-var<private> dQ: u32;
-var<private> gK: u32;
-var<private> fa: vec2f;
-fn dN(dim: u32) {
+var<private> hg: vec4u;
+var<private> hh: u32;
+var<private> fA: bool = false;
+var<private> cX: bool = false;
+var<private> dD: u32;
+var<private> gt: u32;
+var<private> eJ: vec2f;
+fn dm(dim: u32) {
 
-let kI = aZ.x + aZ.y * u32(rtUniform.outputSize.x);
-let key = vec4u(dim, aQ, kI, rtUniform.sequenceSeed);
-if (fQ && all(hA == key) && hB == rtUniform.zSobolLogSPP) { return; }
-hA = key; hB = rtUniform.zSobolLogSPP;
-fQ = true; dv = false;
-var seed = ar(ar(kI, dim), rtUniform.sequenceSeed);
-var index = aQ;
+let kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
+let key = vec4u(dim, aC, kl, rtUniform.sequenceSeed);
+if (fA && all(hg == key) && hh == rtUniform.zSobolLogSPP) { return; }
+hg = key; hh = rtUniform.zSobolLogSPP;
+fA = true; cX = false;
+var seed = ak(ak(kl, dim), rtUniform.sequenceSeed);
+var index = aC;
 if (SAMPLING_PATTERN == 1) {
 var logSPP = rtUniform.zSobolLogSPP;
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-var jw = index >> logSPP;
+var jd = index >> logSPP;
 let mask = (1u << logSPP) - 1u;
-let lu = (uR(aZ) << logSPP) | (index & mask);
-index = qS(lu, dim, logSPP);
-let tile = aZ >> vec2u(8u);
-seed = ar(ar(dim, rtUniform.sequenceSeed), ar(tile.x, tile.y));
+let kY = (uX(aI) << logSPP) | (index & mask);
+index = qJ(kY, dim, logSPP);
+let tile = aI >> vec2u(8u);
+seed = ak(ak(dim, rtUniform.sequenceSeed), ak(tile.x, tile.y));
 
-if (aQ != 0u) { jw += 1u; }
-seed = ar(seed, jw);
+if (aC != 0u) { jd += 1u; }
+seed = ak(seed, jd);
 }
-dQ = ua(index, ar(seed, 0u));
-gK = seed;
-let x = reverseBits(iV(dQ, ar(seed, 1u)));
-fa.x = f32(x >> 8u) * (1.0 / 16777216.0);
+dD = ud(index, ak(seed, 0u));
+gt = seed;
+let x = reverseBits(iD(dD, ak(seed, 1u)));
+eJ.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
-fn lC(dim: u32) -> vec2f {
-dN(dim);
-if (!dv) {
-let y = ua(su(dQ), ar(gK, 2u));
-fa.y = f32(y >> 8u) * (1.0 / 16777216.0);
-dv = true;
+fn le(dim: u32) -> vec2f {
+dm(dim);
+if (!cX) {
+let y = ud(sm(dD), ak(gt, 2u));
+eJ.y = f32(y >> 8u) * (1.0 / 16777216.0);
+cX = true;
 }
-return EPS + (1.0 - 2.0*EPS) * fa;
+return EPS + (1.0 - 2.0*EPS) * eJ;
 }
-fn dp(dim: u32) -> f32 {
+fn sample1D(dim: u32) -> f32 {
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dN(dim);
-return EPS + (1.0 - 2.0*EPS) * fa.x;
+dm(dim);
+return EPS + (1.0 - 2.0*EPS) * eJ.x;
 }
-fn dZ(dim: u32) -> vec2f {
+fn sample2D(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
-let x = dp(dim); let y = dp(dim);
+let x = sample1D(dim); let y = sample1D(dim);
 return vec2f(x,y);
 }
-return lC(dim);
+return le(dim);
 }
 
-fn eC(slot: u32) -> f32 {
-let dim = ar(ar(bT, slot), cP) | 0x80000000u;
-cP += 1u;
+fn ek(slot: u32) -> f32 {
+let dim = ak(ak(samplingBounce, slot), ca) | 0x80000000u;
+ca += 1u;
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-let kI = aZ.x + aZ.y * u32(rtUniform.outputSize.x);
-let seed = ar(ar(kI, dim), rtUniform.sequenceSeed);
-let i = ua(aQ, ar(seed, 0u));
-let x = reverseBits(iV(i, ar(seed, 1u)));
+let kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
+let seed = ak(ak(kl, dim), rtUniform.sequenceSeed);
+let i = ud(aC, ak(seed, 0u));
+let x = reverseBits(iD(i, ak(seed, 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 jh(pos: vec3f, normal: vec3f) -> vec2f {
-let dI = abs(normal);
+fn iO(pos: vec3f, normal: vec3f) -> vec2f {
+let dg = abs(normal);
 var uv = vec2f(0.0);
-if (dI.x > dI.y && dI.x > dI.z) {
+if (dg.x > dg.y && dg.x > dg.z) {
 uv = pos.yz;
-} else if (dI.y > dI.x && dI.y > dI.z) {
+} else if (dg.y > dg.x && dg.y > dg.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -23,18 +23,18 @@ return uv;
 
 
 
-fn hT(pos: vec3f, normal: vec3f) -> vec2f {
+fn hA(pos: vec3f, normal: vec3f) -> vec2f {
 let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2f(theta, pos.y);
 }
 
-fn gU(fE: i32, pos: vec3f, normal: vec3f) -> vec2f {
-if (fE == ${uvProjectionConstants.triplanar}) {
-return jh(pos, normal);
-} else if (fE == ${uvProjectionConstants.spherical}) {
+fn gE(fg: i32, pos: vec3f, normal: vec3f) -> vec2f {
+if (fg == ${uvProjectionConstants.triplanar}) {
+return iO(pos, normal);
+} else if (fg == ${uvProjectionConstants.spherical}) {
 return sphericalProjection(pos);
-} else if (fE == ${uvProjectionConstants.cylindrical}) {
-return hT(pos, normal);
+} else if (fg == ${uvProjectionConstants.cylindrical}) {
+return hA(pos, normal);
 }
 return vec2f(0.0);
 }

package/lib/renderer/wgsl/compose.frag.wgsl.js

@@ -8,24 +8,24 @@ return select(high, low, linear <= vec3f(0.0031308));
 `;
 export const composeDefine = /* wgsl */ `
 
-fn ky(color: vec3f) -> vec3f {
+fn kb(color: vec3f) -> vec3f {
 return clamp(color, vec3f(0.0), vec3f(1.0));
 }
-fn jf(color: vec3f) -> vec3f {
+fn iN(color: vec3f) -> vec3f {
 return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));
 }
-fn kj(jR: vec3f) -> vec3f {
-let color = max(vec3f(0.0), jR - 0.004);
+fn jP(jz: vec3f) -> vec3f {
+let color = max(vec3f(0.0), jz - 0.004);
 return pow((color * (6.2 * color + 0.5)) /
 (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));
 }
-fn pH(value: vec3f) -> vec3f {
-let lv = value * (value + 0.0245786) - 0.000090537;
-let aq = value * (0.983729 * value + 0.4329510) + 0.238081;
-return lv / aq;
+fn pm(value: vec3f) -> vec3f {
+let iF = value * (value + 0.0245786) - 0.000090537;
+let ah = value * (0.983729 * value + 0.4329510) + 0.238081;
+return iF / ah;
 }
-fn mh(jR: vec3f) -> vec3f {
-let qs = mat3x3f(
+fn lO(jz: vec3f) -> vec3f {
+let qk = mat3x3f(
 vec3f(0.59719, 0.07600, 0.02840),
 vec3f(0.35458, 0.90834, 0.13383),
 vec3f(0.04823, 0.01566, 0.83777)
@@ -35,63 +35,63 @@ vec3f(1.60475, -0.10208, -0.00327),
 vec3f(-0.53108, 1.10813, -0.07276),
 vec3f(-0.07367, -0.00605, 1.07602)
 );
-let color = qs * (jR / 0.6);
-return clamp(outputMatrix * pH(color), vec3f(0.0), vec3f(1.0));
+let color = qk * (jz / 0.6);
+return clamp(outputMatrix * pm(color), vec3f(0.0), vec3f(1.0));
 }
-fn gh(value: vec3f) -> vec3f {
-let nM = value * value;
-let rR = nM * nM;
-return 15.5 * rR * nM - 40.14 * rR * value
-+ 31.96 * rR - 6.868 * nM * value
-+ 0.4298 * nM + 0.1191 * value - 0.00232;
+fn fT(value: vec3f) -> vec3f {
+let nB = value * value;
+let rO = nB * nB;
+return 15.5 * rO * nB - 40.14 * rO * value
++ 31.96 * rO - 6.868 * nB * value
++ 0.4298 * nB + 0.1191 * value - 0.00232;
 }
-fn mM(jR: vec3f) -> vec3f {
-let nP = mat3x3f(
+fn my(jz: vec3f) -> vec3f {
+let nE = mat3x3f(
 vec3f(1.6605, -0.1246, -0.0182),
 vec3f(-0.5876, 1.1329, -0.1006),
 vec3f(-0.0728, -0.0083, 1.1187)
 );
-let nQ = mat3x3f(
+let nF = mat3x3f(
 vec3f(0.6274, 0.0691, 0.0164),
 vec3f(0.3293, 0.9195, 0.0880),
 vec3f(0.0433, 0.0113, 0.8956)
 );
-let qu = mat3x3f(
+let qm = mat3x3f(
 vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-let pt = mat3x3f(
+let ph = mat3x3f(
 vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
-var color = qu * (nQ * jR);
+var color = qm * (nF * jz);
 color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));
-color = pt * gh(color);
+color = ph * fT(color);
 color = pow(max(color, vec3f(0.0)), vec3f(2.2));
-return clamp(nP * color, vec3f(0.0), vec3f(1.0));
+return clamp(nE * color, vec3f(0.0), vec3f(1.0));
 }
-fn cp(color: vec3f) -> vec3f {
+fn bZ(color: vec3f) -> vec3f {
 let toneMappingMode = i32(toneMappingParams.x);
-if (toneMappingMode == 1) { return mh(color); }
-if (toneMappingMode == 2) { return kj(color); }
-if (toneMappingMode == 3) { return jf(color); }
-if (toneMappingMode == 4) { return ky(color); }
-return mM(color);
+if (toneMappingMode == 1) { return lO(color); }
+if (toneMappingMode == 2) { return jP(color); }
+if (toneMappingMode == 3) { return iN(color); }
+if (toneMappingMode == 4) { return kb(color); }
+return my(color);
 }
 ${linearToSrgbDefine}
-fn gq(jR: vec3f) -> vec3f {
+fn ga(jz: vec3f) -> vec3f {
 let contrast = colorGradingParams.x;
 let saturation = colorGradingParams.y;
 let temperature = colorGradingParams.z;
 let tint = colorGradingParams.w;
-let uH = vec3f(
+let uL = vec3f(
 1.0 + temperature * 0.16 + tint * 0.04,
 1.0 - tint * 0.12,
 1.0 - temperature * 0.16 + tint * 0.04
 );
-var color = max(jR * uH, vec3f(0.0));
+var color = max(jz * uL, vec3f(0.0));
 color = max((color - 0.18) * contrast + 0.18, vec3f(0.0));
 let luminance = dot(color, vec3f(0.2126, 0.7152, 0.0722));
 return max(mix(vec3f(luminance), color, saturation), vec3f(0.0));
@@ -101,54 +101,54 @@ export function createComposeMain(sdrEncoding = 'srgb') {
     return /* wgsl */ `
 
 var finalColor = load_colorTex(uv, 0);
-var jI = vec4(0.0);
+var jp = vec4(0.0);
 if (bloomIntensity > 0.0) {
-jI = load_bloomTex(uv, 0) * bloomIntensity;
-finalColor = vec4f(finalColor.rgb + jI.rgb, finalColor.a);
+jp = load_bloomTex(uv, 0) * bloomIntensity;
+finalColor = vec4f(finalColor.rgb + jp.rgb, finalColor.a);
 }
 
-var gradedColor = gq(finalColor.rgb * exposure);
-let ja = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
-gradedColor *= 1.0 - toneMappingParams.y * ja;
-let gQ = hdrOutputEnabled > 0.5;
-if (!gQ) {
-gradedColor = cp(gradedColor);
+var gradedColor = ga(finalColor.rgb * exposure);
+let iJ = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
+gradedColor *= 1.0 - toneMappingParams.y * iJ;
+let gy = hdrOutputEnabled > 0.5;
+if (!gy) {
+gradedColor = bZ(gradedColor);
 }
-let mZ = select(
+let mN = select(
 ${sdrEncoding === 'srgb' ? 'linearToSrgb(gradedColor)' : 'pow(max(gradedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
 linearToSrgb(gradedColor),
-gQ
+gy
 );
-var oV = mZ;
+var oL = mN;
 if (flatBackgroundColor.a > 0.5) {
-let jD = clamp(
+let jj = clamp(
 load_flatBackgroundMaskTex(uv, 0).a,
 0.0,
 1.0
 );
-let pX = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));
-oV = mix(pX, mZ, jD);
+let pR = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));
+oL = mix(pR, mN, jj);
 if (bloomIntensity > 0.0) {
-var unbloomedColor = gq(
-max(finalColor.rgb - jI.rgb, vec3f(0.0))
+var unbloomedColor = ga(
+max(finalColor.rgb - jp.rgb, vec3f(0.0))
 * exposure
 );
-unbloomedColor *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) {
-unbloomedColor = cp(unbloomedColor);
+unbloomedColor *= 1.0 - toneMappingParams.y * iJ;
+if (!gy) {
+unbloomedColor = bZ(unbloomedColor);
 }
-let sG = select(
+let sC = select(
 ${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedColor)' : 'pow(max(unbloomedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
 linearToSrgb(unbloomedColor),
-gQ
+gy
 );
-oV += max(mZ - sG, vec3f(0.0))
-* (1.0 - jD);
+oL += max(mN - sC, vec3f(0.0))
+* (1.0 - jj);
 }
 }
-finalColor = vec4f(oV, finalColor.a);
+finalColor = vec4f(oL, finalColor.a);
 if (bloomIntensity > 0.0) {
-finalColor.a = max(finalColor.a, min(dot(jI.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
+finalColor.a = max(finalColor.a, min(dot(jp.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
 }
 
 if (shadowCatcherEnabled > 0.5) {
@@ -162,36 +162,36 @@ let background = load_catcherBackgroundTex(uv, 0);
 
 
 
-let ln = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
-var foregroundColor = gq((foreground.rgb + jI.rgb) * exposure);
-var backgroundColor = gq((background.rgb / max(background.a, 0.000001) + jI.rgb) * exposure);
-foregroundColor *= 1.0 - toneMappingParams.y * ja;
-backgroundColor *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) {
-foregroundColor = cp(foregroundColor);
-backgroundColor = cp(backgroundColor);
+let kU = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
+var foregroundColor = ga((foreground.rgb + jp.rgb) * exposure);
+var backgroundColor = ga((background.rgb / max(background.a, 0.000001) + jp.rgb) * exposure);
+foregroundColor *= 1.0 - toneMappingParams.y * iJ;
+backgroundColor *= 1.0 - toneMappingParams.y * iJ;
+if (!gy) {
+foregroundColor = bZ(foregroundColor);
+backgroundColor = bZ(backgroundColor);
 }
-foregroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(foregroundColor)' : 'pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(foregroundColor), gQ);
-backgroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(backgroundColor)' : 'pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(backgroundColor), gQ);
+foregroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(foregroundColor)' : 'pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(foregroundColor), gy);
+backgroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(backgroundColor)' : 'pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(backgroundColor), gy);
 if (flatBackgroundColor.a > 0.5) {
-var unbloomedBackground = gq(background.rgb / max(background.a, 0.000001) * exposure);
-unbloomedBackground *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) { unbloomedBackground = cp(unbloomedBackground); }
-let nd = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedBackground)' : 'pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(unbloomedBackground), gQ);
-let vL = select(vec3f(0.0), max(backgroundColor - nd, vec3f(0.0)), bloomIntensity > 0.0);
-backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + vL;
+var unbloomedBackground = ga(background.rgb / max(background.a, 0.000001) * exposure);
+unbloomedBackground *= 1.0 - toneMappingParams.y * iJ;
+if (!gy) { unbloomedBackground = bZ(unbloomedBackground); }
+let mO = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedBackground)' : 'pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(unbloomedBackground), gy);
+let vY = select(vec3f(0.0), max(backgroundColor - mO, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + vY;
 }
 
 
-let gf = coverage * opacity;
-let mR = clamp(dot(jI.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
-let hJ = max(foreground.a, mR * (1.0 - coverage - ln));
-let jz = max(background.a, mR * coverage);
-let kX = (jz - ln) * (1.0 - opacity) + ln;
-let alpha = hJ + kX + gf;
-let premultiplied = foregroundColor * hJ
-+ backgroundColor * kX
-+ shadowCatcherColor * gf;
+let fR = coverage * opacity;
+let mD = clamp(dot(jp.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+let hq = max(foreground.a, mD * (1.0 - coverage - kU));
+let jf = max(background.a, mD * coverage);
+let kD = (jf - kU) * (1.0 - opacity) + kU;
+let alpha = hq + kD + fR;
+let premultiplied = foregroundColor * hq
++ backgroundColor * kD
++ shadowCatcherColor * fR;
 finalColor = vec4f(premultiplied / max(alpha, 0.000001), alpha);
 }
 }
@@ -208,8 +208,8 @@ export function createCompositeDenoiseColorMain(output = 'output.denoiseColor',
     const srgbDecode = 'select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92, encoded <= vec3f(0.04045))';
     return /* wgsl */ `
 let encoded = max(${input}.rgb, vec3f(0.0));
-let um = ${sdrEncoding === 'srgb' ? srgbDecode : `select(pow(encoded, vec3f(2.2)), ${srgbDecode}, gQ)`};
-${output} = vec4f(um, ${input}.a);
+let uq = ${sdrEncoding === 'srgb' ? srgbDecode : `select(pow(encoded, vec3f(2.2)), ${srgbDecode}, gy)`};
+${output} = vec4f(uq, ${input}.a);
 
 `;
 }
@@ -219,22 +219,22 @@ export function createCompositeDenoiseAlbedoMain(output = 'output.denoiseAlbedo'
 
 
 let rawAlbedo = load_flatBackgroundMaskTex(uv, 0);
-var pS = rawAlbedo.rgb;
+var pJ = rawAlbedo.rgb;
 if (shadowCatcherEnabled > 0.5 && flatBackgroundColor.a < 0.5) {
 let coverage = clamp(load_shadowCatcherTex(uv, 0).r, 0.0, 1.0);
 let background = load_catcherBackgroundTex(uv, 0);
 if (coverage > 0.0 && background.a > 0.0) {
-var iO = gq(background.rgb / background.a * exposure);
-iO *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) { iO = cp(iO); }
+var iv = ga(background.rgb / background.a * exposure);
+iv *= 1.0 - toneMappingParams.y * iJ;
+if (!gy) { iv = bZ(iv); }
 
 
 
-let sA = clamp(background.a, 0.0, coverage);
-pS += sA * (clamp(iO, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
+let sr = clamp(background.a, 0.0, coverage);
+pJ += sr * (clamp(iv, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
 }
 }
-${output} = vec4f(clamp(pS, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
+${output} = vec4f(clamp(pJ, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
 `;
 }
 export const compositeDenoiseOutputMain = createCompositeDenoiseColorMain() + createCompositeDenoiseAlbedoMain();
@@ -253,15 +253,15 @@ output.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);
 export const compositeDenoiseDisplayMain = createCompositeDenoiseDisplayMain();
 // Shared hit normalization; CPU readback retains its f32 reference path.
 export const hdrResolveWGSL = /* wgsl */ `
-fn fK(color: f32, count: f32, hit: f32, ur: f32, rgb: bool) -> f32 {
+fn fo(color: f32, count: f32, hit: f32, uw: f32, rgb: bool) -> f32 {
 if (count <= 0.0) {
 return 0.0;
 }
-let total = max(count, ur);
+let total = max(count, uw);
 let divisor = select(total, hit, (rgb && (hit > 0.0)));
 return (color / divisor);
 }
-fn jQ(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {
+fn jx(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {
 if ((flat && rgb) && (coverage > 0.0)) {
 return (color * coverage);
 }

package/lib/renderer/wgsl/customDenoise.wgsl.js

@@ -5,19 +5,19 @@ let filtered = load_filteredTex(uv, 0).rgb;
 let foreground = load_foregroundTex(uv, 0);
 let background = load_backgroundTex(uv, 0);
 
-var ni = foreground;
-var nh = background;
+var mS = foreground;
+var mR = background;
 if (any(filtered != original)) {
-let wa = abs(original) > vec3f(0.000001);
-let aq = select(vec3f(1.0), original, wa);
-let scale = select(vec3f(1.0), filtered / aq, wa);
-let vD = select(filtered - original, vec3f(0.0), wa);
-ni = vec4f(foreground.rgb * scale + vD, foreground.a);
+let wu = abs(original) > vec3f(0.000001);
+let ah = select(vec3f(1.0), original, wu);
+let scale = select(vec3f(1.0), filtered / ah, wu);
+let vO = select(filtered - original, vec3f(0.0), wu);
+mS = vec4f(foreground.rgb * scale + vO, foreground.a);
 
-nh = vec4f(background.rgb * scale + vD * background.a, background.a);
+mR = vec4f(background.rgb * scale + vO * background.a, background.a);
 }
-output.foreground = ni;
-output.background = nh;
+output.foreground = mS;
+output.background = mR;
 `;
 /** Custom output alpha is ignored; retain the input composition's coverage. */
 export const customDenoiseCoverageMain = /* wgsl */ `

package/lib/renderer/wgsl/depthQuery.wgsl.js

@@ -10,7 +10,7 @@ let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;
 let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);
 outColor[index] = vec4f(0.0);
 if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }
-var ray = fj(uv);
+var ray = eT(uv);
 let eye = cameraUniform.viewInv[3].xyz;
 let forward = -normalize(cameraUniform.viewInv[2].xyz);
 var si: SurfaceInteraction;
@@ -22,7 +22,7 @@ for (var layer = 0; layer < 32; layer++) {
 intersectScene(ray, &si, 0, false, false);
 if (!si.hit) { return; }
 var material: OpenPbrResolvedMaterial;
-dg(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
 outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);
 return;