@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -68,213 +68,213 @@ float aB(vec3 color) {
 return dot(color, vec3(0.212671, 0.715160, 0.072169));
 }
 
-float cO(float bq) {
-float value = (bq - 1.0) / (bq + 1.0);
+float cR(float br) {
+float value = (br - 1.0) / (br + 1.0);
 return value * value;
 }
 
-float bb(
-float bq,
+float bc(
+float br,
 float specularWeight
 ) {
-float uj = min(
-cO(bq) * specularWeight,
+float vT = min(
+cR(br) * specularWeight,
 0.9999
 );
-float ul = sqrt(uj);
-float lC = (1.0 + ul) / (1.0 - ul);
-return bq < 1.0 ? 1.0 / lC : lC;
+float vV = sqrt(vT);
+float mt = (1.0 + vV) / (1.0 - vV);
+return br < 1.0 ? 1.0 / mt : mt;
 }
 
-float ae(float ct, float relativeIor) {
+float ae(float cv, float relativeIor) {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return sampling_dielectric_fresnel(ct, relativeIor);
+return sampling_dielectric_fresnel(cv, relativeIor);
 }
 
-float aE(float ior) {
+float aF(float ior) {
 if (ior < 1.0) {
 return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;
 }
 return 16.0 + ((ior - 1.0) / 1.5) * 15.0;
 }
 
-float F(int tC, int row) {
-return texelFetch(openPbrEnergyLut, ivec2(tC, row), 0).r;
+float F(int vc, int row) {
+return texelFetch(openPbrEnergyLut, ivec2(vc, row), 0).r;
 }
 
-float gd(
-float dH,
+float gu(
+float dJ,
 float bM,
-float hN
+float iv
 ) {
-float br = clamp(dH, 0.0, 31.0);
+float bw = clamp(dJ, 0.0, 31.0);
 float aK = clamp(bM, 0.0, 31.0);
-float bp = clamp(hN, 0.0, 31.0);
-int dP = int(floor(br));
+float bq = clamp(iv, 0.0, 31.0);
+int dV = int(floor(bw));
 int aP = int(floor(aK));
-int cD = int(floor(bp));
-int hB = min(dP + 1, 31);
-int ch = min(aP + 1, 31);
-int eK = min(cD + 1, 31);
-float ci = br - float(dP);
-float cq = aK - float(aP);
-float kR = bp - float(cD);
-
-float wv = F(cD, dP * 32 + aP);
-float ww = F(eK, dP * 32 + aP);
-float wx = F(cD, dP * 32 + ch);
-float wy = F(eK, dP * 32 + ch);
-float wB = F(cD, hB * 32 + aP);
-float wC = F(eK, hB * 32 + aP);
-float wE = F(cD, hB * 32 + ch);
-float wF = F(eK, hB * 32 + ch);
-float v00 = mix(wv, wB, ci);
-float v01 = mix(ww, wC, ci);
-float v10 = mix(wx, wE, ci);
-float v11 = mix(wy, wF, ci);
+int cG = int(floor(bq));
+int hX = min(dV + 1, 31);
+int ci = min(aP + 1, 31);
+int eU = min(cG + 1, 31);
+float cj = bw - float(dV);
+float ct = aK - float(aP);
+float lK = bq - float(cG);
+
+float ys = F(cG, dV * 32 + aP);
+float yt = F(eU, dV * 32 + aP);
+float yu = F(cG, dV * 32 + ci);
+float yv = F(eU, dV * 32 + ci);
+float yw = F(cG, hX * 32 + aP);
+float yA = F(eU, hX * 32 + aP);
+float yB = F(cG, hX * 32 + ci);
+float yC = F(eU, hX * 32 + ci);
+float v00 = mix(ys, yw, cj);
+float v01 = mix(yt, yA, cj);
+float v10 = mix(yu, yB, cj);
+float v11 = mix(yv, yC, cj);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-kR
+mix(v00, v10, ct),
+mix(v01, v11, ct),
+lK
 );
 }
 
-float gA(float dH, float bM) {
-float br = clamp(dH, 0.0, 31.0);
+float gU(float dJ, float bM) {
+float bw = clamp(dJ, 0.0, 31.0);
 float aK = clamp(bM, 0.0, 31.0);
-int dP = int(floor(br));
+int dV = int(floor(bw));
 int aP = int(floor(aK));
-int hB = min(dP + 1, 31);
-int ch = min(aP + 1, 31);
-float ci = br - float(dP);
-float cq = aK - float(aP);
-float v00 = F(aP, 1024 + dP);
-float v01 = F(ch, 1024 + dP);
-float v10 = F(aP, 1024 + hB);
-float v11 = F(ch, 1024 + hB);
+int hX = min(dV + 1, 31);
+int ci = min(aP + 1, 31);
+float cj = bw - float(dV);
+float ct = aK - float(aP);
+float v00 = F(aP, 1024 + dV);
+float v01 = F(ci, 1024 + dV);
+float v10 = F(aP, 1024 + hX);
+float v11 = F(ci, 1024 + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
 
 
-float ee(
-float dH,
+float el(
+float dJ,
 float bM,
-float hN
+float iv
 ) {
-float br = clamp(dH, 0.0, 31.0);
+float bw = clamp(dJ, 0.0, 31.0);
 float aK = clamp(bM, 0.0, 31.0);
-float bp = clamp(hN, 0.0, 31.0);
-int dP = int(floor(br));
+float bq = clamp(iv, 0.0, 31.0);
+int dV = int(floor(bw));
 int aP = int(floor(aK));
-int cD = int(floor(bp));
-int hB = min(dP + 1, 31);
-int ch = min(aP + 1, 31);
-int eK = min(cD + 1, 31);
-float ci = br - float(dP);
-float cq = aK - float(aP);
-float kR = bp - float(cD);
-
-float wv = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
-float ww = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
-float wx = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
-float wy = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
-float wB = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
-float wC = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
-float wE = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
-float wF = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
-float v00 = mix(wv, wB, ci);
-float v01 = mix(ww, wC, ci);
-float v10 = mix(wx, wE, ci);
-float v11 = mix(wy, wF, ci);
+int cG = int(floor(bq));
+int hX = min(dV + 1, 31);
+int ci = min(aP + 1, 31);
+int eU = min(cG + 1, 31);
+float cj = bw - float(dV);
+float ct = aK - float(aP);
+float lK = bq - float(cG);
+
+float ys = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + aP);
+float yt = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + aP);
+float yu = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + ci);
+float yv = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dV * 32 + ci);
+float yw = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + aP);
+float yA = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + aP);
+float yB = F(cG, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + ci);
+float yC = F(eU, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hX * 32 + ci);
+float v00 = mix(ys, yw, cj);
+float v01 = mix(yt, yA, cj);
+float v10 = mix(yu, yB, cj);
+float v11 = mix(yv, yC, cj);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-kR
+mix(v00, v10, ct),
+mix(v01, v11, ct),
+lK
 );
 }
 
-float ec(float dH, float bM) {
-float br = clamp(dH, 0.0, 31.0);
+float ek(float dJ, float bM) {
+float bw = clamp(dJ, 0.0, 31.0);
 float aK = clamp(bM, 0.0, 31.0);
-int dP = int(floor(br));
+int dV = int(floor(bw));
 int aP = int(floor(aK));
-int hB = min(dP + 1, 31);
-int ch = min(aP + 1, 31);
-float ci = br - float(dP);
-float cq = aK - float(aP);
-float v00 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-float v01 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
-float v10 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
-float v11 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+int hX = min(dV + 1, 31);
+int ci = min(aP + 1, 31);
+float cj = bw - float(dV);
+float ct = aK - float(aP);
+float v00 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dV);
+float v01 = F(ci, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dV);
+float v10 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hX);
+float v11 = F(ci, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
-float eC(float dH, float bM) {
-float br = clamp(dH, 0.0, 31.0);
+float eL(float dJ, float bM) {
+float bw = clamp(dJ, 0.0, 31.0);
 float aK = clamp(bM, 0.0, 31.0);
-int dP = int(floor(br));
+int dV = int(floor(bw));
 int aP = int(floor(aK));
-int hB = min(dP + 1, 31);
-int ch = min(aP + 1, 31);
-float ci = br - float(dP);
-float cq = aK - float(aP);
-float v00 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-float v01 = F(ch, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
-float v10 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
-float v11 = F(ch, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+int hX = min(dV + 1, 31);
+int ci = min(aP + 1, 31);
+float cj = bw - float(dV);
+float ct = aK - float(aP);
+float v00 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dV);
+float v01 = F(ci, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dV);
+float v10 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hX);
+float v11 = F(ci, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hX);
 return mix(
-mix(v00, v10, ci),
-mix(v01, v11, ci),
-cq
+mix(v00, v10, cj),
+mix(v01, v11, cj),
+ct
 );
 }
 
 float aV(float ior, float alpha, float cosine) {
-return ee(aE(ior), sqrt(alpha) * 31.0, cosine * 31.0);
+return el(aF(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-float aY(float ior, float alpha) {
-return ec(aE(ior), sqrt(alpha) * 31.0);
+float aZ(float ior, float alpha) {
+return ek(aF(ior), sqrt(alpha) * 31.0);
 }
-float bU(float ior, float alpha) {
-return eC(aE(ior), sqrt(alpha) * 31.0);
+float bW(float ior, float alpha) {
+return eL(aF(ior), sqrt(alpha) * 31.0);
 }
 
 
 float aR(float alpha, float cosine) {
-float ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
-float bp = clamp(cosine * 31.0, 0.0, 31.0);
-int r0 = int(floor(ie));
-int c0 = int(floor(bp));
+float iL = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+float bq = clamp(cosine * 31.0, 0.0, 31.0);
+int r0 = int(floor(iL));
+int c0 = int(floor(bq));
 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(bp)),
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bp)),
-fract(ie));
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(bq)),
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bq)),
+fract(iL));
 }
 
-float cl(float alpha) {
+float cn(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}),
 F(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));
 }
 
