@meimu/mutracer 0.1.2 → 0.1.4

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

@@ -43,50 +43,50 @@ ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}
 
 
-var<private> tw: u32 = 0u;
+var<private> tL: u32 = 0u;
 
 
 
-fn jO() -> u32 {
+fn jX() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn po(wB: u32) -> f32 {
+fn pK(wP: 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, wB) ^ 0xa511e9b3u;
+let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let key = aq(aq(kd, bd), rtUniform.sequenceSeed);
+let dimension = aq(cF, wP) ^ 0xa511e9b3u;
 return f32(eg(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
 }
 
 
 
-fn tk(fd: f32, scatteringPdf: f32) -> f32 {
-let aW = jO();
-if (aW <= 1u) {
-return aF(fd, scatteringPdf);
+fn tC(fg: f32, scatteringPdf: f32) -> f32 {
+let aV = jX();
+if (aV <= 1u) {
+return aG(fg, scatteringPdf);
 }
-let iE = f32(aW) * fd;
-return iE /
-max(iE + scatteringPdf, 1e-20);
+let iJ = f32(aV) * fg;
+return iJ /
+max(iJ + scatteringPdf, 1e-20);
 }
 
 
-fn fS(scatteringPdf: f32, fd: f32) -> f32 {
-let aW = jO();
-if (aW <= 1u) {
-return aF(scatteringPdf, fd);
+fn fW(scatteringPdf: f32, fg: f32) -> f32 {
+let aV = jX();
+if (aV <= 1u) {
+return aG(scatteringPdf, fg);
 }
-let iE = f32(aW) * fd;
+let iJ = f32(aV) * fg;
 return scatteringPdf /
-max(scatteringPdf + iE, 1e-20);
+max(scatteringPdf + iJ, 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,
-vk: vec3f,
+fn hK(
+he: u32,
+vy: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
-let value = dot(vk, luminance);
-outNormal[gZ] += vec4f(value * value, 0.0, 0.0, 1.0);
+let value = dot(vy, luminance);
+outNormal[he] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[gZ] += vec4f(normal, 1.0);
+outNormal[he] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iM(gZ: u32, value: f32) {
-outShadowCatcher[gZ].moments += vec4f(value, value * value, 0.0, 0.0);
+fn iS(he: u32, value: f32) {
+outShadowCatcher[he].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -130,30 +130,30 @@ normal: vec3f,
 isBlank: bool,
 }
 
-fn dq(sA: vec3f, height: f32, radius: f32) -> f32 {
-let fN = length(sA);
-if (fN < 0.00001) {
+fn dq(sN: vec3f, height: f32, radius: f32) -> f32 {
+let fQ = length(sN);
+if (fQ < 0.00001) {
 return -radius;
 }
 
-let iC = radius * sA.y / fN;
-let ik = -1.5 * height;
+let iG = radius * sN.y / fQ;
+let iq = -1.5 * height;
 var ev: f32;
-if (iC >= 0.0) {
+if (iG >= 0.0) {
 ev = radius;
 }
-else if (iC < ik) {
-ev = -height * fN / sA.y;
+else if (iG < iq) {
+ev = -height * fQ / sN.y;
 }
 else {
 let dW = 1.0
-- iC * iC / (3.0 * ik * ik);
+- iG * iG / (3.0 * iq * iq);
 ev = radius * dW;
 }
-return fN - ev;
+return fQ - ev;
 }
 
-fn eQ(origin: vec3f, direction: vec3f) -> vec3f {
+fn eT(origin: vec3f, direction: vec3f) -> vec3f {
 if (!USE_GROUNDED_BACKGROUND) {
 return direction;
 }
@@ -165,8 +165,8 @@ params.z + params.x,
 rtUniform.groundedBackgroundCenter.y
 );
 let bB = origin - center;
-let eI = dot(bB, bY);
-let ej = eI * eI
+let eJ = dot(bB, bY);
+let ej = eJ * eJ
 - dot(bB, bB) + params.y * params.y;
 if (
 ej <= 0.0
@@ -175,58 +175,61 @@ ej <= 0.0
 return direction;
 }
 
-var cB = -eI + sqrt(ej);
-if (cB <= 0.0) {
+var cC = -eJ + sqrt(ej);
+if (cC <= 0.0) {
 return direction;
 }
 
-let nB = bB + bY * cB;
-if (nB.y >= 0.0) {
-return normalize(nB);
+let nP = bB + bY * cC;
+if (nP.y >= 0.0) {
+return normalize(nP);
 }
 
 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 hT = (-params.x - bB.y) / bY.y;
+let nF = bB + bY * hT;
+let oo = (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 (hT > 0.0 && length(nF.xz) <= oo) {
+return normalize(nF);
 }
 }
 
 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 fh = (cN + cC) * 0.5;
+let pL = bB + bY * fh;
+if (dq(pL, params.x, params.y) > 0.0) {
+cC = fh;
 }
 else {
-cN = fe;
+cN = fh;
 }
 }
-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 hH(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 d = eT(ray.o, ray.d);
+let t = rtUniform.backgroundMapTransform;
+let qb = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
+let aW = textureLinear(backgroundMap, eL(qb));
+bg = vec4f(aW.rgb * t.z, aW.a);
 }
 else if (USE_BACKGROUND) {
 bg = rtUniform.backgroundColor;
 }
 else if (USE_ENVMAP) {
-bg = textureLinear(envMap, aS(ray.d));
+bg = textureLinear(envMap, cY(ray.d));
 }
 return bg;
 }
 
 fn cW(ray: Ray, wavelength: f32) -> vec4f {
-let bg = hE(ray);
+let bg = hH(ray);
 if (SPECTRAL) {
 return vec4f(ai(bg.rgb, wavelength), bg.a);
 }
@@ -234,7 +237,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) {
@@ -253,20 +256,20 @@ let bg = cW(
 (*aa).ray,
 (*si).wavelength
 );
-let cT = select(fS((*aa).scatteringPdf,
-iv(aS((*aa).ray.d)) * rtUniform.envLightPmf),
+let cT = select(fW((*aa).scatteringPdf,
+iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
 1.0, (*aa).scatteringIsDelta);
 (*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
 (*aa).alpha = max((*aa).alpha, bg.a);
 }
 else {
-let tE = aS((*aa).ray.d);
-var emission = textureLinear(envMap, tE).rgb;
+let tQ = cY((*aa).ray.d);
+var emission = textureLinear(envMap, tQ).rgb;
 if (SPECTRAL) {
 emission = ai(emission, (*si).wavelength);
 }
 (*aa).li += (*aa).beta * emission *
-fS((*aa).scatteringPdf, iv(tE));
+fW((*aa).scatteringPdf, iB(tQ));
 }
 }
 else {
@@ -297,10 +300,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 = hC(uv);
+let mM = dot(cam.d, (*aa).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (mz) {
+if (mM) {
 (*aa).alpha = max((*aa).alpha, bg.a);
 } else {
 (*aa).alpha = 1.0;
@@ -309,11 +312,11 @@ if (mz) {
 if (!USE_ENVMAP) {
 
 
-if (mz) {
+if (mM) {
 
 
 (*aa).li += (*aa).beta *
-fS((*aa).scatteringPdf, 1.0) * bg.rgb;
+fW((*aa).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
@@ -321,7 +324,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 +332,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 tW = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
+(*aa).alpha = max(tW, (*aa).alpha);
 }
-if (!cG) {
-tw = u32(max(*depth, 0));
-lO(si, ma, aa);
+if (!cH) {
+tL = u32(max(*depth, 0));
+mc(si, ma, aa);
 }
 else {
 
@@ -349,7 +352,7 @@ else {
 }
 }
 
-if (!(*si).albedoSampled && !cG) {
+if (!(*si).albedoSampled && !cH) {
 
 if ((matType == STANDARD || matType == UNLIT)) {
 if (!((*ma).transmissionWeight > 0.5 ||
@@ -374,12 +377,12 @@ if (*depth > 4) {
 
 
 if (USE_RR) {
-if (*depth >= RR_MAX && !cG) {
-let ow = (*aa).beta;
+if (*depth >= RR_MAX && !cH) {
+let oI = (*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 oz = max(max(oI.x, oI.y), oI.z);
+let q: f32 = max(0.0, 1.0 - oz);
+if (dz(cw(RUSSIAN_ROULETTE)) < q) {
 
 
 (*aa).alpha = 1.0;
@@ -394,13 +397,13 @@ if ((*aa).abort) {
 return;
 }
 
-cY((*aa).ray, si, *depth, true, (*aa).isNextRefraction);
-eT(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex);
+cZ((*aa).ray, si, *depth, true, (*aa).isNextRefraction);
+eX(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 
 if (SPECTRAL) {
 
 if ((*ma).transmissionWeight > 0.001) {
-(*ma).specularIor = eK(
+(*ma).specularIor = eN(
 (*si).wavelength,
 (*ma).specularIor,
 (*ma).transmissionDispersionScale,
@@ -409,32 +412,32 @@ if ((*ma).transmissionWeight > 0.001) {
 }
 }
 
-if (cG) {
+if (cH) {
 return;
 }
 
 
 var lightSample: LightSampleRec;
-let hu = eo(3u) < (*ma).alpha;
+let hy = 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 = mz((*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 eW = fS((*aa).scatteringPdf, lightSample.pdf);
+let mD = (*si).hit && d > distance((*si).position, (*aa).ray.o);
+if (d != INF && !(mD && hy)) {
+let fa = fW((*aa).scatteringPdf, lightSample.pdf);
 if (SPECTRAL) {
 lightSample.emission = ai(lightSample.emission, (*si).wavelength);
 }
-(*aa).li += eW * (*aa).beta * lightSample.emission;
+(*aa).li += fa * (*aa).beta * lightSample.emission;
 (*aa).alpha = 1.0;
 (*aa).abort = true;
 }
 }
 
 if (USE_ENVMAP) {
-if (!((*si).hit && hu)) {
+if (!((*si).hit && hy)) {
 if ((*aa).isNextRefraction) {
 
 
@@ -443,19 +446,19 @@ let bg = cW(
 (*aa).ray,
 (*si).wavelength
 );
-let cT = select(fS((*aa).scatteringPdf,
-iv(aS((*aa).ray.d)) * rtUniform.envLightPmf),
+let cT = select(fW((*aa).scatteringPdf,
+iB(cY((*aa).ray.d)) * rtUniform.envLightPmf),
 1.0, (*aa).scatteringIsDelta);
 (*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
 (*aa).alpha = max((*aa).alpha, bg.a);
 (*aa).abort = true;
 return;
 }
-let _uv = aS((*aa).ray.d);
+let _uv = cY((*aa).ray.d);
 var emission = textureLinear(envMap, _uv).rgb;
-let eW = fS(
+let fa = fW(
 (*aa).scatteringPdf,
-iv(_uv) * rtUniform.envLightPmf
+iB(_uv) * rtUniform.envLightPmf
 );
 if (SPECTRAL) {
 emission = ai(emission, (*si).wavelength);
@@ -464,7 +467,7 @@ emission = ai(emission, (*si).wavelength);
 if (!USE_BACKGROUND) {
 (*aa).alpha = 1.0;
 }
-(*aa).li += (*aa).beta * emission * eW;
+(*aa).li += (*aa).beta * emission * fa;
 (*aa).abort = true;
 }
 }
@@ -472,114 +475,114 @@ if (!USE_BACKGROUND) {
 *depth = *depth + 1;
 }
 
-fn hz(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);
+fn hC(fG: vec2f) -> Ray {
+let origin = cameraUniform.viewProjectionInv * vec4f(fG * 2.0 - 1.0, -1.0, 1.0);
+let center = cameraUniform.viewProjectionInv * vec4f(fG * 2.0 - 1.0, 1.0, 1.0);
 var cam: Ray;
-iw(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
+iC(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
 
 return cam;
 }
 
 
-fn kn(radius: f32, xi: f32) -> vec2f {
+fn kz(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var np = 0; np < 10; np++) {
+for (var nH = 0; nH < 10; nH++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let kD = 1.0 - x;
+let kP = 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 mk = 20.0 * x * kP * kP * kP;
+if (abs(value) < 1e-6 || mk == 0.0) { break; }
+x = clamp(x - value / mk, 0.0, 1.0);
 }
-let jh = x * radius;
-return vec2f(jh, sqrt(max(radius * radius - jh * jh, 0.0)));
+let jo = x * radius;
+return vec2f(jo, sqrt(max(radius * radius - jo * jo, 0.0)));
 }
 
-fn iN(radius: f32, gr: f32) -> f32 {
-if (gr >= radius) { return 0.0; }
-let nS = radius - gr;
-return nS * nS * nS;
+fn iT(radius: f32, gw: f32) -> f32 {
+if (gw >= radius) { return 0.0; }
+let oh = radius - gw;
+return oh * oh * oh;
 }
 
 
-fn mf(source: ad, radius: f32) -> vec3f {
+fn mu(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);
-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;
-var di = geometricNormal;
-var fE = tangent;
+aL(geometricNormal, &tangent, &bitangent);
+var iF = vec3f(0.0);
+
+for (var ig = 0; ig < BEVEL_SAMPLES; ig++) {
+let ph = fo(CAMERA_BEVEL_BASE + u32(ig));
+var cA = ph.x;
+let oG = ph.y;
+var dj = geometricNormal;
+var fH = 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;
-di = fE;
-fE = mx;
-fZ = 0.25;
-hV = 0.5;
-cz = (cz - 0.5) * 4.0;
+var ge = 0.5;
+var hY = 0.25;
+var gG = 0.25;
+if (cA < 0.5) {
+cA *= 2.0;
+}
+else if (cA < 0.75) {
+let mK = dj;
+dj = fH;
+fH = mK;
+ge = 0.25;
+hY = 0.5;
+cA = (cA - 0.5) * 4.0;
 }
 else {
-let mx = di;
-di = ek;
-ek = mx;
-fZ = 0.25;
-gy = 0.5;
-cz = (cz - 0.75) * 4.0;
-}
-
-let gO = kn(radius, ou);
-let phi = TWOPI * cz;
-let qj = gO.x *
-(cos(phi) * fE + sin(phi) * ek);
+let mK = dj;
+dj = ek;
+ek = mK;
+ge = 0.25;
+gG = 0.5;
+cA = (cA - 0.75) * 4.0;
+}
+
+let gU = kz(radius, oG);
+let phi = TWOPI * cA;
+let qv = gU.x *
+(cos(phi) * fH + sin(phi) * ek);
 var ray: Ray;
-iw(
+iC(
 &ray,
-source.position + di * gO.y + qj,
--di
+source.position + dj * gU.y + qv,
+-dj
 );
 var hit: ad;
-iG(
+iM(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gO.y, EPS)
+max(2.0 * gU.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 kQ = ge * abs(dot(dj, hit.faceNormal));
+let mG = hY * abs(dot(fH, hit.faceNormal));
+let kb = gG * abs(dot(ek, hit.faceNormal));
+var weight = kQ / max(
+kQ * kQ + mG * mG +
+kb * kb,
 1e-8
 );
-weight *= iN(radius, distance(hit.position, source.position)) /
-max(iN(radius, gO.x), 1e-8);
-iB += weight * hit.vertexNormal;
+weight *= iT(radius, distance(hit.position, source.position)) /
+max(iT(radius, gU.x), 1e-8);
+iF += weight * hit.vertexNormal;
 }
 
-if (dot(iB, iB) <= 1e-12) { return source.normal; }
-let jA = normalize(iB);
-let result = source.normal + jA - source.vertexNormal;
+if (dot(iF, iF) <= 1e-12) { return source.normal; }
+let jH = normalize(iF);
+let result = source.normal + jH - source.vertexNormal;
 if (dot(result, result) > 1e-12) { return normalize(result); }
 return source.normal;
 }
@@ -596,12 +599,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 rJ = (*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 (rJ && idx > bounceLimit) {
 aa.abort = true;
 }
 if (aa.abort) {
@@ -613,7 +616,7 @@ bounce(uv, &aa, &depth, si, ma, outAux);
 return vec4f(aa.li, aa.alpha);
 }
 
-fn iz(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn iD(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 ${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);
 if (!(*si).hit || ((*ma).materialType != STANDARD && (*ma).materialType != UNLIT) || coverage >= 1.0) {
 return bw(uv, si, ray, ma, outAux);
@@ -623,60 +626,60 @@ return bw(uv, si, ray, ma, outAux);
 
 
 
-var nK = ray;
-nK.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,
+var nY = ray;
+nY.o = (*si).position + ray.d * (EPS * 0.02);
+var dE = *si;
+dE.albedoSampled = false;
+cZ(nY, &dE, 0, false, false);
+var rr: J;
+eX(&rr, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
+var gm = *outAux;
+if (dE.hit && rr.materialType == STANDARD) {
+gm.albedo = select(
+rr.baseColor,
 vec3f(1.0),
-rd.transmissionWeight > 0.5
+rr.transmissionWeight > 0.5
 );
-gg.normal = select(
-dU.normal,
--dU.normal,
+gm.normal = select(
+dE.normal,
+-dE.normal,
 dot(
-dU.normal,
-dU.position - cameraUniform.viewInv[3].xyz
+dE.normal,
+dE.position - cameraUniform.viewInv[3].xyz
 ) > 0.0
 );
-dU.albedoSampled = rd.transmissionWeight > 0.5;
+dE.albedoSampled = rr.transmissionWeight > 0.5;
 }
 let back = bw(
-uv, &dU, nK, &rd, &gg
+uv, &dE, nY, &rr, &gm
 );
 if (coverage <= 0.0) {
-*outAux = gg;
+*outAux = gm;
 return back;
 }
 
-var te = *si;
-var uw = *ma;
-uw.alpha = 1.0;
-var iQ = *outAux;
-let qL = bw(
-uv, &te, ray, &uw, &iQ
+var tu = *si;
+var uI = *ma;
+uI.alpha = 1.0;
+var iW = *outAux;
+let qY = bw(
+uv, &tu, ray, &uI, &iW
 );
-(*outAux).albedo = mix(gg.albedo, iQ.albedo, coverage);
-let fR = mix(gg.normal, iQ.normal, coverage);
+(*outAux).albedo = mix(gm.albedo, iW.albedo, coverage);
+let fV = mix(gm.normal, iW.normal, coverage);
 (*outAux).normal = select(
 vec3f(0.0),
-normalize(fR),
-dot(fR, fR) > 1e-12
+normalize(fV),
+dot(fV, fV) > 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 = gm.isBlank && iW.isBlank;
+(*outAux).isShadowCatcher = gm.isShadowCatcher && iW.isShadowCatcher;
+return mix(back, qY, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
 }
 
 
 
-fn mj(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn my(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 var si: ad;
 var ma: J;
 si.albedoSampled = false;
@@ -687,10 +690,10 @@ si.mediumAnisotropy = 0.0;
 si.barycentrics = vec2f(0.0);
 
 
-cY(ray, &si, 0, false, false);
-eT(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+cZ(ray, &si, 0, false, false);
+eX(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 
-if (ma.materialType == SHADOW_CATCHER) {
+if (si.hit && ma.materialType == SHADOW_CATCHER) {
 (*outAux).isShadowCatcher = true;
 
 
@@ -708,7 +711,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 = mu(si, ma.bevel);
 }
 }
 
@@ -734,40 +737,40 @@ if (SPECTRAL) {
 
 
 
-let sD = array<f32, 3>(650.0, 510.0, 475.0);
-var tC = vec3f(0.0);
+let sQ = array<f32, 3>(650.0, 510.0, 475.0);
+var tO = vec3f(0.0);
 var alpha = 0.0;
-var jw = vec3f(0.0);
-var jx = vec3f(0.0);
-var rS = true;
+var jE = vec3f(0.0);
+var jF = vec3f(0.0);
+var sf = true;
 var si2 = si;
 var ma2 = ma;
-let qz = s0;
-let nG = em;
+let qL = s0;
+let nU = em;
 let eh = rtUniform.dispersionWavelengths == 1;
-let jF = si.hit &&
+let jM = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let rR = select(3, 1, eh);
-var lC = 0;
-if (eh && jF) {
+let se = select(3, 1, eh);
+var lP = 0;
+if (eh && jM) {
 
 
-lC = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+lP = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
 }
-for (var i = 0; i < rR; i++) {
+for (var i = 0; i < se; i++) {
 
 
 
 if (!eh) {
-s0 = qz;
-em = nG;
-cE = 0u;
+s0 = qL;
+em = nU;
+cF = 0u;
 }
 si.wavelength = 0.0;
-if (!eh || jF) {
-si.wavelength = sD[select(i, lC, eh)];
-ma.specularIor = eK(
+if (!eh || jM) {
+si.wavelength = sQ[select(i, lP, eh)];
+ma.specularIor = eN(
 si.wavelength,
 ma.specularIor,
 ma.transmissionDispersionScale,
@@ -783,32 +786,32 @@ dD.normal = (*outAux).normal;
 dD.isBlank = false;
 dD.isShadowCatcher = false;
 }
-let res = iz(uv, &si, ray, &ma, &dD);
+let res = iD(uv, &si, ray, &ma, &dD);
 if (eh) {
 *outAux = dD;
-let scale = select(1.0, 3.0, jF);
+let scale = select(1.0, 3.0, jM);
 return vec4f(res.rgb * scale, res.a);
 }
-tC += res.rgb;
+tO += res.rgb;
 alpha = max(alpha, res.a);
-jw += dD.albedo;
-jx += dD.normal;
-rS = rS && dD.isBlank;
+jE += dD.albedo;
+jF += dD.normal;
+sf = sf && 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 = jE / 3.0;
+(*outAux).normal = jF / 3.0;
+(*outAux).isBlank = sf;
+return vec4f(tO, alpha);
 }
 else {
-return iz(uv, &si, ray, &ma, outAux);
+return iD(uv, &si, ray, &ma, outAux);
 }
 }
 }
 
-fn oz(ip: vec2f) -> vec2f {
+fn oL(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);
@@ -823,17 +826,17 @@ let outputSize = rtUniform.outputSize;
 let scaleOffset = rtUniform.scaleOffset;
 var jitter = rtUniform.jitter;
 
-let fD = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
-if (fD.x >= u32(outputSize.x) || fD.y >= u32(outputSize.y)) {
+let fG = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
+if (fG.x >= u32(outputSize.x) || fG.y >= u32(outputSize.y)) {
 return;
 }
-let idx = fD.x + fD.y * u32(outputSize.x);
+let idx = fG.x + fG.y * u32(outputSize.x);
 
 if (
 rtUniform.adaptiveSampling != 0 &&
 outNormal[idx].a >= textureLoad(
 adaptiveSampleTargets,
-vec2i(fD),
+vec2i(fG),
 0
 ).r
 ) {
@@ -843,26 +846,26 @@ return;
 
 
 
-let uv = (vec2<f32>(f32(fD.x), f32(fD.y)) + vec2f(0.5)) / outputSize;
+let uv = (vec2<f32>(f32(fG.x), f32(fG.y)) + vec2f(0.5)) / outputSize;
 
-bc = fD;
+bc = fG;
 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;
+jitter = (fo(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-jY(fD, i32(bd ^ eg(rtUniform.sequenceSeed)));
-var cam = hz(uv + jitter);
+kh(fG, i32(bd ^ eg(rtUniform.sequenceSeed)));
+var cam = hC(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);
-iw(&cam, origin, dir);
+let ol = -normalize(cameraUniform.viewInv[2].xyz);
+let qy = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, ol));
+let rK = cameraUniform.apertureRadius * oL(fo(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(rK, 0.0, 1.0)).xyz;
+let dir = normalize(qy - origin);
+iC(&cam, origin, dir);
 }
 
 var outAux: RayTraceAuxiliary;
@@ -870,43 +873,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 = my(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 aW = hH(cam);
+let qg = select(0.0, 1.0, aW.a >= 0.01);
+let jw = vec4f(aW.rgb * aW.a, aW.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, aW.a, qg, aF.a);
+outShadowCatcher[idx].background += jw;
+outColor[idx] += jw;
+outAlbedo[idx] += vec4f(outAux.albedo, qg);
+hK(idx, aW.rgb, outAux.normal);
 
 
-let visibility = 1.0 - aN.a;
-iM(idx, visibility * select(
-1.0, dot(dn.rgb, luminance), dn.a >= 0.01
+let visibility = 1.0 - aF.a;
+iS(idx, visibility * select(
+1.0, dot(aW.rgb, luminance), aW.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));
+hK(idx, aF.rgb, outAux.normal);
+iS(idx, dot(aF.rgb, luminance));
 }
 }
 `;