15#include <UT/UT_Version.h> 
   17#if !defined(SESI_OPENVDB) && !defined(SESI_OPENVDB_PRIM) 
   19#include <UT/UT_VDBUtils.h> 
   23#ifndef __HDK_UT_VDBUtils__ 
   24#define __HDK_UT_VDBUtils__ 
   45#include <UT/UT_Assert.h> 
   46#include <UT/UT_BoundingBox.h> 
   47#include <UT/UT_Matrix4.h> 
   48#include <UT/UT_Matrix3.h> 
   49#include <UT/UT_Matrix2.h> 
   50#include <SYS/SYS_Math.h> 
   82    if (grid.
isType<PointIndexGrid>())
 
   83        return UT_VDB_POINTINDEX;
 
   84    if (grid.
isType<PointDataGrid>())
 
   85        return UT_VDB_POINTDATA;
 
   87    return UT_VDB_INVALID;
 
   94    switch(UTvdbGetGridType(grid))
 
  112    case UT_VDB_POINTINDEX:
 
  114    case UT_VDB_POINTDATA:
 
  117        return "invalid type";
 
  123UTvdbGetGridTupleSize(UT_VDBType type)
 
  139    case UT_VDB_POINTINDEX:
 
  140    case UT_VDB_POINTDATA:
 
  153    return UTvdbGetGridTupleSize(UTvdbGetGridType(grid));
 
  161    static void plusEqual(T &lhs, 
const T &rhs)
 
  165struct UT_VDBMath<
bool>
 
  167    static void plusEqual(
bool &lhs, 
const bool &rhs)
 
  174template <
typename Gr
idType>
 
  177    { 
return UTverify_cast<const GridType *>(grid); }
 
  179template <
typename Gr
idType>
 
  182    { 
return UTverify_cast<GridType *>(grid); }
 
  184template <
typename Gr
idType>
 
  187    { 
return *UTverify_cast<const GridType *>(&grid); }
 
  189template <
typename Gr
idType>
 
  192    { 
return *UTverify_cast<GridType *>(&grid); }
 
  194template <
typename Gr
idType>
 
  195inline typename GridType::ConstPtr
 
  196UTvdbGridCast(openvdb::GridBase::ConstPtr grid)
 
  199template <
