xac_interface_standard_lib_doc.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
namespace nv {
namespace index {
 
namespace xac {
 
#define NV_IDX_DEVICE_INLINE_MEMBER 
 
#define NV_IDX_SURFACE_SAMPLE_PROGRAM 
 
#define NV_IDX_VOLUME_SAMPLE_PROGRAM
 
}
 
 
namespace xaclib {
 
/* Free Function Macros */
 
// debug print using define macros 
 
#define printf_condition(PRINT_CONDITION, ...)                  \
do {                                                            \
    if ((bool)PRINT_CONDITION)                                  \
        printf(__VA_ARGS__);                                    \
} while (0)
 
#define printf_thread(THREAD_ID_X, THREAD_ID_Y, ...)            \
do {                                                            \
    if (threadIdx.x==THREAD_ID_X && threadIdx.y==THREAD_ID_Y)   \
        printf(__VA_ARGS__);                                    \
} while (0)
 
#define printf_block(BLOCK_ID_X, BLOCK_ID_Y, ...)               \
do {                                                            \
    if (blockIdx.x == BLOCK_ID_X && blockIdx.y == BLOCK_ID_Y)   \
        printf(__VA_ARGS__);                                    \
} while (0)
 
#define printf_pixel(STATE, PX, PY, ...)                                            \
do {                                                                                \
    const uint2 pixc = nv::index::xaclib::get_pixel_position(STATE.scene);          \
    if (pixc.x == PX && pixc.y == PY)                                               \
        printf(__VA_ARGS__);                                                        \
} while (0)
 
#define printf_box(BOX_MIN, BOX_MAX, POSITION, ...)             \
do {                                                            \
    if (is_inside_bounding_box(BOX_MIN, BOX_MAX, POSITION))     \
        printf(__VA_ARGS__);                                    \
} while (0)
 
/* Free Functions */
 
float4 gamma_correct(const float4& color, float gamma_exp);
 
bool is_inside_bounding_box(const float3& box_min, const float3& box_max, const float3& position);
 
uint2 get_pixel_position(const xac::Scene& scene);
 
xac::Ray transform_ray(const cuda::Mat4x4f& m, const xac::Ray& r);
 
template<const xac::NV_IDX_volume_filter_types filter_type>
float3 volume_gradient(
    const xac::Sparse_volume& volume, 
    const float3& sample_position, 
          float dh = 1.0f);
 
template<const xac::Volume_filter_mode         filter_mode,
         const xac::Volume_classification_mode classification_mode>
float3 volume_gradient(
    const xac::Sparse_volume_sampler<float, filter_mode, classification_mode>& sampler,
    const float3& sample_position, 
          float dh = 1.0f);
 
template<xac::Volume_filter_mode            filter_mode, 
         xac::Volume_classification_mode    classification_mode>
NV_IDX_DEVICE_INLINE_MEMBER
float3 volume_gradient(
    const xac::Sparse_volume&                sparse_volume,
    const xac::Sparse_volume_sample_context& sparse_volume_sample_context,
    const float3&                            sample_position,
          unsigned                           sparse_volume_attrib_idx = 0u,
          float                              dh = 1.0f);
 
float4 headlight_shading(   const xac::Scene& scene,
                            const float3& normal,
                            const float3& view_direction,
                            const float4& sample_color,
                            const float4& specular_color,
                            const float diffuse_falloff = 1.0f,
                            const float shininess = 100.0f,
                            const float ambient_factor = 0.f);
 
float4 phong_shading(   const xac::Scene& scene,
                        const xac::Material_phong& material,
                        const xac::Light& light,
                        const float3& view_direction,
                        const float3& normal,
                        const bool two_sided = false);
 
float4 phong_shading(   const xac::Scene& scene,
                        const uint material_id,
                        const uint light_id,
                        const float3& view_direction,
                        const float3& normal,
                        const bool two_sided = false);
 
bool intersect_ray_plane(   const xac::Ray& ray,
                            const xac::Plane& plane,
                                  float& t_hit,
                                  float2& tex_coord_hit);
 
bool intersect_ray_box(     const xac::Ray& ray,
                            const float3& box_min, 
                            const float3& box_max, 
                                  float& t_near, 
                                  float& t_far);
 
bool intersect_ray_cylinder(    const xac::Ray& ray,
                                const xac::Cylinder& cylinder,
                                      float& t_hit,
                                      float3& hit_normal);
 
bool intersect_ray_ellipsoid(   const xac::Ray& ray,
                                const xac::Ellipsoid& ellipsoid,
                                      float& t_hit,
                                      float3& hit_normal);
 
bool intersect_ray_cone (   const xac::Ray& ray,
                            const xac::Cone& cone,
                                  float& t_hit,
                                  float3& hit_normal);
 
template<typename TYPE>
const TYPE* bind_device_buffer( uint slot_id,
                                uint buffer_index) const;
 
bool device_buffer_available(   uint slot_id) const;
 
// Forward use decalarations of convenience functions (for documentation)
// using default CUDA library functions
 
// matrix, vector functions
using ::transform_point;
using ::transform_point2;
using ::transform_vector;
using ::transform_normal_inv;
using ::transform_plane_inv;
 
// matrix functions
using ::transpose;
using ::inverse;
 
// vector functions
using ::dot;
using ::length;
using ::normalize;
using ::floorf;
using ::fracf;
using ::cross;
using ::reflect;
using ::smoothstep;
 
// general component (scalar/float) utility functions
using ::min;
using ::max;
using ::fminf;
using ::fmaxf;
using ::lerp;
using ::clamp;
using ::fmod;
using ::fmodf;
using ::abs;
using ::fabs;
using ::powf;
 
} // namespace xaclib
} // namespace index
} // namespace nv