Loading...
Searching...
No Matches
openvdb::v11_0 Namespace Reference

## Namespaces

namespace | compression
namespace | internal
namespace | io
namespace | logging
namespace | math
namespace | points
namespace | string
namespace | tools
namespace | tree
namespace | types_internal
namespace | util

## Classes

class | ArithmeticError
struct | CanConvertType
| CanConvertType<FromType, ToType>::value is `true` if a value of type ToType can be constructed from a value of type FromType. More...
struct | CanConvertType< math::Vec2< T >, math::Vec2< T > >
struct | CanConvertType< math::Vec3< T >, math::Vec3< T > >
struct | CanConvertType< math::Vec4< T >, math::Vec4< T > >
struct | CanConvertType< PointDataIndex32, PointIndex32 >
struct | CanConvertType< PointIndex32, PointDataIndex32 >
struct | CanConvertType< T, math::Vec2< T > >
struct | CanConvertType< T, math::Vec3< T > >
struct | CanConvertType< T, math::Vec4< T > >
struct | CanConvertType< T, ValueMask >
struct | CanConvertType< T0, math::Vec2< T1 > >
struct | CanConvertType< T0, math::Vec3< T1 > >
struct | CanConvertType< T0, math::Vec4< T1 > >
struct | CanConvertType< ValueMask, T >
class | CombineArgs
| This struct collects both input and output arguments to "grid combiner" functors used with the tree::TypedGrid::combineExtended() and combine2Extended() methods. AValueType and BValueType are the value types of the two grids being combined. More...
struct | ConvertElementType
| Conversion classes for changing the underlying type of VDB types. More...
struct | ConvertElementType< math::Mat3< T >, SubT >
struct | ConvertElementType< math::Mat4< T >, SubT >
struct | ConvertElementType< math::Quat< T >, SubT >
struct | ConvertElementType< math::Vec2< T >, SubT >
struct | ConvertElementType< math::Vec3< T >, SubT >
struct | ConvertElementType< math::Vec4< T >, SubT >
class | Coord
| Signed (x, y, z) 32-bit integer coordinates. More...
class | CoordBBox
| Axis-aligned bounding box of signed integer coordinates. More...
struct | CopyConstness
| CopyConstness<T1, T2>::Type is either const T2 or `T2` with no `const` qualifier, depending on whether `T1` is `const`. More...
class | DeepCopy
| Tag dispatch class that distinguishes constructors that deep copy. More...
class | Exception
class | Grid
| Container class that associates a tree with a transform and metadata. More...
class | GridBase
| Abstract base class for typed grids. More...
struct | GridNamePred
| Predicate functor that returns `true` for grids that have a specified name. More...
struct | HasMultiPassIO
| Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data. More...
struct | HasMultiPassIO< Grid< TreeType > >
struct | HasMultiPassIO< tree::Tree< RootNodeType > >
struct | index_sequence

Re-implementation of C++17's index_sequence and the helper alias make_index_sequence. This was introduced to fix an issue with clang's builtin implementation which treats template specializations of builtin templates differently when a subsequent parameter is dependent. The result is a resolution failure during partial specialization selection. For example, the following will fail to specialize: More...

class | IndexError
class | IoError
struct | IsSpecializationOf
| Helper metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter. More...
struct | IsSpecializationOf< Template< Args... >, Template >
class | KeyError
class | LookupError
struct | MatTraits
struct | MatTraits< T, false >
class | Metadata
| Base class for storing metadata information in a grid. More...
class | MetaMap
| Container that maps names (strings) to values of arbitrary types. More...
class | NotImplementedError
class | PartialCreate
| Tag dispatch class that distinguishes constructors during file input. More...
struct | PointIndex
| Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid. More...
struct | PromoteContainerType
struct | PromoteType
| Promotion classes which provide an interface for elevating and demoting a scalar or VDB type to a higher or lower precision. Integer types preserve their sign. Types promotion are only valid between 8 to 64 bits (long doubles are not supported). More...
struct | PromoteType< math::Mat3< T > >
struct | PromoteType< math::Mat4< T > >
struct | PromoteType< math::Quat< T > >
struct | PromoteType< math::Vec2< T > >
struct | PromoteType< math::Vec3< T > >
struct | PromoteType< math::Vec4< T > >
struct | QuatTraits
struct | QuatTraits< T, false >
class | ReferenceError
class | RuntimeError
class | ShallowCopy
| Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors. More...
class | Steal
| Tag dispatch class that distinguishes constructors that steal. More...
struct | SwappedCombineOp
class | TopologyCopy
| Tag dispatch class that distinguishes topology copy constructors from deep copy constructors. More...
struct | TreeAdapter
| This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type. More...
struct | TreeAdapter< Grid< _TreeType > >
| Partial specialization for Grid types. More...
struct | TreeAdapter< tree::ValueAccessor< _TreeType > >
| Partial specialization for ValueAccessor types. More...
struct | TupleList
| A trivial wrapper around a std::tuple but with compatible TypeList methods. Importantly can be instatiated from a TypeList and implements a similar foreach interface. More...
struct | TupleList<>
| Specilization of an empty TupleList. Required due to constructor selection. More...
class | TypedMetadata
| Templated metadata class to hold specific types. More...
class | TypeError
struct | TypeList
| A list of types (not necessarily unique) More...
class | UnknownMetadata
| Subclass to hold raw data of an unregistered type. More...
class | ValueError
class | ValueMask
struct | ValueTraits
struct | ValueTraits< T, false >
struct | VecTraits
struct | VecTraits< T, false >
struct | VersionId

## Typedefs

