OpenVDB: openvdb::v5_0 Namespace Reference

OpenVDB 5.0.0

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
openvdb::v5_0 Namespace Reference

## Namespaces
| compression
| io
| logging
| math
| points
| tools
| tree
| 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...
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 > >
class | IllegalValueException
class | IndexError
class | IoError
class | KeyError
class | LookupError
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...
class | ReferenceError
class | RuntimeError
class | ShallowCopy
| Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors. 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...
class | TypedMetadata
| Templated metadata class to hold specific types. More...
class | TypeError
class | UnknownMetadata
| Subclass to hold raw data of an unregistered type. More...
class | ValueError
class | ValueMask
struct | VecTraits
struct | VecTraits< math::Vec2< T > >
struct | VecTraits< math::Vec3< T > >
struct | VecTraits< math::Vec4< T > >
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 | Mat4SMetadata = TypedMetadata< Mat4s >
using | Mat4DMetadata = TypedMetadata< Mat4d >
using | BoolTree = tree::Tree4< bool, 5, 4, 3 >::Type
| Common tree types. More...
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 | StringTree = tree::Tree4< std::string, 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. More...
using | DoubleGrid = Grid< DoubleTree >
using | FloatGrid = Grid< FloatTree >
using | Int32Grid = Grid< Int32Tree >
using | Int64Grid = Grid< Int64Tree >
using | MaskGrid = Grid< MaskTree >
using | StringGrid = Grid< StringTree >
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 | 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< half >
using | Vec3R = math::Vec3< Real >
using | Vec3I = math::Vec3< Index32 >
using | Vec3f = math::Vec3< float >
using | Vec3H = math::Vec3< 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< half >
using | Mat3R = math::Mat3< Real >
using | Mat4R = math::Mat4< Real >
using | Mat4d = math::Mat4< double >
using | Mat4s = math::Mat4< float >
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 >
using | NamePair = std::pair< Name, Name >
typedef std::string | Name

## 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. More...
template<typename GridType >
GridType::Ptr | createGrid ()
| Create a new grid of type `GridType` with background value zero. More...
template<typename TreePtrType >
Grid< typename TreePtrType::element_type >::Ptr | createGrid (TreePtrType)
| Create a new grid of the appropriate type that wraps the given tree. More...
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. More...
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. More...
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. More...
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. More...
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. More...
std::ostream & | operator<< (std::ostream &ostr, const Metadata &metadata)
| Write a Metadata to an output stream. More...
std::ostream & | operator<< (std::ostream &, const MetaMap &)
| Write a MetaMap to an output stream. More...
OPENVDB_IMPORT void | initialize ()
| Global registration of basic types. More...
OPENVDB_IMPORT void | uninitialize ()
| Global deregistration of basic types. More...
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. More...
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`. More...
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`. More...
template<typename T >
const char * | typeNameAsString ()
template<>
const char * | typeNameAsString< bool > ()
template<>
const char * | typeNameAsString< ValueMask > ()
template<>
const char * | typeNameAsString< half > ()
template<>
const char * | typeNameAsString< float > ()
template<>
const char * | typeNameAsString< double > ()
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< std::string > ()
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>". More...
constexpr const char * | getLibraryAbiVersionString ()
| Return a library version number string of the form "<major>.<minor>.<patch>abi<abi>". More...
template<>
math::Mat4s | zeroVal< math::Mat4s > ()
template<>
math::Mat4d | zeroVal< math::Mat4d > ()
template<typename T >
T | zeroVal ()
| Return the value of type T that corresponds to zero. More...
template<>
std::string | zeroVal< std::string > ()
| Return the `std::string` value that corresponds to zero. More...
template<>
bool | zeroVal< bool > ()
| Return the `bool` value that corresponds to zero. More...
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`. More...
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`. More...
std::string | operator+ (const std::string &s, bool)
| Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`. More...
std::string | operator+ (const std::string &s, int)
| Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`. More...
std::string | operator+ (const std::string &s, float)
| Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`. More...
std::string | operator+ (const std::string &s, double)
| Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`. More...

