@meimu/mutracer 0.1.5 → 0.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"openPbrBsdf.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/openPbrBsdf.wgsl.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * OpenPBR energy-compensation, EON and thin-film portions Copyright 2026 Adobe.\n * Licensed under the Apache License, Version 2.0.\n * https://www.apache.org/licenses/LICENSE-2.0\n */\n\n/*\n * Renderer-specific OpenPBR layered BSDF.\n *\n * The prepare/eval/sample/pdf organization and fixed-lobe composition follow:\n * - https://github.com/adobe/openpbr-bsdf\n * - https://github.com/portsmouth/OpenPBR-viewer\n *\n * This compact GPU implementation reuses the renderer's GGX VNDF and volume\n * integrator. Adobe's opaque-dielectric energy tables are used for the base\n * rough-diffuse/specular coupling; fuzz still uses an analytic approximation.\n */\n\nimport { 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';\n\nexport function createOpenPbrBsdfWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {\n  return /* wgsl */ `\nconst OPENPBR_LOBE_FUZZ: i32 = 0;\nconst OPENPBR_LOBE_COAT: i32 = 1;\nconst OPENPBR_LOBE_METAL: i32 = 2;\nconst OPENPBR_LOBE_SPECULAR: i32 = 3;\nconst OPENPBR_LOBE_TRANSMISSION: i32 = 4;\nconst OPENPBR_LOBE_DIFFUSE: i32 = 5;\nconst OPENPBR_LOBE_SUBSURFACE: i32 = 6;\nconst OPENPBR_LOBE_COUNT: i32 = 7;\n\nstruct OpenPbrBasis {\n    tangent: vec3f,\n    bitangent: vec3f,\n    normal: vec3f,\n};\n\nstruct OpenPbrPreparedBsdf {\n    material: OpenPbrResolvedMaterial,\n    basis: OpenPbrBasis,\n${hasAnisotropyDirections ? /* wgsl */ `\n    coatBasis: OpenPbrBasis,\n    directionFrames: bool,\n` : /* wgsl */ ``}\n${hasCoatNormals ? /* wgsl */ `    coatViewLocal: vec3f,` : ''}\n    viewLocal: vec3f,\n    diffuseColor: vec3f,\n    specularEtaTOverEtaI: f32,\n    refractionEtaTOverEtaI: f32,\n    transmissionReflectionIor: f32,\n    thinFilmExteriorIor: f32,\n    thinFilmBaseIor: f32,\n    specularAlpha: f32,\n    diffuseSpecularEnergyCompensation: f32,\n    coatBaseScale: vec3f,\n    metalMsScale: vec3f,\n    metalMsFactor: f32,\n    metalMsProbability: f32,\n\n    dielectricMsReflectionScale: vec3f,\n    dielectricMsTransmissionScale: vec3f,\n    dielectricMsViewLoss: f32,\n    dielectricMsReflectionRatio: f32,\n    dielectricMsProbability: f32,\n\n    weights: array<f32, OPENPBR_LOBE_COUNT>,\n    probabilities: array<f32, OPENPBR_LOBE_COUNT>,\n};\n\nfn openpbr_luminance(color: vec3f) -> f32 {\n    return dot(color, vec3f(0.212671, 0.715160, 0.072169));\n}\n\nfn openpbr_f0_from_ior(etaTOverEtaI: f32) -> f32 {\n    let value = (etaTOverEtaI - 1.0) / (etaTOverEtaI + 1.0);\n    return value * value;\n}\n\nfn openpbr_apply_specular_weight_to_ior(\n    etaTOverEtaI: f32,\n    specularWeight: f32\n) -> f32 {\n    let scaledF0 = min(\n        openpbr_f0_from_ior(etaTOverEtaI) * specularWeight,\n        0.9999\n    );\n    let sqrtF0 = sqrt(scaledF0);\n    let externalIor = (1.0 + sqrtF0) / (1.0 - sqrtF0);\n    return select(externalIor, 1.0 / externalIor, etaTOverEtaI < 1.0);\n}\n\nfn openpbr_dielectric_fresnel(cosTheta: f32, relativeIor: f32) -> f32 {\n    if (abs(relativeIor - 1.0) < 1e-6) {\n        return 0.0;\n    }\n    return sampling_dielectric_fresnel(cosTheta, relativeIor);\n}\n\nfn openpbr_energy_ior_index(ior: f32) -> f32 {\n    if (ior < 1.0) {\n        return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;\n    }\n    return 16.0 + ((ior - 1.0) / 1.5) * 15.0;\n}\n\nfn openpbr_energy_fetch(cosIndex: i32, row: i32) -> f32 {\n    return textureLoad(openPbrEnergyLut, vec2i(cosIndex, row), 0).r;\n}\n\nfn openpbr_energy_trilinear(\n    exactIor: f32,\n    exactAlpha: f32,\n    exactCosine: f32\n) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let cosineIndex = clamp(exactCosine, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let cosine0 = i32(floor(cosineIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let cosine1 = min(cosine0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let cosineMix = cosineIndex - f32(cosine0);\n\n    let v000 = openpbr_energy_fetch(cosine0, ior0 * 32 + alpha0);\n    let v001 = openpbr_energy_fetch(cosine1, ior0 * 32 + alpha0);\n    let v010 = openpbr_energy_fetch(cosine0, ior0 * 32 + alpha1);\n    let v011 = openpbr_energy_fetch(cosine1, ior0 * 32 + alpha1);\n    let v100 = openpbr_energy_fetch(cosine0, ior1 * 32 + alpha0);\n    let v101 = openpbr_energy_fetch(cosine1, ior1 * 32 + alpha0);\n    let v110 = openpbr_energy_fetch(cosine0, ior1 * 32 + alpha1);\n    let v111 = openpbr_energy_fetch(cosine1, ior1 * 32 + alpha1);\n    let v00 = mix(v000, v100, iorMix);\n    let v01 = mix(v001, v101, iorMix);\n    let v10 = mix(v010, v110, iorMix);\n    let v11 = mix(v011, v111, iorMix);\n    return mix(\n        mix(v00, v10, alphaMix),\n        mix(v01, v11, alphaMix),\n        cosineMix\n    );\n}\n\nfn openpbr_energy_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, 1024 + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, 1024 + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, 1024 + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, 1024 + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\n// Adobe c91aad1 ideal dielectric tables clamp IOR indices; unlike opaque\n// dielectric data they do not extrapolate outside [0.4, 2.5].\nfn openpbr_ideal_energy_trilinear(\n    exactIor: f32,\n    exactAlpha: f32,\n    exactCosine: f32\n) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let cosineIndex = clamp(exactCosine, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let cosine0 = i32(floor(cosineIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let cosine1 = min(cosine0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let cosineMix = cosineIndex - f32(cosine0);\n\n    let v000 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha0);\n    let v001 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha0);\n    let v010 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha1);\n    let v011 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha1);\n    let v100 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha0);\n    let v101 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha0);\n    let v110 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha1);\n    let v111 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha1);\n    let v00 = mix(v000, v100, iorMix);\n    let v01 = mix(v001, v101, iorMix);\n    let v10 = mix(v010, v110, iorMix);\n    let v11 = mix(v011, v111, iorMix);\n    return mix(\n        mix(v00, v10, alphaMix),\n        mix(v01, v11, alphaMix),\n        cosineMix\n    );\n}\n\nfn openpbr_ideal_average_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\nfn openpbr_ideal_ratio_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\nfn openpbr_ideal_dielectric_loss(ior: f32, alpha: f32, cosine: f32) -> f32 {\n    return openpbr_ideal_energy_trilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0, cosine * 31.0);\n}\nfn openpbr_ideal_dielectric_average_loss(ior: f32, alpha: f32) -> f32 {\n    return openpbr_ideal_average_bilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0);\n}\nfn openpbr_ideal_dielectric_reflection_ratio(ior: f32, alpha: f32) -> f32 {\n    return openpbr_ideal_ratio_bilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0);\n}\n\n// Adobe openpbr_microfacet_multiple_scattering_{data,lobes}.h (c91aad1):\n// ideal-metal loss E=1-singleScatterEnergy, indexed by sqrt(alpha) and cosine.\nfn openpbr_metal_energy_complement(alpha: f32, cosine: f32) -> f32 {\n    let roughnessIndex = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);\n    let cosineIndex = clamp(cosine * 31.0, 0.0, 31.0);\n    let r0 = i32(floor(roughnessIndex));\n    let c0 = i32(floor(cosineIndex));\n    let r1 = min(r0 + 1, 31);\n    let c1 = min(c0 + 1, 31);\n    return mix(\n        mix(openpbr_energy_fetch(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), openpbr_energy_fetch(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(cosineIndex)),\n        mix(openpbr_energy_fetch(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), openpbr_energy_fetch(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(cosineIndex)),\n        fract(roughnessIndex));\n}\n\nfn openpbr_metal_average_energy_complement(alpha: f32) -> f32 {\n    let index = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);\n    let i0 = i32(floor(index));\n    return mix(openpbr_energy_fetch(i0, ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}),\n        openpbr_energy_fetch(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));\n}\n\nfn openpbr_extrapolate_energy_complement(value: f32, ior: f32) -> f32 {\n    if (ior > 2.5 || ior < 0.4) {\n        let maxF0 = openpbr_f0_from_ior(2.5);\n        let progress = (openpbr_f0_from_ior(ior) - maxF0) / (1.0 - maxF0);\n        return (1.0 - progress) * value;\n    }\n    return value;\n}\n\nfn openpbr_opaque_energy_complement(\n    ior: f32,\n    alpha: f32,\n    cosine: f32\n) -> f32 {\n    let value = openpbr_energy_trilinear(\n        openpbr_energy_ior_index(ior),\n        sqrt(alpha) * 31.0,\n        cosine * 31.0\n    );\n    return openpbr_extrapolate_energy_complement(value, ior);\n}\n\nfn openpbr_opaque_average_energy_complement(ior: f32, alpha: f32) -> f32 {\n    let value = openpbr_energy_bilinear(\n        openpbr_energy_ior_index(ior),\n        sqrt(alpha) * 31.0\n    );\n    return openpbr_extrapolate_energy_complement(value, ior);\n}\n\nfn openpbr_to_world(basis: OpenPbrBasis, direction: vec3f) -> vec3f {\n    return direction.x * basis.tangent\n        + direction.y * basis.bitangent\n        + direction.z * basis.normal;\n}\n\nfn openpbr_to_local(basis: OpenPbrBasis, direction: vec3f) -> vec3f {\n    return vec3f(\n        dot(direction, basis.tangent),\n        dot(direction, basis.bitangent),\n        dot(direction, basis.normal)\n    );\n}\n\nfn openpbr_make_basis(\n    inputTangent: vec3f,\n    normal: vec3f,\n    anisotropy: f32\n) -> OpenPbrBasis {\n    var basis: OpenPbrBasis;\n    basis.normal = normal;\n    var tangent = inputTangent;\n    var bitangent = vec3f(0.0);\n    if (dot(tangent, tangent) < 0.001 || anisotropy <= 0.0) {\n        sampling_orthonormal_basis(normal, &tangent, &bitangent);\n    }\n    else {\n        bitangent = normalize(cross(normal, tangent));\n        tangent = normalize(cross(bitangent, normal));\n    }\n    basis.tangent = tangent;\n    basis.bitangent = bitangent;\n    return basis;\n}\n\nfn openpbr_fresnel_s(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return (incidentIor * incidentCosine - transmittedIor * transmittedCosine)\n        / (incidentIor * incidentCosine + transmittedIor * transmittedCosine);\n}\n\nfn openpbr_fresnel_p(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return (transmittedIor * incidentCosine - incidentIor * transmittedCosine)\n        / (incidentIor * transmittedCosine + transmittedIor * incidentCosine);\n}\n\nfn openpbr_transmission_s(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return 2.0 * incidentIor * incidentCosine\n        / (incidentIor * incidentCosine + transmittedIor * transmittedCosine);\n}\n\nfn openpbr_transmission_p(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return 2.0 * incidentIor * incidentCosine\n        / (incidentIor * transmittedCosine + transmittedIor * incidentCosine);\n}\n\nfn openpbr_complex_multiply(a: vec2f, b: vec2f) -> vec2f {\n    return vec2f(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);\n}\n\nfn openpbr_complex_divide(a: vec2f, b: vec2f) -> vec2f {\n    let denominator = max(dot(b, b), 1e-9);\n    return vec2f(\n        (a.x * b.x + a.y * b.y) / denominator,\n        (a.y * b.x - a.x * b.y) / denominator\n    );\n}\n\nfn openpbr_complex_sqrt(value: vec2f) -> vec2f {\n    let magnitude = length(value);\n    let realPart = sqrt(max(0.0, 0.5 * (magnitude + value.x)));\n    let imaginaryMagnitude = sqrt(max(0.0, 0.5 * (magnitude - value.x)));\n    return vec2f(realPart, select(-imaginaryMagnitude, imaginaryMagnitude, value.y >= 0.0));\n}\n\nfn openpbr_complex_fresnel_reflection(\n    incidentCosine: f32,\n    incidentIor: f32,\n    transmittedIor: vec2f,\n    pPolarized: bool\n) -> vec2f {\n    let incidentSine = sqrt(max(0.0, 1.0 - incidentCosine * incidentCosine));\n    let iorRatio = openpbr_complex_divide(vec2f(incidentIor, 0.0), transmittedIor);\n    let transmittedSine = iorRatio * incidentSine;\n    var transmittedCosine = openpbr_complex_sqrt(\n        vec2f(1.0, 0.0) - openpbr_complex_multiply(transmittedSine, transmittedSine)\n    );\n    if (openpbr_complex_multiply(transmittedIor, transmittedCosine).y < 0.0) {\n        transmittedCosine = -transmittedCosine;\n    }\n\n    let incidentIorCosine = vec2f(incidentIor * incidentCosine, 0.0);\n    let transmittedIorCosine = openpbr_complex_multiply(transmittedIor, transmittedCosine);\n    if (pPolarized) {\n        let transmittedIorIncidentCosine = transmittedIor * incidentCosine;\n        let incidentIorTransmittedCosine = transmittedCosine * incidentIor;\n        return openpbr_complex_divide(\n            transmittedIorIncidentCosine - incidentIorTransmittedCosine,\n            transmittedIorIncidentCosine + incidentIorTransmittedCosine\n        );\n    }\n    return openpbr_complex_divide(\n        incidentIorCosine - transmittedIorCosine,\n        incidentIorCosine + transmittedIorCosine\n    );\n}\n\nfn openpbr_airy_reflectance(\n    reflection12: f32,\n    transmission12: f32,\n    reflection21: f32,\n    transmission21: f32,\n    reflection23: vec2f,\n    phase: f32\n) -> f32 {\n    let phaseRotation = vec2f(cos(phase), sin(phase));\n    let reflectedPhase = openpbr_complex_multiply(reflection23, phaseRotation);\n    let numerator = reflectedPhase * (transmission12 * transmission21);\n    let denominator = vec2f(1.0, 0.0) - reflectedPhase * reflection21;\n    let totalReflection = vec2f(reflection12, 0.0)\n        + openpbr_complex_divide(numerator, denominator);\n    return dot(totalReflection, totalReflection);\n}\n\nfn openpbr_thin_film_reflectance_channel(\n    incidentCosine: f32,\n    wavelength: f32,\n    thickness: f32,\n    exteriorIor: f32,\n    filmIor: f32,\n    substrateIor: vec2f\n) -> f32 {\n    let safeIncidentCosine = clamp(abs(incidentCosine), 1e-5, 1.0);\n    let filmSineSquared = pow(exteriorIor / filmIor, 2.0)\n        * (1.0 - safeIncidentCosine * safeIncidentCosine);\n    if (filmSineSquared >= 1.0) {\n        return 1.0;\n    }\n    let filmCosine = sqrt(1.0 - filmSineSquared);\n    let reflection12S = openpbr_fresnel_s(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let reflection12P = openpbr_fresnel_p(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission12S = openpbr_transmission_s(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission12P = openpbr_transmission_p(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission21Scale = filmIor * filmCosine\n        / max(exteriorIor * safeIncidentCosine, 1e-9);\n    let phase = 2.0 * PI * (2.0 * filmIor * thickness * filmCosine) / wavelength;\n    var reflectance = 0.0;\n    // Both polarizations share Snell's complex solve and the Airy graph.\n    for (var polarization = 0u; polarization < (rtUniform.loopUnrollGuard >> 1u); polarization++) {\n        let reflection12 = select(reflection12S, reflection12P, polarization == 1u);\n        let transmission12 = select(transmission12S, transmission12P, polarization == 1u);\n        let reflection23 = openpbr_complex_fresnel_reflection(\n            filmCosine, filmIor, substrateIor, polarization == 1u);\n        reflectance += openpbr_airy_reflectance(reflection12, transmission12,\n            -reflection12, transmission12 * transmission21Scale, reflection23, phase);\n    }\n    return clamp(0.5 * reflectance, 0.0, 1.0);\n}\n\n\n// OpenPBR 1.1.1 Metal: analytic F82-tint correction to Schlick.\n// Saturation follows Adobe impl/openpbr_lobe_utils.h, openpbr_metal_schlick_with_f82_tint.\nfn openpbr_metal_fresnel(cosine: f32, f0: vec3f, tint: vec3f) -> vec3f {\n    let schlick = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(cosine));\n    if (all(tint == vec3f(1.0))) { return schlick; }\n    let edgeCosine = 1.0 / 7.0;\n    let edgeComplement = 1.0 - edgeCosine;\n    let edgeFresnel = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(edgeCosine));\n    let complement = 1.0 - cosine;\n    let correction = cosine * sampling_schlick_fifth_power(cosine) * complement\n        / (edgeCosine * pow(edgeComplement, 6.0));\n    return clamp(schlick - correction * (edgeFresnel - tint * edgeFresnel), vec3f(0.0), vec3f(1.0));\n}\n\nfn openpbr_metal_complex_ior(f0: f32, f82Tint: f32) -> vec2f {\n    let reflectivity = clamp(f0, 0.0, 0.99);\n    let sqrtReflectivity = sqrt(reflectivity);\n    let minimumIor = (1.0 - reflectivity) / (1.0 + reflectivity);\n    let maximumIor = (1.0 + sqrtReflectivity) / max(1.0 - sqrtReflectivity, 1e-9);\n    let ior = mix(maximumIor, minimumIor, clamp(f82Tint, 0.0, 1.0));\n    let extinctionSquared = (\n        (ior + 1.0) * (ior + 1.0) * reflectivity\n        - (ior - 1.0) * (ior - 1.0)\n    ) / max(1.0 - reflectivity, 1e-9);\n    return vec2f(ior, sqrt(max(extinctionSquared, 0.0)));\n}\n\n\nfn openpbr_thin_film_presence(thickness: f32, weight: f32) -> f32 {\n    return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, thickness);\n}\n\n\n\nfn openpbr_eval_diffuse(\n    material: OpenPbrResolvedMaterial,\n    color: vec3f,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    specularEnergyCompensation: f32,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z <= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let roughness = material.diffuseRoughness;\n    let fonConstantA = 0.5 - 2.0 / (3.0 * PI);\n    let fonConstantB = 2.0 / 3.0 - 28.0 / (15.0 * PI);\n    let muInput = lightLocal.z;\n    let muOutput = viewLocal.z;\n    let directional = dot(lightLocal, viewLocal) - muInput * muOutput;\n    let directionalOverTangent = select(\n        directional,\n        directional / max(max(muInput, muOutput), 1e-7),\n        directional > 0.0\n    );\n    let singleScatterA = 1.0 / (1.0 + fonConstantA * roughness);\n    let singleScatter = color * INVPI * singleScatterA\n        * (1.0 + roughness * directionalOverTangent);\n\n    let inputComplement = 1.0 - muInput;\n    let outputComplement = 1.0 - muOutput;\n    let inputGOverPi = inputComplement * (\n        0.0571085289 + inputComplement * (\n            0.491881867 + inputComplement * (\n                -0.332181442 + inputComplement * 0.0714429953\n            )\n        )\n    );\n    let outputGOverPi = outputComplement * (\n        0.0571085289 + outputComplement * (\n            0.491881867 + outputComplement * (\n                -0.332181442 + outputComplement * 0.0714429953\n            )\n        )\n    );\n    let inputAlbedo = (1.0 + roughness * inputGOverPi)\n        / (1.0 + fonConstantA * roughness);\n    let outputAlbedo = (1.0 + roughness * outputGOverPi)\n        / (1.0 + fonConstantA * roughness);\n    let averageAlbedo = singleScatterA * (1.0 + fonConstantB * roughness);\n    let multipleScatterAlbedo = color * color * averageAlbedo\n        / max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - averageAlbedo));\n    let multipleScatter = multipleScatterAlbedo * INVPI\n        * max(1e-7, 1.0 - outputAlbedo)\n        * max(1e-7, 1.0 - inputAlbedo)\n        / max(1e-7, 1.0 - averageAlbedo);\n    *pdf = lightLocal.z * INVPI;\n    return (singleScatter + multipleScatter) * specularEnergyCompensation;\n}\n\nfn openpbr_fuzz_directional_albedo(viewCosine: f32, roughness: f32) -> f32 {\n    let x = clamp(viewCosine, 0.0, 1.0);\n    let y = clamp(roughness, 0.01, 1.0);\n    let scale = y * (0.0206607 + 1.58491 * y)\n        / (0.0379424 + y * (1.32227 + y));\n    let mean = y * (-0.193854 + y * (-1.14885 + y * (1.7932 - 0.95943 * y * y)))\n        / (0.046391 + y);\n    let offset = y * (0.000654023 + (-0.0207818 + 0.119681 * y) * y)\n        / (1.26264 + y * (-1.92021 + y));\n    let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))\n        / (scale * sqrt(2.0 * PI));\n    return max(gaussian + offset, 0.0);\n}\n\nfn openpbr_eval_fuzz(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (viewLocal.z <= 0.0 || lightLocal.z <= 0.0) {\n        return vec3f(0.0);\n    }\n    let albedo = openpbr_fuzz_directional_albedo(\n        viewLocal.z,\n        material.fuzzRoughness\n    );\n    *pdf = lightLocal.z * INVPI;\n    return material.fuzzColor * albedo * INVPI;\n}\n\nfn openpbr_eval_microfacet_reflection(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    halfVector: vec3f,\n    fresnel: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z <= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let alpha = vec2f(material.alphaX, material.alphaY);\n    let distribution = sampling_ggx_ndf(halfVector, alpha);\n    let masking = sampling_ggx_smith_g1(viewLocal, alpha);\n    let maskingShadowing = masking\n        * sampling_ggx_smith_g1(lightLocal, alpha);\n\n    *pdf = masking * distribution / (4.0 * max(viewLocal.z, 1e-8));\n    return fresnel * distribution * maskingShadowing\n        / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));\n}\n\nfn openpbr_eval_microfacet_refraction(\n    material: OpenPbrResolvedMaterial,\n    relativeIor: f32,\n    tint: vec3f,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    halfVector: vec3f,\n    fresnel: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z >= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let lightHalf = dot(lightLocal, halfVector);\n    let viewHalf = dot(viewLocal, halfVector);\n    // A refracting microfacet must face the view and the opposite side of the\n    // light. Backfacing configurations have no support in the VNDF proposal.\n    if (viewHalf <= 0.0 || lightHalf >= 0.0) {\n        return vec3f(0.0);\n    }\n    let alpha = vec2f(material.alphaX, material.alphaY);\n    let distribution = sampling_ggx_ndf(halfVector, alpha);\n    let masking = sampling_ggx_smith_g1(viewLocal, alpha);\n    let maskingShadowing = masking\n        * sampling_ggx_smith_g1(lightLocal, alpha);\n    var denominator = lightHalf + viewHalf * relativeIor;\n    denominator *= denominator;\n    let jacobian = abs(lightHalf) / max(denominator, 1e-8);\n    let relativeIorSquared = relativeIor * relativeIor;\n\n    *pdf = masking * max(0.0, viewHalf) * distribution * jacobian\n        / max(viewLocal.z, 1e-8);\n    return tint * (vec3f(1.0) - fresnel) * distribution * maskingShadowing\n        * abs(viewHalf) * jacobian * relativeIorSquared\n        / max(abs(lightLocal.z * viewLocal.z), 1e-8);\n}\n\nfn openpbr_transmission_tint(material: OpenPbrResolvedMaterial) -> vec3f {\n    if (HAS_MEDIUM && material.mediumType > 0) {\n        return vec3f(1.0);\n    }\n    return material.transmissionColor;\n}\n\nfn openpbr_thin_wall_fresnel(singleInterfaceFresnel: f32) -> f32 {\n    return 2.0 * singleInterfaceFresnel / (1.0 + singleInterfaceFresnel);\n}\n\nfn openpbr_thin_wall_reflection_coefficient(\n    singleInterfaceFresnel: vec3f,\n    transmissionWeight: f32\n) -> vec3f {\n    let windowFresnel = 2.0 * singleInterfaceFresnel\n        / (vec3f(1.0) + singleInterfaceFresnel);\n    return mix(\n        singleInterfaceFresnel,\n        windowFresnel,\n        clamp(transmissionWeight, 0.0, 1.0)\n    );\n}\n\nfn openpbr_final_transmission_tint(\n    material: OpenPbrResolvedMaterial,\n    incidentCosine: f32,\n    etaTOverEtaI: f32\n) -> vec3f {\n    let tint = openpbr_transmission_tint(material);\n    if (!material.thinWalled) {\n        return tint;\n    }\n    let incidentSineSquared = max(0.0, 1.0 - incidentCosine * incidentCosine);\n    let transmittedSineSquared = incidentSineSquared\n        / max(etaTOverEtaI * etaTOverEtaI, 1e-9);\n    if (transmittedSineSquared >= 1.0) {\n        return vec3f(0.0);\n    }\n    let transmittedCosine = sqrt(1.0 - transmittedSineSquared);\n    return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(transmittedCosine, 1e-5)));\n}\n\nfn openpbr_eval_subsurface_boundary(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (viewLocal.z <= 0.0 || lightLocal.z >= 0.0) {\n        return vec3f(0.0);\n    }\n    let transmittedCosine = -lightLocal.z;\n    let entryFresnel = sampling_dielectric_fresnel(\n        viewLocal.z,\n        material.relativeIor\n    );\n    *pdf = transmittedCosine * INVPI;\n    return vec3f(1.0 - entryFresnel) * INVPI;\n}\n\nfn openpbr_normalize_probabilities(prepared: ptr<function, OpenPbrPreparedBsdf>) {\n    // loopUnrollGuard is 4; the dynamic bound covers all seven lobes without\n    // asking the driver to unroll array operations across the full BSDF.\n    let lobeCount = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));\n    var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];\n    for (var lobe = 1; lobe < lobeCount; lobe++) {\n        total += (*prepared).probabilities[lobe];\n    }\n    if (total <= 1e-8) {\n        for (var lobe = 0; lobe < lobeCount; lobe++) {\n            (*prepared).probabilities[lobe] = 0.0;\n        }\n        return;\n    }\n    let inverseTotal = 1.0 / total;\n    for (var lobe = 0; lobe < lobeCount; lobe++) {\n        (*prepared).probabilities[lobe] *= inverseTotal;\n    }\n}\n\n// Adapted from Adobe c91aad1 impl/openpbr_lobe_utils.h and\n// impl/openpbr_bsdf.h::openpbr_prepare_lobes (Apache-2.0).\nfn openpbr_average_fresnel(eta: f32) -> f32 {\n    if (abs(eta - 1.0) < 1e-6) { return 0.0; }\n    if (eta > 1.0) { return (eta - 1.0) / (4.08567 + 1.00071 * eta); }\n    return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * eta;\n}\n\nfn openpbr_metal_average_fresnel(f0: vec3f, tint: vec3f) -> vec3f {\n    let edgeCosine = 1.0 / 7.0;\n    let edgeFresnel = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(edgeCosine));\n    let b = edgeFresnel * (vec3f(1.0) - tint) / (edgeCosine * pow(1.0 - edgeCosine, 6.0));\n    return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));\n}\n\n// Adobe openpbr_coating_lobe.h: one passage, using the refracted cosine.\n// Partial coverage is mixed separately for each passage, as in the reference.\nfn openpbr_coat_passage(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {\n    if (cosine <= 0.0) { return vec3f(1.0); }\n    let refractedCosine = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));\n    let passage = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(refractedCosine, 1e-5)));\n    return mix(vec3f(1.0), passage, material.coatWeight);\n}\n\nfn openpbr_coat_energy(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {\n    if (material.coatRoughness <= ROUGHNESS_MIN) {\n        return openpbr_dielectric_fresnel(cosine, 1.0 / material.coatIor);\n    }\n    // The opaque-dielectric table is the complement of coat directional albedo.\n    // Adobe uses the original isotropic alpha (r^2) even for anisotropic GGX.\n    return clamp(1.0 - openpbr_opaque_energy_complement(material.coatIor,\n        material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);\n}\n\nfn openpbr_coat_darkening(prepared: OpenPbrPreparedBsdf) -> vec3f {\n    let material = prepared.material;\n    let dielectric = 1.0 - material.baseMetalness;\n    let opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);\n    let sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;\n    let trans = dielectric * material.transmissionWeight;\n    let opaqueSpecularity = openpbr_average_fresnel(prepared.specularEtaTOverEtaI);\n    let transSpecularity = openpbr_average_fresnel(1.0 / prepared.transmissionReflectionIor);\n    let specularity = clamp(opaque * opaqueSpecularity + (sss + trans) * transSpecularity + material.baseMetalness, 0.0, 1.0);\n    let effectiveRoughness = mix(1.0, material.specularRoughness, specularity);\n    let ks = openpbr_average_fresnel(material.coatIor);\n    let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);\n    let k = mix(ks, kr, effectiveRoughness);\n    let eb = material.baseMetalness * material.specularWeight * openpbr_metal_average_fresnel(material.baseWeight * material.baseColor, material.specularColor)\n        + opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), opaqueSpecularity)\n        + sss * material.subsurfaceColor + vec3f(trans);\n    let delta = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));\n    return mix(vec3f(1.0), delta, material.coatWeight * material.coatDarkening);\n}\n\nfn openpbr_coat_base_scale(prepared: OpenPbrPreparedBsdf, lightCosine: f32) -> vec3f {\n    if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }\n    if (prepared.material.inside) {\n        // Inside only outgoing transmission crosses the coat; no coat reflection.\n        return openpbr_coat_passage(prepared.material, -lightCosine);\n    }\n    // Default reference mode applies energy partition on the view side only.\n    return prepared.coatBaseScale * openpbr_coat_passage(prepared.material, lightCosine);\n}\n\n\n${hasAnisotropyDirections ? /* wgsl */ `\nfn openpbr_direction_basis(fallback: OpenPbrBasis, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> OpenPbrBasis {\n    var t = tangent - fallback.normal * dot(fallback.normal, tangent);\n    if (dot(t, t) < 1e-8) { t = fallback.tangent; }\n    t = normalize(t);\n    let b = cross(fallback.normal, t) * select(1.0, -1.0, dot(cross(fallback.normal, t), bitangent) < 0.0);\n    t = t * direction.x + b * direction.y;\n    if (dot(t, t) < 1e-8) { return fallback; }\n    var basis = fallback;\n    basis.tangent = normalize(t);\n    basis.bitangent = normalize(cross(basis.normal, basis.tangent));\n    basis.tangent = normalize(cross(basis.bitangent, basis.normal));\n    return basis;\n}\n\n` : /* wgsl */ ``}\nfn openpbr_prepare(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    viewDirection: vec3f,\n    normal: vec3f\n) -> OpenPbrPreparedBsdf {\n    var prepared: OpenPbrPreparedBsdf;\n    prepared.material = material;\n    prepared.basis = openpbr_make_basis(\n        tangent,\n        normal,\n        max(material.specularAnisotropy, material.coatAnisotropy)\n    );\n${hasAnisotropyDirections ? /* wgsl */ `\n    prepared.coatBasis = prepared.basis;\n    prepared.directionFrames = false;\n${hasCoatNormals ? /* wgsl */ `\n    // Adobe c91aad1 openpbr_prepare_lobes: geometry_coat_basis is independent\n    // of the base shading basis; coat passage uses the same coat cosine.\n    if (material.coatNormalEnabled) {\n        prepared.coatBasis = openpbr_make_basis(material.geometryTangent, material.coatNormal, material.coatAnisotropy);\n        prepared.directionFrames = true;\n    }\n` : ''}\n    if (material.specularAnisotropy > 0.0 && material.anisotropyDirectionEnabled) {\n        prepared.basis = openpbr_direction_basis(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);\n        prepared.directionFrames = true;\n    }\n    if (material.coatAnisotropy > 0.0 && material.coatAnisotropyRotation != 0.0) {\n        prepared.coatBasis = openpbr_direction_basis(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));\n        prepared.directionFrames = true;\n    }\n` : /* wgsl */ ``}\n    prepared.viewLocal = openpbr_to_local(prepared.basis, viewDirection);\n${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, viewDirection);` : ''}\n    prepared.diffuseColor = material.baseColor;\n\n    let dielectricBaseWeight = 1.0 - material.baseMetalness;\n    let opaqueDielectricWeight = dielectricBaseWeight\n        * (1.0 - material.transmissionWeight);\n    prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;\n    prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;\n    if (material.inside) { prepared.weights[OPENPBR_LOBE_COAT] = 0.0; }\n    prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;\n    prepared.weights[OPENPBR_LOBE_SPECULAR] = dielectricBaseWeight;\n    prepared.weights[OPENPBR_LOBE_TRANSMISSION] = dielectricBaseWeight\n        * material.transmissionWeight;\n    prepared.weights[OPENPBR_LOBE_DIFFUSE] = opaqueDielectricWeight\n        * (1.0 - material.subsurfaceWeight) * material.baseWeight;\n    prepared.weights[OPENPBR_LOBE_SUBSURFACE] = opaqueDielectricWeight\n        * material.subsurfaceWeight;\n\n    prepared.specularEtaTOverEtaI = openpbr_apply_specular_weight_to_ior(\n        1.0 / material.relativeIor,\n        material.specularWeight\n    );\n    prepared.material.relativeIor = 1.0 / prepared.specularEtaTOverEtaI;\n    prepared.refractionEtaTOverEtaI = prepared.specularEtaTOverEtaI;\n    prepared.transmissionReflectionIor = prepared.material.relativeIor;\n    // Adobe openpbr_bsdf.h::openpbr_prepare_lobes: reflect relative to\n    // the weighted coat, refract relative to ambient air. Inside ignores coat.\n    if (material.coatWeight > 0.0) {\n        var weightedCoatIor = 1.0;\n        if (!material.inside) { weightedCoatIor = mix(1.0, material.coatIor, material.coatWeight); }\n        let weightedBaseIor = weightedCoatIor * openpbr_apply_specular_weight_to_ior(\n            material.specularIor / weightedCoatIor, material.specularWeight);\n        var reflectionEta = weightedBaseIor / weightedCoatIor;\n        if (weightedCoatIor > weightedBaseIor && weightedBaseIor >= 1.0) {\n            reflectionEta = 1.0 / reflectionEta;\n        }\n        prepared.specularEtaTOverEtaI = reflectionEta;\n        prepared.transmissionReflectionIor = 1.0 / reflectionEta;\n        prepared.refractionEtaTOverEtaI = weightedBaseIor;\n        if (material.inside) {\n            prepared.refractionEtaTOverEtaI = 1.0 / weightedBaseIor;\n            prepared.transmissionReflectionIor = weightedBaseIor;\n        }\n        prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;\n    }\n\n    // Adobe openpbr_bsdf.h::openpbr_prepare_lobes: absolute thin-film media.\n    // Preserve the existing optical solve for uncoated materials.\n    prepared.thinFilmExteriorIor = 1.0;\n    prepared.thinFilmBaseIor = prepared.specularEtaTOverEtaI;\n    if (material.coatWeight > 0.0) {\n        if (material.inside) {\n            prepared.thinFilmExteriorIor = 1.0 / prepared.refractionEtaTOverEtaI;\n            prepared.thinFilmBaseIor = 1.0;\n        }\n        else {\n            prepared.thinFilmExteriorIor = mix(1.0, material.coatIor, material.coatWeight);\n            prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;\n        }\n    }\n    prepared.specularAlpha = material.specularRoughness\n        * material.specularRoughness;\n    let viewCosine = abs(prepared.viewLocal.z);\n    let singleInterfaceFresnel = openpbr_dielectric_fresnel(\n        viewCosine,\n        1.0 / prepared.specularEtaTOverEtaI\n    );\n    let dielectricFresnelEstimate = material.specularColor * select(\n        singleInterfaceFresnel,\n        mix(\n            singleInterfaceFresnel,\n            openpbr_thin_wall_fresnel(singleInterfaceFresnel),\n            material.transmissionWeight\n        ),\n        material.thinWalled\n    );\n    let metalFresnelEstimate = material.specularWeight * openpbr_metal_fresnel(\n        viewCosine,\n        material.baseWeight * material.baseColor,\n        material.specularColor\n    );\n    let transmissionFresnel = select(\n        openpbr_dielectric_fresnel(viewCosine, prepared.transmissionReflectionIor),\n        openpbr_thin_wall_fresnel(openpbr_dielectric_fresnel(viewCosine, prepared.transmissionReflectionIor)),\n        material.thinWalled\n    );\n    let transmissionTint = openpbr_final_transmission_tint(\n        material,\n        viewCosine,\n        prepared.refractionEtaTOverEtaI\n    );\n    let viewEnergyComplement = openpbr_opaque_energy_complement(\n        prepared.specularEtaTOverEtaI,\n        prepared.specularAlpha,\n        viewCosine\n    );\n    let averageEnergyComplement = openpbr_opaque_average_energy_complement(\n        prepared.specularEtaTOverEtaI,\n        prepared.specularAlpha\n    );\n    prepared.diffuseSpecularEnergyCompensation = viewEnergyComplement\n        / max(averageEnergyComplement, 1e-12);\n\n    prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]\n        * openpbr_luminance(material.fuzzColor)\n        * max(openpbr_fuzz_directional_albedo(\n            viewCosine,\n            material.fuzzRoughness\n        ), 0.02);\n    prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;\n    prepared.coatBaseScale = vec3f(1.0);\n    if (material.coatWeight > 0.0 && !material.inside) {\n        ${hasCoatNormals ? /* wgsl */ `let coatViewCosine = select(viewCosine, max(prepared.coatViewLocal.z, 0.0), material.coatNormalEnabled);` : ''}\n        let coatEnergy = openpbr_coat_energy(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});\n        prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * coatEnergy;\n        prepared.coatBaseScale = openpbr_coat_passage(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})\n            * (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * coatEnergy) * openpbr_coat_darkening(prepared);\n    }\n    prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]\n        * openpbr_luminance(metalFresnelEstimate);\n    prepared.metalMsScale = vec3f(0.0);\n    prepared.metalMsFactor = 0.0;\n    prepared.metalMsProbability = 0.0;\n    // Reference suppresses loss below roughness .04 and uses the original\n    // isotropic alpha even when the single-scattering lobe is anisotropic.\n    if (material.specularRoughness >= 0.04 && prepared.weights[OPENPBR_LOBE_METAL] > 0.0) {\n        let averageFresnel = openpbr_metal_average_fresnel(material.baseWeight * material.baseColor, material.specularColor);\n        prepared.metalMsScale = material.specularWeight * averageFresnel * averageFresnel;\n        let viewLoss = openpbr_metal_energy_complement(prepared.specularAlpha, viewCosine);\n        prepared.metalMsFactor = viewLoss / max(openpbr_metal_average_energy_complement(prepared.specularAlpha), 1e-12);\n        let msEstimate = prepared.weights[OPENPBR_LOBE_METAL] * openpbr_luminance(prepared.metalMsScale) * viewLoss;\n        prepared.probabilities[OPENPBR_LOBE_METAL] += msEstimate;\n        prepared.metalMsProbability = msEstimate / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);\n    }\n    prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]\n        * openpbr_luminance(dielectricFresnelEstimate);\n    prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n        * (1.0 - transmissionFresnel)\n        * openpbr_luminance(transmissionTint);\n    // OpenPBR_DielectricMicrofacetMultipleScatteringLobe, Adobe c91aad1\n    // (Apache-2.0). Use the refraction IOR even when coat reflection uses a\n    // different ratio. Restrict this addition to solid transmissive materials;\n    // opaque/subsurface-only and thin-wall paths retain their existing model.\n    // Keep the renderer's exact null boundary discrete: upstream avoids eta=1\n    // for refraction, and its tabulation has small nonzero loss there.\n    prepared.dielectricMsReflectionScale = vec3f(0.0);\n    prepared.dielectricMsTransmissionScale = vec3f(0.0);\n    prepared.dielectricMsViewLoss = 0.0;\n    prepared.dielectricMsReflectionRatio = 0.0;\n    prepared.dielectricMsProbability = 0.0;\n    if (!material.thinWalled && material.transmissionWeight > 0.0 &&\n        prepared.specularAlpha >= 0.0016 && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 &&\n        abs(prepared.refractionEtaTOverEtaI - 1.0) > 1e-6) {\n        let nonOpaqueWeight = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];\n        prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * nonOpaqueWeight;\n        prepared.dielectricMsTransmissionScale = transmissionTint * prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n            + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);\n        prepared.dielectricMsReflectionRatio = openpbr_ideal_dielectric_reflection_ratio(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);\n        prepared.dielectricMsViewLoss = openpbr_ideal_dielectric_loss(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);\n        let averageScale = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);\n        let msEstimate = openpbr_luminance(averageScale) * prepared.dielectricMsViewLoss;\n        prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += msEstimate;\n        prepared.dielectricMsProbability = msEstimate / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);\n    }\n    prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]\n        * openpbr_luminance(prepared.diffuseColor)\n        * prepared.diffuseSpecularEnergyCompensation;\n    prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]\n        * (1.0 - transmissionFresnel)\n        * openpbr_luminance(material.subsurfaceColor)\n        * prepared.diffuseSpecularEnergyCompensation;\n    // Index-matched base interfaces can still reflect through thin film.\n    // Keep proposal support without duplicating the Airy optical solve here.\n    if (material.coatWeight > 0.0 && HAS_THIN_FILM && material.thinFilmWeight > 0.0) {\n        let filmSupport = 0.02 * openpbr_thin_film_presence(material.thinFilmThickness, material.thinFilmWeight);\n        prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * filmSupport);\n        prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * filmSupport);\n    }\n    if (material.coatWeight > 0.0 && !material.inside) {\n        let baseScale = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);\n        prepared.probabilities[OPENPBR_LOBE_METAL] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= baseScale;\n    }\n    openpbr_normalize_probabilities(&prepared);\n    return prepared;\n}\n\n\nfn openpbr_substrate_fresnel(prepared: OpenPbrPreparedBsdf, cosine: f32, reflection: bool) -> f32 {\n    if (prepared.material.coatWeight <= 0.0) {\n        return openpbr_dielectric_fresnel(cosine, prepared.material.relativeIor);\n    }\n    let transFresnel = openpbr_dielectric_fresnel(cosine, prepared.transmissionReflectionIor);\n    if (!reflection) { return transFresnel; }\n    let opaqueFresnel = openpbr_dielectric_fresnel(cosine, 1.0 / prepared.specularEtaTOverEtaI);\n    let nonOpaque = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;\n    return mix(opaqueFresnel, transFresnel, nonOpaque);\n}\n\nfn openpbr_eval_prepared_lobe(\n    prepared: OpenPbrPreparedBsdf,\n    lightDirection: vec3f,\n    allowedLobe: i32,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    let material = prepared.material;\n    let viewLocal = prepared.viewLocal;\n    let lightLocal = openpbr_to_local(prepared.basis, lightDirection);\n    let reflection = lightLocal.z * viewLocal.z > 0.0;\n${hasCoatNormals ? /* wgsl */ `\n    let independentCoat = material.coatNormalEnabled;\n    let geometricReflection = dot(material.geometricNormal, lightDirection) > 0.0;\n    let coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);\n    let coatReflection = geometricReflection && prepared.coatViewLocal.z > 0.0 && coatLightCosine > 0.0;\n` : ''}\n\n    var halfVector: vec3f;\n    if (reflection) {\n        halfVector = normalize(lightLocal + viewLocal);\n    }\n    else {\n        halfVector = normalize(lightLocal + viewLocal * material.relativeIor);\n    }\n    if (halfVector.z < 0.0) {\n        halfVector = -halfVector;\n    }\n\n    var response = vec3f(0.0);\n    *pdf = 0.0;\n    var lobePdf = 0.0;\n    let allowAll = allowedLobe < 0;\n    let allowFuzz = allowAll || allowedLobe == OPENPBR_LOBE_FUZZ;\n    let allowCoat = allowAll || allowedLobe == OPENPBR_LOBE_COAT;\n    let allowMetal = allowAll || allowedLobe == OPENPBR_LOBE_METAL;\n    let allowSpecular = allowAll || allowedLobe == OPENPBR_LOBE_SPECULAR;\n    let allowTransmission = allowAll ||\n        allowedLobe == OPENPBR_LOBE_TRANSMISSION;\n    let allowDiffuse = allowAll || allowedLobe == OPENPBR_LOBE_DIFFUSE;\n    let allowSubsurface = allowAll ||\n        allowedLobe == OPENPBR_LOBE_SUBSURFACE;\n    let viewHalf = abs(dot(viewLocal, halfVector));\n    // Reflection, solid refraction and thin-wall transmission share the same\n    // dielectric optical solve. Select its half angle before evaluating the\n    // film, instead of inlining that large solve in each transport branch.\n    var thinWallHalf = halfVector;\n    var dielectricViewHalf = viewHalf;\n    if (!reflection && material.thinWalled) {\n        thinWallHalf = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);\n        if (thinWallHalf.z < 0.0) { thinWallHalf = -thinWallHalf; }\n        dielectricViewHalf = abs(dot(viewLocal, thinWallHalf));\n    }\n    let evaluateDielectric =\n        (reflection && prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && allowSpecular) ||\n        (!reflection && prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && allowTransmission);\n    let evaluateMetal = reflection && prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && allowMetal;\n    var fresnels: array<vec3f, 2>;\n    if (evaluateDielectric) {\n        fresnels[0] = vec3f(openpbr_substrate_fresnel(prepared, dielectricViewHalf, reflection));\n    }\n    if (evaluateMetal) {\n        fresnels[1] = openpbr_metal_fresnel(viewHalf, material.baseWeight * material.baseColor, material.specularColor);\n    }\n    if (HAS_THIN_FILM && material.thinFilmWeight > 0.0) {\n        let wavelengths = vec3f(620.0, 540.0, 450.0);\n        // Dielectric and conductor substrates share one complete optical graph.\n        for (var substrate = 0u; substrate < (rtUniform.loopUnrollGuard >> 1u); substrate++) {\n            if (!select(evaluateDielectric, evaluateMetal, substrate == 1u)) { continue; }\n            var film = vec3f(0.0);\n            let incidentCosine = select(dielectricViewHalf, viewHalf, substrate == 1u);\n            for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {\n                var ior = vec2f(prepared.thinFilmBaseIor, 0.0);\n                if (substrate == 1u) {\n                    ior = openpbr_metal_complex_ior(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);\n                }\n                film[channel] = openpbr_thin_film_reflectance_channel(incidentCosine,\n                    wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);\n            }\n            fresnels[substrate] = mix(fresnels[substrate], film,\n                openpbr_thin_film_presence(material.thinFilmThickness, material.thinFilmWeight));\n        }\n    }\n    let substrateFresnel = fresnels[0];\n    let diffuseSpecularEnergyCompensation =\n        prepared.diffuseSpecularEnergyCompensation\n        * openpbr_opaque_energy_complement(\n            prepared.specularEtaTOverEtaI,\n            prepared.specularAlpha,\n            abs(lightLocal.z)\n        );\n\n${hasCoatNormals ? /* wgsl */ `\n    // Each lobe retains its own shading hemisphere; topology is geometric.\n    if (!independentCoat || (lightLocal.z != 0.0 && reflection == geometricReflection)) {\n` : ''}\n    if (reflection) {\n        if (prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0 && allowDiffuse) {\n            response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * openpbr_eval_diffuse(\n                material,\n                prepared.diffuseColor,\n                viewLocal,\n                lightLocal,\n                diffuseSpecularEnergyCompensation,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * lobePdf;\n        }\n\n        if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && material.thinWalled &&\n            allowSubsurface) {\n            response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * openpbr_eval_diffuse(\n                material,\n                material.subsurfaceColor,\n                viewLocal,\n                lightLocal,\n                diffuseSpecularEnergyCompensation,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * lobePdf;\n        }\n\n        if (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0 && allowSpecular) {\n            var dielectricFresnel = substrateFresnel;\n            if (material.thinWalled) {\n                dielectricFresnel = openpbr_thin_wall_reflection_coefficient(\n                    dielectricFresnel,\n                    material.transmissionWeight\n                );\n            }\n            let fresnel = material.specularColor * dielectricFresnel;\n            response += prepared.weights[OPENPBR_LOBE_SPECULAR] * openpbr_eval_microfacet_reflection(\n                material,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                fresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * lobePdf;\n        }\n\n        if (prepared.weights[OPENPBR_LOBE_METAL] > 0.0 && allowMetal) {\n            let fresnel = material.specularWeight * fresnels[1];\n            response += prepared.weights[OPENPBR_LOBE_METAL] * openpbr_eval_microfacet_reflection(\n                material,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                fresnel,\n                &lobePdf\n            );\n            if (prepared.metalMsFactor > 0.0) {\n                let factor = min(prepared.metalMsFactor * openpbr_metal_energy_complement(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));\n                response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * factor * INVPI;\n                lobePdf = mix(lobePdf, 0.5 * INVPI, prepared.metalMsProbability);\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * lobePdf;\n        }\n    }\n    else {\n        let fresnel = substrateFresnel;\n        if (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0 && allowTransmission) {\n            if (material.thinWalled) {\n                let mirroredLight = vec3f(lightLocal.xy, -lightLocal.z);\n                let windowFresnel = openpbr_thin_wall_reflection_coefficient(\n                    substrateFresnel,\n                    1.0\n                );\n                let tint = openpbr_final_transmission_tint(\n                    material,\n                    abs(viewLocal.z),\n                    prepared.refractionEtaTOverEtaI\n                );\n                response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n                    * openpbr_eval_microfacet_reflection(\n                        material,\n                        viewLocal,\n                        mirroredLight,\n                        thinWallHalf,\n                        tint * (vec3f(1.0) - windowFresnel),\n                        &lobePdf\n                    );\n            }\n            else {\n                response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n                    * openpbr_eval_microfacet_refraction(\n                        material,\n                        material.relativeIor,\n                        openpbr_transmission_tint(material),\n                        viewLocal,\n                        lightLocal,\n                        halfVector,\n                        fresnel,\n                        &lobePdf\n                    );\n            }\n            if (prepared.dielectricMsProbability > 0.0) {\n                lobePdf *= 1.0 - prepared.dielectricMsProbability;\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * lobePdf;\n        }\n        if (prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0 && allowSubsurface) {\n            if (material.thinWalled) {\n                let flippedLight = vec3f(lightLocal.xy, -lightLocal.z);\n                response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]\n                    * openpbr_eval_diffuse(\n                        material,\n                        material.subsurfaceColor,\n                        viewLocal,\n                        flippedLight,\n                        diffuseSpecularEnergyCompensation,\n                        &lobePdf\n                    );\n                lobePdf *= 0.5;\n            }\n            else {\n                response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * openpbr_eval_subsurface_boundary(\n                    material,\n                    viewLocal,\n                    lightLocal,\n                    &lobePdf\n                );\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * lobePdf;\n        }\n    }\n\n    // Reference value includes the hemisphere ratio before the grazing clamp.\n    // Reference scale_trans has no extra eta^2 factor; single refraction keeps\n    // its existing radiance Jacobian. Both proposals share the aggregate PDF.\n    if (prepared.dielectricMsProbability > 0.0 && allowTransmission) {\n        let cosine = abs(lightLocal.z);\n        if (cosine > 0.0) {\n            let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);\n            let ratio = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);\n            let factors = prepared.dielectricMsViewLoss * openpbr_ideal_dielectric_loss(ior, prepared.specularAlpha, cosine)\n                / max(openpbr_ideal_dielectric_average_loss(ior, prepared.specularAlpha), 1e-12);\n            let factor = min(factors * ratio, 1.0 / cosine);\n            let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);\n            response += scale * factor * INVPI;\n            *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ratio * 0.5 * INVPI;\n        }\n    }\n\n${hasCoatNormals ? /* wgsl */ `    } // base hemisphere support` : ''}\n    if (material.coatWeight > 0.0) {\n        response *= openpbr_coat_base_scale(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});\n    }\n${hasCoatNormals ? /* wgsl */ `\n    // Values are BSDF*cos in world solid angle before the frames are combined.\n    if (independentCoat) { response *= abs(lightLocal.z); }\n` : ''}\n\n${hasAnisotropyDirections ? /* wgsl */ `\n    if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {\n        var coatView = viewLocal;\n        var coatLight = lightLocal;\n        var coatHalf = halfVector;\n        var coatViewHalf = viewHalf;\n        if (prepared.directionFrames) {\n            coatView = ${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))'};\n            coatLight = openpbr_to_local(prepared.coatBasis, lightDirection);\n            coatHalf = normalize(coatLight + coatView);\n            if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }\n            coatViewHalf = abs(dot(coatView, coatHalf));\n        }\n\n        let coatFresnel = vec3f(openpbr_dielectric_fresnel(\n            coatViewHalf,\n            1.0 / material.coatIor\n        ));\n        var coatMaterial = material;\n        let coatAlpha = openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy);\n        coatMaterial.alphaX = coatAlpha.x;\n        coatMaterial.alphaY = coatAlpha.y;\n        if (allowCoat) {\n            response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * openpbr_eval_microfacet_reflection(\n                coatMaterial,\n                coatView,\n                coatLight,\n                coatHalf,\n                coatFresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;\n        }\n    }\n` : /* wgsl */ `\n    if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_COAT] > 0.0) {\n        let coatFresnel = vec3f(openpbr_dielectric_fresnel(\n            viewHalf,\n            1.0 / material.coatIor\n        ));\n        var coatMaterial = material;\n        let coatAlpha = openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy);\n        coatMaterial.alphaX = coatAlpha.x;\n        coatMaterial.alphaY = coatAlpha.y;\n        if (allowCoat) {\n            response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * openpbr_eval_microfacet_reflection(\n                coatMaterial,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                coatFresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;\n        }\n    }\n`}\n\n    if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} && prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0) {\n        let fuzzAlbedo = openpbr_fuzz_directional_albedo(\n            abs(viewLocal.z),\n            material.fuzzRoughness\n        );\n        response *= max(\n            vec3f(0.0),\n            vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * fuzzAlbedo)\n        );\n        if (allowFuzz) {\n            response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * openpbr_eval_fuzz(\n                material,\n                viewLocal,\n                lightLocal,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * lobePdf;\n        }\n    }\n\n    return response * ${hasCoatNormals ? 'select(abs(lightLocal.z), 1.0, independentCoat)' : 'abs(lightLocal.z)'};\n}\n\nfn openpbr_eval_prepared(\n    prepared: OpenPbrPreparedBsdf,\n    lightDirection: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    return openpbr_eval_prepared_lobe(prepared, lightDirection, -1, pdf);\n}\n\n\n\n\n\nfn openpbr_eval(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    viewDirection: vec3f,\n    normal: vec3f,\n    lightDirection: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    let prepared = openpbr_prepare(\n        tangent,\n        material,\n        viewDirection,\n        normal\n    );\n    return openpbr_eval_prepared(prepared, lightDirection, pdf);\n}\n\n\n\n\n// Direction-only proposals do not require the layered response or film optics.\nfn openpbr_sample_direction(\n    prepared: OpenPbrPreparedBsdf, randomSamples: vec3f,\n    lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>, sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>, sampledLobeIndex: ptr<function, u32>\n) -> bool {\n    let material = prepared.material;\n    let viewLocal = prepared.viewLocal;\n    var randomX = randomSamples.x;\n    let randomY = randomSamples.y;\n    let lobeSample = randomSamples.z;\n    *isTransmissionEvent = false;\n    *sampledLobeRoughness = 1.0;\n    *sampledLobeSpecular = false;\n    *sampledLobeDiffuse = false;\n    *sampledLobeIndex = u32(OPENPBR_LOBE_DIFFUSE);\n    *lightDirection = prepared.basis.normal;\n\n    var cdf: array<f32, OPENPBR_LOBE_COUNT>;\n    cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];\n    let lobeCount = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));\n    for (var lobe = 1; lobe < lobeCount; lobe++) {\n        cdf[lobe] = cdf[lobe - 1] + prepared.probabilities[lobe];\n    }\n    if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {\n        return false;\n    }\n\n    var lightLocal: vec3f;\n    if (lobeSample < cdf[OPENPBR_LOBE_FUZZ] || (\n        lobeSample >= cdf[OPENPBR_LOBE_TRANSMISSION] && lobeSample < cdf[OPENPBR_LOBE_DIFFUSE]\n    )) {\n        let sampledFuzz = lobeSample < cdf[OPENPBR_LOBE_FUZZ];\n        *sampledLobeRoughness = select(\n            1.0,\n            material.fuzzRoughness,\n            sampledFuzz\n        );\n        *sampledLobeDiffuse = !sampledFuzz;\n        *sampledLobeIndex = select(\n            u32(OPENPBR_LOBE_DIFFUSE),\n            u32(OPENPBR_LOBE_FUZZ),\n            sampledFuzz\n        );\n        lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n    }\n${hasAnisotropyDirections ? /* wgsl */ `\n    else if (lobeSample < cdf[OPENPBR_LOBE_COAT]) {\n        *sampledLobeRoughness = material.coatRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_COAT);\n        var coatView = viewLocal;\n        if (prepared.directionFrames) { coatView = ${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))'}; }\n        var halfVector = sampling_ggx_visible_normal(\n            coatView,\n            // The VNDF must use the same alpha as the evaluated coat PDF.\n            openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy),\n            vec2f(randomX, randomY)\n        );\n        if (halfVector.z < 0.0) {\n            halfVector = -halfVector;\n        }\n        lightLocal = normalize(reflect(-coatView, halfVector));\n${hasCoatNormals ? /* wgsl */ `\n        if (material.coatNormalEnabled) {\n            // Validate against the sampled coat frame, never the base normal.\n            *lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);\n            return lightLocal.z > 0.0 && dot(material.geometricNormal, *lightDirection) > 0.0;\n        }\n` : ''}\n        if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }\n    }\n` : /* wgsl */ `\n    else if (lobeSample < cdf[OPENPBR_LOBE_COAT]) {\n        *sampledLobeRoughness = material.coatRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_COAT);\n        var halfVector = sampling_ggx_visible_normal(\n            viewLocal,\n            // The VNDF must use the same alpha as the evaluated coat PDF.\n            openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy),\n            vec2f(randomX, randomY)\n        );\n        if (halfVector.z < 0.0) {\n            halfVector = -halfVector;\n        }\n        lightLocal = normalize(reflect(-viewLocal, halfVector));\n    }\n`}\n    else if (lobeSample < cdf[OPENPBR_LOBE_SPECULAR]) {\n        *sampledLobeRoughness = material.specularRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = select(\n            u32(OPENPBR_LOBE_SPECULAR),\n            u32(OPENPBR_LOBE_METAL),\n            lobeSample < cdf[OPENPBR_LOBE_METAL]\n        );\n        let isMetal = lobeSample < cdf[OPENPBR_LOBE_METAL];\n        let metalDraw = (lobeSample - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);\n        if (isMetal && metalDraw < prepared.metalMsProbability) {\n            let z = randomX;\n            let radial = sqrt(max(0.0, 1.0 - z * z));\n            let azimuth = TWOPI * randomY;\n            lightLocal = vec3f(radial * cos(azimuth), radial * sin(azimuth), z);\n        }\n        else {\n            var halfVector = sampling_ggx_visible_normal(\n                viewLocal,\n                vec2f(material.alphaX, material.alphaY),\n                vec2f(randomX, randomY)\n            );\n            if (halfVector.z < 0.0) {\n                halfVector = -halfVector;\n            }\n            lightLocal = normalize(reflect(-viewLocal, halfVector));\n        }\n    }\n    else if (lobeSample < cdf[OPENPBR_LOBE_TRANSMISSION]) {\n        *sampledLobeRoughness = material.specularRoughness;\n        *sampledLobeSpecular = true;\n        *isTransmissionEvent = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_TRANSMISSION);\n        // Split the existing BSDF_LOBE interval. BSDF_DIRECTION retains its\n        // two dimensions; rand.x selects and remaps the reference hemisphere.\n        let msDraw = (lobeSample - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);\n        if (prepared.dielectricMsProbability > 0.0 && msDraw < prepared.dielectricMsProbability) {\n            let ratio = prepared.dielectricMsReflectionRatio;\n            let reflectMs = randomX < ratio;\n            var z: f32;\n            if (reflectMs) { z = min(randomX / ratio, 0.99999994); }\n            else { z = -min((randomX - ratio) / (1.0 - ratio), 0.99999994); }\n            let radial = sqrt(max(0.0, 1.0 - z * z));\n            let azimuth = TWOPI * randomY;\n            lightLocal = vec3f(radial * cos(azimuth), radial * sin(azimuth), z);\n            *isTransmissionEvent = !reflectMs;\n            *sampledLobeIndex = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), reflectMs);\n        }\n        else {\n            var halfVector = sampling_ggx_visible_normal(\n                viewLocal,\n                vec2f(material.alphaX, material.alphaY),\n                vec2f(randomX, randomY)\n            );\n            if (halfVector.z < 0.0) {\n                halfVector = -halfVector;\n            }\n            if (material.thinWalled) {\n                let reflectedLocal = normalize(reflect(-viewLocal, halfVector));\n                lightLocal = vec3f(reflectedLocal.xy, -reflectedLocal.z);\n            }\n            else {\n                lightLocal = refract(\n                    -viewLocal,\n                    halfVector,\n                    prepared.material.relativeIor\n                );\n                if (dot(lightLocal, lightLocal) <= 1e-8) {\n                    *isTransmissionEvent = false;\n                    return false;\n                }\n                lightLocal = normalize(lightLocal);\n            }\n        }\n    }\n    else {\n        *sampledLobeRoughness = 1.0;\n        *sampledLobeDiffuse = true;\n        *isTransmissionEvent = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_SUBSURFACE);\n        if (material.thinWalled) {\n            let transmit = randomX >= 0.5;\n            if (transmit) {\n                randomX = (randomX - 0.5) * 2.0;\n            }\n            else {\n                randomX *= 2.0;\n            }\n            lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n            if (transmit) {\n                lightLocal.z = -lightLocal.z;\n            }\n            else {\n                *isTransmissionEvent = false;\n            }\n        }\n        else {\n            lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n            lightLocal.z = -lightLocal.z;\n        }\n    }\n\n    *lightDirection = openpbr_to_world(prepared.basis, lightLocal);\n    // VNDF reflection may land below the macrosurface. A mirrored thin-wall\n    // transmission draw can likewise land above it. Reject that draw before\n    // aggregate evaluation can accidentally turn it into the opposite lobe.\n    if (lightLocal.z == 0.0 || (lightLocal.z < 0.0) != *isTransmissionEvent) {\n        return false;\n    }\n${hasCoatNormals ? /* wgsl */ `\n    if (material.coatNormalEnabled &&\n        ((dot(material.geometricNormal, *lightDirection) <= 0.0) != *isTransmissionEvent)) { return false; }\n` : ''}\n    return true;\n}\n\nfn openpbr_sample_prepared(\n    prepared: OpenPbrPreparedBsdf,\n    randomSamples: vec3f,\n    lightDirection: ptr<function, vec3f>,\n    pdf: ptr<function, f32>,\n    isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>,\n    sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>,\n    sampledLobeIndex: ptr<function, u32>,\n    marginalPdf: ptr<function, f32>,\n    fullResponse: ptr<function, vec3f>\n) -> vec3f {\n    *pdf = 0.0;\n    *marginalPdf = 0.0;\n    *fullResponse = vec3f(0.0);\n    // Solid microfacet refraction is singular at exactly eta=1: the usual\n    // half vector normalizes light + eta * view, which is zero for straight\n    // transmission. Resolve the physically null boundary as a discrete,\n    // unit-throughput continuation instead of losing the path to NaNs.\n    if (!prepared.material.thinWalled &&\n        abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n        prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6) {\n        *lightDirection = openpbr_to_world(\n            prepared.basis,\n            -prepared.viewLocal\n        );\n        let nullBoundaryTint = openpbr_transmission_tint(prepared.material)\n            * openpbr_coat_base_scale(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});\n        *pdf = 1.0;\n        *marginalPdf = 1.0;\n        *fullResponse = nullBoundaryTint;\n        *isTransmissionEvent = true;\n        *sampledLobeRoughness = 0.0;\n        *sampledLobeSpecular = true;\n        *sampledLobeDiffuse = false;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_TRANSMISSION);\n        return nullBoundaryTint;\n    }\n    if (!openpbr_sample_direction(prepared, randomSamples, lightDirection,\n        isTransmissionEvent, sampledLobeRoughness, sampledLobeSpecular,\n        sampledLobeDiffuse, sampledLobeIndex)) { return vec3f(0.0); }\n    let response = openpbr_eval_prepared(prepared, *lightDirection, pdf);\n    *marginalPdf = *pdf;\n    *fullResponse = response;\n    return response;\n}\n\nfn openpbr_sample(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    randomSamples: vec3f,\n    viewDirection: vec3f,\n    normal: vec3f,\n    lightDirection: ptr<function, vec3f>,\n    pdf: ptr<function, f32>,\n    isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>,\n    sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>,\n    sampledLobeIndex: ptr<function, u32>,\n    marginalPdf: ptr<function, f32>\n) -> vec3f {\n    let prepared = openpbr_prepare(\n        tangent,\n        material,\n        viewDirection,\n        normal\n    );\n    var fullResponse = vec3f(0.0);\n    return openpbr_sample_prepared(\n        prepared,\n        randomSamples,\n        lightDirection,\n        pdf,\n        isTransmissionEvent,\n        sampledLobeRoughness,\n        sampledLobeSpecular,\n        sampledLobeDiffuse,\n        sampledLobeIndex,\n        marginalPdf,\n        &fullResponse\n    );\n}`;\n\n}\n\nexport default createOpenPbrBsdfWgsl();\n"]}
+{"version":3,"file":"openPbrBsdf.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/openPbrBsdf.wgsl.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * OpenPBR energy-compensation, EON and thin-film portions Copyright 2026 Adobe.\n * Licensed under the Apache License, Version 2.0.\n * https://www.apache.org/licenses/LICENSE-2.0\n */\n\n/*\n * Renderer-specific OpenPBR layered BSDF.\n *\n * The prepare/eval/sample/pdf organization and fixed-lobe composition follow:\n * - https://github.com/adobe/openpbr-bsdf\n * - https://github.com/portsmouth/OpenPBR-viewer\n *\n * This compact GPU implementation reuses the renderer's GGX VNDF and volume\n * integrator. Adobe's opaque-dielectric energy tables are used for the base\n * rough-diffuse/specular coupling; fuzz still uses an analytic approximation.\n */\n\nimport { 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';\nconst LOBE_INDICES = [0, 1, 2, 3, 4, 5, 6];\n\nexport function createOpenPbrBsdfWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {\n  return /* wgsl */ `\nconst OPENPBR_LOBE_FUZZ: i32 = 0;\nconst OPENPBR_LOBE_COAT: i32 = 1;\nconst OPENPBR_LOBE_METAL: i32 = 2;\nconst OPENPBR_LOBE_SPECULAR: i32 = 3;\nconst OPENPBR_LOBE_TRANSMISSION: i32 = 4;\nconst OPENPBR_LOBE_DIFFUSE: i32 = 5;\nconst OPENPBR_LOBE_SUBSURFACE: i32 = 6;\nconst OPENPBR_LOBE_COUNT: i32 = ${LOBE_INDICES.length};\n\n// Eager boolean operators below combine pure scalar predicates. This avoids\n// multiplying short-circuit control flow when DXC inlines the layered BSDF.\n\nstruct OpenPbrBasis {\n    tangent: vec3f,\n    bitangent: vec3f,\n    normal: vec3f,\n};\n\nstruct OpenPbrPreparedBsdf {\n    material: OpenPbrResolvedMaterial,\n    basis: OpenPbrBasis,\n${hasAnisotropyDirections ? /* wgsl */ `\n    coatBasis: OpenPbrBasis,\n    directionFrames: bool,\n` : /* wgsl */ ``}\n${hasCoatNormals ? /* wgsl */ `    coatViewLocal: vec3f,` : ''}\n    viewLocal: vec3f,\n    diffuseColor: vec3f,\n    specularEtaTOverEtaI: f32,\n    refractionEtaTOverEtaI: f32,\n    transmissionReflectionIor: f32,\n    thinFilmExteriorIor: f32,\n    thinFilmBaseIor: f32,\n    specularAlpha: f32,\n    diffuseSpecularEnergyCompensation: f32,\n    coatBaseScale: vec3f,\n    metalMsScale: vec3f,\n    metalMsFactor: f32,\n    metalMsProbability: f32,\n\n    dielectricMsReflectionScale: vec3f,\n    dielectricMsTransmissionScale: vec3f,\n    dielectricMsViewLoss: f32,\n    dielectricMsReflectionRatio: f32,\n    dielectricMsProbability: f32,\n\n    weights: array<f32, OPENPBR_LOBE_COUNT>,\n    probabilities: array<f32, OPENPBR_LOBE_COUNT>,\n};\n\nfn openpbr_luminance(color: vec3f) -> f32 {\n    return dot(color, vec3f(0.212671, 0.715160, 0.072169));\n}\n\nfn openpbr_f0_from_ior(etaTOverEtaI: f32) -> f32 {\n    let value = (etaTOverEtaI - 1.0) / (etaTOverEtaI + 1.0);\n    return value * value;\n}\n\nfn openpbr_apply_specular_weight_to_ior(\n    etaTOverEtaI: f32,\n    specularWeight: f32\n) -> f32 {\n    let scaledF0 = min(\n        openpbr_f0_from_ior(etaTOverEtaI) * specularWeight,\n        0.9999\n    );\n    let sqrtF0 = sqrt(scaledF0);\n    let externalIor = (1.0 + sqrtF0) / (1.0 - sqrtF0);\n    return select(externalIor, 1.0 / externalIor, etaTOverEtaI < 1.0);\n}\n\nfn openpbr_dielectric_fresnel(cosTheta: f32, relativeIor: f32) -> f32 {\n    if (abs(relativeIor - 1.0) < 1e-6) {\n        return 0.0;\n    }\n    return sampling_dielectric_fresnel(cosTheta, relativeIor);\n}\n\nfn openpbr_energy_ior_index(ior: f32) -> f32 {\n    if (ior < 1.0) {\n        return 15.0 - ((1.0 / ior - 1.0) / 1.5) * 15.0;\n    }\n    return 16.0 + ((ior - 1.0) / 1.5) * 15.0;\n}\n\nfn openpbr_energy_fetch(cosIndex: i32, row: i32) -> f32 {\n    return textureLoad(openPbrEnergyLut, vec2i(cosIndex, row), 0).r;\n}\n\nfn openpbr_energy_trilinear(\n    exactIor: f32,\n    exactAlpha: f32,\n    exactCosine: f32\n) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let cosineIndex = clamp(exactCosine, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let cosine0 = i32(floor(cosineIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let cosine1 = min(cosine0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let cosineMix = cosineIndex - f32(cosine0);\n\n    let v000 = openpbr_energy_fetch(cosine0, ior0 * 32 + alpha0);\n    let v001 = openpbr_energy_fetch(cosine1, ior0 * 32 + alpha0);\n    let v010 = openpbr_energy_fetch(cosine0, ior0 * 32 + alpha1);\n    let v011 = openpbr_energy_fetch(cosine1, ior0 * 32 + alpha1);\n    let v100 = openpbr_energy_fetch(cosine0, ior1 * 32 + alpha0);\n    let v101 = openpbr_energy_fetch(cosine1, ior1 * 32 + alpha0);\n    let v110 = openpbr_energy_fetch(cosine0, ior1 * 32 + alpha1);\n    let v111 = openpbr_energy_fetch(cosine1, ior1 * 32 + alpha1);\n    let v00 = mix(v000, v100, iorMix);\n    let v01 = mix(v001, v101, iorMix);\n    let v10 = mix(v010, v110, iorMix);\n    let v11 = mix(v011, v111, iorMix);\n    return mix(\n        mix(v00, v10, alphaMix),\n        mix(v01, v11, alphaMix),\n        cosineMix\n    );\n}\n\nfn openpbr_energy_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, 1024 + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, 1024 + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, 1024 + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, 1024 + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\n// Adobe c91aad1 ideal dielectric tables clamp IOR indices; unlike opaque\n// dielectric data they do not extrapolate outside [0.4, 2.5].\nfn openpbr_ideal_energy_trilinear(\n    exactIor: f32,\n    exactAlpha: f32,\n    exactCosine: f32\n) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let cosineIndex = clamp(exactCosine, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let cosine0 = i32(floor(cosineIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let cosine1 = min(cosine0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let cosineMix = cosineIndex - f32(cosine0);\n\n    let v000 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha0);\n    let v001 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha0);\n    let v010 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha1);\n    let v011 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior0 * 32 + alpha1);\n    let v100 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha0);\n    let v101 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha0);\n    let v110 = openpbr_energy_fetch(cosine0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha1);\n    let v111 = openpbr_energy_fetch(cosine1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + ior1 * 32 + alpha1);\n    let v00 = mix(v000, v100, iorMix);\n    let v01 = mix(v001, v101, iorMix);\n    let v10 = mix(v010, v110, iorMix);\n    let v11 = mix(v011, v111, iorMix);\n    return mix(\n        mix(v00, v10, alphaMix),\n        mix(v01, v11, alphaMix),\n        cosineMix\n    );\n}\n\nfn openpbr_ideal_average_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_ENERGY_LUT_AVERAGE_ROW} + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\nfn openpbr_ideal_ratio_bilinear(exactIor: f32, exactAlpha: f32) -> f32 {\n    let iorIndex = clamp(exactIor, 0.0, 31.0);\n    let alphaIndex = clamp(exactAlpha, 0.0, 31.0);\n    let ior0 = i32(floor(iorIndex));\n    let alpha0 = i32(floor(alphaIndex));\n    let ior1 = min(ior0 + 1, 31);\n    let alpha1 = min(alpha0 + 1, 31);\n    let iorMix = iorIndex - f32(ior0);\n    let alphaMix = alphaIndex - f32(alpha0);\n    let v00 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior0);\n    let v01 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior0);\n    let v10 = openpbr_energy_fetch(alpha0, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior1);\n    let v11 = openpbr_energy_fetch(alpha1, ${OPENPBR_DIELECTRIC_REFLECTION_RATIO_LUT_ROW} + ior1);\n    return mix(\n        mix(v00, v10, iorMix),\n        mix(v01, v11, iorMix),\n        alphaMix\n    );\n}\n\nfn openpbr_ideal_dielectric_loss(ior: f32, alpha: f32, cosine: f32) -> f32 {\n    return openpbr_ideal_energy_trilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0, cosine * 31.0);\n}\nfn openpbr_ideal_dielectric_average_loss(ior: f32, alpha: f32) -> f32 {\n    return openpbr_ideal_average_bilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0);\n}\nfn openpbr_ideal_dielectric_reflection_ratio(ior: f32, alpha: f32) -> f32 {\n    return openpbr_ideal_ratio_bilinear(openpbr_energy_ior_index(ior), sqrt(alpha) * 31.0);\n}\n\n// Adobe openpbr_microfacet_multiple_scattering_{data,lobes}.h (c91aad1):\n// ideal-metal loss E=1-singleScatterEnergy, indexed by sqrt(alpha) and cosine.\nfn openpbr_metal_energy_complement(alpha: f32, cosine: f32) -> f32 {\n    let roughnessIndex = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);\n    let cosineIndex = clamp(cosine * 31.0, 0.0, 31.0);\n    let r0 = i32(floor(roughnessIndex));\n    let c0 = i32(floor(cosineIndex));\n    let r1 = min(r0 + 1, 31);\n    let c1 = min(c0 + 1, 31);\n    return mix(\n        mix(openpbr_energy_fetch(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), openpbr_energy_fetch(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r0), fract(cosineIndex)),\n        mix(openpbr_energy_fetch(c0, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), openpbr_energy_fetch(c1, ${OPENPBR_METAL_ENERGY_LUT_ROW} + r1), fract(cosineIndex)),\n        fract(roughnessIndex));\n}\n\nfn openpbr_metal_average_energy_complement(alpha: f32) -> f32 {\n    let index = clamp(sqrt(alpha) * 31.0, 0.0, 31.0);\n    let i0 = i32(floor(index));\n    return mix(openpbr_energy_fetch(i0, ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}),\n        openpbr_energy_fetch(min(i0 + 1, 31), ${OPENPBR_METAL_ENERGY_LUT_AVERAGE_ROW}), fract(index));\n}\n\nfn openpbr_extrapolate_energy_complement(value: f32, ior: f32) -> f32 {\n    if ((ior > 2.5) | (ior < 0.4)) {\n        let maxF0 = openpbr_f0_from_ior(2.5);\n        let progress = (openpbr_f0_from_ior(ior) - maxF0) / (1.0 - maxF0);\n        return (1.0 - progress) * value;\n    }\n    return value;\n}\n\nfn openpbr_opaque_energy_complement(\n    ior: f32,\n    alpha: f32,\n    cosine: f32\n) -> f32 {\n    let value = openpbr_energy_trilinear(\n        openpbr_energy_ior_index(ior),\n        sqrt(alpha) * 31.0,\n        cosine * 31.0\n    );\n    return openpbr_extrapolate_energy_complement(value, ior);\n}\n\nfn openpbr_opaque_average_energy_complement(ior: f32, alpha: f32) -> f32 {\n    let value = openpbr_energy_bilinear(\n        openpbr_energy_ior_index(ior),\n        sqrt(alpha) * 31.0\n    );\n    return openpbr_extrapolate_energy_complement(value, ior);\n}\n\nfn openpbr_to_world(basis: OpenPbrBasis, direction: vec3f) -> vec3f {\n    return direction.x * basis.tangent\n        + direction.y * basis.bitangent\n        + direction.z * basis.normal;\n}\n\nfn openpbr_to_local(basis: OpenPbrBasis, direction: vec3f) -> vec3f {\n    return vec3f(\n        dot(direction, basis.tangent),\n        dot(direction, basis.bitangent),\n        dot(direction, basis.normal)\n    );\n}\n\nfn openpbr_make_basis(\n    inputTangent: vec3f,\n    normal: vec3f,\n    anisotropy: f32\n) -> OpenPbrBasis {\n    var basis: OpenPbrBasis;\n    basis.normal = normal;\n    var tangent = inputTangent;\n    var bitangent = vec3f(0.0);\n    if ((dot(tangent, tangent) < 0.001) | (anisotropy <= 0.0)) {\n        sampling_orthonormal_basis(normal, &tangent, &bitangent);\n    }\n    else {\n        bitangent = normalize(cross(normal, tangent));\n        tangent = normalize(cross(bitangent, normal));\n    }\n    basis.tangent = tangent;\n    basis.bitangent = bitangent;\n    return basis;\n}\n\nfn openpbr_fresnel_s(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return (incidentIor * incidentCosine - transmittedIor * transmittedCosine)\n        / (incidentIor * incidentCosine + transmittedIor * transmittedCosine);\n}\n\nfn openpbr_fresnel_p(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return (transmittedIor * incidentCosine - incidentIor * transmittedCosine)\n        / (incidentIor * transmittedCosine + transmittedIor * incidentCosine);\n}\n\nfn openpbr_transmission_s(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return 2.0 * incidentIor * incidentCosine\n        / (incidentIor * incidentCosine + transmittedIor * transmittedCosine);\n}\n\nfn openpbr_transmission_p(\n    incidentIor: f32,\n    transmittedIor: f32,\n    incidentCosine: f32,\n    transmittedCosine: f32\n) -> f32 {\n    return 2.0 * incidentIor * incidentCosine\n        / (incidentIor * transmittedCosine + transmittedIor * incidentCosine);\n}\n\nfn openpbr_complex_multiply(a: vec2f, b: vec2f) -> vec2f {\n    return vec2f(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);\n}\n\nfn openpbr_complex_divide(a: vec2f, b: vec2f) -> vec2f {\n    let denominator = max(dot(b, b), 1e-9);\n    return vec2f(\n        (a.x * b.x + a.y * b.y) / denominator,\n        (a.y * b.x - a.x * b.y) / denominator\n    );\n}\n\nfn openpbr_complex_sqrt(value: vec2f) -> vec2f {\n    let magnitude = length(value);\n    let realPart = sqrt(max(0.0, 0.5 * (magnitude + value.x)));\n    let imaginaryMagnitude = sqrt(max(0.0, 0.5 * (magnitude - value.x)));\n    return vec2f(realPart, select(-imaginaryMagnitude, imaginaryMagnitude, value.y >= 0.0));\n}\n\nfn openpbr_complex_fresnel_reflection(\n    incidentCosine: f32,\n    incidentIor: f32,\n    transmittedIor: vec2f,\n    pPolarized: bool\n) -> vec2f {\n    let incidentSine = sqrt(max(0.0, 1.0 - incidentCosine * incidentCosine));\n    let iorRatio = openpbr_complex_divide(vec2f(incidentIor, 0.0), transmittedIor);\n    let transmittedSine = iorRatio * incidentSine;\n    var transmittedCosine = openpbr_complex_sqrt(\n        vec2f(1.0, 0.0) - openpbr_complex_multiply(transmittedSine, transmittedSine)\n    );\n    if (openpbr_complex_multiply(transmittedIor, transmittedCosine).y < 0.0) {\n        transmittedCosine = -transmittedCosine;\n    }\n\n    let incidentIorCosine = vec2f(incidentIor * incidentCosine, 0.0);\n    let transmittedIorCosine = openpbr_complex_multiply(transmittedIor, transmittedCosine);\n    if (pPolarized) {\n        let transmittedIorIncidentCosine = transmittedIor * incidentCosine;\n        let incidentIorTransmittedCosine = transmittedCosine * incidentIor;\n        return openpbr_complex_divide(\n            transmittedIorIncidentCosine - incidentIorTransmittedCosine,\n            transmittedIorIncidentCosine + incidentIorTransmittedCosine\n        );\n    }\n    return openpbr_complex_divide(\n        incidentIorCosine - transmittedIorCosine,\n        incidentIorCosine + transmittedIorCosine\n    );\n}\n\nfn openpbr_airy_reflectance(\n    reflection12: f32,\n    transmission12: f32,\n    reflection21: f32,\n    transmission21: f32,\n    reflection23: vec2f,\n    phase: f32\n) -> f32 {\n    let phaseRotation = vec2f(cos(phase), sin(phase));\n    let reflectedPhase = openpbr_complex_multiply(reflection23, phaseRotation);\n    let numerator = reflectedPhase * (transmission12 * transmission21);\n    let denominator = vec2f(1.0, 0.0) - reflectedPhase * reflection21;\n    let totalReflection = vec2f(reflection12, 0.0)\n        + openpbr_complex_divide(numerator, denominator);\n    return dot(totalReflection, totalReflection);\n}\n\nfn openpbr_thin_film_reflectance_channel(\n    incidentCosine: f32,\n    wavelength: f32,\n    thickness: f32,\n    exteriorIor: f32,\n    filmIor: f32,\n    substrateIor: vec2f\n) -> f32 {\n    let safeIncidentCosine = clamp(abs(incidentCosine), 1e-5, 1.0);\n    let filmSineSquared = pow(exteriorIor / filmIor, 2.0)\n        * (1.0 - safeIncidentCosine * safeIncidentCosine);\n    if (filmSineSquared >= 1.0) {\n        return 1.0;\n    }\n    let filmCosine = sqrt(1.0 - filmSineSquared);\n    let reflection12S = openpbr_fresnel_s(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let reflection12P = openpbr_fresnel_p(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission12S = openpbr_transmission_s(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission12P = openpbr_transmission_p(\n        exteriorIor, filmIor, safeIncidentCosine, filmCosine\n    );\n    let transmission21Scale = filmIor * filmCosine\n        / max(exteriorIor * safeIncidentCosine, 1e-9);\n    let phase = 2.0 * PI * (2.0 * filmIor * thickness * filmCosine) / wavelength;\n    var reflectance = 0.0;\n    // Both polarizations share Snell's complex solve and the Airy graph.\n    for (var polarization = 0u; polarization < (rtUniform.loopUnrollGuard >> 1u); polarization++) {\n        let reflection12 = select(reflection12S, reflection12P, polarization == 1u);\n        let transmission12 = select(transmission12S, transmission12P, polarization == 1u);\n        let reflection23 = openpbr_complex_fresnel_reflection(\n            filmCosine, filmIor, substrateIor, polarization == 1u);\n        reflectance += openpbr_airy_reflectance(reflection12, transmission12,\n            -reflection12, transmission12 * transmission21Scale, reflection23, phase);\n    }\n    return clamp(0.5 * reflectance, 0.0, 1.0);\n}\n\n\n// OpenPBR 1.1.1 Metal: analytic F82-tint correction to Schlick.\n// Saturation follows Adobe impl/openpbr_lobe_utils.h, openpbr_metal_schlick_with_f82_tint.\nfn openpbr_metal_fresnel(cosine: f32, f0: vec3f, tint: vec3f) -> vec3f {\n    let schlick = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(cosine));\n    if (all(tint == vec3f(1.0))) { return schlick; }\n    let edgeCosine = 1.0 / 7.0;\n    let edgeComplement = 1.0 - edgeCosine;\n    let edgeFresnel = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(edgeCosine));\n    let complement = 1.0 - cosine;\n    let correction = cosine * sampling_schlick_fifth_power(cosine) * complement\n        / (edgeCosine * pow(edgeComplement, 6.0));\n    return clamp(schlick - correction * (edgeFresnel - tint * edgeFresnel), vec3f(0.0), vec3f(1.0));\n}\n\nfn openpbr_metal_complex_ior(f0: f32, f82Tint: f32) -> vec2f {\n    let reflectivity = clamp(f0, 0.0, 0.99);\n    let sqrtReflectivity = sqrt(reflectivity);\n    let minimumIor = (1.0 - reflectivity) / (1.0 + reflectivity);\n    let maximumIor = (1.0 + sqrtReflectivity) / max(1.0 - sqrtReflectivity, 1e-9);\n    let ior = mix(maximumIor, minimumIor, clamp(f82Tint, 0.0, 1.0));\n    let extinctionSquared = (\n        (ior + 1.0) * (ior + 1.0) * reflectivity\n        - (ior - 1.0) * (ior - 1.0)\n    ) / max(1.0 - reflectivity, 1e-9);\n    return vec2f(ior, sqrt(max(extinctionSquared, 0.0)));\n}\n\n\nfn openpbr_thin_film_presence(thickness: f32, weight: f32) -> f32 {\n    return clamp(weight, 0.0, 1.0) * smoothstep(1e-9, 30.0, thickness);\n}\n\n\n\nfn openpbr_eval_diffuse(\n    material: OpenPbrResolvedMaterial,\n    color: vec3f,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    specularEnergyCompensation: f32,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z <= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let roughness = material.diffuseRoughness;\n    let fonConstantA = 0.5 - 2.0 / (3.0 * PI);\n    let fonConstantB = 2.0 / 3.0 - 28.0 / (15.0 * PI);\n    let muInput = lightLocal.z;\n    let muOutput = viewLocal.z;\n    let directional = dot(lightLocal, viewLocal) - muInput * muOutput;\n    let directionalOverTangent = select(\n        directional,\n        directional / max(max(muInput, muOutput), 1e-7),\n        directional > 0.0\n    );\n    let singleScatterA = 1.0 / (1.0 + fonConstantA * roughness);\n    let singleScatter = color * INVPI * singleScatterA\n        * (1.0 + roughness * directionalOverTangent);\n\n    let inputComplement = 1.0 - muInput;\n    let outputComplement = 1.0 - muOutput;\n    let inputGOverPi = inputComplement * (\n        0.0571085289 + inputComplement * (\n            0.491881867 + inputComplement * (\n                -0.332181442 + inputComplement * 0.0714429953\n            )\n        )\n    );\n    let outputGOverPi = outputComplement * (\n        0.0571085289 + outputComplement * (\n            0.491881867 + outputComplement * (\n                -0.332181442 + outputComplement * 0.0714429953\n            )\n        )\n    );\n    let inputAlbedo = (1.0 + roughness * inputGOverPi)\n        / (1.0 + fonConstantA * roughness);\n    let outputAlbedo = (1.0 + roughness * outputGOverPi)\n        / (1.0 + fonConstantA * roughness);\n    let averageAlbedo = singleScatterA * (1.0 + fonConstantB * roughness);\n    let multipleScatterAlbedo = color * color * averageAlbedo\n        / max(vec3f(1e-7), vec3f(1.0) - color * (1.0 - averageAlbedo));\n    let multipleScatter = multipleScatterAlbedo * INVPI\n        * max(1e-7, 1.0 - outputAlbedo)\n        * max(1e-7, 1.0 - inputAlbedo)\n        / max(1e-7, 1.0 - averageAlbedo);\n    *pdf = lightLocal.z * INVPI;\n    return (singleScatter + multipleScatter) * specularEnergyCompensation;\n}\n\nfn openpbr_fuzz_directional_albedo(viewCosine: f32, roughness: f32) -> f32 {\n    let x = clamp(viewCosine, 0.0, 1.0);\n    let y = clamp(roughness, 0.01, 1.0);\n    let scale = y * (0.0206607 + 1.58491 * y)\n        / (0.0379424 + y * (1.32227 + y));\n    let mean = y * (-0.193854 + y * (-1.14885 + y * (1.7932 - 0.95943 * y * y)))\n        / (0.046391 + y);\n    let offset = y * (0.000654023 + (-0.0207818 + 0.119681 * y) * y)\n        / (1.26264 + y * (-1.92021 + y));\n    let gaussian = exp(-0.5 * pow((x - mean) / scale, 2.0))\n        / (scale * sqrt(2.0 * PI));\n    return max(gaussian + offset, 0.0);\n}\n\nfn openpbr_eval_fuzz(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if ((viewLocal.z <= 0.0) | (lightLocal.z <= 0.0)) {\n        return vec3f(0.0);\n    }\n    let albedo = openpbr_fuzz_directional_albedo(\n        viewLocal.z,\n        material.fuzzRoughness\n    );\n    *pdf = lightLocal.z * INVPI;\n    return material.fuzzColor * albedo * INVPI;\n}\n\nfn openpbr_eval_microfacet_reflection(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    halfVector: vec3f,\n    fresnel: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z <= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let alpha = vec2f(material.alphaX, material.alphaY);\n    let distribution = sampling_ggx_ndf(halfVector, alpha);\n    let masking = sampling_ggx_smith_g1(viewLocal, alpha);\n    let maskingShadowing = masking\n        * sampling_ggx_smith_g1(lightLocal, alpha);\n\n    *pdf = masking * distribution / (4.0 * max(viewLocal.z, 1e-8));\n    return fresnel * distribution * maskingShadowing\n        / (4.0 * max(lightLocal.z * viewLocal.z, 1e-8));\n}\n\nfn openpbr_eval_microfacet_refraction(\n    material: OpenPbrResolvedMaterial,\n    relativeIor: f32,\n    tint: vec3f,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    halfVector: vec3f,\n    fresnel: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if (lightLocal.z >= 0.0) {\n        return vec3f(0.0);\n    }\n\n    let lightHalf = dot(lightLocal, halfVector);\n    let viewHalf = dot(viewLocal, halfVector);\n    // A refracting microfacet must face the view and the opposite side of the\n    // light. Backfacing configurations have no support in the VNDF proposal.\n    if ((viewHalf <= 0.0) | (lightHalf >= 0.0)) {\n        return vec3f(0.0);\n    }\n    let alpha = vec2f(material.alphaX, material.alphaY);\n    let distribution = sampling_ggx_ndf(halfVector, alpha);\n    let masking = sampling_ggx_smith_g1(viewLocal, alpha);\n    let maskingShadowing = masking\n        * sampling_ggx_smith_g1(lightLocal, alpha);\n    var denominator = lightHalf + viewHalf * relativeIor;\n    denominator *= denominator;\n    let jacobian = abs(lightHalf) / max(denominator, 1e-8);\n    let relativeIorSquared = relativeIor * relativeIor;\n\n    *pdf = masking * max(0.0, viewHalf) * distribution * jacobian\n        / max(viewLocal.z, 1e-8);\n    return tint * (vec3f(1.0) - fresnel) * distribution * maskingShadowing\n        * abs(viewHalf) * jacobian * relativeIorSquared\n        / max(abs(lightLocal.z * viewLocal.z), 1e-8);\n}\n\nfn openpbr_transmission_tint(material: OpenPbrResolvedMaterial) -> vec3f {\n    if (HAS_MEDIUM & (material.mediumType > 0)) {\n        return vec3f(1.0);\n    }\n    return material.transmissionColor;\n}\n\nfn openpbr_thin_wall_fresnel(singleInterfaceFresnel: f32) -> f32 {\n    return 2.0 * singleInterfaceFresnel / (1.0 + singleInterfaceFresnel);\n}\n\nfn openpbr_thin_wall_reflection_coefficient(\n    singleInterfaceFresnel: vec3f,\n    transmissionWeight: f32\n) -> vec3f {\n    let windowFresnel = 2.0 * singleInterfaceFresnel\n        / (vec3f(1.0) + singleInterfaceFresnel);\n    return mix(\n        singleInterfaceFresnel,\n        windowFresnel,\n        clamp(transmissionWeight, 0.0, 1.0)\n    );\n}\n\nfn openpbr_final_transmission_tint(\n    material: OpenPbrResolvedMaterial,\n    incidentCosine: f32,\n    etaTOverEtaI: f32\n) -> vec3f {\n    let tint = openpbr_transmission_tint(material);\n    if (!material.thinWalled) {\n        return tint;\n    }\n    let incidentSineSquared = max(0.0, 1.0 - incidentCosine * incidentCosine);\n    let transmittedSineSquared = incidentSineSquared\n        / max(etaTOverEtaI * etaTOverEtaI, 1e-9);\n    if (transmittedSineSquared >= 1.0) {\n        return vec3f(0.0);\n    }\n    let transmittedCosine = sqrt(1.0 - transmittedSineSquared);\n    return pow(max(tint, vec3f(0.0)), vec3f(1.0 / max(transmittedCosine, 1e-5)));\n}\n\nfn openpbr_eval_subsurface_boundary(\n    material: OpenPbrResolvedMaterial,\n    viewLocal: vec3f,\n    lightLocal: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    *pdf = 0.0;\n    if ((viewLocal.z <= 0.0) | (lightLocal.z >= 0.0)) {\n        return vec3f(0.0);\n    }\n    let transmittedCosine = -lightLocal.z;\n    let entryFresnel = sampling_dielectric_fresnel(\n        viewLocal.z,\n        material.relativeIor\n    );\n    *pdf = transmittedCosine * INVPI;\n    return vec3f(1.0 - entryFresnel) * INVPI;\n}\n\nfn openpbr_normalize_probabilities(prepared: ptr<function, OpenPbrPreparedBsdf>) {\n    // Keep the loops dynamically bounded: explicit unrolling regresses Metal\n    // rendering performance. The uniform guard is four, covering all lobes.\n    let lobeCount = min(OPENPBR_LOBE_COUNT, i32(rtUniform.loopUnrollGuard * 2u));\n    var total = (*prepared).probabilities[OPENPBR_LOBE_FUZZ];\n    for (var lobe = 1; lobe < lobeCount; lobe++) {\n        total += (*prepared).probabilities[lobe];\n    }\n    if (total <= 1e-8) {\n        for (var lobe = 0; lobe < lobeCount; lobe++) {\n            (*prepared).probabilities[lobe] = 0.0;\n        }\n        return;\n    }\n    let inverseTotal = 1.0 / total;\n    for (var lobe = 0; lobe < lobeCount; lobe++) {\n        (*prepared).probabilities[lobe] *= inverseTotal;\n    }\n}\n\n// Adapted from Adobe c91aad1 impl/openpbr_lobe_utils.h and\n// impl/openpbr_bsdf.h::openpbr_prepare_lobes (Apache-2.0).\nfn openpbr_average_fresnel(eta: f32) -> f32 {\n    if (abs(eta - 1.0) < 1e-6) { return 0.0; }\n    if (eta > 1.0) { return (eta - 1.0) / (4.08567 + 1.00071 * eta); }\n    return 0.997118 + 0.1014 * eta - 0.965241 * eta * eta - 0.130607 * eta * eta * eta;\n}\n\nfn openpbr_metal_average_fresnel(f0: vec3f, tint: vec3f) -> vec3f {\n    let edgeCosine = 1.0 / 7.0;\n    let edgeFresnel = mix(f0, vec3f(1.0), sampling_schlick_fifth_power(edgeCosine));\n    let b = edgeFresnel * (vec3f(1.0) - tint) / (edgeCosine * pow(1.0 - edgeCosine, 6.0));\n    return clamp(f0 + (vec3f(1.0) - f0) / 21.0 - b / 126.0, vec3f(0.0), vec3f(1.0));\n}\n\n// Adobe openpbr_coating_lobe.h: one passage, using the refracted cosine.\n// Partial coverage is mixed separately for each passage, as in the reference.\nfn openpbr_coat_passage(material: OpenPbrResolvedMaterial, cosine: f32) -> vec3f {\n    if (cosine <= 0.0) { return vec3f(1.0); }\n    let refractedCosine = sqrt(max(0.0, 1.0 - (1.0 - cosine * cosine) / (material.coatIor * material.coatIor)));\n    let passage = pow(max(material.coatColor, vec3f(0.0)), vec3f(0.5 / max(refractedCosine, 1e-5)));\n    return mix(vec3f(1.0), passage, material.coatWeight);\n}\n\nfn openpbr_coat_energy(material: OpenPbrResolvedMaterial, cosine: f32) -> f32 {\n    if (material.coatRoughness <= ROUGHNESS_MIN) {\n        return openpbr_dielectric_fresnel(cosine, 1.0 / material.coatIor);\n    }\n    // The opaque-dielectric table is the complement of coat directional albedo.\n    // Adobe uses the original isotropic alpha (r^2) even for anisotropic GGX.\n    return clamp(1.0 - openpbr_opaque_energy_complement(material.coatIor,\n        material.coatRoughness * material.coatRoughness, cosine), 0.0, 1.0);\n}\n\nfn openpbr_coat_darkening(prepared: OpenPbrPreparedBsdf) -> vec3f {\n    let material = prepared.material;\n    let dielectric = 1.0 - material.baseMetalness;\n    let opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);\n    let sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;\n    let trans = dielectric * material.transmissionWeight;\n    let opaqueSpecularity = openpbr_average_fresnel(prepared.specularEtaTOverEtaI);\n    let transSpecularity = openpbr_average_fresnel(1.0 / prepared.transmissionReflectionIor);\n    let specularity = clamp(opaque * opaqueSpecularity + (sss + trans) * transSpecularity + material.baseMetalness, 0.0, 1.0);\n    let effectiveRoughness = mix(1.0, material.specularRoughness, specularity);\n    let ks = openpbr_average_fresnel(material.coatIor);\n    let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);\n    let k = mix(ks, kr, effectiveRoughness);\n    let eb = material.baseMetalness * material.specularWeight * openpbr_metal_average_fresnel(material.baseWeight * material.baseColor, material.specularColor)\n        + opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), opaqueSpecularity)\n        + sss * material.subsurfaceColor + vec3f(trans);\n    let delta = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));\n    return mix(vec3f(1.0), delta, material.coatWeight * material.coatDarkening);\n}\n\nfn openpbr_coat_base_scale(prepared: OpenPbrPreparedBsdf, lightCosine: f32) -> vec3f {\n    if (prepared.material.coatWeight <= 0.0) { return vec3f(1.0); }\n    if (prepared.material.inside) {\n        // Inside only outgoing transmission crosses the coat; no coat reflection.\n        return openpbr_coat_passage(prepared.material, -lightCosine);\n    }\n    // Default reference mode applies energy partition on the view side only.\n    return prepared.coatBaseScale * openpbr_coat_passage(prepared.material, lightCosine);\n}\n\n\n${hasAnisotropyDirections ? /* wgsl */ `\nfn openpbr_direction_basis(fallback: OpenPbrBasis, tangent: vec3f, bitangent: vec3f, direction: vec2f) -> OpenPbrBasis {\n    var t = tangent - fallback.normal * dot(fallback.normal, tangent);\n    if (dot(t, t) < 1e-8) { t = fallback.tangent; }\n    t = normalize(t);\n    let b = cross(fallback.normal, t) * select(1.0, -1.0, dot(cross(fallback.normal, t), bitangent) < 0.0);\n    t = t * direction.x + b * direction.y;\n    if (dot(t, t) < 1e-8) { return fallback; }\n    var basis = fallback;\n    basis.tangent = normalize(t);\n    basis.bitangent = normalize(cross(basis.normal, basis.tangent));\n    basis.tangent = normalize(cross(basis.bitangent, basis.normal));\n    return basis;\n}\n\n` : /* wgsl */ ``}\nfn openpbr_prepare(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    viewDirection: vec3f,\n    normal: vec3f\n) -> OpenPbrPreparedBsdf {\n    var prepared: OpenPbrPreparedBsdf;\n    prepared.material = material;\n    prepared.basis = openpbr_make_basis(\n        tangent,\n        normal,\n        max(material.specularAnisotropy, material.coatAnisotropy)\n    );\n${hasAnisotropyDirections ? /* wgsl */ `\n    prepared.coatBasis = prepared.basis;\n    prepared.directionFrames = false;\n${hasCoatNormals ? /* wgsl */ `\n    // Adobe c91aad1 openpbr_prepare_lobes: geometry_coat_basis is independent\n    // of the base shading basis; coat passage uses the same coat cosine.\n    if (material.coatNormalEnabled) {\n        prepared.coatBasis = openpbr_make_basis(material.geometryTangent, material.coatNormal, material.coatAnisotropy);\n        prepared.directionFrames = true;\n    }\n` : ''}\n    if ((material.specularAnisotropy > 0.0) & material.anisotropyDirectionEnabled) {\n        prepared.basis = openpbr_direction_basis(prepared.basis, material.directionTangent, material.directionBitangent, material.anisotropyDirection);\n        prepared.directionFrames = true;\n    }\n    if ((material.coatAnisotropy > 0.0) & (material.coatAnisotropyRotation != 0.0)) {\n        prepared.coatBasis = openpbr_direction_basis(prepared.coatBasis, material.geometryTangent, material.geometryBitangent, vec2f(cos(material.coatAnisotropyRotation), sin(material.coatAnisotropyRotation)));\n        prepared.directionFrames = true;\n    }\n` : /* wgsl */ ``}\n    prepared.viewLocal = openpbr_to_local(prepared.basis, viewDirection);\n${hasCoatNormals ? /* wgsl */ `    prepared.coatViewLocal = openpbr_to_local(prepared.coatBasis, viewDirection);` : ''}\n    prepared.diffuseColor = material.baseColor;\n\n    let dielectricBaseWeight = 1.0 - material.baseMetalness;\n    let opaqueDielectricWeight = dielectricBaseWeight\n        * (1.0 - material.transmissionWeight);\n    prepared.weights[OPENPBR_LOBE_FUZZ] = material.fuzzWeight;\n    prepared.weights[OPENPBR_LOBE_COAT] = material.coatWeight;\n    if (material.inside) { prepared.weights[OPENPBR_LOBE_COAT] = 0.0; }\n    prepared.weights[OPENPBR_LOBE_METAL] = material.baseMetalness;\n    prepared.weights[OPENPBR_LOBE_SPECULAR] = dielectricBaseWeight;\n    prepared.weights[OPENPBR_LOBE_TRANSMISSION] = dielectricBaseWeight\n        * material.transmissionWeight;\n    prepared.weights[OPENPBR_LOBE_DIFFUSE] = opaqueDielectricWeight\n        * (1.0 - material.subsurfaceWeight) * material.baseWeight;\n    prepared.weights[OPENPBR_LOBE_SUBSURFACE] = opaqueDielectricWeight\n        * material.subsurfaceWeight;\n\n    prepared.specularEtaTOverEtaI = openpbr_apply_specular_weight_to_ior(\n        1.0 / material.relativeIor,\n        material.specularWeight\n    );\n    prepared.material.relativeIor = 1.0 / prepared.specularEtaTOverEtaI;\n    prepared.refractionEtaTOverEtaI = prepared.specularEtaTOverEtaI;\n    prepared.transmissionReflectionIor = prepared.material.relativeIor;\n    // Adobe openpbr_bsdf.h::openpbr_prepare_lobes: reflect relative to\n    // the weighted coat, refract relative to ambient air. Inside ignores coat.\n    if (material.coatWeight > 0.0) {\n        var weightedCoatIor = 1.0;\n        if (!material.inside) { weightedCoatIor = mix(1.0, material.coatIor, material.coatWeight); }\n        let weightedBaseIor = weightedCoatIor * openpbr_apply_specular_weight_to_ior(\n            material.specularIor / weightedCoatIor, material.specularWeight);\n        var reflectionEta = weightedBaseIor / weightedCoatIor;\n        if ((weightedCoatIor > weightedBaseIor) & (weightedBaseIor >= 1.0)) {\n            reflectionEta = 1.0 / reflectionEta;\n        }\n        prepared.specularEtaTOverEtaI = reflectionEta;\n        prepared.transmissionReflectionIor = 1.0 / reflectionEta;\n        prepared.refractionEtaTOverEtaI = weightedBaseIor;\n        if (material.inside) {\n            prepared.refractionEtaTOverEtaI = 1.0 / weightedBaseIor;\n            prepared.transmissionReflectionIor = weightedBaseIor;\n        }\n        prepared.material.relativeIor = 1.0 / prepared.refractionEtaTOverEtaI;\n    }\n\n    // Adobe openpbr_bsdf.h::openpbr_prepare_lobes: absolute thin-film media.\n    // Preserve the existing optical solve for uncoated materials.\n    prepared.thinFilmExteriorIor = 1.0;\n    prepared.thinFilmBaseIor = prepared.specularEtaTOverEtaI;\n    if (material.coatWeight > 0.0) {\n        if (material.inside) {\n            prepared.thinFilmExteriorIor = 1.0 / prepared.refractionEtaTOverEtaI;\n            prepared.thinFilmBaseIor = 1.0;\n        }\n        else {\n            prepared.thinFilmExteriorIor = mix(1.0, material.coatIor, material.coatWeight);\n            prepared.thinFilmBaseIor = prepared.refractionEtaTOverEtaI;\n        }\n    }\n    prepared.specularAlpha = material.specularRoughness\n        * material.specularRoughness;\n    let viewCosine = abs(prepared.viewLocal.z);\n    let singleInterfaceFresnel = openpbr_dielectric_fresnel(\n        viewCosine,\n        1.0 / prepared.specularEtaTOverEtaI\n    );\n    let dielectricFresnelEstimate = material.specularColor * select(\n        singleInterfaceFresnel,\n        mix(\n            singleInterfaceFresnel,\n            openpbr_thin_wall_fresnel(singleInterfaceFresnel),\n            material.transmissionWeight\n        ),\n        material.thinWalled\n    );\n    let metalFresnelEstimate = material.specularWeight * openpbr_metal_fresnel(\n        viewCosine,\n        material.baseWeight * material.baseColor,\n        material.specularColor\n    );\n    let transmissionFresnel = select(\n        openpbr_dielectric_fresnel(viewCosine, prepared.transmissionReflectionIor),\n        openpbr_thin_wall_fresnel(openpbr_dielectric_fresnel(viewCosine, prepared.transmissionReflectionIor)),\n        material.thinWalled\n    );\n    let transmissionTint = openpbr_final_transmission_tint(\n        material,\n        viewCosine,\n        prepared.refractionEtaTOverEtaI\n    );\n    let viewEnergyComplement = openpbr_opaque_energy_complement(\n        prepared.specularEtaTOverEtaI,\n        prepared.specularAlpha,\n        viewCosine\n    );\n    let averageEnergyComplement = openpbr_opaque_average_energy_complement(\n        prepared.specularEtaTOverEtaI,\n        prepared.specularAlpha\n    );\n    prepared.diffuseSpecularEnergyCompensation = viewEnergyComplement\n        / max(averageEnergyComplement, 1e-12);\n\n    prepared.probabilities[OPENPBR_LOBE_FUZZ] = prepared.weights[OPENPBR_LOBE_FUZZ]\n        * openpbr_luminance(material.fuzzColor)\n        * max(openpbr_fuzz_directional_albedo(\n            viewCosine,\n            material.fuzzRoughness\n        ), 0.02);\n    prepared.probabilities[OPENPBR_LOBE_COAT] = 0.0;\n    prepared.coatBaseScale = vec3f(1.0);\n    if ((material.coatWeight > 0.0) & !material.inside) {\n        ${hasCoatNormals ? /* wgsl */ `let coatViewCosine = select(viewCosine, max(prepared.coatViewLocal.z, 0.0), material.coatNormalEnabled);` : ''}\n        let coatEnergy = openpbr_coat_energy(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'});\n        prepared.probabilities[OPENPBR_LOBE_COAT] = prepared.weights[OPENPBR_LOBE_COAT] * coatEnergy;\n        prepared.coatBaseScale = openpbr_coat_passage(material, ${hasCoatNormals ? 'coatViewCosine' : 'viewCosine'})\n            * (1.0 - prepared.weights[OPENPBR_LOBE_COAT] * coatEnergy) * openpbr_coat_darkening(prepared);\n    }\n    prepared.probabilities[OPENPBR_LOBE_METAL] = prepared.weights[OPENPBR_LOBE_METAL]\n        * openpbr_luminance(metalFresnelEstimate);\n    prepared.metalMsScale = vec3f(0.0);\n    prepared.metalMsFactor = 0.0;\n    prepared.metalMsProbability = 0.0;\n    // Reference suppresses loss below roughness .04 and uses the original\n    // isotropic alpha even when the single-scattering lobe is anisotropic.\n    if ((material.specularRoughness >= 0.04) & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0)) {\n        let averageFresnel = openpbr_metal_average_fresnel(material.baseWeight * material.baseColor, material.specularColor);\n        prepared.metalMsScale = material.specularWeight * averageFresnel * averageFresnel;\n        let viewLoss = openpbr_metal_energy_complement(prepared.specularAlpha, viewCosine);\n        prepared.metalMsFactor = viewLoss / max(openpbr_metal_average_energy_complement(prepared.specularAlpha), 1e-12);\n        let msEstimate = prepared.weights[OPENPBR_LOBE_METAL] * openpbr_luminance(prepared.metalMsScale) * viewLoss;\n        prepared.probabilities[OPENPBR_LOBE_METAL] += msEstimate;\n        prepared.metalMsProbability = msEstimate / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);\n    }\n    prepared.probabilities[OPENPBR_LOBE_SPECULAR] = prepared.weights[OPENPBR_LOBE_SPECULAR]\n        * openpbr_luminance(dielectricFresnelEstimate);\n    prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] = prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n        * (1.0 - transmissionFresnel)\n        * openpbr_luminance(transmissionTint);\n    // OpenPBR_DielectricMicrofacetMultipleScatteringLobe, Adobe c91aad1\n    // (Apache-2.0). Use the refraction IOR even when coat reflection uses a\n    // different ratio. Restrict this addition to solid transmissive materials;\n    // opaque/subsurface-only and thin-wall paths retain their existing model.\n    // Keep the renderer's exact null boundary discrete: upstream avoids eta=1\n    // for refraction, and its tabulation has small nonzero loss there.\n    prepared.dielectricMsReflectionScale = vec3f(0.0);\n    prepared.dielectricMsTransmissionScale = vec3f(0.0);\n    prepared.dielectricMsViewLoss = 0.0;\n    prepared.dielectricMsReflectionRatio = 0.0;\n    prepared.dielectricMsProbability = 0.0;\n    if (!material.thinWalled & (material.transmissionWeight > 0.0) &\n        (prepared.specularAlpha >= 0.0016) & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) &\n        (abs(prepared.refractionEtaTOverEtaI - 1.0) > 1e-6)) {\n        let nonOpaqueWeight = prepared.weights[OPENPBR_LOBE_TRANSMISSION] + prepared.weights[OPENPBR_LOBE_SUBSURFACE];\n        prepared.dielectricMsReflectionScale = select(material.specularColor, vec3f(1.0), material.inside) * nonOpaqueWeight;\n        prepared.dielectricMsTransmissionScale = transmissionTint * prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n            + vec3f(prepared.weights[OPENPBR_LOBE_SUBSURFACE]);\n        prepared.dielectricMsReflectionRatio = openpbr_ideal_dielectric_reflection_ratio(prepared.refractionEtaTOverEtaI, prepared.specularAlpha);\n        prepared.dielectricMsViewLoss = openpbr_ideal_dielectric_loss(prepared.refractionEtaTOverEtaI, prepared.specularAlpha, viewCosine);\n        let averageScale = mix(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, prepared.dielectricMsReflectionRatio);\n        let msEstimate = openpbr_luminance(averageScale) * prepared.dielectricMsViewLoss;\n        prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] += msEstimate;\n        prepared.dielectricMsProbability = msEstimate / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);\n    }\n    prepared.probabilities[OPENPBR_LOBE_DIFFUSE] = prepared.weights[OPENPBR_LOBE_DIFFUSE]\n        * openpbr_luminance(prepared.diffuseColor)\n        * prepared.diffuseSpecularEnergyCompensation;\n    prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] = prepared.weights[OPENPBR_LOBE_SUBSURFACE]\n        * (1.0 - transmissionFresnel)\n        * openpbr_luminance(material.subsurfaceColor)\n        * prepared.diffuseSpecularEnergyCompensation;\n    // Index-matched base interfaces can still reflect through thin film.\n    // Keep proposal support without duplicating the Airy optical solve here.\n    if ((material.coatWeight > 0.0) & HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {\n        let filmSupport = 0.02 * openpbr_thin_film_presence(material.thinFilmThickness, material.thinFilmWeight);\n        prepared.probabilities[OPENPBR_LOBE_SPECULAR] = max(prepared.probabilities[OPENPBR_LOBE_SPECULAR], prepared.weights[OPENPBR_LOBE_SPECULAR] * filmSupport);\n        prepared.probabilities[OPENPBR_LOBE_METAL] = max(prepared.probabilities[OPENPBR_LOBE_METAL], prepared.weights[OPENPBR_LOBE_METAL] * material.specularWeight * filmSupport);\n    }\n    if ((material.coatWeight > 0.0) & !material.inside) {\n        let baseScale = max(max(prepared.coatBaseScale.x, prepared.coatBaseScale.y), prepared.coatBaseScale.z);\n        prepared.probabilities[OPENPBR_LOBE_METAL] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_SPECULAR] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_DIFFUSE] *= baseScale;\n        prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] *= baseScale;\n    }\n    openpbr_normalize_probabilities(&prepared);\n    return prepared;\n}\n\n\nfn openpbr_substrate_fresnel(prepared: OpenPbrPreparedBsdf, cosine: f32, reflection: bool) -> f32 {\n    if (prepared.material.coatWeight <= 0.0) {\n        return openpbr_dielectric_fresnel(cosine, prepared.material.relativeIor);\n    }\n    let transFresnel = openpbr_dielectric_fresnel(cosine, prepared.transmissionReflectionIor);\n    if (!reflection) { return transFresnel; }\n    let opaqueFresnel = openpbr_dielectric_fresnel(cosine, 1.0 / prepared.specularEtaTOverEtaI);\n    let nonOpaque = prepared.material.transmissionWeight + (1.0 - prepared.material.transmissionWeight) * prepared.material.subsurfaceWeight;\n    return mix(opaqueFresnel, transFresnel, nonOpaque);\n}\n\nfn openpbr_eval_prepared_lobe(\n    prepared: OpenPbrPreparedBsdf,\n    lightDirection: vec3f,\n    allowedLobe: i32,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    let material = prepared.material;\n    let viewLocal = prepared.viewLocal;\n    let lightLocal = openpbr_to_local(prepared.basis, lightDirection);\n    let reflection = lightLocal.z * viewLocal.z > 0.0;\n${hasCoatNormals ? /* wgsl */ `\n    let independentCoat = material.coatNormalEnabled;\n    let geometricReflection = dot(material.geometricNormal, lightDirection) > 0.0;\n    let coatLightCosine = dot(prepared.coatBasis.normal, lightDirection);\n    let coatReflection = geometricReflection & (prepared.coatViewLocal.z > 0.0) & (coatLightCosine > 0.0);\n` : ''}\n\n    var halfVector: vec3f;\n    if (reflection) {\n        halfVector = normalize(lightLocal + viewLocal);\n    }\n    else {\n        halfVector = normalize(lightLocal + viewLocal * material.relativeIor);\n    }\n    if (halfVector.z < 0.0) {\n        halfVector = -halfVector;\n    }\n\n    var response = vec3f(0.0);\n    *pdf = 0.0;\n    var lobePdf = 0.0;\n    let allowAll = allowedLobe < 0;\n    let allowFuzz = allowAll | (allowedLobe == OPENPBR_LOBE_FUZZ);\n    let allowCoat = allowAll | (allowedLobe == OPENPBR_LOBE_COAT);\n    let allowMetal = allowAll | (allowedLobe == OPENPBR_LOBE_METAL);\n    let allowSpecular = allowAll | (allowedLobe == OPENPBR_LOBE_SPECULAR);\n    let allowTransmission = allowAll | (allowedLobe == OPENPBR_LOBE_TRANSMISSION);\n    let allowDiffuse = allowAll | (allowedLobe == OPENPBR_LOBE_DIFFUSE);\n    let allowSubsurface = allowAll | (allowedLobe == OPENPBR_LOBE_SUBSURFACE);\n    let viewHalf = abs(dot(viewLocal, halfVector));\n    // Reflection, solid refraction and thin-wall transmission share the same\n    // dielectric optical solve. Select its half angle before evaluating the\n    // film, instead of inlining that large solve in each transport branch.\n    var thinWallHalf = halfVector;\n    var dielectricViewHalf = viewHalf;\n    if (!reflection & material.thinWalled) {\n        thinWallHalf = normalize(vec3f(lightLocal.xy, -lightLocal.z) + viewLocal);\n        if (thinWallHalf.z < 0.0) { thinWallHalf = -thinWallHalf; }\n        dielectricViewHalf = abs(dot(viewLocal, thinWallHalf));\n    }\n    let evaluateDielectric =\n        (reflection & (prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & allowSpecular) |\n        (!reflection & (prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & allowTransmission);\n    let evaluateMetal = reflection & (prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & allowMetal;\n    var fresnels: array<vec3f, 2>;\n    if (evaluateDielectric) {\n        fresnels[0] = vec3f(openpbr_substrate_fresnel(prepared, dielectricViewHalf, reflection));\n    }\n    if (evaluateMetal) {\n        fresnels[1] = openpbr_metal_fresnel(viewHalf, material.baseWeight * material.baseColor, material.specularColor);\n    }\n    if (HAS_THIN_FILM & (material.thinFilmWeight > 0.0)) {\n        let wavelengths = vec3f(620.0, 540.0, 450.0);\n        // Dielectric and conductor substrates share one complete optical graph.\n        for (var substrate = 0u; substrate < (rtUniform.loopUnrollGuard >> 1u); substrate++) {\n            if (!select(evaluateDielectric, evaluateMetal, substrate == 1u)) { continue; }\n            var film = vec3f(0.0);\n            let incidentCosine = select(dielectricViewHalf, viewHalf, substrate == 1u);\n            for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {\n                var ior = vec2f(prepared.thinFilmBaseIor, 0.0);\n                if (substrate == 1u) {\n                    ior = openpbr_metal_complex_ior(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);\n                }\n                film[channel] = openpbr_thin_film_reflectance_channel(incidentCosine,\n                    wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);\n            }\n            fresnels[substrate] = mix(fresnels[substrate], film,\n                openpbr_thin_film_presence(material.thinFilmThickness, material.thinFilmWeight));\n        }\n    }\n    let substrateFresnel = fresnels[0];\n    let diffuseSpecularEnergyCompensation =\n        prepared.diffuseSpecularEnergyCompensation\n        * openpbr_opaque_energy_complement(\n            prepared.specularEtaTOverEtaI,\n            prepared.specularAlpha,\n            abs(lightLocal.z)\n        );\n\n${hasCoatNormals ? /* wgsl */ `\n    // Each lobe retains its own shading hemisphere; topology is geometric.\n    if (!independentCoat | ((lightLocal.z != 0.0) & (reflection == geometricReflection))) {\n` : ''}\n    if (reflection) {\n        if ((prepared.weights[OPENPBR_LOBE_DIFFUSE] > 0.0) & allowDiffuse) {\n            response += prepared.weights[OPENPBR_LOBE_DIFFUSE] * openpbr_eval_diffuse(\n                material,\n                prepared.diffuseColor,\n                viewLocal,\n                lightLocal,\n                diffuseSpecularEnergyCompensation,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_DIFFUSE] * lobePdf;\n        }\n\n        if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & material.thinWalled & allowSubsurface) {\n            response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE] * openpbr_eval_diffuse(\n                material,\n                material.subsurfaceColor,\n                viewLocal,\n                lightLocal,\n                diffuseSpecularEnergyCompensation,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * 0.5 * lobePdf;\n        }\n\n        if ((prepared.weights[OPENPBR_LOBE_SPECULAR] > 0.0) & allowSpecular) {\n            var dielectricFresnel = substrateFresnel;\n            if (material.thinWalled) {\n                dielectricFresnel = openpbr_thin_wall_reflection_coefficient(\n                    dielectricFresnel,\n                    material.transmissionWeight\n                );\n            }\n            let fresnel = material.specularColor * dielectricFresnel;\n            response += prepared.weights[OPENPBR_LOBE_SPECULAR] * openpbr_eval_microfacet_reflection(\n                material,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                fresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SPECULAR] * lobePdf;\n        }\n\n        if ((prepared.weights[OPENPBR_LOBE_METAL] > 0.0) & allowMetal) {\n            let fresnel = material.specularWeight * fresnels[1];\n            response += prepared.weights[OPENPBR_LOBE_METAL] * openpbr_eval_microfacet_reflection(\n                material,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                fresnel,\n                &lobePdf\n            );\n            if (prepared.metalMsFactor > 0.0) {\n                let factor = min(prepared.metalMsFactor * openpbr_metal_energy_complement(prepared.specularAlpha, lightLocal.z), 1.0 / max(lightLocal.z, 1e-8));\n                response += prepared.weights[OPENPBR_LOBE_METAL] * prepared.metalMsScale * factor * INVPI;\n                lobePdf = mix(lobePdf, 0.5 * INVPI, prepared.metalMsProbability);\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_METAL] * lobePdf;\n        }\n    }\n    else {\n        let fresnel = substrateFresnel;\n        if ((prepared.weights[OPENPBR_LOBE_TRANSMISSION] > 0.0) & allowTransmission) {\n            if (material.thinWalled) {\n                let mirroredLight = vec3f(lightLocal.xy, -lightLocal.z);\n                let windowFresnel = openpbr_thin_wall_reflection_coefficient(\n                    substrateFresnel,\n                    1.0\n                );\n                let tint = openpbr_final_transmission_tint(\n                    material,\n                    abs(viewLocal.z),\n                    prepared.refractionEtaTOverEtaI\n                );\n                response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n                    * openpbr_eval_microfacet_reflection(\n                        material,\n                        viewLocal,\n                        mirroredLight,\n                        thinWallHalf,\n                        tint * (vec3f(1.0) - windowFresnel),\n                        &lobePdf\n                    );\n            }\n            else {\n                response += prepared.weights[OPENPBR_LOBE_TRANSMISSION]\n                    * openpbr_eval_microfacet_refraction(\n                        material,\n                        material.relativeIor,\n                        openpbr_transmission_tint(material),\n                        viewLocal,\n                        lightLocal,\n                        halfVector,\n                        fresnel,\n                        &lobePdf\n                    );\n            }\n            if (prepared.dielectricMsProbability > 0.0) {\n                lobePdf *= 1.0 - prepared.dielectricMsProbability;\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * lobePdf;\n        }\n        if ((prepared.weights[OPENPBR_LOBE_SUBSURFACE] > 0.0) & allowSubsurface) {\n            if (material.thinWalled) {\n                let flippedLight = vec3f(lightLocal.xy, -lightLocal.z);\n                response += 0.5 * prepared.weights[OPENPBR_LOBE_SUBSURFACE]\n                    * openpbr_eval_diffuse(\n                        material,\n                        material.subsurfaceColor,\n                        viewLocal,\n                        flippedLight,\n                        diffuseSpecularEnergyCompensation,\n                        &lobePdf\n                    );\n                lobePdf *= 0.5;\n            }\n            else {\n                response += prepared.weights[OPENPBR_LOBE_SUBSURFACE] * openpbr_eval_subsurface_boundary(\n                    material,\n                    viewLocal,\n                    lightLocal,\n                    &lobePdf\n                );\n            }\n            *pdf += prepared.probabilities[OPENPBR_LOBE_SUBSURFACE] * lobePdf;\n        }\n    }\n\n    // Reference value includes the hemisphere ratio before the grazing clamp.\n    // Reference scale_trans has no extra eta^2 factor; single refraction keeps\n    // its existing radiance Jacobian. Both proposals share the aggregate PDF.\n    if ((prepared.dielectricMsProbability > 0.0) & allowTransmission) {\n        let cosine = abs(lightLocal.z);\n        if (cosine > 0.0) {\n            let ior = select(1.0 / prepared.refractionEtaTOverEtaI, prepared.refractionEtaTOverEtaI, reflection);\n            let ratio = select(1.0 - prepared.dielectricMsReflectionRatio, prepared.dielectricMsReflectionRatio, reflection);\n            let factors = prepared.dielectricMsViewLoss * openpbr_ideal_dielectric_loss(ior, prepared.specularAlpha, cosine)\n                / max(openpbr_ideal_dielectric_average_loss(ior, prepared.specularAlpha), 1e-12);\n            let factor = min(factors * ratio, 1.0 / cosine);\n            let scale = select(prepared.dielectricMsTransmissionScale, prepared.dielectricMsReflectionScale, reflection);\n            response += scale * factor * INVPI;\n            *pdf += prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] * prepared.dielectricMsProbability * ratio * 0.5 * INVPI;\n        }\n    }\n\n${hasCoatNormals ? /* wgsl */ `    } // base hemisphere support` : ''}\n    if (material.coatWeight > 0.0) {\n        response *= openpbr_coat_base_scale(prepared, ${hasCoatNormals ? 'select(lightLocal.z, coatLightCosine, independentCoat)' : 'lightLocal.z'});\n    }\n${hasCoatNormals ? /* wgsl */ `\n    // Values are BSDF*cos in world solid angle before the frames are combined.\n    if (independentCoat) { response *= abs(lightLocal.z); }\n` : ''}\n\n${hasAnisotropyDirections ? /* wgsl */ `\n    if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {\n        var coatView = viewLocal;\n        var coatLight = lightLocal;\n        var coatHalf = halfVector;\n        var coatViewHalf = viewHalf;\n        if (prepared.directionFrames) {\n            coatView = ${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))'};\n            coatLight = openpbr_to_local(prepared.coatBasis, lightDirection);\n            coatHalf = normalize(coatLight + coatView);\n            if (coatHalf.z < 0.0) { coatHalf = -coatHalf; }\n            coatViewHalf = abs(dot(coatView, coatHalf));\n        }\n\n        let coatFresnel = vec3f(openpbr_dielectric_fresnel(\n            coatViewHalf,\n            1.0 / material.coatIor\n        ));\n        var coatMaterial = material;\n        let coatAlpha = openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy);\n        coatMaterial.alphaX = coatAlpha.x;\n        coatMaterial.alphaY = coatAlpha.y;\n        if (allowCoat) {\n            response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * openpbr_eval_microfacet_reflection(\n                coatMaterial,\n                coatView,\n                coatLight,\n                coatHalf,\n                coatFresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;\n        }\n    }\n` : /* wgsl */ `\n    if (${hasCoatNormals ? 'select(reflection, coatReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_COAT] > 0.0)) {\n        let coatFresnel = vec3f(openpbr_dielectric_fresnel(\n            viewHalf,\n            1.0 / material.coatIor\n        ));\n        var coatMaterial = material;\n        let coatAlpha = openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy);\n        coatMaterial.alphaX = coatAlpha.x;\n        coatMaterial.alphaY = coatAlpha.y;\n        if (allowCoat) {\n            response += prepared.weights[OPENPBR_LOBE_COAT]${hasCoatNormals ? ' * select(1.0, max(coatLightCosine, 0.0), independentCoat)' : ''} * openpbr_eval_microfacet_reflection(\n                coatMaterial,\n                viewLocal,\n                lightLocal,\n                halfVector,\n                coatFresnel,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_COAT] * lobePdf;\n        }\n    }\n`}\n\n    if (${hasCoatNormals ? 'select(reflection, geometricReflection, independentCoat)' : 'reflection'} & (prepared.weights[OPENPBR_LOBE_FUZZ] > 0.0)) {\n        let fuzzAlbedo = openpbr_fuzz_directional_albedo(\n            abs(viewLocal.z),\n            material.fuzzRoughness\n        );\n        response *= max(\n            vec3f(0.0),\n            vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * fuzzAlbedo)\n        );\n        if (allowFuzz) {\n            response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * openpbr_eval_fuzz(\n                material,\n                viewLocal,\n                lightLocal,\n                &lobePdf\n            );\n            *pdf += prepared.probabilities[OPENPBR_LOBE_FUZZ] * lobePdf;\n        }\n    }\n\n    return response * ${hasCoatNormals ? 'select(abs(lightLocal.z), 1.0, independentCoat)' : 'abs(lightLocal.z)'};\n}\n\nfn openpbr_eval_prepared(\n    prepared: OpenPbrPreparedBsdf,\n    lightDirection: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    return openpbr_eval_prepared_lobe(prepared, lightDirection, -1, pdf);\n}\n\n\n\n\n\nfn openpbr_eval(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    viewDirection: vec3f,\n    normal: vec3f,\n    lightDirection: vec3f,\n    pdf: ptr<function, f32>\n) -> vec3f {\n    let prepared = openpbr_prepare(\n        tangent,\n        material,\n        viewDirection,\n        normal\n    );\n    return openpbr_eval_prepared(prepared, lightDirection, pdf);\n}\n\n\n\n\n// Direction-only proposals do not require the layered response or film optics.\nfn openpbr_sample_direction(\n    prepared: OpenPbrPreparedBsdf, randomSamples: vec3f,\n    lightDirection: ptr<function, vec3f>, isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>, sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>, sampledLobeIndex: ptr<function, u32>\n) -> bool {\n    let material = prepared.material;\n    let viewLocal = prepared.viewLocal;\n    var randomX = randomSamples.x;\n    let randomY = randomSamples.y;\n    let lobeSample = randomSamples.z;\n    *isTransmissionEvent = false;\n    *sampledLobeRoughness = 1.0;\n    *sampledLobeSpecular = false;\n    *sampledLobeDiffuse = false;\n    *sampledLobeIndex = u32(OPENPBR_LOBE_DIFFUSE);\n    *lightDirection = prepared.basis.normal;\n\n    var cdf: array<f32, OPENPBR_LOBE_COUNT>;\n    cdf[OPENPBR_LOBE_FUZZ] = prepared.probabilities[OPENPBR_LOBE_FUZZ];\n    ${LOBE_INDICES.slice(1).map(i => /* wgsl */ `cdf[${i}] = cdf[${i - 1}] + prepared.probabilities[${i}];`).join('\\n    ')}\n    if (cdf[OPENPBR_LOBE_SUBSURFACE] <= 0.0) {\n        return false;\n    }\n\n    var lightLocal: vec3f;\n    if ((lobeSample < cdf[OPENPBR_LOBE_FUZZ]) | (\n        (lobeSample >= cdf[OPENPBR_LOBE_TRANSMISSION]) & (lobeSample < cdf[OPENPBR_LOBE_DIFFUSE])\n    )) {\n        let sampledFuzz = lobeSample < cdf[OPENPBR_LOBE_FUZZ];\n        *sampledLobeRoughness = select(\n            1.0,\n            material.fuzzRoughness,\n            sampledFuzz\n        );\n        *sampledLobeDiffuse = !sampledFuzz;\n        *sampledLobeIndex = select(\n            u32(OPENPBR_LOBE_DIFFUSE),\n            u32(OPENPBR_LOBE_FUZZ),\n            sampledFuzz\n        );\n        lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n    }\n${hasAnisotropyDirections ? /* wgsl */ `\n    else if (lobeSample < cdf[OPENPBR_LOBE_COAT]) {\n        *sampledLobeRoughness = material.coatRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_COAT);\n        var coatView = viewLocal;\n        if (prepared.directionFrames) { coatView = ${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))'}; }\n        var halfVector = sampling_ggx_visible_normal(\n            coatView,\n            // The VNDF must use the same alpha as the evaluated coat PDF.\n            openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy),\n            vec2f(randomX, randomY)\n        );\n        if (halfVector.z < 0.0) {\n            halfVector = -halfVector;\n        }\n        lightLocal = normalize(reflect(-coatView, halfVector));\n${hasCoatNormals ? /* wgsl */ `\n        if (material.coatNormalEnabled) {\n            // Validate against the sampled coat frame, never the base normal.\n            *lightDirection = openpbr_to_world(prepared.coatBasis, lightLocal);\n            return (lightLocal.z > 0.0) & (dot(material.geometricNormal, *lightDirection) > 0.0);\n        }\n` : ''}\n        if (prepared.directionFrames) { lightLocal = openpbr_to_local(prepared.basis, openpbr_to_world(prepared.coatBasis, lightLocal)); }\n    }\n` : /* wgsl */ `\n    else if (lobeSample < cdf[OPENPBR_LOBE_COAT]) {\n        *sampledLobeRoughness = material.coatRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_COAT);\n        var halfVector = sampling_ggx_visible_normal(\n            viewLocal,\n            // The VNDF must use the same alpha as the evaluated coat PDF.\n            openpbr_roughness_to_alpha(material.coatRoughness, material.coatAnisotropy),\n            vec2f(randomX, randomY)\n        );\n        if (halfVector.z < 0.0) {\n            halfVector = -halfVector;\n        }\n        lightLocal = normalize(reflect(-viewLocal, halfVector));\n    }\n`}\n    else if (lobeSample < cdf[OPENPBR_LOBE_SPECULAR]) {\n        *sampledLobeRoughness = material.specularRoughness;\n        *sampledLobeSpecular = true;\n        *sampledLobeIndex = select(\n            u32(OPENPBR_LOBE_SPECULAR),\n            u32(OPENPBR_LOBE_METAL),\n            lobeSample < cdf[OPENPBR_LOBE_METAL]\n        );\n        let isMetal = lobeSample < cdf[OPENPBR_LOBE_METAL];\n        let metalDraw = (lobeSample - cdf[OPENPBR_LOBE_COAT]) / max(prepared.probabilities[OPENPBR_LOBE_METAL], 1e-12);\n        if (isMetal & (metalDraw < prepared.metalMsProbability)) {\n            let z = randomX;\n            let radial = sqrt(max(0.0, 1.0 - z * z));\n            let azimuth = TWOPI * randomY;\n            lightLocal = vec3f(radial * cos(azimuth), radial * sin(azimuth), z);\n        }\n        else {\n            var halfVector = sampling_ggx_visible_normal(\n                viewLocal,\n                vec2f(material.alphaX, material.alphaY),\n                vec2f(randomX, randomY)\n            );\n            if (halfVector.z < 0.0) {\n                halfVector = -halfVector;\n            }\n            lightLocal = normalize(reflect(-viewLocal, halfVector));\n        }\n    }\n    else if (lobeSample < cdf[OPENPBR_LOBE_TRANSMISSION]) {\n        *sampledLobeRoughness = material.specularRoughness;\n        *sampledLobeSpecular = true;\n        *isTransmissionEvent = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_TRANSMISSION);\n        // Split the existing BSDF_LOBE interval. BSDF_DIRECTION retains its\n        // two dimensions; rand.x selects and remaps the reference hemisphere.\n        let msDraw = (lobeSample - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);\n        if ((prepared.dielectricMsProbability > 0.0) & (msDraw < prepared.dielectricMsProbability)) {\n            let ratio = prepared.dielectricMsReflectionRatio;\n            let reflectMs = randomX < ratio;\n            var z: f32;\n            if (reflectMs) { z = min(randomX / ratio, 0.99999994); }\n            else { z = -min((randomX - ratio) / (1.0 - ratio), 0.99999994); }\n            let radial = sqrt(max(0.0, 1.0 - z * z));\n            let azimuth = TWOPI * randomY;\n            lightLocal = vec3f(radial * cos(azimuth), radial * sin(azimuth), z);\n            *isTransmissionEvent = !reflectMs;\n            *sampledLobeIndex = select(u32(OPENPBR_LOBE_TRANSMISSION), u32(OPENPBR_LOBE_SPECULAR), reflectMs);\n        }\n        else {\n            var halfVector = sampling_ggx_visible_normal(\n                viewLocal,\n                vec2f(material.alphaX, material.alphaY),\n                vec2f(randomX, randomY)\n            );\n            if (halfVector.z < 0.0) {\n                halfVector = -halfVector;\n            }\n            if (material.thinWalled) {\n                let reflectedLocal = normalize(reflect(-viewLocal, halfVector));\n                lightLocal = vec3f(reflectedLocal.xy, -reflectedLocal.z);\n            }\n            else {\n                lightLocal = refract(\n                    -viewLocal,\n                    halfVector,\n                    prepared.material.relativeIor\n                );\n                if (dot(lightLocal, lightLocal) <= 1e-8) {\n                    *isTransmissionEvent = false;\n                    return false;\n                }\n                lightLocal = normalize(lightLocal);\n            }\n        }\n    }\n    else {\n        *sampledLobeRoughness = 1.0;\n        *sampledLobeDiffuse = true;\n        *isTransmissionEvent = true;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_SUBSURFACE);\n        if (material.thinWalled) {\n            let transmit = randomX >= 0.5;\n            if (transmit) {\n                randomX = (randomX - 0.5) * 2.0;\n            }\n            else {\n                randomX *= 2.0;\n            }\n            lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n            if (transmit) {\n                lightLocal.z = -lightLocal.z;\n            }\n            else {\n                *isTransmissionEvent = false;\n            }\n        }\n        else {\n            lightLocal = sampling_cosine_hemisphere(vec2f(randomX, randomY));\n            lightLocal.z = -lightLocal.z;\n        }\n    }\n\n    *lightDirection = openpbr_to_world(prepared.basis, lightLocal);\n    // VNDF reflection may land below the macrosurface. A mirrored thin-wall\n    // transmission draw can likewise land above it. Reject that draw before\n    // aggregate evaluation can accidentally turn it into the opposite lobe.\n    if ((lightLocal.z == 0.0) | ((lightLocal.z < 0.0) != *isTransmissionEvent)) {\n        return false;\n    }\n${hasCoatNormals ? /* wgsl */ `\n    if (material.coatNormalEnabled &\n        ((dot(material.geometricNormal, *lightDirection) <= 0.0) != *isTransmissionEvent)) { return false; }\n` : ''}\n    return true;\n}\n\nfn openpbr_sample_prepared(\n    prepared: OpenPbrPreparedBsdf,\n    randomSamples: vec3f,\n    lightDirection: ptr<function, vec3f>,\n    pdf: ptr<function, f32>,\n    isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>,\n    sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>,\n    sampledLobeIndex: ptr<function, u32>,\n    marginalPdf: ptr<function, f32>,\n    fullResponse: ptr<function, vec3f>\n) -> vec3f {\n    *pdf = 0.0;\n    *marginalPdf = 0.0;\n    *fullResponse = vec3f(0.0);\n    // Solid microfacet refraction is singular at exactly eta=1: the usual\n    // half vector normalizes light + eta * view, which is zero for straight\n    // transmission. Resolve the physically null boundary as a discrete,\n    // unit-throughput continuation instead of losing the path to NaNs.\n    if (!prepared.material.thinWalled &\n        (abs(prepared.material.relativeIor - 1.0) <= 1e-6) &\n        (prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6)) {\n        *lightDirection = openpbr_to_world(\n            prepared.basis,\n            -prepared.viewLocal\n        );\n        let nullBoundaryTint = openpbr_transmission_tint(prepared.material)\n            * openpbr_coat_base_scale(prepared, ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, *lightDirection), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});\n        *pdf = 1.0;\n        *marginalPdf = 1.0;\n        *fullResponse = nullBoundaryTint;\n        *isTransmissionEvent = true;\n        *sampledLobeRoughness = 0.0;\n        *sampledLobeSpecular = true;\n        *sampledLobeDiffuse = false;\n        *sampledLobeIndex = u32(OPENPBR_LOBE_TRANSMISSION);\n        return nullBoundaryTint;\n    }\n    if (!openpbr_sample_direction(prepared, randomSamples, lightDirection,\n        isTransmissionEvent, sampledLobeRoughness, sampledLobeSpecular,\n        sampledLobeDiffuse, sampledLobeIndex)) { return vec3f(0.0); }\n    let response = openpbr_eval_prepared(prepared, *lightDirection, pdf);\n    *marginalPdf = *pdf;\n    *fullResponse = response;\n    return response;\n}\n\nfn openpbr_sample(\n    tangent: vec3f,\n    material: OpenPbrResolvedMaterial,\n    randomSamples: vec3f,\n    viewDirection: vec3f,\n    normal: vec3f,\n    lightDirection: ptr<function, vec3f>,\n    pdf: ptr<function, f32>,\n    isTransmissionEvent: ptr<function, bool>,\n    sampledLobeRoughness: ptr<function, f32>,\n    sampledLobeSpecular: ptr<function, bool>,\n    sampledLobeDiffuse: ptr<function, bool>,\n    sampledLobeIndex: ptr<function, u32>,\n    marginalPdf: ptr<function, f32>\n) -> vec3f {\n    let prepared = openpbr_prepare(\n        tangent,\n        material,\n        viewDirection,\n        normal\n    );\n    var fullResponse = vec3f(0.0);\n    return openpbr_sample_prepared(\n        prepared,\n        randomSamples,\n        lightDirection,\n        pdf,\n        isTransmissionEvent,\n        sampledLobeRoughness,\n        sampledLobeSpecular,\n        sampledLobeDiffuse,\n        sampledLobeIndex,\n        marginalPdf,\n        &fullResponse\n    );\n}`;\n\n}\n\nexport default createOpenPbrBsdfWgsl();\n"]}