using | TreeBase = tree::TreeBase
using | GridPtrVec = std::vector<GridBase::Ptr>
using | GridPtrVecIter = GridPtrVec::iterator
using | GridPtrVecCIter = GridPtrVec::const_iterator
using | GridPtrVecPtr = SharedPtr<GridPtrVec>
using | GridCPtrVec = std::vector<GridBase::ConstPtr>
using | GridCPtrVecIter = GridCPtrVec::iterator
using | GridCPtrVecCIter = GridCPtrVec::const_iterator
using | GridCPtrVecPtr = SharedPtr<GridCPtrVec>
using | GridPtrSet = std::set<GridBase::Ptr>
using | GridPtrSetIter = GridPtrSet::iterator
using | GridPtrSetCIter = GridPtrSet::const_iterator
using | GridPtrSetPtr = SharedPtr<GridPtrSet>
using | GridCPtrSet = std::set<GridBase::ConstPtr>
using | GridCPtrSetIter = GridCPtrSet::iterator
using | GridCPtrSetCIter = GridCPtrSet::const_iterator
using | GridCPtrSetPtr = SharedPtr<GridCPtrSet>
using | BoolMetadata = TypedMetadata<bool>
using | DoubleMetadata = TypedMetadata<double>
using | FloatMetadata = TypedMetadata<float>
using | Int32Metadata = TypedMetadata<int32_t>
using | Int64Metadata = TypedMetadata<int64_t>
using | StringMetadata = TypedMetadata<std::string>
using | Vec2DMetadata = TypedMetadata<Vec2d>
using | Vec2IMetadata = TypedMetadata<Vec2i>
using | Vec2SMetadata = TypedMetadata<Vec2s>
using | Vec3DMetadata = TypedMetadata<Vec3d>
using | Vec3IMetadata = TypedMetadata<Vec3i>
using | Vec3SMetadata = TypedMetadata<Vec3s>
using | Vec4DMetadata = TypedMetadata<Vec4d>
using | Vec4IMetadata = TypedMetadata<Vec4i>
using | Vec4SMetadata = TypedMetadata<Vec4s>
using | Mat4SMetadata = TypedMetadata<Mat4s>
using | Mat4DMetadata = TypedMetadata<Mat4d>
using | BoolTree = tree::Tree4<bool, 5, 4, 3>::Type
| Common tree types.
using | DoubleTree = tree::Tree4<double, 5, 4, 3>::Type
using | FloatTree = tree::Tree4<float, 5, 4, 3>::Type
using | Int32Tree = tree::Tree4<int32_t, 5, 4, 3>::Type
using | Int64Tree = tree::Tree4<int64_t, 5, 4, 3>::Type
using | MaskTree = tree::Tree4<ValueMask, 5, 4, 3>::Type
using | UInt32Tree = tree::Tree4<uint32_t, 5, 4, 3>::Type
using | Vec2DTree = tree::Tree4<Vec2d, 5, 4, 3>::Type
using | Vec2ITree = tree::Tree4<Vec2i, 5, 4, 3>::Type
using | Vec2STree = tree::Tree4<Vec2s, 5, 4, 3>::Type
using | Vec3DTree = tree::Tree4<Vec3d, 5, 4, 3>::Type
using | Vec3ITree = tree::Tree4<Vec3i, 5, 4, 3>::Type
using | Vec3STree = tree::Tree4<Vec3f, 5, 4, 3>::Type
using | ScalarTree = FloatTree
using | TopologyTree = MaskTree
using | Vec3dTree = Vec3DTree
using | Vec3fTree = Vec3STree
using | VectorTree = Vec3fTree
using | BoolGrid = Grid<BoolTree>
| Common grid types.
using | DoubleGrid = Grid<DoubleTree>
using | FloatGrid = Grid<FloatTree>
using | Int32Grid = Grid<Int32Tree>
using | Int64Grid = Grid<Int64Tree>
using | MaskGrid = Grid<MaskTree>
using | Vec3DGrid = Grid<Vec3DTree>
using | Vec3IGrid = Grid<Vec3ITree>
using | Vec3SGrid = Grid<Vec3STree>
using | ScalarGrid = FloatGrid
using | TopologyGrid = MaskGrid
using | Vec3dGrid = Vec3DGrid
using | Vec3fGrid = Vec3SGrid
using | VectorGrid = Vec3fGrid
using | MapTypes
| The Map types which OpenVDB will register by default.
using | MetaTypes
| The Metadata types which OpenVDB will register by default.
using | Index32 = uint32_t
using | Index64 = uint64_t
using | Index = Index32
using | Int16 = int16_t
using | Int32 = int32_t
using | Int64 = int64_t
using | Int = Int32
using | Byte = unsigned char
using | Real = double
using | Vec2R = math::Vec2<Real>
using | Vec2I = math::Vec2<Index32>
using | Vec2f = math::Vec2<float>
using | Vec2H = math::Vec2<math::half>
using | Vec3R = math::Vec3<Real>
using | Vec3I = math::Vec3<Index32>
using | Vec3f = math::Vec3<float>
using | Vec3H = math::Vec3<math::half>
using | Vec3U8 = math::Vec3<uint8_t>
using | Vec3U16 = math::Vec3<uint16_t>
using | BBoxd = math::BBox<Vec3d>
using | Vec4R = math::Vec4<Real>
using | Vec4I = math::Vec4<Index32>
using | Vec4f = math::Vec4<float>
using | Vec4H = math::Vec4<math::half>
using | Mat3R = math::Mat3<Real>
using | Mat4R = math::Mat4<Real>
using | QuatR = math::Quat<Real>
template<typename T>
using | SharedPtr = std::shared_ptr<T>
template<typename T>
using | WeakPtr = std::weak_ptr<T>
using | PointIndex32 = PointIndex<Index32, 0>
using | PointIndex64 = PointIndex<Index64, 0>
using | PointDataIndex32 = PointIndex<Index32, 1>
using | PointDataIndex64 = PointIndex<Index64, 1>
template<std::size_t N>
using | make_index_sequence
using | NamePair = std::pair<Name, Name>
typedef std::string | Name
using | Vec2i
using | Vec2s
using | Vec2d
using | Vec3i
using | Vec3s
using | Vec3d
using | Vec4i
using | Vec4s
using | Vec4d
using | Mat3s
using | Mat3d
using | Mat4s
using | Mat4d
using | Quats
using | Quatd
Lists of native Grid Types
The floating point Grid types which OpenVDB will register by default.
using | RealGridTypes = TypeList<FloatGrid, DoubleGrid>
| The integer Grid types which OpenVDB will register by default.
using | IntegerGridTypes = TypeList<Int32Grid, Int64Grid>
| The integer Grid types which OpenVDB will register by default.
using | NumericGridTypes = RealGridTypes::Append<IntegerGridTypes>
using | Vec3GridTypes = TypeList<Vec3IGrid, Vec3SGrid, Vec3DGrid>
| The Vec3 Grid types which OpenVDB will register by default.
using | GridTypes
| The Grid types which OpenVDB will register by default.
Lists of native Tree Types
using | RealTreeTypes = RealGridTypes::Transform<internal::ToTreeType>
using | IntegerTreeTypes = IntegerGridTypes::Transform<internal::ToTreeType>
using | NumericTreeTypes = NumericGridTypes::Transform<internal::ToTreeType>
using | Vec3TreeTypes = Vec3GridTypes::Transform<internal::ToTreeType>
using | TreeTypes = GridTypes::Transform<internal::ToTreeType>
Lists of native TypedAttributeArray Types (for PointDataGrids)
The floating point attribute array types which OpenVDB will register by default.
using | RealAttributeTypes
| The integer attribute array types which OpenVDB will register by default.
using | IntegerAttributeTypes
| The integer attribute array types which OpenVDB will register by default.
using | NumericAttributeTypes
using | Vec3AttributeTypes
| The Vec3 attribute array types which OpenVDB will register by default.
using | Mat3AttributeTypes
| The Mat3 attribute array types which OpenVDB will register by default.
using | Mat4AttributeTypes
| The Mat4 attribute array types which OpenVDB will register by default.
using | QuatAttributeTypes
| The Quat attribute array types which OpenVDB will register by default.
using | AttributeTypes
| The attribute array types which OpenVDB will register by default.

## Enumerations

enum | GridClass { GRID_UNKNOWN = 0 , GRID_LEVEL_SET , GRID_FOG_VOLUME , GRID_STAGGERED }
enum | { NUM_GRID_CLASSES = GRID_STAGGERED + 1 }
enum | VecType { VEC_INVARIANT = 0 , VEC_COVARIANT , VEC_COVARIANT_NORMALIZE , VEC_CONTRAVARIANT_RELATIVE , VEC_CONTRAVARIANT_ABSOLUTE }
enum | { NUM_VEC_TYPES = VEC_CONTRAVARIANT_ABSOLUTE + 1 }
enum | MergePolicy { MERGE_ACTIVE_STATES = 0 , MERGE_NODES , MERGE_ACTIVE_STATES_AND_NODES }

enum

{
OPENVDB_FILE_VERSION_ROOTNODE_MAP = 213 , OPENVDB_FILE_VERSION_INTERNALNODE_COMPRESSION = 214 , OPENVDB_FILE_VERSION_SIMPLIFIED_GRID_TYPENAME = 215 , OPENVDB_FILE_VERSION_GRID_INSTANCING = 216 ,
OPENVDB_FILE_VERSION_BOOL_LEAF_OPTIMIZATION = 217 , OPENVDB_FILE_VERSION_BOOST_UUID = 218 , OPENVDB_FILE_VERSION_NO_GRIDMAP = 219 , OPENVDB_FILE_VERSION_NEW_TRANSFORM = 219 ,
OPENVDB_FILE_VERSION_SELECTIVE_COMPRESSION = 220 , OPENVDB_FILE_VERSION_FLOAT_FRUSTUM_BBOX = 221 , OPENVDB_FILE_VERSION_NODE_MASK_COMPRESSION = 222 , OPENVDB_FILE_VERSION_BLOSC_COMPRESSION = 223 ,
OPENVDB_FILE_VERSION_POINT_INDEX_GRID = 223 , OPENVDB_FILE_VERSION_MULTIPASS_IO = 224
}

