@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -43,50 +43,50 @@ ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}
 
 
-var<private> tw: u32 = 0u;
+var<private> tE: u32 = 0u;
 
 
 
-fn jO() -> u32 {
+fn jQ() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn po(wy: u32) -> f32 {
+fn ps(wI: u32) -> f32 {
 
 
 
 
 if (SAMPLING_PATTERN == 2) { _ = rand(); }
-let jU = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let key = aq(aq(jU, bd), rtUniform.sequenceSeed);
-let dimension = aq(cE, wy) ^ 0xa511e9b3u;
+let jW = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let key = aq(aq(jW, bd), rtUniform.sequenceSeed);
+let dimension = aq(cF, wI) ^ 0xa511e9b3u;
 return f32(eg(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
 }
 
 
 
-fn tk(fd: f32, scatteringPdf: f32) -> f32 {
-let aW = jO();
+fn tq(fd: f32, scatteringPdf: f32) -> f32 {
+let aW = jQ();
 if (aW <= 1u) {
-return aF(fd, scatteringPdf);
+return aG(fd, scatteringPdf);
 }
-let iE = f32(aW) * fd;
-return iE /
-max(iE + scatteringPdf, 1e-20);
+let iF = f32(aW) * fd;
+return iF /
+max(iF + scatteringPdf, 1e-20);
 }
 
 
 fn fS(scatteringPdf: f32, fd: f32) -> f32 {
-let aW = jO();
+let aW = jQ();
 if (aW <= 1u) {
-return aF(scatteringPdf, fd);
+return aG(scatteringPdf, fd);
 }
-let iE = f32(aW) * fd;
+let iF = f32(aW) * fd;
 return scatteringPdf /
-max(scatteringPdf + iE, 1e-20);
+max(scatteringPdf + iF, 1e-20);
 }
 
 ${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}
@@ -101,24 +101,24 @@ ${shadowCatcherAccumulationWGSL}
 @group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
 
 
-fn hH(
-gZ: u32,
-vh: vec3f,
+fn hG(
+ha: u32,
+vp: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
-let value = dot(vh, luminance);
-outNormal[gZ] += vec4f(value * value, 0.0, 0.0, 1.0);
+let value = dot(vp, luminance);
+outNormal[ha] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[gZ] += vec4f(normal, 1.0);
+outNormal[ha] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iM(gZ: u32, value: f32) {
-outShadowCatcher[gZ].moments += vec4f(value, value * value, 0.0, 0.0);
+fn iN(ha: u32, value: f32) {
+outShadowCatcher[ha].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -130,24 +130,24 @@ normal: vec3f,
 isBlank: bool,
 }
 
-fn dq(sA: vec3f, height: f32, radius: f32) -> f32 {
-let fN = length(sA);
+fn dq(sF: vec3f, height: f32, radius: f32) -> f32 {
+let fN = length(sF);
 if (fN < 0.00001) {
 return -radius;
 }
 
-let iC = radius * sA.y / fN;
-let ik = -1.5 * height;
+let iC = radius * sF.y / fN;
+let ij = -1.5 * height;
 var ev: f32;
 if (iC >= 0.0) {
 ev = radius;
 }
-else if (iC < ik) {
-ev = -height * fN / sA.y;
+else if (iC < ij) {
+ev = -height * fN / sF.y;
 }
 else {
 let dW = 1.0
-- iC * iC / (3.0 * ik * ik);
+- iC * iC / (3.0 * ij * ij);
 ev = radius * dW;
 }
 return fN - ev;
@@ -175,46 +175,46 @@ ej <= 0.0
 return direction;
 }
 
-var cB = -eI + sqrt(ej);
-if (cB <= 0.0) {
+var cC = -eI + sqrt(ej);
+if (cC <= 0.0) {
 return direction;
 }
 
-let nB = bB + bY * cB;
-if (nB.y >= 0.0) {
-return normalize(nB);
+let nE = bB + bY * cC;
+if (nE.y >= 0.0) {
+return normalize(nE);
 }
 
 if (bY.y < -0.00001 && params.y > 1.5 * params.x) {
-let hQ = (-params.x - bB.y) / bY.y;
-let nk = bB + bY * hQ;
-let nZ = (2.0 / 3.0)
+let hP = (-params.x - bB.y) / bY.y;
+let nq = bB + bY * hP;
+let oc = (2.0 / 3.0)
 * sqrt(params.y * params.y - 2.25 * params.x * params.x);
-if (hQ > 0.0 && length(nk.xz) <= nZ) {
-return normalize(nk);
+if (hP > 0.0 && length(nq.xz) <= oc) {
+return normalize(nq);
 }
 }
 
 var cN = 0.0;
 for (var i = 0; i < 14; i++) {
-let fe = (cN + cB) * 0.5;
-let pp = bB + bY * fe;
-if (dq(pp, params.x, params.y) > 0.0) {
-cB = fe;
+let fe = (cN + cC) * 0.5;
+let pt = bB + bY * fe;
+if (dq(pt, params.x, params.y) > 0.0) {
+cC = fe;
 }
 else {
 cN = fe;
 }
 }
-let hit = bB + bY * ((cN + cB) * 0.5);
+let hit = bB + bY * ((cN + cC) * 0.5);
 return normalize(hit);
 }
 
-fn hE(ray: Ray) -> vec4f {
+fn hD(ray: Ray) -> vec4f {
 var bg = vec4f(0.0);
 if (USE_BACKGROUND_MAP) {
-let pP = eQ(ray.o, ray.d);
-bg = textureLinear(backgroundMap, aS(pP));
+let pT = eQ(ray.o, ray.d);
+bg = textureLinear(backgroundMap, aS(pT));
 }
 else if (USE_BACKGROUND) {
 bg = rtUniform.backgroundColor;
@@ -226,7 +226,7 @@ return bg;
 }
 
 fn cW(ray: Ray, wavelength: f32) -> vec4f {
-let bg = hE(ray);
+let bg = hD(ray);
 if (SPECTRAL) {
 return vec4f(ai(bg.rgb, wavelength), bg.a);
 }
@@ -234,7 +234,7 @@ return bg;
 }
 
 fn bounce(uv: vec2f, aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, ad>, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) {
-cE = u32(max(*depth, 0));
+cF = u32(max(*depth, 0));
 let matType = (*ma).materialType;
 let isShadowCatcher = matType == SHADOW_CATCHER;
 if (isShadowCatcher) {
@@ -260,13 +260,13 @@ iv(aS((*aa).ray.d)) * rtUniform.envLightPmf),
 (*aa).alpha = max((*aa).alpha, bg.a);
 }
 else {
-let tE = aS((*aa).ray.d);
-var emission = textureLinear(envMap, tE).rgb;
+let tJ = aS((*aa).ray.d);
+var emission = textureLinear(envMap, tJ).rgb;
 if (SPECTRAL) {
 emission = ai(emission, (*si).wavelength);
 }
 (*aa).li += (*aa).beta * emission *
-fS((*aa).scatteringPdf, iv(tE));
+fS((*aa).scatteringPdf, iv(tJ));
 }
 }
 else {
@@ -297,10 +297,10 @@ if ((*aa).fromEye) {
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = hz(uv);
-let mz = dot(cam.d, (*aa).ray.d) > 0.0;
+let cam = hy(uv);
+let mC = dot(cam.d, (*aa).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (mz) {
+if (mC) {
 (*aa).alpha = max((*aa).alpha, bg.a);
 } else {
 (*aa).alpha = 1.0;
@@ -309,7 +309,7 @@ if (mz) {
 if (!USE_ENVMAP) {
 
 
-if (mz) {
+if (mC) {
 
 
 (*aa).li += (*aa).beta *
@@ -321,7 +321,7 @@ fS((*aa).scatteringPdf, 1.0) * bg.rgb;
 return;
 }
 
-var cG = false;
+var cH = false;
 if ((matType == STANDARD || matType == UNLIT)) {
 let alpha = clamp((*ma).alpha, 0.0, 1.0);
 
@@ -329,18 +329,18 @@ if (alpha < 1.0) {
 
 
 if (alpha <= 0.0 || eo(3u) > alpha) {
-cG = true;
+cH = true;
 }
 }
-if (!cG && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (!cH && rtUniform.transmissiveOutputAlphaMin < 1.0) {
 
 
-let tK = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
-(*aa).alpha = max(tK, (*aa).alpha);
+let tP = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
+(*aa).alpha = max(tP, (*aa).alpha);
 }
-if (!cG) {
-tw = u32(max(*depth, 0));
-lO(si, ma, aa);
+if (!cH) {
+tE = u32(max(*depth, 0));
+lR(si, ma, aa);
 }
 else {
 
@@ -349,7 +349,7 @@ else {
 }
 }
 
-if (!(*si).albedoSampled && !cG) {
+if (!(*si).albedoSampled && !cH) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -374,12 +374,12 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !cG) {
-let ow = (*aa).beta;
+if (*depth >= RR_MAX && !cH) {
+let oz = (*aa).beta;
 
-let oj = max(max(ow.x, ow.y), ow.z);
-let q: f32 = max(0.0, 1.0 - oj);
-if (dz(cv(RUSSIAN_ROULETTE)) < q) {
+let oo = max(max(oz.x, oz.y), oz.z);
+let q: f32 = max(0.0, 1.0 - oo);
+if (dz(cw(RUSSIAN_ROULETTE)) < q) {
 
 
 (*aa).alpha = 1.0;
@@ -409,7 +409,7 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (cG) {
+if (cH) {
 return;
 }
 
@@ -419,10 +419,10 @@ let hu = eo(3u) < (*ma).alpha;
 for (var i = 0; i < rtUniform.lightsCount; i++) {
 
 let light: Light = analyticLights[i];
-let d = mk((*aa).ray, light, &lightSample);
+let d = mo((*aa).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let mp = (*si).hit && d > distance((*si).position, (*aa).ray.o);
-if (d != INF && !(mp && hu)) {
+let mt = (*si).hit && d > distance((*si).position, (*aa).ray.o);
+if (d != INF && !(mt && hu)) {
 let eW = fS((*aa).scatteringPdf, lightSample.pdf);
 if (SPECTRAL) {
 lightSample.emission = ai(lightSample.emission, (*si).wavelength);
@@ -472,7 +472,7 @@ if (!USE_BACKGROUND) {
 *depth = *depth + 1;
 }
 
-fn hz(fD: vec2f) -> Ray {
+fn hy(fD: vec2f) -> Ray {
 let origin = cameraUniform.viewProjectionInv * vec4f(fD * 2.0 - 1.0, -1.0, 1.0);
 let center = cameraUniform.viewProjectionInv * vec4f(fD * 2.0 - 1.0, 1.0, 1.0);
 var cam: Ray;
@@ -482,104 +482,104 @@ return cam;
 }
 
 
-fn kn(radius: f32, xi: f32) -> vec2f {
+fn kp(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var np = 0; np < 10; np++) {
+for (var ns = 0; ns < 10; ns++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let kD = 1.0 - x;
+let kG = 1.0 - x;
 let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-let lV = 20.0 * x * kD * kD * kD;
-if (abs(value) < 1e-6 || lV == 0.0) { break; }
-x = clamp(x - value / lV, 0.0, 1.0);
+let lY = 20.0 * x * kG * kG * kG;
+if (abs(value) < 1e-6 || lY == 0.0) { break; }
+x = clamp(x - value / lY, 0.0, 1.0);
 }
-let jh = x * radius;
-return vec2f(jh, sqrt(max(radius * radius - jh * jh, 0.0)));
+let jj = x * radius;
+return vec2f(jj, sqrt(max(radius * radius - jj * jj, 0.0)));
 }
 
-fn iN(radius: f32, gr: f32) -> f32 {
-if (gr >= radius) { return 0.0; }
-let nS = radius - gr;
-return nS * nS * nS;
+fn iO(radius: f32, gs: f32) -> f32 {
+if (gs >= radius) { return 0.0; }
+let nV = radius - gs;
+return nV * nV * nV;
 }
 
 
-fn mf(source: ad, radius: f32) -> vec3f {
+fn mi(source: ad, radius: f32) -> vec3f {
 var geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) {
 geometricNormal = -geometricNormal;
 }
 var tangent: vec3f;
 var bitangent: vec3f;
-aK(geometricNormal, &tangent, &bitangent);
+aL(geometricNormal, &tangent, &bitangent);
 var iB = vec3f(0.0);
 
-for (var ib = 0; ib < BEVEL_SAMPLES; ib++) {
-let oU = fk(CAMERA_BEVEL_BASE + u32(ib));
-var cz = oU.x;
-let ou = oU.y;
+for (var ia = 0; ia < BEVEL_SAMPLES; ia++) {
+let oY = fk(CAMERA_BEVEL_BASE + u32(ia));
+var cA = oY.x;
+let ox = oY.y;
 var di = geometricNormal;
 var fE = tangent;
 var ek = bitangent;
-var fZ = 0.5;
-var hV = 0.25;
-var gy = 0.25;
-if (cz < 0.5) {
-cz *= 2.0;
-}
-else if (cz < 0.75) {
-let mx = di;
+var ga = 0.5;
+var hU = 0.25;
+var gA = 0.25;
+if (cA < 0.5) {
+cA *= 2.0;
+}
+else if (cA < 0.75) {
+let mA = di;
 di = fE;
-fE = mx;
-fZ = 0.25;
-hV = 0.5;
-cz = (cz - 0.5) * 4.0;
+fE = mA;
+ga = 0.25;
+hU = 0.5;
+cA = (cA - 0.5) * 4.0;
 }
 else {
-let mx = di;
+let mA = di;
 di = ek;
-ek = mx;
-fZ = 0.25;
-gy = 0.5;
-cz = (cz - 0.75) * 4.0;
+ek = mA;
+ga = 0.25;
+gA = 0.5;
+cA = (cA - 0.75) * 4.0;
 }
 
-let gO = kn(radius, ou);
-let phi = TWOPI * cz;
-let qj = gO.x *
+let gQ = kp(radius, ox);
+let phi = TWOPI * cA;
+let qn = gQ.x *
 (cos(phi) * fE + sin(phi) * ek);
 var ray: Ray;
 iw(
 &ray,
-source.position + di * gO.y + qj,
+source.position + di * gQ.y + qn,
 -di
 );
 var hit: ad;
-iG(
+iH(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gO.y, EPS)
+max(2.0 * gQ.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-let kE = fZ * abs(dot(di, hit.faceNormal));
-let mt = hV * abs(dot(fE, hit.faceNormal));
-let jS = gy * abs(dot(ek, hit.faceNormal));
-var weight = kE / max(
-kE * kE + mt * mt +
-jS * jS,
+let kH = ga * abs(dot(di, hit.faceNormal));
+let mw = hU * abs(dot(fE, hit.faceNormal));
+let jU = gA * abs(dot(ek, hit.faceNormal));
+var weight = kH / max(
+kH * kH + mw * mw +
+jU * jU,
 1e-8
 );
-weight *= iN(radius, distance(hit.position, source.position)) /
-max(iN(radius, gO.x), 1e-8);
+weight *= iO(radius, distance(hit.position, source.position)) /
+max(iO(radius, gQ.x), 1e-8);
 iB += weight * hit.vertexNormal;
 }
 
 if (dot(iB, iB) <= 1e-12) { return source.normal; }
-let jA = normalize(iB);
-let result = source.normal + jA - source.vertexNormal;
+let jC = normalize(iB);
+let result = source.normal + jC - source.vertexNormal;
 if (dot(result, result) > 1e-12) { return normalize(result); }
 return source.normal;
 }
@@ -596,12 +596,12 @@ aa.scatteringIsDelta = false;
 aa.isNextRefraction = false;
 aa.abort = false;
 
-let rt = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;
+let rB = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;
 let bounceLimit = max(rtUniform.bounces, 0);
 var depth = 0;
 
 for (var idx: i32 = 0; idx < min(bounceLimit * 3, ${MAX_PATH_EVENTS}); idx = idx + 1) {
-if (rt && idx > bounceLimit) {
+if (rB && idx > bounceLimit) {
 aa.abort = true;
 }
 if (aa.abort) {
@@ -623,21 +623,21 @@ return bw(uv, si, ray, ma, outAux);
 
 
 
-var nK = ray;
-nK.o = (*si).position + ray.d * (EPS * 0.02);
+var nN = ray;
+nN.o = (*si).position + ray.d * (EPS * 0.02);
 var dU = *si;
 dU.albedoSampled = false;
-cY(nK, &dU, 0, false, false);
-var rd: J;
-eT(&rd, dU.materialIndex, dU.uv, dU.uv1, dU.instanceIndex);
-var gg = *outAux;
-if (dU.hit && rd.materialType == STANDARD) {
-gg.albedo = select(
-rd.baseColor,
+cY(nN, &dU, 0, false, false);
+var rj: J;
+eT(&rj, dU.materialIndex, dU.uv, dU.uv1, dU.instanceIndex);
+var gh = *outAux;
+if (dU.hit && rj.materialType == STANDARD) {
+gh.albedo = select(
+rj.baseColor,
 vec3f(1.0),
-rd.transmissionWeight > 0.5
+rj.transmissionWeight > 0.5
 );
-gg.normal = select(
+gh.normal = select(
 dU.normal,
 -dU.normal,
 dot(
@@ -645,38 +645,38 @@ dU.normal,
 dU.position - cameraUniform.viewInv[3].xyz
 ) > 0.0
 );
-dU.albedoSampled = rd.transmissionWeight > 0.5;
+dU.albedoSampled = rj.transmissionWeight > 0.5;
 }
 let back = bw(
-uv, &dU, nK, &rd, &gg
+uv, &dU, nN, &rj, &gh
 );
 if (coverage <= 0.0) {
-*outAux = gg;
+*outAux = gh;
 return back;
 }
 
-var te = *si;
-var ut = *ma;
-ut.alpha = 1.0;
-var iQ = *outAux;
-let qL = bw(
-uv, &te, ray, &ut, &iQ
+var tk = *si;
+var uB = *ma;
+uB.alpha = 1.0;
+var iR = *outAux;
+let qQ = bw(
+uv, &tk, ray, &uB, &iR
 );
-(*outAux).albedo = mix(gg.albedo, iQ.albedo, coverage);
-let fR = mix(gg.normal, iQ.normal, coverage);
+(*outAux).albedo = mix(gh.albedo, iR.albedo, coverage);
+let fR = mix(gh.normal, iR.normal, coverage);
 (*outAux).normal = select(
 vec3f(0.0),
 normalize(fR),
 dot(fR, fR) > 1e-12
 );
-(*outAux).isBlank = gg.isBlank && iQ.isBlank;
-(*outAux).isShadowCatcher = gg.isShadowCatcher && iQ.isShadowCatcher;
-return mix(back, qL, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
+(*outAux).isBlank = gh.isBlank && iR.isBlank;
+(*outAux).isShadowCatcher = gh.isShadowCatcher && iR.isShadowCatcher;
+return mix(back, qQ, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
 }
 
 
 
-fn mj(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn mn(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 var si: ad;
 var ma: J;
 si.albedoSampled = false;
@@ -690,7 +690,7 @@ si.barycentrics = vec2f(0.0);
 cY(ray, &si, 0, false, false);
 eT(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
 
-if (ma.materialType == SHADOW_CATCHER) {
+if (si.hit && ma.materialType == SHADOW_CATCHER) {
 (*outAux).isShadowCatcher = true;
 
 
@@ -708,7 +708,7 @@ return vec4f(vec3f(1.0), aa.alpha);
 else {
 if (HAS_BEVEL && rtUniform.bevel != 0) {
 if (ma.bevel > 0.0) {
-si.normal = mf(si, ma.bevel);
+si.normal = mi(si, ma.bevel);
 }
 }
 
@@ -734,39 +734,39 @@ if (SPECTRAL) {
 
 
 
-let sD = array<f32, 3>(650.0, 510.0, 475.0);
-var tC = vec3f(0.0);
+let sI = array<f32, 3>(650.0, 510.0, 475.0);
+var tH = vec3f(0.0);
 var alpha = 0.0;
-var jw = vec3f(0.0);
-var jx = vec3f(0.0);
-var rS = true;
+var jz = vec3f(0.0);
+var jA = vec3f(0.0);
+var rX = true;
 var si2 = si;
 var ma2 = ma;
-let qz = s0;
-let nG = em;
+let qD = s0;
+let nJ = em;
 let eh = rtUniform.dispersionWavelengths == 1;
-let jF = si.hit &&
+let jH = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let rR = select(3, 1, eh);
-var lC = 0;
-if (eh && jF) {
+let rW = select(3, 1, eh);
+var lF = 0;
+if (eh && jH) {
 
 
-lC = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+lF = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
 }
-for (var i = 0; i < rR; i++) {
+for (var i = 0; i < rW; i++) {
 
 
 
 if (!eh) {
-s0 = qz;
-em = nG;
-cE = 0u;
+s0 = qD;
+em = nJ;
+cF = 0u;
 }
 si.wavelength = 0.0;
-if (!eh || jF) {
-si.wavelength = sD[select(i, lC, eh)];
+if (!eh || jH) {
+si.wavelength = sI[select(i, lF, eh)];
 ma.specularIor = eK(
 si.wavelength,
 ma.specularIor,
@@ -786,21 +786,21 @@ dD.isShadowCatcher = false;
 let res = iz(uv, &si, ray, &ma, &dD);
 if (eh) {
 *outAux = dD;
-let scale = select(1.0, 3.0, jF);
+let scale = select(1.0, 3.0, jH);
 return vec4f(res.rgb * scale, res.a);
 }
-tC += res.rgb;
+tH += res.rgb;
 alpha = max(alpha, res.a);
-jw += dD.albedo;
-jx += dD.normal;
-rS = rS && dD.isBlank;
+jz += dD.albedo;
+jA += dD.normal;
+rX = rX && dD.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = jw / 3.0;
-(*outAux).normal = jx / 3.0;
-(*outAux).isBlank = rS;
-return vec4f(tC, alpha);
+(*outAux).albedo = jz / 3.0;
+(*outAux).normal = jA / 3.0;
+(*outAux).isBlank = rX;
+return vec4f(tH, alpha);
 }
 else {
 return iz(uv, &si, ray, &ma, outAux);
@@ -808,7 +808,7 @@ return iz(uv, &si, ray, &ma, outAux);
 }
 }
 
-fn oz(ip: vec2f) -> vec2f {
+fn oC(ip: vec2f) -> vec2f {
 let p = 2.0 * ip - 1.0;
 let greater = abs(p.x) > abs(p.y);
 let r = select(p.y, p.x, greater);
@@ -847,21 +847,21 @@ let uv = (vec2<f32>(f32(fD.x), f32(fD.y)) + vec2f(0.5)) / outputSize;
 
 bc = fD;
 bd = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
-cE = 0u; em = 0u;
+cF = 0u; em = 0u;
 if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {
 jitter = (fk(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-jY(fD, i32(bd ^ eg(rtUniform.sequenceSeed)));
-var cam = hz(uv + jitter);
+ka(fD, i32(bd ^ eg(rtUniform.sequenceSeed)));
+var cam = hy(uv + jitter);
 
 if (cameraUniform.apertureRadius > 0.0) {
 
 let eye = cameraUniform.viewInv[3].xyz;
-let nV = -normalize(cameraUniform.viewInv[2].xyz);
-let qm = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, nV));
-let ru = cameraUniform.apertureRadius * oz(fk(CAMERA_LENS));
-let origin = (cameraUniform.viewInv * vec4f(ru, 0.0, 1.0)).xyz;
-let dir = normalize(qm - origin);
+let nY = -normalize(cameraUniform.viewInv[2].xyz);
+let qq = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, nY));
+let rC = cameraUniform.apertureRadius * oC(fk(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(rC, 0.0, 1.0)).xyz;
+let dir = normalize(qq - origin);
 iw(&cam, origin, dir);
 }
 
@@ -870,43 +870,52 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-var aN = mj(uv + jitter, cam, &outAux);
+var aF = mn(uv + jitter, cam, &outAux);
 
 
 
 if (rtUniform.clamping > 0.0) {
 let clamping = rtUniform.clamping;
-aN = vec4(clamp(aN.rgb, -vec3f(clamping), vec3f(clamping)), aN.a);
+aF = vec4(clamp(aF.rgb, -vec3f(clamping), vec3f(clamping)), aF.a);
 }
-if (!(aN.x < INF && aN.x > -EPS)) {
-aN = vec4f(0.0, 0.0, 0.0, 1.0);
+if (!(aF.x < INF && aF.x > -EPS)) {
+aF = vec4f(0.0, 0.0, 0.0, 1.0);
 }
 
 if (outAux.isShadowCatcher) {
 
 
-let dn = hE(cam);
-let pU = select(0.0, 1.0, dn.a >= 0.01);
-let jo = vec4f(dn.rgb * dn.a, dn.a);
+let dn = hD(cam);
+let pY = select(0.0, 1.0, dn.a >= 0.01);
+let jq = vec4f(dn.rgb * dn.a, dn.a);
 
 
-outShadowCatcher[idx].mask += vec4f(1.0, dn.a, pU, aN.a);
-outShadowCatcher[idx].background += jo;
-outColor[idx] += jo;
-outAlbedo[idx] += vec4f(outAux.albedo, pU);
-hH(idx, dn.rgb, outAux.normal);
+outShadowCatcher[idx].mask += vec4f(1.0, dn.a, pY, aF.a);
+outShadowCatcher[idx].background += jq;
+outColor[idx] += jq;
+outAlbedo[idx] += vec4f(outAux.albedo, pY);
+hG(idx, dn.rgb, outAux.normal);
 
 
-let visibility = 1.0 - aN.a;
-iM(idx, visibility * select(
+let visibility = 1.0 - aF.a;
+iN(idx, visibility * select(
 1.0, dot(dn.rgb, luminance), dn.a >= 0.01
 ));
 }
 else {
-outColor[idx] += aN;
+if (HAS_SHADOW_CATCHER && outAux.isBlank && USE_BACKGROUND && !USE_BACKGROUND_MAP && rtUniform.backgroundColor.a >= 0.99999) {
+
+
+
+
+
+outShadowCatcher[idx].background += aF;
+outShadowCatcher[idx].mask.g += aF.a;
+}
+outColor[idx] += aF;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-hH(idx, aN.rgb, outAux.normal);
-iM(idx, dot(aN.rgb, luminance));
+hG(idx, aF.rgb, outAux.normal);
+iN(idx, dot(aF.rgb, luminance));
 }
 }
 `;