@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -26,18 +26,18 @@ const int OPENPBR_LOBE_DIFFUSE = 5;
 const int OPENPBR_LOBE_SUBSURFACE = 6;
 const int OPENPBR_LOBE_COUNT = 7;
 
-struct bj {
+struct bq {
 vec3 tangent;
 vec3 bitangent;
 vec3 normal;
 };
 
 struct ag {
-J material;
-bj basis;
-bj coatBasis;
+OpenPbrResolvedMaterial material;
+bq basis;
+bq coatBasis;
 bool directionFrames;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 vec3 coatViewLocal;
 #endif
 vec3 viewLocal;
@@ -64,250 +64,250 @@ float weights[OPENPBR_LOBE_COUNT];
 float probabilities[OPENPBR_LOBE_COUNT];
 };
 
-float aw(vec3 color) {
+float aE(vec3 color) {
 return dot(color, vec3(0.212671, 0.715160, 0.072169));
 }
 
-float cV(float bu) {
-float value = (bu - 1.0) / (bu + 1.0);
+float dd(float bE) {
+float value = (bE - 1.0) / (bE + 1.0);
 return value * value;
 }
 
-float aY(
-float bu,
+float bi(
+float bE,
 float specularWeight
 ) {
-float sR = min(
-cV(bu) * specularWeight,
+float uh = min(
+dd(bE) * specularWeight,
 0.9999
 );
-float sT = sqrt(sR);
-float lh = (1.0 + sT) / (1.0 - sT);
-return bu < 1.0 ? 1.0 / lh : lh;
+float uj = sqrt(uh);
+float lR = (1.0 + uj) / (1.0 - uj);
+return bE < 1.0 ? 1.0 / lR : lR;
 }
 
-float af(float cc, float relativeIor) {
+float af(float ci, float relativeIor) {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return cu(cc, relativeIor);
+return cC(ci, relativeIor);
 }
 
-float aC(float ior) {
+float aG(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 sl, int row) {
-return texelFetch(openPbrEnergyLut, ivec2(sl, row), 0).r;
+float F(int tB, int row) {
+return texelFetch(openPbrEnergyLut, ivec2(tB, row), 0).r;
 }
 
-float gd(
-float dJ,
-float bR,
-float hR
+float gt(
+float dU,
+float bV,
+float im
 ) {
-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 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);
+float bH = clamp(dU, 0.0, 31.0);
+float aL = clamp(bV, 0.0, 31.0);
+float bD = clamp(im, 0.0, 31.0);
+int ef = int(floor(bH));
+int aT = int(floor(aL));
+int cQ = int(floor(bD));
+int hU = min(ef + 1, 31);
+int cu = min(aT + 1, 31);
+int fb = min(cQ + 1, 31);
+float cv = bH - float(ef);
+float cI = aL - float(aT);
+float lj = bD - float(cQ);
+
+float wb = F(cQ, ef * 32 + aT);
+float wc = F(fb, ef * 32 + aT);
+float wd = F(cQ, ef * 32 + cu);
+float wf = F(fb, ef * 32 + cu);
+float wg = F(cQ, hU * 32 + aT);
+float wh = F(fb, hU * 32 + aT);
+float wi = F(cQ, hU * 32 + cu);
+float wj = F(fb, hU * 32 + cu);
+float v00 = mix(wb, wg, cv);
+float v01 = mix(wc, wh, cv);
+float v10 = mix(wd, wi, cv);
+float v11 = mix(wf, wj, cv);
 return mix(
-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);
+mix(v00, v10, cI),
+mix(v01, v11, cI),
+lj
+);
+}
+
+float gS(float dU, float bV) {
+float bH = clamp(dU, 0.0, 31.0);
+float aL = clamp(bV, 0.0, 31.0);
+int ef = int(floor(bH));
+int aT = int(floor(aL));
+int hU = min(ef + 1, 31);
+int cu = min(aT + 1, 31);
+float cv = bH - float(ef);
+float cI = aL - float(aT);
+float v00 = F(aT, 1024 + ef);
+float v01 = F(cu, 1024 + ef);
+float v10 = F(aT, 1024 + hU);
+float v11 = F(cu, 1024 + hU);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-cz
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
 );
 }
 
 
 
-float ef(
-float dJ,
-float bR,
-float hR
+float ev(
+float dU,
+float bV,
+float im
 ) {
-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 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);
+float bH = clamp(dU, 0.0, 31.0);
+float aL = clamp(bV, 0.0, 31.0);
+float bD = clamp(im, 0.0, 31.0);
+int ef = int(floor(bH));
+int aT = int(floor(aL));
+int cQ = int(floor(bD));
+int hU = min(ef + 1, 31);
+int cu = min(aT + 1, 31);
+int fb = min(cQ + 1, 31);
+float cv = bH - float(ef);
+float cI = aL - float(aT);
+float lj = bD - float(cQ);
+
+float wb = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + aT);
+float wc = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + aT);
+float wd = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + cu);
+float wf = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + cu);
+float wg = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + aT);
+float wh = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + aT);
+float wi = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + cu);
+float wj = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + cu);
+float v00 = mix(wb, wg, cv);
+float v01 = mix(wc, wh, cv);
+float v10 = mix(wd, wi, cv);
+float v11 = mix(wf, wj, cv);
 return mix(
-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);
+mix(v00, v10, cI),
+mix(v01, v11, cI),
+lj
+);
+}
+
+float eu(float dU, float bV) {
+float bH = clamp(dU, 0.0, 31.0);
+float aL = clamp(bV, 0.0, 31.0);
+int ef = int(floor(bH));
+int aT = int(floor(aL));
+int hU = min(ef + 1, 31);
+int cu = min(aT + 1, 31);
+float cv = bH - float(ef);
+float cI = aL - float(aT);
+float v00 = F(aT, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ef);
+float v01 = F(cu, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ef);
+float v10 = F(aT, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hU);
+float v11 = F(cu, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hU);
 return mix(
-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);
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
+);
+}
+
+float eR(float dU, float bV) {
+float bH = clamp(dU, 0.0, 31.0);
+float aL = clamp(bV, 0.0, 31.0);
+int ef = int(floor(bH));
+int aT = int(floor(aL));
+int hU = min(ef + 1, 31);
+int cu = min(aT + 1, 31);
+float cv = bH - float(ef);
+float cI = aL - float(aT);
+float v00 = F(aT, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ef);
+float v01 = F(cu, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ef);
+float v10 = F(aT, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hU);
+float v11 = F(cu, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hU);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-cz
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
 );
 }
 