| Notable file format version numbers. More...

## Functions

template<typename GridType>
GridType::Ptr | createGrid (const typename GridType::ValueType &background)
| Create a new grid of type `GridType` with a given background value.
template<typename GridType>
GridType::Ptr | createGrid ()
| Create a new grid of type `GridType` with background value zero.
template<typename TreePtrType>
Grid< typenameTreePtrType::element_type >::Ptr | createGrid (TreePtrType)
| Create a new grid of the appropriate type that wraps the given tree.
template<typename GridType>
GridType::Ptr | createLevelSet (Real voxelSize=1.0, Real halfWidth=LEVEL_SET_HALF_WIDTH)
| Create a new grid of type `GridType` classified as a "Level Set", i.e., a narrow-band level set.
template<typename GridPtrContainerT>
GridPtrContainerT::value_type | findGridByName (const GridPtrContainerT &container, const Name &name)
| Return the first grid in the given container whose name is name.
template<typename KeyT, typename GridPtrT>
GridPtrT | findGridByName (const std::map< KeyT, GridPtrT > &container, const Name &name)
| Return the first grid in the given map whose name is name.
template<typename GridType>
GridType::Ptr | gridPtrCast (const GridBase::Ptr &grid)
| Cast a generic grid pointer to a pointer to a grid of a concrete class.
template<typename GridType>
GridType::ConstPtr | gridConstPtrCast (const GridBase::ConstPtr &grid)
| Cast a generic const grid pointer to a const pointer to a grid of a concrete class.
std::ostream & | operator<< (std::ostream &ostr, const Metadata &metadata)
| Write a Metadata to an output stream.
std::ostream & | operator<< (std::ostream &, const MetaMap &)
| Write a MetaMap to an output stream.
OPENVDB_IMPORT void | initialize ()
| Global registration of native Grid, Transform, Metadata and Point attribute types. Also initializes blosc (if enabled).
OPENVDB_IMPORT void | uninitialize ()
| Global deregistration of native Grid, Transform, Metadata and Point attribute types.
template<size_t Start, size_t End, typename OpT>
OPENVDB_FORCE_INLINE auto | foreachIndex (OpT op)
template<size_t Start, size_t End, typename OpT, typename RetT>
OPENVDB_FORCE_INLINE RetT | evalFirstIndex (OpT op, const RetT def=RetT())
template<typename T, typename U>
SharedPtr< T > | ConstPtrCast (const SharedPtr< U > &ptr)
| Return a new shared pointer that points to the same object as the given pointer but with possibly different const-ness.
template<typename T, typename U>
SharedPtr< T > | DynamicPtrCast (const SharedPtr< U > &ptr)
| Return a new shared pointer that is either null or points to the same object as the given pointer after a `dynamic_cast`.
template<typename T, typename U>
SharedPtr< T > | StaticPtrCast (const SharedPtr< U > &ptr)
| Return a new shared pointer that points to the same object as the given pointer after a `static_cast`.
template<std::size_t N, std::size_t... Is>
auto | make_index_sequence_impl ()
template<typename T>
const char * | typeNameAsString ()
template<>
const char * | typeNameAsString< bool > ()
template<>
const char * | typeNameAsString< ValueMask > ()
template<>
const char * | typeNameAsString< math::half > ()
template<>
const char * | typeNameAsString< float > ()
template<>
const char * | typeNameAsString< double > ()
template<>
const char * | typeNameAsString< int8_t > ()
template<>
const char * | typeNameAsString< uint8_t > ()
template<>
const char * | typeNameAsString< int16_t > ()
template<>
const char * | typeNameAsString< uint16_t > ()
template<>
const char * | typeNameAsString< int32_t > ()
template<>
const char * | typeNameAsString< uint32_t > ()
template<>
const char * | typeNameAsString< int64_t > ()
template<>
const char * | typeNameAsString< Vec2i > ()
template<>
const char * | typeNameAsString< Vec2s > ()
template<>
const char * | typeNameAsString< Vec2d > ()
template<>
const char * | typeNameAsString< Vec3U8 > ()
template<>
const char * | typeNameAsString< Vec3U16 > ()
template<>
const char * | typeNameAsString< Vec3i > ()
template<>
const char * | typeNameAsString< Vec3f > ()
template<>
const char * | typeNameAsString< Vec3d > ()
template<>
const char * | typeNameAsString< Vec4i > ()
template<>
const char * | typeNameAsString< Vec4f > ()
template<>
const char * | typeNameAsString< Vec4d > ()
template<>
const char * | typeNameAsString< std::string > ()
template<>
const char * | typeNameAsString< Mat3s > ()
template<>
const char * | typeNameAsString< Mat3d > ()
template<>
const char * | typeNameAsString< Mat4s > ()
template<>
const char * | typeNameAsString< Mat4d > ()
template<>
const char * | typeNameAsString< math::Quats > ()
template<>
const char * | typeNameAsString< math::Quatd > ()
template<>
const char * | typeNameAsString< PointIndex32 > ()
template<>
const char * | typeNameAsString< PointIndex64 > ()
template<>
const char * | typeNameAsString< PointDataIndex32 > ()
template<>
const char * | typeNameAsString< PointDataIndex64 > ()
constexpr const char * | getLibraryVersionString ()
| Return a library version number string of the form "<major>.<minor>.<patch>".
constexpr const char * | getLibraryAbiVersionString ()
| Return a library version number string of the form "<major>.<minor>.<patch>abi<abi>".
constexpr const char * | getPackageUrl ()
constexpr const char * | getPackageRevision ()
template<>
math::Mat3s | zeroVal< math::Mat3s > ()
template<>
math::Mat3d | zeroVal< math::Mat3d > ()
template<>
math::Mat4s | zeroVal< math::Mat4s > ()
template<>
math::Mat4d | zeroVal< math::Mat4d > ()
template<typename T>
constexpr T | zeroVal ()
| Return the value of type T that corresponds to zero.
template<>
std::string | zeroVal< std::string > ()
| Return the `std::string` value that corresponds to zero.
template<>
constexpr bool | zeroVal< bool > ()
| Return the `bool` value that corresponds to zero.
template<>
math::Quats | zeroVal< math::Quats > ()
template<>
math::Quatd | zeroVal< math::Quatd > ()
Name | readString (std::istream &is)
void | writeString (std::ostream &os, const Name &name)
template<typename GridType>
GridType::Ptr | deepCopyTypedGrid (const GridBase::ConstPtr &grid)
| Return a pointer to a deep copy of the given grid, provided that the grid's concrete type is `GridType`.
template<typename GridType>
GridType::Ptr | deepCopyTypedGrid (const GridBase &grid)
| Return a pointer to a deep copy of the given grid, provided that the grid's concrete type is `GridType`.

## Variables

