@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1737 @@
+/*
+ * OpenPBR energy-compensation, EON and thin-film portions Copyright 2026 Adobe.
+ * Licensed under the Apache License, Version 2.0.
+ * https://www.apache.org/licenses/LICENSE-2.0
+ */
+/*
+ * Renderer-specific OpenPBR layered BSDF.
+ *
+ * The prepare/eval/sample/pdf organization and fixed-lobe composition follow:
+ * - https://github.com/adobe/openpbr-bsdf
+ * - https://github.com/portsmouth/OpenPBR-viewer
+ *
+ * This compact GPU implementation reuses the renderer's GGX VNDF and volume
+ * integrator. Adobe's opaque-dielectric energy tables are used for the base
+ * 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';
+export function createOpenPbrBsdfWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
+    return /* wgsl */ `
+const OPENPBR_LOBE_FUZZ: i32 = 0;
+const OPENPBR_LOBE_COAT: i32 = 1;
+const OPENPBR_LOBE_METAL: i32 = 2;
+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;
+
+struct bj {
+tangent: vec3f,
+bitangent: vec3f,
+normal: vec3f,
+};
+
+struct ag {
+material: J,
+basis: bj,
+${hasAnisotropyDirections ? /* wgsl */ `
+coatBasis: bj,
+directionFrames: bool,
+` : /* wgsl */ ``}
+${hasCoatNormals ? /* wgsl */ `    coatViewLocal: vec3f,` : ''}
+viewLocal: vec3f,
+diffuseColor: vec3f,
+specularEtaTOverEtaI: f32,
+refractionEtaTOverEtaI: f32,
+transmissionReflectionIor: f32,
+thinFilmExteriorIor: f32,
+thinFilmBaseIor: f32,
+specularAlpha: f32,
+diffuseSpecularEnergyCompensation: f32,
+coatBaseScale: vec3f,
+metalMsScale: vec3f,
+metalMsFactor: f32,
+metalMsProbability: f32,
+
+dielectricMsReflectionScale: vec3f,
+dielectricMsTransmissionScale: vec3f,
+dielectricMsViewLoss: f32,
+dielectricMsReflectionRatio: f32,
+dielectricMsProbability: f32,
+
+weights: array<f32, OPENPBR_LOBE_COUNT>,
+probabilities: array<f32, OPENPBR_LOBE_COUNT>,
+};
+
+fn aw(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);
+return value * value;
+}
+
+fn aY(
+bu: f32,
+specularWeight: f32
+) -> f32 {
+let sE = min(
+cV(bu) * specularWeight,
+0.9999
+);
+let sG = sqrt(sE);
+let kV = (1.0 + sG) / (1.0 - sG);
+return select(kV, 1.0 / kV, bu < 1.0);
+}
+
+fn af(cc: f32, relativeIor: f32) -> f32 {
+if (abs(relativeIor - 1.0) < 1e-6) {
+return 0.0;
+}
+return ct(cc, relativeIor);
+}
+
+fn aC(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(rX: i32, row: i32) -> f32 {
+return textureLoad(openPbrEnergyLut, vec2i(rX, row), 0).r;
+}
+
+fn fY(
+dI: f32,
+bR: f32,
+hO: f32
+) -> f32 {
+let bA = clamp(dI, 0.0, 31.0);
+let aG = clamp(bR, 0.0, 31.0);
+let bt = clamp(hO, 0.0, 31.0);
+let dP = i32(floor(bA));
+let aM = i32(floor(aG));
+let cI = i32(floor(bt));
+let hB = min(dP + 1, 31);
+let cn = min(aM + 1, 31);
+let eO = min(cI + 1, 31);
+let cp = bA - f32(dP);
+let cy = aG - f32(aM);
+let ku = bt - f32(cI);
+
+let uk = F(cI, dP * 32 + aM);
+let ul = F(eO, dP * 32 + aM);
+let um = F(cI, dP * 32 + cn);
+let un = F(eO, dP * 32 + cn);
+let uo = F(cI, hB * 32 + aM);
+let uq = F(eO, hB * 32 + aM);
+let ur = F(cI, hB * 32 + cn);
+let us = F(eO, hB * 32 + cn);
+let v00 = mix(uk, uo, cp);
+let v01 = mix(ul, uq, cp);
+let v10 = mix(um, ur, cp);
+let v11 = mix(un, us, cp);
+return mix(
+mix(v00, v10, cy),
+mix(v01, v11, cy),
+ku
+);
+}
+
+fn gx(dI: f32, bR: f32) -> f32 {
+let bA = clamp(dI, 0.0, 31.0);
+let aG = clamp(bR, 0.0, 31.0);
+let dP = i32(floor(bA));
+let aM = i32(floor(aG));
+let hB = min(dP + 1, 31);
+let cn = min(aM + 1, 31);
+let cp = bA - f32(dP);
+let cy = aG - f32(aM);
+let v00 = F(aM, 1024 + dP);
+let v01 = F(cn, 1024 + dP);
+let v10 = F(aM, 1024 + hB);
+let v11 = F(cn, 1024 + hB);
+return mix(
+mix(v00, v10, cp),
+mix(v01, v11, cp),
+cy
+);
+}
+
+
+
+fn ef(
+dI: f32,
+bR: f32,
+hO: f32
+) -> f32 {
+let bA = clamp(dI, 0.0, 31.0);
+let aG = clamp(bR, 0.0, 31.0);
+let bt = clamp(hO, 0.0, 31.0);
+let dP = i32(floor(bA));
+let aM = i32(floor(aG));
+let cI = i32(floor(bt));
+let hB = min(dP + 1, 31);
+let cn = min(aM + 1, 31);
+let eO = min(cI + 1, 31);
+let cp = bA - f32(dP);
+let cy = aG - f32(aM);
+let ku = bt - f32(cI);
+
+let uk = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+let ul = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+let um = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+let un = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+let uo = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+let uq = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+let ur = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+let us = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+let v00 = mix(uk, uo, cp);
+let v01 = mix(ul, uq, cp);
+let v10 = mix(um, ur, cp);
+let v11 = mix(un, us, cp);
+return mix(
+mix(v00, v10, cy),
+mix(v01, v11, cy),
+ku
+);
+}
+
+fn ee(dI: f32, bR: f32) -> f32 {
+let bA = clamp(dI, 0.0, 31.0);
+let aG = clamp(bR, 0.0, 31.0);
+let dP = i32(floor(bA));
+let aM = i32(floor(aG));
+let hB = min(dP + 1, 31);
+let cn = min(aM + 1, 31);
+let cp = bA - f32(dP);
+let cy = aG - f32(aM);
+let v00 = F(aM, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
+let v01 = F(cn, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + dP);
+let v10 = F(aM, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+let v11 = F(cn, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + hB);
+return mix(
+mix(v00, v10, cp),
+mix(v01, v11, cp),
+cy
+);
+}
+
+fn eF(dI: f32, bR: f32) -> f32 {
+let bA = clamp(dI, 0.0, 31.0);
+let aG = clamp(bR, 0.0, 31.0);
+let dP = i32(floor(bA));
+let aM = i32(floor(aG));
+let hB = min(dP + 1, 31);
+let cn = min(aM + 1, 31);
+let cp = bA - f32(dP);
+let cy = aG - f32(aM);
+let v00 = F(aM, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
+let v01 = F(cn, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + dP);
+let v10 = F(aM, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+let v11 = F(cn, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + hB);
+return mix(
+mix(v00, v10, cp),
+mix(v01, v11, cp),
+cy
+);
+}
+
+fn bO(ior: f32, alpha: f32, au: f32) -> f32 {
+return ef(aC(ior), sqrt(alpha) * 31.0, au * 31.0);
+}
+fn cO(ior: f32, alpha: f32) -> f32 {
+return ee(aC(ior), sqrt(alpha) * 31.0);
+}
+fn ch(ior: f32, alpha: f32) -> f32 {
+return eF(aC(ior), sqrt(alpha) * 31.0);
+}
+
+
+
+fn bH(alpha: f32, au: f32) -> f32 {
+let ia = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);
+let bt = clamp(au * 31.0, 0.0, 31.0);
+let r0 = i32(floor(ia));
+let c0 = i32(floor(bt));
+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(ia));
+}
+
+fn cu(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 tI = cV(2.5);
+let progress = (cV(ior) - tI) / (1.0 - tI);
+return (1.0 - progress) * value;
+}
+return value;
+}
+
+fn aI(
+ior: f32,
+alpha: f32,
+au: f32
+) -> f32 {
+let value = fY(
+aC(ior),
+sqrt(alpha) * 31.0,
+au * 31.0
+);
+return aX(value, ior);
+}
+
+fn cq(ior: f32, alpha: f32) -> f32 {
+let value = gx(
+aC(ior),
+sqrt(alpha) * 31.0
+);
+return aX(value, ior);
+}
+
+fn openpbr_to_world(basis: bj, 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 {
+return vec3f(
+dot(direction, basis.tangent),
+dot(direction, basis.bitangent),
+dot(direction, basis.normal)
+);
+}
+
+fn fg(
+aU: vec3f,
+normal: vec3f,
+anisotropy: f32
+) -> bj {
+var basis: bj;
+basis.normal = normal;
+var tangent = aU;
+var bitangent = vec3f(0.0);
+if (dot(tangent, tangent) < 0.001 || anisotropy <= 0.0) {
+aK(normal, &tangent, &bitangent);
+}
+else {
+bitangent = normalize(cross(normal, tangent));
+tangent = normalize(cross(bitangent, normal));
+}
+basis.tangent = tangent;
+basis.bitangent = bitangent;
+return basis;
+}
+
+fn jR(
+av: f32,
+ak: f32,
+L: f32,
+S: f32
+) -> f32 {
+return (av * L - ak * S)
+/ (av * L + ak * S);
+}
+
+fn jQ(
+av: f32,
+ak: f32,
+L: f32,
+S: f32
+) -> f32 {
+return (ak * L - av * S)
+/ (av * S + ak * L);
+}
+
+fn gX(
+av: f32,
+ak: f32,
+L: f32,
+S: f32
+) -> f32 {
+return 2.0 * av * L
+/ (av * L + ak * S);
+}
+
+fn gW(
+av: f32,
+ak: f32,
+L: f32,
+S: f32
+) -> f32 {
+return 2.0 * av * L
+/ (av * S + ak * L);
+}
+
+fn aV(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);
+return vec2f(
+(a.x * b.x + a.y * b.y) / ap,
+(a.y * b.x - a.x * b.y) / ap
+);
+}
+
+fn hU(value: vec2f) -> vec2f {
+let ns = length(value);
+let sC = sqrt(max(0.0, 0.5 * (ns + value.x)));
+let fc = sqrt(max(0.0, 0.5 * (ns - value.x)));
+return vec2f(sC, select(-fc, fc, value.y >= 0.0));
+}
+
+fn bX(
+L: f32,
+av: f32,
+ak: vec2f,
+qu: bool
+) -> vec2f {
+let ob = sqrt(max(0.0, 1.0 - L * L));
+let sj = aZ(vec2f(av, 0.0), ak);
+let hw = sj * ob;
+var S = hU(
+vec2f(1.0, 0.0) - aV(hw, hw)
+);
+if (aV(ak, S).y < 0.0) {
+S = -S;
+}
+
+let fH = vec2f(av * L, 0.0);
+let eA = aV(ak, S);
+if (qu) {
+let ci = ak * L;
+let ce = S * av;
+return aZ(
+ci - ce,
+ci + ce
+);
+}
+return aZ(
+fH - eA,
+fH + eA
+);
+}
+
+fn eq(
+iD: f32,
+gG: f32,
+ov: f32,
+mA: f32,
+jW: vec2f,
+phase: f32
+) -> f32 {
+let mX = vec2f(cos(phase), sin(phase));
+let hX = aV(jW, mX);
+let kC = hX * (gG * mA);
+let ap = vec2f(1.0, 0.0) - hX * ov;
+let hv = vec2f(iD, 0.0)
++ aZ(kC, ap);
+return dot(hv, hv);
+}
+
+fn ar(
+L: f32,
+wavelength: f32,
+cm: f32,
+aL: f32,
+ck: f32,
+eu: vec2f
+) -> f32 {
+let dl = clamp(abs(L), 1e-5, 1.0);
+let hq = pow(aL / ck, 2.0)
+* (1.0 - dl * dl);
+if (hq >= 1.0) {
+return 1.0;
+}
+let cU = sqrt(1.0 - hq);
+let kP = jR(
+aL, ck, dl, cU
+);
+let kO = jQ(
+aL, ck, dl, cU
+);
+let jd = gX(
+aL, ck, dl, cU
+);
+let jc = gW(
+aL, ck, dl, cU
+);
+let gj = ck * cU
+/ max(aL * dl, 1e-9);
+let phase = 2.0 * PI * (2.0 * ck * cm * cU) / wavelength;
+var rO = 0.0;
+
+for (var jV = 0u; jV < (rtUniform.loopUnrollGuard >> 1u); jV++) {
+let iD = select(kP, kO, jV == 1u);
+let gG = select(jd, jc, jV == 1u);
+let jW = bX(
+cU, ck, eu, jV == 1u);
+rO += eq(iD, gG,
+-iD, gG * gj, jW, phase);
+}
+return clamp(0.5 * rO, 0.0, 1.0);
+}
+
+
+
+
+fn dT(au: f32, f0: vec3f, tint: vec3f) -> vec3f {
+let qW = mix(f0, vec3f(1.0), aE(au));
+if (all(tint == vec3f(1.0))) { return qW; }
+let dj = 1.0 / 7.0;
+let lW = 1.0 - dj;
+let fF = mix(f0, vec3f(1.0), aE(dj));
+let dg = 1.0 - au;
+let qh = au * aE(au) * dg
+/ (dj * pow(lW, 6.0));
+return clamp(qW - qh * (fF - tint * fF), vec3f(0.0), vec3f(1.0));
+}
+
+fn cQ(f0: f32, tb: f32) -> vec2f {
+let dM = clamp(f0, 0.0, 0.99);
+let gF = sqrt(dM);
+let qt = (1.0 - dM) / (1.0 + dM);
+let qr = (1.0 + gF) / max(1.0 - gF, 1e-9);
+let ior = mix(qr, qt, clamp(tb, 0.0, 1.0));
+let jG = (
+(ior + 1.0) * (ior + 1.0) * dM
+- (ior - 1.0) * (ior - 1.0)
+) / max(1.0 - dM, 1e-9);
+return vec2f(ior, sqrt(max(jG, 0.0)));
+}
+
+
+fn bN(cm: f32, weight: f32) -> f32 {
+return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, cm);
+}
+
+
+
+fn cD(
+material: J,
+color: vec3f,
+viewLocal: vec3f,
+lightLocal: vec3f,
+fo: f32,
+pdf: ptr<function, f32>
+) -> vec3f {
+*pdf = 0.0;
+if (lightLocal.z <= 0.0) {
+return vec3f(0.0);
+}
+
+let roughness = material.diffuseRoughness;
+let gQ = 0.5 - 2.0 / (3.0 * PI);
+let nU = 2.0 / 3.0 - 28.0 / (15.0 * PI);
+let om = lightLocal.z;
+let mn = viewLocal.z;
+let hM = dot(lightLocal, viewLocal) - om * mn;
+let gN = select(
+hM,
+hM / max(max(om, mn), 1e-7),
+hM > 0.0
+);
+let ih = 1.0 / (1.0 + gQ * roughness);
+let nf = color * INVPI * ih
+* (1.0 + roughness * gN);
+
+let dc = 1.0 - om;
+let cP = 1.0 - mn;
+let oc = dc * (
+0.0571085289 + dc * (
+0.491881867 + dc * (
+-0.332181442 + dc * 0.0714429953
+)
+)
+);
+let mW = cP * (
+0.0571085289 + cP * (
+0.491881867 + cP * (
+-0.332181442 + cP * 0.0714429953
+)
+)
+);
+let pi = (1.0 + roughness * oc)
+/ (1.0 + gQ * roughness);
+let oq = (1.0 + roughness * mW)
+/ (1.0 + gQ * roughness);
+let fQ = ih * (1.0 + nU * roughness);
+let hC = color * color * fQ
+/ max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - fQ));
+let lp = hC * INVPI
+* max(1e-7, 1.0 - oq)
+* max(1e-7, 1.0 - pi)
+/ max(1e-7, 1.0 - fQ);
+*pdf = lightLocal.z * INVPI;
+return (nf + lp) * fo;
+}
+
+fn aO(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)
+/ (0.0379424 + y * (1.32227 + y));
+let mean = y * (-0.193854 + y * (-1.14885 + y * (1.7932 - 0.95943 * y * y)))
+/ (0.046391 + y);
+let offset = y * (0.000654023 + (-0.0207818 + 0.119681 * y) * y)
+/ (1.26264 + y * (-1.92021 + y));
+let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))
+/ (scale * sqrt(2.0 * PI));
+return max(gaussian + offset, 0.0);
+}
+
+fn jP(
+material: J,
+viewLocal: vec3f,
+lightLocal: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+*pdf = 0.0;
+if (viewLocal.z <= 0.0 || lightLocal.z <= 0.0) {
+return vec3f(0.0);
+}
+let albedo = aO(
+viewLocal.z,
+material.fuzzRoughness
+);
+*pdf = lightLocal.z * INVPI;
+return material.fuzzColor * albedo * INVPI;
+}
+
+fn am(
+material: J,
+viewLocal: vec3f,
+lightLocal: vec3f,
+V: vec3f,
+cK: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+*pdf = 0.0;
+if (lightLocal.z <= 0.0) {
+return vec3f(0.0);
+}
+
+let alpha = vec2f(material.alphaX, material.alphaY);
+let distribution = gE(V, alpha);
+let jM = bk(viewLocal, alpha);
+let ea = jM
+* bk(lightLocal, alpha);
+
+*pdf = jM * distribution / (4.0 * max(viewLocal.z, 1e-8));
+return cK * distribution * ea
+/ (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));
+}
+
+fn dk(
+material: J,
+relativeIor: f32,
+tint: vec3f,
+viewLocal: vec3f,
+lightLocal: vec3f,
+V: vec3f,
+cK: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+*pdf = 0.0;
+if (lightLocal.z >= 0.0) {
+return vec3f(0.0);
+}
+
+let kz = dot(lightLocal, V);
+let bQ = dot(viewLocal, V);
+
+
+if (bQ <= 0.0 || kz >= 0.0) {
+return vec3f(0.0);
+}
+let alpha = vec2f(material.alphaX, material.alphaY);
+let distribution = gE(V, alpha);
+let jM = bk(viewLocal, alpha);
+let ea = jM
+* bk(lightLocal, alpha);
+var ap = kz + bQ * relativeIor;
+ap *= ap;
+let pn = abs(kz) / max(ap, 1e-8);
+let jm = relativeIor * relativeIor;
+
+*pdf = jM * max(0.0, bQ) * distribution * pn
+/ max(viewLocal.z, 1e-8);
+return tint * (vec3f(1.0) - cK) * distribution * ea
+* abs(bQ) * pn * jm
+/ max(abs(lightLocal.z * viewLocal.z), 1e-8);
+}
+
+fn bn(material: J) -> 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 aP(
+ah: vec3f,
+transmissionWeight: f32
+) -> vec3f {
+let gf = 2.0 * ah
+/ (vec3f(1.0) + ah);
+return mix(
+ah,
+gf,
+clamp(transmissionWeight, 0.0, 1.0)
+);
+}
+
+fn bG(
+material: J,
+L: f32,
+bu: f32
+) -> vec3f {
+let tint = bn(material);
+if (!material.thinWalled) {
+return tint;
+}
+let iF = max(0.0, 1.0 - L * L);
+let dN = iF
+/ max(bu * bu, 1e-9);
+if (dN >= 1.0) {
+return vec3f(0.0);
+}
+let S = sqrt(1.0 - dN);
+return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(S, 1e-5)));
+}
+
+fn dL(
+material: J,
+viewLocal: vec3f,
+lightLocal: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+*pdf = 0.0;
+if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {
+return vec3f(0.0);
+}
+let S = -lightLocal.z;
+let nR = ct(
+viewLocal.z,
+material.relativeIor
+);
+*pdf = S * INVPI;
+return vec3f(1.0 - nR) * INVPI;
+}
+
+fn dQ(prepared: ptr<function, ag>) {
+
+
+let nr = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];
+for (var hR = 1; hR < nr; hR++) {
+total += (*prepared).probabilities[hR];
+}
+if (total <= 1e-8) {
+for (var hR = 0; hR < nr; hR++) {
+(*prepared).probabilities[hR] = 0.0;
+}
+return;
+}
+let og = 1.0 / total;
+for (var hR = 0; hR < nr; hR++) {
+(*prepared).probabilities[hR] *= og;
+}
+}
+
+
+
+fn bM(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 dj = 1.0 / 7.0;
+let fF = mix(f0, vec3f(1.0), aE(dj));
+let b = fF * (vec3f(1.0) - tint) / (dj * pow(1.0 - dj, 6.0));
+return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));
+}
+
+
+
+fn cC(material: J, au: f32) -> vec3f {
+if (au <= 0.0) { return vec3f(1.0); }
+let lr = sqrt(max(0.0, 1.0 - (1.0 - au * au) / (material.coatIor * material.coatIor)));
+let tl = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(lr, 1e-5)));
+return mix(vec3f(1.0), tl, material.coatWeight);
+}
+
+fn gi(material: J, au: f32) -> f32 {
+if (material.coatRoughness <= ROUGHNESS_MIN) {
+return af(au, 1.0 / material.coatIor);
+}
+
+
+return clamp(1.0 - aI(material.coatIor,
+material.coatRoughness * material.coatRoughness, au), 0.0, 1.0);
+}
+
+fn gV(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 tT = dielectric * material.transmissionWeight;
+let fL = bM(prepared.specularEtaTOverEtaI);
+let kI = bM(1.0 / prepared.transmissionReflectionIor);
+let pw = clamp(opaque * fL + (sss + tT) * kI + material.baseMetalness, 0.0, 1.0);
+let ji = mix(1.0, material.specularRoughness, pw);
+let ks = bM(material.coatIor);
+let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
+let k = mix(ks, kr, ji);
+let eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
++ opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fL)
++ sss * material.subsurfaceColor + vec3f(tT);
+let qH = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
+return mix(vec3f(1.0), qH, material.coatWeight * material.coatDarkening);
+}
+
+fn ds(prepared: ag, kY: f32) -> vec3f {
+if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }
+if (prepared.material.inside) {
+
+return cC(prepared.material, -kY);
+}
+
+return prepared.coatBaseScale * cC(prepared.material, kY);
+}
+
+
+${hasAnisotropyDirections ? /* wgsl */ `
+fn du(fallback: bj, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> bj {
+var t = tangent - fallback.normal * dot(fallback.normal, tangent);
+if (dot(t, t) < 1e-8) { t = fallback.tangent; }
+t = normalize(t);
+let b = cross(fallback.normal, t) * select(1.0, -1.0, dot(cross(fallback.normal, t), bitangent) < 0.0);
+t = t * direction.x + b * direction.y;
+if (dot(t, t) < 1e-8) { return fallback; }
+var basis = fallback;
+basis.tangent = normalize(t);
+basis.bitangent = normalize(cross(basis.normal, basis.tangent));
+basis.tangent = normalize(cross(basis.bitangent, basis.normal));
+return basis;
+}
+
+` : /* wgsl */ ``}
+fn eG(
+tangent: vec3f,
+material: J,
+bF: vec3f,
+normal: vec3f
+) -> ag {
+var prepared: ag;
+prepared.material = material;
+prepared.basis = fg(
+tangent,
+normal,
+max(material.specularAnisotropy, material.coatAnisotropy)
+);
+${hasAnisotropyDirections ? /* wgsl */ `
+prepared.coatBasis = prepared.basis;
+prepared.directionFrames = false;
+${hasCoatNormals ? /* wgsl */ `
+
+
+if (material.coatNormalEnabled) {
+prepared.coatBasis = fg(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);
+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)));
+prepared.directionFrames = true;
+}
+` : /* wgsl */ ``}
+prepared.viewLocal = openpbr_to_local(prepared.basis, bF);
+${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, bF);` : ''}
+prepared.diffuseColor = material.baseColor;
+
+let cA = 1.0 - material.baseMetalness;
+let dK = cA
+* (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] = cA;
+prepared.weights[OPENPBR_LOBE_TRANSMISSION] = cA
+* material.transmissionWeight;
+prepared.weights[OPENPBR_LOBE_DIFFUSE] = dK
+* (1.0 - material.subsurfaceWeight) * material.baseWeight;
+prepared.weights[OPENPBR_LOBE_SUBSURFACE] = dK
+* material.subsurfaceWeight;
+
+prepared.specularEtaTOverEtaI = aY(
+1.0 / material.relativeIor,
+material.specularWeight
+);
+prepared.material.relativeIor = 1.0 / prepared.specularEtaTOverEtaI;
+prepared.refractionEtaTOverEtaI = prepared.specularEtaTOverEtaI;
+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;
+if (material.inside) {
+prepared.refractionEtaTOverEtaI = 1.0 / bq;
+prepared.transmissionReflectionIor = bq;
+}
+prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;
+}
+
+
+
+prepared.thinFilmExteriorIor = 1.0;
+prepared.thinFilmBaseIor = prepared.specularEtaTOverEtaI;
+if (material.coatWeight > 0.0) {
+if (material.inside) {
+prepared.thinFilmExteriorIor = 1.0 / prepared.refractionEtaTOverEtaI;
+prepared.thinFilmBaseIor = 1.0;
+}
+else {
+prepared.thinFilmExteriorIor = mix(1.0, material.coatIor, material.coatWeight);
+prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;
+}
+}
+prepared.specularAlpha = material.specularRoughness
+* material.specularRoughness;
+let viewCosine = abs(prepared.viewLocal.z);
+let ah = af(
+viewCosine,
+1.0 / prepared.specularEtaTOverEtaI
+);
+let ft = material.specularColor * select(
+ah,
+mix(
+ah,
+cS(ah),
+material.transmissionWeight
+),
+material.thinWalled
+);
+let hS = material.specularWeight * dT(
+viewCosine,
+material.baseWeight * material.baseColor,
+material.specularColor
+);
+let eL = select(
+af(viewCosine, prepared.transmissionReflectionIor),
+cS(af(viewCosine, prepared.transmissionReflectionIor)),
+material.thinWalled
+);
+let gH = bG(
+material,
+viewCosine,
+prepared.refractionEtaTOverEtaI
+);
+let im = aI(
+prepared.specularEtaTOverEtaI,
+prepared.specularAlpha,
+viewCosine
+);
+let gk = cq(
+prepared.specularEtaTOverEtaI,
+prepared.specularAlpha
+);
+prepared.diffuseSpecularEnergyCompensation = im
+/ max(gk, 1e-12);
+
+prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]
+* aw(material.fuzzColor)
+* max(aO(
+viewCosine,
+material.fuzzRoughness
+), 0.02);
+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 kp = gi(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});
+prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * kp;
+prepared.coatBaseScale = cC(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})
+* (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * kp) * gV(prepared);
+}
+prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]
+* aw(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 hI = bP(material.baseWeight * material.baseColor, material.specularColor);
+prepared.metalMsScale = material.specularWeight * hI * hI;
+let pJ = bH(prepared.specularAlpha, viewCosine);
+prepared.metalMsFactor = pJ / max(cu(prepared.specularAlpha), 1e-12);
+let ff = prepared.weights[OPENPBR_LOBE_METAL] * aw(prepared.metalMsScale) * pJ;
+prepared.probabilities[OPENPBR_LOBE_METAL] += ff;
+prepared.metalMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+}
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]
+* aw(ft);
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+* (1.0 - eL)
+* aw(gH);
+
+
+
+
+
+
+prepared.dielectricMsReflectionScale = vec3f(0.0);
+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 lq = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];
+prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * lq;
+prepared.dielectricMsTransmissionScale = gH * 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 nI = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);
+let ff = aw(nI) * prepared.dielectricMsViewLoss;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += ff;
+prepared.dielectricMsProbability = ff / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+}
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]
+* aw(prepared.diffuseColor)
+* prepared.diffuseSpecularEnergyCompensation;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]
+* (1.0 - eL)
+* aw(material.subsurfaceColor)
+* prepared.diffuseSpecularEnergyCompensation;
+
+
+if (material.coatWeight > 0.0 && HAS_THIN_FILM && material.thinFilmWeight > 0.0) {
+let kW = 0.02 * bN(material.thinFilmThickness, material.thinFilmWeight);
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * kW);
+prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * kW);
+}
+if (material.coatWeight > 0.0 && !material.inside) {
+let gm = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);
+prepared.probabilities[OPENPBR_LOBE_METAL] *= gm;
+prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= gm;
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= gm;
+prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= gm;
+prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= gm;
+}
+dQ(&prepared);
+return prepared;
+}
+
+
+fn cR(prepared: ag, au: f32, reflection: bool) -> f32 {
+if (prepared.material.coatWeight <= 0.0) {
+return af(au, prepared.material.relativeIor);
+}
+let kg = af(au, prepared.transmissionReflectionIor);
+if (!reflection) { return kg; }
+let mU = af(au, 1.0 / prepared.specularEtaTOverEtaI);
+let rC = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;
+return mix(mU, kg, rC);
+}
+
+fn mq(
+prepared: ag,
+lightDirection: vec3f,
+gI: i32,
+pdf: ptr<function, f32>
+) -> vec3f {
+let material = prepared.material;
+let viewLocal = prepared.viewLocal;
+let lightLocal = openpbr_to_local(prepared.basis, lightDirection);
+let reflection = lightLocal.z * viewLocal.z > 0.0;
+${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;
+` : ''}
+
+var V: vec3f;
+if (reflection) {
+V = normalize(lightLocal + viewLocal);
+}
+else {
+V = normalize(lightLocal + viewLocal * material.relativeIor);
+}
+if (V.z < 0.0) {
+V = -V;
+}
+
+var response = vec3f(0.0);
+*pdf = 0.0;
+var aH = 0.0;
+let lQ = gI < 0;
+let uz = lQ || gI == OPENPBR_LOBE_FUZZ;
+let sQ = lQ || gI == OPENPBR_LOBE_COAT;
+let rT = lQ || gI == OPENPBR_LOBE_METAL;
+let pT = lQ || gI == OPENPBR_LOBE_SPECULAR;
+let jz = lQ ||
+gI == OPENPBR_LOBE_TRANSMISSION;
+let sV = lQ || gI == OPENPBR_LOBE_DIFFUSE;
+let oI = lQ ||
+gI == OPENPBR_LOBE_SUBSURFACE;
+let bQ = abs(dot(viewLocal, V));
+
+
+
+var dd = V;
+var jg = bQ;
+if (!reflection && material.thinWalled) {
+dd = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);
+if (dd.z < 0.0) { dd = -dd; }
+jg = abs(dot(viewLocal, dd));
+}
+let lZ =
+(reflection && prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && pT) ||
+(!reflection && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jz);
+let pX = reflection && prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && rT;
+var nj: array<vec3f, 2>;
+if (lZ) {
+nj[0] = vec3f(cR(prepared, jg, reflection));
+}
+if (pX) {
+nj[1] = dT(bQ, 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 kH = 0u; kH < (rtUniform.loopUnrollGuard >> 1u); kH++) {
+if (!select(lZ, pX, kH == 1u)) { continue; }
+var wb = vec3f(0.0);
+let L = select(jg, bQ, kH == 1u);
+for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
+var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
+if (kH == 1u) {
+ior = cQ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
+}
+wb[channel] = ar(L,
+wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
+}
+nj[kH] = mix(nj[kH], wb,
+bN(material.thinFilmThickness, material.thinFilmWeight));
+}
+}
+let ei = nj[0];
+let diffuseSpecularEnergyCompensation =
+prepared.diffuseSpecularEnergyCompensation
+* aI(
+prepared.specularEtaTOverEtaI,
+prepared.specularAlpha,
+abs(lightLocal.z)
+);
+
+${hasCoatNormals ? /* wgsl */ `
+
+if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflection)) {
+` : ''}
+if (reflection) {
+if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0 && sV) {
+response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * cD(
+material,
+prepared.diffuseColor,
+viewLocal,
+lightLocal,
+diffuseSpecularEnergyCompensation,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * aH;
+}
+
+if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled &&
+oI) {
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * cD(
+material,
+material.subsurfaceColor,
+viewLocal,
+lightLocal,
+diffuseSpecularEnergyCompensation,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * aH;
+}
+
+if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && pT) {
+var cr = ei;
+if (material.thinWalled) {
+cr = aP(
+cr,
+material.transmissionWeight
+);
+}
+let cK = material.specularColor * cr;
+response += prepared.weights[OPENPBR_LOBE_SPECULAR] * am(
+material,
+viewLocal,
+lightLocal,
+V,
+cK,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * aH;
+}
+
+if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && rT) {
+let cK = material.specularWeight * nj[1];
+response += prepared.weights[OPENPBR_LOBE_METAL] * am(
+material,
+viewLocal,
+lightLocal,
+V,
+cK,
+&aH
+);
+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;
+aH = mix(aH, 0.5 * INVPI, prepared.metalMsProbability);
+}
+*pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * aH;
+}
+}
+else {
+let cK = ei;
+if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && jz) {
+if (material.thinWalled) {
+let kM = vec3f(lightLocal.xy, -lightLocal.z);
+let gf = aP(
+ei,
+1.0
+);
+let tint = bG(
+material,
+abs(viewLocal.z),
+prepared.refractionEtaTOverEtaI
+);
+response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+* am(
+material,
+viewLocal,
+kM,
+dd,
+tint * (vec3f(1.0) - gf),
+&aH
+);
+}
+else {
+response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]
+* dk(
+material,
+material.relativeIor,
+bn(material),
+viewLocal,
+lightLocal,
+V,
+cK,
+&aH
+);
+}
+if (prepared.dielectricMsProbability > 0.0) {
+aH *= 1.0 - prepared.dielectricMsProbability;
+}
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * aH;
+}
+if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && oI) {
+if (material.thinWalled) {
+let nT = vec3f(lightLocal.xy, -lightLocal.z);
+response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]
+* cD(
+material,
+material.subsurfaceColor,
+viewLocal,
+nT,
+diffuseSpecularEnergyCompensation,
+&aH
+);
+aH *= 0.5;
+}
+else {
+response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * dL(
+material,
+viewLocal,
+lightLocal,
+&aH
+);
+}
+*pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * aH;
+}
+}
+
+
+
+
+if (prepared.dielectricMsProbability > 0.0 && jz) {
+let au = abs(lightLocal.z);
+if (au > 0.0) {
+let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);
+let iU = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);
+let td = prepared.dielectricMsViewLoss * bO(ior, prepared.specularAlpha, au)
+/ max(cO(ior, prepared.specularAlpha), 1e-12);
+let dW = min(td * iU, 1.0 / au);
+let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);
+response += scale * dW * INVPI;
+*pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * iU * 0.5 * INVPI;
+}
+}
+
+${hasCoatNormals ? /* wgsl */ `    } ` : ''}
+if (material.coatWeight > 0.0) {
+response *= ds(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});
+}
+${hasCoatNormals ? /* wgsl */ `
+
+if (independentCoat) { response *= abs(lightLocal.z); }
+` : ''}
+
+${hasAnisotropyDirections ? /* wgsl */ `
+if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
+var dH = viewLocal;
+var kt = lightLocal;
+var gq = V;
+var jD = bQ;
+if (prepared.directionFrames) {
+dH = ${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))'};
+kt = openpbr_to_local(prepared.coatBasis, lightDirection);
+gq = normalize(kt + dH);
+if (gq.z < 0.0) { gq = -gq; }
+jD = abs(dot(dH, gq));
+}
+
+let kU = vec3f(af(
+jD,
+1.0 / material.coatIor
+));
+var dG = material;
+let jp = aJ(material.coatRoughness, material.coatAnisotropy);
+dG.alphaX = jp.x;
+dG.alphaY = jp.y;
+if (sQ) {
+response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
+dG,
+dH,
+kt,
+gq,
+kU,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aH;
+}
+}
+` : /* wgsl */ `
+if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {
+let kU = vec3f(af(
+bQ,
+1.0 / material.coatIor
+));
+var dG = material;
+let jp = aJ(material.coatRoughness, material.coatAnisotropy);
+dG.alphaX = jp.x;
+dG.alphaY = jp.y;
+if (sQ) {
+response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * am(
+dG,
+viewLocal,
+lightLocal,
+V,
+kU,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * aH;
+}
+}
+`}
+
+if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {
+let qn = aO(
+abs(viewLocal.z),
+material.fuzzRoughness
+);
+response *= max(
+vec3f(0.0),
+vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qn)
+);
+if (uz) {
+response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * jP(
+material,
+viewLocal,
+lightLocal,
+&aH
+);
+*pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * aH;
+}
+}
+
+return response * ${hasCoatNormals ? 'select(abs(lightLocal.z), 1.0, independentCoat)' : 'abs(lightLocal.z)'};
+}
+
+fn bI(
+prepared: ag,
+lightDirection: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+return mq(prepared, lightDirection, -1, pdf);
+}
+
+
+
+
+
+fn qU(
+tangent: vec3f,
+material: J,
+bF: vec3f,
+normal: vec3f,
+lightDirection: vec3f,
+pdf: ptr<function, f32>
+) -> vec3f {
+let prepared = eG(
+tangent,
+material,
+bF,
+normal
+);
+return bI(prepared, lightDirection, pdf);
+}
+
+
+
+
+
+fn mV(
+prepared: ag, cl: vec3f,
+lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,
+aA: ptr<function, f32>, aT: ptr<function, bool>,
+bE: ptr<function, bool>, aR: ptr<function, u32>
+) -> bool {
+let material = prepared.material;
+let viewLocal = prepared.viewLocal;
+var cx = cl.x;
+let fp = cl.y;
+let bm = cl.z;
+*isTransmissionEvent = false;
+*aA = 1.0;
+*aT = false;
+*bE = false;
+*aR = 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 nr = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));
+for (var hR = 1; hR < nr; hR++) {
+cdf[hR] = cdf[hR - 1] + prepared.probabilities[hR];
+}
+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]
+)) {
+let pv = bm < cdf[OPENPBR_LOBE_FUZZ];
+*aA = select(
+1.0,
+material.fuzzRoughness,
+pv
+);
+*bE = !pv;
+*aR = select(
+u32(OPENPBR_LOBE_DIFFUSE),
+u32(OPENPBR_LOBE_FUZZ),
+pv
+);
+lightLocal = bi(vec2f(cx, fp));
+}
+${hasAnisotropyDirections ? /* wgsl */ `
+else if (bm < cdf[OPENPBR_LOBE_COAT]) {
+*aA = material.coatRoughness;
+*aT = true;
+*aR = u32(OPENPBR_LOBE_COAT);
+var dH = viewLocal;
+if (prepared.directionFrames) { dH = ${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(
+dH,
+
+aJ(material.coatRoughness, material.coatAnisotropy),
+vec2f(cx, fp)
+);
+if (V.z < 0.0) {
+V = -V;
+}
+lightLocal = normalize(reflect(-dH, V));
+${hasCoatNormals ? /* wgsl */ `
+if (material.coatNormalEnabled) {
+
+*lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);
+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;
+*aT = true;
+*aR = u32(OPENPBR_LOBE_COAT);
+var V = aQ(
+viewLocal,
+
+aJ(material.coatRoughness, material.coatAnisotropy),
+vec2f(cx, fp)
+);
+if (V.z < 0.0) {
+V = -V;
+}
+lightLocal = normalize(reflect(-viewLocal, V));
+}
+`}
+else if (bm < cdf[OPENPBR_LOBE_SPECULAR]) {
+*aA = material.specularRoughness;
+*aT = true;
+*aR = select(
+u32(OPENPBR_LOBE_SPECULAR),
+u32(OPENPBR_LOBE_METAL),
+bm < cdf[OPENPBR_LOBE_METAL]
+);
+let tg = bm < cdf[OPENPBR_LOBE_METAL];
+let rw = (bm - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);
+if (tg && rw < prepared.metalMsProbability) {
+let z = cx;
+let fi = sqrt(max(0.0, 1.0 - z * z));
+let br = TWOPI * fp;
+lightLocal = vec3f(fi * cos(br), fi * sin(br), z);
+}
+else {
+var V = aQ(
+viewLocal,
+vec2f(material.alphaX, material.alphaY),
+vec2f(cx, fp)
+);
+if (V.z < 0.0) {
+V = -V;
+}
+lightLocal = normalize(reflect(-viewLocal, V));
+}
+}
+else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
+*aA = material.specularRoughness;
+*aT = true;
+*isTransmissionEvent = true;
+*aR = u32(OPENPBR_LOBE_TRANSMISSION);
+
+
+let ue = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && ue < prepared.dielectricMsProbability) {
+let iU = prepared.dielectricMsReflectionRatio;
+let lM = cx < iU;
+var z: f32;
+if (lM) { z = min(cx / iU, 0.99999994); }
+else { z = -min((cx - iU) / (1.0 - iU), 0.99999994); }
+let fi = sqrt(max(0.0, 1.0 - z * z));
+let br = TWOPI * fp;
+lightLocal = vec3f(fi * cos(br), fi * sin(br), z);
+*isTransmissionEvent = !lM;
+*aR = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), lM);
+}
+else {
+var V = aQ(
+viewLocal,
+vec2f(material.alphaX, material.alphaY),
+vec2f(cx, fp)
+);
+if (V.z < 0.0) {
+V = -V;
+}
+if (material.thinWalled) {
+let hW = normalize(reflect(-viewLocal, V));
+lightLocal = vec3f(hW.xy, -hW.z);
+}
+else {
+lightLocal = refract(
+-viewLocal,
+V,
+prepared.material.relativeIor
+);
+if (dot(lightLocal, lightLocal) <= 1e-8) {
+*isTransmissionEvent = false;
+return false;
+}
+lightLocal = normalize(lightLocal);
+}
+}
+}
+else {
+*aA = 1.0;
+*bE = true;
+*isTransmissionEvent = true;
+*aR = u32(OPENPBR_LOBE_SUBSURFACE);
+if (material.thinWalled) {
+let pH = cx >= 0.5;
+if (pH) {
+cx = (cx - 0.5) * 2.0;
+}
+else {
+cx *= 2.0;
+}
+lightLocal = bi(vec2f(cx, fp));
+if (pH) {
+lightLocal.z = -lightLocal.z;
+}
+else {
+*isTransmissionEvent = false;
+}
+}
+else {
+lightLocal = bi(vec2f(cx, fp));
+lightLocal.z = -lightLocal.z;
+}
+}
+
+*lightDirection = openpbr_to_world(prepared.basis, lightLocal);
+
+
+
+if (lightLocal.z == 0.0 || (lightLocal.z < 0.0) != *isTransmissionEvent) {
+return false;
+}
+${hasCoatNormals ? /* wgsl */ `
+if (material.coatNormalEnabled &&
+((dot(material.geometricNormal, *lightDirection) <= 0.0) != *isTransmissionEvent)) { return false; }
+` : ''}
+return true;
+}
+
+fn dv(
+prepared: ag,
+cl: vec3f,
+lightDirection: ptr<function, vec3f>,
+pdf: ptr<function, f32>,
+isTransmissionEvent: ptr<function, bool>,
+aA: ptr<function, f32>,
+aT: ptr<function, bool>,
+bE: ptr<function, bool>,
+aR: ptr<function, u32>,
+la: ptr<function, f32>,
+gR: ptr<function, vec3f>
+) -> vec3f {
+*pdf = 0.0;
+*la = 0.0;
+*gR = vec3f(0.0);
+
+
+
+
+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 nu = bn(prepared.material)
+* ds(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});
+*pdf = 1.0;
+*la = 1.0;
+*gR = nu;
+*isTransmissionEvent = true;
+*aA = 0.0;
+*aT = true;
+*bE = false;
+*aR = u32(OPENPBR_LOBE_TRANSMISSION);
+return nu;
+}
+if (!mV(prepared, cl, lightDirection,
+isTransmissionEvent, aA, aT,
+bE, aR)) { return vec3f(0.0); }
+let response = bI(prepared, *lightDirection, pdf);
+*la = *pdf;
+*gR = response;
+return response;
+}
+
+fn su(
+tangent: vec3f,
+material: J,
+cl: vec3f,
+bF: vec3f,
+normal: vec3f,
+lightDirection: ptr<function, vec3f>,
+pdf: ptr<function, f32>,
+isTransmissionEvent: ptr<function, bool>,
+aA: ptr<function, f32>,
+aT: ptr<function, bool>,
+bE: ptr<function, bool>,
+aR: ptr<function, u32>,
+la: ptr<function, f32>
+) -> vec3f {
+let prepared = eG(
+tangent,
+material,
+bF,
+normal
+);
+var gR = vec3f(0.0);
+return dv(
+prepared,
+cl,
+lightDirection,
+pdf,
+isTransmissionEvent,
+aA,
+aT,
+bE,
+aR,
+la,
+&gR
+);
+}`;
+}
+export default createOpenPbrBsdfWgsl();
+//# sourceMappingURL=openPbrBsdf.wgsl.js.map