## 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. More...
const uint32_t | OPENVDB_LIBRARY_MAJOR_VERSION = 5
const uint32_t | OPENVDB_LIBRARY_MINOR_VERSION = 0
const uint32_t | OPENVDB_LIBRARY_PATCH_VERSION = 0
const uint32_t | OPENVDB_LIBRARY_VERSION = (( 5 << 24) | (( 0 & 0xFF) << 16) | ( 0 & 0xFFFF))
| Library version number as a packed integer ("%02x%02x%04x", major, minor, patch) More...
const uint32_t | OPENVDB_ABI_VERSION = 5
const uint32_t | OPENVDB_FILE_VERSION = 224
| The current version number of the VDB file format. More...

## Typedef Documentation

## ◆ 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>

## ◆ 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

## ◆ MaskGrid

using MaskGrid = Grid<MaskTree>

## ◆ MaskTree

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

## ◆ Mat3R

using Mat3R = math::Mat3<Real>

## ◆ Mat4d

using Mat4d = math::Mat4<double>

## ◆ Mat4DMetadata

using Mat4DMetadata = TypedMetadata<Mat4d>

## ◆ Mat4R

using Mat4R = math::Mat4<Real>

## ◆ Mat4s

using Mat4s = math::Mat4<float>

## ◆ Mat4SMetadata

using Mat4SMetadata = TypedMetadata<Mat4s>

## ◆ Name

typedef std::string Name

## ◆ NamePair

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

## ◆ PointDataIndex32

using PointDataIndex32 = PointIndex<Index32, 1>

## ◆ PointDataIndex64

using PointDataIndex64 = PointIndex<Index64, 1>

## ◆ PointIndex32

using PointIndex32 = PointIndex<Index32, 0>

## ◆ PointIndex64

using PointIndex64 = PointIndex<Index64, 0>

## ◆ QuatR

using QuatR = math::Quat<Real>

## ◆ Real

using Real = double

## ◆ ScalarGrid

using ScalarGrid = FloatGrid

## ◆ ScalarTree

using ScalarTree = FloatTree

## ◆ SharedPtr

using SharedPtr = std::shared_ptr<T>

## ◆ StringGrid

using StringGrid = Grid<StringTree>

## ◆ StringMetadata

using StringMetadata = TypedMetadata<std::string>

## ◆ StringTree

using StringTree = tree::Tree4<std::string, 5, 4, 3>::Type

## ◆ TopologyGrid

using TopologyGrid = MaskGrid

## ◆ TopologyTree

using TopologyTree = MaskTree

## ◆ TreeBase

using TreeBase = tree::TreeBase

## ◆ UInt32Tree

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

## ◆ 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<half>

## ◆ Vec2I

using Vec2I = math::Vec2<Index32>

## ◆ Vec2IMetadata

using Vec2IMetadata = TypedMetadata<Vec2i>

## ◆ Vec2ITree

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

## ◆ Vec2R

using Vec2R = math::Vec2<Real>

## ◆ Vec2SMetadata

using Vec2SMetadata = TypedMetadata<Vec2s>

## ◆ Vec2STree

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

## ◆ 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

## ◆ Vec3H

using Vec3H = math::Vec3<half>

## ◆ Vec3I

using Vec3I = math::Vec3<Index32>

## ◆ 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>

## ◆ Vec3SGrid

using Vec3SGrid = Grid<Vec3STree>

## ◆ Vec3SMetadata

using Vec3SMetadata = TypedMetadata<Vec3s>

## ◆ Vec3STree

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

## ◆ Vec3U16

using Vec3U16 = math::Vec3<uint16_t>

## ◆ Vec3U8

using Vec3U8 = math::Vec3<uint8_t>

## ◆ Vec4f

using Vec4f = math::Vec4<float>

## ◆ Vec4H