static const Real | LEVEL_SET_HALF_WIDTH = 3
const int32_t | OPENVDB_MAGIC = 0x56444220
| The magic number is stored in the first four bytes of every VDB file.
const uint32_t | OPENVDB_LIBRARY_MAJOR_VERSION
const uint32_t | OPENVDB_LIBRARY_MINOR_VERSION = ${OpenVDB_MINOR_VERSION}
const uint32_t | OPENVDB_LIBRARY_PATCH_VERSION = ${OpenVDB_PATCH_VERSION}
const uint32_t | OPENVDB_LIBRARY_VERSION
const uint32_t | OPENVDB_ABI_VERSION
const uint32_t | OPENVDB_FILE_VERSION = 224
| The current version number of the VDB file format.

## Typedef Documentation

## AttributeTypes

using AttributeTypes

Initial value:
NumericAttributeTypes::
Append<Vec3AttributeTypes>::
Append<Mat3AttributeTypes>::
Append<Mat4AttributeTypes>::
Append<QuatAttributeTypes>::
Append<points::GroupAttributeArray>::
Append<points::StringAttributeArray>::
Append<points::TypedAttributeArray<bool>>

The attribute array types which OpenVDB will register by default.

## BBoxd

using BBoxd = math::BBox<Vec3d>

## BoolGrid

using BoolGrid = Grid<BoolTree>

Common grid types.

## BoolMetadata

using BoolMetadata = TypedMetadata<bool>

## BoolTree

using BoolTree = tree::Tree4<bool, 5, 4, 3>::Type

Common tree types.

## Byte

using Byte = unsigned char

## DoubleGrid

using DoubleGrid = Grid<DoubleTree>

## DoubleMetadata

using DoubleMetadata = TypedMetadata<double>

## DoubleTree

using DoubleTree = tree::Tree4<double, 5, 4, 3>::Type

## FloatGrid

using FloatGrid = Grid<FloatTree>

## FloatMetadata

using FloatMetadata = TypedMetadata<float>

## FloatTree

using FloatTree = tree::Tree4<float, 5, 4, 3>::Type

## GridCPtrSet

using GridCPtrSet = std::set<GridBase::ConstPtr>

## GridCPtrSetCIter

using GridCPtrSetCIter = GridCPtrSet::const_iterator

## GridCPtrSetIter

using GridCPtrSetIter = GridCPtrSet::iterator

## GridCPtrSetPtr

using GridCPtrSetPtr = SharedPtr<GridCPtrSet>

## GridCPtrVec

using GridCPtrVec = std::vector<GridBase::ConstPtr>

## GridCPtrVecCIter

using GridCPtrVecCIter = GridCPtrVec::const_iterator

## GridCPtrVecIter

using GridCPtrVecIter = GridCPtrVec::iterator

## GridCPtrVecPtr

using GridCPtrVecPtr = SharedPtr<GridCPtrVec>

## GridPtrSet

using GridPtrSet = std::set<GridBase::Ptr>

## GridPtrSetCIter

using GridPtrSetCIter = GridPtrSet::const_iterator

## GridPtrSetIter

using GridPtrSetIter = GridPtrSet::iterator

## GridPtrSetPtr

using GridPtrSetPtr = SharedPtr<GridPtrSet>

## GridPtrVec

using GridPtrVec = std::vector<GridBase::Ptr>

## GridPtrVecCIter

using GridPtrVecCIter = GridPtrVec::const_iterator

## GridPtrVecIter

using GridPtrVecIter = GridPtrVec::iterator

## GridPtrVecPtr

using GridPtrVecPtr = SharedPtr<GridPtrVec>

## GridTypes

using GridTypes

Initial value:
NumericGridTypes::
Append<Vec3GridTypes>::
Append<tools::PointIndexGrid>::
Append<points::PointDataGrid>::
Append<BoolGrid, MaskGrid>

The Grid types which OpenVDB will register by default.

## Index

using Index = Index32

## Index32

using Index32 = uint32_t

## Index64

using Index64 = uint64_t

## Int

using Int = Int32

## Int16

using Int16 = int16_t

## Int32

using Int32 = int32_t

## Int32Grid

using Int32Grid = Grid<Int32Tree>

## Int32Metadata

using Int32Metadata = TypedMetadata<int32_t>

## Int32Tree

using Int32Tree = tree::Tree4<int32_t, 5, 4, 3>::Type

## Int64

using Int64 = int64_t

## Int64Grid

using Int64Grid = Grid<Int64Tree>

## Int64Metadata

using Int64Metadata = TypedMetadata<int64_t>

## Int64Tree

using Int64Tree = tree::Tree4<int64_t, 5, 4, 3>::Type

## IntegerAttributeTypes

using IntegerAttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<int8_t>,
points::TypedAttributeArray<int16_t>,
points::TypedAttributeArray<int32_t>,
points::TypedAttributeArray<int64_t>
>
openvdb::v11_0::points::TypedAttributeArray
Typed class for storing attribute data.
Definition AttributeArray.h:545
openvdb::v11_0::TypeList
A list of types (not necessarily unique)
Definition TypeList.h:578

The integer attribute array types which OpenVDB will register by default.

## IntegerGridTypes

using IntegerGridTypes = TypeList<Int32Grid, Int64Grid>

The integer Grid types which OpenVDB will register by default.

## IntegerTreeTypes

using IntegerTreeTypes = IntegerGridTypes::Transform<internal::ToTreeType>

## make_index_sequence

template<std::size_t N>

using make_index_sequence

Initial value:
std::decay_t<decltype(make_index_sequence_impl<N>())>

## MapTypes

using MapTypes

Initial value:
TypeList<
math::AffineMap,
math::UnitaryMap,
math::ScaleMap,
math::UniformScaleMap,
math::TranslationMap,
math::ScaleTranslateMap,
math::UniformScaleTranslateMap,
math::NonlinearFrustumMap>
openvdb::v11_0::math::AffineMap
A general linear transform using homogeneous coordinates to perform rotation, scaling,...
Definition Maps.h:296
openvdb::v11_0::math::NonlinearFrustumMap
This map is composed of three steps. First it will take a box of size (Lx X Ly X Lz) defined by a mem...
Definition Maps.h:1892
openvdb::v11_0::math::ScaleMap
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
Definition Maps.h:656
openvdb::v11_0::math::ScaleTranslateMap
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
Definition Maps.h:1163
openvdb::v11_0::math::TranslationMap
A specialized linear transform that performs a translation.
Definition Maps.h:978
openvdb::v11_0::math::UniformScaleMap
A specialized Affine transform that scales along the principal axis the scaling is uniform in the thr...
Definition Maps.h:906
openvdb::v11_0::math::UniformScaleTranslateMap
A specialized Affine transform that uniformaly scales along the principal axis and then translates th...
Definition Maps.h:1479
openvdb::v11_0::math::UnitaryMap
A specialized linear transform that performs a unitary maping i.e. rotation and or reflection.
Definition Maps.h:1621

The Map types which OpenVDB will register by default.

## MaskGrid

using MaskGrid = Grid<MaskTree>

## MaskTree

using MaskTree = tree::Tree4<ValueMask, 5, 4, 3>::Type

## Mat3AttributeTypes

using Mat3AttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<math::Mat3<float>>,
points::TypedAttributeArray<math::Mat3<double>>
>

The Mat3 attribute array types which OpenVDB will register by default.

## Mat3d

using Mat3d

## Mat3R

using Mat3R = math::Mat3<Real>

## Mat3s

using Mat3s

## Mat4AttributeTypes

using Mat4AttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<math::Mat4<float>>,
points::TypedAttributeArray<math::Mat4<double>>
>

The Mat4 attribute array types which OpenVDB will register by default.

## Mat4d

using Mat4d

## Mat4DMetadata

using Mat4DMetadata = TypedMetadata<Mat4d>

## Mat4R

using Mat4R = math::Mat4<Real>

## Mat4s

using Mat4s

## Mat4SMetadata

