@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -26,16 +26,16 @@ const int OPENPBR_LOBE_DIFFUSE = 5;
 const int OPENPBR_LOBE_SUBSURFACE = 6;
 const int OPENPBR_LOBE_COUNT = 7;
 
-struct bq {
+struct OpenPbrBasis {
 vec3 tangent;
 vec3 bitangent;
 vec3 normal;
 };
 
-struct ag {
+struct OpenPbrPreparedBsdf {
 OpenPbrResolvedMaterial material;
-bq basis;
-bq coatBasis;
+OpenPbrBasis basis;
+OpenPbrBasis coatBasis;
 bool directionFrames;
 #ifdef USE_COAT_NORMAL_FRAMES
 vec3 coatViewLocal;
@@ -64,250 +64,250 @@ float weights[OPENPBR_LOBE_COUNT];
 float probabilities[OPENPBR_LOBE_COUNT];
 };
 
-float aE(vec3 color) {
+float aB(vec3 color) {
 return dot(color, vec3(0.212671, 0.715160, 0.072169));
 }
 
-float dd(float bE) {
-float value = (bE - 1.0) / (bE + 1.0);
+float cO(float bq) {
+float value = (bq - 1.0) / (bq + 1.0);
 return value * value;
 }
 
-float bi(
-float bE,
+float bb(
+float bq,
 float specularWeight
 ) {
-float uh = min(
-dd(bE) * specularWeight,
+float uj = min(
+cO(bq) * specularWeight,
 0.9999
 );
-float uj = sqrt(uh);
-float lR = (1.0 + uj) / (1.0 - uj);
-return bE < 1.0 ? 1.0 / lR : lR;
+float ul = sqrt(uj);
+float lC = (1.0 + ul) / (1.0 - ul);
+return bq < 1.0 ? 1.0 / lC : lC;
 }
 
-float af(float ci, float relativeIor) {
+float ae(float ct, float relativeIor) {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return cC(ci, relativeIor);
+return sampling_dielectric_fresnel(ct, relativeIor);
 }
 
-float aG(float ior) {
+float aE(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 tB, int row) {
-return texelFetch(openPbrEnergyLut, ivec2(tB, row), 0).r;
+float F(int tC, int row) {
+return texelFetch(openPbrEnergyLut, ivec2(tC, row), 0).r;
 }
 
-float gt(
-float dU,
-float bV,
-float im
+float gd(
+float dH,
+float bM,
+float hN
 ) {
-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);
+float br = clamp(dH, 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));
+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);
 return mix(
-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);
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+kR
+);
+}
+
+float gA(float dH, float bM) {
+float br = clamp(dH, 0.0, 31.0);
+float aK = clamp(bM, 0.0, 31.0);
+int dP = int(floor(br));
+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);
 return mix(
-mix(v00, v10, cv),
-mix(v01, v11, cv),
-cI
+mix(v00, v10, ci),
+mix(v01, v11, ci),
+cq
 );
 }
 
 
 
-float ev(
-float dU,
-float bV,
-float im
+float ee(
+float dH,
+float bM,
+float hN
 ) {
-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);
+float br = clamp(dH, 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));
+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);
 return mix(
-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);
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+kR
+);
+}
+
+float ec(float dH, float bM) {
+float br = clamp(dH, 0.0, 31.0);
+float aK = clamp(bM, 0.0, 31.0);
+int dP = int(floor(br));
+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);
 return mix(
-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);
+mix(v00, v10, ci),
+mix(v01, v11, ci),
+cq
+);
+}
+
+float eC(float dH, float bM) {
+float br = clamp(dH, 0.0, 31.0);
+float aK = clamp(bM, 0.0, 31.0);
+int dP = int(floor(br));
+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);
 return mix(
-mix(v00, v10, cv),
-mix(v01, v11, cv),
-cI
+mix(v00, v10, ci),
+mix(v01, v11, ci),
+cq
 );
 }
 
-float bb(float ior, float alpha, float cosine) {
-return ev(aG(ior), sqrt(alpha) * 31.0, cosine * 31.0);
+float aV(float ior, float alpha, float cosine) {
+return ee(aE(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-float bf(float ior, float alpha) {
-return eu(aG(ior), sqrt(alpha) * 31.0);
+float aY(float ior, float alpha) {
+return ec(aE(ior), sqrt(alpha) * 31.0);
 }
-float ck(float ior, float alpha) {
-return eR(aG(ior), sqrt(alpha) * 31.0);
+float bU(float ior, float alpha) {
+return eC(aE(ior), sqrt(alpha) * 31.0);
 }
 
 
-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));
+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));
 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(bD)),
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bD)),
-fract(iF));
+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));
 }
 
