@meimu/mutracer 0.1.3 → 0.1.4

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

@@ -77,13 +77,13 @@ fn aY(
 bu: f32,
 specularWeight: f32
 ) -> f32 {
-let sJ = min(
+let sR = min(
 cV(bu) * specularWeight,
 0.9999
 );
-let sL = sqrt(sJ);
-let kY = (1.0 + sL) / (1.0 - sL);
-return select(kY, 1.0 / kY, bu < 1.0);
+let sT = sqrt(sR);
+let lh = (1.0 + sT) / (1.0 - sT);
+return select(lh, 1.0 / lh, bu < 1.0);
 }
 
 fn af(cc: f32, relativeIor: f32) -> f32 {
@@ -100,60 +100,60 @@ return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;
 return 16.0 + ((ior - 1.0) / 1.5) * 15.0;
 }
 
-fn F(sc: i32, row: i32) -> f32 {
-return textureLoad(openPbrEnergyLut, vec2i(sc, row), 0).r;
+fn F(sl: i32, row: i32) -> f32 {
+return textureLoad(openPbrEnergyLut, vec2i(sl, row), 0).r;
 }
 
-fn fZ(
-dI: f32,
+fn gd(
+dJ: f32,
 bR: f32,
-hN: f32
+hR: f32
 ) -> f32 {
-let bA = clamp(dI, 0.0, 31.0);
+let bA = clamp(dJ, 0.0, 31.0);
 let aH = clamp(bR, 0.0, 31.0);
-let bt = clamp(hN, 0.0, 31.0);
-let dP = i32(floor(bA));
+let bt = clamp(hR, 0.0, 31.0);
+let dQ = i32(floor(bA));
 let aN = i32(floor(aH));
 let cI = i32(floor(bt));
-let hA = min(dP + 1, 31);
+let hE = min(dQ + 1, 31);
 let cp = min(aN + 1, 31);
-let eO = min(cI + 1, 31);
-let cq = bA - f32(dP);
+let eR = min(cI + 1, 31);
+let cq = bA - f32(dQ);
 let cz = aH - f32(aN);
-let kw = bt - f32(cI);
-
-let ur = F(cI, dP * 32 + aN);
-let us = F(eO, dP * 32 + aN);
-let ut = F(cI, dP * 32 + cp);
-let uw = F(eO, dP * 32 + cp);
-let ux = F(cI, hA * 32 + aN);
-let uy = F(eO, hA * 32 + aN);
-let uz = F(cI, hA * 32 + cp);
-let uA = F(eO, hA * 32 + cp);
-let v00 = mix(ur, ux, cq);
-let v01 = mix(us, uy, cq);
-let v10 = mix(ut, uz, cq);
-let v11 = mix(uw, uA, cq);
+let kE = bt - f32(cI);
+
+let uA = F(cI, dQ * 32 + aN);
+let uB = F(eR, dQ * 32 + aN);
+let uC = F(cI, dQ * 32 + cp);
+let uD = F(eR, dQ * 32 + cp);
+let uE = F(cI, hE * 32 + aN);
+let uF = F(eR, hE * 32 + aN);
+let uG = F(cI, hE * 32 + cp);
+let uH = F(eR, hE * 32 + cp);
+let v00 = mix(uA, uE, cq);
+let v01 = mix(uB, uF, cq);
+let v10 = mix(uC, uG, cq);
+let v11 = mix(uD, uH, cq);
 return mix(
 mix(v00, v10, cz),
 mix(v01, v11, cz),
-kw
+kE
 );
 }
 
-fn gz(dI: f32, bR: f32) -> f32 {
-let bA = clamp(dI, 0.0, 31.0);
+fn gF(dJ: f32, bR: f32) -> f32 {
+let bA = clamp(dJ, 0.0, 31.0);
 let aH = clamp(bR, 0.0, 31.0);
-let dP = i32(floor(bA));
+let dQ = i32(floor(bA));
 let aN = i32(floor(aH));
-let hA = min(dP + 1, 31);
+let hE = min(dQ + 1, 31);
 let cp = min(aN + 1, 31);
-let cq = bA - f32(dP);
+let cq = bA - f32(dQ);
 let cz = aH - f32(aN);
-let v00 = F(aN, 1024 + dP);
-let v01 = F(cp, 1024 + dP);
-let v10 = F(aN, 1024 + hA);
-let v11 = F(cp, 1024 + hA);
+let v00 = F(aN, 1024 + dQ);
+let v01 = F(cp, 1024 + dQ);
+let v10 = F(aN, 1024 + hE);
+let v11 = F(cp, 1024 + hE);
 return mix(
 mix(v00, v10, cq),
 mix(v01, v11, cq),
@@ -164,55 +164,55 @@ cz
 
 
 fn ef(
-dI: f32,
+dJ: f32,
 bR: f32,
-hN: f32
+hR: f32
 ) -> f32 {
-let bA = clamp(dI, 0.0, 31.0);
+let bA = clamp(dJ, 0.0, 31.0);
 let aH = clamp(bR, 0.0, 31.0);
-let bt = clamp(hN, 0.0, 31.0);
-let dP = i32(floor(bA));
+let bt = clamp(hR, 0.0, 31.0);
+let dQ = i32(floor(bA));
 let aN = i32(floor(aH));
 let cI = i32(floor(bt));
-let hA = min(dP + 1, 31);
+let hE = min(dQ + 1, 31);
 let cp = min(aN + 1, 31);
-let eO = min(cI + 1, 31);
-let cq = bA - f32(dP);
+let eR = min(cI + 1, 31);
+let cq = bA - f32(dQ);
 let cz = aH - f32(aN);
-let kw = bt - f32(cI);
-
-let ur = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aN);
-let us = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aN);
-let ut = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cp);
-let uw = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cp);
-let ux = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hA * 32 + aN);
-let uy = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hA * 32 + aN);
-let uz = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hA * 32 + cp);
-let uA = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hA * 32 + cp);
-let v00 = mix(ur, ux, cq);
-let v01 = mix(us, uy, cq);
-let v10 = mix(ut, uz, cq);
-let v11 = mix(uw, uA, cq);
+let kE = bt - f32(cI);
+
+let uA = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
+let uB = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
+let uC = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
+let uD = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
+let uE = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
+let uF = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
+let uG = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
+let uH = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
+let v00 = mix(uA, uE, cq);
+let v01 = mix(uB, uF, cq);
+let v10 = mix(uC, uG, cq);
+let v11 = mix(uD, uH, cq);
 return mix(
 mix(v00, v10, cz),
 mix(v01, v11, cz),
-kw
+kE
 );
 }
 
