ai_shader_bsdf.h

Go to the documentation of this file.

// Copyright 2025 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
 
#pragma once
#include "ai_color.h"
#include "ai_ray.h"
#include "ai_vector.h"
#include "ai_shaderglobals.h"
#include "ai_shader_closure.h"
 
struct AtBSDF;
 
enum AtBSDFLobeFlags {
   AI_BSDF_LOBE_SINGULAR          = 0x01,  
   AI_BSDF_LOBE_WAVELENGTH_SAMPLE = 0x02,  
   AI_BSDF_LOBE_EXIT_BACKGROUND   = 0x04,  
   AI_BSDF_LOBE_EXIT_WHITE        = 0x08   
};
 
 
struct AtBSDFLobeInfo {
   uint8_t ray_type;
   uint8_t flags;
   AtString label;
};
 
 
typedef uint32_t AtBSDFLobeMask;
static const AtBSDFLobeMask AI_BSDF_LOBE_MASK_NONE = 0x0;
 
 
struct AtBSDFLobeSample {
   AI_DEVICE AtBSDFLobeSample(AtRGB weight, float reverse_pdf, float pdf)
   : weight(weight), reverse_pdf(reverse_pdf), pdf(pdf) { }
 
   AI_DEVICE AtBSDFLobeSample(AtRGB eval)
   : weight(eval), reverse_pdf(1.0f), pdf(1.0f) { }
 
   AtBSDFLobeSample() = default;
 
   AtRGB weight;
   float reverse_pdf;
   float pdf;
};
 
 
#ifdef AI_CPU_COMPILER
struct AtBSDFMethods
{
   int            version;
   void           (*Init)(const AtShaderGlobals* sg,
                          AtBSDF* bsdf);
   AtBSDFLobeMask (*Eval)(const AtBSDF* bsdf,
                          const AtVector& wi,
                          const AtBSDFLobeMask lobe_mask,
                          const bool need_pdf,
                          AtBSDFLobeSample out_lobes[]);
   AtBSDFLobeMask (*Sample)(const AtBSDF* bsdf,
                            const AtVector rnd,
                            const float wavelength,
                            const AtBSDFLobeMask lobe_mask,
                            const bool need_pdf,
                            AtVectorDv& out_wi,
                            int& out_lobe_index,
                            AtBSDFLobeSample out_lobes[]);
   AtRGB          (*Albedo)(const AtBSDF* bsdf,
                            const AtShaderGlobals* sg,
                            const AtBSDFLobeMask lobe_mask);
   bool           (*Merge)(AtBSDF* bsdf,
                           const AtBSDF* other_bsdf);
   AtClosureList  (*Interior)(const AtShaderGlobals* sg,
                              AtBSDF* bsdf);
};
#endif // AI_CPU_COMPILER
 
#define AI_BSDF_EXPORT_METHODS(tag)      \
bsdf_init;                               \
bsdf_eval;                               \
bsdf_sample;                             \
static AtBSDFMethods ai_bsdf_methods = { \
   0,                                    \
   Init,                                 \
   Eval,                                 \
   Sample,                               \
   NULL,                                 \
   NULL,                                 \
   NULL,                                 \
};                                       \
AtBSDFMethods* tag = &ai_bsdf_methods;
 
#define bsdf_init                           \
static void Init(const AtShaderGlobals* sg, \
                 AtBSDF* bsdf)
 
#define bsdf_eval                                          \
static AtBSDFLobeMask Eval(const AtBSDF* bsdf,             \
                           const AtVector& wi,             \
                           const AtBSDFLobeMask lobe_mask, \
                           const bool need_pdf,            \
                           AtBSDFLobeSample out_lobes[])
 
#define bsdf_sample                                          \
static AtBSDFLobeMask Sample(const AtBSDF* bsdf,             \
                             const AtVector rnd,             \
                             const float wavelength,         \
                             const AtBSDFLobeMask lobe_mask, \
                             const bool need_pdf,            \
                             AtVectorDv& out_wi,             \
                             int& out_lobe_index,            \
                             AtBSDFLobeSample out_lobes[])
 