-float bO(float ior, float alpha, float au) {
-return ef(aC(ior), sqrt(alpha) * 31.0, au * 31.0);
+float bb(float ior, float alpha, float cosine) {
+return ev(aG(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-float cO(float ior, float alpha) {
-return ee(aC(ior), sqrt(alpha) * 31.0);
+float bf(float ior, float alpha) {
+return eu(aG(ior), sqrt(alpha) * 31.0);
 }
-float ch(float ior, float alpha) {
-return eG(aC(ior), sqrt(alpha) * 31.0);
+float ck(float ior, float alpha) {
+return eR(aG(ior), sqrt(alpha) * 31.0);
 }
 
 
-float bH(float alpha, float au) {
-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(ie));
-int c0 = int(floor(bt));
+float aV(float alpha, float cosine) {
+float iF = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+float bD = clamp(cosine * 31.0, 0.0, 31.0);
+int r0 = int(floor(iF));
+int c0 = int(floor(bD));
 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(ie));
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(bD)),
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bD)),
+fract(iF));
 }
 
-float cv(float alpha) {
+float cD(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 bd(float value, float ior) {
 if (ior > 2.5 || ior < 0.4) {
-float tU = cV(2.5);
-float progress = (cV(ior) - tU) / (1.0 - tU);
+float vu = dd(2.5);
+float progress = (dd(ior) - vu) / (1.0 - vu);
 return (1.0 - progress) * value;
 }
 return value;
 }
 
-float aJ(
+float aw(
 float ior,
 float alpha,
-float au
+float cosine
 ) {
-float value = gd(
-aC(ior),
+float value = gt(
+aG(ior),
 sqrt(alpha) * 31.0,
-au * 31.0
+cosine * 31.0
 );
-return aX(value, ior);
+return bd(value, ior);
 }
 
-float cr(float ior, float alpha) {
-float value = gF(
-aC(ior),
+float cA(float ior, float alpha) {
+float value = gS(
+aG(ior),
 sqrt(alpha) * 31.0
 );
-return aX(value, ior);
+return bd(value, ior);
 }
 
-vec3 openpbr_to_world(bj basis, vec3 direction) {
+vec3 openpbr_to_world(bq basis, vec3 direction) {
 return direction.x * basis.tangent
 + direction.y * basis.bitangent
 + direction.z * basis.normal;
 }
 
-vec3 openpbr_to_local(bj basis, vec3 direction) {
+vec3 openpbr_to_local(bq basis, vec3 direction) {
 return vec3(
 dot(direction, basis.tangent),
 dot(direction, basis.bitangent),
@@ -315,19 +315,19 @@ dot(direction, basis.normal)
 );
 }
 
-bj fj(
-vec3 aT,
+bq fD(
+vec3 aX,
 vec3 normal,
 float anisotropy
 ) {
-bj basis;
+bq basis;
 basis.normal = normal;
 basis.tangent = vec3(0.0);
 #ifdef USE_TANGENT
-basis.tangent = aT;
+basis.tangent = aX;
 #endif
 if (dot(basis.tangent, basis.tangent) < 0.001 || anisotropy <= 0.0) {
-aL(normal, basis.tangent, basis.bitangent);
+aP(normal, basis.tangent, basis.bitangent);
 }
 else {
 basis.bitangent = normalize(cross(normal, basis.tangent));
@@ -336,310 +336,310 @@ basis.tangent = normalize(cross(basis.bitangent, normal));
 return basis;
 }
 
-float ka(
-float av,
-float ak,
-float L,
-float S
+float kF(
+float aB,
+float am,
+float J,
+float ae
 ) {
-return (av * L - ak * S)
-/ (av * L + ak * S);
+return (aB * J - am * ae)
+/ (aB * J + am * ae);
 }
 
-float jZ(
-float av,
-float ak,
-float L,
-float S
+float kE(
+float aB,
+float am,
+float J,
+float ae
 ) {
-return (ak * L - av * S)
-/ (av * S + ak * L);
+return (am * J - aB * ae)
+/ (aB * ae + am * J);
 }
 
-float hc(
-float av,
-float ak,
-float L,
-float S
+float ht(
+float aB,
+float am,
+float J,
+float ae
 ) {
-return 2.0 * av * L
-/ (av * L + ak * S);
+return 2.0 * aB * J
+/ (aB * J + am * ae);
 }
 
-float hb(
-float av,
-float ak,
-float L,
-float S
+float hs(
+float aB,
+float am,
+float J,
+float ae
 ) {
-return 2.0 * av * L
-/ (av * S + ak * L);
+return 2.0 * aB * J
+/ (aB * ae + am * J);
 }
 
-vec2 aU(vec2 a, vec2 b) {
+vec2 aY(vec2 a, vec2 b) {
 return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
-vec2 aZ(vec2 a, vec2 b) {
-float ap = max(dot(b, b), 1e-9);
+vec2 bj(vec2 a, vec2 b) {
+float aq = max(dot(b, b), 1e-9);
 return vec2(
-(a.x * b.x + a.y * b.y) / ap,
-(a.y * b.x - a.x * b.y) / ap
+(a.x * b.x + a.y * b.y) / aq,
+(a.y * b.x - a.x * b.y) / aq
 );
 }
 
-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 iA(vec2 value) {
+float gR = length(value);
+float uf = sqrt(max(0.0, 0.5 * (gR + value.x)));
+float fw = sqrt(max(0.0, 0.5 * (gR - value.x)));
+return vec2(uf, value.y >= 0.0 ? fw : -fw);
 }
 
-vec2 bX(
-float L,
-float av,
-vec2 ak,
-bool qG
+vec2 ce(
+float J,
+float aB,
+vec2 am,
+bool rM
 ) {
-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)
+float pg = sqrt(max(0.0, 1.0 - J * J));
+vec2 tP = bj(vec2(aB, 0.0), am);
+vec2 hQ = tP * pg;
+vec2 ae = iA(
+vec2(1.0, 0.0) - aY(hQ, hQ)
 );
-if (aU(ak, S).y < 0.0) {
-S = -S;
+if (aY(am, ae).y < 0.0) {
+ae = -ae;
 }
 
-vec2 fK = vec2(av * L, 0.0);
-vec2 eB = aU(ak, S);
-if (qG) {
-vec2 ci = ak * L;
-vec2 ce = S * av;
-return aZ(
-ci - ce,
-ci + ce
+vec2 fZ = vec2(aB * J, 0.0);
+vec2 eJ = aY(am, ae);
+if (rM) {
+vec2 cl = am * J;
+vec2 cj = ae * aB;
+return bj(
+cl - cj,
+cl + cj
 );
 }
-return aZ(
-fK - eB,
-fK + eB
+return bj(
+fZ - eJ,
+fZ + eJ
 );
 }
 
-float eq(
-float iH,
-float gM,
-float oH,
-float mN,
-vec2 kf,
+float eE(
+float iZ,
+float ha,
+float pw,
+float nL,
+vec2 kL,
 float phase
 ) {
-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);
+vec2 ol = vec2(cos(phase), sin(phase));
+vec2 iD = aY(kL, ol);
+vec2 lv = iD * (ha * nL);
+vec2 aq = vec2(1.0, 0.0) - iD * pw;
+vec2 hP = vec2(iZ, 0.0)
++ bj(lv, aq);
+return dot(hP, hP);
 }
 
-float ar(
-float L,
+float au(
+float J,
 float wavelength,
+float ct,
+float aR,
 float cn,
-float aM,
-float ck,
-vec2 eu
+vec2 eG
 ) {
-L = clamp(abs(L), 1e-5, 1.0);
-float hu = pow(aM / ck, 2.0)
-* (1.0 - L * L);
-if (hu >= 1.0) {
+J = clamp(abs(J), 1e-5, 1.0);
+float hI = pow(aR / cn, 2.0)
+* (1.0 - J * J);
+if (hI >= 1.0) {
 return 1.0;
 }
-float cU = sqrt(1.0 - hu);
-float lb = ka(
-aM, ck, L, cU
+float dc = sqrt(1.0 - hI);
+float lL = kF(
+aR, cn, J, dc
 );
-float la = jZ(
-aM, ck, L, cU
+float lK = kE(
+aR, cn, J, dc
 );
-float jj = hc(
-aM, ck, L, cU
+float jG = ht(
+aR, cn, J, dc
 );
-float ji = hb(
-aM, ck, L, cU
+float jF = hs(
+aR, cn, J, dc
 );
-float gq = ck * cU
-/ max(aM * L, 1e-9);
-vec2 tb = bX(
-cU, ck, eu, false
+float gG = cn * dc
+/ max(aR * J, 1e-9);
+vec2 ut = ce(
+dc, cn, eG, false
 );
-vec2 ta = bX(
-cU, ck, eu, true
+vec2 us = ce(
+dc, cn, eG, true
 );
-float phase = 2.0 * PI * (2.0 * ck * cn * cU) / wavelength;
-float tJ = eq(
-lb,
-jj,
--lb,
-jj * gq,
-tb,
+float phase = 2.0 * PI * (2.0 * cn * ct * dc) / wavelength;
+float uZ = eE(
+lL,
+jG,
+-lL,
+jG * gG,
+ut,
 phase
 );
-float tI = eq(
-la,
-ji,
--la,
-ji * gq,
-ta,
+float uY = eE(
+lK,
+jF,
+-lK,
+jF * gG,
+us,
 phase
 );
-return clamp(0.5 * (tJ + tI), 0.0, 1.0);
+return clamp(0.5 * (uZ + uY), 0.0, 1.0);
 }
 
-vec3 hG(
-float L,
+vec3 hW(
+float J,
+float ct,
 float cn,
-float ck,
-float eu,
-float aM
+float eG,
+float aR
 ) {
 return vec3(
-ar(
-L, 620.0, cn, aM, ck, vec2(eu, 0.0)
+au(
+J, 620.0, ct, aR, cn, vec2(eG, 0.0)
 ),
-ar(
-L, 540.0, cn, aM, ck, vec2(eu, 0.0)
+au(
+J, 540.0, ct, aR, cn, vec2(eG, 0.0)
 ),
-ar(
-L, 450.0, cn, aM, ck, vec2(eu, 0.0)
+au(
+J, 450.0, ct, aR, cn, vec2(eG, 0.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));
+vec3 cw(float cosine, vec3 f0, vec3 tint) {
+vec3 sr = mix(f0, vec3(1.0), aI(cosine));
+if (all(equal(tint, vec3(1.0)))) { return sr; }
+float dD = 1.0 / 7.0;
+float mY = 1.0 - dD;
+vec3 fX = mix(f0, vec3(1.0), aI(dD));
+float dw = 1.0 - cosine;
+float ru = cosine * aI(cosine) * dw
+/ (dD * pow(mY, 6.0));
+return clamp(sr - ru * (fX - tint * fX), vec3(0.0), vec3(1.0));
 }
 
-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
+vec2 cX(float f0, float uN) {
+float dY = clamp(f0, 0.0, 0.99);
+float gZ = sqrt(dY);
+float rK = (1.0 - dY) / (1.0 + dY);
+float rH = (1.0 + gZ) / max(1.0 - gZ, 1e-9);
+float ior = mix(rH, rK, clamp(uN, 0.0, 1.0));
+float kp = (
+(ior + 1.0) * (ior + 1.0) * dY
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dN, 1e-9);
-return vec2(ior, sqrt(max(jO, 0.0)));
+) / max(1.0 - dY, 1e-9);
+return vec2(ior, sqrt(max(kp, 0.0)));
 }
 
-vec3 iY(
-float L,
+vec3 jr(
+float J,
+float ct,
 float cn,
-float ck,
-vec3 rf,
-vec3 jW,
-float aM
+vec3 sm,
+vec3 kA,
+float aR
 ) {
 return vec3(
-ar(
-L,
+au(
+J,
 620.0,
+ct,
+aR,
 cn,
-aM,
-ck,
-cQ(rf.r, jW.r)
+cX(sm.r, kA.r)
 ),
-ar(
-L,
+au(
+J,
 540.0,
+ct,
+aR,
 cn,
-aM,
-ck,
-cQ(rf.g, jW.g)
+cX(sm.g, kA.g)
 ),
-ar(
-L,
+au(
+J,
 450.0,
+ct,
+aR,
 cn,
-aM,
-ck,
-cQ(rf.b, jW.b)
+cX(sm.b, kA.b)
 )
 );
 }
 
-float bN(float cn, float weight) {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cn);
+float bS(float ct, float weight) {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ct);
 }
 
-vec3 bW(
-vec3 ei,
-float L,
+vec3 cc(
+vec3 ey,
+float J,
+float ct,
 float cn,
-float ck,
-float eu,
+float eG,
 float weight,
-float aM
+float aR
 ) {
-vec3 pq = hG(
-L,
+vec3 qn = hW(
+J,
+ct,
 cn,
-ck,
-eu,
-aM
+eG,
+aR
 );
 return mix(
-ei,
-pq,
-bN(cn, weight)
+ey,
+qn,
+bS(ct, weight)
 );
 }
 
-vec3 lq(
-vec3 ei,
-float L,
+vec3 lZ(
+vec3 ey,
+float J,
+float ct,
 float cn,
-float ck,
-vec3 rf,
-vec3 jW,
+vec3 sm,
+vec3 kA,
 float weight,
-float aM
+float aR
 ) {
-vec3 pq = iY(
-L,
+vec3 qn = jr(
+J,
+ct,
 cn,
-ck,
-rf,
-jW,
-aM
+sm,
+kA,
+aR
 );
 return mix(
-ei,
-pq,
-bN(cn, weight)
+ey,
+qn,
+bS(ct, weight)
 );
 }
 
-vec3 cE(
-J material,
+vec3 bJ(
+OpenPbrResolvedMaterial material,
 vec3 color,
 vec3 viewLocal,
 vec3 lightLocal,
-float ft,
+float fJ,
 out float pdf
 ) {
 pdf = 0.0;
@@ -648,50 +648,50 @@ return vec3(0.0);
 }
 
 float roughness = material.diffuseRoughness;
-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 hl = 0.5 - 2.0 / (3.0 * PI);
+float pc = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+float pp = lightLocal.z;
+float nt = viewLocal.z;
+float directional = dot(lightLocal, viewLocal) - pp * nt;
+float hh = directional > 0.0
+? directional / max(max(pp, nt), 1e-7)
+: directional;
+float iJ = 1.0 / (1.0 + hl * roughness);
+vec3 ot = color * INVPI * iJ
+* (1.0 + roughness * hh);
+
+float dr = 1.0 - pp;
+float outputComplement = 1.0 - nt;
+float ph = dr * (
+0.0571085289 + dr * (
+0.491881867 + dr * (
+-0.332181442 + dr * 0.0714429953
 )
 )
 );
-float nq = cP * (
-0.0571085289 + cP * (
-0.491881867 + cP * (
--0.332181442 + cP * 0.0714429953
+float outputGOverPi = outputComplement * (
+0.0571085289 + outputComplement * (
+0.491881867 + outputComplement * (
+-0.332181442 + outputComplement * 0.0714429953
 )
 )
 );
-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);
+float qr = (1.0 + roughness * ph)
+/ (1.0 + hl * roughness);
+float outputAlbedo = (1.0 + roughness * outputGOverPi)
+/ (1.0 + hl * roughness);
+float gi = iJ * (1.0 + pc * roughness);
+vec3 hV = color * color * gi
+/ max(vec3(1e-7), vec3(1.0) - color * (1.0 - gi));
+vec3 mn = hV * INVPI
+* max(1e-7, 1.0 - outputAlbedo)
+* max(1e-7, 1.0 - qr)
+/ max(1e-7, 1.0 - gi);
 pdf = lightLocal.z * INVPI;
-return (nA + lF) * ft;
+return (ot + mn) * fJ;
 }
 
-float aO(float viewCosine, float roughness) {
+float aU(float viewCosine, float roughness) {
 float x = clamp(viewCosine, 0.0, 1.0);
 float y = clamp(roughness, 0.01, 1.0);
 float scale = y * (0.0206607 + 1.58491 * y)
@@ -705,8 +705,8 @@ float gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-vec3 jY(
-J material,
+vec3 kD(
+OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
 out float pdf
@@ -715,7 +715,7 @@ pdf = 0.0;
 if (viewLocal.z <= 0.0 || lightLocal.z <= 0.0) {
 return vec3(0.0);
 }
-float albedo = aO(
+float albedo = aU(
 viewLocal.z,
 material.fuzzRoughness
 );
@@ -723,12 +723,12 @@ pdf = lightLocal.z * INVPI;
 return material.fuzzColor * albedo * INVPI;
 }
 
-vec3 am(
-J material,
+vec3 ao(
+OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
-vec3 V,
-vec3 cK,
+vec3 ad,
+vec3 bG,
 out float pdf
 ) {
 pdf = 0.0;
@@ -737,24 +737,24 @@ return vec3(0.0);
 }
 
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-float distribution = gK(V, alpha);
-float jV = bk(viewLocal, alpha);
-float ea = jV
-* bk(lightLocal, alpha);
+float distribution = cW(ad, alpha);
+float kz = aF(viewLocal, alpha);
+float ep = kz
+* aF(lightLocal, alpha);
 
-pdf = jV * distribution / (4.0 * max(viewLocal.z, 1e-8));
-return cK * distribution * ea
+pdf = kz * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return bG * distribution * ep
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-vec3 dl(
-J material,
+vec3 dE(
+OpenPbrResolvedMaterial material,
 float relativeIor,
 vec3 tint,
 vec3 viewLocal,
 vec3 lightLocal,
-vec3 V,
-vec3 cK,
+vec3 ad,
+vec3 bG,
 out float pdf
 ) {
 pdf = 0.0;
@@ -762,31 +762,31 @@ if (lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
 
-float kL = dot(lightLocal, V);
-float bQ = dot(viewLocal, V);
+float ls = dot(lightLocal, ad);
+float bm = dot(viewLocal, ad);
 
 
-if (bQ <= 0.0 || kL >= 0.0) {
+if (bm <= 0.0 || ls >= 0.0) {
 return vec3(0.0);
 }
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-float distribution = gK(V, alpha);
-float jV = bk(viewLocal, alpha);
-float ea = jV
-* bk(lightLocal, alpha);
-float ap = kL + bQ * relativeIor;
-ap *= ap;
-float pJ = abs(kL) / max(ap, 1e-8);
-float ju = relativeIor * relativeIor;
-
-pdf = jV * max(0.0, bQ) * distribution * pJ
+float distribution = cW(ad, alpha);
+float kz = aF(viewLocal, alpha);
+float ep = kz
+* aF(lightLocal, alpha);
+float aq = ls + bm * relativeIor;
+aq *= aq;
+float qw = abs(ls) / max(aq, 1e-8);
+float jU = relativeIor * relativeIor;
+
+pdf = kz * max(0.0, bm) * distribution * qw
 / max(viewLocal.z, 1e-8);
-return tint * (vec3(1.0) - cK) * distribution * ea
-* abs(bQ) * pJ * ju
+return tint * (vec3(1.0) - bG) * distribution * ep
+* abs(bm) * qw * jU
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-vec3 bn(J material) {
+vec3 bh(OpenPbrResolvedMaterial material) {
 #ifdef HAS_MEDIUM
 if (material.mediumType > 0) {
 return vec3(1.0);
@@ -795,44 +795,44 @@ return vec3(1.0);
 return material.transmissionColor;
 }
 
-float cS(float ah) {
-return 2.0 * ah / (1.0 + ah);
+float cZ(float ai) {
+return 2.0 * ai / (1.0 + ai);
 }
 
-vec3 aP(
-vec3 ah,
+vec3 av(
+vec3 ai,
 float transmissionWeight
 ) {
-vec3 gk = 2.0 * ah
-/ (vec3(1.0) + ah);
+vec3 gA = 2.0 * ai
+/ (vec3(1.0) + ai);
 return mix(
-ah,
-gk,
+ai,
+gA,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
 
-vec3 bG(
-J material,
-float L,
-float bu
+vec3 bN(
+OpenPbrResolvedMaterial material,
+float J,
+float bE
 ) {
-vec3 tint = bn(material);
+vec3 tint = bh(material);
 if (!material.thinWalled) {
 return tint;
 }
-float iL = max(0.0, 1.0 - L * L);
-float dO = iL
-/ max(bu * bu, 1e-9);
-if (dO >= 1.0) {
+float jc = max(0.0, 1.0 - J * J);
+float ea = jc
+/ max(bE * bE, 1e-9);
+if (ea >= 1.0) {
 return vec3(0.0);
 }
-float S = sqrt(1.0 - dO);
-return pow(max(tint, vec3(0.0)), vec3(1.0 / max(S, 1e-5)));
+float ae = sqrt(1.0 - ea);
+return pow(max(tint, vec3(0.0)), vec3(1.0 / max(ae, 1e-5)));
 }
 
-vec3 dM(
-J material,
+vec3 dX(
+OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
 out float pdf
@@ -841,164 +841,164 @@ pdf = 0.0;
 if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
-float S = -lightLocal.z;
-float og = cu(
+float ae = -lightLocal.z;
+float oY = cC(
 viewLocal.z,
 material.relativeIor
 );
-pdf = S * INVPI;
-return vec3(1.0 - og) * INVPI;
+pdf = ae * INVPI;
+return vec3(1.0 - oY) * INVPI;
 }
 
-void dR(inout ag prepared) {
+void eg(inout ag prepared) {
 float total = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-for (int hU = 1; hU < OPENPBR_LOBE_COUNT; hU++) {
-total += prepared.probabilities[hU];
+for (int jT = 1; jT < OPENPBR_LOBE_COUNT; jT++) {
+total += prepared.probabilities[jT];
 }
 if (total <= 1e-8) {
-for (int hU = 0; hU < OPENPBR_LOBE_COUNT; hU++) {
-prepared.probabilities[hU] = 0.0;
+for (int jT = 0; jT < OPENPBR_LOBE_COUNT; jT++) {
+prepared.probabilities[jT] = 0.0;
 }
 return;
 }
-float ow = 1.0 / total;
-for (int hU = 0; hU < OPENPBR_LOBE_COUNT; hU++) {
-prepared.probabilities[hU] *= ow;
+float pk = 1.0 / total;
+for (int jT = 0; jT < OPENPBR_LOBE_COUNT; jT++) {
+prepared.probabilities[jT] *= pk;
 }
 }
 
 
 
-float bM(float eta) {
+float bR(float eta) {
 if (abs(eta - 1.0) < 1e-6) { return 0.0; }
 if (eta > 1.0) { return (eta - 1.0) / (4.08567 + 1.00071 * eta); }
 return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * eta;
 }
 
-vec3 bP(vec3 f0, vec3 tint) {
-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));
+vec3 bU(vec3 f0, vec3 tint) {
+float dD = 1.0 / 7.0;
+vec3 fX = mix(f0, vec3(1.0), aI(dD));
+vec3 b = fX * (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 cD(J material, float au) {
-if (au <= 0.0) { return vec3(1.0); }
-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);
+vec3 cN(OpenPbrResolvedMaterial material, float cosine) {
+if (cosine <= 0.0) { return vec3(1.0); }
+float mp = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
+vec3 uT = pow(max(material.coatColor, vec3(0.0)), vec3(0.5 / max(mp, 1e-5)));
+return mix(vec3(1.0), uT, material.coatWeight);
 }
 
-float gp(J material, float au) {
+float gF(OpenPbrResolvedMaterial material, float cosine) {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
-return af(au, 1.0 / material.coatIor);
+return af(cosine, 1.0 / material.coatIor);
 }
 
 
-return clamp(1.0 - aJ(material.coatIor,
-material.coatRoughness * material.coatRoughness, au), 0.0, 1.0);
+return clamp(1.0 - aw(material.coatIor,
+material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);
 }
 
-vec3 ha(ag prepared) {
-J material = prepared.material;
+vec3 hr(ag 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 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 vI = dielectric * material.transmissionWeight;
+float gd = bR(prepared.specularEtaTOverEtaI);
+float lE = bR(1.0 / prepared.transmissionReflectionIor);
+float qI = clamp(opaque * gd + (sss + vI) * lE + material.baseMetalness, 0.0, 1.0);
+float jM = mix(1.0, material.specularRoughness, qI);
+float ks = bR(material.coatIor);
 float kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-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), 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);
+float k = mix(ks, kr, jM);
+vec3 eb = material.baseMetalness * material.specularWeight * bU(material.baseWeight * material.baseColor, material.specularColor)
++ opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), gd)
++ sss * material.subsurfaceColor + vec3(vI);
+vec3 rZ = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
+return mix(vec3(1.0), rZ, material.coatWeight * material.coatDarkening);
 }
 
-vec3 ds(ag prepared, float lm) {
+vec3 cF(ag prepared, float lU) {
 if (prepared.material.coatWeight <= 0.0) { return vec3(1.0); }
 if (prepared.material.inside) {
 
-return cD(prepared.material, -lm);
+return cN(prepared.material, -lU);
 }
 
-return prepared.coatBaseScale * cD(prepared.material, lm);
+return prepared.coatBaseScale * cN(prepared.material, lU);
 }
 
 
-bj du(bj fallback, vec3 tangent, vec3 bitangent, vec2 direction) {
+bq dM(bq 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);
 vec3 b = cross(fallback.normal, t) * (dot(cross(fallback.normal, t), bitangent) < 0.0 ? -1.0 : 1.0);
 t = t * direction.x + b * direction.y;
 if (dot(t, t) < 1e-8) { return fallback; }
-bj basis = fallback;
+bq basis = fallback;
 basis.tangent = normalize(t);
 basis.bitangent = normalize(cross(basis.normal, basis.tangent));
 basis.tangent = normalize(cross(basis.bitangent, basis.normal));
 return basis;
 }
 
-ag eH(
+ag ds(
 vec3 tangent,
-J material,
-vec3 bF,
+OpenPbrResolvedMaterial material,
+vec3 bM,
 vec3 normal
 ) {
 ag prepared;
 prepared.material = material;
-prepared.basis = fj(
+prepared.basis = fD(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
 );
 prepared.coatBasis = prepared.basis;
 prepared.directionFrames = false;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fj(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = fD(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 #endif
 if (material.specularAnisotropy > 0.0 && material.anisotropyDirectionEnabled) {
-prepared.basis = du(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 = du(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, bF);
-#ifdef NUM_COAT_NORMAL_MAPS
-prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bF);
+prepared.viewLocal = openpbr_to_local(prepared.basis, bM);
+#ifdef USE_COAT_NORMAL_FRAMES
+prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bM);
 #endif
 prepared.diffuseColor = material.baseColor;
 
-float cB = 1.0 - material.baseMetalness;
-float dL = cB
+float cK = 1.0 - material.baseMetalness;
+float dW = cK
 * (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] = cB;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cB
+prepared.weights[OPENPBR_LOBE_SPECULAR] = cK;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cK
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dL
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dW
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dL
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dW
 * material.subsurfaceWeight;
 
-prepared.specularEtaTOverEtaI = aY(
+prepared.specularEtaTOverEtaI = bi(
 1.0 / material.relativeIor,
 material.specularWeight
 );
@@ -1008,20 +1008,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-float cj = 1.0;
-if (!material.inside) { cj = mix(1.0, material.coatIor, material.coatWeight); }
-float bq = cj * aY(
-material.specularIor / cj, material.specularWeight);
-float er = bq / cj;
-if (cj > bq && bq >= 1.0) {
-er = 1.0 / er;
-}
-prepared.specularEtaTOverEtaI = er;
-prepared.transmissionReflectionIor = 1.0 / er;
-prepared.refractionEtaTOverEtaI = bq;
+float cm = 1.0;
+if (!material.inside) { cm = mix(1.0, material.coatIor, material.coatWeight); }
+float bB = cm * bi(
+material.specularIor / cm, material.specularWeight);
+float eF = bB / cm;
+if (cm > bB && bB >= 1.0) {
+eF = 1.0 / eF;
+}
+prepared.specularEtaTOverEtaI = eF;
+prepared.transmissionReflectionIor = 1.0 / eF;
+prepared.refractionEtaTOverEtaI = bB;
 if (material.inside) {
-prepared.refractionEtaTOverEtaI = 1.0 / bq;
-prepared.transmissionReflectionIor = bq;
+prepared.refractionEtaTOverEtaI = 1.0 / bB;
+prepared.transmissionReflectionIor = bB;
 }
 prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
 }
@@ -1043,88 +1043,88 @@ prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;
 prepared.specularAlpha = material.specularRoughness
 * material.specularRoughness;
 float viewCosine = abs(prepared.viewLocal.z);
-float ah = af(
+float ai = af(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-vec3 fw = material.specularColor * (
+vec3 fN = material.specularColor * (
 material.thinWalled
 ? mix(
-ah,
-cS(ah),
+ai,
+cZ(ai),
 material.transmissionWeight
 )
-: ah
+: ai
 );
-vec3 hV = material.specularWeight * dU(
+vec3 iv = material.specularWeight * cw(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-float eO = material.thinWalled
-? cS(af(viewCosine, prepared.transmissionReflectionIor))
+float eZ = material.thinWalled
+? cZ(af(viewCosine, prepared.transmissionReflectionIor))
 : af(viewCosine, prepared.transmissionReflectionIor);
-vec3 gN = bG(
+vec3 hb = bN(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-float iu = aJ(
+float iM = aw(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-float gr = cr(
+float gH = cA(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = iu
-/ max(gr, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iM
+/ max(gH, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
-* aw(material.fuzzColor)
-* max(aO(
+* aE(material.fuzzColor)
+* max(aU(
 viewCosine,
 material.fuzzRoughness
 ), 0.02);
 prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;
 prepared.coatBaseScale = vec3(1.0);
 if (material.coatWeight > 0.0 && !material.inside) {
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 float coatViewCosine = material.coatNormalEnabled ? max(prepared.coatViewLocal.z, 0.0) : viewCosine;
-float kB = gp(material, coatViewCosine);
+float lf = gF(material, coatViewCosine);
 #else
-float kB = gp(material, viewCosine);
+float lf = gF(material, viewCosine);
 #endif
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kB;
-prepared.coatBaseScale = cD(material,
-#ifdef NUM_COAT_NORMAL_MAPS
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * lf;
+prepared.coatBaseScale = cN(material,
+#ifdef USE_COAT_NORMAL_FRAMES
 coatViewCosine
 #else
 viewCosine
 #endif
 )
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kB) * ha(prepared);
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * lf) * hr(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aw(hV);
+* aE(iv);
 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 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);
+vec3 ig = bU(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * ig * ig;
+float qO = aV(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = qO / max(cD(prepared.specularAlpha), 1e-12);
+float fC = prepared.weights[OPENPBR_LOBE_METAL] * aE(prepared.metalMsScale) * qO;
+prepared.probabilities[OPENPBR_LOBE_METAL] += fC;
+prepared.metalMsProbability = fC / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aw(fw);
+* aE(fN);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eO)
-* aw(gN);
+* (1.0 - eZ)
+* aE(hb);
 
 
 
@@ -1139,127 +1139,127 @@ 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 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]
+float mo = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = (material.inside ? vec3(1.0) : material.specularColor) * mo;
+prepared.dielectricMsTransmissionScale = hb * 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 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.dielectricMsReflectionRatio = ck(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
+prepared.dielectricMsViewLoss = bb(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
+vec3 oR = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+float fC = aE(oR) * prepared.dielectricMsViewLoss;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fC;
+prepared.dielectricMsProbability = fC / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
 }
 prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
-* aw(prepared.diffuseColor)
+* aE(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eO)
-* aw(material.subsurfaceColor)
+* (1.0 - eZ)
+* aE(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
 if (material.coatWeight > 0.0 && material.thinFilmWeight > 0.0) {
-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);
+float lS = 0.02 * bS(material.thinFilmThickness, material.thinFilmWeight);
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * lS);
+prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * lS);
 }
 if (material.coatWeight > 0.0 && !material.inside) {
-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);
+float gI = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
+prepared.probabilities[OPENPBR_LOBE_METAL] *= gI;
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gI;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gI;
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gI;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gI;
+}
+eg(prepared);
 return prepared;
 }
 
-float cR(ag prepared, float au, bool reflection) {
+float cY(ag prepared, float cosine, bool reflection) {
 if (prepared.material.coatWeight <= 0.0) {
-return af(au, prepared.material.relativeIor);
+return af(cosine, prepared.material.relativeIor);
 }
-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);
+float kU = af(cosine, prepared.transmissionReflectionIor);
+if (!reflection) { return kU; }
+float oj = af(cosine, 1.0 / prepared.specularEtaTOverEtaI);
+float sQ = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(oj, kU, sQ);
 }
 
-vec3 bI(
+vec3 bO(
 ag prepared,
 vec3 lightDirection,
 out float pdf
 ) {
-J material = prepared.material;
+OpenPbrResolvedMaterial material = prepared.material;
 vec3 viewLocal = prepared.viewLocal;
 vec3 lightLocal = openpbr_to_local(prepared.basis, lightDirection);
 bool reflection = lightLocal.z * viewLocal.z > 0.0;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 bool independentCoat = material.coatNormalEnabled;
 bool geometricReflection = dot(material.geometricNormal, lightDirection) > 0.0;
 float coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);
 bool coatReflection = geometricReflection && prepared.coatViewLocal.z > 0.0 && coatLightCosine > 0.0;
 #endif
 
-vec3 V;
+vec3 ad;
 if (reflection) {
-V = normalize(lightLocal + viewLocal);
+ad = normalize(lightLocal + viewLocal);
 }
 else {
-V = normalize(lightLocal + viewLocal * material.relativeIor);
+ad = normalize(lightLocal + viewLocal * material.relativeIor);
 }
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
 
 vec3 response = vec3(0.0);
 pdf = 0.0;
-float aI = 0.0;
-float bQ = abs(dot(viewLocal, V));
+float aM = 0.0;
+float bm = abs(dot(viewLocal, ad));
 float diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
-* aJ(
+* aw(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 abs(lightLocal.z)
 );
 
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflection)) {
 #endif
 if (reflection) {
 if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) {
-response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cE(
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bJ(
 material,
 prepared.diffuseColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aI
+aM
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aM;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cE(
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bJ(
 material,
 material.subsurfaceColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aI
+aM
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aM;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) {
-vec3 ct = vec3(cR(prepared, bQ, true));
+vec3 cB = vec3(cY(prepared, bm, true));
 if (material.thinFilmWeight > 0.0) {
-ct = bW(
-ct,
-bQ,
+cB = cc(
+cB,
+bm,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1268,33 +1268,33 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-ct = aP(
-ct,
+cB = av(
+cB,
 material.transmissionWeight
 );
 }
-vec3 cK = material.specularColor * ct;
-response += prepared.weights[OPENPBR_LOBE_SPECULAR] * am(
+vec3 bG = material.specularColor * cB;
+response += prepared.weights[OPENPBR_LOBE_SPECULAR] * ao(
 material,
 viewLocal,
 lightLocal,
-V,
-cK,
-aI
+ad,
+bG,
+aM
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aM;
 }
 
 if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) {
-vec3 cK = dU(
-bQ,
+vec3 bG = cw(
+bm,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
 if (material.thinFilmWeight > 0.0) {
-cK = lq(
-cK,
-bQ,
+bG = lZ(
+bG,
+bm,
 material.thinFilmThickness,
 material.thinFilmIor,
 material.baseWeight * material.baseColor,
@@ -1303,29 +1303,29 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-cK *= material.specularWeight;
-response += prepared.weights[OPENPBR_LOBE_METAL] * am(
+bG *= material.specularWeight;
+response += prepared.weights[OPENPBR_LOBE_METAL] * ao(
 material,
 viewLocal,
 lightLocal,
-V,
-cK,
-aI
+ad,
+bG,
+aM
 );
 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;
-aI = mix(aI, 0.5 * INVPI, prepared.metalMsProbability);
+float cL = min(prepared.metalMsFactor * aV(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
+response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * cL * INVPI;
+aM = mix(aM, 0.5 * INVPI, prepared.metalMsProbability);
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aM;
 }
 }
 else {
-vec3 cK = vec3(cR(prepared, bQ, false));
+vec3 bG = vec3(cY(prepared, bm, false));
 if (material.thinFilmWeight > 0.0) {
-cK = bW(
-cK,
-bQ,
+bG = cc(
+bG,
+bm,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1335,17 +1335,17 @@ prepared.thinFilmExteriorIor
 }
 if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) {
 if (material.thinWalled) {
-vec3 kY = vec3(lightLocal.xy, -lightLocal.z);
-vec3 df = normalize(kY + viewLocal);
-if (df.z < 0.0) {
-df = -df;
+vec3 lI = vec3(lightLocal.xy, -lightLocal.z);
+vec3 du = normalize(lI + viewLocal);
+if (du.z < 0.0) {
+du = -du;
 }
-float nR = abs(dot(viewLocal, df));
-vec3 lL = vec3(cR(prepared, nR, false));
+float oM = abs(dot(viewLocal, du));
+vec3 mv = vec3(cY(prepared, oM, false));
 if (material.thinFilmWeight > 0.0) {
-lL = bW(
-lL,
-nR,
+mv = cc(
+mv,
+oM,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1353,66 +1353,66 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-vec3 gk = aP(
-lL,
+vec3 gA = av(
+mv,
 1.0
 );
-vec3 tint = bG(
+vec3 tint = bN(
 material,
 abs(viewLocal.z),
 prepared.refractionEtaTOverEtaI
 );
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* am(
+* ao(
 material,
 viewLocal,
-kY,
-df,
-tint * (vec3(1.0) - gk),
-aI
+lI,
+du,
+tint * (vec3(1.0) - gA),
+aM
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dl(
+* dE(
 material,
 material.relativeIor,
-bn(material),
+bh(material),
 viewLocal,
 lightLocal,
-V,
-cK,
-aI
+ad,
+bG,
+aM
 );
 }
 if (prepared.dielectricMsProbability > 0.0) {
-aI *= 1.0 - prepared.dielectricMsProbability;
+aM *= 1.0 - prepared.dielectricMsProbability;
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aM;
 }
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) {
 if (material.thinWalled) {
-vec3 oi = vec3(lightLocal.xy, -lightLocal.z);
+vec3 pb = vec3(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* cE(
+* bJ(
 material,
 material.subsurfaceColor,
 viewLocal,
-oi,
+pb,
 diffuseSpecularEnergyCompensation,
-aI
+aM
 );
-aI *= 0.5;
+aM *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dM(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dX(
 material,
 viewLocal,
 lightLocal,
-aI
+aM
 );
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aM;
 }
 }
 
@@ -1420,143 +1420,143 @@ pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aI;
 
 
 if (prepared.dielectricMsProbability > 0.0) {
-float au = abs(lightLocal.z);
-if (au > 0.0) {
+float cosine = abs(lightLocal.z);
+if (cosine > 0.0) {
 float ior = (reflection ? prepared.refractionEtaTOverEtaI : 1.0 / prepared.refractionEtaTOverEtaI);
-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(tr * ja, 1.0 / au);
+float ju = (reflection ? prepared.dielectricMsReflectionRatio : 1.0 - prepared.dielectricMsReflectionRatio);
+float oZ = prepared.dielectricMsViewLoss * bb(ior, prepared.specularAlpha, cosine)
+/ max(bf(ior, prepared.specularAlpha), 1e-12);
+float cL = min(oZ * ju, 1.0 / cosine);
 vec3 scale = (reflection ? prepared.dielectricMsReflectionScale : prepared.dielectricMsTransmissionScale);
-response += scale * dW * INVPI;
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ja * 0.5 * INVPI;
+response += scale * cL * INVPI;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ju * 0.5 * INVPI;
 }
 }
 
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 } 
 #endif
 if (material.coatWeight > 0.0) {
-response *= ds(prepared,
-#ifdef NUM_COAT_NORMAL_MAPS
+response *= cF(prepared,
+#ifdef USE_COAT_NORMAL_FRAMES
 independentCoat ? coatLightCosine : lightLocal.z
 #else
 lightLocal.z
 #endif
 );
 }
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (independentCoat) { response *= abs(lightLocal.z); }
 #endif
 
 if (
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 (independentCoat ? coatReflection : reflection)
 #else
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-vec3 dI = viewLocal;
-vec3 kD = lightLocal;
-vec3 gv = V;
-float jK = bQ;
+vec3 dT = viewLocal;
+vec3 lh = lightLocal;
+vec3 gL = ad;
+float kk = bm;
 if (prepared.directionFrames) {
-dI = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
-#ifdef NUM_COAT_NORMAL_MAPS
-if (independentCoat) { dI = prepared.coatViewLocal; }
+dT = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
+#ifdef USE_COAT_NORMAL_FRAMES
+if (independentCoat) { dT = prepared.coatViewLocal; }
 #endif
-kD = openpbr_to_local(prepared.coatBasis, lightDirection);
-gv = normalize(kD + dI);
-if (gv.z < 0.0) { gv = -gv; }
-jK = abs(dot(dI, gv));
+lh = openpbr_to_local(prepared.coatBasis, lightDirection);
+gL = normalize(lh + dT);
+if (gL.z < 0.0) { gL = -gL; }
+kk = abs(dot(dT, gL));
 }
 
-vec3 lg = vec3(af(
-jK,
+vec3 lQ = vec3(af(
+kk,
 1.0 / material.coatIor
 ));
-J dH = material;
-vec2 jx = aK(material.coatRoughness, material.coatAnisotropy);
-dH.alphaX = jx.x;
-dH.alphaY = jx.y;
+OpenPbrResolvedMaterial dS = material;
+vec2 jX = aN(material.coatRoughness, material.coatAnisotropy);
+dS.alphaX = jX.x;
+dS.alphaY = jX.y;
 response += prepared.weights[OPENPBR_LOBE_COAT]
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(coatLightCosine, 0.0) : 1.0)
 #endif
-* am(
-dH,
-dI,
-kD,
-gv,
-lg,
-aI
+* ao(
+dS,
+dT,
+lh,
+gL,
+lQ,
+aM
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
 }
 
 if (
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 (independentCoat ? geometricReflection : reflection)
 #else
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-float qz = aO(
+float rC = aU(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3(0.0),
-vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qz)
+vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rC)
 );
 response += prepared.weights[OPENPBR_LOBE_FUZZ]
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(lightLocal.z, 0.0) : 1.0)
 #endif
-* jY(
+* kD(
 material,
 viewLocal,
 lightLocal,
-aI
+aM
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aI;
+pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aM;
 }
 
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (independentCoat) { return response; }
 #endif
 return response * abs(lightLocal.z);
 }
 
-vec3 ri(
+vec3 sp(
 vec3 tangent,
-J material,
-vec3 bF,
+OpenPbrResolvedMaterial material,
+vec3 bM,
 vec3 normal,
 vec3 lightDirection,
 out float pdf
 ) {
-ag prepared = eH(
+ag prepared = ds(
 tangent,
 material,
-bF,
+bM,
 normal
 );
-return bI(prepared, lightDirection, pdf);
+return bO(prepared, lightDirection, pdf);
 }
 
-float vW(
+float xN(
 vec3 tangent,
-J material,
-vec3 bF,
+OpenPbrResolvedMaterial material,
+vec3 bM,
 vec3 normal,
 vec3 lightDirection
 ) {
 float pdf;
-ri(
+sp(
 tangent,
 material,
-bF,
+bM,
 normal,
 lightDirection,
 pdf
@@ -1564,18 +1564,18 @@ pdf
 return pdf;
 }
 
-vec3 dv(
+vec3 eN(
 ag prepared,
-vec3 cm,
+vec3 cq,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
-J material = prepared.material;
+OpenPbrResolvedMaterial material = prepared.material;
 vec3 viewLocal = prepared.viewLocal;
-float cy = cm.x;
-float fu = cm.y;
-float bm = cm.z;
+float cH = cq.x;
+float fL = cq.y;
+float bv = cq.z;
 pdf = 0.0;
 isTransmissionEvent = false;
 lightDirection = prepared.basis.normal;
@@ -1588,8 +1588,8 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6) {
 lightDirection = openpbr_to_world(prepared.basis, -viewLocal);
 pdf = 1.0;
 isTransmissionEvent = true;
-return (bn(prepared.material) * ds(prepared,
-#ifdef NUM_COAT_NORMAL_MAPS
+return (bh(prepared.material) * cF(prepared,
+#ifdef USE_COAT_NORMAL_FRAMES
 prepared.material.coatNormalEnabled ? dot(prepared.coatBasis.normal, lightDirection) : -prepared.viewLocal.z
 #else
 -prepared.viewLocal.z
@@ -1599,99 +1599,99 @@ prepared.material.coatNormalEnabled ? dot(prepared.coatBasis.normal, lightDirect
 
 float cdf[OPENPBR_LOBE_COUNT];
 cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-for (int hU = 1; hU < OPENPBR_LOBE_COUNT; hU++) {
-cdf[hU] = cdf[hU - 1] + prepared.probabilities[hU];
+for (int jT = 1; jT < OPENPBR_LOBE_COUNT; jT++) {
+cdf[jT] = cdf[jT - 1] + prepared.probabilities[jT];
 }
 if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {
 return vec3(0.0);
 }
 
 vec3 lightLocal;
-if (bm < cdf[OPENPBR_LOBE_FUZZ] || (
-bm >= cdf[OPENPBR_LOBE_TRANSMISSION] && bm < cdf[OPENPBR_LOBE_DIFFUSE]
+if (bv < cdf[OPENPBR_LOBE_FUZZ] || (
+bv >= cdf[OPENPBR_LOBE_TRANSMISSION] && bv < cdf[OPENPBR_LOBE_DIFFUSE]
 )) {
-lightLocal = bi(vec2(cy, fu));
+lightLocal = aO(vec2(cH, fL));
 }
-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 NUM_COAT_NORMAL_MAPS
-if (material.coatNormalEnabled) { dI = prepared.coatViewLocal; }
+else if (bv < cdf[OPENPBR_LOBE_COAT]) {
+vec3 dT = viewLocal;
+if (prepared.directionFrames) { dT = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)); }
+#ifdef USE_COAT_NORMAL_FRAMES
+if (material.coatNormalEnabled) { dT = prepared.coatViewLocal; }
 #endif
-vec3 V = aQ(
-dI,
+vec3 ad = aD(
+dT,
 
-aK(material.coatRoughness, material.coatAnisotropy),
-vec2(cy, fu)
+aN(material.coatRoughness, material.coatAnisotropy),
+vec2(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-lightLocal = normalize(reflect(-dI, V));
-#ifdef NUM_COAT_NORMAL_MAPS
+lightLocal = normalize(reflect(-dT, ad));
+#ifdef USE_COAT_NORMAL_FRAMES
 if (material.coatNormalEnabled) {
 lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);
 if (lightLocal.z <= 0.0 || dot(material.geometricNormal, lightDirection) <= 0.0) { return vec3(0.0); }
-return bI(prepared, lightDirection, pdf);
+return bO(prepared, lightDirection, pdf);
 }
 #endif
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
-else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
-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 if (bv < cdf[OPENPBR_LOBE_SPECULAR]) {
+bool uP = bv < cdf[OPENPBR_LOBE_METAL];
+float sN = (bv - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (uP && sN < prepared.metalMsProbability) {
+float z = cH;
+float ex = sqrt(max(0.0, 1.0 - z * z));
+float azimuth = TWOPI * fL;
+lightLocal = vec3(ex * cos(azimuth), ex * sin(azimuth), z);
 }
 else {
-vec3 V = aQ(
+vec3 ad = aD(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cy, fu)
+vec2(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-lightLocal = normalize(reflect(-viewLocal, V));
+lightLocal = normalize(reflect(-viewLocal, ad));
 }
 }
-else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+else if (bv < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 isTransmissionEvent = true;
 
 
-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 vS = (bv - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && vS < prepared.dielectricMsProbability) {
+float ju = prepared.dielectricMsReflectionRatio;
+bool mJ = cH < ju;
 float z;
-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;
+if (mJ) { z = min(cH / ju, 0.99999994); }
+else { z = -min((cH - ju) / (1.0 - ju), 0.99999994); }
+float ex = sqrt(max(0.0, 1.0 - z * z));
+float azimuth = TWOPI * fL;
+lightLocal = vec3(ex * cos(azimuth), ex * sin(azimuth), z);
+isTransmissionEvent = !mJ;
 }
 else {
-vec3 V = aQ(
+vec3 ad = aD(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cy, fu)
+vec2(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-float bQ = abs(dot(viewLocal, V));
-vec3 cK = vec3(af(
-bQ,
+float bm = abs(dot(viewLocal, ad));
+vec3 bG = vec3(af(
+bm,
 prepared.material.relativeIor
 ));
 if (material.thinFilmWeight > 0.0) {
-cK = bW(
-cK,
-bQ,
+bG = cc(
+bG,
+bm,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1700,13 +1700,13 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-vec3 hZ = normalize(reflect(-viewLocal, V));
-lightLocal = vec3(hZ.xy, -hZ.z);
+vec3 iC = normalize(reflect(-viewLocal, ad));
+lightLocal = vec3(iC.xy, -iC.z);
 }
 else {
 lightLocal = refract(
 -viewLocal,
-V,
+ad,
 prepared.material.relativeIor
 );
 if (dot(lightLocal, lightLocal) <= 1e-8) {
@@ -1720,13 +1720,13 @@ lightLocal = normalize(lightLocal);
 else {
 isTransmissionEvent = true;
 if (material.thinWalled) {
-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) {
+float lq = cH;
+bool qL = lq >= 0.5;
+cH = qL
+? (lq - 0.5) * 2.0
+: lq * 2.0;
+lightLocal = aO(vec2(cH, fL));
+if (qL) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1734,7 +1734,7 @@ isTransmissionEvent = false;
 }
 }
 else {
-lightLocal = bi(vec2(cy, fu));
+lightLocal = aO(vec2(cH, fL));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1744,24 +1744,24 @@ lightDirection = openpbr_to_world(prepared.basis, lightLocal);
 if (lightLocal.z == 0.0 || (lightLocal.z < 0.0) != isTransmissionEvent) {
 return vec3(0.0);
 }
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (material.coatNormalEnabled &&
 ((dot(material.geometricNormal, lightDirection) <= 0.0) != isTransmissionEvent)) { return vec3(0.0); }
 #endif
-return bI(prepared, lightDirection, pdf);
+return bO(prepared, lightDirection, pdf);
 }
 
-vec3 sJ(
+vec3 tZ(
 vec3 tangent,
-J material,
-vec3 cm,
-vec3 bF,
+OpenPbrResolvedMaterial material,
+vec3 cq,
+vec3 bM,
 vec3 normal,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
-ag prepared = eH(tangent, material, bF, normal);
-return dv(prepared, cm, lightDirection, pdf, isTransmissionEvent);
+ag prepared = ds(tangent, material, bM, normal);
+return eN(prepared, cq, lightDirection, pdf, isTransmissionEvent);
 }`;
 //# sourceMappingURL=openPbrBsdf.glsl.js.map