-float aX(float value, float ior) {
+float aY(float value, float ior) {
 if (ior > 2.5 || ior < 0.4) {
-float vH = cO(2.5);
-float progress = (cO(ior) - vH) / (1.0 - vH);
+float xv = cR(2.5);
+float progress = (cR(ior) - xv) / (1.0 - xv);
 return (1.0 - progress) * value;
 }
 return value;
@@ -285,20 +285,20 @@ float ior,
 float alpha,
 float cosine
 ) {
-float value = gd(
-aE(ior),
+float value = gu(
+aF(ior),
 sqrt(alpha) * 31.0,
 cosine * 31.0
 );
-return aX(value, ior);
+return aY(value, ior);
 }
 
-float cj(float ior, float alpha) {
-float value = gA(
-aE(ior),
+float ck(float ior, float alpha) {
+float value = gU(
+aF(ior),
 sqrt(alpha) * 31.0
 );
-return aX(value, ior);
+return aY(value, ior);
 }
 
 vec3 openpbr_to_world(OpenPbrBasis basis, vec3 direction) {
@@ -315,8 +315,8 @@ dot(direction, basis.normal)
 );
 }
 
-OpenPbrBasis ff(
-vec3 aS,
+OpenPbrBasis ft(
+vec3 aT,
 vec3 normal,
 float anisotropy
 ) {
@@ -324,7 +324,7 @@ OpenPbrBasis basis;
 basis.normal = normal;
 basis.tangent = vec3(0.0);
 #ifdef USE_TANGENT
-basis.tangent = aS;
+basis.tangent = aT;
 #endif
 if (dot(basis.tangent, basis.tangent) < 0.001 || anisotropy <= 0.0) {
 sampling_orthonormal_basis(normal, basis.tangent, basis.bitangent);
@@ -336,7 +336,7 @@ basis.tangent = normalize(cross(basis.bitangent, normal));
 return basis;
 }
 
-float ki(
+float kP(
 float av,
 float ai,
 float J,
@@ -346,7 +346,7 @@ return (av * J - ai * ad)
 / (av * J + ai * ad);
 }
 
-float kh(
+float kO(
 float av,
 float ai,
 float J,
@@ -356,7 +356,7 @@ return (ai * J - av * ad)
 / (av * ad + ai * J);
 }
 
-float gZ(
+float hx(
 float av,
 float ai,
 float J,
@@ -366,7 +366,7 @@ return 2.0 * av * J
 / (av * J + ai * ad);
 }
 
-float gY(
+float hw(
 float av,
 float ai,
 float J,
@@ -376,11 +376,11 @@ return 2.0 * av * J
 / (av * ad + ai * J);
 }
 
-vec2 aT(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);
 }
 
-vec2 bc(vec2 a, vec2 b) {
+vec2 bd(vec2 a, vec2 b) {
 float ah = max(dot(b, b), 1e-9);
 return vec2(
 (a.x * b.x + a.y * b.y) / ah,
@@ -388,133 +388,133 @@ return vec2(
 );
 }
 
-vec2 hV(vec2 value) {
-float gz = length(value);
-float ui = sqrt(max(0.0, 0.5 * (gz + value.x)));
-float fc = sqrt(max(0.0, 0.5 * (gz - value.x)));
-return vec2(ui, value.y >= 0.0 ? fc : -fc);
+vec2 iG(vec2 value) {
+float gT = length(value);
+float vS = sqrt(max(0.0, 0.5 * (gT + value.x)));
+float fo = sqrt(max(0.0, 0.5 * (gT - value.x)));
+return vec2(vS, value.y >= 0.0 ? fo : -fo);
 }
 
-vec2 bR(
+vec2 bS(
 float J,
 float av,
 vec2 ai,
-bool rH
+bool sX
 ) {
-float oV = sqrt(max(0.0, 1.0 - J * J));
-vec2 tR = bc(vec2(av, 0.0), ai);
-vec2 hx = tR * oV;
-vec2 ad = hV(
-vec2(1.0, 0.0) - aT(hx, hx)
+float qd = sqrt(max(0.0, 1.0 - J * J));
+vec2 vA = bd(vec2(av, 0.0), ai);
+vec2 hR = vA * qd;
+vec2 ad = iG(
+vec2(1.0, 0.0) - aU(hR, hR)
 );
-if (aT(ai, ad).y < 0.0) {
+if (aU(ai, ad).y < 0.0) {
 ad = -ad;
 }
 
-vec2 fL = vec2(av * J, 0.0);
-vec2 eu = aT(ai, ad);
-if (rH) {
-vec2 bW = ai * J;
-vec2 bT = ad * av;
-return bc(
-bW - bT,
-bW + bT
+vec2 fX = vec2(av * J, 0.0);
+vec2 eC = aU(ai, ad);
+if (sX) {
+vec2 bY = ai * J;
+vec2 bV = ad * av;
+return bd(
+bY - bV,
+bY + bV
 );
 }
-return bc(
-fL - eu,
-fL + eu
+return bd(
+fX - eC,
+fX + eC
 );
 }
 
-float em(
-float iI,
-float gJ,
-float pk,
-float nA,
-vec2 ko,
+float ev(
+float jh,
+float hb,
+float qu,
+float ov,
+vec2 kV,
 float phase
 ) {
-vec2 nZ = vec2(cos(phase), sin(phase));
-vec2 hY = aT(ko, nZ);
-vec2 iF = hY * (gJ * nA);
-vec2 ah = vec2(1.0, 0.0) - hY * pk;
-vec2 hw = vec2(iI, 0.0)
-+ bc(iF, ah);
-return dot(hw, hw);
+vec2 oY = vec2(cos(phase), sin(phase));
+vec2 iJ = aU(kV, oY);
+vec2 je = iJ * (hb * ov);
+vec2 ah = vec2(1.0, 0.0) - iJ * qu;
+vec2 hQ = vec2(jh, 0.0)
++ bd(je, ah);
+return dot(hQ, hQ);
 }
 
 float ap(
 float J,
 float wavelength,
-float cf,
+float ch,
 float aN,
-float bY,
-vec2 ep
+float ca,
+vec2 ey
 ) {
 J = clamp(abs(J), 1e-5, 1.0);
-float hp = pow(aN / bY, 2.0)
+float hJ = pow(aN / ca, 2.0)
 * (1.0 - J * J);
-if (hp >= 1.0) {
+if (hJ >= 1.0) {
 return 1.0;
 }
-float cN = sqrt(1.0 - hp);
-float lq = ki(
-aN, bY, J, cN
+float cQ = sqrt(1.0 - hJ);
+float ml = kP(
+aN, ca, J, cQ
 );
-float lp = kh(
-aN, bY, J, cN
+float mk = kO(
+aN, ca, J, cQ
 );
-float jm = gZ(
-aN, bY, J, cN
+float jQ = hx(
+aN, ca, J, cQ
 );
-float jl = gY(
-aN, bY, J, cN
+float jP = hw(
+aN, ca, J, cQ
 );
-float gp = bY * cN
+float gI = ca * cQ
 / max(aN * J, 1e-9);
-vec2 uB = bR(
-cN, bY, ep, false
-);
-vec2 uA = bR(
-cN, bY, ep, true
-);
-float phase = 2.0 * PI * (2.0 * bY * cf * cN) / wavelength;
-float vh = em(
-lq,
-jm,
--lq,
-jm * gp,
-uB,
+vec2 wh = bS(
+cQ, ca, ey, false
+);
+vec2 wg = bS(
+cQ, ca, ey, true
+);
+float phase = 2.0 * PI * (2.0 * ca * ch * cQ) / wavelength;
+float wV = ev(
+ml,
+jQ,
+-ml,
+jQ * gI,
+wh,
 phase
 );
-float vg = em(
-lp,
-jl,
--lp,
-jl * gp,
-uA,
+float wU = ev(
+mk,
+jP,
+-mk,
+jP * gI,
+wg,
 phase
 );
-return clamp(0.5 * (vh + vg), 0.0, 1.0);
+return clamp(0.5 * (wV + wU), 0.0, 1.0);
 }
 
-vec3 hD(
+vec3 hZ(
 float J,
-float cf,
-float bY,
-float ep,
+float ch,
+float ca,
+float ey,
 float aN
 ) {
 return vec3(
 ap(
-J, 620.0, cf, aN, bY, vec2(ep, 0.0)
+J, 620.0, ch, aN, ca, vec2(ey, 0.0)
 ),
 ap(
-J, 540.0, cf, aN, bY, vec2(ep, 0.0)
+J, 540.0, ch, aN, ca, vec2(ey, 0.0)
 ),
 ap(
-J, 450.0, cf, aN, bY, vec2(ep, 0.0)
+J, 450.0, ch, aN, ca, vec2(ey, 0.0)
 )
 );
 }
@@ -522,124 +522,124 @@ J, 450.0, cf, aN, bY, vec2(ep, 0.0)
 
 
 vec3 openpbr_metal_fresnel(float cosine, vec3 f0, vec3 tint) {
-vec3 sl = mix(f0, vec3(1.0), aH(cosine));
-if (all(equal(tint, vec3(1.0)))) { return sl; }
-float da = 1.0 / 7.0;
-float mK = 1.0 - da;
-vec3 fJ = mix(f0, vec3(1.0), aH(da));
-float cY = 1.0 - cosine;
-float rp = cosine * aH(cosine) * cY
-/ (da * pow(mK, 6.0));
-return clamp(sl - rp * (fJ - tint * fJ), vec3(0.0), vec3(1.0));
-}
-
-vec2 cJ(float f0, float uS) {
-float dL = clamp(f0, 0.0, 0.99);
-float gI = sqrt(dL);
-float rF = (1.0 - dL) / (1.0 + dL);
-float rC = (1.0 + gI) / max(1.0 - gI, 1e-9);
-float ior = mix(rC, rF, clamp(uS, 0.0, 1.0));
-float jT = (
-(ior + 1.0) * (ior + 1.0) * dL
+vec3 tN = mix(f0, vec3(1.0), aI(cosine));
+if (all(equal(tint, vec3(1.0)))) { return tN; }
+float dd = 1.0 / 7.0;
+float nM = 1.0 - dd;
+vec3 fV = mix(f0, vec3(1.0), aI(dd));
+float da = 1.0 - cosine;
+float sG = cosine * aI(cosine) * da
+/ (dd * pow(nM, 6.0));
+return clamp(tN - sG * (fV - tint * fV), vec3(0.0), vec3(1.0));
+}
+
+vec2 cL(float f0, float wF) {
+float dP = clamp(f0, 0.0, 0.99);
+float ha = sqrt(dP);
+float sU = (1.0 - dP) / (1.0 + dP);
+float sR = (1.0 + ha) / max(1.0 - ha, 1e-9);
+float ior = mix(sR, sU, clamp(wF, 0.0, 1.0));
+float kz = (
+(ior + 1.0) * (ior + 1.0) * dP
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dL, 1e-9);
-return vec2(ior, sqrt(max(jT, 0.0)));
+) / max(1.0 - dP, 1e-9);
+return vec2(ior, sqrt(max(kz, 0.0)));
 }
 
-vec3 iX(
+vec3 jD(
 float J,
-float cf,
-float bY,
-vec3 sg,
-vec3 kd,
+float ch,
+float ca,
+vec3 tG,
+vec3 kK,
 float aN
 ) {
 return vec3(
 ap(
 J,
 620.0,
-cf,
+ch,
 aN,
-bY,
-cJ(sg.r, kd.r)
+ca,
+cL(tG.r, kK.r)
 ),
 ap(
 J,
 540.0,
-cf,
+ch,
 aN,
-bY,
-cJ(sg.g, kd.g)
+ca,
+cL(tG.g, kK.g)
 ),
 ap(
 J,
 450.0,
-cf,
+ch,
 aN,
-bY,
-cJ(sg.b, kd.b)
+ca,
+cL(tG.b, kK.b)
 )
 );
 }
 
-float bJ(float cf, float weight) {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cf);
+float bJ(float ch, float weight) {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ch);
 }
 
-vec3 bQ(
-vec3 ef,
+vec3 bR(
+vec3 em,
 float J,
-float cf,
-float bY,
-float ep,
+float ch,
+float ca,
+float ey,
 float weight,
 float aN
 ) {
-vec3 qe = hD(
+vec3 rm = hZ(
 J,
-cf,
-bY,
-ep,
+ch,
+ca,
+ey,
 aN
 );
 return mix(
-ef,
-qe,
-bJ(cf, weight)
+em,
+rm,
+bJ(ch, weight)
 );
 }
 
-vec3 lI(
-vec3 ef,
+vec3 mA(
+vec3 em,
 float J,
-float cf,
-float bY,
-vec3 sg,
-vec3 kd,
+float ch,
+float ca,
+vec3 tG,
+vec3 kK,
 float weight,
 float aN
 ) {
-vec3 qe = iX(
+vec3 rm = jD(
 J,
-cf,
-bY,
-sg,
-kd,
+ch,
+ca,
+tG,
+kK,
 aN
 );
 return mix(
-ef,
-qe,
-bJ(cf, weight)
+em,
+rm,
+bJ(ch, weight)
 );
 }
 
-vec3 bw(
+vec3 bB(
 OpenPbrResolvedMaterial material,
 vec3 color,
 vec3 viewLocal,
 vec3 lightLocal,
-float fl,
+float fD,
 out float pdf
 ) {
 pdf = 0.0;
@@ -648,24 +648,24 @@ return vec3(0.0);
 }
 
 float roughness = material.diffuseRoughness;
-float gS = 0.5 - 2.0 / (3.0 * PI);
-float oR = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-float pe = lightLocal.z;
-float nd = viewLocal.z;
-float directional = dot(lightLocal, viewLocal) - pe * nd;
-float gP = directional > 0.0
-? directional / max(max(pe, nd), 1e-7)
+float hp = 0.5 - 2.0 / (3.0 * PI);
+float pZ = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+float qn = lightLocal.z;
+float oc = viewLocal.z;
+float directional = dot(lightLocal, viewLocal) - qn * oc;
+float hl = directional > 0.0
+? directional / max(max(qn, oc), 1e-7)
 : directional;
-float il = 1.0 / (1.0 + gS * roughness);
-vec3 oe = color * INVPI * il
-* (1.0 + roughness * gP);
-
-float cW = 1.0 - pe;
-float outputComplement = 1.0 - nd;
-float oW = cW * (
-0.0571085289 + cW * (
-0.491881867 + cW * (
--0.332181442 + cW * 0.0714429953
+float iQ = 1.0 / (1.0 + hp * roughness);
+vec3 pe = color * INVPI * iQ
+* (1.0 + roughness * hl);
+
+float cX = 1.0 - qn;
+float outputComplement = 1.0 - oc;
+float qe = cX * (
+0.0571085289 + cX * (
+0.491881867 + cX * (
+-0.332181442 + cX * 0.0714429953
 )
 )
 );
@@ -676,19 +676,19 @@ float outputGOverPi = outputComplement * (
 )
 )
 );
-float qj = (1.0 + roughness * oW)
-/ (1.0 + gS * roughness);
+float rr = (1.0 + roughness * qe)
+/ (1.0 + hp * roughness);
 float outputAlbedo = (1.0 + roughness * outputGOverPi)
-/ (1.0 + gS * roughness);
-float fU = il * (1.0 + oR * roughness);
-vec3 hC = color * color * fU
-/ max(vec3(1e-7), vec3(1.0) - color * (1.0 - fU));
-vec3 lT = hC * INVPI
+/ (1.0 + hp * roughness);
+float gk = iQ * (1.0 + pZ * roughness);
+vec3 hY = color * color * gk
+/ max(vec3(1e-7), vec3(1.0) - color * (1.0 - gk));
+vec3 mN = hY * INVPI
 * max(1e-7, 1.0 - outputAlbedo)
-* max(1e-7, 1.0 - qj)
-/ max(1e-7, 1.0 - fU);
+* max(1e-7, 1.0 - rr)
+/ max(1e-7, 1.0 - gk);
 pdf = lightLocal.z * INVPI;
-return (oe + lT) * fl;
+return (pe + mN) * fD;
 }
 
 float aQ(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 kg(
+vec3 kN(
 OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -738,16 +738,16 @@ return vec3(0.0);
 
 vec2 alpha = vec2(material.alphaX, material.alphaY);
 float distribution = sampling_ggx_ndf(aa, alpha);
-float kc = aD(viewLocal, alpha);
-float dY = kc
+float kJ = aD(viewLocal, alpha);
+float eh = kJ
 * aD(lightLocal, alpha);
 
-pdf = kc * distribution / (4.0 * max(viewLocal.z, 1e-8));
-return fresnel * distribution * dY
+pdf = kJ * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return fresnel * distribution * eh
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-vec3 dc(
+vec3 df(
 OpenPbrResolvedMaterial material,
 float relativeIor,
 vec3 tint,
@@ -771,22 +771,22 @@ return vec3(0.0);
 }
 vec2 alpha = vec2(material.alphaX, material.alphaY);
 float distribution = sampling_ggx_ndf(aa, alpha);
-float kc = aD(viewLocal, alpha);
-float dY = kc
+float kJ = aD(viewLocal, alpha);
+float eh = kJ
 * aD(lightLocal, alpha);
 float ah = lightHalf + viewHalf * relativeIor;
 ah *= ah;
-float qo = abs(lightHalf) / max(ah, 1e-8);
-float jB = relativeIor * relativeIor;
+float rw = abs(lightHalf) / max(ah, 1e-8);
+float ke = relativeIor * relativeIor;
 
-pdf = kc * max(0.0, viewHalf) * distribution * qo
+pdf = kJ * max(0.0, viewHalf) * distribution * rw
 / max(viewLocal.z, 1e-8);
-return tint * (vec3(1.0) - fresnel) * distribution * dY
-* abs(viewHalf) * qo * jB
+return tint * (vec3(1.0) - fresnel) * distribution * eh
+* abs(viewHalf) * rw * ke
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-vec3 ba(OpenPbrResolvedMaterial material) {
+vec3 bb(OpenPbrResolvedMaterial material) {
 #ifdef HAS_MEDIUM
 if (material.mediumType > 0) {
 return vec3(1.0);
@@ -795,7 +795,7 @@ return vec3(1.0);
 return material.transmissionColor;
 }
 
-float cL(float ag) {
+float cN(float ag) {
 return 2.0 * ag / (1.0 + ag);
 }
 
@@ -803,11 +803,11 @@ vec3 aq(
 vec3 ag,
 float transmissionWeight
 ) {
-vec3 gk = 2.0 * ag
+vec3 gE = 2.0 * ag
 / (vec3(1.0) + ag);
 return mix(
 ag,
-gk,
+gE,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
@@ -815,23 +815,23 @@ clamp(transmissionWeight, 0.0, 1.0)
 vec3 bF(
 OpenPbrResolvedMaterial material,
 float J,
-float bq
+float br
 ) {
-vec3 tint = ba(material);
+vec3 tint = bb(material);
 if (!material.thinWalled) {
 return tint;
 }
-float iK = max(0.0, 1.0 - J * J);
-float dM = iK
-/ max(bq * bq, 1e-9);
-if (dM >= 1.0) {
+float jk = max(0.0, 1.0 - J * J);
+float dR = jk
+/ max(br * br, 1e-9);
+if (dR >= 1.0) {
 return vec3(0.0);
 }
-float ad = sqrt(1.0 - dM);
+float ad = sqrt(1.0 - dR);
 return pow(max(tint, vec3(0.0)), vec3(1.0 / max(ad, 1e-5)));
 }
 
-vec3 dK(
+vec3 dO(
 OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -842,15 +842,15 @@ if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
 float ad = -lightLocal.z;
-float oO = sampling_dielectric_fresnel(
+float pW = sampling_dielectric_fresnel(
 viewLocal.z,
 material.relativeIor
 );
 pdf = ad * INVPI;
-return vec3(1.0 - oO) * INVPI;
+return vec3(1.0 - pW) * INVPI;
 }
 
-void dQ(inout OpenPbrPreparedBsdf prepared) {
+void dW(inout OpenPbrPreparedBsdf prepared) {
 float total = prepared.probabilities[OPENPBR_LOBE_FUZZ];
 for (int lobe = 1; lobe < OPENPBR_LOBE_COUNT; lobe++) {
 total += prepared.probabilities[lobe];
@@ -861,9 +861,9 @@ prepared.probabilities[lobe] = 0.0;
 }
 return;
 }
-float oZ = 1.0 / total;
+float qh = 1.0 / total;
 for (int lobe = 0; lobe < OPENPBR_LOBE_COUNT; lobe++) {
-prepared.probabilities[lobe] *= oZ;
+prepared.probabilities[lobe] *= qh;
 }
 }
 
@@ -876,22 +876,22 @@ return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * e
 }
 
 vec3 bL(vec3 f0, vec3 tint) {
-float da = 1.0 / 7.0;
-vec3 fJ = mix(f0, vec3(1.0), aH(da));
-vec3 b = fJ * (vec3(1.0) - tint) / (da * pow(1.0 - da, 6.0));
+float dd = 1.0 / 7.0;
+vec3 fV = mix(f0, vec3(1.0), aI(dd));
+vec3 b = fV * (vec3(1.0) - tint) / (dd * pow(1.0 - dd, 6.0));
 return clamp(f0 + (vec3(1.0) - f0) / 21.0 - b / 126.0, vec3(0.0), vec3(1.0));
 }
 
 
 
-vec3 cA(OpenPbrResolvedMaterial material, float cosine) {
+vec3 cC(OpenPbrResolvedMaterial material, float cosine) {
 if (cosine <= 0.0) { return vec3(1.0); }
-float lV = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
-vec3 uZ = pow(max(material.coatColor, vec3(0.0)), vec3(0.5 / max(lV, 1e-5)));
-return mix(vec3(1.0), uZ, material.coatWeight);
+float mP = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
+vec3 wN = pow(max(material.coatColor, vec3(0.0)), vec3(0.5 / max(mP, 1e-5)));
+return mix(vec3(1.0), wN, material.coatWeight);
 }
 
-float gn(OpenPbrResolvedMaterial material, float cosine) {
+float gH(OpenPbrResolvedMaterial material, float cosine) {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
 return ae(cosine, 1.0 / material.coatIor);
 }
@@ -901,38 +901,38 @@ return clamp(1.0 - ar(material.coatIor,
 material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);
 }
 
-vec3 gX(OpenPbrPreparedBsdf prepared) {
+vec3 hv(OpenPbrPreparedBsdf prepared) {
 OpenPbrResolvedMaterial 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 vU = dielectric * material.transmissionWeight;
-float fP = bI(prepared.specularEtaTOverEtaI);
-float lg = bI(1.0 / prepared.transmissionReflectionIor);
-float qA = clamp(opaque * fP + (sss + vU) * lg + material.baseMetalness, 0.0, 1.0);
-float jt = mix(1.0, material.specularRoughness, qA);
+float xQ = dielectric * material.transmissionWeight;
+float gb = bI(prepared.specularEtaTOverEtaI);
+float mc = bI(1.0 / prepared.transmissionReflectionIor);
+float rO = clamp(opaque * gb + (sss + xQ) * mc + material.baseMetalness, 0.0, 1.0);
+float jX = mix(1.0, material.specularRoughness, rO);
 float ks = bI(material.coatIor);
 float kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-float k = mix(ks, kr, jt);
+float k = mix(ks, kr, jX);
 vec3 eb = material.baseMetalness * material.specularWeight * bL(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), fP)
-+ sss * material.subsurfaceColor + vec3(vU);
-vec3 rV = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
-return mix(vec3(1.0), rV, material.coatWeight * material.coatDarkening);
++ opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), gb)
++ sss * material.subsurfaceColor + vec3(xQ);
+vec3 tn = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
+return mix(vec3(1.0), tn, material.coatWeight * material.coatDarkening);
 }
 
-vec3 cm(OpenPbrPreparedBsdf prepared, float lF) {
+vec3 cp(OpenPbrPreparedBsdf prepared, float mx) {
 if (prepared.material.coatWeight <= 0.0) { return vec3(1.0); }
 if (prepared.material.inside) {
 
-return cA(prepared.material, -lF);
+return cC(prepared.material, -mx);
 }
 
-return prepared.coatBaseScale * cA(prepared.material, lF);
+return prepared.coatBaseScale * cC(prepared.material, mx);
 }
 
 
-OpenPbrBasis dk(OpenPbrBasis fallback, vec3 tangent, vec3 bitangent, vec2 direction) {
+OpenPbrBasis dm(OpenPbrBasis fallback, vec3 tangent, vec3 bitangent, vec2 direction) {
 vec3 t = tangent - fallback.normal * dot(fallback.normal, tangent);
 if (dot(t, t) < 1e-8) { t = fallback.tangent; }
 t = normalize(t);
@@ -946,15 +946,15 @@ basis.tangent = normalize(cross(basis.bitangent, basis.normal));
 return basis;
 }
 
-OpenPbrPreparedBsdf bV(
+OpenPbrPreparedBsdf bX(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bD,
+vec3 bE,
 vec3 normal
 ) {
 OpenPbrPreparedBsdf prepared;
 prepared.material = material;
-prepared.basis = ff(
+prepared.basis = ft(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -965,40 +965,40 @@ prepared.directionFrames = false;
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = ff(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = ft(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 #endif
 if (material.specularAnisotropy > 0.0 && material.anisotropyDirectionEnabled) {
-prepared.basis = dk(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
+prepared.basis = dm(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
 prepared.directionFrames = true;
 }
 if (material.coatAnisotropy > 0.0 && material.coatAnisotropyRotation != 0.0) {
-prepared.coatBasis = dk(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
+prepared.coatBasis = dm(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
 prepared.directionFrames = true;
 }
-prepared.viewLocal = openpbr_to_local(prepared.basis, bD);
+prepared.viewLocal = openpbr_to_local(prepared.basis, bE);
 #ifdef USE_COAT_NORMAL_FRAMES
-prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bD);
+prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bE);
 #endif
 prepared.diffuseColor = material.baseColor;
 
-float cu = 1.0 - material.baseMetalness;
-float dJ = cu
+float cw = 1.0 - material.baseMetalness;
+float dN = cw
 * (1.0 - material.transmissionWeight);
 prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;
 prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;
 if (material.inside) { prepared.weights[OPENPBR_LOBE_COAT] = 0.0; }
 prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;
-prepared.weights[OPENPBR_LOBE_SPECULAR] = cu;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cu
+prepared.weights[OPENPBR_LOBE_SPECULAR] = cw;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cw
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dJ
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dN
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dJ
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dN
 * material.subsurfaceWeight;
 
-prepared.specularEtaTOverEtaI = bb(
+prepared.specularEtaTOverEtaI = bc(
 1.0 / material.relativeIor,
 material.specularWeight
 );
@@ -1008,20 +1008,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-float bX = 1.0;
-if (!material.inside) { bX = mix(1.0, material.coatIor, material.coatWeight); }
-float bn = bX * bb(
-material.specularIor / bX, material.specularWeight);
-float eo = bn / bX;
-if (bX > bn && bn >= 1.0) {
-eo = 1.0 / eo;
-}
-prepared.specularEtaTOverEtaI = eo;
-prepared.transmissionReflectionIor = 1.0 / eo;
-prepared.refractionEtaTOverEtaI = bn;
+float bZ = 1.0;
+if (!material.inside) { bZ = mix(1.0, material.coatIor, material.coatWeight); }
+float bo = bZ * bc(
+material.specularIor / bZ, material.specularWeight);
+float ew = bo / bZ;
+if (bZ > bo && bo >= 1.0) {
+ew = 1.0 / ew;
+}
+prepared.specularEtaTOverEtaI = ew;
+prepared.transmissionReflectionIor = 1.0 / ew;
+prepared.refractionEtaTOverEtaI = bo;
 if (material.inside) {
-prepared.refractionEtaTOverEtaI = 1.0 / bn;
-prepared.transmissionReflectionIor = bn;
+prepared.refractionEtaTOverEtaI = 1.0 / bo;
+prepared.transmissionReflectionIor = bo;
 }
 prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
 }
@@ -1047,39 +1047,39 @@ float ag = ae(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-vec3 fu = material.specularColor * (
+vec3 fJ = material.specularColor * (
 material.thinWalled
 ? mix(
 ag,
-cL(ag),
+cN(ag),
 material.transmissionWeight
 )
 : ag
 );
-vec3 hS = material.specularWeight * openpbr_metal_fresnel(
+vec3 iD = material.specularWeight * openpbr_metal_fresnel(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-float eI = material.thinWalled
-? cL(ae(viewCosine, prepared.transmissionReflectionIor))
+float eS = material.thinWalled
+? cN(ae(viewCosine, prepared.transmissionReflectionIor))
 : ae(viewCosine, prepared.transmissionReflectionIor);
-vec3 gK = bF(
+vec3 hc = bF(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-float ir = ar(
+float iT = ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-float gq = cj(
+float gJ = ck(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = ir
-/ max(gq, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iT
+/ max(gJ, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
 * aB(material.fuzzColor)
@@ -1092,39 +1092,39 @@ prepared.coatBaseScale = vec3(1.0);
 if (material.coatWeight > 0.0 && !material.inside) {
 #ifdef USE_COAT_NORMAL_FRAMES
 float coatViewCosine = material.coatNormalEnabled ? max(prepared.coatViewLocal.z, 0.0) : viewCosine;
-float kO = gn(material, coatViewCosine);
+float lH = gH(material, coatViewCosine);
 #else
-float kO = gn(material, viewCosine);
+float lH = gH(material, viewCosine);
 #endif
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kO;
-prepared.coatBaseScale = cA(material,
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * lH;
+prepared.coatBaseScale = cC(material,
 #ifdef USE_COAT_NORMAL_FRAMES
 coatViewCosine
 #else
 viewCosine
 #endif
 )
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kO) * gX(prepared);
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * lH) * hv(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aB(hS);
+* aB(iD);
 prepared.metalMsScale = 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 = bL(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * hI * hI;
-float qF = aR(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = qF / max(cl(prepared.specularAlpha), 1e-12);
-float fe = prepared.weights[OPENPBR_LOBE_METAL] * aB(prepared.metalMsScale) * qF;
-prepared.probabilities[OPENPBR_LOBE_METAL] += fe;
-prepared.metalMsProbability = fe / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+vec3 il = bL(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * il * il;
+float rT = aR(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = rT / max(cn(prepared.specularAlpha), 1e-12);
+float fq = prepared.weights[OPENPBR_LOBE_METAL] * aB(prepared.metalMsScale) * rT;
+prepared.probabilities[OPENPBR_LOBE_METAL] += fq;
+prepared.metalMsProbability = fq / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aB(fu);
+* aB(fJ);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eI)
-* aB(gK);
+* (1.0 - eS)
+* aB(hc);
 
 
 
@@ -1139,52 +1139,52 @@ 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 lU = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = (material.inside ? vec3(1.0) : material.specularColor) * lU;
-prepared.dielectricMsTransmissionScale = gK * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+float mO = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = (material.inside ? vec3(1.0) : material.specularColor) * mO;
+prepared.dielectricMsTransmissionScale = hc * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 + vec3(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
-prepared.dielectricMsReflectionRatio = bU(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
+prepared.dielectricMsReflectionRatio = bW(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
 prepared.dielectricMsViewLoss = aV(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-vec3 oG = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-float fe = aB(oG) * prepared.dielectricMsViewLoss;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fe;
-prepared.dielectricMsProbability = fe / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+vec3 pM = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+float fq = aB(pM) * prepared.dielectricMsViewLoss;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fq;
+prepared.dielectricMsProbability = fq / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
 * aB(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eI)
+* (1.0 - eS)
 * aB(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
 if (material.coatWeight > 0.0 && material.thinFilmWeight > 0.0) {
-float lD = 0.02 * bJ(material.thinFilmThickness, material.thinFilmWeight);
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * lD);
-prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * lD);
+float mv = 0.02 * bJ(material.thinFilmThickness, material.thinFilmWeight);
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * mv);
+prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * mv);
 }
 if (material.coatWeight > 0.0 && !material.inside) {
-float gr = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
-prepared.probabilities[OPENPBR_LOBE_METAL] *= gr;
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gr;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gr;
-prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gr;
-prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gr;
-}
-dQ(prepared);
+float gK = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
+prepared.probabilities[OPENPBR_LOBE_METAL] *= gK;
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gK;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gK;
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gK;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gK;
+}
+dW(prepared);
 return prepared;
 }
 
-float cK(OpenPbrPreparedBsdf prepared, float cosine, bool reflection) {
+float cM(OpenPbrPreparedBsdf prepared, float cosine, bool reflection) {
 if (prepared.material.coatWeight <= 0.0) {
 return ae(cosine, prepared.material.relativeIor);
 }
-float kA = ae(cosine, prepared.transmissionReflectionIor);
-if (!reflection) { return kA; }
-float nY = ae(cosine, 1.0 / prepared.specularEtaTOverEtaI);
-float sN = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(nY, kA, sN);
+float lk = ae(cosine, prepared.transmissionReflectionIor);
+if (!reflection) { return lk; }
+float oX = ae(cosine, 1.0 / prepared.specularEtaTOverEtaI);
+float um = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(oX, lk, um);
 }
 
 vec3 openpbr_eval_prepared(
@@ -1231,7 +1231,7 @@ 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] * bw(
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bB(
 material,
 prepared.diffuseColor,
 viewLocal,
@@ -1243,7 +1243,7 @@ pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * lobePdf;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bw(
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bB(
 material,
 material.subsurfaceColor,
 viewLocal,
@@ -1255,10 +1255,10 @@ pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * lobePdf;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) {
-vec3 ck = vec3(cK(prepared, viewHalf, true));
+vec3 cl = vec3(cM(prepared, viewHalf, true));
 if (material.thinFilmWeight > 0.0) {
-ck = bQ(
-ck,
+cl = bR(
+cl,
 viewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
@@ -1268,12 +1268,12 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-ck = aq(
-ck,
+cl = aq(
+cl,
 material.transmissionWeight
 );
 }
-vec3 fresnel = material.specularColor * ck;
+vec3 fresnel = material.specularColor * cl;
 response += prepared.weights[OPENPBR_LOBE_SPECULAR] * aj(
 material,
 viewLocal,
@@ -1292,7 +1292,7 @@ material.baseWeight * material.baseColor,
 material.specularColor
 );
 if (material.thinFilmWeight > 0.0) {
-fresnel = lI(
+fresnel = mA(
 fresnel,
 viewHalf,
 material.thinFilmThickness,
@@ -1313,17 +1313,17 @@ fresnel,
 lobePdf
 );
 if (prepared.metalMsFactor > 0.0) {
-float cv = min(prepared.metalMsFactor * aR(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
-response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * cv * INVPI;
+float cA = min(prepared.metalMsFactor * aR(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
+response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * cA * INVPI;
 lobePdf = mix(lobePdf, 0.5 * INVPI, prepared.metalMsProbability);
 }
 pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * lobePdf;
 }
 }
 else {
-vec3 fresnel = vec3(cK(prepared, viewHalf, false));
+vec3 fresnel = vec3(cM(prepared, viewHalf, false));
 if (material.thinFilmWeight > 0.0) {
-fresnel = bQ(
+fresnel = bR(
 fresnel,
 viewHalf,
 material.thinFilmThickness,
@@ -1335,16 +1335,16 @@ prepared.thinFilmExteriorIor
 }
 if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) {
 if (material.thinWalled) {
-vec3 lm = vec3(lightLocal.xy, -lightLocal.z);
-vec3 thinWallHalf = normalize(lm + viewLocal);
+vec3 mi = vec3(lightLocal.xy, -lightLocal.z);
+vec3 thinWallHalf = normalize(mi + viewLocal);
 if (thinWallHalf.z < 0.0) {
 thinWallHalf = -thinWallHalf;
 }
 float thinWallViewHalf = abs(dot(viewLocal, thinWallHalf));
-vec3 lZ = vec3(cK(prepared, thinWallViewHalf, false));
+vec3 mT = vec3(cM(prepared, thinWallViewHalf, false));
 if (material.thinFilmWeight > 0.0) {
-lZ = bQ(
-lZ,
+mT = bR(
+mT,
 thinWallViewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
@@ -1353,8 +1353,8 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-vec3 gk = aq(
-lZ,
+vec3 gE = aq(
+mT,
 1.0
 );
 vec3 tint = bF(
@@ -1366,18 +1366,18 @@ response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 * aj(
 material,
 viewLocal,
-lm,
+mi,
 thinWallHalf,
-tint * (vec3(1.0) - gk),
+tint * (vec3(1.0) - gE),
 lobePdf
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dc(
+* df(
 material,
 material.relativeIor,
-ba(material),
+bb(material),
 viewLocal,
 lightLocal,
 aa,
@@ -1392,20 +1392,20 @@ pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * lobePdf;
 }
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) {
 if (material.thinWalled) {
-vec3 oQ = vec3(lightLocal.xy, -lightLocal.z);
+vec3 pY = vec3(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* bw(
+* bB(
 material,
 material.subsurfaceColor,
 viewLocal,
-oQ,
+pY,
 diffuseSpecularEnergyCompensation,
 lobePdf
 );
 lobePdf *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dK(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dO(
 material,
 viewLocal,
 lightLocal,
@@ -1423,13 +1423,13 @@ if (prepared.dielectricMsProbability > 0.0) {
 float cosine = abs(lightLocal.z);
 if (cosine > 0.0) {
 float ior = (reflection ? prepared.refractionEtaTOverEtaI : 1.0 / prepared.refractionEtaTOverEtaI);
-float iZ = (reflection ? prepared.dielectricMsReflectionRatio : 1.0 - prepared.dielectricMsReflectionRatio);
-float oP = prepared.dielectricMsViewLoss * aV(ior, prepared.specularAlpha, cosine)
-/ max(aY(ior, prepared.specularAlpha), 1e-12);
-float cv = min(oP * iZ, 1.0 / cosine);
+float fw = (reflection ? prepared.dielectricMsReflectionRatio : 1.0 - prepared.dielectricMsReflectionRatio);
+float pX = prepared.dielectricMsViewLoss * aV(ior, prepared.specularAlpha, cosine)
+/ max(aZ(ior, prepared.specularAlpha), 1e-12);
+float cA = min(pX * fw, 1.0 / cosine);
 vec3 scale = (reflection ? prepared.dielectricMsReflectionScale : prepared.dielectricMsTransmissionScale);
-response += scale * cv * INVPI;
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iZ * 0.5 * INVPI;
+response += scale * cA * INVPI;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * fw * 0.5 * INVPI;
 }
 }
 
@@ -1437,7 +1437,7 @@ pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMs
 } 
 #endif
 if (material.coatWeight > 0.0) {
-response *= cm(prepared,
+response *= cp(prepared,
 #ifdef USE_COAT_NORMAL_FRAMES
 independentCoat ? coatLightCosine : lightLocal.z
 #else
@@ -1456,39 +1456,39 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-vec3 dG = viewLocal;
-vec3 kQ = lightLocal;
+vec3 dI = viewLocal;
+vec3 lJ = lightLocal;
 vec3 coatHalf = aa;
 float coatViewHalf = viewHalf;
 if (prepared.directionFrames) {
-dG = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
+dI = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
 #ifdef USE_COAT_NORMAL_FRAMES
-if (independentCoat) { dG = prepared.coatViewLocal; }
+if (independentCoat) { dI = prepared.coatViewLocal; }
 #endif
-kQ = openpbr_to_local(prepared.coatBasis, lightDirection);
-coatHalf = normalize(kQ + dG);
+lJ = openpbr_to_local(prepared.coatBasis, lightDirection);
+coatHalf = normalize(lJ + dI);
 if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }
-coatViewHalf = abs(dot(dG, coatHalf));
+coatViewHalf = abs(dot(dI, coatHalf));
 }
 
-vec3 lB = vec3(ae(
+vec3 mr = vec3(ae(
 coatViewHalf,
 1.0 / material.coatIor
 ));
-OpenPbrResolvedMaterial dF = material;
-vec2 jD = aL(material.coatRoughness, material.coatAnisotropy);
-dF.alphaX = jD.x;
-dF.alphaY = jD.y;
+OpenPbrResolvedMaterial dH = material;
+vec2 kh = aL(material.coatRoughness, material.coatAnisotropy);
+dH.alphaX = kh.x;
+dH.alphaY = kh.y;
 response += prepared.weights[OPENPBR_LOBE_COAT]
 #ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(coatLightCosine, 0.0) : 1.0)
 #endif
 * aj(
-dF,
-dG,
-kQ,
+dH,
+dI,
+lJ,
 coatHalf,
-lB,
+mr,
 lobePdf
 );
 pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
@@ -1501,19 +1501,19 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-float rt = aQ(
+float sL = aQ(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3(0.0),
-vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rt)
+vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * sL)
 );
 response += prepared.weights[OPENPBR_LOBE_FUZZ]
 #ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(lightLocal.z, 0.0) : 1.0)
 #endif
-* kg(
+* kN(
 material,
 viewLocal,
 lightLocal,
@@ -1528,18 +1528,18 @@ if (independentCoat) { return response; }
 return response * abs(lightLocal.z);
 }
 
-vec3 sj(
+vec3 tJ(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bD,
+vec3 bE,
 vec3 normal,
 vec3 lightDirection,
 out float pdf
 ) {
-OpenPbrPreparedBsdf prepared = bV(
+OpenPbrPreparedBsdf prepared = bX(
 tangent,
 material,
-bD,
+bE,
 normal
 );
 return openpbr_eval_prepared(prepared, lightDirection, pdf);
@@ -1548,15 +1548,15 @@ return openpbr_eval_prepared(prepared, lightDirection, pdf);
 float openpbr_pdf(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bD,
+vec3 bE,
 vec3 normal,
 vec3 lightDirection
 ) {
 float pdf;
-sj(
+tJ(
 tangent,
 material,
-bD,
+bE,
 normal,
 lightDirection,
 pdf
@@ -1564,7 +1564,7 @@ pdf
 return pdf;
 }
 
-vec3 dl(
+vec3 dr(
 OpenPbrPreparedBsdf prepared,
 vec3 cc,
 out vec3 lightDirection,
@@ -1573,9 +1573,9 @@ out bool isTransmissionEvent
 ) {
 OpenPbrResolvedMaterial material = prepared.material;
 vec3 viewLocal = prepared.viewLocal;
-float cp = cc.x;
-float fp = cc.y;
-float bl = cc.z;
+float cr = cc.x;
+float fG = cc.y;
+float bm = cc.z;
 pdf = 0.0;
 isTransmissionEvent = false;
 lightDirection = prepared.basis.normal;
@@ -1588,7 +1588,7 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6) {
 lightDirection = openpbr_to_world(prepared.basis, -viewLocal);
 pdf = 1.0;
 isTransmissionEvent = true;
-return (ba(prepared.material) * cm(prepared,
+return (bb(prepared.material) * cp(prepared,
 #ifdef USE_COAT_NORMAL_FRAMES
 prepared.material.coatNormalEnabled ? dot(prepared.coatBasis.normal, lightDirection) : -prepared.viewLocal.z
 #else
@@ -1607,27 +1607,27 @@ return vec3(0.0);
 }
 
 vec3 lightLocal;
-if (bl < cdf[OPENPBR_LOBE_FUZZ] || (
-bl >= cdf[OPENPBR_LOBE_TRANSMISSION] && bl < cdf[OPENPBR_LOBE_DIFFUSE]
+if (bm < cdf[OPENPBR_LOBE_FUZZ] || (
+bm >= cdf[OPENPBR_LOBE_TRANSMISSION] && bm < cdf[OPENPBR_LOBE_DIFFUSE]
 )) {
-lightLocal = aM(vec2(cp, fp));
+lightLocal = aM(vec2(cr, fG));
 }
-else if (bl < cdf[OPENPBR_LOBE_COAT]) {
-vec3 dG = viewLocal;
-if (prepared.directionFrames) { dG = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)); }
+else if (bm < cdf[OPENPBR_LOBE_COAT]) {
+vec3 dI = viewLocal;
+if (prepared.directionFrames) { dI = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)); }
 #ifdef USE_COAT_NORMAL_FRAMES
-if (material.coatNormalEnabled) { dG = prepared.coatViewLocal; }
+if (material.coatNormalEnabled) { dI = prepared.coatViewLocal; }
 #endif
 vec3 aa = aA(
-dG,
+dI,
 
 aL(material.coatRoughness, material.coatAnisotropy),
-vec2(cp, fp)
+vec2(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
 }
-lightLocal = normalize(reflect(-dG, aa));
+lightLocal = normalize(reflect(-dI, aa));
 #ifdef USE_COAT_NORMAL_FRAMES
 if (material.coatNormalEnabled) {
 lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);
@@ -1637,20 +1637,20 @@ return openpbr_eval_prepared(prepared, lightDirection, pdf);
 #endif
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
-else if (bl < cdf[OPENPBR_LOBE_SPECULAR]) {
-bool uU = bl < cdf[OPENPBR_LOBE_METAL];
-float sK = (bl - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (uU && sK < prepared.metalMsProbability) {
-float z = cp;
-float dr = sqrt(max(0.0, 1.0 - z * z));
-float azimuth = TWOPI * fp;
-lightLocal = vec3(dr * cos(azimuth), dr * sin(azimuth), z);
+else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
+bool wI = bm < cdf[OPENPBR_LOBE_METAL];
+float uj = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (wI && uj < prepared.metalMsProbability) {
+float z = cr;
+float dw = sqrt(max(0.0, 1.0 - z * z));
+float azimuth = TWOPI * fG;
+lightLocal = vec3(dw * cos(azimuth), dw * sin(azimuth), z);
 }
 else {
 vec3 aa = aA(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cp, fp)
+vec2(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
@@ -1658,27 +1658,27 @@ aa = -aa;
 lightLocal = normalize(reflect(-viewLocal, aa));
 }
 }
-else if (bl < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 isTransmissionEvent = true;
 
 
-float wk = (bl - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && wk < prepared.dielectricMsProbability) {
-float iZ = prepared.dielectricMsReflectionRatio;
-bool mv = cp < iZ;
+float yj = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && yj < prepared.dielectricMsProbability) {
+float fw = prepared.dielectricMsReflectionRatio;
+bool nt = cr < fw;
 float z;
-if (mv) { z = min(cp / iZ, 0.99999994); }
-else { z = -min((cp - iZ) / (1.0 - iZ), 0.99999994); }
-float dr = sqrt(max(0.0, 1.0 - z * z));
-float azimuth = TWOPI * fp;
-lightLocal = vec3(dr * cos(azimuth), dr * sin(azimuth), z);
-isTransmissionEvent = !mv;
+if (nt) { z = min(cr / fw, 0.99999994); }
+else { z = -min((cr - fw) / (1.0 - fw), 0.99999994); }
+float dw = sqrt(max(0.0, 1.0 - z * z));
+float azimuth = TWOPI * fG;
+lightLocal = vec3(dw * cos(azimuth), dw * sin(azimuth), z);
+isTransmissionEvent = !nt;
 }
 else {
 vec3 aa = aA(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cp, fp)
+vec2(cr, fG)
 );
 if (aa.z < 0.0) {
 aa = -aa;
@@ -1689,7 +1689,7 @@ viewHalf,
 prepared.material.relativeIor
 ));
 if (material.thinFilmWeight > 0.0) {
-fresnel = bQ(
+fresnel = bR(
 fresnel,
 viewHalf,
 material.thinFilmThickness,
@@ -1700,8 +1700,8 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-vec3 hX = normalize(reflect(-viewLocal, aa));
-lightLocal = vec3(hX.xy, -hX.z);
+vec3 iI = normalize(reflect(-viewLocal, aa));
+lightLocal = vec3(iI.xy, -iI.z);
 }
 else {
 lightLocal = refract(
@@ -1720,13 +1720,13 @@ lightLocal = normalize(lightLocal);
 else {
 isTransmissionEvent = true;
 if (material.thinWalled) {
-float kW = cp;
-bool qD = kW >= 0.5;
-cp = qD
-? (kW - 0.5) * 2.0
-: kW * 2.0;
-lightLocal = aM(vec2(cp, fp));
-if (qD) {
+float lP = cr;
+bool rR = lP >= 0.5;
+cr = rR
+? (lP - 0.5) * 2.0
+: lP * 2.0;
+lightLocal = aM(vec2(cr, fG));
+if (rR) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1734,7 +1734,7 @@ isTransmissionEvent = false;
 }
 }
 else {
-lightLocal = aM(vec2(cp, fp));
+lightLocal = aM(vec2(cr, fG));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1751,17 +1751,17 @@ if (material.coatNormalEnabled &&
 return openpbr_eval_prepared(prepared, lightDirection, pdf);
 }
 
-vec3 uc(
+vec3 vL(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
 vec3 cc,
-vec3 bD,
+vec3 bE,
 vec3 normal,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
-OpenPbrPreparedBsdf prepared = bV(tangent, material, bD, normal);
-return dl(prepared, cc, lightDirection, pdf, isTransmissionEvent);
+OpenPbrPreparedBsdf prepared = bX(tangent, material, bE, normal);
+return dr(prepared, cc, lightDirection, pdf, isTransmissionEvent);
 }`;
 //# sourceMappingURL=openPbrBsdf.glsl.js.map