typename Gr
idType>
 
  200inline typename GridType::Ptr
 
  201UTvdbGridCast(openvdb::GridBase::Ptr grid)
 
  207namespace UT_VDBUtils {
 
  212template<
typename Gr
idType, 
typename OpType, 
typename Gr
idBaseType>
 
  214callTypedGrid(GridBaseType &grid, OpType& op)
 
  216    op.template operator()<
GridType>(UTvdbGridCast<GridType>(grid));
 
  252#define UT_VDB_DECL_PROCESS_TYPED_GRID(GRID_BASE_T) \ 
  253template<typename OpType> \ 
  255UTvdbProcessTypedGrid(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  257    using namespace openvdb; \ 
  258    using namespace UT_VDBUtils; \ 
  261        case UT_VDB_FLOAT:  callTypedGrid<FloatGrid>(grid, op); break; \ 
  262        case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \ 
  263        case UT_VDB_INT32:  callTypedGrid<Int32Grid>(grid, op); break; \ 
  264        case UT_VDB_INT64:  callTypedGrid<Int64Grid>(grid, op); break; \ 
  265        case UT_VDB_VEC3F:  callTypedGrid<Vec3SGrid>(grid, op); break; \ 
  266        case UT_VDB_VEC3D:  callTypedGrid<Vec3DGrid>(grid, op); break; \ 
  267        case UT_VDB_VEC3I:  callTypedGrid<Vec3IGrid>(grid, op); break; \ 
  268        default: return false; \ 
  272template<typename OpType> \ 
  274UTvdbProcessTypedGridTopology(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  276    using namespace openvdb; \ 
  277    using namespace UT_VDBUtils; \ 
  280        case UT_VDB_FLOAT:  callTypedGrid<FloatGrid>(grid, op); break; \ 
  281        case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \ 
  282        case UT_VDB_INT32:  callTypedGrid<Int32Grid>(grid, op); break; \ 
  283        case UT_VDB_INT64:  callTypedGrid<Int64Grid>(grid, op); break; \ 
  284        case UT_VDB_VEC3F:  callTypedGrid<Vec3SGrid>(grid, op); break; \ 
  285        case UT_VDB_VEC3D:  callTypedGrid<Vec3DGrid>(grid, op); break; \ 
  286        case UT_VDB_VEC3I:  callTypedGrid<Vec3IGrid>(grid, op); break; \ 
  287        case UT_VDB_BOOL:   callTypedGrid<BoolGrid>(grid, op); break; \ 
  288        default: return false; \ 
  292template<typename OpType> \ 
  294UTvdbProcessTypedGridVec3(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  296    using namespace openvdb; \ 
  297    using namespace UT_VDBUtils; \ 
  300        case UT_VDB_VEC3F:  callTypedGrid<Vec3SGrid>(grid, op); break; \ 
  301        case UT_VDB_VEC3D:  callTypedGrid<Vec3DGrid>(grid, op); break; \ 
  302        case UT_VDB_VEC3I:  callTypedGrid<Vec3IGrid>(grid, op); break; \ 
  303        default:            return false; \ 
  307template<typename OpType> \ 
  309UTvdbProcessTypedGridScalar(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  311    using namespace openvdb; \ 
  312    using namespace UT_VDBUtils; \ 
  315        case UT_VDB_FLOAT:  callTypedGrid<FloatGrid>(grid, op); break; \ 
  316        case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \ 
  317        case UT_VDB_INT32:  callTypedGrid<Int32Grid>(grid, op); break; \ 
  318        case UT_VDB_INT64:  callTypedGrid<Int64Grid>(grid, op); break; \ 
  319        default:            return false; \ 
  323template<typename OpType> \ 
  325UTvdbProcessTypedGridReal(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  327    using namespace openvdb; \ 
  328    using namespace UT_VDBUtils; \ 
  331        case UT_VDB_FLOAT:  callTypedGrid<FloatGrid>(grid, op); break; \ 
  332        case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \ 
  333        default:            return false; \ 
  337template<typename OpType> \ 
  339UTvdbProcessTypedGridPoint(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \ 
  341    using namespace openvdb; \ 
  342    using namespace openvdb::tools; \ 
  343    using namespace openvdb::points; \ 
  344    using namespace UT_VDBUtils; \ 
  347        case UT_VDB_POINTINDEX: callTypedGrid<PointIndexGrid>(grid, op); break; \ 
  348        case UT_VDB_POINTDATA:  callTypedGrid<PointDataGrid>(grid, op); break; \ 
  349        default:                return false; \ 
  356UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::ConstPtr)
 
  359UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::Ptr)
 
  365#define UT_VDB_CALL(GRIDT, RETURN, FNAME, GRIDBASE, ...) \ 
  367        RETURN FNAME <GRIDT> (UTvdbGridCast<GRIDT>(GRIDBASE), __VA_ARGS__ ); \ 
  385#define UTvdbCallRealType(TYPE, FNAME, GRIDBASE, ...)   \ 
  386    if (TYPE == UT_VDB_FLOAT)   \ 
  387        UT_VDB_CALL(openvdb::FloatGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  388    else if (TYPE == UT_VDB_DOUBLE)     \ 
  389        UT_VDB_CALL(openvdb::DoubleGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  391#define UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, ...) \ 
  392    UTvdbCallRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__)               \ 
  393    else if (TYPE == UT_VDB_INT32)      \ 
  394        UT_VDB_CALL(openvdb::Int32Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  395    else if (TYPE == UT_VDB_INT64)      \ 
  396        UT_VDB_CALL(openvdb::Int64Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  398#define UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, ...)   \ 
  399    if (TYPE == UT_VDB_VEC3F)   \ 
  400        UT_VDB_CALL(openvdb::Vec3fGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  401    else if (TYPE == UT_VDB_VEC3D)      \ 
  402        UT_VDB_CALL(openvdb::Vec3dGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  403    else if (TYPE == UT_VDB_VEC3I)      \ 
  404        UT_VDB_CALL(openvdb::Vec3IGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  406#define UTvdbCallPointType(TYPE, FNAME, GRIDBASE, ...)  \ 
  407    if (TYPE == UT_VDB_POINTINDEX)      \ 
  408        UT_VDB_CALL(openvdb::tools::PointIndexGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  409    else if (TYPE == UT_VDB_POINTDATA)  \ 
  410        UT_VDB_CALL(openvdb::points::PointDataGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  412#define UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, ...)   \ 
  413    if (TYPE == UT_VDB_BOOL) \ 
  414        UT_VDB_CALL(openvdb::BoolGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \ 
  416#define UTvdbCallAllType(TYPE, FNAME, GRIDBASE, ...)    \ 
  417    UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__)             \ 
  418    else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \ 
  420#define UTvdbCallAllTopology(TYPE, FNAME, GRIDBASE, ...)        \ 
  421    UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__)             \ 
  422    else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  423    else UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  445#define UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, ...) \ 
  446    if (TYPE == UT_VDB_FLOAT)   \ 
  447        UT_VDB_CALL(openvdb::FloatGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  448    else if (TYPE == UT_VDB_DOUBLE)     \ 
  449        UT_VDB_CALL(openvdb::DoubleGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  451#define UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, ...)       \ 
  452    UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__)             \ 
  453    else if (TYPE == UT_VDB_INT32)      \ 
  454        UT_VDB_CALL(openvdb::Int32Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  455    else if (TYPE == UT_VDB_INT64)      \ 
  456        UT_VDB_CALL(openvdb::Int64Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  458#define UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, ...) \ 
  459    if (TYPE == UT_VDB_VEC3F)   \ 
  460        UT_VDB_CALL(openvdb::Vec3fGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  461    else if (TYPE == UT_VDB_VEC3D)      \ 
  462        UT_VDB_CALL(openvdb::Vec3dGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  463    else if (TYPE == UT_VDB_VEC3I)      \ 
  464        UT_VDB_CALL(openvdb::Vec3IGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  466#define UTvdbReturnPointType(TYPE, FNAME, GRIDBASE, ...)        \ 
  467    if (TYPE == UT_VDB_POINTINDEX)      \ 
  468        UT_VDB_CALL(openvdb::tools::PointIndexGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  469    else if (TYPE == UT_VDB_POINTDATA)  \ 
  470        UT_VDB_CALL(openvdb::points::PointDataGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  472#define UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, ...)         \ 
  473    if (TYPE == UT_VDB_BOOL) \ 
  474        UT_VDB_CALL(openvdb::BoolGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \ 
  476#define UTvdbReturnAllType(TYPE, FNAME, GRIDBASE, ...)  \ 
  477    UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  478    else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \ 
  480#define UTvdbReturnAllTopology(TYPE, FNAME, GRIDBASE, ...)      \ 
  481    UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  482    else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  483    else UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \ 
  495UTvdbConvert(
const openvdb::math::Mat4<S> &src)
 
  497    return UT_Matrix4T<S>(src(0,0), src(0,1), src(0,2), src(0,3),
 
  498                          src(1,0), src(1,1), src(1,2), src(1,3),
 
  499                          src(2,0), src(2,1), src(2,2), src(2,3),
 
  500                          src(3,0), src(3,1), src(3,2), src(3,3));
 
  505UTvdbConvert(
const openvdb::math::Mat3<S> &src)
 
  507    return UT_Matrix3T<S>(src(0,0), src(0,1), src(0,2),
 
  508                          src(1,0), src(1,1), src(1,2),
 
  509                          src(2,0), src(2,1), src(2,2));
 
  514UTvdbConvert(
const openvdb::math::Mat2<S> &src)
 
  516    return UT_Matrix2T<S>(src(0,0), src(0,1),
 
  524openvdb::math::Mat4<S>
 
  525UTvdbConvert(
const UT_Matrix4T<S> &src)
 
  527    return openvdb::math::Mat4<S>(src(0,0), src(0,1), src(0,2), src(0,3),
 
  528                                  src(1,0), src(1,1), src(1,2), src(1,3),
 
  529                                  src(2,0), src(2,1), src(2,2), src(2,3),
 
  530                                  src(3,0), src(3,1), src(3,2), src(3,3));
 
  533openvdb::math::Mat3<S>
 
  534UTvdbConvert(
const UT_Matrix3T<S> &src)
 
  536    return openvdb::math::Mat3<S>(src(0,0), src(0,1), src(0,2),
 
  537                                  src(1,0), src(1,1), src(1,2),
 
  538                                  src(2,0), src(2,1), src(2,2));
 
  541openvdb::math::Mat2<S>
 
  542UTvdbConvert(
const UT_Matrix2T<S> &src)
 
  544    return openvdb::math::Mat2<S>(src(0,0), src(0,1),
 
  553UTvdbConvert(
const openvdb::math::Vec4<S> &src)
 
  555    return UT_Vector4T<S>(src.asPointer());
 
  559UTvdbConvert(
const openvdb::math::Vec3<S> &src)
 
  561    return UT_Vector3T<S>(src.asPointer());
 
  565UTvdbConvert(
const openvdb::math::Vec2<S> &src)
 
  567    return UT_Vector2T<S>(src.asPointer());
 
  574openvdb::math::Vec4<S>
 
  575UTvdbConvert(
const UT_Vector4T<S> &src)
 
  577    return openvdb::math::Vec4<S>(src.data());
 
  580openvdb::math::Vec3<S>
 
  581UTvdbConvert(
const UT_Vector3T<S> &src)
 
  583    return openvdb::math::Vec3<S>(src.data());
 
  586openvdb::math::Vec2<S>
 
  587UTvdbConvert(
const UT_Vector2T<S> &src)
 
  589    return openvdb::math::Vec2<S>(src.data());
 
  595inline UT_BoundingBoxD
 
  603inline openvdb::math::CoordBBox
 
  604UTvdbConvert(
const UT_BoundingBoxI &bbox)
 
  606    return openvdb::math::CoordBBox(
 
  607        openvdb::math::Coord(bbox.xmin(), bbox.ymin(), bbox.zmin()),
 
  608        openvdb::math::Coord(bbox.xmax(), bbox.ymax(), bbox.zmax()));
 
  613inline openvdb::math::Transform::Ptr
 
  614UTvdbCreateTransform(
const UT_Vector3 &orig, 
const UT_Vector3 &voxsize)
 
  617    UT_ASSERT(SYSalmostEqual(voxsize.minComponent(), voxsize.maxComponent()));
 
  618    fpreal vs = voxsize.maxComponent();
 
  619    openvdb::math::Transform::Ptr xform =
 
  620                            openvdb::math::Transform::createLinearTransform(vs);
 
  622    xform->postTranslate(UTvdbConvert(orig) + vs / 2);
 
  627inline openvdb::math::Vec4<T>   SYSabs(
const openvdb::math::Vec4<T> &v1)
 
  628{  
return openvdb::math::Vec4<T>( SYSabs(v1[0]),
 
  635inline openvdb::math::Vec3<T>   SYSabs(
const openvdb::math::Vec3<T> &v1)
 
  636{  
return openvdb::math::Vec3<T>( SYSabs(v1[0]),
 
  642inline openvdb::math::Vec2<T>   SYSabs(
const openvdb::math::Vec2<T> &v1)
 
  643{  
return openvdb::math::Vec2<T>( SYSabs(v1[0]),
 
  649inline openvdb::math::Vec4<T>   SYSmin(
const openvdb::math::Vec4<T> &v1, 
const openvdb::math::Vec4<T> &v2)
 
  650{  
return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0]),
 
  651                                  SYSmin(v1[1], v2[1]),
 
  652                                  SYSmin(v1[2], v2[2]),
 
  657inline openvdb::math::Vec4<T>   SYSmax(
const openvdb::math::Vec4<T> &v1, 
const openvdb::math::Vec4<T> &v2)
 
  658{  
return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0]),
 
  659                                  SYSmax(v1[1], v2[1]),
 
  660                                  SYSmax(v1[2], v2[2]),
 
  665inline openvdb::math::Vec4<T>   SYSmin(
const openvdb::math::Vec4<T> &v1, 
const openvdb::math::Vec4<T> &v2, 
const openvdb::math::Vec4<T> &v3)
 
  666{  
return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0], v3[0]),
 
  667                                  SYSmin(v1[1], v2[1], v3[1]),
 
  668                                  SYSmin(v1[2], v2[2], v3[2]),
 
  669                                  SYSmin(v1[3], v2[3], v3[3])
 
  673inline openvdb::math::Vec4<T>   SYSmax(
const openvdb::math::Vec4<T> &v1, 
const openvdb::math::Vec4<T> &v2, 
const openvdb::math::Vec4<T> &v3)
 
  674{  
return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0], v3[0]),
 
  675                                  SYSmax(v1[1], v2[1], v3[1]),
 
  676                                  SYSmax(v1[2], v2[2], v3[2]),
 
  677                                  SYSmax(v1[3], v2[3], v3[3])
 
  681inline openvdb::math::Vec3<T>   SYSmin(
const openvdb::math::Vec3<T> &v1, 
const openvdb::math::Vec3<T> &v2)
 
  682{  
return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0]),
 
  683                                  SYSmin(v1[1], v2[1]),
 
  688inline openvdb::math::Vec3<T>   SYSmax(
const openvdb::math::Vec3<T> &v1, 
const openvdb::math::Vec3<T> &v2)
 
  689{  
return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0]),
 
  690                                  SYSmax(v1[1], v2[1]),
 
  695inline openvdb::math::Vec3<T>   SYSmin(
const openvdb::math::Vec3<T> &v1, 
const openvdb::math::Vec3<T> &v2, 
const openvdb::math::Vec3<T> &v3)
 
  696{  
return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0], v3[0]),
 
  697                                  SYSmin(v1[1], v2[1], v3[1]),
 
  698                                  SYSmin(v1[2], v2[2], v3[2])
 
  702inline openvdb::math::Vec3<T>   SYSmax(
const openvdb::math::Vec3<T> &v1, 
const openvdb::math::Vec3<T> &v2, 
const openvdb::math::Vec3<T> &v3)
 
  703{  
return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0], v3[0]),
 
  704                                  SYSmax(v1[1], v2[1], v3[1]),
 
  705                                  SYSmax(v1[2], v2[2], v3[2])
 
  709inline openvdb::math::Vec2<T>   SYSmin(
const openvdb::math::Vec2<T> &v1, 
const openvdb::math::Vec2<T> &v2)
 
  710{  
return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0]),
 
  715inline openvdb::math::Vec2<T>   SYSmax(
const openvdb::math::Vec2<T> &v1, 
const openvdb::math::Vec2<T> &v2)
 
  716{  
return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0]),
 
  721inline openvdb::math::Vec2<T>   SYSmin(
const openvdb::math::Vec2<T> &v1, 
const openvdb::math::Vec2<T> &v2, 
const openvdb::math::Vec2<T> &v3)
 
  722{  
return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0], v3[0]),
 
  723                                  SYSmin(v1[1], v2[1], v3[1])
 
  727inline openvdb::math::Vec2<T>   SYSmax(
const openvdb::math::Vec2<T> &v1, 
const openvdb::math::Vec2<T> &v2, 
const openvdb::math::Vec2<T> &v3)
 
  728{  
return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0], v3[0]),
 
  729                                  SYSmax(v1[1], v2[1], v3[1])
 
Attribute-owned data structure for points. Point attributes are stored in leaf nodes and ordered by v...
Space-partitioning acceleration structure for points. Partitions the points into voxels to accelerate...
Abstract base class for typed grids.
Definition Grid.h:78
bool isType() const
Return true if this grid is of the same type as the template parameter.
Definition Grid.h:146
Axis-aligned bounding box of signed integer coordinates.
Definition Coord.h:252
Coord getStart() const
Return the minimum coordinate.
Definition Coord.h:336
Coord getEnd() const
Return the maximum coordinate plus one.
Definition Coord.h:339
Vec3d asVec3d() const
Definition Coord.h:144
GridType
List of types that are currently supported by NanoVDB.
Definition NanoVDB.h:219
Definition AttributeArray.h:42
Vec3DGrid Vec3dGrid
Definition openvdb.h:84
Grid< FloatTree > FloatGrid
Definition openvdb.h:75
GridType::ConstPtr gridConstPtrCast(const GridBase::ConstPtr &grid)
Cast a generic const grid pointer to a const pointer to a grid of a concrete class.
Definition Grid.h:1018
Grid< BoolTree > BoolGrid
Common grid types.
Definition openvdb.h:73
GridType::Ptr gridPtrCast(const GridBase::Ptr &grid)
Cast a generic grid pointer to a pointer to a grid of a concrete class.
Definition Grid.h:1002
Vec3SGrid Vec3fGrid
Definition openvdb.h:85
OPENVDB_IMPORT void initialize()
Global registration of native Grid, Transform, Metadata and Point attribute types....
Grid< Vec3ITree > Vec3IGrid
Definition openvdb.h:80
Grid< Int64Tree > Int64Grid
Definition openvdb.h:77
Grid< Int32Tree > Int32Grid
Definition openvdb.h:76
Grid< DoubleTree > DoubleGrid
Definition openvdb.h:74
Definition Exceptions.h:13