#define bsdf_albedo                                                                                 \
static AtRGB Albedo(const AtBSDF* bsdf, const AtShaderGlobals* sg, const AtBSDFLobeMask lobe_mask); \
AI_OPTIONAL_METHOD_INSTALL(ai_bsdf_methods, Albedo)                                                 \
static AtRGB Albedo(const AtBSDF* bsdf, const AtShaderGlobals* sg, const AtBSDFLobeMask lobe_mask)
 
#define bsdf_merge                                         \
static bool Merge(AtBSDF* bsdf, const AtBSDF* other_bsdf); \
AI_OPTIONAL_METHOD_INSTALL(ai_bsdf_methods, Merge)         \
static bool Merge(AtBSDF* bsdf, const AtBSDF* other_bsdf)
 
#define bsdf_interior                                                   \
static AtClosureList Interior(const AtShaderGlobals* sg, AtBSDF* bsdf); \
AI_OPTIONAL_METHOD_INSTALL(ai_bsdf_methods, Interior)                   \
static AtClosureList Interior(const AtShaderGlobals* sg, AtBSDF* bsdf)
 
 
#ifdef AI_CPU_COMPILER
AI_API AtBSDF* AiBSDF(const AtShaderGlobals* sg, const AtRGB& weight, const AtBSDFMethods* methods, size_t data_size);
 
AI_API const AtBSDFMethods*  AiBSDFGetMethods (const AtBSDF* bsdf);
#endif // AI_CPU_COMPILER
AI_API AI_DEVICE void*       AiBSDFGetData    (const AtBSDF* bsdf);
AI_API const AtBSDFLobeInfo* AiBSDFGetLobes   (const AtBSDF* bsdf);
AI_API int                   AiBSDFGetNumLobes(const AtBSDF* bsdf);
AI_API AI_DEVICE AtRGB       AiBSDFGetWeight  (const AtBSDF* bsdf);
 
AI_API AI_DEVICE void AiBSDFSetDirectIndirect(AtBSDF* bsdf, float weight_direct, float weight_indirect);
AI_API AI_DEVICE void AiBSDFGetDirectIndirect(const AtBSDF* bsdf, float& weight_direct, float& weight_indirect);
 
AI_API AI_DEVICE void AiBSDFInitLobes (AtBSDF* bsdf, const AtBSDFLobeInfo* lobes, int num_lobes);
AI_API AI_DEVICE void AiBSDFInitNormal(AtBSDF* bsdf, const AtVector& N, bool bounding);
 
AI_API AI_DEVICE float AiBSDFBumpShadow  (const AtVector& Ns, const AtVector& N, const AtVector& Ld);
AI_API AI_DEVICE float AiBSDFMinRoughness(const AtShaderGlobals* sg);
/*\}*/
 
 
 
enum AtOrenNayarModel : unsigned char {
 
   QUALITATIVE,
 
   ENERGY_PRESERVING
};
 
struct AtOrenNayarBSDFParams
{
   AtRGB weight = AI_RGB_WHITE;
 
   AtVector N = AI_V3_Z;
 
   AtOrenNayarModel model = AtOrenNayarModel::ENERGY_PRESERVING;
 
   float r = 0.0f;
 
   bool transmission = false;
 
   AtString label = AtString();
};
 
AI_API AI_DEVICE AtBSDF* AiOrenNayarBSDF_private(const AtShaderGlobals*       sg,
                                                 const AtOrenNayarBSDFParams& params);
 
inline AI_DEVICE AtBSDF* AiOrenNayarBSDF(const AtShaderGlobals*       sg,
                                         const AtOrenNayarBSDFParams& params)
{
   return AiOrenNayarBSDF_private(sg, params);
}
 
AI_API AI_DEVICE AtBSDF*
AiOrenNayarBSDF(const AtShaderGlobals* sg, const AtRGB& weight, const AtVector& N,
                AtOrenNayarModel model = AtOrenNayarModel::ENERGY_PRESERVING, float r = 0.0f,
                bool transmission = false, const AtString label = AtString());
 
/* \}*/ // Diffuse BRDF
 
 
 
#define AI_MICROFACET_BECKMANN 0x00 
#define AI_MICROFACET_GGX 0x01      
struct AtMicrofacetBSDFParams
{
   AtRGB weight = AI_RGB_WHITE;
 
   int distribution = AI_MICROFACET_GGX;
 