-fn ee(dI: f32, bR: f32) -> f32 {
-let bA = clamp(dI, 0.0, 31.0);
+fn ee(dJ: f32, bR: f32) -> f32 {
+let bA = clamp(dJ, 0.0, 31.0);
 let aH = clamp(bR, 0.0, 31.0);
-let dP = i32(floor(bA));
+let dQ = i32(floor(bA));
 let aN = i32(floor(aH));
-let hA = min(dP + 1, 31);
+let hE = min(dQ + 1, 31);
 let cp = min(aN + 1, 31);
-let cq = bA - f32(dP);
+let cq = bA - f32(dQ);
 let cz = aH - f32(aN);
-let v00 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-let v01 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-let v10 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hA);
-let v11 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hA);
+let v00 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
+let v01 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
+let v10 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
+let v11 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
 return mix(
 mix(v00, v10, cq),
 mix(v01, v11, cq),
@@ -220,19 +220,19 @@ cz
 );
 }
 
-fn eF(dI: f32, bR: f32) -> f32 {
-let bA = clamp(dI, 0.0, 31.0);
+fn eG(dJ: f32, bR: f32) -> f32 {
+let bA = clamp(dJ, 0.0, 31.0);
 let aH = clamp(bR, 0.0, 31.0);
-let dP = i32(floor(bA));
+let dQ = i32(floor(bA));
 let aN = i32(floor(aH));
-let hA = min(dP + 1, 31);
+let hE = min(dQ + 1, 31);
 let cp = min(aN + 1, 31);
-let cq = bA - f32(dP);
+let cq = bA - f32(dQ);
 let cz = aH - f32(aN);
-let v00 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-let v01 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-let v10 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hA);
-let v11 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hA);
+let v00 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
+let v01 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
+let v10 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
+let v11 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
 return mix(
 mix(v00, v10, cq),
 mix(v01, v11, cq),
@@ -247,22 +247,22 @@ fn cO(ior: f32, alpha: f32) -> f32 {
 return ee(aC(ior), sqrt(alpha) * 31.0);
 }
 fn ch(ior: f32, alpha: f32) -> f32 {
-return eF(aC(ior), sqrt(alpha) * 31.0);
+return eG(aC(ior), sqrt(alpha) * 31.0);
 }
 
 
 
 fn bH(alpha: f32, au: f32) -> f32 {
-let hZ = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+let ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
 let bt = clamp(au * 31.0, 0.0, 31.0);
-let r0 = i32(floor(hZ));
+let r0 = i32(floor(ie));
 let c0 = i32(floor(bt));
 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(bt)),
 mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bt)),