using Mat4SMetadata = TypedMetadata<Mat4s>

## MetaTypes

using MetaTypes

Initial value:
TypeList<
BoolMetadata,
DoubleMetadata,
FloatMetadata,
Int32Metadata,
Int64Metadata,
StringMetadata,
Vec2IMetadata,
Vec2SMetadata,
Vec2DMetadata,
Vec3IMetadata,
Vec3SMetadata,
Vec3DMetadata,
Vec4IMetadata,
Vec4SMetadata,
Vec4DMetadata,
Mat4SMetadata,
Mat4DMetadata,
io::DelayedLoadMetadata>
openvdb::v11_0::io::DelayedLoadMetadata
Store a buffer of data that can be optionally used during reading for faster delayed-load I/O perform...
Definition DelayedLoadMetadata.h:22
openvdb::v11_0::Vec4DMetadata
TypedMetadata< Vec4d > Vec4DMetadata
Definition Metadata.h:370
openvdb::v11_0::FloatMetadata
TypedMetadata< float > FloatMetadata
Definition Metadata.h:360
openvdb::v11_0::Vec2DMetadata
TypedMetadata< Vec2d > Vec2DMetadata
Definition Metadata.h:364
openvdb::v11_0::Vec3DMetadata
TypedMetadata< Vec3d > Vec3DMetadata
Definition Metadata.h:367
openvdb::v11_0::Int32Metadata
TypedMetadata< int32_t > Int32Metadata
Definition Metadata.h:361
openvdb::v11_0::Mat4DMetadata
TypedMetadata< Mat4d > Mat4DMetadata
Definition Metadata.h:374
openvdb::v11_0::Vec2IMetadata
TypedMetadata< Vec2i > Vec2IMetadata
Definition Metadata.h:365
openvdb::v11_0::StringMetadata
TypedMetadata< std::string > StringMetadata
Definition Metadata.h:363
openvdb::v11_0::Vec4SMetadata
TypedMetadata< Vec4s > Vec4SMetadata
Definition Metadata.h:372
openvdb::v11_0::Vec3SMetadata
TypedMetadata< Vec3s > Vec3SMetadata
Definition Metadata.h:369
openvdb::v11_0::Vec2SMetadata
TypedMetadata< Vec2s > Vec2SMetadata
Definition Metadata.h:366
openvdb::v11_0::Vec4IMetadata
TypedMetadata< Vec4i > Vec4IMetadata
Definition Metadata.h:371
openvdb::v11_0::Mat4SMetadata
TypedMetadata< Mat4s > Mat4SMetadata
Definition Metadata.h:373
openvdb::v11_0::Vec3IMetadata
TypedMetadata< Vec3i > Vec3IMetadata
Definition Metadata.h:368
openvdb::v11_0::BoolMetadata
TypedMetadata< bool > BoolMetadata
Definition Metadata.h:358
openvdb::v11_0::Int64Metadata
TypedMetadata< int64_t > Int64Metadata
Definition Metadata.h:362
openvdb::v11_0::DoubleMetadata
TypedMetadata< double > DoubleMetadata
Definition Metadata.h:359

The Metadata types which OpenVDB will register by default.

## Name

typedef std::string Name

## NamePair

using NamePair = std::pair<Name, Name>

## NumericAttributeTypes

using NumericAttributeTypes

Initial value:
RealAttributeTypes::Append<IntegerAttributeTypes>
openvdb::v11_0::TypeList< points::TypedAttributeArray< float >, points::TypedAttributeArray< double >, points::TypedAttributeArray< float, points::TruncateCodec >, points::TypedAttributeArray< float, points::FixedPointCodec< true, points::UnitRange > >, points::TypedAttributeArray< float, points::FixedPointCodec< false, points::UnitRange > > >::Append
typename typelist_internal::TSAppendImpl< Self, TypesToAppend... >::type Append
Definition TypeList.h:656

The scalar attribute array types which OpenVDB will register by default. This is a combination of native floating point and integer array types. Note that this list does not include bool arrays.

## NumericGridTypes

using NumericGridTypes = RealGridTypes::Append<IntegerGridTypes>

The scalar Grid types which OpenVDB will register by default. This is a combination of native floating point and integer grid types. Note that this list does not include Bool or Mask Grids.

## NumericTreeTypes

using NumericTreeTypes = NumericGridTypes::Transform<internal::ToTreeType>

## PointDataIndex32

using PointDataIndex32 = PointIndex<Index32, 1>

## PointDataIndex64

using PointDataIndex64 = PointIndex<Index64, 1>

## PointIndex32

using PointIndex32 = PointIndex<Index32, 0>

## PointIndex64

using PointIndex64 = PointIndex<Index64, 0>

## QuatAttributeTypes

using QuatAttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<math::Quat<float>>,
points::TypedAttributeArray<math::Quat<double>>
>

The Quat attribute array types which OpenVDB will register by default.

## Quatd

using Quatd

## QuatR

using QuatR = math::Quat<Real>

## Quats

using Quats

## Real

using Real = double

## RealAttributeTypes

using RealAttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<float>,
points::TypedAttributeArray<double>,
points::TypedAttributeArray<float, points::TruncateCodec>,
points::TypedAttributeArray<float, points::FixedPointCodec<true, points::UnitRange>>,
points::TypedAttributeArray<float, points::FixedPointCodec<false, points::UnitRange>>
>

The integer attribute array types which OpenVDB will register by default.

## RealGridTypes

using RealGridTypes = TypeList<FloatGrid, DoubleGrid>

The integer Grid types which OpenVDB will register by default.

## RealTreeTypes

using RealTreeTypes = RealGridTypes::Transform<internal::ToTreeType>

## ScalarGrid

using ScalarGrid = FloatGrid

## ScalarTree

using ScalarTree = FloatTree

## SharedPtr

template<typename T>

using SharedPtr = std::shared_ptr<T>

## StringMetadata

using StringMetadata = TypedMetadata<std::string>

## TopologyGrid

using TopologyGrid = MaskGrid

## TopologyTree

using TopologyTree = MaskTree

## TreeBase

using TreeBase = tree::TreeBase

## TreeTypes

using TreeTypes = GridTypes::Transform<internal::ToTreeType>

## UInt32Tree

using UInt32Tree = tree::Tree4<uint32_t, 5, 4, 3>::Type

## Vec2d

using Vec2d

## Vec2DMetadata

using Vec2DMetadata = TypedMetadata<Vec2d>

## Vec2DTree

using Vec2DTree = tree::Tree4<Vec2d, 5, 4, 3>::Type

## Vec2f

using Vec2f = math::Vec2<float>

## Vec2H

using Vec2H = math::Vec2<math::half>

## Vec2I

using Vec2I = math::Vec2<Index32>

## Vec2i

using Vec2i

## Vec2IMetadata

using Vec2IMetadata = TypedMetadata<Vec2i>

## Vec2ITree

using Vec2ITree = tree::Tree4<Vec2i, 5, 4, 3>::Type

## Vec2R

using Vec2R = math::Vec2<Real>

## Vec2s

using Vec2s

## Vec2SMetadata

using Vec2SMetadata = TypedMetadata<Vec2s>

## Vec2STree

using Vec2STree = tree::Tree4<Vec2s, 5, 4, 3>::Type

## Vec3AttributeTypes

using Vec3AttributeTypes