   AtVector N = AI_V3_Z;
 
   AtVector U = AI_V3_ZERO;
 
   float ior = 1.5f;
 
   float rx = 0.f;
 
   float ry = 0.f;
 
   float haze_weight = 0.f;
 
   float rx_haze = 0.f;
 
   float ry_haze = 0.f;
 
   int32_t dielectric_priority = 0;
 
   float thin_walled_transmission = 0.0f;
 
   float specular_weight = 1.0f;
 
   float retro_reflectivity = 0.0f;
 
   uint8_t exit_type = 0;
 
   AtString label = AtString();
};
 
AI_API AI_DEVICE AtBSDF* AiMicrofacetBSDF_private(const AtShaderGlobals*        sg,
                                                  const AtMicrofacetBSDFParams& params);
 
inline AI_DEVICE AtBSDF* AiMicrofacetBSDF(const AtShaderGlobals*        sg,
                                          const AtMicrofacetBSDFParams& params)
{
   return AiMicrofacetBSDF_private(sg, params);
}
 
AI_API AI_DEVICE AtBSDF*
AiMicrofacetBSDF(const AtShaderGlobals* sg, const AtRGB& weight, int distribution,
                 const AtVector& N, const AtVector* U, float ior, float rx, float ry,
                 uint8_t exit_type = 0, int32_t dielectric_priority = 0,
                 float thin_walled_transmission = 0, const AtString label = AtString());
 
struct AtMicrofacetRefractionBSDFParams
{
   AtRGB weight = AI_RGB_WHITE;
 
   int distribution = AI_MICROFACET_GGX;
 
   AtVector N = AI_V3_Z;
 
   AtVector U = AI_V3_ZERO;
 
   float ior = 1.5f;
 
   float rx = 0.f;
 
   float ry = 0.f;
 
   float haze_weight = 0.f;
 
   float rx_haze = 0.f;
 
   float ry_haze = 0.f;
 
   float dispersion = 0.f;
 
   // volumetric closure giving the (optional) embedded scattering/absorbing medium of the dielectric
   AtClosureList interior_volume = AtClosureList();
 
   bool use_fresnel = true;
 
   int32_t dielectric_priority = 0;
 
   float specular_weight = 1.0f;
 
   uint8_t exit_type = 0;
 
   AtString label = AtString();
};
 
AI_API AI_DEVICE AtBSDF*
AiMicrofacetRefractionBSDF_private(const AtShaderGlobals*                  sg,
                                   const AtMicrofacetRefractionBSDFParams& params);
 
inline AI_DEVICE AtBSDF* AiMicrofacetRefractionBSDF(const AtShaderGlobals* sg,
                                                    const AtMicrofacetRefractionBSDFParams& params)
{
   return AiMicrofacetRefractionBSDF_private(sg, params);
}
 
AI_API AI_DEVICE AtBSDF* AiMicrofacetRefractionBSDF(
   const AtShaderGlobals* sg, const AtRGB& weight, int distribution, const AtVector& N,
   const AtVector* U, float ior, float rx, float ry, float dispersion, bool use_fresnel = true,
   AtClosureList interior_volume = AtClosureList(), uint8_t exit_type = 0,
   int32_t dielectric_priority = 0, const AtString label = AtString());
 
struct AtMicrofacetThinWallRefractionBSDFParams
{
   AtRGB weight = AI_RGB_WHITE;
 
   int distribution = AI_MICROFACET_GGX;
 
   AtVector N = AI_V3_Z;
 
   AtVector U = AI_V3_ZERO;
 
   float ior = 1.5f;
 
   float rx = 0.f;
 
   float ry = 0.f;
 
   float haze_weight = 0.f;
 
   float rx_haze = 0.f;
 
   float ry_haze = 0.f;
 
   float specular_weight = 1.0f;
 
   uint8_t exit_type = 0;
 
   AtString label = AtString();
};
 
AI_API AI_DEVICE AtBSDF* AiMicrofacetThinWallRefractionBSDF_private(
   const AtShaderGlobals* sg, const AtMicrofacetThinWallRefractionBSDFParams& params);
 