-fract(hZ));
+fract(ie));
 }
 
 fn cv(alpha: f32) -> f32 {
@@ -274,8 +274,8 @@ F(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));
 
 fn aX(value: f32, ior: f32) -> f32 {
 if (ior > 2.5 || ior < 0.4) {
-let tN = cV(2.5);
-let progress = (cV(ior) - tN) / (1.0 - tN);
+let tU = cV(2.5);
+let progress = (cV(ior) - tU) / (1.0 - tU);
 return (1.0 - progress) * value;
 }
 return value;
@@ -286,7 +286,7 @@ ior: f32,
 alpha: f32,
 au: f32
 ) -> f32 {
-let value = fZ(
+let value = gd(
 aC(ior),
 sqrt(alpha) * 31.0,
 au * 31.0
@@ -295,7 +295,7 @@ return aX(value, ior);
 }
 
 fn cr(ior: f32, alpha: f32) -> f32 {
-let value = gz(
+let value = gF(
 aC(ior),
 sqrt(alpha) * 31.0
 );
@@ -316,14 +316,14 @@ dot(direction, basis.normal)
 );
 }
 
-fn fg(
-aU: vec3f,
+fn fj(
+aT: vec3f,
 normal: vec3f,
 anisotropy: f32
 ) -> bj {
 var basis: bj;
 basis.normal = normal;
-var tangent = aU;
+var tangent = aT;
 var bitangent = vec3f(0.0);
 if (dot(tangent, tangent) < 0.001 || anisotropy <= 0.0) {
 aL(normal, &tangent, &bitangent);
@@ -337,7 +337,7 @@ basis.bitangent = bitangent;
 return basis;
 }
 
-fn jT(
+fn ka(
 av: f32,
 ak: f32,
 L: f32,
@@ -347,7 +347,7 @@ return (av * L - ak * S)
 / (av * L + ak * S);
 }
 
-fn jS(
+fn jZ(
 av: f32,
 ak: f32,
 L: f32,
@@ -357,7 +357,7 @@ return (ak * L - av * S)
 / (av * S + ak * L);
 }
 
-fn gY(
+fn hc(
 av: f32,
 ak: f32,
 L: f32,
@@ -367,7 +367,7 @@ return 2.0 * av * L
 / (av * L + ak * S);
 }
 
-fn gX(
+fn hb(
 av: f32,
 ak: f32,
 L: f32,
@@ -377,7 +377,7 @@ return 2.0 * av * L
 / (av * S + ak * L);
 }
 
-fn aV(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);
 }
 
@@ -389,32 +389,32 @@ return vec2f(
 );
 }
 
-fn hT(value: vec2f) -> vec2f {
-let nv = length(value);
-let sH = sqrt(max(0.0, 0.5 * (nv + value.x)));
-let fc = sqrt(max(0.0, 0.5 * (nv - value.x)));
-return vec2f(sH, select(-fc, fc, value.y >= 0.0));
+fn hX(value: vec2f) -> vec2f {
+let nK = length(value);
+let sP = sqrt(max(0.0, 0.5 * (nK + value.x)));
+let ff = sqrt(max(0.0, 0.5 * (nK - value.x)));
+return vec2f(sP, select(-ff, ff, value.y >= 0.0));
 }
 
 fn bX(
 L: f32,
 av: f32,
 ak: vec2f,
-qy: bool
+qG: bool
 ) -> vec2f {
-let oe = sqrt(max(0.0, 1.0 - L * L));
-let sp = aZ(vec2f(av, 0.0), ak);
-let hw = sp * oe;
-var S = hT(
-vec2f(1.0, 0.0) - aV(hw, hw)
+let os = sqrt(max(0.0, 1.0 - L * L));
+let sA = aZ(vec2f(av, 0.0), ak);
+let hA = sA * os;
+var S = hX(
+vec2f(1.0, 0.0) - aU(hA, hA)
 );
-if (aV(ak, S).y < 0.0) {
+if (aU(ak, S).y < 0.0) {
 S = -S;
 }
 
-let fH = vec2f(av * L, 0.0);
-let eA = aV(ak, S);
-if (qy) {
+let fK = vec2f(av * L, 0.0);
+let eB = aU(ak, S);
+if (qG) {
 let ci = ak * L;
 let ce = S * av;
 return aZ(
@@ -423,26 +423,26 @@ ci + ce
 );
 }
 return aZ(
-fH - eA,
-fH + eA
+fK - eB,
+fK + eB
 );
 }
 
 fn eq(
-iD: f32,
-gI: f32,
-oy: f32,
-mD: f32,
-jY: vec2f,
+iH: f32,
+gM: f32,
+oH: f32,
+mN: f32,
+kf: vec2f,
 phase: f32
 ) -> f32 {
-let nd = vec2f(cos(phase), sin(phase));
-let hW = aV(jY, nd);
-let kF = hW * (gI * mD);
-let ap = vec2f(1.0, 0.0) - hW * oy;
-let hv = vec2f(iD, 0.0)
-+ aZ(kF, ap);
-return dot(hv, hv);
+let nr = vec2f(cos(phase), sin(phase));
+let ia = aU(kf, nr);
+let kO = ia * (gM * mN);
+let ap = vec2f(1.0, 0.0) - ia * oH;
+let hz = vec2f(iH, 0.0)
++ aZ(kO, ap);
+return dot(hz, hz);
 }
 
 fn ar(
@@ -453,67 +453,67 @@ aM: f32,
 ck: f32,
 eu: vec2f
 ) -> f32 {
-let dl = clamp(abs(L), 1e-5, 1.0);
-let hq = pow(aM / ck, 2.0)
-* (1.0 - dl * dl);
-if (hq >= 1.0) {
+let dm = clamp(abs(L), 1e-5, 1.0);
+let hu = pow(aM / ck, 2.0)
+* (1.0 - dm * dm);
+if (hu >= 1.0) {
 return 1.0;
 }
-let cU = sqrt(1.0 - hq);
-let kS = jT(
-aM, ck, dl, cU
+let cU = sqrt(1.0 - hu);
+let lb = ka(
+aM, ck, dm, cU
 );
-let kR = jS(
-aM, ck, dl, cU
+let la = jZ(
+aM, ck, dm, cU
 );
-let jf = gY(
-aM, ck, dl, cU
+let jj = hc(
+aM, ck, dm, cU
 );
-let je = gX(
-aM, ck, dl, cU
+let ji = hb(
+aM, ck, dm, cU
 );
-let gk = ck * cU
-/ max(aM * dl, 1e-9);
+let gq = ck * cU
+/ max(aM * dm, 1e-9);
 let phase = 2.0 * PI * (2.0 * ck * cn * cU) / wavelength;
-var rT = 0.0;
+var sb = 0.0;
 
-for (var jX = 0u; jX < (rtUniform.loopUnrollGuard >> 1u); jX++) {
-let iD = select(kS, kR, jX == 1u);
-let gI = select(jf, je, jX == 1u);
-let jY = bX(
-cU, ck, eu, jX == 1u);
-rT += eq(iD, gI,
--iD, gI * gk, jY, phase);
+for (var ke = 0u; ke < (rtUniform.loopUnrollGuard >> 1u); ke++) {
+let iH = select(lb, la, ke == 1u);
+let gM = select(jj, ji, ke == 1u);
+let kf = bX(
+cU, ck, eu, ke == 1u);
+sb += eq(iH, gM,
+-iH, gM * gq, kf, phase);
 }
-return clamp(0.5 * rT, 0.0, 1.0);
+return clamp(0.5 * sb, 0.0, 1.0);
 }
 
 
 
 
-fn dT(au: f32, f0: vec3f, tint: vec3f) -> vec3f {
-let ra = mix(f0, vec3f(1.0), aE(au));
-if (all(tint == vec3f(1.0))) { return ra; }
-let dj = 1.0 / 7.0;
-let lZ = 1.0 - dj;
-let fF = mix(f0, vec3f(1.0), aE(dj));
-let dg = 1.0 - au;
-let ql = au * aE(au) * dg
-/ (dj * pow(lZ, 6.0));
-return clamp(ra - ql * (fF - tint * fF), vec3f(0.0), vec3f(1.0));
+fn dU(au: f32, f0: vec3f, tint: vec3f) -> vec3f {
+let rk = mix(f0, vec3f(1.0), aE(au));
+if (all(tint == vec3f(1.0))) { return rk; }
+let dk = 1.0 / 7.0;
+let ml = 1.0 - dk;
+let fI = mix(f0, vec3f(1.0), aE(dk));
+let di = 1.0 - au;
+let qt = au * aE(au) * di
+/ (dk * pow(ml, 6.0));
+return clamp(rk - qt * (fI - tint * fI), vec3f(0.0), vec3f(1.0));
 }
 
-fn cQ(f0: f32, tg: f32) -> vec2f {
-let dM = clamp(f0, 0.0, 0.99);
-let gH = sqrt(dM);
-let qx = (1.0 - dM) / (1.0 + dM);
-let qv = (1.0 + gH) / max(1.0 - gH, 1e-9);
-let ior = mix(qv, qx, clamp(tg, 0.0, 1.0));
-let jI = (
-(ior + 1.0) * (ior + 1.0) * dM
+fn cQ(f0: f32, tp: f32) -> vec2f {
+let dN = clamp(f0, 0.0, 0.99);
+let gL = sqrt(dN);
+let qF = (1.0 - dN) / (1.0 + dN);
+let qD = (1.0 + gL) / max(1.0 - gL, 1e-9);
+let ior = mix(qD, qF, clamp(tp, 0.0, 1.0));
+let jO = (
+(ior + 1.0) * (ior + 1.0) * dN
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dM, 1e-9);
-return vec2f(ior, sqrt(max(jI, 0.0)));
+) / max(1.0 - dN, 1e-9);
+return vec2f(ior, sqrt(max(jO, 0.0)));
 }
 
 
@@ -528,7 +528,7 @@ material: J,
 color: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-fo: f32,
+ft: f32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -537,49 +537,49 @@ return vec3f(0.0);
 }
 
 let roughness = material.diffuseRoughness;
-let gS = 0.5 - 2.0 / (3.0 * PI);
-let nX = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-let os = lightLocal.z;
-let mq = viewLocal.z;
-let hL = dot(lightLocal, viewLocal) - os * mq;
-let gP = select(
-hL,
-hL / max(max(os, mq), 1e-7),
-hL > 0.0
+let gW = 0.5 - 2.0 / (3.0 * PI);
+let oj = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+let oB = lightLocal.z;
+let mB = viewLocal.z;
+let hP = dot(lightLocal, viewLocal) - oB * mB;
+let gT = select(
+hP,
+hP / max(max(oB, mB), 1e-7),
+hP > 0.0
 );
-let ig = 1.0 / (1.0 + gS * roughness);
-let ni = color * INVPI * ig
-* (1.0 + roughness * gP);
-
-let dc = 1.0 - os;
-let cP = 1.0 - mq;
-let og = dc * (
-0.0571085289 + dc * (
-0.491881867 + dc * (
--0.332181442 + dc * 0.0714429953
+let il = 1.0 / (1.0 + gW * roughness);
+let nA = color * INVPI * il
+* (1.0 + roughness * gT);
+
+let dd = 1.0 - oB;
+let cP = 1.0 - mB;
+let ot = dd * (
+0.0571085289 + dd * (
+0.491881867 + dd * (
+-0.332181442 + dd * 0.0714429953
 )
 )
 );
-let mZ = cP * (
+let nq = cP * (
 0.0571085289 + cP * (
 0.491881867 + cP * (
 -0.332181442 + cP * 0.0714429953
 )
 )
 );
-let pm = (1.0 + roughness * og)
-/ (1.0 + gS * roughness);
-let ou = (1.0 + roughness * mZ)
-/ (1.0 + gS * roughness);
-let fQ = ig * (1.0 + nX * roughness);
-let hB = color * color * fQ
-/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fQ));
-let ls = hB * INVPI
-* max(1e-7, 1.0 - ou)
-* max(1e-7, 1.0 - pm)
-/ max(1e-7, 1.0 - fQ);
+let pv = (1.0 + roughness * ot)
+/ (1.0 + gW * roughness);
+let oD = (1.0 + roughness * nq)
+/ (1.0 + gW * roughness);
+let fU = il * (1.0 + oj * roughness);
+let hF = color * color * fU
+/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fU));
+let lF = hF * INVPI
+* max(1e-7, 1.0 - oD)
+* max(1e-7, 1.0 - pv)
+/ max(1e-7, 1.0 - fU);
 *pdf = lightLocal.z * INVPI;
-return (ni + ls) * fo;
+return (nA + lF) * ft;
 }
 
 fn aO(viewCosine: f32, roughness: f32) -> f32 {
@@ -596,7 +596,7 @@ let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-fn jR(
+fn jY(
 material: J,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -628,17 +628,17 @@ return vec3f(0.0);
 }
 
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = gG(V, alpha);
-let jO = bk(viewLocal, alpha);
-let ea = jO
+let distribution = gK(V, alpha);
+let jV = bk(viewLocal, alpha);
+let ea = jV
 * bk(lightLocal, alpha);
 
-*pdf = jO * distribution / (4.0 * max(viewLocal.z, 1e-8));
+*pdf = jV * distribution / (4.0 * max(viewLocal.z, 1e-8));
 return cK * distribution * ea
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-fn dk(
+fn dl(
 material: J,
 relativeIor: f32,
 tint: vec3f,
@@ -653,27 +653,27 @@ if (lightLocal.z >= 0.0) {
 return vec3f(0.0);
 }
 
-let kC = dot(lightLocal, V);
+let kL = dot(lightLocal, V);
 let bQ = dot(viewLocal, V);
 
 
-if (bQ <= 0.0 || kC >= 0.0) {
+if (bQ <= 0.0 || kL >= 0.0) {
 return vec3f(0.0);
 }
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = gG(V, alpha);
-let jO = bk(viewLocal, alpha);
-let ea = jO
+let distribution = gK(V, alpha);
+let jV = bk(viewLocal, alpha);
+let ea = jV
 * bk(lightLocal, alpha);
-var ap = kC + bQ * relativeIor;
+var ap = kL + bQ * relativeIor;
 ap *= ap;
-let pr = abs(kC) / max(ap, 1e-8);
-let jo = relativeIor * relativeIor;
+let pJ = abs(kL) / max(ap, 1e-8);
+let ju = relativeIor * relativeIor;
 
-*pdf = jO * max(0.0, bQ) * distribution * pr
+*pdf = jV * max(0.0, bQ) * distribution * pJ
 / max(viewLocal.z, 1e-8);
 return tint * (vec3f(1.0) - cK) * distribution * ea
-* abs(bQ) * pr * jo
+* abs(bQ) * pJ * ju
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
@@ -692,11 +692,11 @@ fn aP(
 ah: vec3f,
 transmissionWeight: f32
 ) -> vec3f {
-let gg = 2.0 * ah
+let gk = 2.0 * ah
 / (vec3f(1.0) + ah);
 return mix(
 ah,
-gg,
+gk,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
@@ -710,17 +710,17 @@ let tint = bn(material);
 if (!material.thinWalled) {
 return tint;
 }
-let iG = max(0.0, 1.0 - L * L);
-let dN = iG
+let iL = max(0.0, 1.0 - L * L);
+let dO = iL
 / max(bu * bu, 1e-9);
-if (dN >= 1.0) {
+if (dO >= 1.0) {
 return vec3f(0.0);
 }
-let S = sqrt(1.0 - dN);
+let S = sqrt(1.0 - dO);
 return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(S, 1e-5)));
 }
 
-fn dL(
+fn dM(
 material: J,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -731,31 +731,31 @@ if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
 return vec3f(0.0);
 }
 let S = -lightLocal.z;
-let nU = cu(
+let og = cu(
 viewLocal.z,
 material.relativeIor
 );
 *pdf = S * INVPI;
-return vec3f(1.0 - nU) * INVPI;
+return vec3f(1.0 - og) * INVPI;
 }
 
-fn dQ(prepared: ptr<function, ag>) {
+fn dR(prepared: ptr<function, ag>) {
 
 
-let nu = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+let nJ = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
 var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];
-for (var hQ = 1; hQ < nu; hQ++) {
-total += (*prepared).probabilities[hQ];
+for (var hU = 1; hU < nJ; hU++) {
+total += (*prepared).probabilities[hU];
 }
 if (total <= 1e-8) {
-for (var hQ = 0; hQ < nu; hQ++) {
-(*prepared).probabilities[hQ] = 0.0;
+for (var hU = 0; hU < nJ; hU++) {
+(*prepared).probabilities[hU] = 0.0;
 }
 return;
 }
-let oj = 1.0 / total;
-for (var hQ = 0; hQ < nu; hQ++) {
-(*prepared).probabilities[hQ] *= oj;
+let ow = 1.0 / total;
+for (var hU = 0; hU < nJ; hU++) {
+(*prepared).probabilities[hU] *= ow;
 }
 }
 
@@ -768,9 +768,9 @@ return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * e
 }
 
 fn bP(f0: vec3f, tint: vec3f) -> vec3f {
-let dj = 1.0 / 7.0;
-let fF = mix(f0, vec3f(1.0), aE(dj));
-let b = fF * (vec3f(1.0) - tint) / (dj * pow(1.0 - dj, 6.0));
+let dk = 1.0 / 7.0;
+let fI = mix(f0, vec3f(1.0), aE(dk));
+let b = fI * (vec3f(1.0) - tint) / (dk * pow(1.0 - dk, 6.0));
 return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
 }
 
@@ -778,12 +778,12 @@ return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
 
 fn cD(material: J, au: f32) -> vec3f {
 if (au <= 0.0) { return vec3f(1.0); }
-let lu = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
-let tr = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lu, 1e-5)));
-return mix(vec3f(1.0), tr, material.coatWeight);
+let lH = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
+let tD = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lH, 1e-5)));
+return mix(vec3f(1.0), tD, material.coatWeight);
 }
 
-fn gj(material: J, au: f32) -> f32 {
+fn gp(material: J, au: f32) -> f32 {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
 return af(au, 1.0 / material.coatIor);
 }
@@ -793,34 +793,34 @@ return clamp(1.0 - aJ(material.coatIor,
 material.coatRoughness * material.coatRoughness, au), 0.0, 1.0);
 }
 
-fn gW(prepared: ag) -> vec3f {
+fn ha(prepared: ag) -> 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 tZ = dielectric * material.transmissionWeight;
-let fL = bM(prepared.specularEtaTOverEtaI);
-let kL = bM(1.0 / prepared.transmissionReflectionIor);
-let pJ = clamp(opaque * fL + (sss + tZ) * kL + material.baseMetalness, 0.0, 1.0);
-let jk = mix(1.0, material.specularRoughness, pJ);
+let ug = dielectric * material.transmissionWeight;
+let fO = bM(prepared.specularEtaTOverEtaI);
+let kU = bM(1.0 / prepared.transmissionReflectionIor);
+let pR = clamp(opaque * fO + (sss + ug) * kU + material.baseMetalness, 0.0, 1.0);
+let jp = mix(1.0, material.specularRoughness, pR);
 let ks = bM(material.coatIor);
 let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-let k = mix(ks, kr, jk);
+let k = mix(ks, kr, jp);
 let eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fL)
-+ sss * material.subsurfaceColor + vec3f(tZ);
-let qL = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
-return mix(vec3f(1.0), qL, material.coatWeight * material.coatDarkening);
++ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fO)
++ sss * material.subsurfaceColor + vec3f(ug);
+let qU = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
+return mix(vec3f(1.0), qU, material.coatWeight * material.coatDarkening);
 }
 
-fn ds(prepared: ag, lb: f32) -> vec3f {
+fn ds(prepared: ag, lm: f32) -> vec3f {
 if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }
 if (prepared.material.inside) {
 
-return cD(prepared.material, -lb);
+return cD(prepared.material, -lm);
 }
 
-return prepared.coatBaseScale * cD(prepared.material, lb);
+return prepared.coatBaseScale * cD(prepared.material, lm);
 }
 
 
@@ -840,7 +840,7 @@ return basis;
 }
 
 ` : /* wgsl */ ``}
-fn eG(
+fn eH(
 tangent: vec3f,
 material: J,
 bF: vec3f,
@@ -848,7 +848,7 @@ normal: vec3f
 ) -> ag {
 var prepared: ag;
 prepared.material = material;
-prepared.basis = fg(
+prepared.basis = fj(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -860,7 +860,7 @@ ${hasCoatNormals ? /* wgsl */ `
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fg(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = fj(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 ` : ''}
@@ -878,7 +878,7 @@ ${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(pre
 prepared.diffuseColor = material.baseColor;
 
 let cB = 1.0 - material.baseMetalness;
-let dK = cB
+let dL = cB
 * (1.0 - material.transmissionWeight);
 prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;
 prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;
@@ -887,9 +887,9 @@ prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;
 prepared.weights[OPENPBR_LOBE_SPECULAR] = cB;
 prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cB
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dK
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dL
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dK
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dL
 * material.subsurfaceWeight;
 
 prepared.specularEtaTOverEtaI = aY(
@@ -941,7 +941,7 @@ let ah = af(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-let ft = material.specularColor * select(
+let fw = material.specularColor * select(
 ah,
 mix(
 ah,
@@ -950,32 +950,32 @@ material.transmissionWeight
 ),
 material.thinWalled
 );
-let hR = material.specularWeight * dT(
+let hV = material.specularWeight * dU(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-let eL = select(
+let eO = select(
 af(viewCosine, prepared.transmissionReflectionIor),
 cS(af(viewCosine, prepared.transmissionReflectionIor)),
 material.thinWalled
 );
-let gJ = bG(
+let gN = bG(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-let il = aJ(
+let iu = aJ(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-let gm = cr(
+let gr = cr(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = il
-/ max(gm, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iu
+/ max(gr, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
 * aw(material.fuzzColor)
@@ -987,32 +987,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 kt = gj(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kt;
+let kB = gp(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kB;
 prepared.coatBaseScale = cD(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kt) * gW(prepared);
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kB) * ha(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aw(hR);
+* aw(hV);
 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 hH = bP(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * hH * hH;
-let pN = bH(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = pN / max(cv(prepared.specularAlpha), 1e-12);
-let ff = prepared.weights[OPENPBR_LOBE_METAL] * aw(prepared.metalMsScale) * pN;
-prepared.probabilities[OPENPBR_LOBE_METAL] += ff;
-prepared.metalMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+let hL = bP(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * hL * hL;
+let pV = bH(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = pV / max(cv(prepared.specularAlpha), 1e-12);
+let fi = prepared.weights[OPENPBR_LOBE_METAL] * aw(prepared.metalMsScale) * pV;
+prepared.probabilities[OPENPBR_LOBE_METAL] += fi;
+prepared.metalMsProbability = fi / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aw(ft);
+* aw(fw);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eL)
-* aw(gJ);
+* (1.0 - eO)
+* aw(gN);
 
 
 
@@ -1027,40 +1027,40 @@ 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 lt = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lt;
-prepared.dielectricMsTransmissionScale = gJ * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+let lG = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lG;
+prepared.dielectricMsTransmissionScale = gN * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
 prepared.dielectricMsReflectionRatio = ch(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
 prepared.dielectricMsViewLoss = bO(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-let nL = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-let ff = aw(nL) * prepared.dielectricMsViewLoss;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += ff;
-prepared.dielectricMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+let nW = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+let fi = aw(nW) * prepared.dielectricMsViewLoss;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fi;
+prepared.dielectricMsProbability = fi / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
 * aw(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eL)
+* (1.0 - eO)
 * aw(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
 if (material.coatWeight > 0.0 && HAS_THIN_FILM && material.thinFilmWeight > 0.0) {
-let kZ = 0.02 * bN(material.thinFilmThickness, material.thinFilmWeight);
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * kZ);
-prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * kZ);
+let lj = 0.02 * bN(material.thinFilmThickness, material.thinFilmWeight);
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * lj);
+prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * lj);
 }
 if (material.coatWeight > 0.0 && !material.inside) {
-let gn = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
-prepared.probabilities[OPENPBR_LOBE_METAL] *= gn;
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gn;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gn;
-prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gn;
-prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gn;
-}
-dQ(&prepared);
+let gs = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
+prepared.probabilities[OPENPBR_LOBE_METAL] *= gs;
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gs;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gs;
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gs;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gs;
+}
+dR(&prepared);
 return prepared;
 }
 
@@ -1069,17 +1069,17 @@ fn cR(prepared: ag, au: f32, reflection: bool) -> f32 {
 if (prepared.material.coatWeight <= 0.0) {
 return af(au, prepared.material.relativeIor);
 }
-let ki = af(au, prepared.transmissionReflectionIor);
-if (!reflection) { return ki; }
-let mX = af(au, 1.0 / prepared.specularEtaTOverEtaI);
-let rH = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(mX, ki, rH);
+let kp = af(au, prepared.transmissionReflectionIor);
+if (!reflection) { return kp; }
+let nl = af(au, 1.0 / prepared.specularEtaTOverEtaI);
+let rP = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(nl, kp, rP);
 }
 
-fn mu(
+fn mE(
 prepared: ag,
 lightDirection: vec3f,
-gK: i32,
+gO: i32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 let material = prepared.material;
@@ -1107,58 +1107,58 @@ V = -V;
 var response = vec3f(0.0);
 *pdf = 0.0;
 var aI = 0.0;
-let lT = gK < 0;
-let uG = lT || gK == OPENPBR_LOBE_FUZZ;
-let sV = lT || gK == OPENPBR_LOBE_COAT;
-let rY = lT || gK == OPENPBR_LOBE_METAL;
-let pX = lT || gK == OPENPBR_LOBE_SPECULAR;
-let jB = lT ||
-gK == OPENPBR_LOBE_TRANSMISSION;
-let ta = lT || gK == OPENPBR_LOBE_DIFFUSE;
-let oL = lT ||
-gK == OPENPBR_LOBE_SUBSURFACE;
+let mf = gO < 0;
+let uN = mf || gO == OPENPBR_LOBE_FUZZ;
+let tc = mf || gO == OPENPBR_LOBE_COAT;
+let sg = mf || gO == OPENPBR_LOBE_METAL;
+let qf = mf || gO == OPENPBR_LOBE_SPECULAR;
+let jG = mf ||
+gO == OPENPBR_LOBE_TRANSMISSION;
+let th = mf || gO == OPENPBR_LOBE_DIFFUSE;
+let oU = mf ||
+gO == OPENPBR_LOBE_SUBSURFACE;
 let bQ = abs(dot(viewLocal, V));
 
 
 
-var dd = V;
-var ji = bQ;
+var df = V;
+var jn = bQ;
 if (!reflection && material.thinWalled) {
-dd = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
-if (dd.z < 0.0) { dd = -dd; }
-ji = abs(dot(viewLocal, dd));
+df = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
+if (df.z < 0.0) { df = -df; }
+jn = abs(dot(viewLocal, df));
 }
-let me =
-(reflection && prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && pX) ||
-(!reflection && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jB);
-let qb = reflection && prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && rY;
-var np: array<vec3f, 2>;
-if (me) {
-np[0] = vec3f(cR(prepared, ji, reflection));
+let mp =
+(reflection && prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && qf) ||
+(!reflection && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jG);
+let qj = reflection && prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && sg;
+var nE: array<vec3f, 2>;
+if (mp) {
+nE[0] = vec3f(cR(prepared, jn, reflection));
 }
-if (qb) {
-np[1] = dT(bQ, material.baseWeight * material.baseColor, material.specularColor);
+if (qj) {
+nE[1] = dU(bQ, material.baseWeight * material.baseColor, material.specularColor);
 }
 if (HAS_THIN_FILM && material.thinFilmWeight > 0.0) {
 let wavelengths = vec3f(620.0, 540.0, 450.0);
 
-for (var kK = 0u; kK < (rtUniform.loopUnrollGuard >> 1u); kK++) {
-if (!select(me, qb, kK == 1u)) { continue; }
-var wi = vec3f(0.0);
-let L = select(ji, bQ, kK == 1u);
+for (var kT = 0u; kT < (rtUniform.loopUnrollGuard >> 1u); kT++) {
+if (!select(mp, qj, kT == 1u)) { continue; }
+var wp = vec3f(0.0);
+let L = select(jn, bQ, kT == 1u);
 for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
 var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
-if (kK == 1u) {
+if (kT == 1u) {
 ior = cQ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
 }
-wi[channel] = ar(L,
+wp[channel] = ar(L,
 wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
 }
-np[kK] = mix(np[kK], wi,
+nE[kT] = mix(nE[kT], wp,
 bN(material.thinFilmThickness, material.thinFilmWeight));
 }
 }
-let ei = np[0];
+let ei = nE[0];
 let diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
 * aJ(
@@ -1172,7 +1172,7 @@ ${hasCoatNormals ? /* wgsl */ `
 if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflection)) {
 ` : ''}
 if (reflection) {
-if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0 && ta) {
+if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0 && th) {
 response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cE(
 material,
 prepared.diffuseColor,
@@ -1185,7 +1185,7 @@ diffuseSpecularEnergyCompensation,
 }
 
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled &&
-oL) {
+oU) {
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cE(
 material,
 material.subsurfaceColor,
@@ -1197,7 +1197,7 @@ diffuseSpecularEnergyCompensation,
 *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aI;
 }
 
-if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && pX) {
+if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && qf) {
 var ct = ei;
 if (material.thinWalled) {
 ct = aP(
@@ -1217,8 +1217,8 @@ cK,
 *pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aI;
 }
 
-if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && rY) {
-let cK = material.specularWeight * np[1];
+if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && sg) {
+let cK = material.specularWeight * nE[1];
 response += prepared.weights[OPENPBR_LOBE_METAL] * am(
 material,
 viewLocal,
@@ -1237,10 +1237,10 @@ aI = mix(aI, 0.5 * INVPI, prepared.metalMsProbability);
 }
 else {
 let cK = ei;
-if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jB) {
+if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jG) {
 if (material.thinWalled) {
-let kP = vec3f(lightLocal.xy, -lightLocal.z);
-let gg = aP(
+let kY = vec3f(lightLocal.xy, -lightLocal.z);
+let gk = aP(
 ei,
 1.0
 );
@@ -1253,15 +1253,15 @@ response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 * am(
 material,
 viewLocal,
-kP,
-dd,
-tint * (vec3f(1.0) - gg),
+kY,
+df,
+tint * (vec3f(1.0) - gk),
 &aI
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dk(
+* dl(
 material,
 material.relativeIor,
 bn(material),
@@ -1277,22 +1277,22 @@ aI *= 1.0 - prepared.dielectricMsProbability;
 }
 *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aI;
 }
-if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && oL) {
+if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && oU) {
 if (material.thinWalled) {
-let nW = vec3f(lightLocal.xy, -lightLocal.z);
+let oi = vec3f(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
 * cE(
 material,
 material.subsurfaceColor,
 viewLocal,
-nW,
+oi,
 diffuseSpecularEnergyCompensation,
 &aI
 );
 aI *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dL(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dM(
 material,
 viewLocal,
 lightLocal,
@@ -1306,17 +1306,17 @@ lightLocal,
 
 
 
-if (prepared.dielectricMsProbability > 0.0 && jB) {
+if (prepared.dielectricMsProbability > 0.0 && jG) {
 let au = abs(lightLocal.z);
 if (au > 0.0) {
 let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);
-let iV = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
-let tj = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
+let ja = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
+let tr = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
 / max(cO(ior, prepared.specularAlpha), 1e-12);
-let dW = min(tj * iV, 1.0 / au);
+let dW = min(tr * ja, 1.0 / au);
 let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);
 response += scale * dW * INVPI;
-*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iV * 0.5 * INVPI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ja * 0.5 * INVPI;
 }
 }
 
@@ -1331,33 +1331,33 @@ if (independentCoat) { response *= abs(lightLocal.z); }
 
 ${hasAnisotropyDirections ? /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-var dH = viewLocal;
-var kv = lightLocal;
-var gr = V;
-var jF = bQ;
+var dI = viewLocal;
+var kD = lightLocal;
+var gv = V;
+var jK = bQ;
 if (prepared.directionFrames) {
-dH = ${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))'};
-kv = openpbr_to_local(prepared.coatBasis, lightDirection);
-gr = normalize(kv + dH);
-if (gr.z < 0.0) { gr = -gr; }
-jF = abs(dot(dH, gr));
+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))'};
+kD = openpbr_to_local(prepared.coatBasis, lightDirection);
+gv = normalize(kD + dI);
+if (gv.z < 0.0) { gv = -gv; }
+jK = abs(dot(dI, gv));
 }
 
-let kX = vec3f(af(
-jF,
+let lg = vec3f(af(
+jK,
 1.0 / material.coatIor
 ));
-var dG = material;
-let jr = aK(material.coatRoughness, material.coatAnisotropy);
-dG.alphaX = jr.x;
-dG.alphaY = jr.y;
-if (sV) {
+var dH = material;
+let jx = aK(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = jx.x;
+dH.alphaY = jx.y;
+if (tc) {
 response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
-dG,
 dH,
-kv,
-gr,
-kX,
+dI,
+kD,
+gv,
+lg,
 &aI
 );
 *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
@@ -1365,21 +1365,21 @@ kX,
 }
 ` : /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-let kX = vec3f(af(
+let lg = vec3f(af(
 bQ,
 1.0 / material.coatIor
 ));
-var dG = material;
-let jr = aK(material.coatRoughness, material.coatAnisotropy);
-dG.alphaX = jr.x;
-dG.alphaY = jr.y;
-if (sV) {
+var dH = material;
+let jx = aK(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = jx.x;
+dH.alphaY = jx.y;
+if (tc) {
 response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
-dG,
+dH,
 viewLocal,
 lightLocal,
 V,
-kX,
+lg,
 &aI
 );
 *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
@@ -1388,16 +1388,16 @@ kX,
 `}
 
 if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-let qr = aO(
+let qz = aO(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3f(0.0),
-vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qr)
+vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qz)
 );
-if (uG) {
-response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * jR(
+if (uN) {
+response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * jY(
 material,
 viewLocal,
 lightLocal,
@@ -1415,14 +1415,14 @@ prepared: ag,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-return mu(prepared, lightDirection, -1, pdf);
+return mE(prepared, lightDirection, -1, pdf);
 }
 
 
 
 
 
-fn qY(
+fn ri(
 tangent: vec3f,
 material: J,
 bF: vec3f,
@@ -1430,7 +1430,7 @@ normal: vec3f,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = eG(
+let prepared = eH(
 tangent,
 material,
 bF,
@@ -1443,29 +1443,29 @@ return bI(prepared, lightDirection, pdf);
 
 
 
-fn mY(
+fn np(
 prepared: ag, cm: vec3f,
 lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,
-aA: ptr<function, f32>, aT: ptr<function, bool>,
+aA: ptr<function, f32>, aS: ptr<function, bool>,
 bE: ptr<function, bool>, aR: ptr<function, u32>
 ) -> bool {
 let material = prepared.material;
 let viewLocal = prepared.viewLocal;
 var cy = cm.x;
-let fp = cm.y;
+let fu = cm.y;
 let bm = cm.z;
 *isTransmissionEvent = false;
 *aA = 1.0;
-*aT = false;
+*aS = false;
 *bE = false;
 *aR = u32(OPENPBR_LOBE_DIFFUSE);
 *lightDirection = prepared.basis.normal;
 
 var cdf: array<f32, OPENPBR_LOBE_COUNT>;
 cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-let nu = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
-for (var hQ = 1; hQ < nu; hQ++) {
-cdf[hQ] = cdf[hQ - 1] + prepared.probabilities[hQ];
+let nJ = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+for (var hU = 1; hU < nJ; hU++) {
+cdf[hU] = cdf[hU - 1] + prepared.probabilities[hU];
 }
 if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {
 return false;
@@ -1475,37 +1475,37 @@ var lightLocal: vec3f;
 if (bm < cdf[OPENPBR_LOBE_FUZZ] || (
 bm >= cdf[OPENPBR_LOBE_TRANSMISSION] && bm < cdf[OPENPBR_LOBE_DIFFUSE]
 )) {
-let pI = bm < cdf[OPENPBR_LOBE_FUZZ];
+let pQ = bm < cdf[OPENPBR_LOBE_FUZZ];
 *aA = select(
 1.0,
 material.fuzzRoughness,
-pI
+pQ
 );
-*bE = !pI;
+*bE = !pQ;
 *aR = select(
 u32(OPENPBR_LOBE_DIFFUSE),
 u32(OPENPBR_LOBE_FUZZ),
-pI
+pQ
 );
-lightLocal = bi(vec2f(cy, fp));
+lightLocal = bi(vec2f(cy, fu));
 }
 ${hasAnisotropyDirections ? /* wgsl */ `
 else if (bm < cdf[OPENPBR_LOBE_COAT]) {
 *aA = material.coatRoughness;
-*aT = true;
+*aS = true;
 *aR = u32(OPENPBR_LOBE_COAT);
-var dH = viewLocal;
-if (prepared.directionFrames) { dH = ${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 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 V = aQ(
-dH,
+dI,
 
 aK(material.coatRoughness, material.coatAnisotropy),
-vec2f(cy, fp)
+vec2f(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
 }
-lightLocal = normalize(reflect(-dH, V));
+lightLocal = normalize(reflect(-dI, V));
 ${hasCoatNormals ? /* wgsl */ `
 if (material.coatNormalEnabled) {
 
@@ -1518,13 +1518,13 @@ if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, op
 ` : /* wgsl */ `
 else if (bm < cdf[OPENPBR_LOBE_COAT]) {
 *aA = material.coatRoughness;
-*aT = true;
+*aS = true;
 *aR = u32(OPENPBR_LOBE_COAT);
 var V = aQ(
 viewLocal,
 
 aK(material.coatRoughness, material.coatAnisotropy),
-vec2f(cy, fp)
+vec2f(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
@@ -1534,25 +1534,25 @@ lightLocal = normalize(reflect(-viewLocal, V));
 `}
 else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
 *aA = material.specularRoughness;
-*aT = true;
+*aS = true;
 *aR = select(
 u32(OPENPBR_LOBE_SPECULAR),
 u32(OPENPBR_LOBE_METAL),
 bm < cdf[OPENPBR_LOBE_METAL]
 );
-let tm = bm < cdf[OPENPBR_LOBE_METAL];
-let rE = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (tm && rE < prepared.metalMsProbability) {
+let tw = bm < cdf[OPENPBR_LOBE_METAL];
+let rM = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (tw && rM < prepared.metalMsProbability) {
 let z = cy;
-let fi = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * fp;
-lightLocal = vec3f(fi * cos(br), fi * sin(br), z);
+let fl = sqrt(max(0.0, 1.0 - z * z));
+let br = TWOPI * fu;
+lightLocal = vec3f(fl * cos(br), fl * sin(br), z);
 }
 else {
 var V = aQ(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cy, fp)
+vec2f(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
@@ -1562,36 +1562,36 @@ lightLocal = normalize(reflect(-viewLocal, V));
 }
 else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 *aA = material.specularRoughness;
-*aT = true;
+*aS = true;
 *isTransmissionEvent = true;
 *aR = u32(OPENPBR_LOBE_TRANSMISSION);
 
 
-let uk = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && uk < prepared.dielectricMsProbability) {
-let iV = prepared.dielectricMsReflectionRatio;
-let lP = cy < iV;
+let us = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && us < prepared.dielectricMsProbability) {
+let ja = prepared.dielectricMsReflectionRatio;
+let lZ = cy < ja;
 var z: f32;
-if (lP) { z = min(cy / iV, 0.99999994); }
-else { z = -min((cy - iV) / (1.0 - iV), 0.99999994); }
-let fi = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * fp;
-lightLocal = vec3f(fi * cos(br), fi * sin(br), z);
-*isTransmissionEvent = !lP;
-*aR = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), lP);
+if (lZ) { z = min(cy / ja, 0.99999994); }
+else { z = -min((cy - ja) / (1.0 - ja), 0.99999994); }
+let fl = sqrt(max(0.0, 1.0 - z * z));
+let br = TWOPI * fu;
+lightLocal = vec3f(fl * cos(br), fl * sin(br), z);
+*isTransmissionEvent = !lZ;
+*aR = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), lZ);
 }
 else {
 var V = aQ(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cy, fp)
+vec2f(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
 }
 if (material.thinWalled) {
-let hV = normalize(reflect(-viewLocal, V));
-lightLocal = vec3f(hV.xy, -hV.z);
+let hZ = normalize(reflect(-viewLocal, V));
+lightLocal = vec3f(hZ.xy, -hZ.z);
 }
 else {
 lightLocal = refract(
@@ -1613,15 +1613,15 @@ else {
 *isTransmissionEvent = true;
 *aR = u32(OPENPBR_LOBE_SUBSURFACE);
 if (material.thinWalled) {
-let pL = cy >= 0.5;
-if (pL) {
+let pT = cy >= 0.5;
+if (pT) {
 cy = (cy - 0.5) * 2.0;
 }
 else {
 cy *= 2.0;
 }
-lightLocal = bi(vec2f(cy, fp));
-if (pL) {
+lightLocal = bi(vec2f(cy, fu));
+if (pT) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1629,7 +1629,7 @@ else {
 }
 }
 else {
-lightLocal = bi(vec2f(cy, fp));
+lightLocal = bi(vec2f(cy, fu));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1655,15 +1655,15 @@ lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
 aA: ptr<function, f32>,
-aT: ptr<function, bool>,
+aS: ptr<function, bool>,
 bE: ptr<function, bool>,
 aR: ptr<function, u32>,
-ld: ptr<function, f32>,
-gT: ptr<function, vec3f>
+lo: ptr<function, f32>,
+gX: ptr<function, vec3f>
 ) -> vec3f {
 *pdf = 0.0;
-*ld = 0.0;
-*gT = vec3f(0.0);
+*lo = 0.0;
+*gX = vec3f(0.0);
 
 
 
@@ -1675,28 +1675,28 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6) {
 prepared.basis,
 -prepared.viewLocal
 );
-let nB = bn(prepared.material)
+let nM = bn(prepared.material)
 * ds(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
 *pdf = 1.0;
-*ld = 1.0;
-*gT = nB;
+*lo = 1.0;
+*gX = nM;
 *isTransmissionEvent = true;
 *aA = 0.0;
-*aT = true;
+*aS = true;
 *bE = false;
 *aR = u32(OPENPBR_LOBE_TRANSMISSION);
-return nB;
+return nM;
 }
-if (!mY(prepared, cm, lightDirection,
-isTransmissionEvent, aA, aT,
+if (!np(prepared, cm, lightDirection,
+isTransmissionEvent, aA, aS,
 bE, aR)) { return vec3f(0.0); }
 let response = bI(prepared, *lightDirection, pdf);
-*ld = *pdf;
-*gT = response;
+*lo = *pdf;
+*gX = response;
 return response;
 }
 
-fn sB(
+fn sJ(
 tangent: vec3f,
 material: J,
 cm: vec3f,
@@ -1706,18 +1706,18 @@ lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
 aA: ptr<function, f32>,
-aT: ptr<function, bool>,
+aS: ptr<function, bool>,
 bE: ptr<function, bool>,
 aR: ptr<function, u32>,
-ld: ptr<function, f32>
+lo: ptr<function, f32>
 ) -> vec3f {
-let prepared = eG(
+let prepared = eH(
 tangent,
 material,
 bF,
 normal
 );
-var gT = vec3f(0.0);
+var gX = vec3f(0.0);
 return dv(
 prepared,
 cm,
@@ -1725,11 +1725,11 @@ lightDirection,
 pdf,
 isTransmissionEvent,
 aA,
-aT,
+aS,
 bE,
 aR,
-ld,
-&gT
+lo,
+&gX
 );
 }`;
 }