@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -43,50 +43,50 @@ ${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
 ${sampleLightWgsl}
 
 
-var<private> tE: u32 = 0u;
+var<private> tL: u32 = 0u;
 
 
 
-fn jQ() -> u32 {
+fn jX() -> u32 {
 return u32(max(rtUniform.directLightCandidates, 1));
 }
 
 
 
 
-fn ps(wI: u32) -> f32 {
+fn pK(wP: u32) -> f32 {
 
 
 
 
 if (SAMPLING_PATTERN == 2) { _ = rand(); }
-let jW = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let key = aq(aq(jW, bd), rtUniform.sequenceSeed);
-let dimension = aq(cF, wI) ^ 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 tq(fd: f32, scatteringPdf: f32) -> f32 {
-let aW = jQ();
-if (aW <= 1u) {
-return aG(fd, scatteringPdf);
+fn tC(fg: f32, scatteringPdf: f32) -> f32 {
+let aV = jX();
+if (aV <= 1u) {
+return aG(fg, scatteringPdf);
 }
-let iF = f32(aW) * fd;
-return iF /
-max(iF + scatteringPdf, 1e-20);
+let iJ = f32(aV) * fg;
+return iJ /
+max(iJ + scatteringPdf, 1e-20);
 }
 
 
-fn fS(scatteringPdf: f32, fd: f32) -> f32 {
-let aW = jQ();
-if (aW <= 1u) {
-return aG(scatteringPdf, fd);
+fn fX(scatteringPdf: f32, fg: f32) -> f32 {
+let aV = jX();
+if (aV <= 1u) {
+return aG(scatteringPdf, fg);
 }
-let iF = f32(aW) * fd;
+let iJ = f32(aV) * fg;
 return scatteringPdf /
-max(scatteringPdf + iF, 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 hG(
-ha: u32,
-vp: vec3f,
+fn hK(
+hg: u32,
+vy: vec3f,
 normal: vec3f
 ) {
 if (rtUniform.varianceMoments != 0) {
-let value = dot(vp, luminance);
-outNormal[ha] += vec4f(value * value, 0.0, 0.0, 1.0);
+let value = dot(vy, luminance);
+outNormal[hg] += vec4f(value * value, 0.0, 0.0, 1.0);
 }
 else {
-outNormal[ha] += vec4f(normal, 1.0);
+outNormal[hg] += vec4f(normal, 1.0);
 }
 }
 
 
 
-fn iN(ha: u32, value: f32) {
-outShadowCatcher[ha].moments += vec4f(value, value * value, 0.0, 0.0);
+fn iS(hg: u32, value: f32) {
+outShadowCatcher[hg].moments += vec4f(value, value * value, 0.0, 0.0);
 }
 
 
@@ -130,30 +130,30 @@ normal: vec3f,
 isBlank: bool,
 }
 
-fn dq(sF: vec3f, height: f32, radius: f32) -> f32 {
-let fN = length(sF);
-if (fN < 0.00001) {
+fn dq(sN: vec3f, height: f32, radius: f32) -> f32 {
+let fR = length(sN);
+if (fR < 0.00001) {
 return -radius;
 }
 
-let iC = radius * sF.y / fN;
-let ij = -1.5 * height;
+let iG = radius * sN.y / fR;
+let iq = -1.5 * height;
 var ev: f32;
-if (iC >= 0.0) {
+if (iG >= 0.0) {
 ev = radius;
 }
-else if (iC < ij) {
-ev = -height * fN / sF.y;
+else if (iG < iq) {
+ev = -height * fR / sN.y;
 }
 else {
 let dW = 1.0
-- iC * iC / (3.0 * ij * ij);
+- iG * iG / (3.0 * iq * iq);
 ev = radius * dW;
 }
-return fN - ev;
+return fR - 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 cC = -eI + sqrt(ej);
+var cC = -eJ + sqrt(ej);
 if (cC <= 0.0) {
 return direction;
 }
 
-let nE = bB + bY * cC;
-if (nE.y >= 0.0) {
-return normalize(nE);
+let nO = bB + bY * cC;
+if (nO.y >= 0.0) {
+return normalize(nO);
 }
 
 if (bY.y < -0.00001 && params.y > 1.5 * params.x) {
-let hP = (-params.x - bB.y) / bY.y;
-let nq = bB + bY * hP;
-let oc = (2.0 / 3.0)
+let hT = (-params.x - bB.y) / bY.y;
+let nE = bB + bY * hT;
+let om = (2.0 / 3.0)
 * sqrt(params.y * params.y - 2.25 * params.x * params.x);
-if (hP > 0.0 && length(nq.xz) <= oc) {
-return normalize(nq);
+if (hT > 0.0 && length(nE.xz) <= om) {
+return normalize(nE);
 }
 }
 
 var cN = 0.0;
 for (var i = 0; i < 14; i++) {
-let fe = (cN + cC) * 0.5;
-let pt = bB + bY * fe;
-if (dq(pt, params.x, params.y) > 0.0) {
-cC = 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 + cC) * 0.5);
 return normalize(hit);
 }
 
-fn hD(ray: Ray) -> vec4f {
+fn hH(ray: Ray) -> vec4f {
 var bg = vec4f(0.0);
 if (USE_BACKGROUND_MAP) {
-let pT = eQ(ray.o, ray.d);
-bg = textureLinear(backgroundMap, aS(pT));
+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 = hD(ray);
+let bg = hH(ray);
 if (SPECTRAL) {
 return vec4f(ai(bg.rgb, wavelength), bg.a);
 }
@@ -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(fX((*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 tJ = aS((*aa).ray.d);
-var emission = textureLinear(envMap, tJ).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(tJ));
+fX((*aa).scatteringPdf, iB(tQ));
 }
 }
 else {
@@ -297,10 +300,10 @@ if ((*aa).fromEye) {
 (USE_BACKGROUND && !USE_BACKGROUND_MAP);
 }
 else {
-let cam = hy(uv);
-let mC = dot(cam.d, (*aa).ray.d) > 0.0;
+let cam = hC(uv);
+let mL = dot(cam.d, (*aa).ray.d) > 0.0;
 if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
-if (mC) {
+if (mL) {
 (*aa).alpha = max((*aa).alpha, bg.a);
 } else {
 (*aa).alpha = 1.0;
@@ -309,11 +312,11 @@ if (mC) {
 if (!USE_ENVMAP) {
 
 
-if (mC) {
+if (mL) {
 
 
 (*aa).li += (*aa).beta *
-fS((*aa).scatteringPdf, 1.0) * bg.rgb;
+fX((*aa).scatteringPdf, 1.0) * bg.rgb;
 }
 }
 }
@@ -335,12 +338,12 @@ cH = true;
 if (!cH && rtUniform.transmissiveOutputAlphaMin < 1.0) {
 
 
-let tP = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
-(*aa).alpha = max(tP, (*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 (!cH) {
-tE = u32(max(*depth, 0));
-lR(si, ma, aa);
+tL = u32(max(*depth, 0));
+mb(si, ma, aa);
 }
 else {
 
@@ -375,10 +378,10 @@ if (*depth > 4) {
 
 if (USE_RR) {
 if (*depth >= RR_MAX && !cH) {
-let oz = (*aa).beta;
+let oH = (*aa).beta;
 
-let oo = max(max(oz.x, oz.y), oz.z);
-let q: f32 = max(0.0, 1.0 - oo);
+let oy = max(max(oH.x, oH.y), oH.z);
+let q: f32 = max(0.0, 1.0 - oy);
 if (dz(cw(RUSSIAN_ROULETTE)) < q) {
 
 
@@ -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,
@@ -415,26 +418,26 @@ 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 = mo((*aa).ray, light, &lightSample);
+let d = my((*aa).ray, light, &lightSample);
 lightSample.pdf *= light.selectionPmf;
-let mt = (*si).hit && d > distance((*si).position, (*aa).ray.o);
-if (d != INF && !(mt && hu)) {
-let eW = fS((*aa).scatteringPdf, lightSample.pdf);
+let mC = (*si).hit && d > distance((*si).position, (*aa).ray.o);
+if (d != INF && !(mC && hy)) {
+let fa = fX((*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(fX((*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 = fX(
 (*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,40 +475,40 @@ if (!USE_BACKGROUND) {
 *depth = *depth + 1;
 }
 
-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);
+fn hC(fH: vec2f) -> Ray {
+let origin = cameraUniform.viewProjectionInv * vec4f(fH * 2.0 - 1.0, -1.0, 1.0);
+let center = cameraUniform.viewProjectionInv * vec4f(fH * 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 kp(radius: f32, xi: f32) -> vec2f {
+fn kz(radius: f32, xi: f32) -> vec2f {
 var x = 0.25;
-for (var ns = 0; ns < 10; ns++) {
+for (var nG = 0; nG < 10; nG++) {
 let x2 = x * x;
 let x3 = x2 * x;
-let kG = 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 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 mj = 20.0 * x * kP * kP * kP;
+if (abs(value) < 1e-6 || mj == 0.0) { break; }
+x = clamp(x - value / mj, 0.0, 1.0);
 }
-let jj = x * radius;
-return vec2f(jj, sqrt(max(radius * radius - jj * jj, 0.0)));
+let jo = x * radius;
+return vec2f(jo, sqrt(max(radius * radius - jo * jo, 0.0)));
 }
 
-fn iO(radius: f32, gs: f32) -> f32 {
-if (gs >= radius) { return 0.0; }
-let nV = radius - gs;
-return nV * nV * nV;
+fn iT(radius: f32, gx: f32) -> f32 {
+if (gx >= radius) { return 0.0; }
+let og = radius - gx;
+return og * og * og;
 }
 
 
-fn mi(source: ad, radius: f32) -> vec3f {
+fn mt(source: ad, radius: f32) -> vec3f {
 var geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) {
 geometricNormal = -geometricNormal;
@@ -513,73 +516,73 @@ geometricNormal = -geometricNormal;
 var tangent: vec3f;
 var bitangent: vec3f;
 aL(geometricNormal, &tangent, &bitangent);
-var iB = vec3f(0.0);
-
-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 iF = vec3f(0.0);
+
+for (var ig = 0; ig < BEVEL_SAMPLES; ig++) {
+let ph = fp(CAMERA_BEVEL_BASE + u32(ig));
+var cA = ph.x;
+let oF = ph.y;
+var dj = geometricNormal;
+var fI = tangent;
 var ek = bitangent;
-var ga = 0.5;
-var hU = 0.25;
-var gA = 0.25;
+var gf = 0.5;
+var hY = 0.25;
+var gH = 0.25;
 if (cA < 0.5) {
 cA *= 2.0;
 }
 else if (cA < 0.75) {
-let mA = di;
-di = fE;
-fE = mA;
-ga = 0.25;
-hU = 0.5;
+let mJ = dj;
+dj = fI;
+fI = mJ;
+gf = 0.25;
+hY = 0.5;
 cA = (cA - 0.5) * 4.0;
 }
 else {
-let mA = di;
-di = ek;
-ek = mA;
-ga = 0.25;
-gA = 0.5;
+let mJ = dj;
+dj = ek;
+ek = mJ;
+gf = 0.25;
+gH = 0.5;
 cA = (cA - 0.75) * 4.0;
 }
 
-let gQ = kp(radius, ox);
+let gV = kz(radius, oF);
 let phi = TWOPI * cA;
-let qn = gQ.x *
-(cos(phi) * fE + sin(phi) * ek);
+let qv = gV.x *
+(cos(phi) * fI + sin(phi) * ek);
 var ray: Ray;
-iw(
+iC(
 &ray,
-source.position + di * gQ.y + qn,
--di
+source.position + dj * gV.y + qv,
+-dj
 );
 var hit: ad;
-iH(
+iM(
 ray,
 &hit,
 source.instanceIndex,
-max(2.0 * gQ.y, EPS)
+max(2.0 * gV.y, EPS)
 );
 if (!hit.hit) { continue; }
 
-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,
+let kQ = gf * abs(dot(dj, hit.faceNormal));
+let mF = hY * abs(dot(fI, hit.faceNormal));
+let kb = gH * abs(dot(ek, hit.faceNormal));
+var weight = kQ / max(
+kQ * kQ + mF * mF +
+kb * kb,
 1e-8
 );
-weight *= iO(radius, distance(hit.position, source.position)) /
-max(iO(radius, gQ.x), 1e-8);
-iB += weight * hit.vertexNormal;
+weight *= iT(radius, distance(hit.position, source.position)) /
+max(iT(radius, gV.x), 1e-8);
+iF += weight * hit.vertexNormal;
 }
 
-if (dot(iB, iB) <= 1e-12) { return source.normal; }
-let jC = normalize(iB);
-let result = source.normal + jC - 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 rB = (*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 (rB && 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 nN = ray;
-nN.o = (*si).position + ray.d * (EPS * 0.02);
-var dU = *si;
-dU.albedoSampled = false;
-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,
+var nX = ray;
+nX.o = (*si).position + ray.d * (EPS * 0.02);
+var dE = *si;
+dE.albedoSampled = false;
+cZ(nX, &dE, 0, false, false);
+var rr: J;
+eX(&rr, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
+var gn = *outAux;
+if (dE.hit && rr.materialType == STANDARD) {
+gn.albedo = select(
+rr.baseColor,
 vec3f(1.0),
-rj.transmissionWeight > 0.5
+rr.transmissionWeight > 0.5
 );
-gh.normal = select(
-dU.normal,
--dU.normal,
+gn.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 = rj.transmissionWeight > 0.5;
+dE.albedoSampled = rr.transmissionWeight > 0.5;
 }
 let back = bw(
-uv, &dU, nN, &rj, &gh
+uv, &dE, nX, &rr, &gn
 );
 if (coverage <= 0.0) {
-*outAux = gh;
+*outAux = gn;
 return back;
 }
 
-var tk = *si;
-var uB = *ma;
-uB.alpha = 1.0;
-var iR = *outAux;
-let qQ = bw(
-uv, &tk, ray, &uB, &iR
+var tu = *si;
+var uI = *ma;
+uI.alpha = 1.0;
+var iW = *outAux;
+let qY = bw(
+uv, &tu, ray, &uI, &iW
 );
-(*outAux).albedo = mix(gh.albedo, iR.albedo, coverage);
-let fR = mix(gh.normal, iR.normal, coverage);
+(*outAux).albedo = mix(gn.albedo, iW.albedo, coverage);
+let fW = mix(gn.normal, iW.normal, coverage);
 (*outAux).normal = select(
 vec3f(0.0),
-normalize(fR),
-dot(fR, fR) > 1e-12
+normalize(fW),
+dot(fW, fW) > 1e-12
 );
-(*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);`}
+(*outAux).isBlank = gn.isBlank && iW.isBlank;
+(*outAux).isShadowCatcher = gn.isShadowCatcher && iW.isShadowCatcher;
+return mix(back, qY, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
 }
 
 
 
-fn mn(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+fn mx(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
 var si: ad;
 var ma: J;
 si.albedoSampled = false;
@@ -687,8 +690,8 @@ 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 (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 = mi(si, ma.bevel);
+si.normal = mt(si, ma.bevel);
 }
 }
 
@@ -734,40 +737,40 @@ if (SPECTRAL) {
 
 
 
-let sI = array<f32, 3>(650.0, 510.0, 475.0);
-var tH = vec3f(0.0);
+let sQ = array<f32, 3>(650.0, 510.0, 475.0);
+var tO = vec3f(0.0);
 var alpha = 0.0;
-var jz = vec3f(0.0);
-var jA = vec3f(0.0);
-var rX = true;
+var jE = vec3f(0.0);
+var jF = vec3f(0.0);
+var sf = true;
 var si2 = si;
 var ma2 = ma;
-let qD = s0;
-let nJ = em;
+let qL = s0;
+let nT = em;
 let eh = rtUniform.dispersionWavelengths == 1;
-let jH = si.hit &&
+let jM = si.hit &&
 ma.transmissionWeight > 0.001 &&
 ma.transmissionDispersionScale > 0.001;
-let rW = select(3, 1, eh);
-var lF = 0;
-if (eh && jH) {
+let se = select(3, 1, eh);
+var lO = 0;
+if (eh && jM) {
 
 
-lF = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+lO = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
 }
-for (var i = 0; i < rW; i++) {
+for (var i = 0; i < se; i++) {
 
 
 
 if (!eh) {
-s0 = qD;
-em = nJ;
+s0 = qL;
+em = nT;
 cF = 0u;
 }
 si.wavelength = 0.0;
-if (!eh || jH) {
-si.wavelength = sI[select(i, lF, eh)];
-ma.specularIor = eK(
+if (!eh || jM) {
+si.wavelength = sQ[select(i, lO, 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, jH);
+let scale = select(1.0, 3.0, jM);
 return vec4f(res.rgb * scale, res.a);
 }
-tH += res.rgb;
+tO += res.rgb;
 alpha = max(alpha, res.a);
-jz += dD.albedo;
-jA += dD.normal;
-rX = rX && dD.isBlank;
+jE += dD.albedo;
+jF += dD.normal;
+sf = sf && dD.isBlank;
 si = si2;
 ma = ma2;
 }
-(*outAux).albedo = jz / 3.0;
-(*outAux).normal = jA / 3.0;
-(*outAux).isBlank = rX;
-return vec4f(tH, 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 oC(ip: vec2f) -> vec2f {
+fn oK(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 fH = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
+if (fH.x >= u32(outputSize.x) || fH.y >= u32(outputSize.y)) {
 return;
 }
-let idx = fD.x + fD.y * u32(outputSize.x);
+let idx = fH.x + fH.y * u32(outputSize.x);
 
 if (
 rtUniform.adaptiveSampling != 0 &&
 outNormal[idx].a >= textureLoad(
 adaptiveSampleTargets,
-vec2i(fD),
+vec2i(fH),
 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(fH.x), f32(fH.y)) + vec2f(0.5)) / outputSize;
 
-bc = fD;
+bc = fH;
 bd = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
 cF = 0u; em = 0u;
 if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {
-jitter = (fk(CAMERA_PIXEL) - 0.5) / outputSize;
+jitter = (fp(CAMERA_PIXEL) - 0.5) / outputSize;
 }
-ka(fD, i32(bd ^ eg(rtUniform.sequenceSeed)));
-var cam = hy(uv + jitter);
+kh(fH, i32(bd ^ eg(rtUniform.sequenceSeed)));
+var cam = hC(uv + jitter);
 
 if (cameraUniform.apertureRadius > 0.0) {
 
 let eye = cameraUniform.viewInv[3].xyz;
-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);
+let oj = -normalize(cameraUniform.viewInv[2].xyz);
+let qy = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, oj));
+let rK = cameraUniform.apertureRadius * oK(fp(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,7 +873,7 @@ outAux.albedo = vec3f(0.0);
 outAux.normal = vec3f(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
-var aF = mn(uv + jitter, cam, &outAux);
+var aF = mx(uv + jitter, cam, &outAux);
 
 
 
@@ -885,21 +888,21 @@ aF = vec4f(0.0, 0.0, 0.0, 1.0);
 if (outAux.isShadowCatcher) {
 
 
-let dn = hD(cam);
-let pY = select(0.0, 1.0, dn.a >= 0.01);
-let jq = 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, pY, aF.a);
-outShadowCatcher[idx].background += jq;
-outColor[idx] += jq;
-outAlbedo[idx] += vec4f(outAux.albedo, pY);
-hG(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 - aF.a;
-iN(idx, visibility * select(
-1.0, dot(dn.rgb, luminance), dn.a >= 0.01
+iS(idx, visibility * select(
+1.0, dot(aW.rgb, luminance), aW.a >= 0.01
 ));
 }
 else {
@@ -914,8 +917,8 @@ outShadowCatcher[idx].mask.g += aF.a;
 }
 outColor[idx] += aF;
 outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
-hG(idx, aF.rgb, outAux.normal);
-iN(idx, dot(aF.rgb, luminance));
+hK(idx, aF.rgb, outAux.normal);
+iS(idx, dot(aF.rgb, luminance));
 }
 }
 `;