@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -72,214 +72,214 @@ fn aB(color: vec3f) -> f32 {
 return dot(color, vec3f(0.212671, 0.715160, 0.072169));
 }
 
-fn cO(bq: f32) -> f32 {
-let value = (bq - 1.0) / (bq + 1.0);
+fn cR(br: f32) -> f32 {
+let value = (br - 1.0) / (br + 1.0);
 return value * value;
 }
 
-fn bb(
-bq: f32,
+fn bc(
+br: f32,
 specularWeight: f32
 ) -> f32 {
-let uj = min(
-cO(bq) * specularWeight,
+let vT = min(
+cR(br) * specularWeight,
 0.9999
 );
-let ul = sqrt(uj);
-let lC = (1.0 + ul) / (1.0 - ul);
-return select(lC, 1.0 / lC, bq < 1.0);
+let vV = sqrt(vT);
+let mt = (1.0 + vV) / (1.0 - vV);
+return select(mt, 1.0 / mt, br < 1.0);
 }
 
-fn ae(ct: f32, relativeIor: f32) -> f32 {
+fn ae(cv: f32, relativeIor: f32) -> f32 {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return sampling_dielectric_fresnel(ct, relativeIor);
+return sampling_dielectric_fresnel(cv, relativeIor);
 }
 
-fn aE(ior: f32) -> f32 {
+fn aF(ior: f32) -> f32 {
 if (ior < 1.0) {
 return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;
 }
 return 16.0 + ((ior - 1.0) / 1.5) * 15.0;
 }
 
-fn F(tC: i32, row: i32) -> f32 {
-return textureLoad(openPbrEnergyLut, vec2i(tC, row), 0).r;
+fn F(vc: i32, row: i32) -> f32 {
+return textureLoad(openPbrEnergyLut, vec2i(vc, row), 0).r;
 }
 
-fn gd(
-dH: f32,
+fn gu(
+dJ: f32,
 bM: f32,
-hN: f32
+iv: f32
 ) -> f32 {
-let br = clamp(dH, 0.0, 31.0);
+let bw = clamp(dJ, 0.0, 31.0);
 let aK = clamp(bM, 0.0, 31.0);
-let bp = clamp(hN, 0.0, 31.0);
-let dP = i32(floor(br));
+let bq = clamp(iv, 0.0, 31.0);
+let dV = i32(floor(bw));
 let aP = i32(floor(aK));
-let cD = i32(floor(bp));
-let hB = min(dP + 1, 31);
-let ch = min(aP + 1, 31);
-let eK = min(cD + 1, 31);
-let ci = br - f32(dP);
-let cq = aK - f32(aP);
-let kR = bp - f32(cD);
-
-let wv = F(cD, dP * 32 + aP);
-let ww = F(eK, dP * 32 + aP);
-let wx = F(cD, dP * 32 + ch);
-let wy = F(eK, dP * 32 + ch);
-let wB = F(cD, hB * 32 + aP);
-let wC = F(eK, hB * 32 + aP);
-let wE = F(cD, hB * 32 + ch);
-let wF = F(eK, hB * 32 + ch);
-let v00 = mix(wv, wB, ci);
-let v01 = mix(ww, wC, ci);
-let v10 = mix(wx, wE, ci);
-let v11 = mix(wy, wF, ci);
+let cG = i32(floor(bq));
+let hX = min(dV + 1, 31);
+let ci = min(aP + 1, 31);
+let eU = min(cG + 1, 31);
+let cj = bw - f32(dV);
+let ct = aK - f32(aP);
+let lK = bq - f32(cG);
+
+let ys = F(cG, dV * 32 + aP);
+let yt = F(eU, dV * 32 + aP);
+let yu = F(cG, dV * 32 + ci);
+let yv = F(eU, dV * 32 + ci);
+let yw = F(cG, hX * 32 + aP);
+let yA = F(eU, hX * 32 + aP);
+let yB = F(cG, hX * 32 + ci);
+let yC = F(eU, hX * 32 + ci);
+let v00 = mix(ys, yw, cj);
+let v01 = mix(yt, yA, cj);
+let v10 = mix(yu, yB, cj);
+let v11 = mix(yv, yC, cj);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-kR
+mix(v00, v10, ct),
+mix(v01, v11, ct),
+lK
 );
 }
 
-fn gA(dH: f32, bM: f32) -> f32 {
-let br = clamp(dH, 0.0, 31.0);
+fn gU(dJ: f32, bM: f32) -> f32 {
+let bw = clamp(dJ, 0.0, 31.0);
 let aK = clamp(bM, 0.0, 31.0);
-let dP = i32(floor(br));
+let dV = i32(floor(bw));
 let aP = i32(floor(aK));
-let hB = min(dP + 1, 31);
-let ch = min(aP + 1, 31);
-let ci = br - f32(dP);
-let cq = aK - f32(aP);
-let v00 = F(aP, 1024 + dP);
-let v01 = F(ch, 1024 + dP);
-let v10 = F(aP, 1024 + hB);
-let v11 = F(ch, 1024 + hB);
+let hX = min(dV + 1, 31);
+let ci = min(aP + 1, 31);
+let cj = bw - f32(dV);
+let ct = aK - f32(aP);
+let v00 = F(aP, 1024 + dV);
+let v01 = F(ci, 1024 + dV);
+let v10 = F(aP, 1024 + hX);
+let v11 = F(ci, 1024 + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
 
 
-fn ee(
-dH: f32,
+fn el(
+dJ: f32,
 bM: f32,
-hN: f32
+iv: f32
 ) -> f32 {
-let br = clamp(dH, 0.0, 31.0);
+let bw = clamp(dJ, 0.0, 31.0);
 let aK = clamp(bM, 0.0, 31.0);
-let bp = clamp(hN, 0.0, 31.0);
-let dP = i32(floor(br));
+let bq = clamp(iv, 0.0, 31.0);
+let dV = i32(floor(bw));
 let aP = i32(floor(aK));
-let cD = i32(floor(bp));
-let hB = min(dP + 1, 31);
-let ch = min(aP + 1, 31);
-let eK = min(cD + 1, 31);
-let ci = br - f32(dP);
-let cq = aK - f32(aP);
-let kR = bp - f32(cD);
-
-let wv = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
-let ww = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
-let wx = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
-let wy = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
-let wB = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
-let wC = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
-let wE = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
-let wF = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
-let v00 = mix(wv, wB, ci);
-let v01 = mix(ww, wC, ci);
-let v10 = mix(wx, wE, ci);
-let v11 = mix(wy, wF, ci);
+let cG = i32(floor(bq));
+let hX = min(dV + 1, 31);
+let ci = min(aP + 1, 31);
+let eU = min(cG + 1, 31);
+let cj = bw - f32(dV);
+let ct = aK - f32(aP);
+let lK = bq - f32(cG);
+
+let ys = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + aP);
+let yt = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + aP);
+let yu = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + ci);
+let yv = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + ci);
+let yw = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + aP);
+let yA = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + aP);
+let yB = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + ci);
+let yC = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + ci);
+let v00 = mix(ys, yw, cj);
+let v01 = mix(yt, yA, cj);
+let v10 = mix(yu, yB, cj);
+let v11 = mix(yv, yC, cj);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-kR
+mix(v00, v10, ct),
+mix(v01, v11, ct),
+lK
 );
 }
 
-fn ec(dH: f32, bM: f32) -> f32 {
-let br = clamp(dH, 0.0, 31.0);
+fn ek(dJ: f32, bM: f32) -> f32 {
+let bw = clamp(dJ, 0.0, 31.0);
 let aK = clamp(bM, 0.0, 31.0);
-let dP = i32(floor(br));
+let dV = i32(floor(bw));
 let aP = i32(floor(aK));
-let hB = min(dP + 1, 31);
-let ch = min(aP + 1, 31);
-let ci = br - f32(dP);
-let cq = aK - f32(aP);
-let v00 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-let v01 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-let v10 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
-let v11 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+let hX = min(dV + 1, 31);
+let ci = min(aP + 1, 31);
+let cj = bw - f32(dV);
+let ct = aK - f32(aP);
+let v00 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dV);
+let v01 = F(ci, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dV);
+let v10 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hX);
+let v11 = F(ci, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
-fn eC(dH: f32, bM: f32) -> f32 {
-let br = clamp(dH, 0.0, 31.0);
+fn eL(dJ: f32, bM: f32) -> f32 {
+let bw = clamp(dJ, 0.0, 31.0);
 let aK = clamp(bM, 0.0, 31.0);
-let dP = i32(floor(br));
+let dV = i32(floor(bw));
 let aP = i32(floor(aK));
-let hB = min(dP + 1, 31);
-let ch = min(aP + 1, 31);
-let ci = br - f32(dP);
-let cq = aK - f32(aP);
-let v00 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-let v01 = F(ch, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-let v10 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
-let v11 = F(ch, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+let hX = min(dV + 1, 31);
+let ci = min(aP + 1, 31);
+let cj = bw - f32(dV);
+let ct = aK - f32(aP);
+let v00 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dV);
+let v01 = F(ci, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dV);
+let v10 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hX);
+let v11 = F(ci, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
 fn aV(ior: f32, alpha: f32, cosine: f32) -> f32 {
-return ee(aE(ior), sqrt(alpha) * 31.0, cosine * 31.0);
+return el(aF(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-fn aY(ior: f32, alpha: f32) -> f32 {
-return ec(aE(ior), sqrt(alpha) * 31.0);
+fn aZ(ior: f32, alpha: f32) -> f32 {
+return ek(aF(ior), sqrt(alpha) * 31.0);
 }
-fn bU(ior: f32, alpha: f32) -> f32 {
-return eC(aE(ior), sqrt(alpha) * 31.0);
+fn bW(ior: f32, alpha: f32) -> f32 {
+return eL(aF(ior), sqrt(alpha) * 31.0);
 }
 
 
 
 fn aR(alpha: f32, cosine: f32) -> f32 {
-let ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
-let bp = clamp(cosine * 31.0, 0.0, 31.0);
-let r0 = i32(floor(ie));
-let c0 = i32(floor(bp));
+let iL = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+let bq = clamp(cosine * 31.0, 0.0, 31.0);
+let r0 = i32(floor(iL));
+let c0 = i32(floor(bq));
 let r1 = min(r0 + 1, 31);
 let c1 = min(c0 + 1, 31);
 return mix(
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(bp)),
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bp)),
-fract(ie));
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(bq)),
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bq)),
+fract(iL));
 }
 
-fn cl(alpha: f32) -> f32 {
+fn cn(alpha: f32) -> f32 {
 let index = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
 let i0 = i32(floor(index));
 return mix(F(i0, ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}),
 F(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));
 }
 
-fn aX(value: f32, ior: f32) -> f32 {
+fn aY(value: f32, ior: f32) -> f32 {
 if ((ior > 2.5) | (ior < 0.4)) {
-let vH = cO(2.5);
-let progress = (cO(ior) - vH) / (1.0 - vH);
+let xv = cR(2.5);
+let progress = (cR(ior) - xv) / (1.0 - xv);
 return (1.0 - progress) * value;
 }
 return value;
@@ -290,20 +290,20 @@ ior: f32,
 alpha: f32,
 cosine: f32
 ) -> f32 {
-let value = gd(
-aE(ior),
+let value = gu(
+aF(ior),
 sqrt(alpha) * 31.0,
 cosine * 31.0
 );
-return aX(value, ior);
+return aY(value, ior);
 }
 
-fn cj(ior: f32, alpha: f32) -> f32 {
-let value = gA(
-aE(ior),
+fn ck(ior: f32, alpha: f32) -> f32 {
+let value = gU(
+aF(ior),
 sqrt(alpha) * 31.0
 );
-return aX(value, ior);
+return aY(value, ior);
 }
 
 fn openpbr_to_world(basis: OpenPbrBasis, direction: vec3f) -> vec3f {
@@ -320,14 +320,14 @@ dot(direction, basis.normal)
 );
 }
 
-fn ff(
-aS: vec3f,
+fn ft(
+aT: vec3f,
 normal: vec3f,
 anisotropy: f32
 ) -> OpenPbrBasis {
 var basis: OpenPbrBasis;
 basis.normal = normal;
-var tangent = aS;
+var tangent = aT;
 var bitangent = vec3f(0.0);
 if ((dot(tangent, tangent) < 0.001) | (anisotropy <= 0.0)) {
 sampling_orthonormal_basis(normal, &tangent, &bitangent);
@@ -341,7 +341,7 @@ basis.bitangent = bitangent;
 return basis;
 }
 
-fn ki(
+fn kP(
 av: f32,
 ai: f32,
 J: f32,
@@ -351,7 +351,7 @@ return (av * J - ai * ad)
 / (av * J + ai * ad);
 }
 
-fn kh(
+fn kO(
 av: f32,
 ai: f32,
 J: f32,
@@ -361,7 +361,7 @@ return (ai * J - av * ad)
 / (av * ad + ai * J);
 }
 
-fn gZ(
+fn hx(
 av: f32,
 ai: f32,
 J: f32,
@@ -371,7 +371,7 @@ return 2.0 * av * J
 / (av * J + ai * ad);
 }
 
-fn gY(
+fn hw(
 av: f32,
 ai: f32,
 J: f32,
@@ -381,11 +381,11 @@ return 2.0 * av * J
 / (av * ad + ai * J);
 }
 
-fn aT(a: vec2f, b: vec2f) -> vec2f {
+fn aU(a: vec2f, b: vec2f) -> vec2f {
 return vec2f(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
-fn bc(a: vec2f, b: vec2f) -> vec2f {
+fn bd(a: vec2f, b: vec2f) -> vec2f {
 let ah = max(dot(b, b), 1e-9);
 return vec2f(
 (a.x * b.x + a.y * b.y) / ah,
@@ -393,101 +393,101 @@ return vec2f(
 );
 }
 
-fn hV(value: vec2f) -> vec2f {
-let gz = length(value);
-let ui = sqrt(max(0.0, 0.5 * (gz + value.x)));
-let fc = sqrt(max(0.0, 0.5 * (gz - value.x)));
-return vec2f(ui, select(-fc, fc, value.y >= 0.0));
+fn iG(value: vec2f) -> vec2f {
+let gT = length(value);
+let vS = sqrt(max(0.0, 0.5 * (gT + value.x)));
+let fo = sqrt(max(0.0, 0.5 * (gT - value.x)));
+return vec2f(vS, select(-fo, fo, value.y >= 0.0));
 }
 
-fn bR(
+fn bS(
 J: f32,
 av: f32,
 ai: vec2f,
-rH: bool
+sX: bool
 ) -> vec2f {
-let oV = sqrt(max(0.0, 1.0 - J * J));
-let tR = bc(vec2f(av, 0.0), ai);
-let hx = tR * oV;
-var ad = hV(
-vec2f(1.0, 0.0) - aT(hx, hx)
+let qd = sqrt(max(0.0, 1.0 - J * J));
+let vA = bd(vec2f(av, 0.0), ai);
+let hR = vA * qd;
+var ad = iG(
+vec2f(1.0, 0.0) - aU(hR, hR)
 );
-if (aT(ai, ad).y < 0.0) {
+if (aU(ai, ad).y < 0.0) {
 ad = -ad;
 }
 
-let fL = vec2f(av * J, 0.0);
-let eu = aT(ai, ad);
-if (rH) {
-let bW = ai * J;
-let bT = ad * av;
-return bc(
-bW - bT,
-bW + bT
+let fX = vec2f(av * J, 0.0);
+let eC = aU(ai, ad);
+if (sX) {
+let bY = ai * J;
+let bV = ad * av;
+return bd(
+bY - bV,
+bY + bV
 );
 }
-return bc(
-fL - eu,
-fL + eu
+return bd(
+fX - eC,
+fX + eC
 );
 }
 
-fn em(
-iI: f32,
-gJ: f32,
-pk: f32,
-nA: f32,
-ko: vec2f,
+fn ev(
+jh: f32,
+hb: f32,
+qu: f32,
+ov: f32,
+kV: vec2f,
 phase: f32
 ) -> f32 {
-let nZ = vec2f(cos(phase), sin(phase));
-let hY = aT(ko, nZ);
-let iF = hY * (gJ * nA);
-let ah = vec2f(1.0, 0.0) - hY * pk;
-let hw = vec2f(iI, 0.0)
-+ bc(iF, ah);
-return dot(hw, hw);
+let oY = vec2f(cos(phase), sin(phase));
+let iJ = aU(kV, oY);
+let je = iJ * (hb * ov);
+let ah = vec2f(1.0, 0.0) - iJ * qu;
+let hQ = vec2f(jh, 0.0)
++ bd(je, ah);
+return dot(hQ, hQ);
 }
 
 fn ap(
 J: f32,
 wavelength: f32,
-cf: f32,
+ch: f32,
 aN: f32,
-bY: f32,
-ep: vec2f
+ca: f32,
+ey: vec2f
 ) -> f32 {
-let dd = clamp(abs(J), 1e-5, 1.0);
-let hp = pow(aN / bY, 2.0)
-* (1.0 - dd * dd);
-if (hp >= 1.0) {
+let dg = clamp(abs(J), 1e-5, 1.0);
+let hJ = pow(aN / ca, 2.0)
+* (1.0 - dg * dg);
+if (hJ >= 1.0) {
 return 1.0;
 }
-let cN = sqrt(1.0 - hp);
-let lq = ki(
-aN, bY, dd, cN
+let cQ = sqrt(1.0 - hJ);
+let ml = kP(
+aN, ca, dg, cQ
 );
-let lp = kh(
-aN, bY, dd, cN
+let mk = kO(
+aN, ca, dg, cQ
 );
-let jm = gZ(
-aN, bY, dd, cN
+let jQ = hx(
+aN, ca, dg, cQ
 );
-let jl = gY(
-aN, bY, dd, cN
+let jP = hw(
+aN, ca, dg, cQ
 );
-let gp = bY * cN
-/ max(aN * dd, 1e-9);
-let phase = 2.0 * PI * (2.0 * bY * cf * cN) / wavelength;
+let gI = ca * cQ
+/ max(aN * dg, 1e-9);
+let phase = 2.0 * PI * (2.0 * ca * ch * cQ) / wavelength;
 var reflectance = 0.0;
 
-for (var kn = 0u; kn < (rtUniform.loopUnrollGuard >> 1u); kn++) {
-let iI = select(lq, lp, kn == 1u);
-let gJ = select(jm, jl, kn == 1u);
-let ko = bR(
-cN, bY, ep, kn == 1u);
-reflectance += em(iI, gJ,
--iI, gJ * gp, ko, phase);
+for (var kU = 0u; kU < (rtUniform.loopUnrollGuard >> 1u); kU++) {
+let jh = select(ml, mk, kU == 1u);
+let hb = select(jQ, jP, kU == 1u);
+let kV = bS(
+cQ, ca, ey, kU == 1u);
+reflectance += ev(jh, hb,
+-jh, hb * gI, kV, phase);
 }
 return clamp(0.5 * reflectance, 0.0, 1.0);
 }
@@ -496,43 +496,43 @@ return clamp(0.5 * reflectance, 0.0, 1.0);
 
 
 fn openpbr_metal_fresnel(cosine: f32, f0: vec3f, tint: vec3f) -> vec3f {
-let sl = mix(f0, vec3f(1.0), aH(cosine));
-if (all(tint == vec3f(1.0))) { return sl; }
-let da = 1.0 / 7.0;
-let mK = 1.0 - da;
-let fJ = mix(f0, vec3f(1.0), aH(da));
-let cY = 1.0 - cosine;
-let rp = cosine * aH(cosine) * cY
-/ (da * pow(mK, 6.0));
-return clamp(sl - rp * (fJ - tint * fJ), vec3f(0.0), vec3f(1.0));
-}
-
-fn cJ(f0: f32, uS: f32) -> vec2f {
-let dL = clamp(f0, 0.0, 0.99);
-let gI = sqrt(dL);
-let rF = (1.0 - dL) / (1.0 + dL);
-let rC = (1.0 + gI) / max(1.0 - gI, 1e-9);
-let ior = mix(rC, rF, clamp(uS, 0.0, 1.0));
-let jT = (
-(ior + 1.0) * (ior + 1.0) * dL
+let tN = mix(f0, vec3f(1.0), aI(cosine));
+if (all(tint == vec3f(1.0))) { return tN; }
+let dd = 1.0 / 7.0;
+let nM = 1.0 - dd;
+let fV = mix(f0, vec3f(1.0), aI(dd));
+let da = 1.0 - cosine;
+let sG = cosine * aI(cosine) * da
+/ (dd * pow(nM, 6.0));
+return clamp(tN - sG * (fV - tint * fV), vec3f(0.0), vec3f(1.0));
+}
+
+fn cL(f0: f32, wF: f32) -> vec2f {
+let dP = clamp(f0, 0.0, 0.99);
+let ha = sqrt(dP);
+let sU = (1.0 - dP) / (1.0 + dP);
+let sR = (1.0 + ha) / max(1.0 - ha, 1e-9);
+let ior = mix(sR, sU, clamp(wF, 0.0, 1.0));
+let kz = (
+(ior + 1.0) * (ior + 1.0) * dP
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dL, 1e-9);
-return vec2f(ior, sqrt(max(jT, 0.0)));
+) / max(1.0 - dP, 1e-9);
+return vec2f(ior, sqrt(max(kz, 0.0)));
 }
 
 
-fn bJ(cf: f32, weight: f32) -> f32 {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cf);
+fn bJ(ch: f32, weight: f32) -> f32 {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ch);
 }
 
 
 
-fn bw(
+fn bB(
 material: OpenPbrResolvedMaterial,
 color: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-fl: f32,
+fD: f32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -541,26 +541,26 @@ return vec3f(0.0);
 }
 
 let roughness = material.diffuseRoughness;
-let gS = 0.5 - 2.0 / (3.0 * PI);
-let oR = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-let pe = lightLocal.z;
-let nd = viewLocal.z;
-let directional = dot(lightLocal, viewLocal) - pe * nd;
-let gP = select(
+let hp = 0.5 - 2.0 / (3.0 * PI);
+let pZ = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+let qn = lightLocal.z;
+let oc = viewLocal.z;
+let directional = dot(lightLocal, viewLocal) - qn * oc;
+let hl = select(
 directional,
-directional / max(max(pe, nd), 1e-7),
+directional / max(max(qn, oc), 1e-7),
 directional > 0.0
 );
-let il = 1.0 / (1.0 + gS * roughness);
-let oe = color * INVPI * il
-* (1.0 + roughness * gP);
-
-let cW = 1.0 - pe;
-let outputComplement = 1.0 - nd;
-let oW = cW * (
-0.0571085289 + cW * (
-0.491881867 + cW * (
--0.332181442 + cW * 0.0714429953
+let iQ = 1.0 / (1.0 + hp * roughness);
+let pe = color * INVPI * iQ
+* (1.0 + roughness * hl);
+
+let cX = 1.0 - qn;
+let outputComplement = 1.0 - oc;
+let qe = cX * (
+0.0571085289 + cX * (
+0.491881867 + cX * (
+-0.332181442 + cX * 0.0714429953
 )
 )
 );
@@ -571,19 +571,19 @@ let outputGOverPi = outputComplement * (
 )
 )
 );
-let qj = (1.0 + roughness * oW)
-/ (1.0 + gS * roughness);
+let rr = (1.0 + roughness * qe)
+/ (1.0 + hp * roughness);
 let outputAlbedo = (1.0 + roughness * outputGOverPi)
-/ (1.0 + gS * roughness);
-let fU = il * (1.0 + oR * roughness);
-let hC = color * color * fU
-/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fU));
-let lT = hC * INVPI
+/ (1.0 + hp * roughness);
+let gk = iQ * (1.0 + pZ * roughness);
+let hY = color * color * gk
+/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - gk));
+let mN = hY * INVPI
 * max(1e-7, 1.0 - outputAlbedo)
-* max(1e-7, 1.0 - qj)
-/ max(1e-7, 1.0 - fU);
+* max(1e-7, 1.0 - rr)
+/ max(1e-7, 1.0 - gk);
 *pdf = lightLocal.z * INVPI;
-return (oe + lT) * fl;
+return (pe + mN) * fD;
 }
 
 fn aQ(viewCosine: f32, roughness: f32) -> f32 {
@@ -600,7 +600,7 @@ let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-fn kg(
+fn kN(
 material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -633,16 +633,16 @@ return vec3f(0.0);
 
 let alpha = vec2f(material.alphaX, material.alphaY);
 let distribution = sampling_ggx_ndf(aa, alpha);
-let kc = aD(viewLocal, alpha);
-let dY = kc
+let kJ = aD(viewLocal, alpha);
+let eh = kJ
 * aD(lightLocal, alpha);
 
-*pdf = kc * distribution / (4.0 * max(viewLocal.z, 1e-8));
-return fresnel * distribution * dY
+*pdf = kJ * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return fresnel * distribution * eh
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-fn dc(
+fn df(
 material: OpenPbrResolvedMaterial,
 relativeIor: f32,
 tint: vec3f,
@@ -666,29 +666,29 @@ return vec3f(0.0);
 }
 let alpha = vec2f(material.alphaX, material.alphaY);
 let distribution = sampling_ggx_ndf(aa, alpha);
-let kc = aD(viewLocal, alpha);
-let dY = kc
+let kJ = aD(viewLocal, alpha);
+let eh = kJ
 * aD(lightLocal, alpha);
 var ah = lightHalf + viewHalf * relativeIor;
 ah *= ah;
-let qo = abs(lightHalf) / max(ah, 1e-8);
-let jB = relativeIor * relativeIor;
+let rw = abs(lightHalf) / max(ah, 1e-8);
+let ke = relativeIor * relativeIor;
 
-*pdf = kc * max(0.0, viewHalf) * distribution * qo
+*pdf = kJ * max(0.0, viewHalf) * distribution * rw
 / max(viewLocal.z, 1e-8);
-return tint * (vec3f(1.0) - fresnel) * distribution * dY
-* abs(viewHalf) * qo * jB
+return tint * (vec3f(1.0) - fresnel) * distribution * eh
+* abs(viewHalf) * rw * ke
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-fn ba(material: OpenPbrResolvedMaterial) -> vec3f {
+fn bb(material: OpenPbrResolvedMaterial) -> vec3f {
 if (HAS_MEDIUM & (material.mediumType > 0)) {
 return vec3f(1.0);
 }
 return material.transmissionColor;
 }
 
-fn cL(ag: f32) -> f32 {
+fn cN(ag: f32) -> f32 {
 return 2.0 * ag / (1.0 + ag);
 }
 
@@ -696,11 +696,11 @@ fn aq(
 ag: vec3f,
 transmissionWeight: f32
 ) -> vec3f {
-let gk = 2.0 * ag
+let gE = 2.0 * ag
 / (vec3f(1.0) + ag);
 return mix(
 ag,
-gk,
+gE,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
@@ -708,23 +708,23 @@ clamp(transmissionWeight, 0.0, 1.0)
 fn bF(
 material: OpenPbrResolvedMaterial,
 J: f32,
-bq: f32
+br: f32
 ) -> vec3f {
-let tint = ba(material);
+let tint = bb(material);
 if (!material.thinWalled) {
 return tint;
 }
-let iK = max(0.0, 1.0 - J * J);
-let dM = iK
-/ max(bq * bq, 1e-9);
-if (dM >= 1.0) {
+let jk = max(0.0, 1.0 - J * J);
+let dR = jk
+/ max(br * br, 1e-9);
+if (dR >= 1.0) {
 return vec3f(0.0);
 }
-let ad = sqrt(1.0 - dM);
+let ad = sqrt(1.0 - dR);
 return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(ad, 1e-5)));
 }
 
-fn dK(
+fn dO(
 material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -735,31 +735,31 @@ if ((viewLocal.z <= 0.0) | (lightLocal.z >= 0.0)) {
 return vec3f(0.0);
 }
 let ad = -lightLocal.z;
-let oO = sampling_dielectric_fresnel(
+let pW = sampling_dielectric_fresnel(
 viewLocal.z,
 material.relativeIor
 );
 *pdf = ad * INVPI;
-return vec3f(1.0 - oO) * INVPI;
+return vec3f(1.0 - pW) * INVPI;
 }
 
-fn dQ(prepared: ptr<function, OpenPbrPreparedBsdf>) {
+fn dW(prepared: ptr<function, OpenPbrPreparedBsdf>) {
 
 
-let sJ = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+let ui = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
 var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];
-for (var lobe = 1; lobe < sJ; lobe++) {
+for (var lobe = 1; lobe < ui; lobe++) {
 total += (*prepared).probabilities[lobe];
 }
 if (total <= 1e-8) {
-for (var lobe = 0; lobe < sJ; lobe++) {
+for (var lobe = 0; lobe < ui; lobe++) {
 (*prepared).probabilities[lobe] = 0.0;
 }
 return;
 }
-let oZ = 1.0 / total;
-for (var lobe = 0; lobe < sJ; lobe++) {
-(*prepared).probabilities[lobe] *= oZ;
+let qh = 1.0 / total;
+for (var lobe = 0; lobe < ui; lobe++) {
+(*prepared).probabilities[lobe] *= qh;
 }
 }
 
@@ -772,22 +772,22 @@ return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * e
 }
 
 fn bL(f0: vec3f, tint: vec3f) -> vec3f {
-let da = 1.0 / 7.0;
-let fJ = mix(f0, vec3f(1.0), aH(da));
-let b = fJ * (vec3f(1.0) - tint) / (da * pow(1.0 - da, 6.0));
+let dd = 1.0 / 7.0;
+let fV = mix(f0, vec3f(1.0), aI(dd));
+let b = fV * (vec3f(1.0) - tint) / (dd * pow(1.0 - dd, 6.0));
 return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
 }
 
 
 
-fn cA(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {
+fn cC(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {
 if (cosine <= 0.0) { return vec3f(1.0); }
-let lV = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
-let uZ = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lV, 1e-5)));
-return mix(vec3f(1.0), uZ, material.coatWeight);
+let mP = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
+let wN = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(mP, 1e-5)));
+return mix(vec3f(1.0), wN, material.coatWeight);
 }
 
-fn gn(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {
+fn gH(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
 return ae(cosine, 1.0 / material.coatIor);
 }
@@ -797,39 +797,39 @@ return clamp(1.0 - ar(material.coatIor,
 material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);
 }
 
-fn gX(prepared: OpenPbrPreparedBsdf) -> vec3f {
+fn hv(prepared: OpenPbrPreparedBsdf) -> vec3f {
 let material = prepared.material;
 let dielectric = 1.0 - material.baseMetalness;
 let opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);
 let sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;
-let vU = dielectric * material.transmissionWeight;
-let fP = bI(prepared.specularEtaTOverEtaI);
-let lg = bI(1.0 / prepared.transmissionReflectionIor);
-let qA = clamp(opaque * fP + (sss + vU) * lg + material.baseMetalness, 0.0, 1.0);
-let jt = mix(1.0, material.specularRoughness, qA);
+let xQ = dielectric * material.transmissionWeight;
+let gb = bI(prepared.specularEtaTOverEtaI);
+let mc = bI(1.0 / prepared.transmissionReflectionIor);
+let rO = clamp(opaque * gb + (sss + xQ) * mc + material.baseMetalness, 0.0, 1.0);
+let jX = mix(1.0, material.specularRoughness, rO);
 let ks = bI(material.coatIor);
 let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-let k = mix(ks, kr, jt);
+let k = mix(ks, kr, jX);
 let eb = material.baseMetalness * material.specularWeight * bL(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fP)
-+ sss * material.subsurfaceColor + vec3f(vU);
-let rV = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
-return mix(vec3f(1.0), rV, material.coatWeight * material.coatDarkening);
++ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), gb)
++ sss * material.subsurfaceColor + vec3f(xQ);
+let tn = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
+return mix(vec3f(1.0), tn, material.coatWeight * material.coatDarkening);
 }
 
-fn cm(prepared: OpenPbrPreparedBsdf, lF: f32) -> vec3f {
+fn cp(prepared: OpenPbrPreparedBsdf, mx: f32) -> vec3f {
 if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }
 if (prepared.material.inside) {
 
-return cA(prepared.material, -lF);
+return cC(prepared.material, -mx);
 }
 
-return prepared.coatBaseScale * cA(prepared.material, lF);
+return prepared.coatBaseScale * cC(prepared.material, mx);
 }
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn dk(fallback: OpenPbrBasis, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> OpenPbrBasis {
+fn dm(fallback: OpenPbrBasis, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> OpenPbrBasis {
 var t = tangent - fallback.normal * dot(fallback.normal, tangent);
 if (dot(t, t) < 1e-8) { t = fallback.tangent; }
 t = normalize(t);
@@ -844,15 +844,15 @@ return basis;
 }
 
 ` : /* wgsl */ ``}
-fn bV(
+fn bX(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
-bD: vec3f,
+bE: vec3f,
 normal: vec3f
 ) -> OpenPbrPreparedBsdf {
 var prepared: OpenPbrPreparedBsdf;
 prepared.material = material;
-prepared.basis = ff(
+prepared.basis = ft(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -864,39 +864,39 @@ ${hasCoatNormals ? /* wgsl */ `
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = ff(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = ft(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 ` : ''}
 if ((material.specularAnisotropy > 0.0) & material.anisotropyDirectionEnabled) {
-prepared.basis = dk(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
+prepared.basis = dm(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
 prepared.directionFrames = true;
 }
 if ((material.coatAnisotropy > 0.0) & (material.coatAnisotropyRotation != 0.0)) {
-prepared.coatBasis = dk(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
+prepared.coatBasis = dm(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
 prepared.directionFrames = true;
 }
 ` : /* wgsl */ ``}
-prepared.viewLocal = openpbr_to_local(prepared.basis, bD);
-${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bD);` : ''}
+prepared.viewLocal = openpbr_to_local(prepared.basis, bE);
+${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bE);` : ''}
 prepared.diffuseColor = material.baseColor;
 
-let cu = 1.0 - material.baseMetalness;
-let dJ = cu
+let cw = 1.0 - material.baseMetalness;
+let dN = cw
 * (1.0 - material.transmissionWeight);
 prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;
 prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;
 if (material.inside) { prepared.weights[OPENPBR_LOBE_COAT] = 0.0; }
 prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;
-prepared.weights[OPENPBR_LOBE_SPECULAR] = cu;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cu
+prepared.weights[OPENPBR_LOBE_SPECULAR] = cw;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cw
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dJ
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dN
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dJ
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dN
 * material.subsurfaceWeight;
 
-prepared.specularEtaTOverEtaI = bb(
+prepared.specularEtaTOverEtaI = bc(
 1.0 / material.relativeIor,
 material.specularWeight
 );
@@ -906,20 +906,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-var bX = 1.0;
-if (!material.inside) { bX = mix(1.0, material.coatIor, material.coatWeight); }
-let bn = bX * bb(
-material.specularIor / bX, material.specularWeight);
-var eo = bn / bX;
-if ((bX > bn) & (bn >= 1.0)) {
-eo = 1.0 / eo;
-}
-prepared.specularEtaTOverEtaI = eo;
-prepared.transmissionReflectionIor = 1.0 / eo;
-prepared.refractionEtaTOverEtaI = bn;
+var bZ = 1.0;
+if (!material.inside) { bZ = mix(1.0, material.coatIor, material.coatWeight); }
+let bo = bZ * bc(
+material.specularIor / bZ, material.specularWeight);
+var ew = bo / bZ;
+if ((bZ > bo) & (bo >= 1.0)) {
+ew = 1.0 / ew;
+}
+prepared.specularEtaTOverEtaI = ew;
+prepared.transmissionReflectionIor = 1.0 / ew;
+prepared.refractionEtaTOverEtaI = bo;
 if (material.inside) {
-prepared.refractionEtaTOverEtaI = 1.0 / bn;
-prepared.transmissionReflectionIor = bn;
+prepared.refractionEtaTOverEtaI = 1.0 / bo;
+prepared.transmissionReflectionIor = bo;
 }
 prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
 }
@@ -945,41 +945,41 @@ let ag = ae(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-let fu = material.specularColor * select(
+let fJ = material.specularColor * select(
 ag,
 mix(
 ag,
-cL(ag),
+cN(ag),
 material.transmissionWeight
 ),
 material.thinWalled
 );
-let hS = material.specularWeight * openpbr_metal_fresnel(
+let iD = material.specularWeight * openpbr_metal_fresnel(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-let eI = select(
+let eS = select(
 ae(viewCosine, prepared.transmissionReflectionIor),
-cL(ae(viewCosine, prepared.transmissionReflectionIor)),
+cN(ae(viewCosine, prepared.transmissionReflectionIor)),
 material.thinWalled
 );
-let gK = bF(
+let hc = bF(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-let ir = ar(
+let iT = ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-let gq = cj(
+let gJ = ck(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = ir
-/ max(gq, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iT
+/ max(gJ, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
 * aB(material.fuzzColor)
@@ -991,32 +991,32 @@ prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;
 prepared.coatBaseScale = vec3f(1.0);
 if ((material.coatWeight > 0.0) & !material.inside) {
 ${hasCoatNormals ? /* wgsl */ `let coatViewCosine = select(viewCosine, max(prepared.coatViewLocal.z, 0.0), material.coatNormalEnabled);` : ''}
-let kO = gn(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kO;
-prepared.coatBaseScale = cA(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kO) * gX(prepared);
+let lH = gH(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * lH;
+prepared.coatBaseScale = cC(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * lH) * hv(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aB(hS);
+* aB(iD);
 prepared.metalMsScale = vec3f(0.0);
 prepared.metalMsFactor = 0.0;
 prepared.metalMsProbability = 0.0;
 
 
 if ((material.specularRoughness >= 0.04) & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0)) {
-let hI = bL(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * hI * hI;
-let qF = aR(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = qF / max(cl(prepared.specularAlpha), 1e-12);
-let fe = prepared.weights[OPENPBR_LOBE_METAL] * aB(prepared.metalMsScale) * qF;
-prepared.probabilities[OPENPBR_LOBE_METAL] += fe;
-prepared.metalMsProbability = fe / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+let il = bL(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * il * il;
+let rT = aR(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = rT / max(cn(prepared.specularAlpha), 1e-12);
+let fq = prepared.weights[OPENPBR_LOBE_METAL] * aB(prepared.metalMsScale) * rT;
+prepared.probabilities[OPENPBR_LOBE_METAL] += fq;
+prepared.metalMsProbability = fq / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aB(fu);
+* aB(fJ);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eI)
-* aB(gK);
+* (1.0 - eS)
+* aB(hc);
 
 
 
@@ -1031,59 +1031,59 @@ prepared.dielectricMsProbability = 0.0;
 if (!material.thinWalled & (material.transmissionWeight > 0.0) &
 (prepared.specularAlpha >= 0.0016) & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) &
 (abs(prepared.refractionEtaTOverEtaI - 1.0) > 1e-6)) {
-let lU = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lU;
-prepared.dielectricMsTransmissionScale = gK * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+let mO = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * mO;
+prepared.dielectricMsTransmissionScale = hc * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
-prepared.dielectricMsReflectionRatio = bU(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
+prepared.dielectricMsReflectionRatio = bW(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
 prepared.dielectricMsViewLoss = aV(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-let oG = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-let fe = aB(oG) * prepared.dielectricMsViewLoss;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fe;
-prepared.dielectricMsProbability = fe / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+let pM = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+let fq = aB(pM) * prepared.dielectricMsViewLoss;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fq;
+prepared.dielectricMsProbability = fq / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
 * aB(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eI)
+* (1.0 - eS)
 * aB(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
 if ((material.coatWeight > 0.0) & HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {
-let lD = 0.02 * bJ(material.thinFilmThickness, material.thinFilmWeight);
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * lD);
-prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * lD);
+let mv = 0.02 * bJ(material.thinFilmThickness, material.thinFilmWeight);
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * mv);
+prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * mv);
 }
 if ((material.coatWeight > 0.0) & !material.inside) {
-let gr = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
-prepared.probabilities[OPENPBR_LOBE_METAL] *= gr;
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gr;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gr;
-prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gr;
-prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gr;
-}
-dQ(&prepared);
+let gK = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
+prepared.probabilities[OPENPBR_LOBE_METAL] *= gK;
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gK;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gK;
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gK;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gK;
+}
+dW(&prepared);
 return prepared;
 }
 
 
-fn cK(prepared: OpenPbrPreparedBsdf, cosine: f32, reflection: bool) -> f32 {
+fn cM(prepared: OpenPbrPreparedBsdf, cosine: f32, reflection: bool) -> f32 {
 if (prepared.material.coatWeight <= 0.0) {
 return ae(cosine, prepared.material.relativeIor);
 }
-let kA = ae(cosine, prepared.transmissionReflectionIor);
-if (!reflection) { return kA; }
-let nY = ae(cosine, 1.0 / prepared.specularEtaTOverEtaI);
-let sN = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(nY, kA, sN);
+let lk = ae(cosine, prepared.transmissionReflectionIor);
+if (!reflection) { return lk; }
+let oX = ae(cosine, 1.0 / prepared.specularEtaTOverEtaI);
+let um = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(oX, lk, um);
 }
 
-fn nh(
+fn og(
 prepared: OpenPbrPreparedBsdf,
 lightDirection: vec3f,
-gL: i32,
+hg: i32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 let material = prepared.material;
@@ -1111,14 +1111,14 @@ aa = -aa;
 var response = vec3f(0.0);
 *pdf = 0.0;
 var lobePdf = 0.0;
-let mA = gL < 0;
-let wP = mA | (gL == OPENPBR_LOBE_FUZZ);
-let uE = mA | (gL == OPENPBR_LOBE_COAT);
-let tn = mA | (gL == OPENPBR_LOBE_METAL);
-let qW = mA | (gL == OPENPBR_LOBE_SPECULAR);
-let jJ = mA | (gL == OPENPBR_LOBE_TRANSMISSION);
-let uJ = mA | (gL == OPENPBR_LOBE_DIFFUSE);
-let pG = mA | (gL == OPENPBR_LOBE_SUBSURFACE);
+let nD = hg < 0;
+let yQ = nD | (hg == OPENPBR_LOBE_FUZZ);
+let wm = nD | (hg == OPENPBR_LOBE_COAT);
+let uT = nD | (hg == OPENPBR_LOBE_METAL);
+let sm = nD | (hg == OPENPBR_LOBE_SPECULAR);
+let ko = nD | (hg == OPENPBR_LOBE_TRANSMISSION);
+let ws = nD | (hg == OPENPBR_LOBE_DIFFUSE);
+let qJ = nD | (hg == OPENPBR_LOBE_SUBSURFACE);
 let viewHalf = abs(dot(viewLocal, aa));
 
 
@@ -1130,37 +1130,37 @@ thinWallHalf = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
 if (thinWallHalf.z < 0.0) { thinWallHalf = -thinWallHalf; }
 dielectricViewHalf = abs(dot(viewLocal, thinWallHalf));
 }
-let mP =
-(reflection & (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & qW) |
-(!reflection & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & jJ);
-let ra = reflection & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & tn;
-var oq: array<vec3f, 2>;
-if (mP) {
-oq[0] = vec3f(cK(prepared, dielectricViewHalf, reflection));
+let nR =
+(reflection & (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & sm) |
+(!reflection & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & ko);
+let sr = reflection & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & uT;
+var pk: array<vec3f, 2>;
+if (nR) {
+pk[0] = vec3f(cM(prepared, dielectricViewHalf, reflection));
 }
-if (ra) {
-oq[1] = openpbr_metal_fresnel(viewHalf, material.baseWeight * material.baseColor, material.specularColor);
+if (sr) {
+pk[1] = openpbr_metal_fresnel(viewHalf, material.baseWeight * material.baseColor, material.specularColor);
 }
 if (HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {
-let vV = vec3f(620.0, 540.0, 450.0);
+let xR = vec3f(620.0, 540.0, 450.0);
 
-for (var lf = 0u; lf < (rtUniform.loopUnrollGuard >> 1u); lf++) {
-if (!select(mP, ra, lf == 1u)) { continue; }
-var wY = vec3f(0.0);
-let J = select(dielectricViewHalf, viewHalf, lf == 1u);
+for (var mb = 0u; mb < (rtUniform.loopUnrollGuard >> 1u); mb++) {
+if (!select(nR, sr, mb == 1u)) { continue; }
+var yY = vec3f(0.0);
+let J = select(dielectricViewHalf, viewHalf, mb == 1u);
 for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
 var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
-if (lf == 1u) {
-ior = cJ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
+if (mb == 1u) {
+ior = cL(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
 }
-wY[channel] = ap(J,
-vV[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
+yY[channel] = ap(J,
+xR[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
 }
-oq[lf] = mix(oq[lf], wY,
+pk[mb] = mix(pk[mb], yY,
 bJ(material.thinFilmThickness, material.thinFilmWeight));
 }
 }
-let ef = oq[0];
+let em = pk[0];
 let diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
 * ar(
@@ -1174,8 +1174,8 @@ ${hasCoatNormals ? /* wgsl */ `
 if (!independentCoat | ((lightLocal.z != 0.0) & (reflection == geometricReflection))) {
 ` : ''}
 if (reflection) {
-if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & uJ) {
-response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bw(
+if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & ws) {
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bB(
 material,
 prepared.diffuseColor,
 viewLocal,
@@ -1186,8 +1186,8 @@ diffuseSpecularEnergyCompensation,
 *pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * lobePdf;
 }
 
-if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & material.thinWalled & pG) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bw(
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & material.thinWalled & qJ) {
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bB(
 material,
 material.subsurfaceColor,
 viewLocal,
@@ -1198,15 +1198,15 @@ diffuseSpecularEnergyCompensation,
 *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * lobePdf;
 }
 
-if ((prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & qW) {
-var ck = ef;
+if ((prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & sm) {
+var cl = em;
 if (material.thinWalled) {
-ck = aq(
-ck,
+cl = aq(
+cl,
 material.transmissionWeight
 );
 }
-let fresnel = material.specularColor * ck;
+let fresnel = material.specularColor * cl;
 response += prepared.weights[OPENPBR_LOBE_SPECULAR] * aj(
 material,
 viewLocal,
@@ -1218,8 +1218,8 @@ fresnel,
 *pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * lobePdf;
 }
 
-if ((prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & tn) {
-let fresnel = material.specularWeight * oq[1];
+if ((prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & uT) {
+let fresnel = material.specularWeight * pk[1];
 response += prepared.weights[OPENPBR_LOBE_METAL] * aj(
 material,
 viewLocal,
@@ -1229,20 +1229,20 @@ fresnel,
 &lobePdf
 );
 if (prepared.metalMsFactor > 0.0) {
-let cv = min(prepared.metalMsFactor * aR(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
-response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * cv * INVPI;
+let cA = min(prepared.metalMsFactor * aR(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
+response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * cA * INVPI;
 lobePdf = mix(lobePdf, 0.5 * INVPI, prepared.metalMsProbability);
 }
 *pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * lobePdf;
 }
 }
 else {
-let fresnel = ef;
-if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & jJ) {
+let fresnel = em;
+if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & ko) {
 if (material.thinWalled) {
-let lm = vec3f(lightLocal.xy, -lightLocal.z);
-let gk = aq(
-ef,
+let mi = vec3f(lightLocal.xy, -lightLocal.z);
+let gE = aq(
+em,
 1.0
 );
 let tint = bF(
@@ -1254,18 +1254,18 @@ response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 * aj(
 material,
 viewLocal,
-lm,
+mi,
 thinWallHalf,
-tint * (vec3f(1.0) - gk),
+tint * (vec3f(1.0) - gE),
 &lobePdf
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dc(
+* df(
 material,
 material.relativeIor,
-ba(material),
+bb(material),
 viewLocal,
 lightLocal,
 aa,
@@ -1278,22 +1278,22 @@ lobePdf *= 1.0 - prepared.dielectricMsProbability;
 }
 *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * lobePdf;
 }
-if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & pG) {
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & qJ) {
 if (material.thinWalled) {
-let oQ = vec3f(lightLocal.xy, -lightLocal.z);
+let pY = vec3f(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* bw(
+* bB(
 material,
 material.subsurfaceColor,
 viewLocal,
-oQ,
+pY,
 diffuseSpecularEnergyCompensation,
 &lobePdf
 );
 lobePdf *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dK(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dO(
 material,
 viewLocal,
 lightLocal,
@@ -1307,23 +1307,23 @@ lightLocal,
 
 
 
-if ((prepared.dielectricMsProbability > 0.0) & jJ) {
+if ((prepared.dielectricMsProbability > 0.0) & ko) {
 let cosine = abs(lightLocal.z);
 if (cosine > 0.0) {
 let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);
-let iZ = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
-let oP = prepared.dielectricMsViewLoss * aV(ior, prepared.specularAlpha, cosine)
-/ max(aY(ior, prepared.specularAlpha), 1e-12);
-let cv = min(oP * iZ, 1.0 / cosine);
+let fw = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
+let pX = prepared.dielectricMsViewLoss * aV(ior, prepared.specularAlpha, cosine)
+/ max(aZ(ior, prepared.specularAlpha), 1e-12);
+let cA = min(pX * fw, 1.0 / cosine);
 let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);
-response += scale * cv * INVPI;
-*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iZ * 0.5 * INVPI;
+response += scale * cA * INVPI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * fw * 0.5 * INVPI;
 }
 }
 
 ${hasCoatNormals ? /* wgsl */ `    } ` : ''}
 if (material.coatWeight > 0.0) {
-response *= cm(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
+response *= cp(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
 }
 ${hasCoatNormals ? /* wgsl */ `
 
@@ -1332,33 +1332,33 @@ if (independentCoat) { response *= abs(lightLocal.z); }
 
 ${hasAnisotropyDirections ? /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {
-var dG = viewLocal;
-var kQ = lightLocal;
+var dI = viewLocal;
+var lJ = lightLocal;
 var coatHalf = aa;
 var coatViewHalf = viewHalf;
 if (prepared.directionFrames) {
-dG = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, independentCoat)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'};
-kQ = openpbr_to_local(prepared.coatBasis, lightDirection);
-coatHalf = normalize(kQ + dG);
+dI = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, independentCoat)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'};
+lJ = openpbr_to_local(prepared.coatBasis, lightDirection);
+coatHalf = normalize(lJ + dI);
 if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }
-coatViewHalf = abs(dot(dG, coatHalf));
+coatViewHalf = abs(dot(dI, coatHalf));
 }
 
-let lB = vec3f(ae(
+let mr = vec3f(ae(
 coatViewHalf,
 1.0 / material.coatIor
 ));
-var dF = material;
-let jD = aL(material.coatRoughness, material.coatAnisotropy);
-dF.alphaX = jD.x;
-dF.alphaY = jD.y;
-if (uE) {
+var dH = material;
+let kh = aL(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = kh.x;
+dH.alphaY = kh.y;
+if (wm) {
 response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * aj(
-dF,
-dG,
-kQ,
+dH,
+dI,
+lJ,
 coatHalf,
-lB,
+mr,
 &lobePdf
 );
 *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
@@ -1366,21 +1366,21 @@ lB,
 }
 ` : /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {
-let lB = vec3f(ae(
+let mr = vec3f(ae(
 viewHalf,
 1.0 / material.coatIor
 ));
-var dF = material;
-let jD = aL(material.coatRoughness, material.coatAnisotropy);
-dF.alphaX = jD.x;
-dF.alphaY = jD.y;
-if (uE) {
+var dH = material;
+let kh = aL(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = kh.x;
+dH.alphaY = kh.y;
+if (wm) {
 response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * aj(
-dF,
+dH,
 viewLocal,
 lightLocal,
 aa,
-lB,
+mr,
 &lobePdf
 );
 *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
@@ -1389,16 +1389,16 @@ lB,
 `}
 
 if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0)) {
-let rt = aQ(
+let sL = aQ(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3f(0.0),
-vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rt)
+vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * sL)
 );
-if (wP) {
-response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * kg(
+if (yQ) {
+response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * kN(
 material,
 viewLocal,
 lightLocal,
@@ -1416,25 +1416,25 @@ prepared: OpenPbrPreparedBsdf,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-return nh(prepared, lightDirection, -1, pdf);
+return og(prepared, lightDirection, -1, pdf);
 }
 
 
 
 
 
-fn sj(
+fn tJ(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
-bD: vec3f,
+bE: vec3f,
 normal: vec3f,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = bV(
+let prepared = bX(
 tangent,
 material,
-bD,
+bE,
 normal
 );
 return openpbr_eval_prepared(prepared, lightDirection, pdf);
@@ -1444,22 +1444,22 @@ return openpbr_eval_prepared(prepared, lightDirection, pdf);
 
 
 
-fn iW(
+fn jC(
 prepared: OpenPbrPreparedBsdf, cc: vec3f,
 lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,
-aO: ptr<function, f32>, bk: ptr<function, bool>,
-cC: ptr<function, bool>, bh: ptr<function, u32>
+aO: ptr<function, f32>, bl: ptr<function, bool>,
+cE: ptr<function, bool>, bi: ptr<function, u32>
 ) -> bool {
 let material = prepared.material;
 let viewLocal = prepared.viewLocal;
-var cp = cc.x;
-let fp = cc.y;
-let bl = cc.z;
+var cr = cc.x;
+let fG = cc.y;
+let bm = cc.z;
 *isTransmissionEvent = false;
 *aO = 1.0;
-*bk = false;
-*cC = false;
-*bh = u32(OPENPBR_LOBE_DIFFUSE);
+*bl = false;
+*cE = false;
+*bi = u32(OPENPBR_LOBE_DIFFUSE);
 *lightDirection = prepared.basis.normal;
 
 var cdf: array<f32, OPENPBR_LOBE_COUNT>;
@@ -1470,40 +1470,40 @@ return false;
 }
 
 var lightLocal: vec3f;
-if ((bl < cdf[OPENPBR_LOBE_FUZZ]) | (
-(bl >= cdf[OPENPBR_LOBE_TRANSMISSION]) & (bl < cdf[OPENPBR_LOBE_DIFFUSE])
+if ((bm < cdf[OPENPBR_LOBE_FUZZ]) | (
+(bm >= cdf[OPENPBR_LOBE_TRANSMISSION]) & (bm < cdf[OPENPBR_LOBE_DIFFUSE])
 )) {
-let qy = bl < cdf[OPENPBR_LOBE_FUZZ];
+let rL = bm < cdf[OPENPBR_LOBE_FUZZ];
 *aO = select(
 1.0,
 material.fuzzRoughness,
-qy
+rL
 );
-*cC = !qy;
-*bh = select(
+*cE = !rL;
+*bi = select(
 u32(OPENPBR_LOBE_DIFFUSE),
 u32(OPENPBR_LOBE_FUZZ),
-qy
+rL
 );
-lightLocal = aM(vec2f(cp, fp));
+lightLocal = aM(vec2f(cr, fG));
 }
 ${hasAnisotropyDirections ? /* wgsl */ `
-else if (bl < cdf[OPENPBR_LOBE_COAT]) {
+else if (bm < cdf[OPENPBR_LOBE_COAT]) {
 *aO = material.coatRoughness;
-*bk = true;
-*bh = u32(OPENPBR_LOBE_COAT);
-var dG = viewLocal;
-if (prepared.directionFrames) { dG = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, material.coatNormalEnabled)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'}; }
+*bl = true;
+*bi = u32(OPENPBR_LOBE_COAT);
+var dI = viewLocal;
+if (prepared.directionFrames) { dI = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, material.coatNormalEnabled)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'}; }
 var aa = aA(
-dG,
+dI,
 
 aL(material.coatRoughness, material.coatAnisotropy),
-vec2f(cp, fp)
+vec2f(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
 }
-lightLocal = normalize(reflect(-dG, aa));
+lightLocal = normalize(reflect(-dI, aa));
 ${hasCoatNormals ? /* wgsl */ `
 if (material.coatNormalEnabled) {
 
@@ -1514,15 +1514,15 @@ return (lightLocal.z > 0.0) & (dot(material.geometricNormal, *lightDirection) >
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
 ` : /* wgsl */ `
-else if (bl < cdf[OPENPBR_LOBE_COAT]) {
+else if (bm < cdf[OPENPBR_LOBE_COAT]) {
 *aO = material.coatRoughness;
-*bk = true;
-*bh = u32(OPENPBR_LOBE_COAT);
+*bl = true;
+*bi = u32(OPENPBR_LOBE_COAT);
 var aa = aA(
 viewLocal,
 
 aL(material.coatRoughness, material.coatAnisotropy),
-vec2f(cp, fp)
+vec2f(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
@@ -1530,27 +1530,27 @@ aa = -aa;
 lightLocal = normalize(reflect(-viewLocal, aa));
 }
 `}
-else if (bl < cdf[OPENPBR_LOBE_SPECULAR]) {
+else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
 *aO = material.specularRoughness;
-*bk = true;
-*bh = select(
+*bl = true;
+*bi = select(
 u32(OPENPBR_LOBE_SPECULAR),
 u32(OPENPBR_LOBE_METAL),
-bl < cdf[OPENPBR_LOBE_METAL]
+bm < cdf[OPENPBR_LOBE_METAL]
 );
-let uU = bl < cdf[OPENPBR_LOBE_METAL];
-let sK = (bl - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (uU & (sK < prepared.metalMsProbability)) {
-let z = cp;
-let dr = sqrt(max(0.0, 1.0 - z * z));
-let azimuth = TWOPI * fp;
-lightLocal = vec3f(dr * cos(azimuth), dr * sin(azimuth), z);
+let wI = bm < cdf[OPENPBR_LOBE_METAL];
+let uj = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (wI & (uj < prepared.metalMsProbability)) {
+let z = cr;
+let dw = sqrt(max(0.0, 1.0 - z * z));
+let azimuth = TWOPI * fG;
+lightLocal = vec3f(dw * cos(azimuth), dw * sin(azimuth), z);
 }
 else {
 var aa = aA(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cp, fp)
+vec2f(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
@@ -1558,38 +1558,38 @@ aa = -aa;
 lightLocal = normalize(reflect(-viewLocal, aa));
 }
 }
-else if (bl < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 *aO = material.specularRoughness;
-*bk = true;
+*bl = true;
 *isTransmissionEvent = true;
-*bh = u32(OPENPBR_LOBE_TRANSMISSION);
+*bi = u32(OPENPBR_LOBE_TRANSMISSION);
 
 
-let wk = (bl - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if ((prepared.dielectricMsProbability > 0.0) & (wk < prepared.dielectricMsProbability)) {
-let iZ = prepared.dielectricMsReflectionRatio;
-let mv = cp < iZ;
+let yj = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if ((prepared.dielectricMsProbability > 0.0) & (yj < prepared.dielectricMsProbability)) {
+let fw = prepared.dielectricMsReflectionRatio;
+let nt = cr < fw;
 var z: f32;
-if (mv) { z = min(cp / iZ, 0.99999994); }
-else { z = -min((cp - iZ) / (1.0 - iZ), 0.99999994); }
-let dr = sqrt(max(0.0, 1.0 - z * z));
-let azimuth = TWOPI * fp;
-lightLocal = vec3f(dr * cos(azimuth), dr * sin(azimuth), z);
-*isTransmissionEvent = !mv;
-*bh = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), mv);
+if (nt) { z = min(cr / fw, 0.99999994); }
+else { z = -min((cr - fw) / (1.0 - fw), 0.99999994); }
+let dw = sqrt(max(0.0, 1.0 - z * z));
+let azimuth = TWOPI * fG;
+lightLocal = vec3f(dw * cos(azimuth), dw * sin(azimuth), z);
+*isTransmissionEvent = !nt;
+*bi = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), nt);
 }
 else {
 var aa = aA(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cp, fp)
+vec2f(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
 }
 if (material.thinWalled) {
-let hX = normalize(reflect(-viewLocal, aa));
-lightLocal = vec3f(hX.xy, -hX.z);
+let iI = normalize(reflect(-viewLocal, aa));
+lightLocal = vec3f(iI.xy, -iI.z);
 }
 else {
 lightLocal = refract(
@@ -1607,19 +1607,19 @@ lightLocal = normalize(lightLocal);
 }
 else {
 *aO = 1.0;
-*cC = true;
+*cE = true;
 *isTransmissionEvent = true;
-*bh = u32(OPENPBR_LOBE_SUBSURFACE);
+*bi = u32(OPENPBR_LOBE_SUBSURFACE);
 if (material.thinWalled) {
-let qD = cp >= 0.5;
-if (qD) {
-cp = (cp - 0.5) * 2.0;
+let rR = cr >= 0.5;
+if (rR) {
+cr = (cr - 0.5) * 2.0;
 }
 else {
-cp *= 2.0;
+cr *= 2.0;
 }
-lightLocal = aM(vec2f(cp, fp));
-if (qD) {
+lightLocal = aM(vec2f(cr, fG));
+if (rR) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1627,7 +1627,7 @@ else {
 }
 }
 else {
-lightLocal = aM(vec2f(cp, fp));
+lightLocal = aM(vec2f(cr, fG));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1646,22 +1646,22 @@ if (material.coatNormalEnabled &
 return true;
 }
 
-fn dl(
+fn dr(
 prepared: OpenPbrPreparedBsdf,
 cc: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
 aO: ptr<function, f32>,
-bk: ptr<function, bool>,
-cC: ptr<function, bool>,
-bh: ptr<function, u32>,
+bl: ptr<function, bool>,
+cE: ptr<function, bool>,
+bi: ptr<function, u32>,
 marginalPdf: ptr<function, f32>,
-jU: ptr<function, vec3f>
+kA: ptr<function, vec3f>
 ) -> vec3f {
 *pdf = 0.0;
 *marginalPdf = 0.0;
-*jU = vec3f(0.0);
+*kA = vec3f(0.0);
 
 
 
@@ -1673,61 +1673,61 @@ if (!prepared.material.thinWalled &
 prepared.basis,
 -prepared.viewLocal
 );
-let ov = ba(prepared.material)
-* cm(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
+let pp = bb(prepared.material)
+* cp(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
 *pdf = 1.0;
 *marginalPdf = 1.0;
-*jU = ov;
+*kA = pp;
 *isTransmissionEvent = true;
 *aO = 0.0;
-*bk = true;
-*cC = false;
-*bh = u32(OPENPBR_LOBE_TRANSMISSION);
-return ov;
-}
-if (!iW(prepared, cc, lightDirection,
-isTransmissionEvent, aO, bk,
-cC, bh)) { return vec3f(0.0); }
+*bl = true;
+*cE = false;
+*bi = u32(OPENPBR_LOBE_TRANSMISSION);
+return pp;
+}
+if (!jC(prepared, cc, lightDirection,
+isTransmissionEvent, aO, bl,
+cE, bi)) { return vec3f(0.0); }
 let response = openpbr_eval_prepared(prepared, *lightDirection, pdf);
 *marginalPdf = *pdf;
-*jU = response;
+*kA = response;
 return response;
 }
 
-fn uc(
+fn vL(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
 cc: vec3f,
-bD: vec3f,
+bE: vec3f,
 normal: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
 aO: ptr<function, f32>,
-bk: ptr<function, bool>,
-cC: ptr<function, bool>,
-bh: ptr<function, u32>,
+bl: ptr<function, bool>,
+cE: ptr<function, bool>,
+bi: ptr<function, u32>,
 marginalPdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = bV(
+let prepared = bX(
 tangent,
 material,
-bD,
+bE,
 normal
 );
-var jU = vec3f(0.0);
-return dl(
+var kA = vec3f(0.0);
+return dr(
 prepared,
 cc,
 lightDirection,
 pdf,
 isTransmissionEvent,
 aO,
-bk,
-cC,
-bh,
+bl,
+cE,
+bi,
 marginalPdf,
-&jU
+&kA
 );
 }`;
 }