@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -30,17 +30,17 @@ const OPENPBR_LOBE_COUNT: i32 = ${LOBE_INDICES.length};
 
 
 
-struct bq {
+struct OpenPbrBasis {
 tangent: vec3f,
 bitangent: vec3f,
 normal: vec3f,
 };
 
-struct ag {
+struct OpenPbrPreparedBsdf {
 material: OpenPbrResolvedMaterial,
-basis: bq,
+basis: OpenPbrBasis,
 ${hasAnisotropyDirections ? /* wgsl */ `
-coatBasis: bq,
+coatBasis: OpenPbrBasis,
 directionFrames: bool,
 ` : /* wgsl */ ``}
 ${hasCoatNormals ? /* wgsl */ `    coatViewLocal: vec3f,` : ''}
@@ -68,251 +68,251 @@ weights: array<f32, OPENPBR_LOBE_COUNT>,
 probabilities: array<f32, OPENPBR_LOBE_COUNT>,
 };
 
-fn aE(color: vec3f) -> f32 {
+fn aB(color: vec3f) -> f32 {
 return dot(color, vec3f(0.212671, 0.715160, 0.072169));
 }
 
-fn dd(bE: f32) -> f32 {
-let value = (bE - 1.0) / (bE + 1.0);
+fn cO(bq: f32) -> f32 {
+let value = (bq - 1.0) / (bq + 1.0);
 return value * value;
 }
 
-fn bi(
-bE: f32,
+fn bb(
+bq: f32,
 specularWeight: f32
 ) -> f32 {
-let uh = min(
-dd(bE) * specularWeight,
+let uj = min(
+cO(bq) * specularWeight,
 0.9999
 );
-let uj = sqrt(uh);
-let lR = (1.0 + uj) / (1.0 - uj);
-return select(lR, 1.0 / lR, bE < 1.0);
+let ul = sqrt(uj);
+let lC = (1.0 + ul) / (1.0 - ul);
+return select(lC, 1.0 / lC, bq < 1.0);
 }
 
-fn af(ci: f32, relativeIor: f32) -> f32 {
+fn ae(ct: f32, relativeIor: f32) -> f32 {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return cC(ci, relativeIor);
+return sampling_dielectric_fresnel(ct, relativeIor);
 }
 
-fn aG(ior: f32) -> f32 {
+fn aE(ior: f32) -> f32 {
 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;
 }
 
-fn F(tB: i32, row: i32) -> f32 {
-return textureLoad(openPbrEnergyLut, vec2i(tB, row), 0).r;
+fn F(tC: i32, row: i32) -> f32 {
+return textureLoad(openPbrEnergyLut, vec2i(tC, row), 0).r;
 }
 
-fn gt(
-dU: f32,
-bV: f32,
-im: f32
+fn gd(
+dH: f32,
+bM: f32,
+hN: f32
 ) -> f32 {
-let bH = clamp(dU, 0.0, 31.0);
-let aL = clamp(bV, 0.0, 31.0);
-let bD = clamp(im, 0.0, 31.0);
-let ef = i32(floor(bH));
-let aT = i32(floor(aL));
-let cQ = i32(floor(bD));
-let hU = min(ef + 1, 31);
-let cu = min(aT + 1, 31);
-let fb = min(cQ + 1, 31);
-let cv = bH - f32(ef);
-let cI = aL - f32(aT);
-let lj = bD - f32(cQ);
-
-let wb = F(cQ, ef * 32 + aT);
-let wc = F(fb, ef * 32 + aT);
-let wd = F(cQ, ef * 32 + cu);
-let wf = F(fb, ef * 32 + cu);
-let wg = F(cQ, hU * 32 + aT);
-let wh = F(fb, hU * 32 + aT);
-let wi = F(cQ, hU * 32 + cu);
-let wj = F(fb, hU * 32 + cu);
-let v00 = mix(wb, wg, cv);
-let v01 = mix(wc, wh, cv);
-let v10 = mix(wd, wi, cv);
-let v11 = mix(wf, wj, cv);
+let br = clamp(dH, 0.0, 31.0);
+let aK = clamp(bM, 0.0, 31.0);
+let bp = clamp(hN, 0.0, 31.0);
+let dP = i32(floor(br));
+let aP = i32(floor(aK));
+let cD = i32(floor(bp));
+let hB = min(dP + 1, 31);
+let ch = min(aP + 1, 31);
+let eK = min(cD + 1, 31);
+let ci = br - f32(dP);
+let cq = aK - f32(aP);
+let kR = bp - f32(cD);
+
+let wv = F(cD, dP * 32 + aP);
+let ww = F(eK, dP * 32 + aP);
+let wx = F(cD, dP * 32 + ch);
+let wy = F(eK, dP * 32 + ch);
+let wB = F(cD, hB * 32 + aP);
+let wC = F(eK, hB * 32 + aP);
+let wE = F(cD, hB * 32 + ch);
+let wF = F(eK, hB * 32 + ch);
+let v00 = mix(wv, wB, ci);
+let v01 = mix(ww, wC, ci);
+let v10 = mix(wx, wE, ci);
+let v11 = mix(wy, wF, ci);
 return mix(
-mix(v00, v10, cI),
-mix(v01, v11, cI),
-lj
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+kR
 );
 }
 
-fn gS(dU: f32, bV: f32) -> f32 {
-let bH = clamp(dU, 0.0, 31.0);
-let aL = clamp(bV, 0.0, 31.0);
-let ef = i32(floor(bH));
-let aT = i32(floor(aL));
-let hU = min(ef + 1, 31);
-let cu = min(aT + 1, 31);
-let cv = bH - f32(ef);
-let cI = aL - f32(aT);
-let v00 = F(aT, 1024 + ef);
-let v01 = F(cu, 1024 + ef);
-let v10 = F(aT, 1024 + hU);
-let v11 = F(cu, 1024 + hU);
+fn gA(dH: f32, bM: f32) -> f32 {
+let br = clamp(dH, 0.0, 31.0);
+let aK = clamp(bM, 0.0, 31.0);
+let dP = i32(floor(br));
+let aP = i32(floor(aK));
+let hB = min(dP + 1, 31);
+let ch = min(aP + 1, 31);
+let ci = br - f32(dP);
+let cq = aK - f32(aP);
+let v00 = F(aP, 1024 + dP);
+let v01 = F(ch, 1024 + dP);
+let v10 = F(aP, 1024 + hB);
+let 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
 );
 }
 
 
 
-fn ev(
-dU: f32,
-bV: f32,
-im: f32
+fn ee(
+dH: f32,
+bM: f32,
+hN: f32
 ) -> f32 {
-let bH = clamp(dU, 0.0, 31.0);
-let aL = clamp(bV, 0.0, 31.0);
-let bD = clamp(im, 0.0, 31.0);
-let ef = i32(floor(bH));
-let aT = i32(floor(aL));
-let cQ = i32(floor(bD));
-let hU = min(ef + 1, 31);
-let cu = min(aT + 1, 31);
-let fb = min(cQ + 1, 31);
-let cv = bH - f32(ef);
-let cI = aL - f32(aT);
-let lj = bD - f32(cQ);
-
-let wb = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + aT);
-let wc = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + aT);
-let wd = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + cu);
-let wf = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ef * 32 + cu);
-let wg = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + aT);
-let wh = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + aT);
-let wi = F(cQ, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + cu);
-let wj = F(fb, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hU * 32 + cu);
-let v00 = mix(wb, wg, cv);
-let v01 = mix(wc, wh, cv);
-let v10 = mix(wd, wi, cv);
-let v11 = mix(wf, wj, cv);
+let br = clamp(dH, 0.0, 31.0);
+let aK = clamp(bM, 0.0, 31.0);
+let bp = clamp(hN, 0.0, 31.0);
+let dP = i32(floor(br));
+let aP = i32(floor(aK));
+let cD = i32(floor(bp));
+let hB = min(dP + 1, 31);
+let ch = min(aP + 1, 31);
+let eK = min(cD + 1, 31);
+let ci = br - f32(dP);
+let cq = aK - f32(aP);
+let kR = bp - f32(cD);
+
+let wv = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
+let ww = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aP);
+let wx = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
+let wy = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + ch);
+let wB = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
+let wC = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aP);
+let wE = F(cD, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
+let wF = F(eK, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + ch);
+let v00 = mix(wv, wB, ci);
+let v01 = mix(ww, wC, ci);
+let v10 = mix(wx, wE, ci);
+let v11 = mix(wy, wF, ci);
 return mix(
-mix(v00, v10, cI),
-mix(v01, v11, cI),
-lj
+mix(v00, v10, cq),
+mix(v01, v11, cq),
+kR
 );
 }
 
-fn eu(dU: f32, bV: f32) -> f32 {
-let bH = clamp(dU, 0.0, 31.0);
-let aL = clamp(bV, 0.0, 31.0);
-let ef = i32(floor(bH));
-let aT = i32(floor(aL));
-let hU = min(ef + 1, 31);
-let cu = min(aT + 1, 31);
-let cv = bH - f32(ef);
-let cI = aL - f32(aT);
-let v00 = F(aT, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ef);
-let v01 = F(cu, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ef);
-let v10 = F(aT, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hU);
-let v11 = F(cu, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hU);
+fn ec(dH: f32, bM: f32) -> f32 {
+let br = clamp(dH, 0.0, 31.0);
+let aK = clamp(bM, 0.0, 31.0);
+let dP = i32(floor(br));
+let aP = i32(floor(aK));
+let hB = min(dP + 1, 31);
+let ch = min(aP + 1, 31);
+let ci = br - f32(dP);
+let cq = aK - f32(aP);
+let v00 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
+let v01 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
+let v10 = F(aP, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+let v11 = F(ch, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
 return mix(
-mix(v00, v10, cv),
-mix(v01, v11, cv),
-cI
+mix(v00, v10, ci),
+mix(v01, v11, ci),
+cq
 );
 }
 
-fn eR(dU: f32, bV: f32) -> f32 {
-let bH = clamp(dU, 0.0, 31.0);
-let aL = clamp(bV, 0.0, 31.0);
-let ef = i32(floor(bH));
-let aT = i32(floor(aL));
-let hU = min(ef + 1, 31);
-let cu = min(aT + 1, 31);
-let cv = bH - f32(ef);
-let cI = aL - f32(aT);
-let v00 = F(aT, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ef);
-let v01 = F(cu, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ef);
-let v10 = F(aT, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hU);
-let v11 = F(cu, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hU);
+fn eC(dH: f32, bM: f32) -> f32 {
+let br = clamp(dH, 0.0, 31.0);
+let aK = clamp(bM, 0.0, 31.0);
+let dP = i32(floor(br));
+let aP = i32(floor(aK));
+let hB = min(dP + 1, 31);
+let ch = min(aP + 1, 31);
+let ci = br - f32(dP);
+let cq = aK - f32(aP);
+let v00 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
+let v01 = F(ch, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
+let v10 = F(aP, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+let 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
 );
 }
 
-fn bb(ior: f32, alpha: f32, cosine: f32) -> f32 {
-return ev(aG(ior), sqrt(alpha) * 31.0, cosine * 31.0);
+fn aV(ior: f32, alpha: f32, cosine: f32) -> f32 {
+return ee(aE(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-fn bf(ior: f32, alpha: f32) -> f32 {
-return eu(aG(ior), sqrt(alpha) * 31.0);
+fn aY(ior: f32, alpha: f32) -> f32 {
+return ec(aE(ior), sqrt(alpha) * 31.0);
 }
-fn ck(ior: f32, alpha: f32) -> f32 {
-return eR(aG(ior), sqrt(alpha) * 31.0);
+fn bU(ior: f32, alpha: f32) -> f32 {
+return eC(aE(ior), sqrt(alpha) * 31.0);
 }
 
 
 
-fn aV(alpha: f32, cosine: f32) -> f32 {
-let iF = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
-let bD = clamp(cosine * 31.0, 0.0, 31.0);
-let r0 = i32(floor(iF));
-let c0 = i32(floor(bD));
+fn aR(alpha: f32, cosine: f32) -> f32 {
+let ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+let bp = clamp(cosine * 31.0, 0.0, 31.0);
+let r0 = i32(floor(ie));
+let c0 = i32(floor(bp));
 let r1 = min(r0 + 1, 31);
 let c1 = min(c0 + 1, 31);
 return mix(
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(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));
 }
 
-fn cD(alpha: f32) -> f32 {
+fn cl(alpha: f32) -> f32 {
 let index = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
 let i0 = i32(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));
 }
 
-fn bd(value: f32, ior: f32) -> f32 {
+fn aX(value: f32, ior: f32) -> f32 {
 if ((ior > 2.5) | (ior < 0.4)) {
-let vu = dd(2.5);
-let progress = (dd(ior) - vu) / (1.0 - vu);
+let vH = cO(2.5);
+let progress = (cO(ior) - vH) / (1.0 - vH);
 return (1.0 - progress) * value;
 }
 return value;
 }
 
-fn aw(
+fn ar(
 ior: f32,
 alpha: f32,
 cosine: f32
 ) -> f32 {
-let value = gt(
-aG(ior),
+let value = gd(
+aE(ior),
 sqrt(alpha) * 31.0,
 cosine * 31.0
 );
-return bd(value, ior);
+return aX(value, ior);
 }
 
-fn cA(ior: f32, alpha: f32) -> f32 {
-let value = gS(
-aG(ior),
+fn cj(ior: f32, alpha: f32) -> f32 {
+let value = gA(
+aE(ior),
 sqrt(alpha) * 31.0
 );
-return bd(value, ior);
+return aX(value, ior);
 }
 
-fn openpbr_to_world(basis: bq, direction: vec3f) -> vec3f {
+fn openpbr_to_world(basis: OpenPbrBasis, direction: vec3f) -> vec3f {
 return direction.x * basis.tangent
 + direction.y * basis.bitangent
 + direction.z * basis.normal;
 }
 
-fn openpbr_to_local(basis: bq, direction: vec3f) -> vec3f {
+fn openpbr_to_local(basis: OpenPbrBasis, direction: vec3f) -> vec3f {
 return vec3f(
 dot(direction, basis.tangent),
 dot(direction, basis.bitangent),
@@ -320,17 +320,17 @@ dot(direction, basis.normal)
 );
 }
 
-fn fD(
-aX: vec3f,
+fn ff(
+aS: vec3f,
 normal: vec3f,
 anisotropy: f32
-) -> bq {
-var basis: bq;
+) -> OpenPbrBasis {
+var basis: OpenPbrBasis;
 basis.normal = normal;
-var tangent = aX;
+var tangent = aS;
 var bitangent = vec3f(0.0);
 if ((dot(tangent, tangent) < 0.001) | (anisotropy <= 0.0)) {
-aP(normal, &tangent, &bitangent);
+sampling_orthonormal_basis(normal, &tangent, &bitangent);
 }
 else {
 bitangent = normalize(cross(normal, tangent));
@@ -341,153 +341,153 @@ basis.bitangent = bitangent;
 return basis;
 }
 
-fn kF(
-aB: f32,
-am: f32,
+fn ki(
+av: f32,
+ai: f32,
 J: f32,
-ae: f32
+ad: f32
 ) -> f32 {
-return (aB * J - am * ae)
-/ (aB * J + am * ae);
+return (av * J - ai * ad)
+/ (av * J + ai * ad);
 }
 
-fn kE(
-aB: f32,
-am: f32,
+fn kh(
+av: f32,
+ai: f32,
 J: f32,
-ae: f32
+ad: f32
 ) -> f32 {
-return (am * J - aB * ae)
-/ (aB * ae + am * J);
+return (ai * J - av * ad)
+/ (av * ad + ai * J);
 }
 
-fn ht(
-aB: f32,
-am: f32,
+fn gZ(
+av: f32,
+ai: f32,
 J: f32,
-ae: f32
+ad: f32
 ) -> f32 {
-return 2.0 * aB * J
-/ (aB * J + am * ae);
+return 2.0 * av * J
+/ (av * J + ai * ad);
 }
 
-fn hs(
-aB: f32,
-am: f32,
+fn gY(
+av: f32,
+ai: f32,
 J: f32,
-ae: f32
+ad: f32
 ) -> f32 {
-return 2.0 * aB * J
-/ (aB * ae + am * J);
+return 2.0 * av * J
+/ (av * ad + ai * J);
 }
 
-fn aY(a: vec2f, b: vec2f) -> vec2f {
+fn aT(a: vec2f, b: vec2f) -> vec2f {
 return vec2f(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
-fn bj(a: vec2f, b: vec2f) -> vec2f {
-let aq = max(dot(b, b), 1e-9);
+fn bc(a: vec2f, b: vec2f) -> vec2f {
+let ah = max(dot(b, b), 1e-9);
 return vec2f(
-(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
 );
 }
 
-fn iA(value: vec2f) -> vec2f {
-let gR = length(value);
-let uf = sqrt(max(0.0, 0.5 * (gR + value.x)));
-let fw = sqrt(max(0.0, 0.5 * (gR - value.x)));
-return vec2f(uf, select(-fw, fw, value.y >= 0.0));
+fn hV(value: vec2f) -> vec2f {
+let gz = length(value);
+let ui = sqrt(max(0.0, 0.5 * (gz + value.x)));
+let fc = sqrt(max(0.0, 0.5 * (gz - value.x)));
+return vec2f(ui, select(-fc, fc, value.y >= 0.0));
 }
 
-fn ce(
+fn bR(
 J: f32,
-aB: f32,
-am: vec2f,
-rM: bool
+av: f32,
+ai: vec2f,
+rH: bool
 ) -> vec2f {
-let pg = sqrt(max(0.0, 1.0 - J * J));
-let tP = bj(vec2f(aB, 0.0), am);
-let hQ = tP * pg;
-var ae = iA(
-vec2f(1.0, 0.0) - aY(hQ, hQ)
+let oV = sqrt(max(0.0, 1.0 - J * J));
+let tR = bc(vec2f(av, 0.0), ai);
+let hx = tR * oV;
+var ad = hV(
+vec2f(1.0, 0.0) - aT(hx, hx)
 );
-if (aY(am, ae).y < 0.0) {
-ae = -ae;
-}
-
-let fZ = vec2f(aB * J, 0.0);
-let eJ = aY(am, ae);
-if (rM) {
-let cl = am * J;
-let cj = ae * aB;
-return bj(
-cl - cj,
-cl + cj
+if (aT(ai, ad).y < 0.0) {
+ad = -ad;
+}
+
+let fL = vec2f(av * J, 0.0);
+let eu = aT(ai, ad);
+if (rH) {
+let bW = ai * J;
+let bT = ad * av;
+return bc(
+bW - bT,
+bW + bT
 );
 }
-return bj(
-fZ - eJ,
-fZ + eJ
+return bc(
+fL - eu,
+fL + eu
 );
 }
 
-fn eE(
-iZ: f32,
-ha: f32,
-pw: f32,
-nL: f32,
-kL: vec2f,
+fn em(
+iI: f32,
+gJ: f32,
+pk: f32,
+nA: f32,
+ko: vec2f,
 phase: f32
 ) -> f32 {
-let ol = vec2f(cos(phase), sin(phase));
-let iD = aY(kL, ol);
-let lv = iD * (ha * nL);
-let aq = vec2f(1.0, 0.0) - iD * pw;
-let hP = vec2f(iZ, 0.0)
-+ bj(lv, aq);
-return dot(hP, hP);
+let nZ = vec2f(cos(phase), sin(phase));
+let hY = aT(ko, nZ);
+let iF = hY * (gJ * nA);
+let ah = vec2f(1.0, 0.0) - hY * pk;
+let hw = vec2f(iI, 0.0)
++ bc(iF, ah);
+return dot(hw, hw);
 }
 
-fn au(
+fn ap(
 J: f32,
 wavelength: f32,
-ct: f32,
-aR: f32,
-cn: f32,
-eG: vec2f
+cf: f32,
+aN: f32,
+bY: f32,
+ep: vec2f
 ) -> f32 {
-let dF = clamp(abs(J), 1e-5, 1.0);
-let hI = pow(aR / cn, 2.0)
-* (1.0 - dF * dF);
-if (hI >= 1.0) {
+let dd = clamp(abs(J), 1e-5, 1.0);
+let hp = pow(aN / bY, 2.0)
+* (1.0 - dd * dd);
+if (hp >= 1.0) {
 return 1.0;
 }
-let dc = sqrt(1.0 - hI);
-let lL = kF(
-aR, cn, dF, dc
+let cN = sqrt(1.0 - hp);
+let lq = ki(
+aN, bY, dd, cN
 );
-let lK = kE(
-aR, cn, dF, dc
+let lp = kh(
+aN, bY, dd, cN
 );
-let jG = ht(
-aR, cn, dF, dc
+let jm = gZ(
+aN, bY, dd, cN
 );
-let jF = hs(
-aR, cn, dF, dc
+let jl = gY(
+aN, bY, dd, cN
 );
-let gG = cn * dc
-/ max(aR * dF, 1e-9);
-let phase = 2.0 * PI * (2.0 * cn * ct * dc) / wavelength;
+let gp = bY * cN
+/ max(aN * dd, 1e-9);
+let phase = 2.0 * PI * (2.0 * bY * cf * cN) / wavelength;
 var reflectance = 0.0;
 
-for (var kJ = 0u; kJ < (rtUniform.loopUnrollGuard >> 1u); kJ++) {
-let iZ = select(lL, lK, kJ == 1u);
-let ha = select(jG, jF, kJ == 1u);
-let kL = ce(
-dc, cn, eG, kJ == 1u);
-reflectance += eE(iZ, ha,
--iZ, ha * gG, kL, phase);
+for (var kn = 0u; kn < (rtUniform.loopUnrollGuard >> 1u); kn++) {
+let iI = select(lq, lp, kn == 1u);
+let gJ = select(jm, jl, kn == 1u);
+let ko = bR(
+cN, bY, ep, kn == 1u);
+reflectance += em(iI, gJ,
+-iI, gJ * gp, ko, phase);
 }
 return clamp(0.5 * reflectance, 0.0, 1.0);
 }
@@ -495,44 +495,44 @@ return clamp(0.5 * reflectance, 0.0, 1.0);
 
 
 
-fn cw(cosine: f32, f0: vec3f, tint: vec3f) -> vec3f {
-let sr = mix(f0, vec3f(1.0), aI(cosine));
-if (all(tint == vec3f(1.0))) { return sr; }
-let dD = 1.0 / 7.0;
-let mY = 1.0 - dD;
-let fX = mix(f0, vec3f(1.0), aI(dD));
-let dw = 1.0 - cosine;
-let ru = cosine * aI(cosine) * dw
-/ (dD * pow(mY, 6.0));
-return clamp(sr - ru * (fX - tint * fX), vec3f(0.0), vec3f(1.0));
+fn openpbr_metal_fresnel(cosine: f32, f0: vec3f, tint: vec3f) -> vec3f {
+let sl = mix(f0, vec3f(1.0), aH(cosine));
+if (all(tint == vec3f(1.0))) { return sl; }
+let da = 1.0 / 7.0;
+let mK = 1.0 - da;
+let fJ = mix(f0, vec3f(1.0), aH(da));
+let cY = 1.0 - cosine;
+let rp = cosine * aH(cosine) * cY
+/ (da * pow(mK, 6.0));
+return clamp(sl - rp * (fJ - tint * fJ), vec3f(0.0), vec3f(1.0));
 }
 
-fn cX(f0: f32, uN: f32) -> vec2f {
-let dY = clamp(f0, 0.0, 0.99);
-let gZ = sqrt(dY);
-let rK = (1.0 - dY) / (1.0 + dY);
-let rH = (1.0 + gZ) / max(1.0 - gZ, 1e-9);
-let ior = mix(rH, rK, clamp(uN, 0.0, 1.0));
-let kp = (
-(ior + 1.0) * (ior + 1.0) * dY
+fn cJ(f0: f32, uS: f32) -> vec2f {
+let dL = clamp(f0, 0.0, 0.99);
+let gI = sqrt(dL);
+let rF = (1.0 - dL) / (1.0 + dL);
+let rC = (1.0 + gI) / max(1.0 - gI, 1e-9);
+let ior = mix(rC, rF, clamp(uS, 0.0, 1.0));
+let jT = (
+(ior + 1.0) * (ior + 1.0) * dL
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dY, 1e-9);
-return vec2f(ior, sqrt(max(kp, 0.0)));
+) / max(1.0 - dL, 1e-9);
+return vec2f(ior, sqrt(max(jT, 0.0)));
 }
 
 
-fn bS(ct: f32, weight: f32) -> f32 {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ct);
+fn bJ(cf: f32, weight: f32) -> f32 {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cf);
 }
 
 
 
-fn bJ(
+fn bw(
 material: OpenPbrResolvedMaterial,
 color: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-fJ: f32,
+fl: f32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -541,26 +541,26 @@ return vec3f(0.0);
 }
 
 let roughness = material.diffuseRoughness;
-let hl = 0.5 - 2.0 / (3.0 * PI);
-let pc = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-let pp = lightLocal.z;
-let nt = viewLocal.z;
-let directional = dot(lightLocal, viewLocal) - pp * nt;
-let hh = select(
+let gS = 0.5 - 2.0 / (3.0 * PI);
+let oR = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+let pe = lightLocal.z;
+let nd = viewLocal.z;
+let directional = dot(lightLocal, viewLocal) - pe * nd;
+let gP = select(
 directional,
-directional / max(max(pp, nt), 1e-7),
+directional / max(max(pe, nd), 1e-7),
 directional > 0.0
 );
-let iJ = 1.0 / (1.0 + hl * roughness);
-let ot = color * INVPI * iJ
-* (1.0 + roughness * hh);
-
-let dr = 1.0 - pp;
-let outputComplement = 1.0 - nt;
-let ph = dr * (
-0.0571085289 + dr * (
-0.491881867 + dr * (
--0.332181442 + dr * 0.0714429953
+let il = 1.0 / (1.0 + gS * roughness);
+let oe = color * INVPI * il
+* (1.0 + roughness * gP);
+
+let cW = 1.0 - pe;
+let outputComplement = 1.0 - nd;
+let oW = cW * (
+0.0571085289 + cW * (
+0.491881867 + cW * (
+-0.332181442 + cW * 0.0714429953
 )
 )
 );
@@ -571,22 +571,22 @@ let outputGOverPi = outputComplement * (
 )
 )
 );
-let qr = (1.0 + roughness * ph)
-/ (1.0 + hl * roughness);
+let qj = (1.0 + roughness * oW)
+/ (1.0 + gS * roughness);
 let outputAlbedo = (1.0 + roughness * outputGOverPi)
-/ (1.0 + hl * roughness);
-let gi = iJ * (1.0 + pc * roughness);
-let hV = color * color * gi
-/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - gi));
-let mn = hV * INVPI
+/ (1.0 + gS * roughness);
+let fU = il * (1.0 + oR * roughness);
+let hC = color * color * fU
+/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fU));
+let 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;
 }
 
-fn aU(viewCosine: f32, roughness: f32) -> f32 {
+fn aQ(viewCosine: f32, roughness: f32) -> f32 {
 let x = clamp(viewCosine, 0.0, 1.0);
 let y = clamp(roughness, 0.01, 1.0);
 let scale = y * (0.0206607 + 1.58491 * y)
@@ -600,7 +600,7 @@ let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-fn kD(
+fn kg(
 material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -610,7 +610,7 @@ pdf: ptr<function, f32>
 if ((viewLocal.z <= 0.0) | (lightLocal.z <= 0.0)) {
 return vec3f(0.0);
 }
-let albedo = aU(
+let albedo = aQ(
 viewLocal.z,
 material.fuzzRoughness
 );
@@ -618,12 +618,12 @@ material.fuzzRoughness
 return material.fuzzColor * albedo * INVPI;
 }
 
-fn ao(
+fn aj(
 material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
-ad: vec3f,
-bG: vec3f,
+aa: vec3f,
+fresnel: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -632,24 +632,24 @@ return vec3f(0.0);
 }
 
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = cW(ad, alpha);
-let kz = aF(viewLocal, alpha);
-let ep = kz
-* aF(lightLocal, alpha);
+let distribution = sampling_ggx_ndf(aa, alpha);
+let kc = aD(viewLocal, alpha);
+let 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));
 }
 
-fn dE(
+fn dc(
 material: OpenPbrResolvedMaterial,
 relativeIor: f32,
 tint: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-ad: vec3f,
-bG: vec3f,
+aa: vec3f,
+fresnel: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -657,74 +657,74 @@ if (lightLocal.z >= 0.0) {
 return vec3f(0.0);
 }
 
-let ls = dot(lightLocal, ad);
-let bm = dot(viewLocal, ad);
+let lightHalf = dot(lightLocal, aa);
+let viewHalf = dot(viewLocal, aa);
 
 
-if ((bm <= 0.0) | (ls >= 0.0)) {
+if ((viewHalf <= 0.0) | (lightHalf >= 0.0)) {
 return vec3f(0.0);
 }
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = cW(ad, alpha);
-let kz = aF(viewLocal, alpha);
-let ep = kz
-* aF(lightLocal, alpha);
-var aq = ls + bm * relativeIor;
-aq *= aq;
-let qw = abs(ls) / max(aq, 1e-8);
-let jU = relativeIor * relativeIor;
-
-*pdf = kz * max(0.0, bm) * distribution * qw
+let distribution = sampling_ggx_ndf(aa, alpha);
+let kc = aD(viewLocal, alpha);
+let dY = kc
+* aD(lightLocal, alpha);
+var ah = lightHalf + viewHalf * relativeIor;
+ah *= ah;
+let qo = abs(lightHalf) / max(ah, 1e-8);
+let jB = relativeIor * relativeIor;
+
+*pdf = kc * max(0.0, viewHalf) * distribution * qo
 / max(viewLocal.z, 1e-8);
-return tint * (vec3f(1.0) - bG) * distribution * ep
-* abs(bm) * qw * jU
+return tint * (vec3f(1.0) - fresnel) * distribution * dY
+* abs(viewHalf) * qo * jB
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-fn bh(material: OpenPbrResolvedMaterial) -> vec3f {
+fn ba(material: OpenPbrResolvedMaterial) -> vec3f {
 if (HAS_MEDIUM & (material.mediumType > 0)) {
 return vec3f(1.0);
 }
 return material.transmissionColor;
 }
 
-fn cZ(ai: f32) -> f32 {
-return 2.0 * ai / (1.0 + ai);
+fn cL(ag: f32) -> f32 {
+return 2.0 * ag / (1.0 + ag);
 }
 
-fn av(
-ai: vec3f,
+fn aq(
+ag: vec3f,
 transmissionWeight: f32
 ) -> vec3f {
-let gA = 2.0 * ai
-/ (vec3f(1.0) + ai);
+let gk = 2.0 * ag
+/ (vec3f(1.0) + ag);
 return mix(
-ai,
-gA,
+ag,
+gk,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
 
-fn bN(
+fn bF(
 material: OpenPbrResolvedMaterial,
 J: f32,
-bE: f32
+bq: f32
 ) -> vec3f {
-let tint = bh(material);
+let tint = ba(material);
 if (!material.thinWalled) {
 return tint;
 }
-let jc = max(0.0, 1.0 - J * J);
-let ea = jc
-/ max(bE * bE, 1e-9);
-if (ea >= 1.0) {
+let iK = max(0.0, 1.0 - J * J);
+let dM = iK
+/ max(bq * bq, 1e-9);
+if (dM >= 1.0) {
 return vec3f(0.0);
 }
-let ae = sqrt(1.0 - ea);
-return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(ae, 1e-5)));
+let ad = sqrt(1.0 - dM);
+return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(ad, 1e-5)));
 }
 
-fn dX(
+fn dK(
 material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
@@ -734,102 +734,102 @@ pdf: ptr<function, f32>
 if ((viewLocal.z <= 0.0) | (lightLocal.z >= 0.0)) {
 return vec3f(0.0);
 }
-let ae = -lightLocal.z;
-let oY = cC(
+let ad = -lightLocal.z;
+let oO = sampling_dielectric_fresnel(
 viewLocal.z,
 material.relativeIor
 );
-*pdf = ae * INVPI;
-return vec3f(1.0 - oY) * INVPI;
+*pdf = ad * INVPI;
+return vec3f(1.0 - oO) * INVPI;
 }
 
-fn eg(prepared: ptr<function, ag>) {
+fn dQ(prepared: ptr<function, OpenPbrPreparedBsdf>) {
 
 
-let sM = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+let sJ = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
 var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];
-for (var jT = 1; jT < sM; jT++) {
-total += (*prepared).probabilities[jT];
+for (var lobe = 1; lobe < sJ; lobe++) {
+total += (*prepared).probabilities[lobe];
 }
 if (total <= 1e-8) {
-for (var jT = 0; jT < sM; jT++) {
-(*prepared).probabilities[jT] = 0.0;
+for (var lobe = 0; lobe < sJ; lobe++) {
+(*prepared).probabilities[lobe] = 0.0;
 }
 return;
 }
-let pk = 1.0 / total;
-for (var jT = 0; jT < sM; jT++) {
-(*prepared).probabilities[jT] *= pk;
+let oZ = 1.0 / total;
+for (var lobe = 0; lobe < sJ; lobe++) {
+(*prepared).probabilities[lobe] *= oZ;
 }
 }
 
 
 
-fn bR(eta: f32) -> f32 {
+fn bI(eta: f32) -> f32 {
 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;
 }
 
-fn bU(f0: vec3f, tint: vec3f) -> vec3f {
-let dD = 1.0 / 7.0;
-let fX = mix(f0, vec3f(1.0), aI(dD));
-let b = fX * (vec3f(1.0) - tint) / (dD * pow(1.0 - dD, 6.0));
+fn bL(f0: vec3f, tint: vec3f) -> vec3f {
+let da = 1.0 / 7.0;
+let fJ = mix(f0, vec3f(1.0), aH(da));
+let b = fJ * (vec3f(1.0) - tint) / (da * pow(1.0 - da, 6.0));
 return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
 }
 
 
 
-fn cN(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {
+fn cA(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {
 if (cosine <= 0.0) { return vec3f(1.0); }
-let mp = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
-let uT = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(mp, 1e-5)));
-return mix(vec3f(1.0), uT, material.coatWeight);
+let lV = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));
+let uZ = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lV, 1e-5)));
+return mix(vec3f(1.0), uZ, material.coatWeight);
 }
 
-fn gF(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {
+fn gn(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {
 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);
 }
 
-fn hr(prepared: ag) -> vec3f {
+fn gX(prepared: OpenPbrPreparedBsdf) -> vec3f {
 let material = prepared.material;
 let dielectric = 1.0 - material.baseMetalness;
 let opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);
 let sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;
-let vI = dielectric * material.transmissionWeight;
-let gd = bR(prepared.specularEtaTOverEtaI);
-let lE = bR(1.0 / prepared.transmissionReflectionIor);
-let qI = clamp(opaque * gd + (sss + vI) * lE + material.baseMetalness, 0.0, 1.0);
-let jM = mix(1.0, material.specularRoughness, qI);
-let ks = bR(material.coatIor);
+let vU = dielectric * material.transmissionWeight;
+let fP = bI(prepared.specularEtaTOverEtaI);
+let lg = bI(1.0 / prepared.transmissionReflectionIor);
+let qA = clamp(opaque * fP + (sss + vU) * lg + material.baseMetalness, 0.0, 1.0);
+let jt = mix(1.0, material.specularRoughness, qA);
+let ks = bI(material.coatIor);
 let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-let k = mix(ks, kr, jM);
-let eb = material.baseMetalness * material.specularWeight * bU(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), gd)
-+ sss * material.subsurfaceColor + vec3f(vI);
-let rZ = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
-return mix(vec3f(1.0), rZ, material.coatWeight * material.coatDarkening);
+let k = mix(ks, kr, jt);
+let eb = material.baseMetalness * material.specularWeight * bL(material.baseWeight * material.baseColor, material.specularColor)
++ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fP)
++ sss * material.subsurfaceColor + vec3f(vU);
+let rV = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
+return mix(vec3f(1.0), rV, material.coatWeight * material.coatDarkening);
 }
 
-fn cF(prepared: ag, lU: f32) -> vec3f {
+fn cm(prepared: OpenPbrPreparedBsdf, lF: f32) -> vec3f {
 if (prepared.material.coatWeight <= 0.0) { return vec3f(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);
 }
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn dM(fallback: bq, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> bq {
+fn dk(fallback: OpenPbrBasis, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> OpenPbrBasis {
 var t = tangent - fallback.normal * dot(fallback.normal, tangent);
 if (dot(t, t) < 1e-8) { t = fallback.tangent; }
 t = normalize(t);
@@ -844,15 +844,15 @@ return basis;
 }
 
 ` : /* wgsl */ ``}
-fn ds(
+fn bV(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
-bM: vec3f,
+bD: vec3f,
 normal: vec3f
-) -> ag {
-var prepared: ag;
+) -> OpenPbrPreparedBsdf {
+var prepared: OpenPbrPreparedBsdf;
 prepared.material = material;
-prepared.basis = fD(
+prepared.basis = ff(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -864,39 +864,39 @@ ${hasCoatNormals ? /* wgsl */ `
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fD(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = ff(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 ` : ''}
 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, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
+prepared.coatBasis = dk(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
 prepared.directionFrames = true;
 }
 ` : /* wgsl */ ``}
-prepared.viewLocal = openpbr_to_local(prepared.basis, bM);
-${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bM);` : ''}
+prepared.viewLocal = openpbr_to_local(prepared.basis, bD);
+${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bD);` : ''}
 prepared.diffuseColor = material.baseColor;
 
-let cK = 1.0 - material.baseMetalness;
-let dW = cK
+let cu = 1.0 - material.baseMetalness;
+let 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
 );
@@ -906,20 +906,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-var cm = 1.0;
-if (!material.inside) { cm = mix(1.0, material.coatIor, material.coatWeight); }
-let bB = cm * bi(
-material.specularIor / cm, material.specularWeight);
-var eF = bB / cm;
-if ((cm > bB) & (bB >= 1.0)) {
-eF = 1.0 / eF;
-}
-prepared.specularEtaTOverEtaI = eF;
-prepared.transmissionReflectionIor = 1.0 / eF;
-prepared.refractionEtaTOverEtaI = bB;
+var bX = 1.0;
+if (!material.inside) { bX = mix(1.0, material.coatIor, material.coatWeight); }
+let bn = bX * bb(
+material.specularIor / bX, material.specularWeight);
+var 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;
 }
@@ -941,49 +941,49 @@ prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;
 prepared.specularAlpha = material.specularRoughness
 * material.specularRoughness;
 let viewCosine = abs(prepared.viewLocal.z);
-let ai = af(
+let ag = ae(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-let fN = material.specularColor * select(
-ai,
+let fu = material.specularColor * select(
+ag,
 mix(
-ai,
-cZ(ai),
+ag,
+cL(ag),
 material.transmissionWeight
 ),
 material.thinWalled
 );
-let iv = material.specularWeight * cw(
+let hS = material.specularWeight * openpbr_metal_fresnel(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-let eZ = select(
-af(viewCosine, prepared.transmissionReflectionIor),
-cZ(af(viewCosine, prepared.transmissionReflectionIor)),
+let eI = select(
+ae(viewCosine, prepared.transmissionReflectionIor),
+cL(ae(viewCosine, prepared.transmissionReflectionIor)),
 material.thinWalled
 );
-let hb = bN(
+let gK = bF(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-let iM = aw(
+let ir = ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-let gH = cA(
+let 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);
@@ -991,32 +991,32 @@ prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;
 prepared.coatBaseScale = vec3f(1.0);
 if ((material.coatWeight > 0.0) & !material.inside) {
 ${hasCoatNormals ? /* wgsl */ `let coatViewCosine = select(viewCosine, max(prepared.coatViewLocal.z, 0.0), material.coatNormalEnabled);` : ''}
-let lf = gF(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * lf;
-prepared.coatBaseScale = cN(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * lf) * hr(prepared);
+let kO = gn(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kO;
+prepared.coatBaseScale = cA(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
+* (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 = vec3f(0.0);
 prepared.metalMsFactor = 0.0;
 prepared.metalMsProbability = 0.0;
 
 
 if ((material.specularRoughness >= 0.04) & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0)) {
-let ig = bU(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * ig * ig;
-let qO = aV(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = qO / max(cD(prepared.specularAlpha), 1e-12);
-let 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);
+let hI = bL(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * hI * hI;
+let qF = aR(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = qF / max(cl(prepared.specularAlpha), 1e-12);
+let 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);
 
 
 
@@ -1031,59 +1031,59 @@ prepared.dielectricMsProbability = 0.0;
 if (!material.thinWalled & (material.transmissionWeight > 0.0) &
 (prepared.specularAlpha >= 0.0016) & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) &
 (abs(prepared.refractionEtaTOverEtaI - 1.0) > 1e-6)) {
-let mo = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * mo;
-prepared.dielectricMsTransmissionScale = hb * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+let lU = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lU;
+prepared.dielectricMsTransmissionScale = gK * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
 + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
-prepared.dielectricMsReflectionRatio = ck(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
-prepared.dielectricMsViewLoss = bb(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-let oR = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-let 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);
+let oG = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+let 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) & HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {
-let 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);
+let 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) {
-let 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);
+let 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;
 }
 
 
-fn cY(prepared: ag, cosine: f32, reflection: bool) -> f32 {
+fn cK(prepared: OpenPbrPreparedBsdf, cosine: f32, reflection: bool) -> f32 {
 if (prepared.material.coatWeight <= 0.0) {
-return af(cosine, prepared.material.relativeIor);
+return ae(cosine, prepared.material.relativeIor);
 }
-let kU = af(cosine, prepared.transmissionReflectionIor);
-if (!reflection) { return kU; }
-let oj = af(cosine, 1.0 / prepared.specularEtaTOverEtaI);
-let sQ = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(oj, kU, sQ);
+let kA = ae(cosine, prepared.transmissionReflectionIor);
+if (!reflection) { return kA; }
+let nY = ae(cosine, 1.0 / prepared.specularEtaTOverEtaI);
+let sN = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(nY, kA, sN);
 }
 
-fn nA(
-prepared: ag,
+fn nh(
+prepared: OpenPbrPreparedBsdf,
 lightDirection: vec3f,
-hc: i32,
+gL: i32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 let material = prepared.material;
@@ -1097,73 +1097,73 @@ let coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);
 let coatReflection = geometricReflection & (prepared.coatViewLocal.z > 0.0) & (coatLightCosine > 0.0);
 ` : ''}
 
-var ad: vec3f;
+var aa: vec3f;
 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;
 }
 
 var response = vec3f(0.0);
 *pdf = 0.0;
-var aM = 0.0;
-let mO = hc < 0;
-let ws = mO | (hc == OPENPBR_LOBE_FUZZ);
-let uA = mO | (hc == OPENPBR_LOBE_COAT);
-let tn = mO | (hc == OPENPBR_LOBE_METAL);
-let rf = mO | (hc == OPENPBR_LOBE_SPECULAR);
-let kd = mO | (hc == OPENPBR_LOBE_TRANSMISSION);
-let uF = mO | (hc == OPENPBR_LOBE_DIFFUSE);
-let pP = mO | (hc == OPENPBR_LOBE_SUBSURFACE);
-let bm = abs(dot(viewLocal, ad));
+var lobePdf = 0.0;
+let mA = gL < 0;
+let wP = mA | (gL == OPENPBR_LOBE_FUZZ);
+let uE = mA | (gL == OPENPBR_LOBE_COAT);
+let tn = mA | (gL == OPENPBR_LOBE_METAL);
+let qW = mA | (gL == OPENPBR_LOBE_SPECULAR);
+let jJ = mA | (gL == OPENPBR_LOBE_TRANSMISSION);
+let uJ = mA | (gL == OPENPBR_LOBE_DIFFUSE);
+let pG = mA | (gL == OPENPBR_LOBE_SUBSURFACE);
+let viewHalf = abs(dot(viewLocal, aa));
 
 
 
-var du = ad;
-var jK = bm;
+var thinWallHalf = aa;
+var dielectricViewHalf = viewHalf;
 if (!reflection & material.thinWalled) {
-du = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
-if (du.z < 0.0) { du = -du; }
-jK = abs(dot(viewLocal, du));
+thinWallHalf = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
+if (thinWallHalf.z < 0.0) { thinWallHalf = -thinWallHalf; }
+dielectricViewHalf = abs(dot(viewLocal, thinWallHalf));
 }
-let ne =
-(reflection & (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & rf) |
-(!reflection & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & kd);
-let rk = reflection & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & tn;
-var oA: array<vec3f, 2>;
-if (ne) {
-oA[0] = vec3f(cY(prepared, jK, reflection));
+let mP =
+(reflection & (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & qW) |
+(!reflection & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & jJ);
+let ra = reflection & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & tn;
+var oq: array<vec3f, 2>;
+if (mP) {
+oq[0] = vec3f(cK(prepared, dielectricViewHalf, reflection));
 }
-if (rk) {
-oA[1] = cw(bm, material.baseWeight * material.baseColor, material.specularColor);
+if (ra) {
+oq[1] = openpbr_metal_fresnel(viewHalf, material.baseWeight * material.baseColor, material.specularColor);
 }
 if (HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {
-let wavelengths = vec3f(620.0, 540.0, 450.0);
+let vV = vec3f(620.0, 540.0, 450.0);
 
-for (var lD = 0u; lD < (rtUniform.loopUnrollGuard >> 1u); lD++) {
-if (!select(ne, rk, lD == 1u)) { continue; }
-var yi = vec3f(0.0);
-let J = select(jK, bm, lD == 1u);
+for (var lf = 0u; lf < (rtUniform.loopUnrollGuard >> 1u); lf++) {
+if (!select(mP, ra, lf == 1u)) { continue; }
+var wY = vec3f(0.0);
+let J = select(dielectricViewHalf, viewHalf, lf == 1u);
 for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
 var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
-if (lD == 1u) {
-ior = cX(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
+if (lf == 1u) {
+ior = cJ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
 }
-yi[channel] = au(J,
-wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
+wY[channel] = ap(J,
+vV[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
 }
-oA[lD] = mix(oA[lD], yi,
-bS(material.thinFilmThickness, material.thinFilmWeight));
+oq[lf] = mix(oq[lf], wY,
+bJ(material.thinFilmThickness, material.thinFilmWeight));
 }
 }
-let ey = oA[0];
+let ef = oq[0];
 let diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
-* aw(
+* ar(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 abs(lightLocal.z)
@@ -1174,156 +1174,156 @@ ${hasCoatNormals ? /* wgsl */ `
 if (!independentCoat | ((lightLocal.z != 0.0) & (reflection == geometricReflection))) {
 ` : ''}
 if (reflection) {
-if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & uF) {
-response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bJ(
+if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & uJ) {
+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 & pP) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bJ(
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & material.thinWalled & pG) {
+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) & rf) {
-var cB = ey;
+if ((prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & qW) {
+var ck = ef;
 if (material.thinWalled) {
-cB = av(
-cB,
+ck = aq(
+ck,
 material.transmissionWeight
 );
 }
-let bG = material.specularColor * cB;
-response += prepared.weights[OPENPBR_LOBE_SPECULAR] * ao(
+let 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) & tn) {
-let bG = material.specularWeight * oA[1];
-response += prepared.weights[OPENPBR_LOBE_METAL] * ao(
+let fresnel = material.specularWeight * oq[1];
+response += prepared.weights[OPENPBR_LOBE_METAL] * aj(
 material,
 viewLocal,
 lightLocal,
-ad,
-bG,
-&aM
+aa,
+fresnel,
+&lobePdf
 );
 if (prepared.metalMsFactor > 0.0) {
-let 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);
+let 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 {
-let bG = ey;
-if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & kd) {
+let fresnel = ef;
+if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & jJ) {
 if (material.thinWalled) {
-let lI = vec3f(lightLocal.xy, -lightLocal.z);
-let gA = av(
-ey,
+let lm = vec3f(lightLocal.xy, -lightLocal.z);
+let gk = aq(
+ef,
 1.0
 );
-let tint = bN(
+let tint = bF(
 material,
 abs(viewLocal.z),
 prepared.refractionEtaTOverEtaI
 );
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* ao(
+* aj(
 material,
 viewLocal,
-lI,
-du,
-tint * (vec3f(1.0) - gA),
-&aM
+lm,
+thinWallHalf,
+tint * (vec3f(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) & pP) {
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & pG) {
 if (material.thinWalled) {
-let pb = vec3f(lightLocal.xy, -lightLocal.z);
+let oQ = vec3f(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;
 }
 }
 
 
 
 
-if ((prepared.dielectricMsProbability > 0.0) & kd) {
+if ((prepared.dielectricMsProbability > 0.0) & jJ) {
 let cosine = abs(lightLocal.z);
 if (cosine > 0.0) {
 let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);
-let ju = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
-let oZ = prepared.dielectricMsViewLoss * bb(ior, prepared.specularAlpha, cosine)
-/ max(bf(ior, prepared.specularAlpha), 1e-12);
-let cL = min(oZ * ju, 1.0 / cosine);
+let iZ = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
+let oP = prepared.dielectricMsViewLoss * aV(ior, prepared.specularAlpha, cosine)
+/ max(aY(ior, prepared.specularAlpha), 1e-12);
+let cv = min(oP * iZ, 1.0 / cosine);
 let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);
-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;
 }
 }
 
 ${hasCoatNormals ? /* wgsl */ `    } ` : ''}
 if (material.coatWeight > 0.0) {
-response *= cF(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
+response *= cm(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
 }
 ${hasCoatNormals ? /* wgsl */ `
 
@@ -1332,134 +1332,134 @@ if (independentCoat) { response *= abs(lightLocal.z); }
 
 ${hasAnisotropyDirections ? /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {
-var dT = viewLocal;
-var lh = lightLocal;
-var gL = ad;
-var kk = bm;
+var dG = viewLocal;
+var kQ = lightLocal;
+var coatHalf = aa;
+var coatViewHalf = viewHalf;
 if (prepared.directionFrames) {
-dT = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, independentCoat)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'};
-lh = openpbr_to_local(prepared.coatBasis, lightDirection);
-gL = normalize(lh + dT);
-if (gL.z < 0.0) { gL = -gL; }
-kk = abs(dot(dT, gL));
+dG = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, independentCoat)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'};
+kQ = openpbr_to_local(prepared.coatBasis, lightDirection);
+coatHalf = normalize(kQ + dG);
+if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }
+coatViewHalf = abs(dot(dG, coatHalf));
 }
 
-let lQ = vec3f(af(
-kk,
+let lB = vec3f(ae(
+coatViewHalf,
 1.0 / material.coatIor
 ));
-var dS = material;
-let jX = aN(material.coatRoughness, material.coatAnisotropy);
-dS.alphaX = jX.x;
-dS.alphaY = jX.y;
-if (uA) {
-response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * ao(
-dS,
-dT,
-lh,
-gL,
-lQ,
-&aM
+var dF = material;
+let jD = aL(material.coatRoughness, material.coatAnisotropy);
+dF.alphaX = jD.x;
+dF.alphaY = jD.y;
+if (uE) {
+response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * aj(
+dF,
+dG,
+kQ,
+coatHalf,
+lB,
+&lobePdf
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
 }
 }
 ` : /* wgsl */ `
 if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {
-let lQ = vec3f(af(
-bm,
+let lB = vec3f(ae(
+viewHalf,
 1.0 / material.coatIor
 ));
-var dS = material;
-let jX = aN(material.coatRoughness, material.coatAnisotropy);
-dS.alphaX = jX.x;
-dS.alphaY = jX.y;
-if (uA) {
-response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * ao(
-dS,
+var dF = material;
+let jD = aL(material.coatRoughness, material.coatAnisotropy);
+dF.alphaX = jD.x;
+dF.alphaY = jD.y;
+if (uE) {
+response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * aj(
+dF,
 viewLocal,
 lightLocal,
-ad,
-lQ,
-&aM
+aa,
+lB,
+&lobePdf
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;
 }
 }
 `}
 
 if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0)) {
-let rC = aU(
+let rt = aQ(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3f(0.0),
-vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rC)
+vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rt)
 );
-if (ws) {
-response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * kD(
+if (wP) {
+response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * kg(
 material,
 viewLocal,
 lightLocal,
-&aM
+&lobePdf
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aM;
+*pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * lobePdf;
 }
 }
 
 return response * ${hasCoatNormals ? 'select(abs(lightLocal.z), 1.0, independentCoat)' : 'abs(lightLocal.z)'};
 }
 
-fn bO(
-prepared: ag,
+fn openpbr_eval_prepared(
+prepared: OpenPbrPreparedBsdf,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-return nA(prepared, lightDirection, -1, pdf);
+return nh(prepared, lightDirection, -1, pdf);
 }
 
 
 
 
 
-fn sp(
+fn sj(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
-bM: vec3f,
+bD: vec3f,
 normal: vec3f,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = ds(
+let prepared = bV(
 tangent,
 material,
-bM,
+bD,
 normal
 );
-return bO(prepared, lightDirection, pdf);
+return openpbr_eval_prepared(prepared, lightDirection, pdf);
 }
 
 
 
 
 
-fn jq(
-prepared: ag, cq: vec3f,
+fn iW(
+prepared: OpenPbrPreparedBsdf, cc: vec3f,
 lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,
-aS: ptr<function, f32>, bu: ptr<function, bool>,
-cO: ptr<function, bool>, bn: ptr<function, u32>
+aO: ptr<function, f32>, bk: ptr<function, bool>,
+cC: ptr<function, bool>, bh: ptr<function, u32>
 ) -> bool {
 let material = prepared.material;
 let viewLocal = prepared.viewLocal;
-var cH = cq.x;
-let fL = cq.y;
-let bv = cq.z;
+var cp = cc.x;
+let fp = cc.y;
+let bl = cc.z;
 *isTransmissionEvent = false;
-*aS = 1.0;
-*bu = false;
-*cO = false;
-*bn = u32(OPENPBR_LOBE_DIFFUSE);
+*aO = 1.0;
+*bk = false;
+*cC = false;
+*bh = u32(OPENPBR_LOBE_DIFFUSE);
 *lightDirection = prepared.basis.normal;
 
 var cdf: array<f32, OPENPBR_LOBE_COUNT>;
@@ -1470,40 +1470,40 @@ return false;
 }
 
 var lightLocal: vec3f;
-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])
 )) {
-let qG = bv < cdf[OPENPBR_LOBE_FUZZ];
-*aS = select(
+let qy = bl < cdf[OPENPBR_LOBE_FUZZ];
+*aO = select(
 1.0,
 material.fuzzRoughness,
-qG
+qy
 );
-*cO = !qG;
-*bn = select(
+*cC = !qy;
+*bh = select(
 u32(OPENPBR_LOBE_DIFFUSE),
 u32(OPENPBR_LOBE_FUZZ),
-qG
+qy
 );
-lightLocal = aO(vec2f(cH, fL));
+lightLocal = aM(vec2f(cp, fp));
 }
 ${hasAnisotropyDirections ? /* wgsl */ `
-else if (bv < cdf[OPENPBR_LOBE_COAT]) {
-*aS = material.coatRoughness;
-*bu = true;
-*bn = u32(OPENPBR_LOBE_COAT);
-var dT = viewLocal;
-if (prepared.directionFrames) { dT = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, material.coatNormalEnabled)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'}; }
-var ad = aD(
-dT,
-
-aN(material.coatRoughness, material.coatAnisotropy),
-vec2f(cH, fL)
+else if (bl < cdf[OPENPBR_LOBE_COAT]) {
+*aO = material.coatRoughness;
+*bk = true;
+*bh = u32(OPENPBR_LOBE_COAT);
+var dG = viewLocal;
+if (prepared.directionFrames) { dG = ${hasCoatNormals ? 'select(openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal)), prepared.coatViewLocal, material.coatNormalEnabled)' : 'openpbr_to_local(prepared.coatBasis, openpbr_to_world(prepared.basis, viewLocal))'}; }
+var aa = aA(
+dG,
+
+aL(material.coatRoughness, material.coatAnisotropy),
+vec2f(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));
 ${hasCoatNormals ? /* wgsl */ `
 if (material.coatNormalEnabled) {
 
@@ -1514,87 +1514,87 @@ return (lightLocal.z > 0.0) & (dot(material.geometricNormal, *lightDirection) >
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
 ` : /* wgsl */ `
-else if (bv < cdf[OPENPBR_LOBE_COAT]) {
-*aS = material.coatRoughness;
-*bu = true;
-*bn = u32(OPENPBR_LOBE_COAT);
-var ad = aD(
+else if (bl < cdf[OPENPBR_LOBE_COAT]) {
+*aO = material.coatRoughness;
+*bk = true;
+*bh = u32(OPENPBR_LOBE_COAT);
+var aa = aA(
 viewLocal,
 
-aN(material.coatRoughness, material.coatAnisotropy),
-vec2f(cH, fL)
+aL(material.coatRoughness, material.coatAnisotropy),
+vec2f(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_SPECULAR]) {
-*aS = material.specularRoughness;
-*bu = true;
-*bn = select(
+else if (bl < cdf[OPENPBR_LOBE_SPECULAR]) {
+*aO = material.specularRoughness;
+*bk = true;
+*bh = select(
 u32(OPENPBR_LOBE_SPECULAR),
 u32(OPENPBR_LOBE_METAL),
-bv < cdf[OPENPBR_LOBE_METAL]
+bl < cdf[OPENPBR_LOBE_METAL]
 );
-let uP = bv < cdf[OPENPBR_LOBE_METAL];
-let sN = (bv - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (uP & (sN < prepared.metalMsProbability)) {
-let z = cH;
-let ex = sqrt(max(0.0, 1.0 - z * z));
-let azimuth = TWOPI * fL;
-lightLocal = vec3f(ex * cos(azimuth), ex * sin(azimuth), z);
+let uU = bl < cdf[OPENPBR_LOBE_METAL];
+let sK = (bl - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (uU & (sK < prepared.metalMsProbability)) {
+let z = cp;
+let dr = sqrt(max(0.0, 1.0 - z * z));
+let azimuth = TWOPI * fp;
+lightLocal = vec3f(dr * cos(azimuth), dr * sin(azimuth), z);
 }
 else {
-var ad = aD(
+var aa = aA(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cH, fL)
+vec2f(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]) {
-*aS = material.specularRoughness;
-*bu = true;
+else if (bl < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+*aO = material.specularRoughness;
+*bk = true;
 *isTransmissionEvent = true;
-*bn = u32(OPENPBR_LOBE_TRANSMISSION);
+*bh = u32(OPENPBR_LOBE_TRANSMISSION);
 
 
-let vS = (bv - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if ((prepared.dielectricMsProbability > 0.0) & (vS < prepared.dielectricMsProbability)) {
-let ju = prepared.dielectricMsReflectionRatio;
-let mJ = cH < ju;
+let wk = (bl - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if ((prepared.dielectricMsProbability > 0.0) & (wk < prepared.dielectricMsProbability)) {
+let iZ = prepared.dielectricMsReflectionRatio;
+let mv = cp < iZ;
 var z: f32;
-if (mJ) { z = min(cH / ju, 0.99999994); }
-else { z = -min((cH - ju) / (1.0 - ju), 0.99999994); }
-let ex = sqrt(max(0.0, 1.0 - z * z));
-let azimuth = TWOPI * fL;
-lightLocal = vec3f(ex * cos(azimuth), ex * sin(azimuth), z);
-*isTransmissionEvent = !mJ;
-*bn = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), mJ);
+if (mv) { z = min(cp / iZ, 0.99999994); }
+else { z = -min((cp - iZ) / (1.0 - iZ), 0.99999994); }
+let dr = sqrt(max(0.0, 1.0 - z * z));
+let azimuth = TWOPI * fp;
+lightLocal = vec3f(dr * cos(azimuth), dr * sin(azimuth), z);
+*isTransmissionEvent = !mv;
+*bh = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), mv);
 }
 else {
-var ad = aD(
+var aa = aA(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cH, fL)
+vec2f(cp, fp)
 );
-if (ad.z < 0.0) {
-ad = -ad;
+if (aa.z < 0.0) {
+aa = -aa;
 }
 if (material.thinWalled) {
-let iC = normalize(reflect(-viewLocal, ad));
-lightLocal = vec3f(iC.xy, -iC.z);
+let hX = normalize(reflect(-viewLocal, aa));
+lightLocal = vec3f(hX.xy, -hX.z);
 }
 else {
 lightLocal = refract(
 -viewLocal,
-ad,
+aa,
 prepared.material.relativeIor
 );
 if (dot(lightLocal, lightLocal) <= 1e-8) {
@@ -1606,20 +1606,20 @@ lightLocal = normalize(lightLocal);
 }
 }
 else {
-*aS = 1.0;
-*cO = true;
+*aO = 1.0;
+*cC = true;
 *isTransmissionEvent = true;
-*bn = u32(OPENPBR_LOBE_SUBSURFACE);
+*bh = u32(OPENPBR_LOBE_SUBSURFACE);
 if (material.thinWalled) {
-let qL = cH >= 0.5;
-if (qL) {
-cH = (cH - 0.5) * 2.0;
+let qD = cp >= 0.5;
+if (qD) {
+cp = (cp - 0.5) * 2.0;
 }
 else {
-cH *= 2.0;
+cp *= 2.0;
 }
-lightLocal = aO(vec2f(cH, fL));
-if (qL) {
+lightLocal = aM(vec2f(cp, fp));
+if (qD) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1627,7 +1627,7 @@ else {
 }
 }
 else {
-lightLocal = aO(vec2f(cH, fL));
+lightLocal = aM(vec2f(cp, fp));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1646,22 +1646,22 @@ if (material.coatNormalEnabled &
 return true;
 }
 
-fn eN(
-prepared: ag,
-cq: vec3f,
+fn dl(
+prepared: OpenPbrPreparedBsdf,
+cc: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
-aS: ptr<function, f32>,
-bu: ptr<function, bool>,
-cO: ptr<function, bool>,
-bn: ptr<function, u32>,
-lW: ptr<function, f32>,
-kq: ptr<function, vec3f>
+aO: ptr<function, f32>,
+bk: ptr<function, bool>,
+cC: ptr<function, bool>,
+bh: ptr<function, u32>,
+marginalPdf: ptr<function, f32>,
+jU: ptr<function, vec3f>
 ) -> vec3f {
 *pdf = 0.0;
-*lW = 0.0;
-*kq = vec3f(0.0);
+*marginalPdf = 0.0;
+*jU = vec3f(0.0);
 
 
 
@@ -1673,61 +1673,61 @@ if (!prepared.material.thinWalled &
 prepared.basis,
 -prepared.viewLocal
 );
-let oF = bh(prepared.material)
-* cF(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
+let ov = ba(prepared.material)
+* cm(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
 *pdf = 1.0;
-*lW = 1.0;
-*kq = oF;
+*marginalPdf = 1.0;
+*jU = ov;
 *isTransmissionEvent = true;
-*aS = 0.0;
-*bu = true;
-*cO = false;
-*bn = u32(OPENPBR_LOBE_TRANSMISSION);
-return oF;
-}
-if (!jq(prepared, cq, lightDirection,
-isTransmissionEvent, aS, bu,
-cO, bn)) { return vec3f(0.0); }
-let response = bO(prepared, *lightDirection, pdf);
-*lW = *pdf;
-*kq = response;
+*aO = 0.0;
+*bk = true;
+*cC = false;
+*bh = u32(OPENPBR_LOBE_TRANSMISSION);
+return ov;
+}
+if (!iW(prepared, cc, lightDirection,
+isTransmissionEvent, aO, bk,
+cC, bh)) { return vec3f(0.0); }
+let response = openpbr_eval_prepared(prepared, *lightDirection, pdf);
+*marginalPdf = *pdf;
+*jU = response;
 return response;
 }
 
-fn tZ(
+fn uc(
 tangent: vec3f,
 material: OpenPbrResolvedMaterial,
-cq: vec3f,
-bM: vec3f,
+cc: vec3f,
+bD: vec3f,
 normal: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
-aS: ptr<function, f32>,
-bu: ptr<function, bool>,
-cO: ptr<function, bool>,
-bn: ptr<function, u32>,
-lW: ptr<function, f32>
+aO: ptr<function, f32>,
+bk: ptr<function, bool>,
+cC: ptr<function, bool>,
+bh: ptr<function, u32>,
+marginalPdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = ds(
+let prepared = bV(
 tangent,
 material,
-bM,
+bD,
 normal
 );
-var kq = vec3f(0.0);
-return eN(
+var jU = vec3f(0.0);
+return dl(
 prepared,
-cq,
+cc,
 lightDirection,
 pdf,
 isTransmissionEvent,
-aS,
-bu,
-cO,
-bn,
-lW,
-&kq
+aO,
+bk,
+cC,
+bh,
+marginalPdf,
+&jU
 );
 }`;
 }