ai_shader_bsdf.h

Go to the documentation of this file.

// Copyright 2021 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"
 
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;
};
 
 
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);
};
 
#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)
 
 
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);
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 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);
/*\}*/
 
 
AI_API AI_DEVICE AtBSDF* AiOrenNayarBSDF(const AtShaderGlobals* sg, const AtRGB& weight,
                                         const AtVector& N, float r = 0.0f, bool transmission = false,
                                         const AtString label = AtString());
 
AI_API AI_DEVICE AtBSDF* AiMicrofacetBSDF(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,
                                          const AtString label = AtString());
 
AI_API AI_DEVICE
AtBSDF* AiMicrofacetBSDF_private(const AtShaderGlobals* sg, const AtRGB& weight,
                                 int distribution, const AtVector& N, const AtVector *U,
                                 float ior, float rx, float ry, uint8_t exit_type,
                                 const AtString label,
                                 int32_t dielectric_importance);
 
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 = NULL,
                                                    uint8_t exit_type = 0, const AtString label = AtString());
 
AI_API AI_DEVICE AtBSDF* AiMicrofacetRefractionBSDF_private(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, AtClosureList interior,
                                                            uint8_t exit_type, const AtString label,
                                                            int32_t dielectric_importance);
 
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 thickness, float eta);
 
AI_API AI_DEVICE AtBSDF* AiMetalBSDF(const AtShaderGlobals* sg, const AtRGB& weight,
                                     int distribution, const AtVector& N, const AtVector *U,
                                     const AtRGB& n, const AtRGB& k, float rx, float ry,
                                     const AtString label = AtString());
 
AI_API AI_DEVICE AtBSDF* AidEonBSDF(const AtShaderGlobals* sg, const AtRGB& absorption, const AtRGB weights[3],
                                    const AtVector& tangent, const float roughness, 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());
 
AI_API AI_DEVICE AtBSDF* AiSheenBSDF(const AtShaderGlobals* sg, const AtRGB &weight, const AtVector& N,
                                     const float r, const AtString label = AtString());
 
/* \}*/
 
#define AI_MICROFACET_BECKMANN   0x00  
#define AI_MICROFACET_GGX        0x01  
/*\}*/
 
 
AI_API void AiBSDFIntegrate(AtShaderGlobals* sg, AtRGB* direct, AtRGB* indirect, AtBSDF* bsdf);
 
AI_API AI_DEVICE AtRGB AiBSDFAlbedo(const AtShaderGlobals* sg, AtBSDF* bsdf);
/* \}*/
 
 
/*\}*/