ai_volume.h

Go to the documentation of this file.

// Copyright 2026 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_bbox.h"
#include "ai_color.h"
#include "ai_params.h"
#include "ai_string.h"
#include "ai_version.h"
 
// forward declaration
struct AtNode;
struct AtShaderGlobals;
 
#define AI_VOLUME_INTERP_CLOSEST   0   
#define AI_VOLUME_INTERP_TRILINEAR 1   
#define AI_VOLUME_INTERP_TRICUBIC  2   
/* \} */
 
struct AtVolumeData
{
   void*  private_info;    
   AtBBox bbox;            
   float  auto_step_size;  
};
 
struct AtVolumeIntersectionInfo;
 
AI_API void AiVolumeAddIntersection(const AtVolumeIntersectionInfo* info, float t0, float t1);
AI_API void AiVolumeMergeIntersection(const AtVolumeIntersectionInfo* info, float t0, float t1, uint32_t prim_id);
 
/*
 * Volume file querying.
 */
AI_API AtArray* AiVolumeFileGetChannels(const char* filename);
AI_API AtBBox   AiVolumeFileGetBBox(const char* filename, const AtArray* channels);
 
AI_API bool AiVolumeFileMakeLODs(const char* input_vdb, const char* output_vdb,
                                 int requested_number_of_levels);
 
typedef bool (*AtVolumeCreate)(const AtNode* node,
                               AtVolumeData* data);
 
typedef bool (*AtVolumeUpdate)(const AtNode* node,
                               AtVolumeData* data);
 
typedef bool (*AtVolumeCleanup)(const AtNode* node,
                                AtVolumeData* data);
 
typedef bool (*AtVolumeSample)(const AtVolumeData* data,
                               const AtString channel,
                               const AtShaderGlobals* sg,
                               int interp,
                               AtParamValue *value,
                               uint8_t *type);
 
typedef bool (*AtVolumeGradient)(const AtVolumeData* data,
                                 const AtString channel,
                                 const AtShaderGlobals* sg,
                                 int interp,
                                 AtVector* gradient);
 
typedef void (*AtVolumeRayExtents)(const AtVolumeData* data,
                                   const AtVolumeIntersectionInfo* info,
                                   uint16_t tid,
                                   float time,
                                   const AtVector* origin,
                                   const AtVector* direction,
                                   float t0,
                                   float t1);
 
struct AtVolumeNodeMethods
{
   AtVolumeCreate        Create;        
   AtVolumeUpdate        Update;        
   AtVolumeCleanup       Cleanup;       
   AtVolumeRayExtents    RayExtents;    
   AtVolumeSample        Sample;        
   AtVolumeGradient      Gradient;      
};
 
#define AI_VOLUME_NODE_EXPORT_METHODS(tag)   \
AI_INSTANCE_COMMON_SHAPE_METHODS             \
volume_create;                               \
volume_update;                               \
volume_cleanup;                              \
volume_ray_extents;                          \
volume_sample;                               \
volume_gradient;                             \
static AtVolumeNodeMethods ai_vol_mtds = {   \
   VolumeCreate,                             \
   VolumeUpdate,                             \
   VolumeCleanup,                            \
   VolumeRayExtents,                         \
   VolumeSample,                             \
   VolumeGradient                            \
};                                           \
static AtNodeMethods ai_node_mtds = {        \
   &ai_common_mtds,                          \
   &ai_vol_mtds                              \
};                                           \
const AtNodeMethods* tag = &ai_node_mtds;
 
#define volume_create                          \
static bool VolumeCreate(const AtNode* node,   \
                         AtVolumeData* data)
 
#define volume_update                          \
static bool VolumeUpdate(const AtNode* node,   \
                         AtVolumeData* data)
 
#define volume_cleanup                         \
static bool VolumeCleanup(const AtNode* node,  \
                          AtVolumeData* data)
 
#define volume_ray_extents                                         \
static void VolumeRayExtents(const AtVolumeData* data,             \
                             const AtVolumeIntersectionInfo* info, \
                             uint16_t tid,                         \
                             float time,                           \
                             const AtVector* origin,               \
                             const AtVector* direction,            \
                             float t0,                             \
                             float t1)
 
#define volume_sample                                \
static bool VolumeSample(const AtVolumeData* data,   \
                         const AtString channel,     \
                         const AtShaderGlobals* sg,  \
                         int interp,                 \
                         AtParamValue *value,        \
                         uint8_t *type)
 
#define volume_gradient                                \
static bool VolumeGradient(const AtVolumeData* data,   \
                           const AtString channel,     \
                           const AtShaderGlobals* sg,  \
                           int interp,                 \
                           AtVector* gradient)
 
/*\}*/