inline AI_DEVICE AtBSDF*
AiMicrofacetThinWallRefractionBSDF(const AtShaderGlobals*                          sg,
                                   const AtMicrofacetThinWallRefractionBSDFParams& params)
{
   return AiMicrofacetThinWallRefractionBSDF_private(sg, params);
}
 
AI_API AI_DEVICE AtBSDF*
AiMicrofacetThinWallRefractionBSDF(const AtShaderGlobals* sg, const AtRGB& weight,
                                   int distribution, const AtVector& N, const AtVector* U,
                                   float eta, float rx, float ry, uint8_t exit_type = 0,
                                   AtString label = AtString());
 
 
AI_API AI_DEVICE void AiMicrofacetSetThinFilm(AtBSDF* bsdf, float weight, float thickness,
                                              float ior);
/* \}*/ // Thin-film modifier
 
/* \}*/ // Microfacet BSDFs
 
 
 
AI_API AI_DEVICE
void AiMicrofacetSetThinFilm(AtBSDF* bsdf, float weight, float thickness, float ior);
/* \}*/ // Thin-film modifier
 
 
 
enum AtMetalFresnelMode {
 
   GULBRANDSEN,
 
   F82_TINT
};
 
struct AtMetalBSDFParams
{
   AtRGB weight = AI_RGB_WHITE;
 
   int distribution = AI_MICROFACET_GGX;
 
   AtVector N = AI_V3_Z;
 
   AtVector U = AI_V3_ZERO;
 
   AtMetalFresnelMode fresnel_mode = F82_TINT;
 
   AtRGB fresnel1 = AI_RGB_50GREY;
 
   AtRGB fresnel2 = AI_RGB_WHITE;
 
   float specular_weight = 1.0f;
 
   float rx = 0.f;
 
   float ry = 0.f;
 
   float haze_weight = 0.f;
 
   float rx_haze = 0.f;
 
   float ry_haze = 0.f;
 
   float retro_reflectivity = 0.0f;
 
   AtString label = AtString();
};
 
AI_API AI_DEVICE AtBSDF* AiMetalBSDF_private(const AtShaderGlobals*   sg,
                                             const AtMetalBSDFParams& params);
 
inline AI_DEVICE AtBSDF* AiMetalBSDF(const AtShaderGlobals* sg, const AtMetalBSDFParams& params)
{
   return AiMetalBSDF_private(sg, params);
}
 
AI_API AI_DEVICE AtBSDF* AiMetalBSDF(const AtShaderGlobals* sg, const AtRGB& weight,
                                     int distribution, const AtVector& N, const AtVector* U,
                                     AtMetalFresnelMode fresnel_mode, const AtRGB& fresnel1,
                                     const AtRGB& fresnel2, float specular_weight,
                                     float rx, float ry, const AtString label = AtString());
 
/* \}*/ // Metal BRDF
 
 
AI_API AI_DEVICE AtBSDF* AidEonBSDF(const AtShaderGlobals* sg, const AtRGB& absorption, const AtRGB weights[3],
                                    const AtVector& tangent,
                                    const float roughness_longitudinal, const float roughness_azimuthal,
                                    const float eta, const float tilt, const AtString label = AtString());
 
AI_API AI_DEVICE AtBSDF* AiZinkeBSDF(const AtShaderGlobals* sg, const AtRGB &weight, const AtVector& tangent,
                                     const AtString label = AtString());
 
/* \}*/ // Hair BSDFs
 
 
 
AI_API AI_DEVICE AtBSDF* AiSheenBSDF(const AtShaderGlobals* sg, const AtRGB &weight, const AtVector& N,
                                     const float r, const AtString label = AtString());
 
AI_API AI_DEVICE AtBSDF* AiFuzzBSDF(const AtShaderGlobals* sg, const AtRGB &weight, const AtVector& N,
                                    const float r, const AtString label = AtString());
 
 
/* \}*/ // Sheen/Fuzz BRDF
 
/* \}*/ // Built-in BSDFs
 
 
 
AI_API void AiBSDFIntegrate(AtShaderGlobals* sg, AtRGB* direct, AtRGB* indirect, AtBSDF* bsdf);
 
AI_API AI_DEVICE AtRGB AiBSDFAlbedo(const AtShaderGlobals* sg, AtBSDF* bsdf);
/* \}*/
 
/*\}*/