Initial value:
TypeList<
points::TypedAttributeArray<math::Vec3<int32_t>>,
points::TypedAttributeArray<math::Vec3<float>>,
points::TypedAttributeArray<math::Vec3<double>>,
points::TypedAttributeArray<math::Vec3<float>, points::TruncateCodec>,
points::TypedAttributeArray<math::Vec3<float>, points::FixedPointCodec<true, points::PositionRange>>,
points::TypedAttributeArray<math::Vec3<float>, points::FixedPointCodec<false, points::PositionRange>>,
points::TypedAttributeArray<math::Vec3<float>, points::FixedPointCodec<true, points::UnitRange>>,
points::TypedAttributeArray<math::Vec3<float>, points::FixedPointCodec<false, points::UnitRange>>,
points::TypedAttributeArray<math::Vec3<float>, points::UnitVecCodec>
>
openvdb::v11_0::points::FixedPointCodec
Definition AttributeArray.h:511
openvdb::v11_0::points::TruncateCodec
Definition AttributeArray.h:481
openvdb::v11_0::points::UnitVecCodec
Definition AttributeArray.h:526

The Vec3 attribute array types which OpenVDB will register by default.

## Vec3d

using Vec3d

## Vec3DGrid

using Vec3DGrid = Grid<Vec3DTree>

## Vec3dGrid

using Vec3dGrid = Vec3DGrid

## Vec3DMetadata

using Vec3DMetadata = TypedMetadata<Vec3d>

## Vec3DTree

using Vec3DTree = tree::Tree4<Vec3d, 5, 4, 3>::Type

## Vec3dTree

using Vec3dTree = Vec3DTree

## Vec3f

using Vec3f = math::Vec3<float>

## Vec3fGrid

using Vec3fGrid = Vec3SGrid

## Vec3fTree

using Vec3fTree = Vec3STree

## Vec3GridTypes

using Vec3GridTypes = TypeList<Vec3IGrid, Vec3SGrid, Vec3DGrid>

The Vec3 Grid types which OpenVDB will register by default.

## Vec3H

using Vec3H = math::Vec3<math::half>

## Vec3I

using Vec3I = math::Vec3<Index32>

## Vec3i

using Vec3i

## Vec3IGrid

using Vec3IGrid = Grid<Vec3ITree>

## Vec3IMetadata

using Vec3IMetadata = TypedMetadata<Vec3i>

## Vec3ITree

using Vec3ITree = tree::Tree4<Vec3i, 5, 4, 3>::Type

## Vec3R

using Vec3R = math::Vec3<Real>

## Vec3s

using Vec3s

## Vec3SGrid

using Vec3SGrid = Grid<Vec3STree>

## Vec3SMetadata

using Vec3SMetadata = TypedMetadata<Vec3s>

## Vec3STree

using Vec3STree = tree::Tree4<Vec3f, 5, 4, 3>::Type

## Vec3TreeTypes

using Vec3TreeTypes = Vec3GridTypes::Transform<internal::ToTreeType>

## Vec3U16

using Vec3U16 = math::Vec3<uint16_t>

## Vec3U8

using Vec3U8 = math::Vec3<uint8_t>

## Vec4d

using Vec4d

## Vec4DMetadata

using Vec4DMetadata = TypedMetadata<Vec4d>

## Vec4f

using Vec4f = math::Vec4<float>

## Vec4H

using Vec4H = math::Vec4<math::half>

## Vec4I

using Vec4I = math::Vec4<Index32>

## Vec4i

using Vec4i

## Vec4IMetadata

using Vec4IMetadata = TypedMetadata<Vec4i>

## Vec4R

using Vec4R = math::Vec4<Real>

## Vec4s

using Vec4s

## Vec4SMetadata

using Vec4SMetadata = TypedMetadata<Vec4s>

## VectorGrid

using VectorGrid = Vec3fGrid

## VectorTree

using VectorTree = Vec3fTree

## WeakPtr

template<typename T>

using WeakPtr = std::weak_ptr<T>

## Enumeration Type Documentation

## anonymous enum

anonymous enum

Notable file format version numbers.

Enumerator
OPENVDB_FILE_VERSION_ROOTNODE_MAP |
OPENVDB_FILE_VERSION_INTERNALNODE_COMPRESSION |
OPENVDB_FILE_VERSION_SIMPLIFIED_GRID_TYPENAME |
OPENVDB_FILE_VERSION_GRID_INSTANCING |
OPENVDB_FILE_VERSION_BOOL_LEAF_OPTIMIZATION |
OPENVDB_FILE_VERSION_BOOST_UUID |
OPENVDB_FILE_VERSION_NO_GRIDMAP |
OPENVDB_FILE_VERSION_NEW_TRANSFORM |
OPENVDB_FILE_VERSION_SELECTIVE_COMPRESSION |
OPENVDB_FILE_VERSION_FLOAT_FRUSTUM_BBOX |
OPENVDB_FILE_VERSION_NODE_MASK_COMPRESSION |
OPENVDB_FILE_VERSION_BLOSC_COMPRESSION |
OPENVDB_FILE_VERSION_POINT_INDEX_GRID |
OPENVDB_FILE_VERSION_MULTIPASS_IO |

## anonymous enum

anonymous enum

Enumerator
NUM_VEC_TYPES |

## anonymous enum

anonymous enum

Enumerator
NUM_GRID_CLASSES |

## GridClass

enum GridClass

Enumerator
GRID_UNKNOWN |
GRID_LEVEL_SET |
GRID_FOG_VOLUME |
GRID_STAGGERED |

## MergePolicy

enum MergePolicy

Specify how grids should be merged during certain (typically multithreaded) operations.

MERGE_ACTIVE_STATES

  The output grid is active wherever any of the input grids is active.

MERGE_NODES

  The output grid's tree has a node wherever any of the input grids' trees has a node, regardless of any active states.

MERGE_ACTIVE_STATES_AND_NODES
  The output grid is active wherever any of the input grids is active, and its tree has a node wherever any of the input grids' trees has a node.

Enumerator
MERGE_ACTIVE_STATES |
MERGE_NODES |
MERGE_ACTIVE_STATES_AND_NODES |

## VecType

enum VecType

The type of a vector determines how transforms are applied to it:

Invariant

  Does not transform (e.g., tuple, uvw, color)

Covariant

  Apply inverse-transpose transformation: w = 0, ignores translation (e.g., gradient/normal)

Covariant Normalize

  Apply inverse-transpose transformation: w = 0, ignores translation, vectors are renormalized (e.g., unit normal)

Contravariant Relative

  Apply "regular" transformation: w = 0, ignores translation (e.g., displacement, velocity, acceleration)

Contravariant Absolute
  Apply "regular" transformation: w = 1, vector translates (e.g., position)

Enumerator
VEC_INVARIANT |
VEC_COVARIANT |
VEC_COVARIANT_NORMALIZE |
VEC_CONTRAVARIANT_RELATIVE |
VEC_CONTRAVARIANT_ABSOLUTE |

## Function Documentation

## ConstPtrCast()

template<typename T, typename U>

SharedPtr< T > ConstPtrCast | ( | const SharedPtr< U > & | ptr | ) |

inline

Return a new shared pointer that points to the same object as the given pointer but with possibly different const-ness.

Example:
  FloatGrid::ConstPtr grid = ...;
  FloatGrid::Ptr nonConstGrid = ConstPtrCast<FloatGrid>(grid);
  FloatGrid::ConstPtr constGrid = ConstPtrCast<const FloatGrid>(nonConstGrid);
  openvdb::v11_0::Grid< FloatTree >::ConstPtr
  SharedPtr< const Grid > ConstPtr
  Definition Grid.h:574
  openvdb::v11_0::Grid< FloatTree >::Ptr
  SharedPtr< Grid > Ptr
  Definition Grid.h:573
  openvdb::v11_0::ConstPtrCast
  SharedPtr< T > ConstPtrCast(const SharedPtr< U > &ptr)
  Return a new shared pointer that points to the same object as the given pointer but with possibly dif...
  Definition Types.h:126

