@meimu/mutracer 0.1.2 → 0.1.4

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

@@ -77,20 +77,20 @@ float aY(
 float bu,
 float specularWeight
 ) {
-float sE = min(
+float sR = min(
 cV(bu) * specularWeight,
 0.9999
 );
-float sG = sqrt(sE);
-float kV = (1.0 + sG) / (1.0 - sG);
-return bu < 1.0 ? 1.0 / kV : kV;
+float sT = sqrt(sR);
+float lh = (1.0 + sT) / (1.0 - sT);
+return bu < 1.0 ? 1.0 / lh : lh;
 }
 
 float af(float cc, float relativeIor) {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return ct(cc, relativeIor);
+return cu(cc, relativeIor);
 }
 
 float aC(float ior) {
@@ -100,143 +100,143 @@ return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;
 return 16.0 + ((ior - 1.0) / 1.5) * 15.0;
 }
 
-float F(int rX, int row) {
-return texelFetch(openPbrEnergyLut, ivec2(rX, row), 0).r;
+float F(int sl, int row) {
+return texelFetch(openPbrEnergyLut, ivec2(sl, row), 0).r;
 }
 
-float fY(
-float dI,
+float gd(
+float dJ,
 float bR,
-float hO
+float hR
 ) {
-float bA = clamp(dI, 0.0, 31.0);
-float aG = clamp(bR, 0.0, 31.0);
-float bt = clamp(hO, 0.0, 31.0);
-int dP = int(floor(bA));
-int aM = int(floor(aG));
+float bA = clamp(dJ, 0.0, 31.0);
+float aH = clamp(bR, 0.0, 31.0);
+float bt = clamp(hR, 0.0, 31.0);
+int dQ = int(floor(bA));
+int aN = int(floor(aH));
 int cI = int(floor(bt));
-int hB = min(dP + 1, 31);
-int cn = min(aM + 1, 31);
-int eO = min(cI + 1, 31);
-float cp = bA - float(dP);
-float cy = aG - float(aM);
-float ku = bt - float(cI);
-
-float ul = F(cI, dP * 32 + aM);
-float um = F(eO, dP * 32 + aM);
-float un = F(cI, dP * 32 + cn);
-float uo = F(eO, dP * 32 + cn);
-float uq = F(cI, hB * 32 + aM);
-float ur = F(eO, hB * 32 + aM);
-float us = F(cI, hB * 32 + cn);
-float ut = F(eO, hB * 32 + cn);
-float v00 = mix(ul, uq, cp);
-float v01 = mix(um, ur, cp);
-float v10 = mix(un, us, cp);
-float v11 = mix(uo, ut, cp);
+int hE = min(dQ + 1, 31);
+int cp = min(aN + 1, 31);
+int eR = min(cI + 1, 31);
+float cq = bA - float(dQ);
+float cz = aH - float(aN);
+float kE = bt - float(cI);
+
+float uA = F(cI, dQ * 32 + aN);
+float uB = F(eR, dQ * 32 + aN);
+float uC = F(cI, dQ * 32 + cp);
+float uD = F(eR, dQ * 32 + cp);
+float uE = F(cI, hE * 32 + aN);
+float uF = F(eR, hE * 32 + aN);
+float uG = F(cI, hE * 32 + cp);
+float uH = F(eR, hE * 32 + cp);
+float v00 = mix(uA, uE, cq);
+float v01 = mix(uB, uF, cq);
+float v10 = mix(uC, uG, cq);
+float v11 = mix(uD, uH, cq);
 return mix(
-mix(v00, v10, cy),
-mix(v01, v11, cy),
-ku
-);
-}
-
-float gx(float dI, float bR) {
-float bA = clamp(dI, 0.0, 31.0);
-float aG = clamp(bR, 0.0, 31.0);
-int dP = int(floor(bA));
-int aM = int(floor(aG));
-int hB = min(dP + 1, 31);
-int cn = min(aM + 1, 31);
-float cp = bA - float(dP);
-float cy = aG - float(aM);
-float v00 = F(aM, 1024 + dP);
-float v01 = F(cn, 1024 + dP);
-float v10 = F(aM, 1024 + hB);
-float v11 = F(cn, 1024 + hB);
+mix(v00, v10, cz),
+mix(v01, v11, cz),
+kE
+);
+}
+
+float gF(float dJ, float bR) {
+float bA = clamp(dJ, 0.0, 31.0);
+float aH = clamp(bR, 0.0, 31.0);
+int dQ = int(floor(bA));
+int aN = int(floor(aH));
+int hE = min(dQ + 1, 31);
+int cp = min(aN + 1, 31);
+float cq = bA - float(dQ);
+float cz = aH - float(aN);
+float v00 = F(aN, 1024 + dQ);
+float v01 = F(cp, 1024 + dQ);
+float v10 = F(aN, 1024 + hE);
+float v11 = F(cp, 1024 + hE);
 return mix(
-mix(v00, v10, cp),
-mix(v01, v11, cp),
-cy
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+cz
 );
 }
 
 
 
 float ef(
-float dI,
+float dJ,
 float bR,
-float hO
+float hR
 ) {
-float bA = clamp(dI, 0.0, 31.0);
-float aG = clamp(bR, 0.0, 31.0);
-float bt = clamp(hO, 0.0, 31.0);
-int dP = int(floor(bA));
-int aM = int(floor(aG));
+float bA = clamp(dJ, 0.0, 31.0);
+float aH = clamp(bR, 0.0, 31.0);
+float bt = clamp(hR, 0.0, 31.0);
+int dQ = int(floor(bA));
+int aN = int(floor(aH));
 int cI = int(floor(bt));
-int hB = min(dP + 1, 31);
-int cn = min(aM + 1, 31);
-int eO = min(cI + 1, 31);
-float cp = bA - float(dP);
-float cy = aG - float(aM);
-float ku = bt - float(cI);
-
-float ul = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-float um = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-float un = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-float uo = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-float uq = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-float ur = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-float us = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-float ut = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-float v00 = mix(ul, uq, cp);
-float v01 = mix(um, ur, cp);
-float v10 = mix(un, us, cp);
-float v11 = mix(uo, ut, cp);
+int hE = min(dQ + 1, 31);
+int cp = min(aN + 1, 31);
+int eR = min(cI + 1, 31);
+float cq = bA - float(dQ);
+float cz = aH - float(aN);
+float kE = bt - float(cI);
+
+float uA = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
+float uB = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
+float uC = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
+float uD = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
+float uE = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
+float uF = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
+float uG = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
+float uH = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
+float v00 = mix(uA, uE, cq);
+float v01 = mix(uB, uF, cq);
+float v10 = mix(uC, uG, cq);
+float v11 = mix(uD, uH, cq);
 return mix(
-mix(v00, v10, cy),
-mix(v01, v11, cy),
-ku
-);
-}
-
-float ee(float dI, float bR) {
-float bA = clamp(dI, 0.0, 31.0);
-float aG = clamp(bR, 0.0, 31.0);
-int dP = int(floor(bA));
-int aM = int(floor(aG));
-int hB = min(dP + 1, 31);
-int cn = min(aM + 1, 31);
-float cp = bA - float(dP);
-float cy = aG - float(aM);
-float v00 = F(aM, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-float v01 = F(cn, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-float v10 = F(aM, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
-float v11 = F(cn, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+mix(v00, v10, cz),
+mix(v01, v11, cz),
+kE
+);
+}
+
+float ee(float dJ, float bR) {
+float bA = clamp(dJ, 0.0, 31.0);
+float aH = clamp(bR, 0.0, 31.0);
+int dQ = int(floor(bA));
+int aN = int(floor(aH));
+int hE = min(dQ + 1, 31);
+int cp = min(aN + 1, 31);
+float cq = bA - float(dQ);
+float cz = aH - float(aN);
+float v00 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
+float v01 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
+float v10 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
+float v11 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
 return mix(
-mix(v00, v10, cp),
-mix(v01, v11, cp),
-cy
-);
-}
-
-float eF(float dI, float bR) {
-float bA = clamp(dI, 0.0, 31.0);
-float aG = clamp(bR, 0.0, 31.0);
-int dP = int(floor(bA));
-int aM = int(floor(aG));
-int hB = min(dP + 1, 31);
-int cn = min(aM + 1, 31);
-float cp = bA - float(dP);
-float cy = aG - float(aM);
-float v00 = F(aM, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-float v01 = F(cn, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-float v10 = F(aM, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
-float v11 = F(cn, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+cz
+);
+}
+
+float eG(float dJ, float bR) {
+float bA = clamp(dJ, 0.0, 31.0);
+float aH = clamp(bR, 0.0, 31.0);
+int dQ = int(floor(bA));
+int aN = int(floor(aH));
+int hE = min(dQ + 1, 31);
+int cp = min(aN + 1, 31);
+float cq = bA - float(dQ);
+float cz = aH - float(aN);
+float v00 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
+float v01 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
+float v10 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
+float v11 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
 return mix(
-mix(v00, v10, cp),
-mix(v01, v11, cp),
-cy
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+cz
 );
 }
 
@@ -247,24 +247,24 @@ float cO(float ior, float alpha) {
 return ee(aC(ior), sqrt(alpha) * 31.0);
 }
 float ch(float ior, float alpha) {
-return eF(aC(ior), sqrt(alpha) * 31.0);
+return eG(aC(ior), sqrt(alpha) * 31.0);
 }
 
 
 float bH(float alpha, float au) {
-float ia = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+float ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
 float bt = clamp(au * 31.0, 0.0, 31.0);
-int r0 = int(floor(ia));
+int r0 = int(floor(ie));
 int c0 = int(floor(bt));
 int r1 = min(r0 + 1, 31);
 int 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(ia));
+fract(ie));
 }
 
-float cu(float alpha) {
+float cv(float alpha) {
 float index = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
 int i0 = int(floor(index));
 return mix(F(i0, ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}),
@@ -273,19 +273,19 @@ F(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));
 
 float aX(float value, float ior) {
 if (ior > 2.5 || ior < 0.4) {
-float tI = cV(2.5);
-float progress = (cV(ior) - tI) / (1.0 - tI);
+float tU = cV(2.5);
+float progress = (cV(ior) - tU) / (1.0 - tU);
 return (1.0 - progress) * value;
 }
 return value;
 }
 
-float aI(
+float aJ(
 float ior,
 float alpha,
 float au
 ) {
-float value = fY(
+float value = gd(
 aC(ior),
 sqrt(alpha) * 31.0,
 au * 31.0
@@ -293,8 +293,8 @@ au * 31.0
 return aX(value, ior);
 }
 
-float cq(float ior, float alpha) {
-float value = gx(
+float cr(float ior, float alpha) {
+float value = gF(
 aC(ior),
 sqrt(alpha) * 31.0
 );
@@ -315,8 +315,8 @@ dot(direction, basis.normal)
 );
 }
 
-bj fg(
-vec3 aU,
+bj fj(
+vec3 aT,
 vec3 normal,
 float anisotropy
 ) {
@@ -324,10 +324,10 @@ bj basis;
 basis.normal = normal;
 basis.tangent = vec3(0.0);
 #ifdef USE_TANGENT
-basis.tangent = aU;
+basis.tangent = aT;
 #endif
 if (dot(basis.tangent, basis.tangent) < 0.001 || anisotropy <= 0.0) {
-aK(normal, basis.tangent, basis.bitangent);
+aL(normal, basis.tangent, basis.bitangent);
 }
 else {
 basis.bitangent = normalize(cross(normal, basis.tangent));
@@ -336,7 +336,7 @@ basis.tangent = normalize(cross(basis.bitangent, normal));
 return basis;
 }
 
-float jR(
+float ka(
 float av,
 float ak,
 float L,
@@ -346,7 +346,7 @@ return (av * L - ak * S)
 / (av * L + ak * S);
 }
 
-float jQ(
+float jZ(
 float av,
 float ak,
 float L,
@@ -356,7 +356,7 @@ return (ak * L - av * S)
 / (av * S + ak * L);
 }
 
-float gX(
+float hc(
 float av,
 float ak,
 float L,
@@ -366,7 +366,7 @@ return 2.0 * av * L
 / (av * L + ak * S);
 }
 
-float gW(
+float hb(
 float av,
 float ak,
 float L,
@@ -376,7 +376,7 @@ return 2.0 * av * L
 / (av * S + ak * L);
 }
 
-vec2 aV(vec2 a, vec2 b) {
+vec2 aU(vec2 a, vec2 b) {
 return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
@@ -388,32 +388,32 @@ return vec2(
 );
 }
 
-vec2 hU(vec2 value) {
-float ns = length(value);
-float sC = sqrt(max(0.0, 0.5 * (ns + value.x)));
-float fc = sqrt(max(0.0, 0.5 * (ns - value.x)));
-return vec2(sC, value.y >= 0.0 ? fc : -fc);
+vec2 hX(vec2 value) {
+float nK = length(value);
+float sP = sqrt(max(0.0, 0.5 * (nK + value.x)));
+float ff = sqrt(max(0.0, 0.5 * (nK - value.x)));
+return vec2(sP, value.y >= 0.0 ? ff : -ff);
 }
 
 vec2 bX(
 float L,
 float av,
 vec2 ak,
-bool qu
+bool qG
 ) {
-float ob = sqrt(max(0.0, 1.0 - L * L));
-vec2 sj = aZ(vec2(av, 0.0), ak);
-vec2 hw = sj * ob;
-vec2 S = hU(
-vec2(1.0, 0.0) - aV(hw, hw)
+float os = sqrt(max(0.0, 1.0 - L * L));
+vec2 sA = aZ(vec2(av, 0.0), ak);
+vec2 hA = sA * os;
+vec2 S = hX(
+vec2(1.0, 0.0) - aU(hA, hA)
 );
-if (aV(ak, S).y < 0.0) {
+if (aU(ak, S).y < 0.0) {
 S = -S;
 }
 
-vec2 fH = vec2(av * L, 0.0);
-vec2 eA = aV(ak, S);
-if (qu) {
+vec2 fK = vec2(av * L, 0.0);
+vec2 eB = aU(ak, S);
+if (qG) {
 vec2 ci = ak * L;
 vec2 ce = S * av;
 return aZ(
@@ -422,224 +422,224 @@ ci + ce
 );
 }
 return aZ(
-fH - eA,
-fH + eA
+fK - eB,
+fK + eB
 );
 }
 
 float eq(
-float iD,
-float gG,
-float ov,
-float mA,
-vec2 jW,
+float iH,
+float gM,
+float oH,
+float mN,
+vec2 kf,
 float phase
 ) {
-vec2 mX = vec2(cos(phase), sin(phase));
-vec2 hX = aV(jW, mX);
-vec2 kC = hX * (gG * mA);
-vec2 ap = vec2(1.0, 0.0) - hX * ov;
-vec2 hv = vec2(iD, 0.0)
-+ aZ(kC, ap);
-return dot(hv, hv);
+vec2 nr = vec2(cos(phase), sin(phase));
+vec2 ia = aU(kf, nr);
+vec2 kO = ia * (gM * mN);
+vec2 ap = vec2(1.0, 0.0) - ia * oH;
+vec2 hz = vec2(iH, 0.0)
++ aZ(kO, ap);
+return dot(hz, hz);
 }
 
 float ar(
 float L,
 float wavelength,
-float cm,
-float aL,
+float cn,
+float aM,
 float ck,
 vec2 eu
 ) {
 L = clamp(abs(L), 1e-5, 1.0);
-float hq = pow(aL / ck, 2.0)
+float hu = pow(aM / ck, 2.0)
 * (1.0 - L * L);
-if (hq >= 1.0) {
+if (hu >= 1.0) {
 return 1.0;
 }
-float cU = sqrt(1.0 - hq);
-float kP = jR(
-aL, ck, L, cU
+float cU = sqrt(1.0 - hu);
+float lb = ka(
+aM, ck, L, cU
 );
-float kO = jQ(
-aL, ck, L, cU
+float la = jZ(
+aM, ck, L, cU
 );
-float jd = gX(
-aL, ck, L, cU
+float jj = hc(
+aM, ck, L, cU
 );
-float jc = gW(
-aL, ck, L, cU
+float ji = hb(
+aM, ck, L, cU
 );
-float gj = ck * cU
-/ max(aL * L, 1e-9);
-vec2 sP = bX(
+float gq = ck * cU
+/ max(aM * L, 1e-9);
+vec2 tb = bX(
 cU, ck, eu, false
 );
-vec2 sO = bX(
+vec2 ta = bX(
 cU, ck, eu, true
 );
-float phase = 2.0 * PI * (2.0 * ck * cm * cU) / wavelength;
-float tu = eq(
-kP,
-jd,
--kP,
-jd * gj,
-sP,
+float phase = 2.0 * PI * (2.0 * ck * cn * cU) / wavelength;
+float tJ = eq(
+lb,
+jj,
+-lb,
+jj * gq,
+tb,
 phase
 );
-float tr = eq(
-kO,
-jc,
--kO,
-jc * gj,
-sO,
+float tI = eq(
+la,
+ji,
+-la,
+ji * gq,
+ta,
 phase
 );
-return clamp(0.5 * (tu + tr), 0.0, 1.0);
+return clamp(0.5 * (tJ + tI), 0.0, 1.0);
 }
 
-vec3 hD(
+vec3 hG(
 float L,
-float cm,
+float cn,
 float ck,
 float eu,
-float aL
+float aM
 ) {
 return vec3(
 ar(
-L, 620.0, cm, aL, ck, vec2(eu, 0.0)
+L, 620.0, cn, aM, ck, vec2(eu, 0.0)
 ),
 ar(
-L, 540.0, cm, aL, ck, vec2(eu, 0.0)
+L, 540.0, cn, aM, ck, vec2(eu, 0.0)
 ),
 ar(
-L, 450.0, cm, aL, ck, vec2(eu, 0.0)
+L, 450.0, cn, aM, ck, vec2(eu, 0.0)
 )
 );
 }
 
 
 
-vec3 dT(float au, vec3 f0, vec3 tint) {
-vec3 qW = mix(f0, vec3(1.0), aE(au));
-if (all(equal(tint, vec3(1.0)))) { return qW; }
-float dj = 1.0 / 7.0;
-float lW = 1.0 - dj;
-vec3 fF = mix(f0, vec3(1.0), aE(dj));
-float dg = 1.0 - au;
-float qh = au * aE(au) * dg
-/ (dj * pow(lW, 6.0));
-return clamp(qW - qh * (fF - tint * fF), vec3(0.0), vec3(1.0));
+vec3 dU(float au, vec3 f0, vec3 tint) {
+vec3 rk = mix(f0, vec3(1.0), aE(au));
+if (all(equal(tint, vec3(1.0)))) { return rk; }
+float dk = 1.0 / 7.0;
+float ml = 1.0 - dk;
+vec3 fI = mix(f0, vec3(1.0), aE(dk));
+float di = 1.0 - au;
+float qt = au * aE(au) * di
+/ (dk * pow(ml, 6.0));
+return clamp(rk - qt * (fI - tint * fI), vec3(0.0), vec3(1.0));
 }
 
-vec2 cQ(float f0, float tb) {
-float dM = clamp(f0, 0.0, 0.99);
-float gF = sqrt(dM);
-float qt = (1.0 - dM) / (1.0 + dM);
-float qr = (1.0 + gF) / max(1.0 - gF, 1e-9);
-float ior = mix(qr, qt, clamp(tb, 0.0, 1.0));
-float jG = (
-(ior + 1.0) * (ior + 1.0) * dM
+vec2 cQ(float f0, float tp) {
+float dN = clamp(f0, 0.0, 0.99);
+float gL = sqrt(dN);
+float qF = (1.0 - dN) / (1.0 + dN);
+float qD = (1.0 + gL) / max(1.0 - gL, 1e-9);
+float ior = mix(qD, qF, clamp(tp, 0.0, 1.0));
+float jO = (
+(ior + 1.0) * (ior + 1.0) * dN
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dM, 1e-9);
-return vec2(ior, sqrt(max(jG, 0.0)));
+) / max(1.0 - dN, 1e-9);
+return vec2(ior, sqrt(max(jO, 0.0)));
 }
 
-vec3 iS(
+vec3 iY(
 float L,
-float cm,
+float cn,
 float ck,
-vec3 qS,
-vec3 jN,
-float aL
+vec3 rf,
+vec3 jW,
+float aM
 ) {
 return vec3(
 ar(
 L,
 620.0,
-cm,
-aL,
+cn,
+aM,
 ck,
-cQ(qS.r, jN.r)
+cQ(rf.r, jW.r)
 ),
 ar(
 L,
 540.0,
-cm,
-aL,
+cn,
+aM,
 ck,
-cQ(qS.g, jN.g)
+cQ(rf.g, jW.g)
 ),
 ar(
 L,
 450.0,
-cm,
-aL,
+cn,
+aM,
 ck,
-cQ(qS.b, jN.b)
+cQ(rf.b, jW.b)
 )
 );
 }
 
-float bN(float cm, float weight) {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cm);
+float bN(float cn, float weight) {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cn);
 }
 
 vec3 bW(
 vec3 ei,
 float L,
-float cm,
+float cn,
 float ck,
 float eu,
 float weight,
-float aL
+float aM
 ) {
-vec3 pd = hD(
+vec3 pq = hG(
 L,
-cm,
+cn,
 ck,
 eu,
-aL
+aM
 );
 return mix(
 ei,
-pd,
-bN(cm, weight)
+pq,
+bN(cn, weight)
 );
 }
 
-vec3 lc(
+vec3 lq(
 vec3 ei,
 float L,
-float cm,
+float cn,
 float ck,
-vec3 qS,
-vec3 jN,
+vec3 rf,
+vec3 jW,
 float weight,
-float aL
+float aM
 ) {
-vec3 pd = iS(
+vec3 pq = iY(
 L,
-cm,
+cn,
 ck,
-qS,
-jN,
-aL
+rf,
+jW,
+aM
 );
 return mix(
 ei,
-pd,
-bN(cm, weight)
+pq,
+bN(cn, weight)
 );
 }
 
-vec3 cD(
+vec3 cE(
 J material,
 vec3 color,
 vec3 viewLocal,
 vec3 lightLocal,
-float fo,
+float ft,
 out float pdf
 ) {
 pdf = 0.0;
@@ -648,47 +648,47 @@ return vec3(0.0);
 }
 
 float roughness = material.diffuseRoughness;
-float gQ = 0.5 - 2.0 / (3.0 * PI);
-float nU = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-float om = lightLocal.z;
-float mn = viewLocal.z;
-float hM = dot(lightLocal, viewLocal) - om * mn;
-float gN = hM > 0.0
-? hM / max(max(om, mn), 1e-7)
-: hM;
-float ih = 1.0 / (1.0 + gQ * roughness);
-vec3 nf = color * INVPI * ih
-* (1.0 + roughness * gN);
-
-float dc = 1.0 - om;
-float cP = 1.0 - mn;
-float oc = dc * (
-0.0571085289 + dc * (
-0.491881867 + dc * (
--0.332181442 + dc * 0.0714429953
+float gW = 0.5 - 2.0 / (3.0 * PI);
+float oj = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+float oB = lightLocal.z;
+float mB = viewLocal.z;
+float hP = dot(lightLocal, viewLocal) - oB * mB;
+float gT = hP > 0.0
+? hP / max(max(oB, mB), 1e-7)
+: hP;
+float il = 1.0 / (1.0 + gW * roughness);
+vec3 nA = color * INVPI * il
+* (1.0 + roughness * gT);
+
+float dd = 1.0 - oB;
+float cP = 1.0 - mB;
+float ot = dd * (
+0.0571085289 + dd * (
+0.491881867 + dd * (
+-0.332181442 + dd * 0.0714429953
 )
 )
 );
-float mW = cP * (
+float nq = cP * (
 0.0571085289 + cP * (
 0.491881867 + cP * (
 -0.332181442 + cP * 0.0714429953
 )
 )
 );
-float pi = (1.0 + roughness * oc)
-/ (1.0 + gQ * roughness);
-float oq = (1.0 + roughness * mW)
-/ (1.0 + gQ * roughness);
-float fQ = ih * (1.0 + nU * roughness);
-vec3 hC = color * color * fQ
-/ max(vec3(1e-7), vec3(1.0) - color * (1.0 - fQ));
-vec3 lp = hC * INVPI
-* max(1e-7, 1.0 - oq)
-* max(1e-7, 1.0 - pi)
-/ max(1e-7, 1.0 - fQ);
+float pv = (1.0 + roughness * ot)
+/ (1.0 + gW * roughness);
+float oD = (1.0 + roughness * nq)
+/ (1.0 + gW * roughness);
+float fU = il * (1.0 + oj * roughness);
+vec3 hF = color * color * fU
+/ max(vec3(1e-7), vec3(1.0) - color * (1.0 - fU));
+vec3 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 (nf + lp) * fo;
+return (nA + lF) * ft;
 }
 
 float aO(float viewCosine, float roughness) {
@@ -705,7 +705,7 @@ float gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-vec3 jP(
+vec3 jY(
 J material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -737,17 +737,17 @@ return vec3(0.0);
 }
 
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-float distribution = gE(V, alpha);
-float jM = bk(viewLocal, alpha);
-float ea = jM
+float distribution = gK(V, alpha);
+float jV = bk(viewLocal, alpha);
+float ea = jV
 * bk(lightLocal, alpha);
 
-pdf = jM * 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));
 }
 
-vec3 dk(
+vec3 dl(
 J material,
 float relativeIor,
 vec3 tint,
@@ -762,27 +762,27 @@ if (lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
 
-float kz = dot(lightLocal, V);
+float kL = dot(lightLocal, V);
 float bQ = dot(viewLocal, V);
 
 
-if (bQ <= 0.0 || kz >= 0.0) {
+if (bQ <= 0.0 || kL >= 0.0) {
 return vec3(0.0);
 }
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-float distribution = gE(V, alpha);
-float jM = bk(viewLocal, alpha);
-float ea = jM
+float distribution = gK(V, alpha);
+float jV = bk(viewLocal, alpha);
+float ea = jV
 * bk(lightLocal, alpha);
-float ap = kz + bQ * relativeIor;
+float ap = kL + bQ * relativeIor;
 ap *= ap;
-float pn = abs(kz) / max(ap, 1e-8);
-float jm = relativeIor * relativeIor;
+float pJ = abs(kL) / max(ap, 1e-8);
+float ju = relativeIor * relativeIor;
 
-pdf = jM * max(0.0, bQ) * distribution * pn
+pdf = jV * max(0.0, bQ) * distribution * pJ
 / max(viewLocal.z, 1e-8);
 return tint * (vec3(1.0) - cK) * distribution * ea
-* abs(bQ) * pn * jm
+* abs(bQ) * pJ * ju
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
@@ -803,11 +803,11 @@ vec3 aP(
 vec3 ah,
 float transmissionWeight
 ) {
-vec3 gf = 2.0 * ah
+vec3 gk = 2.0 * ah
 / (vec3(1.0) + ah);
 return mix(
 ah,
-gf,
+gk,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
@@ -821,17 +821,17 @@ vec3 tint = bn(material);
 if (!material.thinWalled) {
 return tint;
 }
-float iF = max(0.0, 1.0 - L * L);
-float dN = iF
+float iL = max(0.0, 1.0 - L * L);
+float dO = iL
 / max(bu * bu, 1e-9);
-if (dN >= 1.0) {
+if (dO >= 1.0) {
 return vec3(0.0);
 }
-float S = sqrt(1.0 - dN);
+float S = sqrt(1.0 - dO);
 return pow(max(tint, vec3(0.0)), vec3(1.0 / max(S, 1e-5)));
 }
 
-vec3 dL(
+vec3 dM(
 J material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -842,28 +842,28 @@ if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
 float S = -lightLocal.z;
-float nR = ct(
+float og = cu(
 viewLocal.z,
 material.relativeIor
 );
 pdf = S * INVPI;
-return vec3(1.0 - nR) * INVPI;
+return vec3(1.0 - og) * INVPI;
 }
 
-void dQ(inout ag prepared) {
+void dR(inout ag prepared) {
 float total = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-for (int hR = 1; hR < OPENPBR_LOBE_COUNT; hR++) {
-total += prepared.probabilities[hR];
+for (int hU = 1; hU < OPENPBR_LOBE_COUNT; hU++) {
+total += prepared.probabilities[hU];
 }
 if (total <= 1e-8) {
-for (int hR = 0; hR < OPENPBR_LOBE_COUNT; hR++) {
-prepared.probabilities[hR] = 0.0;
+for (int hU = 0; hU < OPENPBR_LOBE_COUNT; hU++) {
+prepared.probabilities[hU] = 0.0;
 }
 return;
 }
-float og = 1.0 / total;
-for (int hR = 0; hR < OPENPBR_LOBE_COUNT; hR++) {
-prepared.probabilities[hR] *= og;
+float ow = 1.0 / total;
+for (int hU = 0; hU < OPENPBR_LOBE_COUNT; hU++) {
+prepared.probabilities[hU] *= ow;
 }
 }
 
@@ -876,59 +876,59 @@ return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * e
 }
 
 vec3 bP(vec3 f0, vec3 tint) {
-float dj = 1.0 / 7.0;
-vec3 fF = mix(f0, vec3(1.0), aE(dj));
-vec3 b = fF * (vec3(1.0) - tint) / (dj * pow(1.0 - dj, 6.0));
+float dk = 1.0 / 7.0;
+vec3 fI = mix(f0, vec3(1.0), aE(dk));
+vec3 b = fI * (vec3(1.0) - tint) / (dk * pow(1.0 - dk, 6.0));
 return clamp(f0 + (vec3(1.0) - f0) / 21.0 - b / 126.0, vec3(0.0), vec3(1.0));
 }
 
 
 
-vec3 cC(J material, float au) {
+vec3 cD(J material, float au) {
 if (au <= 0.0) { return vec3(1.0); }
-float lr = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
-vec3 tl = pow(max(material.coatColor, vec3(0.0)), vec3(0.5 / max(lr, 1e-5)));
-return mix(vec3(1.0), tl, material.coatWeight);
+float lH = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
+vec3 tD = pow(max(material.coatColor, vec3(0.0)), vec3(0.5 / max(lH, 1e-5)));
+return mix(vec3(1.0), tD, material.coatWeight);
 }
 
-float gi(J material, float au) {
+float gp(J material, float au) {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
 return af(au, 1.0 / material.coatIor);
 }
 
 
-return clamp(1.0 - aI(material.coatIor,
+return clamp(1.0 - aJ(material.coatIor,
 material.coatRoughness * material.coatRoughness, au), 0.0, 1.0);
 }
 
-vec3 gV(ag prepared) {
+vec3 ha(ag prepared) {
 J material = prepared.material;
 float dielectric = 1.0 - material.baseMetalness;
 float opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);
 float sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;
-float tU = dielectric * material.transmissionWeight;
-float fL = bM(prepared.specularEtaTOverEtaI);
-float kI = bM(1.0 / prepared.transmissionReflectionIor);
-float pw = clamp(opaque * fL + (sss + tU) * kI + material.baseMetalness, 0.0, 1.0);
-float ji = mix(1.0, material.specularRoughness, pw);
+float ug = dielectric * material.transmissionWeight;
+float fO = bM(prepared.specularEtaTOverEtaI);
+float kU = bM(1.0 / prepared.transmissionReflectionIor);
+float pR = clamp(opaque * fO + (sss + ug) * kU + material.baseMetalness, 0.0, 1.0);
+float jp = mix(1.0, material.specularRoughness, pR);
 float ks = bM(material.coatIor);
 float kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-float k = mix(ks, kr, ji);
+float k = mix(ks, kr, jp);
 vec3 eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), fL)
-+ sss * material.subsurfaceColor + vec3(tU);
-vec3 qH = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
-return mix(vec3(1.0), qH, material.coatWeight * material.coatDarkening);
++ opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), fO)
++ sss * material.subsurfaceColor + vec3(ug);
+vec3 qU = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
+return mix(vec3(1.0), qU, material.coatWeight * material.coatDarkening);
 }
 
-vec3 ds(ag prepared, float kY) {
+vec3 ds(ag prepared, float lm) {
 if (prepared.material.coatWeight <= 0.0) { return vec3(1.0); }
 if (prepared.material.inside) {
 
-return cC(prepared.material, -kY);
+return cD(prepared.material, -lm);
 }
 
-return prepared.coatBaseScale * cC(prepared.material, kY);
+return prepared.coatBaseScale * cD(prepared.material, lm);
 }
 
 
@@ -946,7 +946,7 @@ basis.tangent = normalize(cross(basis.bitangent, basis.normal));
 return basis;
 }
 
-ag eG(
+ag eH(
 vec3 tangent,
 J material,
 vec3 bF,
@@ -954,7 +954,7 @@ vec3 normal
 ) {
 ag prepared;
 prepared.material = material;
-prepared.basis = fg(
+prepared.basis = fj(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -965,7 +965,7 @@ prepared.directionFrames = false;
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fg(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = fj(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 #endif
@@ -983,19 +983,19 @@ prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bF);
 #endif
 prepared.diffuseColor = material.baseColor;
 
-float cA = 1.0 - material.baseMetalness;
-float dK = cA
+float cB = 1.0 - material.baseMetalness;
+float dL = cB
 * (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] = cA;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cA
+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(
@@ -1047,7 +1047,7 @@ float ah = af(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-vec3 ft = material.specularColor * (
+vec3 fw = material.specularColor * (
 material.thinWalled
 ? mix(
 ah,
@@ -1056,30 +1056,30 @@ material.transmissionWeight
 )
 : ah
 );
-vec3 hS = material.specularWeight * dT(
+vec3 hV = material.specularWeight * dU(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-float eL = material.thinWalled
+float eO = material.thinWalled
 ? cS(af(viewCosine, prepared.transmissionReflectionIor))
 : af(viewCosine, prepared.transmissionReflectionIor);
-vec3 gH = bG(
+vec3 gN = bG(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-float im = aI(
+float iu = aJ(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-float gk = cq(
+float gr = cr(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = im
-/ max(gk, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iu
+/ max(gr, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
 * aw(material.fuzzColor)
@@ -1092,39 +1092,39 @@ prepared.coatBaseScale = vec3(1.0);
 if (material.coatWeight > 0.0 && !material.inside) {
 #ifdef NUM_COAT_NORMAL_MAPS
 float coatViewCosine = material.coatNormalEnabled ? max(prepared.coatViewLocal.z, 0.0) : viewCosine;
-float kp = gi(material, coatViewCosine);
+float kB = gp(material, coatViewCosine);
 #else
-float kp = gi(material, viewCosine);
+float kB = gp(material, viewCosine);
 #endif
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kp;
-prepared.coatBaseScale = cC(material,
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kB;
+prepared.coatBaseScale = cD(material,
 #ifdef NUM_COAT_NORMAL_MAPS
 coatViewCosine
 #else
 viewCosine
 #endif
 )
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kp) * gV(prepared);
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kB) * ha(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aw(hS);
+* aw(hV);
 prepared.metalMsScale = vec3(0.0);
 prepared.metalMsFactor = 0.0;
 prepared.metalMsProbability = 0.0;
 if (material.specularRoughness >= 0.04 && prepared.weights[OPENPBR_LOBE_METAL] > 0.0) {
-vec3 hI = bP(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * hI * hI;
-float pJ = bH(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = pJ / max(cu(prepared.specularAlpha), 1e-12);
-float ff = prepared.weights[OPENPBR_LOBE_METAL] * aw(prepared.metalMsScale) * pJ;
-prepared.probabilities[OPENPBR_LOBE_METAL] += ff;
-prepared.metalMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+vec3 hL = bP(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * hL * hL;
+float pV = bH(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = pV / max(cv(prepared.specularAlpha), 1e-12);
+float 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(gH);
+* (1.0 - eO)
+* aw(gN);
 
 
 
@@ -1139,40 +1139,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) {
-float lq = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = (material.inside ? vec3(1.0) : material.specularColor) * lq;
-prepared.dielectricMsTransmissionScale = gH * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+float lG = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = (material.inside ? vec3(1.0) : material.specularColor) * lG;
+prepared.dielectricMsTransmissionScale = gN * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 + vec3(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
 prepared.dielectricMsReflectionRatio = ch(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
 prepared.dielectricMsViewLoss = bO(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-vec3 nI = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-float ff = aw(nI) * prepared.dielectricMsViewLoss;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += ff;
-prepared.dielectricMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+vec3 nW = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+float 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 && material.thinFilmWeight > 0.0) {
-float kW = 0.02 * bN(material.thinFilmThickness, material.thinFilmWeight);
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * kW);
-prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * kW);
+float 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) {
-float gm = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
-prepared.probabilities[OPENPBR_LOBE_METAL] *= gm;
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gm;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gm;
-prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gm;
-prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gm;
-}
-dQ(prepared);
+float 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;
 }
 
@@ -1180,11 +1180,11 @@ float cR(ag prepared, float au, bool reflection) {
 if (prepared.material.coatWeight <= 0.0) {
 return af(au, prepared.material.relativeIor);
 }
-float kg = af(au, prepared.transmissionReflectionIor);
-if (!reflection) { return kg; }
-float mU = af(au, 1.0 / prepared.specularEtaTOverEtaI);
-float rC = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(mU, kg, rC);
+float kp = af(au, prepared.transmissionReflectionIor);
+if (!reflection) { return kp; }
+float nl = af(au, 1.0 / prepared.specularEtaTOverEtaI);
+float rP = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(nl, kp, rP);
 }
 
 vec3 bI(
@@ -1216,11 +1216,11 @@ V = -V;
 
 vec3 response = vec3(0.0);
 pdf = 0.0;
-float aH = 0.0;
+float aI = 0.0;
 float bQ = abs(dot(viewLocal, V));
 float diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
-* aI(
+* aJ(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 abs(lightLocal.z)
@@ -1231,34 +1231,34 @@ if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflectio
 #endif
 if (reflection) {
 if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) {
-response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cD(
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cE(
 material,
 prepared.diffuseColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aH
+aI
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aI;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cD(
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cE(
 material,
 material.subsurfaceColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aH
+aI
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aI;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) {
-vec3 cr = vec3(cR(prepared, bQ, true));
+vec3 ct = vec3(cR(prepared, bQ, true));
 if (material.thinFilmWeight > 0.0) {
-cr = bW(
-cr,
+ct = bW(
+ct,
 bQ,
 material.thinFilmThickness,
 material.thinFilmIor,
@@ -1268,31 +1268,31 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-cr = aP(
-cr,
+ct = aP(
+ct,
 material.transmissionWeight
 );
 }
-vec3 cK = material.specularColor * cr;
+vec3 cK = material.specularColor * ct;
 response += prepared.weights[OPENPBR_LOBE_SPECULAR] * am(
 material,
 viewLocal,
 lightLocal,
 V,
 cK,
-aH
+aI
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aI;
 }
 
 if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) {
-vec3 cK = dT(
+vec3 cK = dU(
 bQ,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
 if (material.thinFilmWeight > 0.0) {
-cK = lc(
+cK = lq(
 cK,
 bQ,
 material.thinFilmThickness,
@@ -1310,14 +1310,14 @@ viewLocal,
 lightLocal,
 V,
 cK,
-aH
+aI
 );
 if (prepared.metalMsFactor > 0.0) {
 float dW = min(prepared.metalMsFactor * bH(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
 response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * dW * INVPI;
-aH = mix(aH, 0.5 * INVPI, prepared.metalMsProbability);
+aI = mix(aI, 0.5 * INVPI, prepared.metalMsProbability);
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aI;
 }
 }
 else {
@@ -1335,17 +1335,17 @@ prepared.thinFilmExteriorIor
 }
 if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) {
 if (material.thinWalled) {
-vec3 kM = vec3(lightLocal.xy, -lightLocal.z);
-vec3 dd = normalize(kM + viewLocal);
-if (dd.z < 0.0) {
-dd = -dd;
+vec3 kY = vec3(lightLocal.xy, -lightLocal.z);
+vec3 df = normalize(kY + viewLocal);
+if (df.z < 0.0) {
+df = -df;
 }
-float nD = abs(dot(viewLocal, dd));
-vec3 lv = vec3(cR(prepared, nD, false));
+float nR = abs(dot(viewLocal, df));
+vec3 lL = vec3(cR(prepared, nR, false));
 if (material.thinFilmWeight > 0.0) {
-lv = bW(
-lv,
-nD,
+lL = bW(
+lL,
+nR,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1353,8 +1353,8 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-vec3 gf = aP(
-lv,
+vec3 gk = aP(
+lL,
 1.0
 );
 vec3 tint = bG(
@@ -1366,15 +1366,15 @@ response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 * am(
 material,
 viewLocal,
-kM,
-dd,
-tint * (vec3(1.0) - gf),
-aH
+kY,
+df,
+tint * (vec3(1.0) - gk),
+aI
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dk(
+* dl(
 material,
 material.relativeIor,
 bn(material),
@@ -1382,37 +1382,37 @@ viewLocal,
 lightLocal,
 V,
 cK,
-aH
+aI
 );
 }
 if (prepared.dielectricMsProbability > 0.0) {
-aH *= 1.0 - prepared.dielectricMsProbability;
+aI *= 1.0 - prepared.dielectricMsProbability;
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aI;
 }
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) {
 if (material.thinWalled) {
-vec3 nT = vec3(lightLocal.xy, -lightLocal.z);
+vec3 oi = vec3(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* cD(
+* cE(
 material,
 material.subsurfaceColor,
 viewLocal,
-nT,
+oi,
 diffuseSpecularEnergyCompensation,
-aH
+aI
 );
-aH *= 0.5;
+aI *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dL(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dM(
 material,
 viewLocal,
 lightLocal,
-aH
+aI
 );
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aI;
 }
 }
 
@@ -1423,13 +1423,13 @@ if (prepared.dielectricMsProbability > 0.0) {
 float au = abs(lightLocal.z);
 if (au > 0.0) {
 float ior = (reflection ? prepared.refractionEtaTOverEtaI : 1.0 / prepared.refractionEtaTOverEtaI);
-float iU = (reflection ? prepared.dielectricMsReflectionRatio : 1.0 - prepared.dielectricMsReflectionRatio);
-float td = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
+float ja = (reflection ? prepared.dielectricMsReflectionRatio : 1.0 - prepared.dielectricMsReflectionRatio);
+float tr = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
 / max(cO(ior, prepared.specularAlpha), 1e-12);
-float dW = min(td * iU, 1.0 / au);
+float dW = min(tr * ja, 1.0 / au);
 vec3 scale = (reflection ? prepared.dielectricMsReflectionScale : prepared.dielectricMsTransmissionScale);
 response += scale * dW * INVPI;
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iU * 0.5 * INVPI;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ja * 0.5 * INVPI;
 }
 }
 
@@ -1456,42 +1456,42 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-vec3 dH = viewLocal;
-vec3 kt = lightLocal;
-vec3 gq = V;
-float jD = bQ;
+vec3 dI = viewLocal;
+vec3 kD = lightLocal;
+vec3 gv = V;
+float jK = bQ;
 if (prepared.directionFrames) {
-dH = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
+dI = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
 #ifdef NUM_COAT_NORMAL_MAPS
-if (independentCoat) { dH = prepared.coatViewLocal; }
+if (independentCoat) { dI = prepared.coatViewLocal; }
 #endif
-kt = openpbr_to_local(prepared.coatBasis, lightDirection);
-gq = normalize(kt + dH);
-if (gq.z < 0.0) { gq = -gq; }
-jD = abs(dot(dH, gq));
+kD = openpbr_to_local(prepared.coatBasis, lightDirection);
+gv = normalize(kD + dI);
+if (gv.z < 0.0) { gv = -gv; }
+jK = abs(dot(dI, gv));
 }
 
-vec3 kU = vec3(af(
-jD,
+vec3 lg = vec3(af(
+jK,
 1.0 / material.coatIor
 ));
-J dG = material;
-vec2 jp = aJ(material.coatRoughness, material.coatAnisotropy);
-dG.alphaX = jp.x;
-dG.alphaY = jp.y;
+J dH = material;
+vec2 jx = aK(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = jx.x;
+dH.alphaY = jx.y;
 response += prepared.weights[OPENPBR_LOBE_COAT]
 #ifdef NUM_COAT_NORMAL_MAPS
 * (independentCoat ? max(coatLightCosine, 0.0) : 1.0)
 #endif
 * am(
-dG,
 dH,
-kt,
-gq,
-kU,
-aH
+dI,
+kD,
+gv,
+lg,
+aI
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
 }
 
 if (
@@ -1501,25 +1501,25 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-float qn = aO(
+float qz = aO(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3(0.0),
-vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qn)
+vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qz)
 );
 response += prepared.weights[OPENPBR_LOBE_FUZZ]
 #ifdef NUM_COAT_NORMAL_MAPS
 * (independentCoat ? max(lightLocal.z, 0.0) : 1.0)
 #endif
-* jP(
+* jY(
 material,
 viewLocal,
 lightLocal,
-aH
+aI
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aH;
+pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aI;
 }
 
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -1528,7 +1528,7 @@ if (independentCoat) { return response; }
 return response * abs(lightLocal.z);
 }
 
-vec3 qU(
+vec3 ri(
 vec3 tangent,
 J material,
 vec3 bF,
@@ -1536,7 +1536,7 @@ vec3 normal,
 vec3 lightDirection,
 out float pdf
 ) {
-ag prepared = eG(
+ag prepared = eH(
 tangent,
 material,
 bF,
@@ -1545,7 +1545,7 @@ normal
 return bI(prepared, lightDirection, pdf);
 }
 
-float vK(
+float vW(
 vec3 tangent,
 J material,
 vec3 bF,
@@ -1553,7 +1553,7 @@ vec3 normal,
 vec3 lightDirection
 ) {
 float pdf;
-qU(
+ri(
 tangent,
 material,
 bF,
@@ -1566,16 +1566,16 @@ return pdf;
 
 vec3 dv(
 ag prepared,
-vec3 cl,
+vec3 cm,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
 J material = prepared.material;
 vec3 viewLocal = prepared.viewLocal;
-float cx = cl.x;
-float fp = cl.y;
-float bm = cl.z;
+float cy = cm.x;
+float fu = cm.y;
+float bm = cm.z;
 pdf = 0.0;
 isTransmissionEvent = false;
 lightDirection = prepared.basis.normal;
@@ -1599,8 +1599,8 @@ prepared.material.coatNormalEnabled ? dot(prepared.coatBasis.normal, lightDirect
 
 float cdf[OPENPBR_LOBE_COUNT];
 cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-for (int hR = 1; hR < OPENPBR_LOBE_COUNT; hR++) {
-cdf[hR] = cdf[hR - 1] + prepared.probabilities[hR];
+for (int hU = 1; hU < OPENPBR_LOBE_COUNT; hU++) {
+cdf[hU] = cdf[hU - 1] + prepared.probabilities[hU];
 }
 if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {
 return vec3(0.0);
@@ -1610,24 +1610,24 @@ vec3 lightLocal;
 if (bm < cdf[OPENPBR_LOBE_FUZZ] || (
 bm >= cdf[OPENPBR_LOBE_TRANSMISSION] && bm < cdf[OPENPBR_LOBE_DIFFUSE]
 )) {
-lightLocal = bi(vec2(cx, fp));
+lightLocal = bi(vec2(cy, fu));
 }
 else if (bm < cdf[OPENPBR_LOBE_COAT]) {
-vec3 dH = viewLocal;
-if (prepared.directionFrames) { dH = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)); }
+vec3 dI = viewLocal;
+if (prepared.directionFrames) { dI = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)); }
 #ifdef NUM_COAT_NORMAL_MAPS
-if (material.coatNormalEnabled) { dH = prepared.coatViewLocal; }
+if (material.coatNormalEnabled) { dI = prepared.coatViewLocal; }
 #endif
 vec3 V = aQ(
-dH,
+dI,
 
-aJ(material.coatRoughness, material.coatAnisotropy),
-vec2(cx, fp)
+aK(material.coatRoughness, material.coatAnisotropy),
+vec2(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
 }
-lightLocal = normalize(reflect(-dH, V));
+lightLocal = normalize(reflect(-dI, V));
 #ifdef NUM_COAT_NORMAL_MAPS
 if (material.coatNormalEnabled) {
 lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);
@@ -1638,19 +1638,19 @@ return bI(prepared, lightDirection, pdf);
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
 else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
-bool tg = bm < cdf[OPENPBR_LOBE_METAL];
-float rw = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (tg && rw < prepared.metalMsProbability) {
-float z = cx;
-float fi = sqrt(max(0.0, 1.0 - z * z));
-float br = TWOPI * fp;
-lightLocal = vec3(fi * cos(br), fi * sin(br), z);
+bool tw = bm < cdf[OPENPBR_LOBE_METAL];
+float rM = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (tw && rM < prepared.metalMsProbability) {
+float z = cy;
+float fl = sqrt(max(0.0, 1.0 - z * z));
+float br = TWOPI * fu;
+lightLocal = vec3(fl * cos(br), fl * sin(br), z);
 }
 else {
 vec3 V = aQ(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cx, fp)
+vec2(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
@@ -1662,23 +1662,23 @@ else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 isTransmissionEvent = true;
 
 
-float uf = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && uf < prepared.dielectricMsProbability) {
-float iU = prepared.dielectricMsReflectionRatio;
-bool lM = cx < iU;
+float us = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && us < prepared.dielectricMsProbability) {
+float ja = prepared.dielectricMsReflectionRatio;
+bool lZ = cy < ja;
 float z;
-if (lM) { z = min(cx / iU, 0.99999994); }
-else { z = -min((cx - iU) / (1.0 - iU), 0.99999994); }
-float fi = sqrt(max(0.0, 1.0 - z * z));
-float br = TWOPI * fp;
-lightLocal = vec3(fi * cos(br), fi * sin(br), z);
-isTransmissionEvent = !lM;
+if (lZ) { z = min(cy / ja, 0.99999994); }
+else { z = -min((cy - ja) / (1.0 - ja), 0.99999994); }
+float fl = sqrt(max(0.0, 1.0 - z * z));
+float br = TWOPI * fu;
+lightLocal = vec3(fl * cos(br), fl * sin(br), z);
+isTransmissionEvent = !lZ;
 }
 else {
 vec3 V = aQ(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cx, fp)
+vec2(cy, fu)
 );
 if (V.z < 0.0) {
 V = -V;
@@ -1700,8 +1700,8 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-vec3 hW = normalize(reflect(-viewLocal, V));
-lightLocal = vec3(hW.xy, -hW.z);
+vec3 hZ = normalize(reflect(-viewLocal, V));
+lightLocal = vec3(hZ.xy, -hZ.z);
 }
 else {
 lightLocal = refract(
@@ -1720,13 +1720,13 @@ lightLocal = normalize(lightLocal);
 else {
 isTransmissionEvent = true;
 if (material.thinWalled) {
-float ky = cx;
-bool pH = ky >= 0.5;
-cx = pH
-? (ky - 0.5) * 2.0
-: ky * 2.0;
-lightLocal = bi(vec2(cx, fp));
-if (pH) {
+float kK = cy;
+bool pT = kK >= 0.5;
+cy = pT
+? (kK - 0.5) * 2.0
+: kK * 2.0;
+lightLocal = bi(vec2(cy, fu));
+if (pT) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1734,7 +1734,7 @@ isTransmissionEvent = false;
 }
 }
 else {
-lightLocal = bi(vec2(cx, fp));
+lightLocal = bi(vec2(cy, fu));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1751,17 +1751,17 @@ if (material.coatNormalEnabled &&
 return bI(prepared, lightDirection, pdf);
 }
 
-vec3 su(
+vec3 sJ(
 vec3 tangent,
 J material,
-vec3 cl,
+vec3 cm,
 vec3 bF,
 vec3 normal,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
-ag prepared = eG(tangent, material, bF, normal);
-return dv(prepared, cl, lightDirection, pdf, isTransmissionEvent);
+ag prepared = eH(tangent, material, bF, normal);
+return dv(prepared, cm, lightDirection, pdf, isTransmissionEvent);
 }`;
 //# sourceMappingURL=openPbrBsdf.glsl.js.map