using Vec4H = math::Vec4<half>

## ◆ Vec4I

using Vec4I = math::Vec4<Index32>

## ◆ Vec4R

using Vec4R = math::Vec4<Real>

## ◆ VectorGrid

using VectorGrid = Vec3fGrid

## ◆ VectorTree

using VectorTree = Vec3fTree

## ◆ WeakPtr

using WeakPtr = std::weak_ptr<T>

## Enumeration Type Documentation

## ◆ anonymous enum

anonymous enum

Enumerator
NUM_GRID_CLASSES |

## ◆ anonymous enum

anonymous enum

Enumerator
NUM_VEC_TYPES |

## ◆ 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 |

## ◆ 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()

SharedPtr<T> openvdb::v5_0::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);

## ◆ createGrid() [1/3]

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() [2/3]

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() [3/3]

Grid< typename TreePtrType::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()

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]

GridType::Ptr openvdb::v5_0::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`.

## ◆ deepCopyTypedGrid() [2/2]

GridType::Ptr openvdb::v5_0::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`.

## ◆ DynamicPtrCast()

SharedPtr<T> openvdb::v5_0::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);

## ◆ findGridByName() [1/2]

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

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

## ◆ findGridByName() [2/2]

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

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

## ◆ getLibraryAbiVersionString()

constexpr const char* openvdb::v5_0::getLibraryAbiVersionString | ( |  | ) |
| inline

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

## ◆ getLibraryVersionString()

constexpr const char* openvdb::v5_0::getLibraryVersionString | ( |  | ) |
| inline

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

## ◆ gridConstPtrCast()

GridType::ConstPtr openvdb::v5_0::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()

GridType::Ptr openvdb::v5_0::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 openvdb::v5_0::initialize | ( |  | ) |

Global registration of basic types.

## ◆ operator+() [1/4]

std::string openvdb::v5_0::operator+ | ( | const std::string & | s,
|  | bool |
| ) |  |
| inline

Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`.

## ◆ operator+() [2/4]

std::string openvdb::v5_0::operator+ | ( | const std::string & | s,
|  | int |
| ) |  |
| inline

Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`.

## ◆ operator+() [3/4]

