@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -15,6 +15,7 @@
  * rough-diffuse/specular coupling; fuzz still uses an analytic approximation.
  */
 import { OPENPBR_METAL_ENERGY_LUT_ROW, OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW, OPENPBR_DIELECTRIC_ENERGY_LUT_ROW, OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW, OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW } from '../../openPbrEnergyLut.js';
+const LOBE_INDICES = [0, 1, 2, 3, 4, 5, 6];
 export function createOpenPbrBsdfWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 const OPENPBR_LOBE_FUZZ: i32 = 0;
@@ -24,19 +25,22 @@ const OPENPBR_LOBE_SPECULAR: i32 = 3;
 const OPENPBR_LOBE_TRANSMISSION: i32 = 4;
 const OPENPBR_LOBE_DIFFUSE: i32 = 5;
 const OPENPBR_LOBE_SUBSURFACE: i32 = 6;
-const OPENPBR_LOBE_COUNT: i32 = 7;
+const OPENPBR_LOBE_COUNT: i32 = ${LOBE_INDICES.length};
 
-struct bj {
+
+
+
+struct bq {
 tangent: vec3f,
 bitangent: vec3f,
 normal: vec3f,
 };
 
 struct ag {
-material: J,
-basis: bj,
+material: OpenPbrResolvedMaterial,
+basis: bq,
 ${hasAnisotropyDirections ? /* wgsl */ `
-coatBasis: bj,
+coatBasis: bq,
 directionFrames: bool,
 ` : /* wgsl */ ``}
 ${hasCoatNormals ? /* wgsl */ `    coatViewLocal: vec3f,` : ''}
@@ -64,251 +68,251 @@ weights: array<f32, OPENPBR_LOBE_COUNT>,
 probabilities: array<f32, OPENPBR_LOBE_COUNT>,
 };
 
-fn aw(color: vec3f) -> f32 {
+fn aE(color: vec3f) -> f32 {
 return dot(color, vec3f(0.212671, 0.715160, 0.072169));
 }
 
-fn cV(bu: f32) -> f32 {
-let value = (bu - 1.0) / (bu + 1.0);
+fn dd(bE: f32) -> f32 {
+let value = (bE - 1.0) / (bE + 1.0);
 return value * value;
 }
 
-fn aY(
-bu: f32,
+fn bi(
+bE: f32,
 specularWeight: f32
 ) -> f32 {
-let sR = min(
-cV(bu) * specularWeight,
+let uh = min(
+dd(bE) * specularWeight,
 0.9999
 );
-let sT = sqrt(sR);
-let lh = (1.0 + sT) / (1.0 - sT);
-return select(lh, 1.0 / lh, bu < 1.0);
+let uj = sqrt(uh);
+let lR = (1.0 + uj) / (1.0 - uj);
+return select(lR, 1.0 / lR, bE < 1.0);
 }
 
-fn af(cc: f32, relativeIor: f32) -> f32 {
+fn af(ci: f32, relativeIor: f32) -> f32 {
 if (abs(relativeIor - 1.0) < 1e-6) {
 return 0.0;
 }
-return cu(cc, relativeIor);
+return cC(ci, relativeIor);
 }
 
-fn aC(ior: f32) -> f32 {
+fn aG(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(sl: i32, row: i32) -> f32 {
-return textureLoad(openPbrEnergyLut, vec2i(sl, row), 0).r;
+fn F(tB: i32, row: i32) -> f32 {
+return textureLoad(openPbrEnergyLut, vec2i(tB, row), 0).r;
 }
 
-fn ge(
-dJ: f32,
-bR: f32,
-hR: f32
+fn gt(
+dU: f32,
+bV: f32,
+im: f32
 ) -> f32 {
-let bA = clamp(dJ, 0.0, 31.0);
-let aH = clamp(bR, 0.0, 31.0);
-let bt = clamp(hR, 0.0, 31.0);
-let dQ = i32(floor(bA));
-let aN = i32(floor(aH));
-let cI = i32(floor(bt));
-let hE = min(dQ + 1, 31);
-let cp = min(aN + 1, 31);
-let eR = min(cI + 1, 31);
-let cq = bA - f32(dQ);
-let cz = aH - f32(aN);
-let kE = bt - f32(cI);
-
-let uA = F(cI, dQ * 32 + aN);
-let uB = F(eR, dQ * 32 + aN);
-let uC = F(cI, dQ * 32 + cp);
-let uD = F(eR, dQ * 32 + cp);
-let uE = F(cI, hE * 32 + aN);
-let uF = F(eR, hE * 32 + aN);
-let uG = F(cI, hE * 32 + cp);
-let uH = F(eR, hE * 32 + cp);
-let v00 = mix(uA, uE, cq);
-let v01 = mix(uB, uF, cq);
-let v10 = mix(uC, uG, cq);
-let v11 = mix(uD, uH, cq);
+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);
 return mix(
-mix(v00, v10, cz),
-mix(v01, v11, cz),
-kE
+mix(v00, v10, cI),
+mix(v01, v11, cI),
+lj
 );
 }
 
-fn gG(dJ: f32, bR: f32) -> f32 {
-let bA = clamp(dJ, 0.0, 31.0);
-let aH = clamp(bR, 0.0, 31.0);
-let dQ = i32(floor(bA));
-let aN = i32(floor(aH));
-let hE = min(dQ + 1, 31);
-let cp = min(aN + 1, 31);
-let cq = bA - f32(dQ);
-let cz = aH - f32(aN);
-let v00 = F(aN, 1024 + dQ);
-let v01 = F(cp, 1024 + dQ);
-let v10 = F(aN, 1024 + hE);
-let v11 = F(cp, 1024 + hE);
+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);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-cz
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
 );
 }
 
 
 
-fn ef(
-dJ: f32,
-bR: f32,
-hR: f32
+fn ev(
+dU: f32,
+bV: f32,
+im: f32
 ) -> f32 {
-let bA = clamp(dJ, 0.0, 31.0);
-let aH = clamp(bR, 0.0, 31.0);
-let bt = clamp(hR, 0.0, 31.0);
-let dQ = i32(floor(bA));
-let aN = i32(floor(aH));
-let cI = i32(floor(bt));
-let hE = min(dQ + 1, 31);
-let cp = min(aN + 1, 31);
-let eR = min(cI + 1, 31);
-let cq = bA - f32(dQ);
-let cz = aH - f32(aN);
-let kE = bt - f32(cI);
-
-let uA = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
-let uB = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + aN);
-let uC = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
-let uD = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dQ * 32 + cp);
-let uE = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
-let uF = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + aN);
-let uG = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
-let uH = F(eR, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hE * 32 + cp);
-let v00 = mix(uA, uE, cq);
-let v01 = mix(uB, uF, cq);
-let v10 = mix(uC, uG, cq);
-let v11 = mix(uD, uH, cq);
+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);
 return mix(
-mix(v00, v10, cz),
-mix(v01, v11, cz),
-kE
+mix(v00, v10, cI),
+mix(v01, v11, cI),
+lj
 );
 }
 
-fn ee(dJ: f32, bR: f32) -> f32 {
-let bA = clamp(dJ, 0.0, 31.0);
-let aH = clamp(bR, 0.0, 31.0);
-let dQ = i32(floor(bA));
-let aN = i32(floor(aH));
-let hE = min(dQ + 1, 31);
-let cp = min(aN + 1, 31);
-let cq = bA - f32(dQ);
-let cz = aH - f32(aN);
-let v00 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
-let v01 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dQ);
-let v10 = F(aN, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
-let v11 = F(cp, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hE);
+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);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-cz
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
 );
 }
 
-fn eG(dJ: f32, bR: f32) -> f32 {
-let bA = clamp(dJ, 0.0, 31.0);
-let aH = clamp(bR, 0.0, 31.0);
-let dQ = i32(floor(bA));
-let aN = i32(floor(aH));
-let hE = min(dQ + 1, 31);
-let cp = min(aN + 1, 31);
-let cq = bA - f32(dQ);
-let cz = aH - f32(aN);
-let v00 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
-let v01 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dQ);
-let v10 = F(aN, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
-let v11 = F(cp, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hE);
+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);
 return mix(
-mix(v00, v10, cq),
-mix(v01, v11, cq),
-cz
+mix(v00, v10, cv),
+mix(v01, v11, cv),
+cI
 );
 }
 
-fn bO(ior: f32, alpha: f32, au: f32) -> f32 {
-return ef(aC(ior), sqrt(alpha) * 31.0, au * 31.0);
+fn bb(ior: f32, alpha: f32, cosine: f32) -> f32 {
+return ev(aG(ior), sqrt(alpha) * 31.0, cosine * 31.0);
 }
-fn cO(ior: f32, alpha: f32) -> f32 {
-return ee(aC(ior), sqrt(alpha) * 31.0);
+fn bf(ior: f32, alpha: f32) -> f32 {
+return eu(aG(ior), sqrt(alpha) * 31.0);
 }
-fn ch(ior: f32, alpha: f32) -> f32 {
-return eG(aC(ior), sqrt(alpha) * 31.0);
+fn ck(ior: f32, alpha: f32) -> f32 {
+return eR(aG(ior), sqrt(alpha) * 31.0);
 }
 
 
 
-fn bH(alpha: f32, au: f32) -> f32 {
-let ie = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
-let bt = clamp(au * 31.0, 0.0, 31.0);
-let r0 = i32(floor(ie));
-let c0 = i32(floor(bt));
+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));
 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(bt)),
-mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bt)),
-fract(ie));
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(bD)),
+mix(F(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), F(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(bD)),
+fract(iF));
 }
 