-float cD(float alpha) {
+float cl(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 bd(float value, float ior) {
+float aX(float value, float ior) {
 if (ior > 2.5 || ior < 0.4) {
-float vu = dd(2.5);
-float progress = (dd(ior) - vu) / (1.0 - vu);
+float vH = cO(2.5);
+float progress = (cO(ior) - vH) / (1.0 - vH);
 return (1.0 - progress) * value;
 }
 return value;
 }
 
-float aw(
+float ar(
 float ior,
 float alpha,
 float cosine
 ) {
-float value = gt(
-aG(ior),
+float value = gd(
+aE(ior),
 sqrt(alpha) * 31.0,
 cosine * 31.0
 );
-return bd(value, ior);
+return aX(value, ior);
 }
 
-float cA(float ior, float alpha) {
-float value = gS(
-aG(ior),
+float cj(float ior, float alpha) {
+float value = gA(
+aE(ior),
 sqrt(alpha) * 31.0
 );
-return bd(value, ior);
+return aX(value, ior);
 }
 
-vec3 openpbr_to_world(bq basis, vec3 direction) {
+vec3 openpbr_to_world(OpenPbrBasis basis, vec3 direction) {
 return direction.x * basis.tangent
 + direction.y * basis.bitangent
 + direction.z * basis.normal;
 }
 
-vec3 openpbr_to_local(bq basis, vec3 direction) {
+vec3 openpbr_to_local(OpenPbrBasis basis, vec3 direction) {
 return vec3(
 dot(direction, basis.tangent),
 dot(direction, basis.bitangent),
@@ -315,19 +315,19 @@ dot(direction, basis.normal)
 );
 }
 
-bq fD(
-vec3 aX,
+OpenPbrBasis ff(
+vec3 aS,
 vec3 normal,
 float anisotropy
 ) {
-bq basis;
+OpenPbrBasis basis;
 basis.normal = normal;
 basis.tangent = vec3(0.0);
 #ifdef USE_TANGENT
-basis.tangent = aX;
+basis.tangent = aS;
 #endif
 if (dot(basis.tangent, basis.tangent) < 0.001 || anisotropy <= 0.0) {
-aP(normal, basis.tangent, basis.bitangent);
+sampling_orthonormal_basis(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 kF(
-float aB,
-float am,
+float ki(
+float av,
+float ai,
 float J,
-float ae
+float ad
 ) {
-return (aB * J - am * ae)
-/ (aB * J + am * ae);
+return (av * J - ai * ad)
+/ (av * J + ai * ad);
 }
 
-float kE(
-float aB,
-float am,
+float kh(
+float av,
+float ai,
 float J,
-float ae
+float ad
 ) {
-return (am * J - aB * ae)
-/ (aB * ae + am * J);
+return (ai * J - av * ad)
+/ (av * ad + ai * J);
 }
 
-float ht(
-float aB,
-float am,
+float gZ(
+float av,
+float ai,
 float J,
-float ae
+float ad
 ) {
-return 2.0 * aB * J
-/ (aB * J + am * ae);
+return 2.0 * av * J
+/ (av * J + ai * ad);
 }
 
-float hs(
-float aB,
-float am,
+float gY(
+float av,
+float ai,
 float J,
-float ae
+float ad
 ) {
-return 2.0 * aB * J
-/ (aB * ae + am * J);
+return 2.0 * av * J
+/ (av * ad + ai * J);
 }
 
-vec2 aY(vec2 a, vec2 b) {
+vec2 aT(vec2 a, vec2 b) {
 return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
-vec2 bj(vec2 a, vec2 b) {
-float aq = max(dot(b, b), 1e-9);
+vec2 bc(vec2 a, vec2 b) {
+float ah = max(dot(b, b), 1e-9);
 return vec2(
-(a.x * b.x + a.y * b.y) / aq,
-(a.y * b.x - a.x * b.y) / aq
+(a.x * b.x + a.y * b.y) / ah,
+(a.y * b.x - a.x * b.y) / ah
 );
 }
 
-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 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 ce(
+vec2 bR(
 float J,
-float aB,
-vec2 am,
-bool rM
+float av,
+vec2 ai,
+bool rH
 ) {
-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)
+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)
 );
-if (aY(am, ae).y < 0.0) {
-ae = -ae;
+if (aT(ai, ad).y < 0.0) {
+ad = -ad;
 }
 
-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
+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
 );
 }
-return bj(
-fZ - eJ,
-fZ + eJ
+return bc(
+fL - eu,
+fL + eu
 );
 }
 
-float eE(
-float iZ,
-float ha,
-float pw,
-float nL,
-vec2 kL,
+float em(
+float iI,
+float gJ,
+float pk,
+float nA,
+vec2 ko,
 float phase
 ) {
-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);
+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);
 }
 
-float au(
+float ap(
 float J,
 float wavelength,
-float ct,
-float aR,
-float cn,
-vec2 eG
+float cf,
+float aN,
+float bY,
+vec2 ep
 ) {
 J = clamp(abs(J), 1e-5, 1.0);
-float hI = pow(aR / cn, 2.0)
+float hp = pow(aN / bY, 2.0)
 * (1.0 - J * J);
-if (hI >= 1.0) {
+if (hp >= 1.0) {
 return 1.0;
 }
-float dc = sqrt(1.0 - hI);
-float lL = kF(
-aR, cn, J, dc
+float cN = sqrt(1.0 - hp);
+float lq = ki(
+aN, bY, J, cN
 );
-float lK = kE(
-aR, cn, J, dc
+float lp = kh(
+aN, bY, J, cN
 );
-float jG = ht(
-aR, cn, J, dc
+float jm = gZ(
+aN, bY, J, cN
 );
-float jF = hs(
-aR, cn, J, dc
+float jl = gY(
+aN, bY, J, cN
 );
-float gG = cn * dc
-/ max(aR * J, 1e-9);
-vec2 ut = ce(
-dc, cn, eG, false
+float gp = bY * cN
+/ max(aN * J, 1e-9);
+vec2 uB = bR(
+cN, bY, ep, false
 );
-vec2 us = ce(
-dc, cn, eG, true
+vec2 uA = bR(
+cN, bY, ep, true
 );
-float phase = 2.0 * PI * (2.0 * cn * ct * dc) / wavelength;
-float uZ = eE(
-lL,
-jG,
--lL,
-jG * gG,
-ut,
+float phase = 2.0 * PI * (2.0 * bY * cf * cN) / wavelength;
+float vh = em(
+lq,
+jm,
+-lq,
+jm * gp,
+uB,
 phase
 );
-float uY = eE(
-lK,
-jF,
--lK,
-jF * gG,
-us,
+float vg = em(
+lp,
+jl,
+-lp,
+jl * gp,
+uA,
 phase
 );
-return clamp(0.5 * (uZ + uY), 0.0, 1.0);
+return clamp(0.5 * (vh + vg), 0.0, 1.0);
 }
 
-vec3 hW(
+vec3 hD(
 float J,
-float ct,
-float cn,
-float eG,
-float aR
+float cf,
+float bY,
+float ep,
+float aN
 ) {
 return vec3(
-au(
-J, 620.0, ct, aR, cn, vec2(eG, 0.0)
+ap(
+J, 620.0, cf, aN, bY, vec2(ep, 0.0)
 ),
-au(
-J, 540.0, ct, aR, cn, vec2(eG, 0.0)
+ap(
+J, 540.0, cf, aN, bY, vec2(ep, 0.0)
 ),
-au(
-J, 450.0, ct, aR, cn, vec2(eG, 0.0)
+ap(
+J, 450.0, cf, aN, bY, vec2(ep, 0.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));
+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 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
+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
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dY, 1e-9);
-return vec2(ior, sqrt(max(kp, 0.0)));
+) / max(1.0 - dL, 1e-9);
+return vec2(ior, sqrt(max(jT, 0.0)));
 }
 
-vec3 jr(
+vec3 iX(
 float J,
-float ct,
-float cn,
-vec3 sm,
-vec3 kA,
-float aR
+float cf,
+float bY,
+vec3 sg,
+vec3 kd,
+float aN
 ) {
 return vec3(
-au(
+ap(
 J,
 620.0,
-ct,
-aR,
-cn,
-cX(sm.r, kA.r)
+cf,
+aN,
+bY,
+cJ(sg.r, kd.r)
 ),
-au(
+ap(
 J,
 540.0,
-ct,
-aR,
-cn,
-cX(sm.g, kA.g)
+cf,
+aN,
+bY,
+cJ(sg.g, kd.g)
 ),
-au(
+ap(
 J,
 450.0,
-ct,
-aR,
-cn,
-cX(sm.b, kA.b)
+cf,
+aN,
+bY,
+cJ(sg.b, kd.b)
 )
 );
 }
 
-float bS(float ct, float weight) {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ct);
+float bJ(float cf, float weight) {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cf);
 }
 
-vec3 cc(
-vec3 ey,
+vec3 bQ(
+vec3 ef,
 float J,
-float ct,
-float cn,
-float eG,
+float cf,
+float bY,
+float ep,
 float weight,
-float aR
+float aN
 ) {
-vec3 qn = hW(
+vec3 qe = hD(
 J,
-ct,
-cn,
-eG,
-aR
+cf,
+bY,
+ep,
+aN
 );
 return mix(
-ey,
-qn,
-bS(ct, weight)
+ef,
+qe,
+bJ(cf, weight)
 );
 }
 
-vec3 lZ(
-vec3 ey,
+vec3 lI(
+vec3 ef,
 float J,
-float ct,
-float cn,
-vec3 sm,
-vec3 kA,
+float cf,
+float bY,
+vec3 sg,
+vec3 kd,
 float weight,
-float aR
+float aN
 ) {
-vec3 qn = jr(
+vec3 qe = iX(
 J,
-ct,
-cn,
-sm,
-kA,
-aR
+cf,
+bY,
+sg,
+kd,
+aN
 );
 return mix(
-ey,
-qn,
-bS(ct, weight)
+ef,
+qe,
+bJ(cf, weight)
 );
 }
 
-vec3 bJ(
+vec3 bw(
 OpenPbrResolvedMaterial material,
 vec3 color,
 vec3 viewLocal,
 vec3 lightLocal,
-float fJ,
+float fl,
 out float pdf
 ) {
 pdf = 0.0;
@@ -648,24 +648,24 @@ return vec3(0.0);
 }
 
 float roughness = material.diffuseRoughness;
-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)
+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)
 : 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 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
 )
 )
 );
@@ -676,22 +676,22 @@ float outputGOverPi = outputComplement * (
 )
 )
 );
-float qr = (1.0 + roughness * ph)
-/ (1.0 + hl * roughness);
+float qj = (1.0 + roughness * oW)
+/ (1.0 + gS * 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
+/ (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
 * max(1e-7, 1.0 - outputAlbedo)
-* max(1e-7, 1.0 - qr)
-/ max(1e-7, 1.0 - gi);
+* max(1e-7, 1.0 - qj)
+/ max(1e-7, 1.0 - fU);
 pdf = lightLocal.z * INVPI;
-return (ot + mn) * fJ;
+return (oe + lT) * fl;
 }
 
-float aU(float viewCosine, float roughness) {
+float aQ(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,7 +705,7 @@ float gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-vec3 kD(
+vec3 kg(
 OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -715,7 +715,7 @@ pdf = 0.0;
 if (viewLocal.z <= 0.0 || lightLocal.z <= 0.0) {
 return vec3(0.0);
 }
-float albedo = aU(
+float albedo = aQ(
 viewLocal.z,
 material.fuzzRoughness
 );
@@ -723,12 +723,12 @@ pdf = lightLocal.z * INVPI;
 return material.fuzzColor * albedo * INVPI;
 }
 
-vec3 ao(
+vec3 aj(
 OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
-vec3 ad,
-vec3 bG,
+vec3 aa,
+vec3 fresnel,
 out float pdf
 ) {
 pdf = 0.0;
@@ -737,24 +737,24 @@ return vec3(0.0);
 }
 
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-float distribution = cW(ad, alpha);
-float kz = aF(viewLocal, alpha);
-float ep = kz
-* aF(lightLocal, alpha);
+float distribution = sampling_ggx_ndf(aa, alpha);
+float kc = aD(viewLocal, alpha);
+float dY = kc
+* aD(lightLocal, alpha);
 
-pdf = kz * distribution / (4.0 * max(viewLocal.z, 1e-8));
-return bG * distribution * ep
+pdf = kc * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return fresnel * distribution * dY
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-vec3 dE(
+vec3 dc(
 OpenPbrResolvedMaterial material,
 float relativeIor,
 vec3 tint,
 vec3 viewLocal,
 vec3 lightLocal,
-vec3 ad,
-vec3 bG,
+vec3 aa,
+vec3 fresnel,
 out float pdf
 ) {
 pdf = 0.0;
@@ -762,31 +762,31 @@ if (lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
 
-float ls = dot(lightLocal, ad);
-float bm = dot(viewLocal, ad);
+float lightHalf = dot(lightLocal, aa);
+float viewHalf = dot(viewLocal, aa);
 
 
-if (bm <= 0.0 || ls >= 0.0) {
+if (viewHalf <= 0.0 || lightHalf >= 0.0) {
 return vec3(0.0);
 }
 vec2 alpha = vec2(material.alphaX, material.alphaY);
-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
+float distribution = sampling_ggx_ndf(aa, alpha);
+float kc = aD(viewLocal, alpha);
+float dY = kc
+* aD(lightLocal, alpha);
+float ah = lightHalf + viewHalf * relativeIor;
+ah *= ah;
+float qo = abs(lightHalf) / max(ah, 1e-8);
+float jB = relativeIor * relativeIor;
+
+pdf = kc * max(0.0, viewHalf) * distribution * qo
 / max(viewLocal.z, 1e-8);
-return tint * (vec3(1.0) - bG) * distribution * ep
-* abs(bm) * qw * jU
+return tint * (vec3(1.0) - fresnel) * distribution * dY
+* abs(viewHalf) * qo * jB
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-vec3 bh(OpenPbrResolvedMaterial material) {
+vec3 ba(OpenPbrResolvedMaterial material) {
 #ifdef HAS_MEDIUM
 if (material.mediumType > 0) {
 return vec3(1.0);
@@ -795,43 +795,43 @@ return vec3(1.0);
 return material.transmissionColor;
 }
 
-float cZ(float ai) {
-return 2.0 * ai / (1.0 + ai);
+float cL(float ag) {
+return 2.0 * ag / (1.0 + ag);
 }
 
-vec3 av(
-vec3 ai,
+vec3 aq(
+vec3 ag,
 float transmissionWeight
 ) {
-vec3 gA = 2.0 * ai
-/ (vec3(1.0) + ai);
+vec3 gk = 2.0 * ag
+/ (vec3(1.0) + ag);
 return mix(
-ai,
-gA,
+ag,
+gk,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
 
-vec3 bN(
+vec3 bF(
 OpenPbrResolvedMaterial material,
 float J,
-float bE
+float bq
 ) {
-vec3 tint = bh(material);
+vec3 tint = ba(material);
 if (!material.thinWalled) {
 return tint;
 }
-float jc = max(0.0, 1.0 - J * J);
-float ea = jc
-/ max(bE * bE, 1e-9);
-if (ea >= 1.0) {
+float iK = max(0.0, 1.0 - J * J);
+float dM = iK
+/ max(bq * bq, 1e-9);
+if (dM >= 1.0) {
 return vec3(0.0);
 }
-float ae = sqrt(1.0 - ea);
-return pow(max(tint, vec3(0.0)), vec3(1.0 / max(ae, 1e-5)));
+float ad = sqrt(1.0 - dM);
+return pow(max(tint, vec3(0.0)), vec3(1.0 / max(ad, 1e-5)));
 }
 
-vec3 dX(
+vec3 dK(
 OpenPbrResolvedMaterial material,
 vec3 viewLocal,
 vec3 lightLocal,
@@ -841,120 +841,120 @@ pdf = 0.0;
 if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
 return vec3(0.0);
 }
-float ae = -lightLocal.z;
-float oY = cC(
+float ad = -lightLocal.z;
+float oO = sampling_dielectric_fresnel(
 viewLocal.z,
 material.relativeIor
 );
-pdf = ae * INVPI;
-return vec3(1.0 - oY) * INVPI;
+pdf = ad * INVPI;
+return vec3(1.0 - oO) * INVPI;
 }
 
-void eg(inout ag prepared) {
+void dQ(inout OpenPbrPreparedBsdf prepared) {
 float total = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-for (int jT = 1; jT < OPENPBR_LOBE_COUNT; jT++) {
-total += prepared.probabilities[jT];
+for (int lobe = 1; lobe < OPENPBR_LOBE_COUNT; lobe++) {
+total += prepared.probabilities[lobe];
 }
 if (total <= 1e-8) {
-for (int jT = 0; jT < OPENPBR_LOBE_COUNT; jT++) {
-prepared.probabilities[jT] = 0.0;
+for (int lobe = 0; lobe < OPENPBR_LOBE_COUNT; lobe++) {
+prepared.probabilities[lobe] = 0.0;
 }
 return;
 }
-float pk = 1.0 / total;
-for (int jT = 0; jT < OPENPBR_LOBE_COUNT; jT++) {
-prepared.probabilities[jT] *= pk;
+float oZ = 1.0 / total;
+for (int lobe = 0; lobe < OPENPBR_LOBE_COUNT; lobe++) {
+prepared.probabilities[lobe] *= oZ;
 }
 }
 
 
 
-float bR(float eta) {
+float bI(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 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));
+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));
 return clamp(f0 + (vec3(1.0) - f0) / 21.0 - b / 126.0, vec3(0.0), vec3(1.0));
 }
 
 
 
-vec3 cN(OpenPbrResolvedMaterial material, float cosine) {
+vec3 cA(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 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 gF(OpenPbrResolvedMaterial material, float cosine) {
+float gn(OpenPbrResolvedMaterial material, float cosine) {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
-return af(cosine, 1.0 / material.coatIor);
+return ae(cosine, 1.0 / material.coatIor);
 }
 
 
-return clamp(1.0 - aw(material.coatIor,
+return clamp(1.0 - ar(material.coatIor,
 material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);
 }
 
-vec3 hr(ag prepared) {
+vec3 gX(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 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 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 ks = bI(material.coatIor);
 float kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-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);
+float k = mix(ks, kr, jt);
+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);
 }
 
-vec3 cF(ag prepared, float lU) {
+vec3 cm(OpenPbrPreparedBsdf prepared, float lF) {
 if (prepared.material.coatWeight <= 0.0) { return vec3(1.0); }
 if (prepared.material.inside) {
 
-return cN(prepared.material, -lU);
+return cA(prepared.material, -lF);
 }
 
-return prepared.coatBaseScale * cN(prepared.material, lU);
+return prepared.coatBaseScale * cA(prepared.material, lF);
 }
 
 
-bq dM(bq fallback, vec3 tangent, vec3 bitangent, vec2 direction) {
+OpenPbrBasis dk(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);
 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; }
-bq basis = fallback;
+OpenPbrBasis 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 ds(
+OpenPbrPreparedBsdf bV(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bM,
+vec3 bD,
 vec3 normal
 ) {
-ag prepared;
+OpenPbrPreparedBsdf prepared;
 prepared.material = material;
-prepared.basis = fD(
+prepared.basis = ff(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -965,40 +965,40 @@ prepared.directionFrames = false;
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fD(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = ff(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 #endif
 if (material.specularAnisotropy > 0.0 && material.anisotropyDirectionEnabled) {
-prepared.basis = dM(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
+prepared.basis = dk(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
 prepared.directionFrames = true;
 }
 if (material.coatAnisotropy > 0.0 && material.coatAnisotropyRotation != 0.0) {
-prepared.coatBasis = dM(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
+prepared.coatBasis = dk(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
 prepared.directionFrames = true;
 }
-prepared.viewLocal = openpbr_to_local(prepared.basis, bM);
+prepared.viewLocal = openpbr_to_local(prepared.basis, bD);
 #ifdef USE_COAT_NORMAL_FRAMES
-prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bM);
+prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bD);
 #endif
 prepared.diffuseColor = material.baseColor;
 
-float cK = 1.0 - material.baseMetalness;
-float dW = cK
+float cu = 1.0 - material.baseMetalness;
+float dJ = cu
 * (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] = cK;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cK
+prepared.weights[OPENPBR_LOBE_SPECULAR] = cu;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cu
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dW
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dJ
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dW
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dJ
 * material.subsurfaceWeight;
 
-prepared.specularEtaTOverEtaI = bi(
+prepared.specularEtaTOverEtaI = bb(
 1.0 / material.relativeIor,
 material.specularWeight
 );
@@ -1008,20 +1008,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-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;
+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;
 if (material.inside) {
-prepared.refractionEtaTOverEtaI = 1.0 / bB;
-prepared.transmissionReflectionIor = bB;
+prepared.refractionEtaTOverEtaI = 1.0 / bn;
+prepared.transmissionReflectionIor = bn;
 }
 prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
 }
@@ -1043,47 +1043,47 @@ prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;
 prepared.specularAlpha = material.specularRoughness
 * material.specularRoughness;
 float viewCosine = abs(prepared.viewLocal.z);
-float ai = af(
+float ag = ae(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-vec3 fN = material.specularColor * (
+vec3 fu = material.specularColor * (
 material.thinWalled
 ? mix(
-ai,
-cZ(ai),
+ag,
+cL(ag),
 material.transmissionWeight
 )
-: ai
+: ag
 );
-vec3 iv = material.specularWeight * cw(
+vec3 hS = material.specularWeight * openpbr_metal_fresnel(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-float eZ = material.thinWalled
-? cZ(af(viewCosine, prepared.transmissionReflectionIor))
-: af(viewCosine, prepared.transmissionReflectionIor);
-vec3 hb = bN(
+float eI = material.thinWalled
+? cL(ae(viewCosine, prepared.transmissionReflectionIor))
+: ae(viewCosine, prepared.transmissionReflectionIor);
+vec3 gK = bF(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-float iM = aw(
+float ir = ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-float gH = cA(
+float gq = cj(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = iM
-/ max(gH, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = ir
+/ max(gq, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
-* aE(material.fuzzColor)
-* max(aU(
+* aB(material.fuzzColor)
+* max(aQ(
 viewCosine,
 material.fuzzRoughness
 ), 0.02);
@@ -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 lf = gF(material, coatViewCosine);
+float kO = gn(material, coatViewCosine);
 #else
-float lf = gF(material, viewCosine);
+float kO = gn(material, viewCosine);
 #endif
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * lf;
-prepared.coatBaseScale = cN(material,
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kO;
+prepared.coatBaseScale = cA(material,
 #ifdef USE_COAT_NORMAL_FRAMES
 coatViewCosine
 #else
 viewCosine
 #endif
 )
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * lf) * hr(prepared);
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kO) * gX(prepared);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aE(iv);
+* aB(hS);
 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 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);
+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);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aE(fN);
+* aB(fu);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eZ)
-* aE(hb);
+* (1.0 - eI)
+* aB(gK);
 
 
 
@@ -1139,56 +1139,56 @@ 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 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]
+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]
 + vec3(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
-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.dielectricMsReflectionRatio = bU(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);
 }
 prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
-* aE(prepared.diffuseColor)
+* aB(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eZ)
-* aE(material.subsurfaceColor)
+* (1.0 - eI)
+* aB(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
 if (material.coatWeight > 0.0 && material.thinFilmWeight > 0.0) {
-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);
+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);
 }
 if (material.coatWeight > 0.0 && !material.inside) {
-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);
+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);
 return prepared;
 }
 
-float cY(ag prepared, float cosine, bool reflection) {
+float cK(OpenPbrPreparedBsdf prepared, float cosine, bool reflection) {
 if (prepared.material.coatWeight <= 0.0) {
-return af(cosine, prepared.material.relativeIor);
+return ae(cosine, prepared.material.relativeIor);
 }
-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);
+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);
 }
 
-vec3 bO(
-ag prepared,
+vec3 openpbr_eval_prepared(
+OpenPbrPreparedBsdf prepared,
 vec3 lightDirection,
 out float pdf
 ) {
@@ -1203,24 +1203,24 @@ float coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);
 bool coatReflection = geometricReflection && prepared.coatViewLocal.z > 0.0 && coatLightCosine > 0.0;
 #endif
 
-vec3 ad;
+vec3 aa;
 if (reflection) {
-ad = normalize(lightLocal + viewLocal);
+aa = normalize(lightLocal + viewLocal);
 }
 else {
-ad = normalize(lightLocal + viewLocal * material.relativeIor);
+aa = normalize(lightLocal + viewLocal * material.relativeIor);
 }
-if (ad.z < 0.0) {
-ad = -ad;
+if (aa.z < 0.0) {
+aa = -aa;
 }
 
 vec3 response = vec3(0.0);
 pdf = 0.0;
-float aM = 0.0;
-float bm = abs(dot(viewLocal, ad));
+float lobePdf = 0.0;
+float viewHalf = abs(dot(viewLocal, aa));
 float diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
-* aw(
+* ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 abs(lightLocal.z)
@@ -1231,35 +1231,35 @@ 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] * bJ(
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bw(
 material,
 prepared.diffuseColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aM
+lobePdf
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aM;
+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] * bJ(
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bw(
 material,
 material.subsurfaceColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-aM
+lobePdf
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * lobePdf;
 }
 
 if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) {
-vec3 cB = vec3(cY(prepared, bm, true));
+vec3 ck = vec3(cK(prepared, viewHalf, true));
 if (material.thinFilmWeight > 0.0) {
-cB = cc(
-cB,
-bm,
+ck = bQ(
+ck,
+viewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1268,33 +1268,33 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-cB = av(
-cB,
+ck = aq(
+ck,
 material.transmissionWeight
 );
 }
-vec3 bG = material.specularColor * cB;
-response += prepared.weights[OPENPBR_LOBE_SPECULAR] * ao(
+vec3 fresnel = material.specularColor * ck;
+response += prepared.weights[OPENPBR_LOBE_SPECULAR] * aj(
 material,
 viewLocal,
 lightLocal,
-ad,
-bG,
-aM
+aa,
+fresnel,
+lobePdf
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * lobePdf;
 }
 
 if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) {
-vec3 bG = cw(
-bm,
+vec3 fresnel = openpbr_metal_fresnel(
+viewHalf,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
 if (material.thinFilmWeight > 0.0) {
-bG = lZ(
-bG,
-bm,
+fresnel = lI(
+fresnel,
+viewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
 material.baseWeight * material.baseColor,
@@ -1303,29 +1303,29 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-bG *= material.specularWeight;
-response += prepared.weights[OPENPBR_LOBE_METAL] * ao(
+fresnel *= material.specularWeight;
+response += prepared.weights[OPENPBR_LOBE_METAL] * aj(
 material,
 viewLocal,
 lightLocal,
-ad,
-bG,
-aM
+aa,
+fresnel,
+lobePdf
 );
 if (prepared.metalMsFactor > 0.0) {
-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);
+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;
+lobePdf = mix(lobePdf, 0.5 * INVPI, prepared.metalMsProbability);
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * lobePdf;
 }
 }
 else {
-vec3 bG = vec3(cY(prepared, bm, false));
+vec3 fresnel = vec3(cK(prepared, viewHalf, false));
 if (material.thinFilmWeight > 0.0) {
-bG = cc(
-bG,
-bm,
+fresnel = bQ(
+fresnel,
+viewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1335,17 +1335,17 @@ prepared.thinFilmExteriorIor
 }
 if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) {
 if (material.thinWalled) {
-vec3 lI = vec3(lightLocal.xy, -lightLocal.z);
-vec3 du = normalize(lI + viewLocal);
-if (du.z < 0.0) {
-du = -du;
+vec3 lm = vec3(lightLocal.xy, -lightLocal.z);
+vec3 thinWallHalf = normalize(lm + viewLocal);
+if (thinWallHalf.z < 0.0) {
+thinWallHalf = -thinWallHalf;
 }
-float oM = abs(dot(viewLocal, du));
-vec3 mv = vec3(cY(prepared, oM, false));
+float thinWallViewHalf = abs(dot(viewLocal, thinWallHalf));
+vec3 lZ = vec3(cK(prepared, thinWallViewHalf, false));
 if (material.thinFilmWeight > 0.0) {
-mv = cc(
-mv,
-oM,
+lZ = bQ(
+lZ,
+thinWallViewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1353,66 +1353,66 @@ material.thinFilmWeight,
 prepared.thinFilmExteriorIor
 );
 }
-vec3 gA = av(
-mv,
+vec3 gk = aq(
+lZ,
 1.0
 );
-vec3 tint = bN(
+vec3 tint = bF(
 material,
 abs(viewLocal.z),
 prepared.refractionEtaTOverEtaI
 );
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* ao(
+* aj(
 material,
 viewLocal,
-lI,
-du,
-tint * (vec3(1.0) - gA),
-aM
+lm,
+thinWallHalf,
+tint * (vec3(1.0) - gk),
+lobePdf
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dE(
+* dc(
 material,
 material.relativeIor,
-bh(material),
+ba(material),
 viewLocal,
 lightLocal,
-ad,
-bG,
-aM
+aa,
+fresnel,
+lobePdf
 );
 }
 if (prepared.dielectricMsProbability > 0.0) {
-aM *= 1.0 - prepared.dielectricMsProbability;
+lobePdf *= 1.0 - prepared.dielectricMsProbability;
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * lobePdf;
 }
 if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) {
 if (material.thinWalled) {
-vec3 pb = vec3(lightLocal.xy, -lightLocal.z);
+vec3 oQ = vec3(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* bJ(
+* bw(
 material,
 material.subsurfaceColor,
 viewLocal,
-pb,
+oQ,
 diffuseSpecularEnergyCompensation,
-aM
+lobePdf
 );
-aM *= 0.5;
+lobePdf *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dX(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dK(
 material,
 viewLocal,
 lightLocal,
-aM
+lobePdf
 );
 }
-pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * lobePdf;
 }
 }
 
@@ -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 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);
+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);
 vec3 scale = (reflection ? prepared.dielectricMsReflectionScale : prepared.dielectricMsTransmissionScale);
-response += scale * cL * INVPI;
-pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ju * 0.5 * INVPI;
+response += scale * cv * INVPI;
+pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iZ * 0.5 * INVPI;
 }
 }
 
@@ -1437,7 +1437,7 @@ pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMs
 } 
 #endif
 if (material.coatWeight > 0.0) {
-response *= cF(prepared,
+response *= cm(prepared,
 #ifdef USE_COAT_NORMAL_FRAMES
 independentCoat ? coatLightCosine : lightLocal.z
 #else
@@ -1456,42 +1456,42 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-vec3 dT = viewLocal;
-vec3 lh = lightLocal;
-vec3 gL = ad;
-float kk = bm;
+vec3 dG = viewLocal;
+vec3 kQ = lightLocal;
+vec3 coatHalf = aa;
+float coatViewHalf = viewHalf;
 if (prepared.directionFrames) {
-dT = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
+dG = openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal));
 #ifdef USE_COAT_NORMAL_FRAMES
-if (independentCoat) { dT = prepared.coatViewLocal; }
+if (independentCoat) { dG = prepared.coatViewLocal; }
 #endif
-lh = openpbr_to_local(prepared.coatBasis, lightDirection);
-gL = normalize(lh + dT);
-if (gL.z < 0.0) { gL = -gL; }
-kk = abs(dot(dT, gL));
+kQ = openpbr_to_local(prepared.coatBasis, lightDirection);
+coatHalf = normalize(kQ + dG);
+if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }
+coatViewHalf = abs(dot(dG, coatHalf));
 }
 
-vec3 lQ = vec3(af(
-kk,
+vec3 lB = vec3(ae(
+coatViewHalf,
 1.0 / material.coatIor
 ));
-OpenPbrResolvedMaterial dS = material;
-vec2 jX = aN(material.coatRoughness, material.coatAnisotropy);
-dS.alphaX = jX.x;
-dS.alphaY = jX.y;
+OpenPbrResolvedMaterial dF = material;
+vec2 jD = aL(material.coatRoughness, material.coatAnisotropy);
+dF.alphaX = jD.x;
+dF.alphaY = jD.y;
 response += prepared.weights[OPENPBR_LOBE_COAT]
 #ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(coatLightCosine, 0.0) : 1.0)
 #endif
-* ao(
-dS,
-dT,
-lh,
-gL,
-lQ,
-aM
+* aj(
+dF,
+dG,
+kQ,
+coatHalf,
+lB,
+lobePdf
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
 }
 
 if (
@@ -1501,25 +1501,25 @@ if (
 reflection
 #endif
 && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-float rC = aU(
+float rt = aQ(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3(0.0),
-vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rC)
+vec3(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rt)
 );
 response += prepared.weights[OPENPBR_LOBE_FUZZ]
 #ifdef USE_COAT_NORMAL_FRAMES
 * (independentCoat ? max(lightLocal.z, 0.0) : 1.0)
 #endif
-* kD(
+* kg(
 material,
 viewLocal,
 lightLocal,
-aM
+lobePdf
 );
-pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aM;
+pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * lobePdf;
 }
 
 #ifdef USE_COAT_NORMAL_FRAMES
@@ -1528,35 +1528,35 @@ if (independentCoat) { return response; }
 return response * abs(lightLocal.z);
 }
 
-vec3 sp(
+vec3 sj(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bM,
+vec3 bD,
 vec3 normal,
 vec3 lightDirection,
 out float pdf
 ) {
-ag prepared = ds(
+OpenPbrPreparedBsdf prepared = bV(
 tangent,
 material,
-bM,
+bD,
 normal
 );
-return bO(prepared, lightDirection, pdf);
+return openpbr_eval_prepared(prepared, lightDirection, pdf);
 }
 
-float xN(
+float openpbr_pdf(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 bM,
+vec3 bD,
 vec3 normal,
 vec3 lightDirection
 ) {
 float pdf;
-sp(
+sj(
 tangent,
 material,
-bM,
+bD,
 normal,
 lightDirection,
 pdf
@@ -1564,18 +1564,18 @@ pdf
 return pdf;
 }
 
-vec3 eN(
-ag prepared,
-vec3 cq,
+vec3 dl(
+OpenPbrPreparedBsdf prepared,
+vec3 cc,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
 OpenPbrResolvedMaterial material = prepared.material;
 vec3 viewLocal = prepared.viewLocal;
-float cH = cq.x;
-float fL = cq.y;
-float bv = cq.z;
+float cp = cc.x;
+float fp = cc.y;
+float bl = 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 (bh(prepared.material) * cF(prepared,
+return (ba(prepared.material) * cm(prepared,
 #ifdef USE_COAT_NORMAL_FRAMES
 prepared.material.coatNormalEnabled ? dot(prepared.coatBasis.normal, lightDirection) : -prepared.viewLocal.z
 #else
@@ -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 jT = 1; jT < OPENPBR_LOBE_COUNT; jT++) {
-cdf[jT] = cdf[jT - 1] + prepared.probabilities[jT];
+for (int lobe = 1; lobe < OPENPBR_LOBE_COUNT; lobe++) {
+cdf[lobe] = cdf[lobe - 1] + prepared.probabilities[lobe];
 }
 if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {
 return vec3(0.0);
 }
 
 vec3 lightLocal;
-if (bv < cdf[OPENPBR_LOBE_FUZZ] || (
-bv >= cdf[OPENPBR_LOBE_TRANSMISSION] && bv < cdf[OPENPBR_LOBE_DIFFUSE]
+if (bl < cdf[OPENPBR_LOBE_FUZZ] || (
+bl >= cdf[OPENPBR_LOBE_TRANSMISSION] && bl < cdf[OPENPBR_LOBE_DIFFUSE]
 )) {
-lightLocal = aO(vec2(cH, fL));
+lightLocal = aM(vec2(cp, fp));
 }
-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)); }
+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)); }
 #ifdef USE_COAT_NORMAL_FRAMES
-if (material.coatNormalEnabled) { dT = prepared.coatViewLocal; }
+if (material.coatNormalEnabled) { dG = prepared.coatViewLocal; }
 #endif
-vec3 ad = aD(
-dT,
+vec3 aa = aA(
+dG,
 
-aN(material.coatRoughness, material.coatAnisotropy),
-vec2(cH, fL)
+aL(material.coatRoughness, material.coatAnisotropy),
+vec2(cp, fp)
 );
-if (ad.z < 0.0) {
-ad = -ad;
+if (aa.z < 0.0) {
+aa = -aa;
 }
-lightLocal = normalize(reflect(-dT, ad));
+lightLocal = normalize(reflect(-dG, aa));
 #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 bO(prepared, lightDirection, pdf);
+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 (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 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 {
-vec3 ad = aD(
+vec3 aa = aA(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cH, fL)
+vec2(cp, fp)
 );
-if (ad.z < 0.0) {
-ad = -ad;
+if (aa.z < 0.0) {
+aa = -aa;
 }
-lightLocal = normalize(reflect(-viewLocal, ad));
+lightLocal = normalize(reflect(-viewLocal, aa));
 }
 }
-else if (bv < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+else if (bl < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 isTransmissionEvent = true;
 
 
-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 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 z;
-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;
+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;
 }
 else {
-vec3 ad = aD(
+vec3 aa = aA(
 viewLocal,
 vec2(material.alphaX, material.alphaY),
-vec2(cH, fL)
+vec2(cp, fp)
 );
-if (ad.z < 0.0) {
-ad = -ad;
+if (aa.z < 0.0) {
+aa = -aa;
 }
-float bm = abs(dot(viewLocal, ad));
-vec3 bG = vec3(af(
-bm,
+float viewHalf = abs(dot(viewLocal, aa));
+vec3 fresnel = vec3(ae(
+viewHalf,
 prepared.material.relativeIor
 ));
 if (material.thinFilmWeight > 0.0) {
-bG = cc(
-bG,
-bm,
+fresnel = bQ(
+fresnel,
+viewHalf,
 material.thinFilmThickness,
 material.thinFilmIor,
 prepared.thinFilmBaseIor,
@@ -1700,13 +1700,13 @@ prepared.thinFilmExteriorIor
 );
 }
 if (material.thinWalled) {
-vec3 iC = normalize(reflect(-viewLocal, ad));
-lightLocal = vec3(iC.xy, -iC.z);
+vec3 hX = normalize(reflect(-viewLocal, aa));
+lightLocal = vec3(hX.xy, -hX.z);
 }
 else {
 lightLocal = refract(
 -viewLocal,
-ad,
+aa,
 prepared.material.relativeIor
 );
 if (dot(lightLocal, lightLocal) <= 1e-8) {
@@ -1720,13 +1720,13 @@ lightLocal = normalize(lightLocal);
 else {
 isTransmissionEvent = true;
 if (material.thinWalled) {
-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) {
+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) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1734,7 +1734,7 @@ isTransmissionEvent = false;
 }
 }
 else {
-lightLocal = aO(vec2(cH, fL));
+lightLocal = aM(vec2(cp, fp));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1748,20 +1748,20 @@ return vec3(0.0);
 if (material.coatNormalEnabled &&
 ((dot(material.geometricNormal, lightDirection) <= 0.0) != isTransmissionEvent)) { return vec3(0.0); }
 #endif
-return bO(prepared, lightDirection, pdf);
+return openpbr_eval_prepared(prepared, lightDirection, pdf);
 }
 
-vec3 tZ(
+vec3 uc(
 vec3 tangent,
 OpenPbrResolvedMaterial material,
-vec3 cq,
-vec3 bM,
+vec3 cc,
+vec3 bD,
 vec3 normal,
 out vec3 lightDirection,
 out float pdf,
 out bool isTransmissionEvent
 ) {
-ag prepared = ds(tangent, material, bM, normal);
-return eN(prepared, cq, lightDirection, pdf, isTransmissionEvent);
+OpenPbrPreparedBsdf prepared = bV(tangent, material, bD, normal);
+return dl(prepared, cc, lightDirection, pdf, isTransmissionEvent);
 }`;
 //# sourceMappingURL=openPbrBsdf.glsl.js.map