std::string openvdb::v5_0::operator+ | ( | const std::string & | s,
|  | float |
| ) |  |
| inline

Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`.

## ◆ operator+() [4/4]

std::string openvdb::v5_0::operator+ | ( | const std::string & | s,
|  | double |
| ) |  |
| inline

Needed to support the `(zeroVal<ValueType>() + val)` idiom when `ValueType` is `std::string`.

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

std::ostream& openvdb::v5_0::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 openvdb::v5_0::readString | ( | std::istream & | is | ) |
| inline

## ◆ StaticPtrCast()

SharedPtr<T> openvdb::v5_0::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);

## ◆ typeNameAsString()

const char* openvdb::v5_0::typeNameAsString | ( |  | ) |

## ◆ typeNameAsString< bool >()

const char* openvdb::v5_0::typeNameAsString< bool > | ( |  | ) |
| inline

## ◆ typeNameAsString< double >()

const char* openvdb::v5_0::typeNameAsString< double > | ( |  | ) |
| inline

## ◆ typeNameAsString< float >()

const char* openvdb::v5_0::typeNameAsString< float > | ( |  | ) |
| inline

## ◆ typeNameAsString< half >()

const char* openvdb::v5_0::typeNameAsString< half > | ( |  | ) |
| inline

## ◆ typeNameAsString< int16_t >()

const char* openvdb::v5_0::typeNameAsString< int16_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< int32_t >()

const char* openvdb::v5_0::typeNameAsString< int32_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< int64_t >()

const char* openvdb::v5_0::typeNameAsString< int64_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< Mat4d >()

const char* openvdb::v5_0::typeNameAsString< Mat4d > | ( |  | ) |
| inline

## ◆ typeNameAsString< Mat4s >()

const char* openvdb::v5_0::typeNameAsString< Mat4s > | ( |  | ) |
| inline

## ◆ typeNameAsString< math::Quatd >()

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

## ◆ typeNameAsString< math::Quats >()

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

## ◆ typeNameAsString< PointDataIndex32 >()

const char* openvdb::v5_0::typeNameAsString< PointDataIndex32 > | ( |  | ) |
| inline

## ◆ typeNameAsString< PointDataIndex64 >()

const char* openvdb::v5_0::typeNameAsString< PointDataIndex64 > | ( |  | ) |
| inline

## ◆ typeNameAsString< PointIndex32 >()

const char* openvdb::v5_0::typeNameAsString< PointIndex32 > | ( |  | ) |
| inline

## ◆ typeNameAsString< PointIndex64 >()

const char* openvdb::v5_0::typeNameAsString< PointIndex64 > | ( |  | ) |
| inline

## ◆ typeNameAsString< std::string >()

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

## ◆ typeNameAsString< uint16_t >()

const char* openvdb::v5_0::typeNameAsString< uint16_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< uint32_t >()

const char* openvdb::v5_0::typeNameAsString< uint32_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< uint8_t >()

const char* openvdb::v5_0::typeNameAsString< uint8_t > | ( |  | ) |
| inline

## ◆ typeNameAsString< ValueMask >()

const char* openvdb::v5_0::typeNameAsString< ValueMask > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec2d >()

const char* openvdb::v5_0::typeNameAsString< Vec2d > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec2i >()

const char* openvdb::v5_0::typeNameAsString< Vec2i > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec2s >()

const char* openvdb::v5_0::typeNameAsString< Vec2s > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec3d >()

const char* openvdb::v5_0::typeNameAsString< Vec3d > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec3f >()

const char* openvdb::v5_0::typeNameAsString< Vec3f > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec3i >()

const char* openvdb::v5_0::typeNameAsString< Vec3i > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec3U16 >()

const char* openvdb::v5_0::typeNameAsString< Vec3U16 > | ( |  | ) |
| inline

## ◆ typeNameAsString< Vec3U8 >()

const char* openvdb::v5_0::typeNameAsString< Vec3U8 > | ( |  | ) |
| inline

## ◆ uninitialize()

OPENVDB_IMPORT void openvdb::v5_0::uninitialize | ( |  | ) |

Global deregistration of basic types.

## ◆ writeString()

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

## ◆ zeroVal()

T openvdb::v5_0::zeroVal | ( |  | ) |
| inline

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 >()

bool openvdb::v5_0::zeroVal< bool > | ( |  | ) |
| inline

Return the `bool` value that corresponds to zero.

## ◆ zeroVal< math::Mat4d >()

math::Mat4d openvdb::v5_0::zeroVal< math::Mat4d > | ( |  | ) |
| inline

## ◆ zeroVal< math::Mat4s >()

math::Mat4s openvdb::v5_0::zeroVal< math::Mat4s > | ( |  | ) |
| inline

## ◆ zeroVal< math::Quatd >()

math::Quatd openvdb::v5_0::zeroVal< math::Quatd > | ( |  | ) |
| inline

## ◆ zeroVal< math::Quats >()

math::Quats openvdb::v5_0::zeroVal< math::Quats > | ( |  | ) |
| inline

## ◆ zeroVal< std::string >()

std::string openvdb::v5_0::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 = 5

## ◆ 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 = 5

## ◆ OPENVDB_LIBRARY_MINOR_VERSION

const uint32_t OPENVDB_LIBRARY_MINOR_VERSION = 0

## ◆ OPENVDB_LIBRARY_PATCH_VERSION

const uint32_t OPENVDB_LIBRARY_PATCH_VERSION = 0

## ◆ OPENVDB_LIBRARY_VERSION

const uint32_t OPENVDB_LIBRARY_VERSION = (( 5 << 24) | (( 0 & 0xFF) << 16) | ( 0 & 0xFFFF))

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.