@tushar-br/editing-pack 1.0.194 → 1.0.195

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_chiang_hair_bsdf.glsl

@@ -0,0 +1,291 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet_specular.glsl"
+
+// https://eugenedeon.com/pdfs/egsrhair.pdf
+void mx_deon_hair_absorption_from_melanin(
+    float melanin_concentration,
+    float melanin_redness,
+    // constants converted to color via exp(-c). the defaults are lin_rec709 colors, they may be
+    // transformed to scene-linear rendering color space.
+    vec3 eumelanin_color,    // default: (0.657704, 0.498077, 0.254106) == exp(-(0.419, 0.697, 1.37))
+    vec3 pheomelanin_color,  // default: (0.829443, 0.670320, 0.349937) == exp(-(0.187, 0.4, 1.05))
+    out vec3 absorption)
+{
+    float melanin = -log(max(1.0 - melanin_concentration, 0.0001));
+    float eumelanin = melanin * (1.0 - melanin_redness);
+    float pheomelanin = melanin * melanin_redness;
+    absorption = max(
+        eumelanin * -log(eumelanin_color) + pheomelanin * -log(pheomelanin_color), 
+        vec3(0.0)
+    );
+}
+
+// https://media.disneyanimation.com/uploads/production/publication_asset/152/asset/eurographics2016Fur_Smaller.pdf
+void mx_chiang_hair_absorption_from_color(vec3 color, float betaN, out vec3 absorption)
+{
+    float b2 = betaN* betaN;
+    float b4 = b2 * b2;
+    float b_fac = 
+        5.969 - 
+        (0.215 * betaN) + 
+        (2.532 * b2) -
+        (10.73 * b2 * betaN) + 
+        (5.574 * b4) +
+        (0.245 * b4 * betaN);
+    vec3 sigma = log(min(max(color, 0.001), vec3(1.0))) / b_fac;
+    absorption = sigma * sigma;
+}
+
+void mx_chiang_hair_roughness(
+    float longitudinal,
+    float azimuthal,
+    float scale_TT,   // empirical roughness scale from Marschner et al. (2003).
+    float scale_TRT,  // default: scale_TT = 0.5, scale_TRT = 2.0
+    out vec2 roughness_R,
+    out vec2 roughness_TT,
+    out vec2 roughness_TRT
+)
+{
+    float lr = clamp(longitudinal, 0.001, 1.0);
+    float ar = clamp(azimuthal, 0.001, 1.0);
+
+    // longitudinal variance
+    float v = 0.726 * lr + 0.812 * lr * lr + 3.7 * pow(lr, 20.0);
+    v = v * v;
+
+    float s = 0.265 * ar + 1.194 * ar * ar + 5.372 * pow(ar, 22.0);
+
+    roughness_R = vec2(v, s);
+    roughness_TT = vec2(v * scale_TT * scale_TT, s);
+    roughness_TRT = vec2(v * scale_TRT * scale_TRT, s);
+}
+
+float mx_hair_transform_sin_cos(float x)
+{
+    return sqrt(max(1.0 - x * x, 0.0));
+}
+
+float mx_hair_I0(float x)
+{
+    float v = 1.0;
+    float n = 1.0;
+    float d = 1.0;
+    float f = 1.0;
+    float x2 = x * x;
+    for (int i = 0; i < 9 ; ++i)
+    {
+        d *= 4.0 * (f * f);
+        n *= x2;
+        v += n / d;
+        f += 1.0;
+    }
+    return v;
+}
+
+float mx_hair_log_I0(float x)
+{
+    if (x > 12.0)
+        return x + 0.5 * (-log(2.0 * M_PI) + log(1.0 / x) + 1.0 / (8.0 * x));
+    else
+        return log(mx_hair_I0(x));
+}
+
+float mx_hair_logistic(float x, float s)
+{
+    if (x > 0.0)
+        x = -x;
+    float f = exp(x / s);
+    return f / (s * (1.0 + f) * (1.0 + f));
+}
+
+float mx_hair_logistic_cdf(float x, float s)
+{
+    return 1.0 / (1.0 + exp(-x / s));
+}
+
+float mx_hair_trimmed_logistic(float x, float s, float a, float b)
+{
+    // the constant can be found in Chiang et al. (2016) Appendix A, eq. (12)
+    s *= 0.626657;  // sqrt(M_PI/8)
+    return mx_hair_logistic(x, s) / (mx_hair_logistic_cdf(b, s) - mx_hair_logistic_cdf(a, s));
+}
+
+float mx_hair_phi(int p, float gammaO, float gammaT)
+{
+    float fP = float(p);
+    return 2.0 * fP * gammaT - 2.0 * gammaO + fP * M_PI;
+}
+
+float mx_hair_longitudinal_scattering(  // Mp
+    float sinThetaI,
+    float cosThetaI,
+    float sinThetaO,
+    float cosThetaO,
+    float v
+)
+{
+    float inv_v = 1.0 / v;
+    float a = cosThetaO * cosThetaI * inv_v;
+    float b = sinThetaO * sinThetaI * inv_v;
+    if (v < 0.1)
+        return exp(mx_hair_log_I0(a) - b - inv_v + 0.6931 + log(0.5 * inv_v));
+    else
+        return ((exp(-b) * mx_hair_I0(a)) / (2.0 * v * sinh(inv_v)));
+}
+
+float mx_hair_azimuthal_scattering(  // Np
+    float phi,
+    int p,
+    float s,
+    float gammaO,
+    float gammaT
+)
+{
+    if (p >= 3)
+        return float(0.5 / M_PI);
+
+    float dphi = phi - mx_hair_phi(p, gammaO, gammaT);
+    if (isinf(dphi))
+        return float(0.5 / M_PI);
+
+    while (dphi > M_PI)    dphi -= (2.0 * M_PI);
+    while (dphi < (-M_PI)) dphi += (2.0 * M_PI);
+
+    return mx_hair_trimmed_logistic(dphi, s, -M_PI, M_PI);
+}
+
+void mx_hair_alpha_angles(
+    float alpha,
+    float sinThetaI,
+    float cosThetaI,
+    out vec2 angles[4]
+)
+{
+    // 0:R, 1:TT, 2:TRT, 3:TRRT+
+    for (int i = 0; i <= 3; ++i)
+    {
+        if (alpha == 0.0 || i == 3)
+            angles[i] = vec2(sinThetaI, cosThetaI);
+        else
+        {
+            float m = 2.0 - float(i) * 3.0;
+            float sa = sin(m * alpha);
+            float ca = cos(m * alpha);
+            angles[i].x = sinThetaI * ca + cosThetaI * sa;
+            angles[i].y = cosThetaI * ca - sinThetaI * sa;
+        }
+    }
+}
+
+void mx_hair_attenuation(float f, vec3 T, out vec3 Ap[4])  // Ap
+{
+    // 0:R, 1:TT, 2:TRT, 3:TRRT+
+    Ap[0] = vec3(f);
+    Ap[1] = (1.0 - f) * (1.0 - f) * T;
+    Ap[2] = Ap[1] * T * f;
+    Ap[3] = Ap[2] * T * f / (vec3(1.0) - T * f);
+}
+
+void mx_chiang_hair_bsdf(ClosureData closureData, vec3 tint_R, vec3 tint_TT, vec3 tint_TRT, float ior,
+                         vec2 roughness_R, vec2 roughness_TT, vec2 roughness_TRT, float cuticle_angle,
+                         vec3 absorption_coefficient, vec3 N, vec3 X, inout BSDF bsdf)
+{
+    vec3 V = closureData.V;
+    vec3 L = closureData.L;
+
+    N = mx_forward_facing_normal(N, V);
+
+    bsdf.throughput = vec3(0.0);
+
+    if (closureData.closureType == CLOSURE_TYPE_REFLECTION)
+    {
+        X = normalize(X - dot(X, N) * N);
+        vec3 Y = cross(N, X);
+
+        float sinThetaO = dot(V, X);
+        float sinThetaI = dot(L, X);
+        float cosThetaO = mx_hair_transform_sin_cos(sinThetaO);
+        float cosThetaI = mx_hair_transform_sin_cos(sinThetaI);
+
+        float y1 = dot(L, N);
+        float x1 = dot(L, Y);
+        float y2 = dot(V, N);
+        float x2 = dot(V, Y);
+        float phi = mx_atan(y1 * x2 - y2 * x1, x1 * x2 + y1 * y2);
+
+        vec3 k1_p = normalize(V - X * dot(V, X));
+        float cosGammaO = dot(N, k1_p);
+        float sinGammaO = mx_hair_transform_sin_cos(cosGammaO);
+        if (dot(k1_p, Y) > 0.0)
+            sinGammaO = -sinGammaO;
+        float gammaO = asin(sinGammaO);
+
+        float sinThetaT = sinThetaO / ior;
+        float cosThetaT = mx_hair_transform_sin_cos(sinThetaT);
+        float etaP = sqrt(max(ior * ior - sinThetaO * sinThetaO, 0.0)) / max(cosThetaO, M_FLOAT_EPS);
+        float sinGammaT = max(min(sinGammaO / etaP, 1.0), -1.0);
+        float cosGammaT = sqrt(1.0 - sinGammaT * sinGammaT);
+        float gammaT = asin(sinGammaT);
+
+        // attenuation
+        vec3 Ap[4];
+        float fresnel = mx_fresnel_dielectric(cosThetaO * cosGammaO, ior);
+        vec3 T = exp(-absorption_coefficient * (2.0 * cosGammaT / cosThetaT));
+        mx_hair_attenuation(fresnel, T, Ap);
+
+        // parameters for each lobe
+        vec2 angles[4];
+        float alpha = cuticle_angle * M_PI - (M_PI / 2.0);  // remap [0, 1] to [-PI/2, PI/2]
+        mx_hair_alpha_angles(alpha, sinThetaI, cosThetaI, angles);
+
+        vec3 tint[4];
+        tint[0] = tint_R;
+        tint[1] = tint_TT;
+        tint[2] = tint_TRT;
+        tint[3] = tint_TRT;
+
+        roughness_R = clamp(roughness_R, 0.001, 1.0);
+        roughness_TT = clamp(roughness_TT, 0.001, 1.0);
+        roughness_TRT = clamp(roughness_TRT, 0.001, 1.0);
+
+        vec2 vs[4];
+        vs[0] = roughness_R;
+        vs[1] = roughness_TT;
+        vs[2] = roughness_TRT;
+        vs[3] = roughness_TRT;
+
+        // R, TT, TRT, TRRT+
+        vec3 F = vec3(0.0);
+        for (int i = 0; i <= 3; ++i)
+        {
+            tint[i] = max(tint[i], vec3(0.0));
+            float Mp = mx_hair_longitudinal_scattering(angles[i].x, angles[i].y, sinThetaO, cosThetaO, vs[i].x);
+            float Np = (i == 3) ?  (1.0 / 2.0 * M_PI) : mx_hair_azimuthal_scattering(phi, i, vs[i].y, gammaO, gammaT);
+            F += Mp * Np * tint[i] * Ap[i];
+        }
+
+        bsdf.response = F * closureData.occlusion * M_PI_INV;
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_INDIRECT)
+    {
+        // This indirect term is a *very* rough approximation.
+
+        float NdotV = clamp(dot(N, V), M_FLOAT_EPS, 1.0);
+        FresnelData fd = mx_init_fresnel_dielectric(ior, 0.0, 1.0);
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+
+        vec2 roughness = (roughness_R + roughness_TT + roughness_TRT) / vec2(3.0);  // ?
+        vec2 safeAlpha = clamp(roughness, M_FLOAT_EPS, 1.0);
+        float avgAlpha = mx_average_alpha(safeAlpha);
+
+        // Use GGX to match the behavior of mx_environment_radiance.
+        float F0 = mx_ior_to_f0(ior);
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, F0, 1.0) * comp;
+
+        vec3 Li = mx_environment_radiance(N, V, X, safeAlpha, 0, fd);
+        vec3 tint = (tint_R + tint_TT + tint_TRT) / vec3(3.0);  // ?
+
+        bsdf.response = Li * comp * tint;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_conductor_bsdf.glsl

@@ -0,0 +1,51 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet_specular.glsl"
+
+void mx_conductor_bsdf(ClosureData closureData, float weight, vec3 ior_n, vec3 ior_k, vec2 roughness, float thinfilm_thickness, float thinfilm_ior, vec3 N, vec3 X, int distribution, inout BSDF bsdf)
+{
+    bsdf.throughput = vec3(0.0);
+
+    if (weight < M_FLOAT_EPS)
+    {
+        return;
+    }
+
+    vec3 V = closureData.V;
+    vec3 L = closureData.L;
+
+    N = mx_forward_facing_normal(N, V);
+    float NdotV = clamp(dot(N, V), M_FLOAT_EPS, 1.0);
+
+    FresnelData fd = mx_init_fresnel_conductor(ior_n, ior_k, thinfilm_thickness, thinfilm_ior);
+
+    vec2 safeAlpha = clamp(roughness, M_FLOAT_EPS, 1.0);
+    float avgAlpha = mx_average_alpha(safeAlpha);
+
+    if (closureData.closureType == CLOSURE_TYPE_REFLECTION)
+    {
+        X = normalize(X - dot(X, N) * N);
+        vec3 Y = cross(N, X);
+        vec3 H = normalize(L + V);
+
+        float NdotL = clamp(dot(N, L), M_FLOAT_EPS, 1.0);
+        float VdotH = clamp(dot(V, H), M_FLOAT_EPS, 1.0);
+
+        vec3 Ht = vec3(dot(H, X), dot(H, Y), dot(H, N));
+
+        vec3 F = mx_compute_fresnel(VdotH, fd);
+        float D = mx_ggx_NDF(Ht, safeAlpha);
+        float G = mx_ggx_smith_G2(NdotL, NdotV, avgAlpha);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+
+        // Note: NdotL is cancelled out
+        bsdf.response = D * F * G * comp * closureData.occlusion * weight / (4.0 * NdotV);
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_INDIRECT)
+    {
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 Li = mx_environment_radiance(N, V, X, safeAlpha, distribution, fd);
+        bsdf.response = Li * comp * weight;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_dielectric_bsdf.glsl

@@ -0,0 +1,73 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet_specular.glsl"
+
+void mx_dielectric_bsdf(ClosureData closureData, float weight, vec3 tint, float ior, vec2 roughness, float thinfilm_thickness, float thinfilm_ior, vec3 N, vec3 X, int distribution, int scatter_mode, inout BSDF bsdf)
+{
+    if (weight < M_FLOAT_EPS)
+    {
+        return;
+    }
+    if (closureData.closureType != CLOSURE_TYPE_TRANSMISSION && scatter_mode == 1)
+    {
+        return;
+    }
+
+    vec3 V = closureData.V;
+    vec3 L = closureData.L;
+
+    N = mx_forward_facing_normal(N, V);
+    float NdotV = clamp(dot(N, V), M_FLOAT_EPS, 1.0);
+
+    FresnelData fd = mx_init_fresnel_dielectric(ior, thinfilm_thickness, thinfilm_ior);
+    float F0 = mx_ior_to_f0(ior);
+
+    vec2 safeAlpha = clamp(roughness, M_FLOAT_EPS, 1.0);
+    float avgAlpha = mx_average_alpha(safeAlpha);
+    vec3 safeTint = max(tint, 0.0);
+
+    if (closureData.closureType == CLOSURE_TYPE_REFLECTION)
+    {
+        X = normalize(X - dot(X, N) * N);
+        vec3 Y = cross(N, X);
+        vec3 H = normalize(L + V);
+
+        float NdotL = clamp(dot(N, L), M_FLOAT_EPS, 1.0);
+        float VdotH = clamp(dot(V, H), M_FLOAT_EPS, 1.0);
+
+        vec3 Ht = vec3(dot(H, X), dot(H, Y), dot(H, N));
+
+        vec3 F = mx_compute_fresnel(VdotH, fd);
+        float D = mx_ggx_NDF(Ht, safeAlpha);
+        float G = mx_ggx_smith_G2(NdotL, NdotV, avgAlpha);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, F0, 1.0) * comp;
+        bsdf.throughput = 1.0 - dirAlbedo * weight;
+
+        bsdf.response = D * F * G * comp * safeTint * closureData.occlusion * weight / (4.0 * NdotV);
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_TRANSMISSION)
+    {
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, F0, 1.0) * comp;
+        bsdf.throughput = 1.0 - dirAlbedo * weight;
+
+        if (scatter_mode != 0)
+        {
+            bsdf.response = mx_surface_transmission(N, V, X, safeAlpha, distribution, fd, safeTint) * weight;
+        }
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_INDIRECT)
+    {
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, F0, 1.0) * comp;
+        bsdf.throughput = 1.0 - dirAlbedo * weight;
+
+        vec3 Li = mx_environment_radiance(N, V, X, safeAlpha, distribution, fd);
+        bsdf.response = Li * safeTint * comp * weight;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_displacement_float.glsl

@@ -0,0 +1,5 @@
+void mx_displacement_float(float disp, float scale, out displacementshader result)
+{
+    result.offset = vec3(disp);
+    result.scale = scale;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_displacement_vector3.glsl

@@ -0,0 +1,5 @@
+void mx_displacement_vector3(vec3 disp, float scale, out displacementshader result)
+{
+    result.offset = disp;
+    result.scale = scale;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_generalized_schlick_bsdf.glsl

@@ -0,0 +1,80 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet_specular.glsl"
+
+void mx_generalized_schlick_bsdf(ClosureData closureData, float weight, vec3 color0, vec3 color82, vec3 color90, float exponent, vec2 roughness, float thinfilm_thickness, float thinfilm_ior, vec3 N, vec3 X, int distribution, int scatter_mode, inout BSDF bsdf)
+{
+    if (weight < M_FLOAT_EPS)
+    {
+        return;
+    }
+    if (closureData.closureType != CLOSURE_TYPE_TRANSMISSION && scatter_mode == 1)
+    {
+        return;
+    }
+
+    vec3 V = closureData.V;
+    vec3 L = closureData.L;
+
+    N = mx_forward_facing_normal(N, V);
+    float NdotV = clamp(dot(N, V), M_FLOAT_EPS, 1.0);
+
+    vec3 safeColor0 = max(color0, 0.0);
+    vec3 safeColor82 = max(color82, 0.0);
+    vec3 safeColor90 = max(color90, 0.0);
+    FresnelData fd = mx_init_fresnel_schlick(safeColor0, safeColor82, safeColor90, exponent, thinfilm_thickness, thinfilm_ior);
+
+    vec2 safeAlpha = clamp(roughness, M_FLOAT_EPS, 1.0);
+    float avgAlpha = mx_average_alpha(safeAlpha);
+
+    if (closureData.closureType == CLOSURE_TYPE_REFLECTION)
+    {
+        X = normalize(X - dot(X, N) * N);
+        vec3 Y = cross(N, X);
+        vec3 H = normalize(L + V);
+
+        float NdotL = clamp(dot(N, L), M_FLOAT_EPS, 1.0);
+        float VdotH = clamp(dot(V, H), M_FLOAT_EPS, 1.0);
+
+        vec3 Ht = vec3(dot(H, X), dot(H, Y), dot(H, N));
+
+        vec3  F = mx_compute_fresnel(VdotH, fd);
+        float D = mx_ggx_NDF(Ht, safeAlpha);
+        float G = mx_ggx_smith_G2(NdotL, NdotV, avgAlpha);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, safeColor0, safeColor90) * comp;
+        float avgDirAlbedo = dot(dirAlbedo, vec3(1.0 / 3.0));
+        bsdf.throughput = vec3(1.0 - avgDirAlbedo * weight);
+
+        // Note: NdotL is cancelled out
+        bsdf.response = D * F * G * comp * closureData.occlusion * weight / (4.0 * NdotV);
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_TRANSMISSION)
+    {
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, safeColor0, safeColor90) * comp;
+        float avgDirAlbedo = dot(dirAlbedo, vec3(1.0 / 3.0));
+        bsdf.throughput = vec3(1.0 - avgDirAlbedo * weight);
+
+        if (scatter_mode != 0)
+        {
+            float avgF0 = dot(safeColor0, vec3(1.0 / 3.0));
+            fd.ior = vec3(mx_f0_to_ior(avgF0));
+            bsdf.response = mx_surface_transmission(N, V, X, safeAlpha, distribution, fd, vec3(1.0)) * weight;
+        }
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_INDIRECT)
+    {
+        vec3 F = mx_compute_fresnel(NdotV, fd);
+
+        vec3 comp = mx_ggx_energy_compensation(NdotV, avgAlpha, F);
+        vec3 dirAlbedo = mx_ggx_dir_albedo(NdotV, avgAlpha, safeColor0, safeColor90) * comp;
+        float avgDirAlbedo = dot(dirAlbedo, vec3(1.0 / 3.0));
+        bsdf.throughput = vec3(1.0 - avgDirAlbedo * weight);
+
+        vec3 Li = mx_environment_radiance(N, V, X, safeAlpha, distribution, fd);
+        bsdf.response = Li * comp * weight;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_generalized_schlick_edf.glsl

@@ -0,0 +1,13 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet.glsl"
+
+void mx_generalized_schlick_edf(ClosureData closureData, vec3 color0, vec3 color90, float exponent, EDF base, out EDF result)
+{
+    if (closureData.closureType == CLOSURE_TYPE_EMISSION)
+    {
+        vec3 N = mx_forward_facing_normal(closureData.N, closureData.V);
+        float NdotV = clamp(dot(N, closureData.V), M_FLOAT_EPS, 1.0);
+        vec3 f = mx_fresnel_schlick(NdotV, color0, color90, exponent);
+        result = base * f;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_layer_bsdf.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_layer_bsdf(ClosureData closureData, BSDF top, BSDF base, out BSDF result)
+{
+    result.response = top.response + base.response * top.throughput;
+    result.throughput = top.throughput + base.throughput;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_layer_vdf.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_layer_vdf(ClosureData closureData, BSDF top, BSDF base, out BSDF result)
+{
+    result.response = top.response + base.response;
+    result.throughput = top.throughput + base.throughput;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_mix_bsdf.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_mix_bsdf(ClosureData closureData, BSDF fg, BSDF bg, float mixValue, out BSDF result)
+{
+    result.response = mix(bg.response, fg.response, mixValue);
+    result.throughput = mix(bg.throughput, fg.throughput, mixValue);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_mix_edf.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_mix_edf(ClosureData closureData, EDF fg, EDF bg, float mixValue, out EDF result)
+{
+    result = mix(bg, fg, mixValue);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_multiply_bsdf_color3.glsl

@@ -0,0 +1,8 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_multiply_bsdf_color3(ClosureData closureData, BSDF in1, vec3 in2, out BSDF result)
+{
+    vec3 tint = clamp(in2, 0.0, 1.0);
+    result.response = in1.response * tint;
+    result.throughput = in1.throughput * tint;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_multiply_bsdf_float.glsl

@@ -0,0 +1,8 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_multiply_bsdf_float(ClosureData closureData, BSDF in1, float in2, out BSDF result)
+{
+    float weight = clamp(in2, 0.0, 1.0);
+    result.response = in1.response * weight;
+    result.throughput = in1.throughput * weight;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_multiply_edf_color3.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_multiply_edf_color3(ClosureData closureData, EDF in1, vec3 in2, out EDF result)
+{
+    result = in1 * in2;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_multiply_edf_float.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_closure_type.glsl"
+
+void mx_multiply_edf_float(ClosureData closureData, EDF in1, float in2, out EDF result)
+{
+    result = in1 * in2;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_oren_nayar_diffuse_bsdf.glsl

@@ -0,0 +1,37 @@
+#include "lib/mx_closure_type.glsl"
+#include "lib/mx_microfacet_diffuse.glsl"
+
+void mx_oren_nayar_diffuse_bsdf(ClosureData closureData, float weight, vec3 color, float roughness, vec3 N, bool energy_compensation, inout BSDF bsdf)
+{
+    bsdf.throughput = vec3(0.0);
+
+    if (weight < M_FLOAT_EPS)
+    {
+        return;
+    }
+
+    vec3 V = closureData.V;
+    vec3 L = closureData.L;
+
+    N = mx_forward_facing_normal(N, V);
+    float NdotV = clamp(dot(N, V), M_FLOAT_EPS, 1.0);
+
+    if (closureData.closureType == CLOSURE_TYPE_REFLECTION)
+    {
+        float NdotL = clamp(dot(N, L), M_FLOAT_EPS, 1.0);
+        float LdotV = clamp(dot(L, V), M_FLOAT_EPS, 1.0);
+
+        vec3 diffuse = energy_compensation ?
+                       mx_oren_nayar_compensated_diffuse(NdotV, NdotL, LdotV, roughness, color) :
+                       mx_oren_nayar_diffuse(NdotV, NdotL, LdotV, roughness) * color;
+        bsdf.response = diffuse * closureData.occlusion * weight * NdotL * M_PI_INV;
+    }
+    else if (closureData.closureType == CLOSURE_TYPE_INDIRECT)
+    {
+        vec3 diffuse = energy_compensation ?
+                       mx_oren_nayar_compensated_diffuse_dir_albedo(NdotV, roughness, color) :
+                       mx_oren_nayar_diffuse_dir_albedo(NdotV, roughness) * color;
+        vec3 Li = mx_environment_irradiance(N);
+        bsdf.response = Li * diffuse * weight;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_roughness_anisotropy.glsl

@@ -0,0 +1,15 @@
+void mx_roughness_anisotropy(float roughness, float anisotropy, out vec2 result)
+{
+    float roughness_sqr = clamp(roughness*roughness, M_FLOAT_EPS, 1.0);
+    if (anisotropy > 0.0)
+    {
+        float aspect = sqrt(1.0 - clamp(anisotropy, 0.0, 0.98));
+        result.x = min(roughness_sqr / aspect, 1.0);
+        result.y = roughness_sqr * aspect;
+    }
+    else
+    {
+        result.x = roughness_sqr;
+        result.y = roughness_sqr;
+    }
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/pbrlib/genglsl/mx_roughness_dual.glsl

@@ -0,0 +1,9 @@
+void mx_roughness_dual(vec2 roughness, out vec2 result)
+{
+    if (roughness.y < 0.0)
+    {
+        roughness.y = roughness.x;
+    }
+    result.x = clamp(roughness.x * roughness.x, M_FLOAT_EPS, 1.0);
+    result.y = clamp(roughness.y * roughness.y, M_FLOAT_EPS, 1.0);
+}