## createGrid() [1/3]

template<typename GridType>

GridType::Ptr createGrid | ( |  | ) |

inline

Create a new grid of type `GridType` with background value zero.

Note
  Calling createGrid<GridType>() is equivalent to calling GridType::create().

## createGrid() [2/3]

template<typename GridType>

GridType::Ptr createGrid | ( | const typename GridType::ValueType & | background | ) |

inline

Create a new grid of type `GridType` with a given background value.

Note
  Calling createGrid<GridType>(background) is equivalent to calling GridType::create(background).

## createGrid() [3/3]

template<typename TreePtrType>

Grid< typenameTreePtrType::element_type >::Ptr createGrid | ( | TreePtrType | tree | ) |

inline

Create a new grid of the appropriate type that wraps the given tree.

Note
  This function can be called without specifying the template argument, i.e., as createGrid(tree).

## createLevelSet()

template<typename GridType>

GridType::Ptr createLevelSet | ( | Real | voxelSize = 1.0,
|  | Real | halfWidth = LEVEL_SET_HALF_WIDTH )

Create a new grid of type `GridType` classified as a "Level Set", i.e., a narrow-band level set.

Note
  `GridType::ValueType` must be a floating-point scalar.

Parameters

  voxelSize | the size of a voxel in world units
  halfWidth | the half width of the narrow band in voxel units

The voxel size and the narrow band half width define the grid's background value as halfWidth*voxelWidth. The transform is linear with a uniform scaling only corresponding to the specified voxel size.

Note
  It is generally advisable to specify a half-width of the narrow band that is larger than one voxel unit, otherwise zero crossings are not guaranteed.

## deepCopyTypedGrid() [1/2]

template<typename GridType>

GridType::Ptr deepCopyTypedGrid | ( | const GridBase & | grid | ) |

inline

Return a pointer to a deep copy of the given grid, provided that the grid's concrete type is `GridType`.

Return a null pointer if the input pointer is null or if it points to a grid that is not of type `GridType`.

## deepCopyTypedGrid() [2/2]

template<typename GridType>

GridType::Ptr deepCopyTypedGrid | ( | const GridBase::ConstPtr & | grid | ) |

inline

Return a pointer to a deep copy of the given grid, provided that the grid's concrete type is `GridType`.

Return a null pointer if the input pointer is null or if it points to a grid that is not of type `GridType`.

## DynamicPtrCast()

template<typename T, typename U>

SharedPtr< T > DynamicPtrCast | ( | const SharedPtr< U > & | ptr | ) |

inline

Return a new shared pointer that is either null or points to the same object as the given pointer after a `dynamic_cast`.

Example:
  GridBase::ConstPtr grid = ...;
  FloatGrid::ConstPtr floatGrid = DynamicPtrCast<const FloatGrid>(grid);
  openvdb::v11_0::GridBase::ConstPtr
  SharedPtr< const GridBase > ConstPtr
  Definition Grid.h:81
  openvdb::v11_0::DynamicPtrCast
  SharedPtr< T > DynamicPtrCast(const SharedPtr< U > &ptr)
  Return a new shared pointer that is either null or points to the same object as the given pointer aft...
  Definition Types.h:136

## evalFirstIndex()

template<size_t Start, size_t End, typename OpT, typename RetT>

OPENVDB_FORCE_INLINE RetT evalFirstIndex | ( | OpT | op,
|  | const RetT | def = RetT() )

## findGridByName() [1/2]

template<typename GridPtrContainerT>

GridPtrContainerT::value_type findGridByName | ( | const GridPtrContainerT & | container,
|  | const Name & | name )

inline

Return the first grid in the given container whose name is name.

## findGridByName() [2/2]

template<typename KeyT, typename GridPtrT>

GridPtrT findGridByName | ( | const std::map< KeyT, GridPtrT > & | container,
|  | const Name & | name )

inline

Return the first grid in the given map whose name is name.

## foreachIndex()

template<size_t Start, size_t End, typename OpT>

OPENVDB_FORCE_INLINE auto foreachIndex | ( | OpT | op | ) |

## getLibraryAbiVersionString()

const char * getLibraryAbiVersionString | ( |  | ) |

inline constexpr

Return a library version number string of the form "<major>.<minor>.<patch>abi<abi>".

## getLibraryVersionString()

const char * getLibraryVersionString | ( |  | ) |

inline constexpr

Return a library version number string of the form "<major>.<minor>.<patch>".

## getPackageRevision()

const char * getPackageRevision | ( |  | ) |

inline constexpr

## getPackageUrl()

const char * getPackageUrl | ( |  | ) |

inline constexpr

## gridConstPtrCast()

template<typename GridType>

GridType::ConstPtr gridConstPtrCast | ( | const GridBase::ConstPtr & | grid | ) |

inline

Cast a generic const grid pointer to a const pointer to a grid of a concrete class.

Return a null pointer if the input pointer is null or if it points to a grid that is not of type `GridType`.

Note
  Calling gridConstPtrCast<GridType>(grid) is equivalent to calling GridBase::constGrid<GridType>(grid).

## gridPtrCast()

template<typename GridType>

GridType::Ptr gridPtrCast | ( | const GridBase::Ptr & | grid | ) |

inline

Cast a generic grid pointer to a pointer to a grid of a concrete class.

Return a null pointer if the input pointer is null or if it points to a grid that is not of type `GridType`.

Note
  Calling gridPtrCast<GridType>(grid) is equivalent to calling GridBase::grid<GridType>(grid).

## initialize()

OPENVDB_IMPORT void initialize | ( |  | ) |

Global registration of native Grid, Transform, Metadata and Point attribute types. Also initializes blosc (if enabled).

Calling this methods registers factory callbacks for the set of native grid, transform, metadata and point attribute types that OpenVDB supports by default. For most types, calling openvdb::initialize is only required for serialization support. However, openvdb::initialize must be called for PointDataGrid attribute usage as these callbacks are used in various tools.

Note
  This method is thread safe - it can be concurrently called multiple times, early exiting if it has already been called so long as openvdb::uninitialize() has not been called.

## make_index_sequence_impl()

template<std::size_t N, std::size_t... Is>

auto make_index_sequence_impl | ( |  | ) |

## operator<<() [1/2]

std::ostream & operator<< | ( | std::ostream & | ,
|  | const MetaMap & | )

Write a MetaMap to an output stream.

## operator<<() [2/2]

std::ostream & operator<< | ( | std::ostream & | ostr,
|  | const Metadata & | metadata )

inline

Write a Metadata to an output stream.

## readString()

Name readString | ( | std::istream & | is | ) |

inline

## StaticPtrCast()

template<typename T, typename U>

SharedPtr< T > StaticPtrCast | ( | const SharedPtr< U > & | ptr | ) |

inline

Return a new shared pointer that points to the same object as the given pointer after a `static_cast`.

Example:
  FloatGrid::Ptr floatGrid = ...;
  GridBase::Ptr grid = StaticPtrCast<GridBase>(floatGrid);
  openvdb::v11_0::GridBase::Ptr
  SharedPtr< GridBase > Ptr
  Definition Grid.h:80
  openvdb::v11_0::StaticPtrCast
  SharedPtr< T > StaticPtrCast(const SharedPtr< U > &ptr)
  Return a new shared pointer that points to the same object as the given pointer after a static_cast.
  Definition Types.h:146

## typeNameAsString()

template<typename T>

const char * typeNameAsString | ( |  | ) |

## typeNameAsString< bool >()

template<>

const char * typeNameAsString< bool > | ( |  | ) |

inline