-fn cv(alpha: f32) -> f32 {
+fn cD(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 aX(value: f32, ior: f32) -> f32 {
-if (ior > 2.5 || ior < 0.4) {
-let tU = cV(2.5);
-let progress = (cV(ior) - tU) / (1.0 - tU);
+fn bd(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);
 return (1.0 - progress) * value;
 }
 return value;
 }
 
-fn aJ(
+fn aw(
 ior: f32,
 alpha: f32,
-au: f32
+cosine: f32
 ) -> f32 {
-let value = ge(
-aC(ior),
+let value = gt(
+aG(ior),
 sqrt(alpha) * 31.0,
-au * 31.0
+cosine * 31.0
 );
-return aX(value, ior);
+return bd(value, ior);
 }
 
-fn cr(ior: f32, alpha: f32) -> f32 {
-let value = gG(
-aC(ior),
+fn cA(ior: f32, alpha: f32) -> f32 {
+let value = gS(
+aG(ior),
 sqrt(alpha) * 31.0
 );
-return aX(value, ior);
+return bd(value, ior);
 }
 
-fn openpbr_to_world(basis: bj, direction: vec3f) -> vec3f {
+fn openpbr_to_world(basis: bq, direction: vec3f) -> vec3f {
 return direction.x * basis.tangent
 + direction.y * basis.bitangent
 + direction.z * basis.normal;
 }
 
-fn openpbr_to_local(basis: bj, direction: vec3f) -> vec3f {
+fn openpbr_to_local(basis: bq, direction: vec3f) -> vec3f {
 return vec3f(
 dot(direction, basis.tangent),
 dot(direction, basis.bitangent),
@@ -316,17 +320,17 @@ dot(direction, basis.normal)
 );
 }
 
-fn fj(
-aT: vec3f,
+fn fD(
+aX: vec3f,
 normal: vec3f,
 anisotropy: f32
-) -> bj {
-var basis: bj;
+) -> bq {
+var basis: bq;
 basis.normal = normal;
-var tangent = aT;
+var tangent = aX;
 var bitangent = vec3f(0.0);
-if (dot(tangent, tangent) < 0.001 || anisotropy <= 0.0) {
-aL(normal, &tangent, &bitangent);
+if ((dot(tangent, tangent) < 0.001) | (anisotropy <= 0.0)) {
+aP(normal, &tangent, &bitangent);
 }
 else {
 bitangent = normalize(cross(normal, tangent));
@@ -337,198 +341,198 @@ basis.bitangent = bitangent;
 return basis;
 }
 
-fn ka(
-av: f32,
-ak: f32,
-L: f32,
-S: f32
+fn kF(
+aB: f32,
+am: f32,
+J: f32,
+ae: f32
 ) -> f32 {
-return (av * L - ak * S)
-/ (av * L + ak * S);
+return (aB * J - am * ae)
+/ (aB * J + am * ae);
 }
 
-fn jZ(
-av: f32,
-ak: f32,
-L: f32,
-S: f32
+fn kE(
+aB: f32,
+am: f32,
+J: f32,
+ae: f32
 ) -> f32 {
-return (ak * L - av * S)
-/ (av * S + ak * L);
+return (am * J - aB * ae)
+/ (aB * ae + am * J);
 }
 
-fn hd(
-av: f32,
-ak: f32,
-L: f32,
-S: f32
+fn ht(
+aB: f32,
+am: f32,
+J: f32,
+ae: f32
 ) -> f32 {
-return 2.0 * av * L
-/ (av * L + ak * S);
+return 2.0 * aB * J
+/ (aB * J + am * ae);
 }
 
-fn hc(
-av: f32,
-ak: f32,
-L: f32,
-S: f32
+fn hs(
+aB: f32,
+am: f32,
+J: f32,
+ae: f32
 ) -> f32 {
-return 2.0 * av * L
-/ (av * S + ak * L);
+return 2.0 * aB * J
+/ (aB * ae + am * J);
 }
 
-fn aU(a: vec2f, b: vec2f) -> vec2f {
+fn aY(a: vec2f, b: vec2f) -> vec2f {
 return vec2f(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
-fn aZ(a: vec2f, b: vec2f) -> vec2f {
-let ap = max(dot(b, b), 1e-9);
+fn bj(a: vec2f, b: vec2f) -> vec2f {
+let aq = max(dot(b, b), 1e-9);
 return vec2f(
-(a.x * b.x + a.y * b.y) / ap,
-(a.y * b.x - a.x * b.y) / ap
+(a.x * b.x + a.y * b.y) / aq,
+(a.y * b.x - a.x * b.y) / aq
 );
 }
 
-fn hX(value: vec2f) -> vec2f {
-let nJ = length(value);
-let sP = sqrt(max(0.0, 0.5 * (nJ + value.x)));
-let ff = sqrt(max(0.0, 0.5 * (nJ - value.x)));
-return vec2f(sP, select(-ff, ff, value.y >= 0.0));
+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 bX(
-L: f32,
-av: f32,
-ak: vec2f,
-qG: bool
+fn ce(
+J: f32,
+aB: f32,
+am: vec2f,
+rM: bool
 ) -> vec2f {
-let oq = sqrt(max(0.0, 1.0 - L * L));
-let sA = aZ(vec2f(av, 0.0), ak);
-let hA = sA * oq;
-var S = hX(
-vec2f(1.0, 0.0) - aU(hA, hA)
+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)
 );
-if (aU(ak, S).y < 0.0) {
-S = -S;
-}
-
-let fL = vec2f(av * L, 0.0);
-let eB = aU(ak, S);
-if (qG) {
-let ci = ak * L;
-let ce = S * av;
-return aZ(
-ci - ce,
-ci + ce
+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
 );
 }
-return aZ(
-fL - eB,
-fL + eB
+return bj(
+fZ - eJ,
+fZ + eJ
 );
 }
 
-fn eq(
-iH: f32,
-gN: f32,
-oG: f32,
-mM: f32,
-kf: vec2f,
+fn eE(
+iZ: f32,
+ha: f32,
+pw: f32,
+nL: f32,
+kL: vec2f,
 phase: f32
 ) -> f32 {
-let nq = vec2f(cos(phase), sin(phase));
-let ia = aU(kf, nq);
-let kO = ia * (gN * mM);
-let ap = vec2f(1.0, 0.0) - ia * oG;
-let hz = vec2f(iH, 0.0)
-+ aZ(kO, ap);
-return dot(hz, hz);
+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);
 }
 
-fn ar(
-L: f32,
+fn au(
+J: f32,
 wavelength: f32,
+ct: f32,
+aR: f32,
 cn: f32,
-aM: f32,
-ck: f32,
-eu: vec2f
+eG: vec2f
 ) -> f32 {
-let dm = clamp(abs(L), 1e-5, 1.0);
-let hu = pow(aM / ck, 2.0)
-* (1.0 - dm * dm);
-if (hu >= 1.0) {
+let dF = clamp(abs(J), 1e-5, 1.0);
+let hI = pow(aR / cn, 2.0)
+* (1.0 - dF * dF);
+if (hI >= 1.0) {
 return 1.0;
 }
-let cU = sqrt(1.0 - hu);
-let lb = ka(
-aM, ck, dm, cU
+let dc = sqrt(1.0 - hI);
+let lL = kF(
+aR, cn, dF, dc
 );
-let la = jZ(
-aM, ck, dm, cU
+let lK = kE(
+aR, cn, dF, dc
 );
-let jj = hd(
-aM, ck, dm, cU
+let jG = ht(
+aR, cn, dF, dc
 );
-let ji = hc(
-aM, ck, dm, cU
+let jF = hs(
+aR, cn, dF, dc
 );
-let gr = ck * cU
-/ max(aM * dm, 1e-9);
-let phase = 2.0 * PI * (2.0 * ck * cn * cU) / wavelength;
-var sb = 0.0;
+let gG = cn * dc
+/ max(aR * dF, 1e-9);
+let phase = 2.0 * PI * (2.0 * cn * ct * dc) / wavelength;
+var reflectance = 0.0;
 
-for (var ke = 0u; ke < (rtUniform.loopUnrollGuard >> 1u); ke++) {
-let iH = select(lb, la, ke == 1u);
-let gN = select(jj, ji, ke == 1u);
-let kf = bX(
-cU, ck, eu, ke == 1u);
-sb += eq(iH, gN,
--iH, gN * gr, kf, phase);
+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);
 }
-return clamp(0.5 * sb, 0.0, 1.0);
+return clamp(0.5 * reflectance, 0.0, 1.0);
 }
 
 
 
 
-fn dU(au: f32, f0: vec3f, tint: vec3f) -> vec3f {
-let rk = mix(f0, vec3f(1.0), aE(au));
-if (all(tint == vec3f(1.0))) { return rk; }
-let dk = 1.0 / 7.0;
-let mk = 1.0 - dk;
-let fJ = mix(f0, vec3f(1.0), aE(dk));
-let di = 1.0 - au;
-let qt = au * aE(au) * di
-/ (dk * pow(mk, 6.0));
-return clamp(rk - qt * (fJ - tint * fJ), vec3f(0.0), vec3f(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 cQ(f0: f32, tp: f32) -> vec2f {
-let dN = clamp(f0, 0.0, 0.99);
-let gM = sqrt(dN);
-let qF = (1.0 - dN) / (1.0 + dN);
-let qD = (1.0 + gM) / max(1.0 - gM, 1e-9);
-let ior = mix(qD, qF, clamp(tp, 0.0, 1.0));
-let jO = (
-(ior + 1.0) * (ior + 1.0) * dN
+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
 - (ior - 1.0) * (ior - 1.0)
-) / max(1.0 - dN, 1e-9);
-return vec2f(ior, sqrt(max(jO, 0.0)));
+) / max(1.0 - dY, 1e-9);
+return vec2f(ior, sqrt(max(kp, 0.0)));
 }
 
 
-fn bN(cn: f32, weight: f32) -> f32 {
-return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cn);
+fn bS(ct: f32, weight: f32) -> f32 {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, ct);
 }
 
 
 
-fn cE(
-material: J,
+fn bJ(
+material: OpenPbrResolvedMaterial,
 color: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-fu: f32,
+fJ: f32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -537,52 +541,52 @@ return vec3f(0.0);
 }
 
 let roughness = material.diffuseRoughness;
-let gX = 0.5 - 2.0 / (3.0 * PI);
-let oi = 2.0 / 3.0 - 28.0 / (15.0 * PI);
-let oA = lightLocal.z;
-let mA = viewLocal.z;
-let hP = dot(lightLocal, viewLocal) - oA * mA;
-let gU = select(
-hP,
-hP / max(max(oA, mA), 1e-7),
-hP > 0.0
+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(
+directional,
+directional / max(max(pp, nt), 1e-7),
+directional > 0.0
 );
-let il = 1.0 / (1.0 + gX * roughness);
-let nv = color * INVPI * il
-* (1.0 + roughness * gU);
-
-let dd = 1.0 - oA;
-let cP = 1.0 - mA;
-let os = dd * (
-0.0571085289 + dd * (
-0.491881867 + dd * (
--0.332181442 + dd * 0.0714429953
+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 np = cP * (
-0.0571085289 + cP * (
-0.491881867 + cP * (
--0.332181442 + cP * 0.0714429953
+let outputGOverPi = outputComplement * (
+0.0571085289 + outputComplement * (
+0.491881867 + outputComplement * (
+-0.332181442 + outputComplement * 0.0714429953
 )
 )
 );
-let pv = (1.0 + roughness * os)
-/ (1.0 + gX * roughness);
-let oC = (1.0 + roughness * np)
-/ (1.0 + gX * roughness);
-let fV = il * (1.0 + oi * roughness);
-let hF = color * color * fV
-/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fV));
-let lE = hF * INVPI
-* max(1e-7, 1.0 - oC)
-* max(1e-7, 1.0 - pv)
-/ max(1e-7, 1.0 - fV);
+let qr = (1.0 + roughness * ph)
+/ (1.0 + hl * 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
+* max(1e-7, 1.0 - outputAlbedo)
+* max(1e-7, 1.0 - qr)
+/ max(1e-7, 1.0 - gi);
 *pdf = lightLocal.z * INVPI;
-return (nv + lE) * fu;
+return (ot + mn) * fJ;
 }
 
-fn aO(viewCosine: f32, roughness: f32) -> f32 {
+fn aU(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)
@@ -596,17 +600,17 @@ let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
 return max(gaussian + offset, 0.0);
 }
 
-fn jY(
-material: J,
+fn kD(
+material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
-if (viewLocal.z <= 0.0 || lightLocal.z <= 0.0) {
+if ((viewLocal.z <= 0.0) | (lightLocal.z <= 0.0)) {
 return vec3f(0.0);
 }
-let albedo = aO(
+let albedo = aU(
 viewLocal.z,
 material.fuzzRoughness
 );
@@ -614,12 +618,12 @@ material.fuzzRoughness
 return material.fuzzColor * albedo * INVPI;
 }
 
-fn am(
-material: J,
+fn ao(
+material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
-V: vec3f,
-cK: vec3f,
+ad: vec3f,
+bG: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -628,24 +632,24 @@ return vec3f(0.0);
 }
 
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = gL(V, alpha);
-let jV = bk(viewLocal, alpha);
-let ea = jV
-* bk(lightLocal, alpha);
+let distribution = cW(ad, alpha);
+let kz = aF(viewLocal, alpha);
+let ep = kz
+* aF(lightLocal, alpha);
 
-*pdf = jV * distribution / (4.0 * max(viewLocal.z, 1e-8));
-return cK * distribution * ea
+*pdf = kz * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return bG * distribution * ep
 / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
 }
 
-fn dl(
-material: J,
+fn dE(
+material: OpenPbrResolvedMaterial,
 relativeIor: f32,
 tint: vec3f,
 viewLocal: vec3f,
 lightLocal: vec3f,
-V: vec3f,
-cK: vec3f,
+ad: vec3f,
+bG: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
@@ -653,179 +657,179 @@ if (lightLocal.z >= 0.0) {
 return vec3f(0.0);
 }
 
-let kL = dot(lightLocal, V);
-let bQ = dot(viewLocal, V);
+let ls = dot(lightLocal, ad);
+let bm = dot(viewLocal, ad);
 
 
-if (bQ <= 0.0 || kL >= 0.0) {
+if ((bm <= 0.0) | (ls >= 0.0)) {
 return vec3f(0.0);
 }
 let alpha = vec2f(material.alphaX, material.alphaY);
-let distribution = gL(V, alpha);
-let jV = bk(viewLocal, alpha);
-let ea = jV
-* bk(lightLocal, alpha);
-var ap = kL + bQ * relativeIor;
-ap *= ap;
-let pJ = abs(kL) / max(ap, 1e-8);
-let ju = relativeIor * relativeIor;
-
-*pdf = jV * max(0.0, bQ) * distribution * pJ
+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
 / max(viewLocal.z, 1e-8);
-return tint * (vec3f(1.0) - cK) * distribution * ea
-* abs(bQ) * pJ * ju
+return tint * (vec3f(1.0) - bG) * distribution * ep
+* abs(bm) * qw * jU
 / max(abs(lightLocal.z * viewLocal.z), 1e-8);
 }
 
-fn bn(material: J) -> vec3f {
-if (HAS_MEDIUM && material.mediumType > 0) {
+fn bh(material: OpenPbrResolvedMaterial) -> vec3f {
+if (HAS_MEDIUM & (material.mediumType > 0)) {
 return vec3f(1.0);
 }
 return material.transmissionColor;
 }
 
-fn cS(ah: f32) -> f32 {
-return 2.0 * ah / (1.0 + ah);
+fn cZ(ai: f32) -> f32 {
+return 2.0 * ai / (1.0 + ai);
 }
 
-fn aP(
-ah: vec3f,
+fn av(
+ai: vec3f,
 transmissionWeight: f32
 ) -> vec3f {
-let gm = 2.0 * ah
-/ (vec3f(1.0) + ah);
+let gA = 2.0 * ai
+/ (vec3f(1.0) + ai);
 return mix(
-ah,
-gm,
+ai,
+gA,
 clamp(transmissionWeight, 0.0, 1.0)
 );
 }
 
-fn bG(
-material: J,
-L: f32,
-bu: f32
+fn bN(
+material: OpenPbrResolvedMaterial,
+J: f32,
+bE: f32
 ) -> vec3f {
-let tint = bn(material);
+let tint = bh(material);
 if (!material.thinWalled) {
 return tint;
 }
-let iL = max(0.0, 1.0 - L * L);
-let dO = iL
-/ max(bu * bu, 1e-9);
-if (dO >= 1.0) {
+let jc = max(0.0, 1.0 - J * J);
+let ea = jc
+/ max(bE * bE, 1e-9);
+if (ea >= 1.0) {
 return vec3f(0.0);
 }
-let S = sqrt(1.0 - dO);
-return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(S, 1e-5)));
+let ae = sqrt(1.0 - ea);
+return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(ae, 1e-5)));
 }
 
-fn dM(
-material: J,
+fn dX(
+material: OpenPbrResolvedMaterial,
 viewLocal: vec3f,
 lightLocal: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
 *pdf = 0.0;
-if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
+if ((viewLocal.z <= 0.0) | (lightLocal.z >= 0.0)) {
 return vec3f(0.0);
 }
-let S = -lightLocal.z;
-let oe = cu(
+let ae = -lightLocal.z;
+let oY = cC(
 viewLocal.z,
 material.relativeIor
 );
-*pdf = S * INVPI;
-return vec3f(1.0 - oe) * INVPI;
+*pdf = ae * INVPI;
+return vec3f(1.0 - oY) * INVPI;
 }
 
-fn dR(prepared: ptr<function, ag>) {
+fn eg(prepared: ptr<function, ag>) {
 
 
-let nI = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+let sM = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
 var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];
-for (var hU = 1; hU < nI; hU++) {
-total += (*prepared).probabilities[hU];
+for (var jT = 1; jT < sM; jT++) {
+total += (*prepared).probabilities[jT];
 }
 if (total <= 1e-8) {
-for (var hU = 0; hU < nI; hU++) {
-(*prepared).probabilities[hU] = 0.0;
+for (var jT = 0; jT < sM; jT++) {
+(*prepared).probabilities[jT] = 0.0;
 }
 return;
 }
-let ov = 1.0 / total;
-for (var hU = 0; hU < nI; hU++) {
-(*prepared).probabilities[hU] *= ov;
+let pk = 1.0 / total;
+for (var jT = 0; jT < sM; jT++) {
+(*prepared).probabilities[jT] *= pk;
 }
 }
 
 
 
-fn bM(eta: f32) -> f32 {
+fn bR(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 bP(f0: vec3f, tint: vec3f) -> vec3f {
-let dk = 1.0 / 7.0;
-let fJ = mix(f0, vec3f(1.0), aE(dk));
-let b = fJ * (vec3f(1.0) - tint) / (dk * pow(1.0 - dk, 6.0));
+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));
 return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
 }
 
 
 
-fn cD(material: J, au: f32) -> vec3f {
-if (au <= 0.0) { return vec3f(1.0); }
-let lG = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
-let tD = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lG, 1e-5)));
-return mix(vec3f(1.0), tD, material.coatWeight);
+fn cN(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);
 }
 
-fn gq(material: J, au: f32) -> f32 {
+fn gF(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {
 if (material.coatRoughness <= ROUGHNESS_MIN) {
-return af(au, 1.0 / material.coatIor);
+return af(cosine, 1.0 / material.coatIor);
 }
 
 
-return clamp(1.0 - aJ(material.coatIor,
-material.coatRoughness * material.coatRoughness, au), 0.0, 1.0);
+return clamp(1.0 - aw(material.coatIor,
+material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);
 }
 
-fn hb(prepared: ag) -> vec3f {
+fn hr(prepared: ag) -> 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 ug = dielectric * material.transmissionWeight;
-let fP = bM(prepared.specularEtaTOverEtaI);
-let kU = bM(1.0 / prepared.transmissionReflectionIor);
-let pR = clamp(opaque * fP + (sss + ug) * kU + material.baseMetalness, 0.0, 1.0);
-let jp = mix(1.0, material.specularRoughness, pR);
-let ks = bM(material.coatIor);
+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 kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
-let k = mix(ks, kr, jp);
-let eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
-+ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fP)
-+ sss * material.subsurfaceColor + vec3f(ug);
-let qU = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
-return mix(vec3f(1.0), qU, material.coatWeight * material.coatDarkening);
+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);
 }
 
-fn ds(prepared: ag, lm: f32) -> vec3f {
+fn cF(prepared: ag, lU: f32) -> vec3f {
 if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }
 if (prepared.material.inside) {
 
-return cD(prepared.material, -lm);
+return cN(prepared.material, -lU);
 }
 
-return prepared.coatBaseScale * cD(prepared.material, lm);
+return prepared.coatBaseScale * cN(prepared.material, lU);
 }
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn du(fallback: bj, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> bj {
+fn dM(fallback: bq, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> bq {
 var t = tangent - fallback.normal * dot(fallback.normal, tangent);
 if (dot(t, t) < 1e-8) { t = fallback.tangent; }
 t = normalize(t);
@@ -840,15 +844,15 @@ return basis;
 }
 
 ` : /* wgsl */ ``}
-fn eH(
+fn ds(
 tangent: vec3f,
-material: J,
-bF: vec3f,
+material: OpenPbrResolvedMaterial,
+bM: vec3f,
 normal: vec3f
 ) -> ag {
 var prepared: ag;
 prepared.material = material;
-prepared.basis = fj(
+prepared.basis = fD(
 tangent,
 normal,
 max(material.specularAnisotropy, material.coatAnisotropy)
@@ -860,39 +864,39 @@ ${hasCoatNormals ? /* wgsl */ `
 
 
 if (material.coatNormalEnabled) {
-prepared.coatBasis = fj(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
+prepared.coatBasis = fD(material.geometryTangent, material.coatNormal, material.coatAnisotropy);
 prepared.directionFrames = true;
 }
 ` : ''}
-if (material.specularAnisotropy > 0.0 && material.anisotropyDirectionEnabled) {
-prepared.basis = du(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
+if ((material.specularAnisotropy > 0.0) & material.anisotropyDirectionEnabled) {
+prepared.basis = dM(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);
 prepared.directionFrames = true;
 }
-if (material.coatAnisotropy > 0.0 && material.coatAnisotropyRotation != 0.0) {
-prepared.coatBasis = du(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));
+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.directionFrames = true;
 }
 ` : /* wgsl */ ``}
-prepared.viewLocal = openpbr_to_local(prepared.basis, bF);
-${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bF);` : ''}
+prepared.viewLocal = openpbr_to_local(prepared.basis, bM);
+${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bM);` : ''}
 prepared.diffuseColor = material.baseColor;
 
-let cB = 1.0 - material.baseMetalness;
-let dL = cB
+let cK = 1.0 - material.baseMetalness;
+let dW = cK
 * (1.0 - material.transmissionWeight);
 prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;
 prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;
 if (material.inside) { prepared.weights[OPENPBR_LOBE_COAT] = 0.0; }
 prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;
-prepared.weights[OPENPBR_LOBE_SPECULAR] = cB;
-prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cB
+prepared.weights[OPENPBR_LOBE_SPECULAR] = cK;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cK
 * material.transmissionWeight;
-prepared.weights[OPENPBR_LOBE_DIFFUSE] = dL
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dW
 * (1.0 - material.subsurfaceWeight) * material.baseWeight;
-prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dL
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dW
 * material.subsurfaceWeight;
 
-prepared.specularEtaTOverEtaI = aY(
+prepared.specularEtaTOverEtaI = bi(
 1.0 / material.relativeIor,
 material.specularWeight
 );
@@ -902,20 +906,20 @@ prepared.transmissionReflectionIor = prepared.material.relativeIor;
 
 
 if (material.coatWeight > 0.0) {
-var cj = 1.0;
-if (!material.inside) { cj = mix(1.0, material.coatIor, material.coatWeight); }
-let bq = cj * aY(
-material.specularIor / cj, material.specularWeight);
-var er = bq / cj;
-if (cj > bq && bq >= 1.0) {
-er = 1.0 / er;
-}
-prepared.specularEtaTOverEtaI = er;
-prepared.transmissionReflectionIor = 1.0 / er;
-prepared.refractionEtaTOverEtaI = bq;
+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;
 if (material.inside) {
-prepared.refractionEtaTOverEtaI = 1.0 / bq;
-prepared.transmissionReflectionIor = bq;
+prepared.refractionEtaTOverEtaI = 1.0 / bB;
+prepared.transmissionReflectionIor = bB;
 }
 prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
 }
@@ -937,82 +941,82 @@ prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;
 prepared.specularAlpha = material.specularRoughness
 * material.specularRoughness;
 let viewCosine = abs(prepared.viewLocal.z);
-let ah = af(
+let ai = af(
 viewCosine,
 1.0 / prepared.specularEtaTOverEtaI
 );
-let fA = material.specularColor * select(
-ah,
+let fN = material.specularColor * select(
+ai,
 mix(
-ah,
-cS(ah),
+ai,
+cZ(ai),
 material.transmissionWeight
 ),
 material.thinWalled
 );
-let hV = material.specularWeight * dU(
+let iv = material.specularWeight * cw(
 viewCosine,
 material.baseWeight * material.baseColor,
 material.specularColor
 );
-let eO = select(
+let eZ = select(
 af(viewCosine, prepared.transmissionReflectionIor),
-cS(af(viewCosine, prepared.transmissionReflectionIor)),
+cZ(af(viewCosine, prepared.transmissionReflectionIor)),
 material.thinWalled
 );
-let gO = bG(
+let hb = bN(
 material,
 viewCosine,
 prepared.refractionEtaTOverEtaI
 );
-let iu = aJ(
+let iM = aw(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 viewCosine
 );
-let gs = cr(
+let gH = cA(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha
 );
-prepared.diffuseSpecularEnergyCompensation = iu
-/ max(gs, 1e-12);
+prepared.diffuseSpecularEnergyCompensation = iM
+/ max(gH, 1e-12);
 
 prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
-* aw(material.fuzzColor)
-* max(aO(
+* aE(material.fuzzColor)
+* max(aU(
 viewCosine,
 material.fuzzRoughness
 ), 0.02);
 prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;
 prepared.coatBaseScale = vec3f(1.0);
-if (material.coatWeight > 0.0 && !material.inside) {
+if ((material.coatWeight > 0.0) & !material.inside) {
 ${hasCoatNormals ? /* wgsl */ `let coatViewCosine = select(viewCosine, max(prepared.coatViewLocal.z, 0.0), material.coatNormalEnabled);` : ''}
-let kB = gq(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
-prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kB;
-prepared.coatBaseScale = cD(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
-* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kB) * hb(prepared);
+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);
 }
 prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
-* aw(hV);
+* aE(iv);
 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 hL = bP(material.baseWeight * material.baseColor, material.specularColor);
-prepared.metalMsScale = material.specularWeight * hL * hL;
-let pV = bH(prepared.specularAlpha, viewCosine);
-prepared.metalMsFactor = pV / max(cv(prepared.specularAlpha), 1e-12);
-let fi = prepared.weights[OPENPBR_LOBE_METAL] * aw(prepared.metalMsScale) * pV;
-prepared.probabilities[OPENPBR_LOBE_METAL] += fi;
-prepared.metalMsProbability = fi / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+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);
 }
 prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
-* aw(fA);
+* aE(fN);
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* (1.0 - eO)
-* aw(gO);
+* (1.0 - eZ)
+* aE(hb);
 
 
 
@@ -1024,62 +1028,62 @@ prepared.dielectricMsTransmissionScale = vec3f(0.0);
 prepared.dielectricMsViewLoss = 0.0;
 prepared.dielectricMsReflectionRatio = 0.0;
 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 lF = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
-prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lF;
-prepared.dielectricMsTransmissionScale = gO * prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+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]
 + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);
-prepared.dielectricMsReflectionRatio = ch(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
-prepared.dielectricMsViewLoss = bO(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
-let nV = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
-let fi = aw(nV) * prepared.dielectricMsViewLoss;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += fi;
-prepared.dielectricMsProbability = fi / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+prepared.dielectricMsReflectionRatio = ck(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);
+prepared.dielectricMsViewLoss = bb(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);
+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.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
-* aw(prepared.diffuseColor)
+* aE(prepared.diffuseColor)
 * prepared.diffuseSpecularEnergyCompensation;
 prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* (1.0 - eO)
-* aw(material.subsurfaceColor)
+* (1.0 - eZ)
+* aE(material.subsurfaceColor)
 * prepared.diffuseSpecularEnergyCompensation;
 
 
-if (material.coatWeight > 0.0 && HAS_THIN_FILM && material.thinFilmWeight > 0.0) {
-let lj = 0.02 * bN(material.thinFilmThickness, material.thinFilmWeight);
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * lj);
-prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * lj);
+if ((material.coatWeight > 0.0) & 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);
 }
-if (material.coatWeight > 0.0 && !material.inside) {
-let gt = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
-prepared.probabilities[OPENPBR_LOBE_METAL] *= gt;
-prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gt;
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gt;
-prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gt;
-prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gt;
+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;
 }
-dR(&prepared);
+eg(&prepared);
 return prepared;
 }
 
 
-fn cR(prepared: ag, au: f32, reflection: bool) -> f32 {
+fn cY(prepared: ag, cosine: f32, reflection: bool) -> f32 {
 if (prepared.material.coatWeight <= 0.0) {
-return af(au, prepared.material.relativeIor);
+return af(cosine, prepared.material.relativeIor);
 }
-let kp = af(au, prepared.transmissionReflectionIor);
-if (!reflection) { return kp; }
-let nk = af(au, 1.0 / prepared.specularEtaTOverEtaI);
-let rP = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
-return mix(nk, kp, rP);
+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);
 }
 
-fn mD(
+fn nA(
 prepared: ag,
 lightDirection: vec3f,
-gP: i32,
+hc: i32,
 pdf: ptr<function, f32>
 ) -> vec3f {
 let material = prepared.material;
@@ -1090,78 +1094,76 @@ ${hasCoatNormals ? /* wgsl */ `
 let independentCoat = material.coatNormalEnabled;
 let geometricReflection = dot(material.geometricNormal, lightDirection) > 0.0;
 let coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);
-let coatReflection = geometricReflection && prepared.coatViewLocal.z > 0.0 && coatLightCosine > 0.0;
+let coatReflection = geometricReflection & (prepared.coatViewLocal.z > 0.0) & (coatLightCosine > 0.0);
 ` : ''}
 
-var V: vec3f;
+var ad: vec3f;
 if (reflection) {
-V = normalize(lightLocal + viewLocal);
+ad = normalize(lightLocal + viewLocal);
 }
 else {
-V = normalize(lightLocal + viewLocal * material.relativeIor);
+ad = normalize(lightLocal + viewLocal * material.relativeIor);
 }
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
 
 var response = vec3f(0.0);
 *pdf = 0.0;
-var aI = 0.0;
-let me = gP < 0;
-let uN = me || gP == OPENPBR_LOBE_FUZZ;
-let tc = me || gP == OPENPBR_LOBE_COAT;
-let sg = me || gP == OPENPBR_LOBE_METAL;
-let qf = me || gP == OPENPBR_LOBE_SPECULAR;
-let jG = me ||
-gP == OPENPBR_LOBE_TRANSMISSION;
-let th = me || gP == OPENPBR_LOBE_DIFFUSE;
-let oT = me ||
-gP == OPENPBR_LOBE_SUBSURFACE;
-let bQ = abs(dot(viewLocal, V));
-
-
-
-var df = V;
-var jn = bQ;
-if (!reflection && material.thinWalled) {
-df = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
-if (df.z < 0.0) { df = -df; }
-jn = abs(dot(viewLocal, df));
-}
-let mo =
-(reflection && prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && qf) ||
-(!reflection && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jG);
-let qj = reflection && prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && sg;
-var nD: array<vec3f, 2>;
-if (mo) {
-nD[0] = vec3f(cR(prepared, jn, reflection));
-}
-if (qj) {
-nD[1] = dU(bQ, material.baseWeight * material.baseColor, material.specularColor);
-}
-if (HAS_THIN_FILM && material.thinFilmWeight > 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 du = ad;
+var jK = bm;
+if (!reflection & material.thinWalled) {
+du = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
+if (du.z < 0.0) { du = -du; }
+jK = abs(dot(viewLocal, du));
+}
+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));
+}
+if (rk) {
+oA[1] = cw(bm, material.baseWeight * material.baseColor, material.specularColor);
+}
+if (HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {
 let wavelengths = vec3f(620.0, 540.0, 450.0);
 
-for (var kT = 0u; kT < (rtUniform.loopUnrollGuard >> 1u); kT++) {
-if (!select(mo, qj, kT == 1u)) { continue; }
-var wp = vec3f(0.0);
-let L = select(jn, bQ, kT == 1u);
+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 channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
 var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
-if (kT == 1u) {
-ior = cQ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
+if (lD == 1u) {
+ior = cX(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
 }
-wp[channel] = ar(L,
+yi[channel] = au(J,
 wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
 }
-nD[kT] = mix(nD[kT], wp,
-bN(material.thinFilmThickness, material.thinFilmWeight));
+oA[lD] = mix(oA[lD], yi,
+bS(material.thinFilmThickness, material.thinFilmWeight));
 }
 }
-let ei = nD[0];
+let ey = oA[0];
 let diffuseSpecularEnergyCompensation =
 prepared.diffuseSpecularEnergyCompensation
-* aJ(
+* aw(
 prepared.specularEtaTOverEtaI,
 prepared.specularAlpha,
 abs(lightLocal.z)
@@ -1169,160 +1171,159 @@ abs(lightLocal.z)
 
 ${hasCoatNormals ? /* wgsl */ `
 
-if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflection)) {
+if (!independentCoat | ((lightLocal.z != 0.0) & (reflection == geometricReflection))) {
 ` : ''}
 if (reflection) {
-if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0 && th) {
-response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cE(
+if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & uF) {
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * bJ(
 material,
 prepared.diffuseColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-&aI
+&aM
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aM;
 }
 
-if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled &&
-oT) {
-response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cE(
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & material.thinWalled & pP) {
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * bJ(
 material,
 material.subsurfaceColor,
 viewLocal,
 lightLocal,
 diffuseSpecularEnergyCompensation,
-&aI
+&aM
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aM;
 }
 
-if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && qf) {
-var ct = ei;
+if ((prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & rf) {
+var cB = ey;
 if (material.thinWalled) {
-ct = aP(
-ct,
+cB = av(
+cB,
 material.transmissionWeight
 );
 }
-let cK = material.specularColor * ct;
-response += prepared.weights[OPENPBR_LOBE_SPECULAR] * am(
+let bG = material.specularColor * cB;
+response += prepared.weights[OPENPBR_LOBE_SPECULAR] * ao(
 material,
 viewLocal,
 lightLocal,
-V,
-cK,
-&aI
+ad,
+bG,
+&aM
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aM;
 }
 
-if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && sg) {
-let cK = material.specularWeight * nD[1];
-response += prepared.weights[OPENPBR_LOBE_METAL] * am(
+if ((prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & tn) {
+let bG = material.specularWeight * oA[1];
+response += prepared.weights[OPENPBR_LOBE_METAL] * ao(
 material,
 viewLocal,
 lightLocal,
-V,
-cK,
-&aI
+ad,
+bG,
+&aM
 );
 if (prepared.metalMsFactor > 0.0) {
-let dW = min(prepared.metalMsFactor * bH(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));
-response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * dW * INVPI;
-aI = mix(aI, 0.5 * INVPI, prepared.metalMsProbability);
+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);
 }
-*pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aM;
 }
 }
 else {
-let cK = ei;
-if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jG) {
+let bG = ey;
+if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & kd) {
 if (material.thinWalled) {
-let kY = vec3f(lightLocal.xy, -lightLocal.z);
-let gm = aP(
-ei,
+let lI = vec3f(lightLocal.xy, -lightLocal.z);
+let gA = av(
+ey,
 1.0
 );
-let tint = bG(
+let tint = bN(
 material,
 abs(viewLocal.z),
 prepared.refractionEtaTOverEtaI
 );
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* am(
+* ao(
 material,
 viewLocal,
-kY,
-df,
-tint * (vec3f(1.0) - gm),
-&aI
+lI,
+du,
+tint * (vec3f(1.0) - gA),
+&aM
 );
 }
 else {
 response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
-* dl(
+* dE(
 material,
 material.relativeIor,
-bn(material),
+bh(material),
 viewLocal,
 lightLocal,
-V,
-cK,
-&aI
+ad,
+bG,
+&aM
 );
 }
 if (prepared.dielectricMsProbability > 0.0) {
-aI *= 1.0 - prepared.dielectricMsProbability;
+aM *= 1.0 - prepared.dielectricMsProbability;
 }
-*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aM;
 }
-if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && oT) {
+if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & pP) {
 if (material.thinWalled) {
-let oh = vec3f(lightLocal.xy, -lightLocal.z);
+let pb = vec3f(lightLocal.xy, -lightLocal.z);
 response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
-* cE(
+* bJ(
 material,
 material.subsurfaceColor,
 viewLocal,
-oh,
+pb,
 diffuseSpecularEnergyCompensation,
-&aI
+&aM
 );
-aI *= 0.5;
+aM *= 0.5;
 }
 else {
-response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dM(
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dX(
 material,
 viewLocal,
 lightLocal,
-&aI
+&aM
 );
 }
-*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aM;
 }
 }
 
 
 
 
-if (prepared.dielectricMsProbability > 0.0 && jG) {
-let au = abs(lightLocal.z);
-if (au > 0.0) {
+if ((prepared.dielectricMsProbability > 0.0) & kd) {
+let cosine = abs(lightLocal.z);
+if (cosine > 0.0) {
 let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);
-let ja = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
-let tr = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
-/ max(cO(ior, prepared.specularAlpha), 1e-12);
-let dW = min(tr * ja, 1.0 / au);
+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 scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);
-response += scale * dW * INVPI;
-*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ja * 0.5 * INVPI;
+response += scale * cL * INVPI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ju * 0.5 * INVPI;
 }
 }
 
 ${hasCoatNormals ? /* wgsl */ `    } ` : ''}
 if (material.coatWeight > 0.0) {
-response *= ds(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
+response *= cF(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
 }
 ${hasCoatNormals ? /* wgsl */ `
 
@@ -1330,273 +1331,270 @@ if (independentCoat) { response *= abs(lightLocal.z); }
 ` : ''}
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-var dI = viewLocal;
-var kD = lightLocal;
-var gw = V;
-var jK = bQ;
+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;
 if (prepared.directionFrames) {
-dI = ${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))'};
-kD = openpbr_to_local(prepared.coatBasis, lightDirection);
-gw = normalize(kD + dI);
-if (gw.z < 0.0) { gw = -gw; }
-jK = abs(dot(dI, gw));
+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));
 }
 
-let lg = vec3f(af(
-jK,
+let lQ = vec3f(af(
+kk,
 1.0 / material.coatIor
 ));
-var dH = material;
-let jx = aK(material.coatRoughness, material.coatAnisotropy);
-dH.alphaX = jx.x;
-dH.alphaY = jx.y;
-if (tc) {
-response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
-dH,
-dI,
-kD,
-gw,
-lg,
-&aI
+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
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
 }
 }
 ` : /* wgsl */ `
-if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
-let lg = vec3f(af(
-bQ,
+if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {
+let lQ = vec3f(af(
+bm,
 1.0 / material.coatIor
 ));
-var dH = material;
-let jx = aK(material.coatRoughness, material.coatAnisotropy);
-dH.alphaX = jx.x;
-dH.alphaY = jx.y;
-if (tc) {
-response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
-dH,
+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,
 viewLocal,
 lightLocal,
-V,
-lg,
-&aI
+ad,
+lQ,
+&aM
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aM;
 }
 }
 `}
 
-if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
-let qz = aO(
+if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0)) {
+let rC = aU(
 abs(viewLocal.z),
 material.fuzzRoughness
 );
 response *= max(
 vec3f(0.0),
-vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qz)
+vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * rC)
 );
-if (uN) {
-response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * jY(
+if (ws) {
+response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * kD(
 material,
 viewLocal,
 lightLocal,
-&aI
+&aM
 );
-*pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aM;
 }
 }
 
 return response * ${hasCoatNormals ? 'select(abs(lightLocal.z), 1.0, independentCoat)' : 'abs(lightLocal.z)'};
 }
 
-fn bI(
+fn bO(
 prepared: ag,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-return mD(prepared, lightDirection, -1, pdf);
+return nA(prepared, lightDirection, -1, pdf);
 }
 
 
 
 
 
-fn ri(
+fn sp(
 tangent: vec3f,
-material: J,
-bF: vec3f,
+material: OpenPbrResolvedMaterial,
+bM: vec3f,
 normal: vec3f,
 lightDirection: vec3f,
 pdf: ptr<function, f32>
 ) -> vec3f {
-let prepared = eH(
+let prepared = ds(
 tangent,
 material,
-bF,
+bM,
 normal
 );
-return bI(prepared, lightDirection, pdf);
+return bO(prepared, lightDirection, pdf);
 }
 
 
 
 
 
-fn nl(
-prepared: ag, cm: vec3f,
+fn jq(
+prepared: ag, cq: vec3f,
 lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,
-aA: ptr<function, f32>, aS: ptr<function, bool>,
-bE: ptr<function, bool>, aR: ptr<function, u32>
+aS: ptr<function, f32>, bu: ptr<function, bool>,
+cO: ptr<function, bool>, bn: ptr<function, u32>
 ) -> bool {
 let material = prepared.material;
 let viewLocal = prepared.viewLocal;
-var cy = cm.x;
-let fv = cm.y;
-let bm = cm.z;
+var cH = cq.x;
+let fL = cq.y;
+let bv = cq.z;
 *isTransmissionEvent = false;
-*aA = 1.0;
-*aS = false;
-*bE = false;
-*aR = u32(OPENPBR_LOBE_DIFFUSE);
+*aS = 1.0;
+*bu = false;
+*cO = false;
+*bn = u32(OPENPBR_LOBE_DIFFUSE);
 *lightDirection = prepared.basis.normal;
 
 var cdf: array<f32, OPENPBR_LOBE_COUNT>;
 cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];
-let nI = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
-for (var hU = 1; hU < nI; hU++) {
-cdf[hU] = cdf[hU - 1] + prepared.probabilities[hU];
-}
+${LOBE_INDICES.slice(1).map(i => /* wgsl */ `cdf[${i}] = cdf[${i - 1}] + prepared.probabilities[${i}];`).join('\n    ')}
 if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {
 return false;
 }
 
 var lightLocal: vec3f;
-if (bm < cdf[OPENPBR_LOBE_FUZZ] || (
-bm >= cdf[OPENPBR_LOBE_TRANSMISSION] && bm < cdf[OPENPBR_LOBE_DIFFUSE]
+if ((bv < cdf[OPENPBR_LOBE_FUZZ]) | (
+(bv >= cdf[OPENPBR_LOBE_TRANSMISSION]) & (bv < cdf[OPENPBR_LOBE_DIFFUSE])
 )) {
-let pQ = bm < cdf[OPENPBR_LOBE_FUZZ];
-*aA = select(
+let qG = bv < cdf[OPENPBR_LOBE_FUZZ];
+*aS = select(
 1.0,
 material.fuzzRoughness,
-pQ
+qG
 );
-*bE = !pQ;
-*aR = select(
+*cO = !qG;
+*bn = select(
 u32(OPENPBR_LOBE_DIFFUSE),
 u32(OPENPBR_LOBE_FUZZ),
-pQ
+qG
 );
-lightLocal = bi(vec2f(cy, fv));
+lightLocal = aO(vec2f(cH, fL));
 }
 ${hasAnisotropyDirections ? /* wgsl */ `
-else if (bm < cdf[OPENPBR_LOBE_COAT]) {
-*aA = material.coatRoughness;
-*aS = true;
-*aR = u32(OPENPBR_LOBE_COAT);
-var dI = viewLocal;
-if (prepared.directionFrames) { dI = ${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 V = aQ(
-dI,
-
-aK(material.coatRoughness, material.coatAnisotropy),
-vec2f(cy, fv)
+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)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-lightLocal = normalize(reflect(-dI, V));
+lightLocal = normalize(reflect(-dT, ad));
 ${hasCoatNormals ? /* wgsl */ `
 if (material.coatNormalEnabled) {
 
 *lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);
-return lightLocal.z > 0.0 && dot(material.geometricNormal, *lightDirection) > 0.0;
+return (lightLocal.z > 0.0) & (dot(material.geometricNormal, *lightDirection) > 0.0);
 }
 ` : ''}
 if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }
 }
 ` : /* wgsl */ `
-else if (bm < cdf[OPENPBR_LOBE_COAT]) {
-*aA = material.coatRoughness;
-*aS = true;
-*aR = u32(OPENPBR_LOBE_COAT);
-var V = aQ(
+else if (bv < cdf[OPENPBR_LOBE_COAT]) {
+*aS = material.coatRoughness;
+*bu = true;
+*bn = u32(OPENPBR_LOBE_COAT);
+var ad = aD(
 viewLocal,
 
-aK(material.coatRoughness, material.coatAnisotropy),
-vec2f(cy, fv)
+aN(material.coatRoughness, material.coatAnisotropy),
+vec2f(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-lightLocal = normalize(reflect(-viewLocal, V));
+lightLocal = normalize(reflect(-viewLocal, ad));
 }
 `}
-else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
-*aA = material.specularRoughness;
-*aS = true;
-*aR = select(
+else if (bv < cdf[OPENPBR_LOBE_SPECULAR]) {
+*aS = material.specularRoughness;
+*bu = true;
+*bn = select(
 u32(OPENPBR_LOBE_SPECULAR),
 u32(OPENPBR_LOBE_METAL),
-bm < cdf[OPENPBR_LOBE_METAL]
+bv < cdf[OPENPBR_LOBE_METAL]
 );
-let tw = bm < cdf[OPENPBR_LOBE_METAL];
-let rM = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
-if (tw && rM < prepared.metalMsProbability) {
-let z = cy;
-let fl = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * fv;
-lightLocal = vec3f(fl * cos(br), fl * sin(br), z);
+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);
 }
 else {
-var V = aQ(
+var ad = aD(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cy, fv)
+vec2f(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
-lightLocal = normalize(reflect(-viewLocal, V));
+lightLocal = normalize(reflect(-viewLocal, ad));
 }
 }
-else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
-*aA = material.specularRoughness;
-*aS = true;
+else if (bv < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+*aS = material.specularRoughness;
+*bu = true;
 *isTransmissionEvent = true;
-*aR = u32(OPENPBR_LOBE_TRANSMISSION);
+*bn = u32(OPENPBR_LOBE_TRANSMISSION);
 
 
-let us = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && us < prepared.dielectricMsProbability) {
-let ja = prepared.dielectricMsReflectionRatio;
-let lY = cy < ja;
+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;
 var z: f32;
-if (lY) { z = min(cy / ja, 0.99999994); }
-else { z = -min((cy - ja) / (1.0 - ja), 0.99999994); }
-let fl = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * fv;
-lightLocal = vec3f(fl * cos(br), fl * sin(br), z);
-*isTransmissionEvent = !lY;
-*aR = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), lY);
+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);
 }
 else {
-var V = aQ(
+var ad = aD(
 viewLocal,
 vec2f(material.alphaX, material.alphaY),
-vec2f(cy, fv)
+vec2f(cH, fL)
 );
-if (V.z < 0.0) {
-V = -V;
+if (ad.z < 0.0) {
+ad = -ad;
 }
 if (material.thinWalled) {
-let hZ = normalize(reflect(-viewLocal, V));
-lightLocal = vec3f(hZ.xy, -hZ.z);
+let iC = normalize(reflect(-viewLocal, ad));
+lightLocal = vec3f(iC.xy, -iC.z);
 }
 else {
 lightLocal = refract(
 -viewLocal,
-V,
+ad,
 prepared.material.relativeIor
 );
 if (dot(lightLocal, lightLocal) <= 1e-8) {
@@ -1608,20 +1606,20 @@ lightLocal = normalize(lightLocal);
 }
 }
 else {
-*aA = 1.0;
-*bE = true;
+*aS = 1.0;
+*cO = true;
 *isTransmissionEvent = true;
-*aR = u32(OPENPBR_LOBE_SUBSURFACE);
+*bn = u32(OPENPBR_LOBE_SUBSURFACE);
 if (material.thinWalled) {
-let pT = cy >= 0.5;
-if (pT) {
-cy = (cy - 0.5) * 2.0;
+let qL = cH >= 0.5;
+if (qL) {
+cH = (cH - 0.5) * 2.0;
 }
 else {
-cy *= 2.0;
+cH *= 2.0;
 }
-lightLocal = bi(vec2f(cy, fv));
-if (pT) {
+lightLocal = aO(vec2f(cH, fL));
+if (qL) {
 lightLocal.z = -lightLocal.z;
 }
 else {
@@ -1629,7 +1627,7 @@ else {
 }
 }
 else {
-lightLocal = bi(vec2f(cy, fv));
+lightLocal = aO(vec2f(cH, fL));
 lightLocal.z = -lightLocal.z;
 }
 }
@@ -1638,98 +1636,98 @@ lightLocal.z = -lightLocal.z;
 
 
 
-if (lightLocal.z == 0.0 || (lightLocal.z < 0.0) != *isTransmissionEvent) {
+if ((lightLocal.z == 0.0) | ((lightLocal.z < 0.0) != *isTransmissionEvent)) {
 return false;
 }
 ${hasCoatNormals ? /* wgsl */ `
-if (material.coatNormalEnabled &&
+if (material.coatNormalEnabled &
 ((dot(material.geometricNormal, *lightDirection) <= 0.0) != *isTransmissionEvent)) { return false; }
 ` : ''}
 return true;
 }
 
-fn dv(
+fn eN(
 prepared: ag,
-cm: vec3f,
+cq: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
-aA: ptr<function, f32>,
-aS: ptr<function, bool>,
-bE: ptr<function, bool>,
-aR: ptr<function, u32>,
-lo: ptr<function, f32>,
-gY: ptr<function, vec3f>
+aS: ptr<function, f32>,
+bu: ptr<function, bool>,
+cO: ptr<function, bool>,
+bn: ptr<function, u32>,
+lW: ptr<function, f32>,
+kq: ptr<function, vec3f>
 ) -> vec3f {
 *pdf = 0.0;
-*lo = 0.0;
-*gY = vec3f(0.0);
+*lW = 0.0;
+*kq = vec3f(0.0);
 
 
 
 
-if (!prepared.material.thinWalled &&
-abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
-prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6) {
+if (!prepared.material.thinWalled &
+(abs(prepared.material.relativeIor - 1.0) <= 1e-6) &
+(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6)) {
 *lightDirection = openpbr_to_world(
 prepared.basis,
 -prepared.viewLocal
 );
-let nL = bn(prepared.material)
-* ds(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
+let oF = bh(prepared.material)
+* cF(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
 *pdf = 1.0;
-*lo = 1.0;
-*gY = nL;
+*lW = 1.0;
+*kq = oF;
 *isTransmissionEvent = true;
-*aA = 0.0;
-*aS = true;
-*bE = false;
-*aR = u32(OPENPBR_LOBE_TRANSMISSION);
-return nL;
-}
-if (!nl(prepared, cm, lightDirection,
-isTransmissionEvent, aA, aS,
-bE, aR)) { return vec3f(0.0); }
-let response = bI(prepared, *lightDirection, pdf);
-*lo = *pdf;
-*gY = response;
+*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;
 return response;
 }
 
-fn sJ(
+fn tZ(
 tangent: vec3f,
-material: J,
-cm: vec3f,
-bF: vec3f,
+material: OpenPbrResolvedMaterial,
+cq: vec3f,
+bM: vec3f,
 normal: vec3f,
 lightDirection: ptr<function, vec3f>,
 pdf: ptr<function, f32>,
 isTransmissionEvent: ptr<function, bool>,
-aA: ptr<function, f32>,
-aS: ptr<function, bool>,
-bE: ptr<function, bool>,
-aR: ptr<function, u32>,
-lo: ptr<function, f32>
+aS: ptr<function, f32>,
+bu: ptr<function, bool>,
+cO: ptr<function, bool>,
+bn: ptr<function, u32>,
+lW: ptr<function, f32>
 ) -> vec3f {
-let prepared = eH(
+let prepared = ds(
 tangent,
 material,
-bF,
+bM,
 normal
 );
-var gY = vec3f(0.0);
-return dv(
+var kq = vec3f(0.0);
+return eN(
 prepared,
-cm,
+cq,
 lightDirection,
 pdf,
 isTransmissionEvent,
-aA,
 aS,
-bE,
-aR,
-lo,
-&gY
+bu,
+cO,
+bn,
+lW,
+&kq
 );
 }`;
 }