@meimu/mutracer 0.1.4 → 0.1.5

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

@@ -11,18 +11,18 @@ export default /*wgsl*/ `
 const SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
 fn sampleShadowCatcher(si: ad, bounce: i32, aa: ptr<function, Path>) {
-let oT = -(*aa).ray.d;
+let oS = -(*aa).ray.d;
 
 
 if (rtUniform.lightChoiceCount > 0) {
 var shadow = 0.0;
 for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 var lightSample: LightSampleRec;
-let ln = vec3f(fo(rd(candidate, 1u)), dz(rd(candidate, 0u)));
+let ln = vec3f(fp(rd(candidate, 1u)), dz(rd(candidate, 0u)));
 sampleLight(si.position, ln, &lightSample, false);
 let lightDir = lightSample.direction;
 let cosThetaL = dot(si.normal, lightDir);
-let pM = dot(si.normal, oT) * cosThetaL;
+let pM = dot(si.normal, oS) * cosThetaL;
 if (lightSample.pdf > 0.0 && pM >= 0.0) {
 var ray: Ray;
 iC(&ray, si.position + EPS * lightDir, lightDir);

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

@@ -5,27 +5,27 @@ export default /*wgsl*/ `
 
 fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
 let rm = vec3f(alpha, 1.0);
-let gj = normalize(rm * view);
-let uh = min(gj.z, 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 lJ = vec3f(
-gj.x + fl * cos(br),
-gj.y + fl * sin(br),
+let lI = vec3f(
+gk.x + fl * cos(br),
+gk.y + fl * sin(br),
 rh
 );
-return normalize(rm * lJ);
+return normalize(rm * lI);
 }
 
-fn gK(oq: vec3f, alpha: vec2f) -> f32 {
+fn gL(oo: vec3f, alpha: vec2f) -> f32 {
 let hr = vec3f(
-oq.x / alpha.x,
-oq.y / alpha.y,
-oq.z
+oo.x / alpha.x,
+oo.y / alpha.y,
+oo.z
 );
 let ap = dot(hr, hr);
 return 1.0 / (
@@ -39,9 +39,9 @@ if (eF <= 1e-8) {
 return 0.0;
 }
 let ic = alpha * direction.xy;
-let lK = dot(ic, ic)
+let lJ = dot(ic, ic)
 / (eF * eF);
-return 2.0 / (1.0 + sqrt(1.0 + lK));
+return 2.0 / (1.0 + sqrt(1.0 + lJ));
 }
 
 fn aE(au: f32) -> f32 {
@@ -57,17 +57,17 @@ if (kl >= 1.0) {
 return 1.0;
 }
 
-let lU = sqrt(max(0.0, 1.0 - kl));
-let ba = (iA - cJ * lU)
-/ max(iA + cJ * lU, 1e-8);
-let pN = (cJ * iA - lU)
-/ max(cJ * iA + lU, 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 + pN * pN
 );
 }
 
-fn gh(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 kF = gh(samplePoint);
+let kF = gi(samplePoint);
 return vec3f(
 kF,
 sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-fn aG(pr: f32, nO: f32) -> f32 {
-let scale = max(pr, nO);
+fn aG(pr: f32, nN: f32) -> f32 {
+let scale = max(pr, nN);
 if (scale <= 0.0) {
 return 0.0;
 }
-let normalized = vec2f(pr, nO) / scale;
-let oP = normalized * normalized;
-return oP.x / (oP.x + oP.y);
+let normalized = vec2f(pr, nN) / scale;
+let oO = normalized * normalized;
+return oO.x / (oO.x + oO.y);
 }
 
 fn aL(
@@ -139,12 +139,12 @@ return vec3f(0.0, 0.0, rgb.b);
 
 fn eN(
 wavelength: f32,
-hg: f32,
+hh: f32,
 hp: f32,
 qs: f32
 ) -> f32 {
 if (wavelength == 0.0 || hp <= 0.0) {
-return hg;
+return hh;
 }
 
 let FRAUNHOFER_C = 656.3;
@@ -154,15 +154,15 @@ let jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-let nh = max(qs / hp, 1e-6);
-let qR = (hg - 1.0) * jR / nh;
-let tl = hg
+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 fp(
-gy: vec3f,
+fn fq(
+gz: vec3f,
 anisotropy: f32,
 samplePoint: vec2f
 ) -> vec3f {
@@ -182,10 +182,10 @@ let ud = sqrt(max(0.0, 1.0 - au * au));
 let br = TWOPI * samplePoint.x;
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(gy, &tangent, &bitangent);
+aL(gz, &tangent, &bitangent);
 return tangent * (ud * cos(br))
 + bitangent * (ud * sin(br))
-+ gy * au;
++ gz * au;
 }
 
 fn bD(au: f32, anisotropy: f32) -> f32 {

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

@@ -99,18 +99,18 @@ return cw(9u + (candidate - 1u) * 3u + slot);
 
 var<private> hl: vec4u;
 var<private> hm: u32;
-var<private> fB: bool = false;
+var<private> fC: bool = false;
 var<private> dg: bool = false;
 var<private> dF: u32;
-var<private> gu: u32;
+var<private> gv: u32;
 var<private> eQ: vec2f;
 fn dw(dim: u32) {
 
 let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
 let key = vec4u(dim, bd, kd, rtUniform.sequenceSeed);
-if (fB && all(hl == key) && hm == rtUniform.zSobolLogSPP) { return; }
+if (fC && all(hl == key) && hm == rtUniform.zSobolLogSPP) { return; }
 hl = key; hm = rtUniform.zSobolLogSPP;
-fB = true; dg = false;
+fC = true; dg = false;
 var ij = aq(aq(kd, dim), rtUniform.sequenceSeed);
 var index = bd;
 if (SAMPLING_PATTERN == 1) {
@@ -129,14 +129,14 @@ if (bd != 0u) { jb += 1u; }
 ij = aq(ij, jb);
 }
 dF = sK(index, aq(ij, 0u));
-gu = ij;
+gv = ij;
 let x = reverseBits(iE(dF, aq(ij, 1u)));
 eQ.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
 fn kS(dim: u32) -> vec2f {
 dw(dim);
 if (!dg) {
-let y = sK(rl(dF), aq(gu, 2u));
+let y = sK(rl(dF), aq(gv, 2u));
 eQ.y = f32(y >> 8u) * (1.0 / 16777216.0);
 dg = true;
 }
@@ -147,7 +147,7 @@ if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 dw(dim);
 return EPS + (1.0 - 2.0*EPS) * eQ.x;
 }
-fn fo(dim: u32) -> vec2f {
+fn fp(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
 let x = dz(dim); let y = dz(dim);
 return vec2f(x,y);

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

@@ -28,7 +28,7 @@ let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2f(theta, pos.y);
 }
 
-fn gH(fk: i32, pos: vec3f, normal: vec3f) -> vec2f {
+fn gI(fk: i32, pos: vec3f, normal: vec3f) -> vec2f {
 if (fk == ${uvProjectionConstants.triplanar}) {
 return iR(pos, normal);
 } else if (fk == ${uvProjectionConstants.spherical}) {

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

@@ -1,5 +1,5 @@
 export const linearToSrgbDefine = /* wgsl */ `
-fn fM(color: vec3f) -> vec3f {
+fn fN(color: vec3f) -> vec3f {
 let linear = max(color, vec3f(0.0));
 let low = linear * 12.92;
 let high = 1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055;
@@ -19,7 +19,7 @@ let color = max(vec3f(0.0), jr - 0.004);
 return pow((color * (6.2 * color + 0.5)) /
 (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));
 }
-fn oJ(value: vec3f) -> vec3f {
+fn oI(value: vec3f) -> vec3f {
 let kO = value * (value + 0.0245786) - 0.000090537;
 let ap = value * (0.983729 * value + 0.4329510) + 0.238081;
 return kO / ap;
@@ -30,28 +30,28 @@ vec3f(0.59719, 0.07600, 0.02840),
 vec3f(0.35458, 0.90834, 0.13383),
 vec3f(0.04823, 0.01566, 0.83777)
 );
-let oE = mat3x3f(
+let oD = mat3x3f(
 vec3f(1.60475, -0.10208, -0.00327),
 vec3f(-0.53108, 1.10813, -0.07276),
 vec3f(-0.07367, -0.00605, 1.07602)
 );
 let color = pw * (jr / 0.6);
-return clamp(oE * oJ(color), vec3f(0.0), vec3f(1.0));
+return clamp(oD * oI(color), vec3f(0.0), vec3f(1.0));
 }
-fn fT(value: vec3f) -> vec3f {
-let mO = value * value;
-let qK = mO * mO;
-return 15.5 * qK * mO - 40.14 * qK * value
-+ 31.96 * qK - 6.868 * mO * value
-+ 0.4298 * mO + 0.1191 * value - 0.00232;
+fn fU(value: vec3f) -> vec3f {
+let mN = value * value;
+let qK = mN * mN;
+return 15.5 * qK * mN - 40.14 * qK * value
++ 31.96 * qK - 6.868 * mN * value
++ 0.4298 * mN + 0.1191 * value - 0.00232;
 }
-fn me(jr: vec3f) -> vec3f {
-let mR = mat3x3f(
+fn mc(jr: vec3f) -> vec3f {
+let mQ = mat3x3f(
 vec3f(1.6605, -0.1246, -0.0182),
 vec3f(-0.5876, 1.1329, -0.1006),
 vec3f(-0.0728, -0.0083, 1.1187)
 );
-let mS = mat3x3f(
+let mR = mat3x3f(
 vec3f(0.6274, 0.0691, 0.0164),
 vec3f(0.3293, 0.9195, 0.0880),
 vec3f(0.0433, 0.0113, 0.8956)
@@ -61,16 +61,16 @@ vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-let oF = mat3x3f(
+let oE = mat3x3f(
 vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
-var color = pH * (mS * jr);
+var color = pH * (mR * jr);
 color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));
-color = oF * fT(color);
+color = oE * fU(color);
 color = pow(max(color, vec3f(0.0)), vec3f(2.2));
-return clamp(mR * color, vec3f(0.0), vec3f(1.0));
+return clamp(mQ * color, vec3f(0.0), vec3f(1.0));
 }
 fn cl(color: vec3f) -> vec3f {
 let toneMappingMode = i32(toneMappingParams.x);
@@ -78,10 +78,10 @@ if (toneMappingMode == 1) { return lv(color); }
 if (toneMappingMode == 2) { return jJ(color); }
 if (toneMappingMode == 3) { return iP(color); }
 if (toneMappingMode == 4) { return jU(color); }
-return me(color);
+return mc(color);
 }
 ${linearToSrgbDefine}
-fn gb(jr: vec3f) -> vec3f {
+fn gc(jr: vec3f) -> vec3f {
 let contrast = colorGradingParams.x;
 let saturation = colorGradingParams.y;
 let temperature = colorGradingParams.z;
@@ -106,46 +106,46 @@ jl = load_bloomTex(uv, 0) * bloomIntensity;
 dY = vec4f(dY.rgb + jl.rgb, dY.a);
 }
 
-var ll = gb(dY.rgb * exposure);
+var ll = gc(dY.rgb * exposure);
 let iI = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
 ll *= 1.0 - toneMappingParams.y * iI;
-let gA = hdrOutputEnabled > 0.5;
-if (!gA) {
+let gC = hdrOutputEnabled > 0.5;
+if (!gC) {
 ll = cl(ll);
 }
-let mn = select(
+let ml = select(
 pow(max(ll, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fM(ll),
-gA
+fN(ll),
+gC
 );
-var oc = mn;
+var ob = ml;
 if (flatBackgroundColor.a > 0.5) {
 let jg = clamp(
 load_flatBackgroundMaskTex(uv, 0).a,
 0.0,
 1.0
 );
-let pb = fM(max(flatBackgroundColor.rgb, vec3f(0.0)));
-oc = mix(pb, mn, jg);
+let pb = fN(max(flatBackgroundColor.rgb, vec3f(0.0)));
+ob = mix(pb, ml, jg);
 if (bloomIntensity > 0.0) {
-var ir = gb(
+var ir = gc(
 max(dY.rgb - jl.rgb, vec3f(0.0))
 * exposure
 );
 ir *= 1.0 - toneMappingParams.y * iI;
-if (!gA) {
+if (!gC) {
 ir = cl(ir);
 }
 let rF = select(
 pow(max(ir, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fM(ir),
-gA
+fN(ir),
+gC
 );
-oc += max(mn - rF, vec3f(0.0))
+ob += max(ml - rF, vec3f(0.0))
 * (1.0 - jg);
 }
 }
-dY = vec4f(oc, dY.a);
+dY = vec4f(ob, dY.a);
 if (bloomIntensity > 0.0) {
 dY.a = max(dY.a, min(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
 }
@@ -162,35 +162,35 @@ let background = load_catcherBackgroundTex(uv, 0);
 
 
 let kH = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
-var bK = gb((foreground.rgb + jl.rgb) * exposure);
-var backgroundColor = gb((background.rgb / max(background.a, 0.000001) + jl.rgb) * exposure);
+var bK = gc((foreground.rgb + jl.rgb) * exposure);
+var backgroundColor = gc((background.rgb / max(background.a, 0.000001) + jl.rgb) * exposure);
 bK *= 1.0 - toneMappingParams.y * iI;
 backgroundColor *= 1.0 - toneMappingParams.y * iI;
-if (!gA) {
+if (!gC) {
 bK = cl(bK);
 backgroundColor = cl(backgroundColor);
 }
-bK = select(pow(max(bK, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(bK), gA);
-backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(backgroundColor), gA);
+bK = select(pow(max(bK, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(bK), gC);
+backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(backgroundColor), gC);
 if (flatBackgroundColor.a > 0.5) {
-var eP = gb(background.rgb / max(background.a, 0.000001) * exposure);
+var eP = gc(background.rgb / max(background.a, 0.000001) * exposure);
 eP *= 1.0 - toneMappingParams.y * iI;
-if (!gA) { eP = cl(eP); }
-let mo = select(pow(max(eP, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(eP), gA);
-let uk = select(vec3f(0.0), max(backgroundColor - mo, vec3f(0.0)), bloomIntensity > 0.0);
-backgroundColor = fM(max(flatBackgroundColor.rgb, vec3f(0.0))) + uk;
+if (!gC) { eP = cl(eP); }
+let mn = select(pow(max(eP, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(eP), gC);
+let uk = select(vec3f(0.0), max(backgroundColor - mn, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = fN(max(flatBackgroundColor.rgb, vec3f(0.0))) + uk;
 }
 
 
-let fR = coverage * opacity;
-let mg = clamp(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
-let hv = max(foreground.a, mg * (1.0 - coverage - kH));
-let jd = max(background.a, mg * coverage);
+let fS = coverage * opacity;
+let mf = clamp(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+let hv = max(foreground.a, mf * (1.0 - coverage - kH));
+let jd = max(background.a, mf * coverage);
 let ku = (jd - kH) * (1.0 - opacity) + kH;
-let alpha = hv + ku + fR;
+let alpha = hv + ku + fS;
 let premultiplied = bK * hv
 + backgroundColor * ku
-+ shadowCatcherColor * fR;
++ shadowCatcherColor * fS;
 dY = vec4f(premultiplied / max(alpha, 0.000001), alpha);
 }
 }
@@ -207,7 +207,7 @@ let sW = select(
 pow(encoded, vec3f(2.2)),
 select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92,
 encoded <= vec3f(0.04045)),
-gA
+gC
 );
 output.denoiseColor = vec4f(sW, dY.a);
 
@@ -221,9 +221,9 @@ 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 iv = gb(background.rgb / background.a * exposure);
+var iv = gc(background.rgb / background.a * exposure);
 iv *= 1.0 - toneMappingParams.y * iI;
-if (!gA) { iv = cl(iv); }
+if (!gC) { iv = cl(iv); }
 
 
 
@@ -240,7 +240,7 @@ let denoised = load_colorTex(uv, 0);
 
 let alpha = select(load_composedTex(uv, 0).a, clamp(denoised.a, 0.0, 1.0), denoisedAlpha > 0.5);
 let linear = max(denoised.rgb, vec3f(0.0));
-let encoded = select(pow(linear, vec3f(1.0 / 2.2)), fM(linear), hdrOutputEnabled > 0.5);
+let encoded = select(pow(linear, vec3f(1.0 / 2.2)), fN(linear), hdrOutputEnabled > 0.5);
 output.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);
 `;
 //# sourceMappingURL=compose.frag.wgsl.js.map

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 mt = foreground;
-var mr = background;
+var mr = foreground;
+var mq = background;
 if (any(filtered != original)) {
 let uz = abs(original) > vec3f(0.000001);
 let ap = select(vec3f(1.0), original, uz);
 let scale = select(vec3f(1.0), filtered / ap, uz);
 let ub = select(filtered - original, vec3f(0.0), uz);
-mt = vec4f(foreground.rgb * scale + ub, foreground.a);
+mr = vec4f(foreground.rgb * scale + ub, foreground.a);
 
-mr = vec4f(background.rgb * scale + ub * background.a, background.a);
+mq = vec4f(background.rgb * scale + ub * background.a, background.a);
 }
-output.foreground = mt;
-output.background = mr;
+output.foreground = mr;
+output.background = mq;
 `;
 /** Custom output alpha is ignored; retain the input composition's coverage. */
 export const customDenoiseCoverageMain = /* wgsl */ `

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

@@ -12,7 +12,7 @@ outColor[index] = vec4f(0.0);
 if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }
 var ray = hC(uv);
 let eye = cameraUniform.viewInv[3].xyz;
-let ol = -normalize(cameraUniform.viewInv[2].xyz);
+let oj = -normalize(cameraUniform.viewInv[2].xyz);
 var si: ad;
 si.triangleIndex = -1;
 
@@ -24,7 +24,7 @@ if (!si.hit) { return; }
 var material: J;
 eX(&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, ol), 0.0), 0.0, 0.0, 0.0);
+outColor[index] = vec4f(max(dot(si.position - eye, oj), 0.0), 0.0, 0.0, 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

package/lib/renderer/wgsl/offlineAdaptive.compute.js

@@ -40,14 +40,14 @@ let ux = tileX * params.tileSize;
 let uy = tileY * params.tileSize;
 let wl = min(ux + params.tileSize, params.width);
 let wm = min(uy + params.tileSize, params.height);
-var mZ = 0.0;
+var mY = 0.0;
 var je = 0.0;
 var count = 0u;
 
 for (var y = uy; y < wm; y++) {
 for (var x = ux; x < wl; x++) {
-let fP = y * params.width + x;
-let offset = fP * 4u;
+let fQ = y * params.width + x;
+let offset = fQ * 4u;
 let samples = pilotMoments[offset + 3u];
 if (samples <= 0.0) {
 continue;
@@ -66,13 +66,13 @@ var variance = pi;
 if (samples > 1.0) {
 variance = pi * samples / (samples - 1.0);
 }
-mZ += mean;
+mY += mean;
 je = max(je, variance);
 count += 1u;
 }
 }
 
-let mean = mZ / f32(max(count, 1u));
+let mean = mY / f32(max(count, 1u));
 var oX = 0.0;
 if (params.hasPrevious != 0u) {
 oX = previousVariance[tile];