## typeNameAsString< double >()

template<>

const char * typeNameAsString< double > | ( |  | ) |

inline

## typeNameAsString< float >()

template<>

const char * typeNameAsString< float > | ( |  | ) |

inline

## typeNameAsString< int16_t >()

template<>

const char * typeNameAsString< int16_t > | ( |  | ) |

inline

## typeNameAsString< int32_t >()

template<>

const char * typeNameAsString< int32_t > | ( |  | ) |

inline

## typeNameAsString< int64_t >()

template<>

const char * typeNameAsString< int64_t > | ( |  | ) |

inline

## typeNameAsString< int8_t >()

template<>

const char * typeNameAsString< int8_t > | ( |  | ) |

inline

## typeNameAsString< Mat3d >()

template<>

const char * typeNameAsString< Mat3d > | ( |  | ) |

inline

## typeNameAsString< Mat3s >()

template<>

const char * typeNameAsString< Mat3s > | ( |  | ) |

inline

## typeNameAsString< Mat4d >()

template<>

const char * typeNameAsString< Mat4d > | ( |  | ) |

inline

## typeNameAsString< Mat4s >()

template<>

const char * typeNameAsString< Mat4s > | ( |  | ) |

inline

## typeNameAsString< math::half >()

template<>

const char * typeNameAsString< math::half > | ( |  | ) |

inline

## typeNameAsString< math::Quatd >()

template<>

const char * typeNameAsString< math::Quatd > | ( |  | ) |

inline

## typeNameAsString< math::Quats >()

template<>

const char * typeNameAsString< math::Quats > | ( |  | ) |

inline

## typeNameAsString< PointDataIndex32 >()

template<>

const char * typeNameAsString< PointDataIndex32 > | ( |  | ) |

inline

## typeNameAsString< PointDataIndex64 >()

template<>

const char * typeNameAsString< PointDataIndex64 > | ( |  | ) |

inline

## typeNameAsString< PointIndex32 >()

template<>

const char * typeNameAsString< PointIndex32 > | ( |  | ) |

inline

## typeNameAsString< PointIndex64 >()

template<>

const char * typeNameAsString< PointIndex64 > | ( |  | ) |

inline

## typeNameAsString< std::string >()

template<>

const char * typeNameAsString< std::string > | ( |  | ) |

inline

## typeNameAsString< uint16_t >()

template<>

const char * typeNameAsString< uint16_t > | ( |  | ) |

inline

## typeNameAsString< uint32_t >()

template<>

const char * typeNameAsString< uint32_t > | ( |  | ) |

inline

## typeNameAsString< uint8_t >()

template<>

const char * typeNameAsString< uint8_t > | ( |  | ) |

inline

## typeNameAsString< ValueMask >()

template<>

const char * typeNameAsString< ValueMask > | ( |  | ) |

inline

## typeNameAsString< Vec2d >()

template<>

const char * typeNameAsString< Vec2d > | ( |  | ) |

inline

## typeNameAsString< Vec2i >()

template<>

const char * typeNameAsString< Vec2i > | ( |  | ) |

inline

## typeNameAsString< Vec2s >()

template<>

const char * typeNameAsString< Vec2s > | ( |  | ) |

inline

## typeNameAsString< Vec3d >()

template<>

const char * typeNameAsString< Vec3d > | ( |  | ) |

inline

## typeNameAsString< Vec3f >()

template<>

const char * typeNameAsString< Vec3f > | ( |  | ) |

inline

## typeNameAsString< Vec3i >()

template<>

const char * typeNameAsString< Vec3i > | ( |  | ) |

inline

## typeNameAsString< Vec3U16 >()

template<>

const char * typeNameAsString< Vec3U16 > | ( |  | ) |

inline

## typeNameAsString< Vec3U8 >()

template<>

const char * typeNameAsString< Vec3U8 > | ( |  | ) |

inline

## typeNameAsString< Vec4d >()

template<>

const char * typeNameAsString< Vec4d > | ( |  | ) |

inline

## typeNameAsString< Vec4f >()

template<>

const char * typeNameAsString< Vec4f > | ( |  | ) |

inline

## typeNameAsString< Vec4i >()

template<>

const char * typeNameAsString< Vec4i > | ( |  | ) |

inline

## uninitialize()

OPENVDB_IMPORT void uninitialize | ( |  | ) |

Global deregistration of native Grid, Transform, Metadata and Point attribute types.

Clears all registered factory callbacks. This includes everything registered by openvdb::initialize() but will also include any manually registered types.

Note
  This method is thread safe - it can be concurrently called multiple times.

Warning
  This method does not uninitialize blosc. This is to avoid changing program states should another library also be using blosc. If blosc is enabled, consider calling blosc_destroy() in your application.

## writeString()

void writeString | ( | std::ostream & | os,
|  | const Name & | name )

inline

## zeroVal()

template<typename T>

T zeroVal | ( |  | ) |

inline constexpr

Return the value of type T that corresponds to zero.

Note
  A zeroVal<T>() specialization must be defined for each `ValueType` T that cannot be constructed using the form `T(0)`. For example, `std::string(0)` treats 0 as `nullptr` and throws a `std::logic_error`.

## zeroVal< bool >()

template<>

bool zeroVal< bool > | ( |  | ) |

inline constexpr

Return the `bool` value that corresponds to zero.

## zeroVal< math::Mat3d >()

template<>

math::Mat3d zeroVal< math::Mat3d > | ( |  | ) |

inline

## zeroVal< math::Mat3s >()

template<>

math::Mat3s zeroVal< math::Mat3s > | ( |  | ) |

inline

## zeroVal< math::Mat4d >()

template<>

math::Mat4d zeroVal< math::Mat4d > | ( |  | ) |

inline

## zeroVal< math::Mat4s >()

template<>

math::Mat4s zeroVal< math::Mat4s > | ( |  | ) |

inline

## zeroVal< math::Quatd >()

template<>

math::Quatd zeroVal< math::Quatd > | ( |  | ) |

inline

## zeroVal< math::Quats >()

template<>

math::Quats zeroVal< math::Quats > | ( |  | ) |

inline

## zeroVal< std::string >()

template<>

std::string zeroVal< std::string > | ( |  | ) |

inline

Return the `std::string` value that corresponds to zero.

## Variable Documentation

## LEVEL_SET_HALF_WIDTH

const Real LEVEL_SET_HALF_WIDTH = 3

static

## OPENVDB_ABI_VERSION

const uint32_t OPENVDB_ABI_VERSION

ABI version number

## OPENVDB_FILE_VERSION

const uint32_t OPENVDB_FILE_VERSION = 224

The current version number of the VDB file format.

This can be used to enable various backwards compatibility switches or to reject files that cannot be read.

## OPENVDB_LIBRARY_MAJOR_VERSION

const uint32_t OPENVDB_LIBRARY_MAJOR_VERSION

Library major, minor and patch version numbers

## OPENVDB_LIBRARY_MINOR_VERSION

const uint32_t OPENVDB_LIBRARY_MINOR_VERSION = ${OpenVDB_MINOR_VERSION}

## OPENVDB_LIBRARY_PATCH_VERSION

const uint32_t OPENVDB_LIBRARY_PATCH_VERSION = ${OpenVDB_PATCH_VERSION}

## OPENVDB_LIBRARY_VERSION

const uint32_t OPENVDB_LIBRARY_VERSION

Library version number as a packed integer ("%02x%02x%04x", major, minor, patch)

## OPENVDB_MAGIC

const int32_t OPENVDB_MAGIC = 0x56444220

The magic number is stored in the first four bytes of every VDB file.

This can be used to quickly test whether we have a valid file or not.