Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Ncxx14
Cindex_sequence
Cmake_index_sequence
Cmake_index_sequence< 0, Is... >
NGU_VDBPointToolsInternal
CIndexToOffsetOp
CPackedMaskConstructor
Nhoudini_utils
CParmList	Parameter template list that is always terminated
CParmFactory	Helper class to simplify construction of PRM_Templates and dynamic user interfaces
COpFactory	Helper class to simplify operator registration
COpPolicy	An OpPolicy customizes the behavior of an OpFactory. This base class specifies the required interface
CScopedInputLock	Helper class to manage input locking
Nnanovdb
Nio
CFileHeader	Data encoded at the head of each segment of a file or stream
CFileMetaData
Nutil
Nmorphology
CNearestNeighborBitMask
Cconditional	C++11 implementation of std::conditional
Cconditional< false, TrueT, FalseT >	Template specialization of conditional
Cdisable_if
Cdisable_if< true, T >
Cenable_if	C++11 implementation of std::enable_if
Cenable_if< true, T >
Cis_const
Cis_const< const T >
Cis_floating_point	C++11 implementation of std::is_floating_point
Cis_pointer	Trait used to identify template parameter that are pointers
Cis_pointer< T * >	Template specialization of pointers
Cis_same	C++11 implementation of std::is_same
Cis_same< T, T >
Cis_same< T0, T1 >
Cis_specialization	Metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter
Cis_specialization< TemplateType< Args... >, TemplateType >
Cmatch_const	Trait used to transfer the const-ness of a reference type to another type
Cmatch_const< T, const ReferenceT >	Template specialization used to transfer the const-ness of a reference type to another type
CRange
CRange< 1, T >
CRange< 2, T >
CRange< 3, T >
Cremove_const	Trait use to const from type. Default implementation is just a pass-through
Cremove_const< const T >	Template specialization of trait class use to remove const qualifier type from a type
Cremove_pointer	Trait use to remove pointer, i.e. "*", qualifier from a type. Default implementation is just a pass-through
Cremove_pointer< T * >	Template specialization of trait class use to to remove pointer, i.e. "*", qualifier from a type
Cremove_reference	Trait use to remove reference, i.e. "&", qualifier from a type. Default implementation is just a pass-through
Cremove_reference< T & >	Template specialization of trait class use to remove reference, i.e. "&", qualifier from a type
CSplit
CTimer
CBitArray
CBitArray< 16 >
CBitArray< 32 >
CBitArray< 64 >
CBitArray< 8 >
CBitFlags
CBufferTraits
CBuildToValueMap	Maps one type (e.g. the build types above) to other (actual) types
CBuildToValueMap< Fp16 >
CBuildToValueMap< Fp4 >
CBuildToValueMap< Fp8 >
CBuildToValueMap< FpN >
CBuildToValueMap< Half >
CBuildToValueMap< Point >
CBuildToValueMap< ValueIndex >
CBuildToValueMap< ValueMask >
CBuildToValueMap< ValueOnIndex >
CBuildTraits	Define static boolean tests for template build types
CChannelAccessor	Class to access values in channels at a specific voxel location
CChecksum	Class that encapsulates two CRC32 checksums, one for the Grid, Tree and Root node meta data and one for the remaining grid nodes
CFloatTraits
CFloatTraits< bool, 1 >
CFloatTraits< Point, 1 >
CFloatTraits< T, 8 >
CFloatTraits< ValueIndex, 1 >
CFloatTraits< ValueMask, 1 >
CFloatTraits< ValueOnIndex, 1 >
CFp16	Dummy type for a 16bit quantization of float point values
CFp4	Dummy type for a 4bit quantization of float point values
CFp8	Dummy type for a 8bit quantization of float point values
CFpN	Dummy type for a variable bit quantization of floating point values
CGetDim	Implements Tree::getDim(math::Coord)
CGetLeaf	Return the pointer to the leaf node that contains math::Coord. Implements Tree::probeLeaf(math::Coord)
CGetLower	Return point to the lower internal node where math::Coord maps to one of its values, i.e. terminates
CGetNodeInfo	Implements Tree::getNodeInfo(math::Coord)
CNodeInfo
CGetState	Implements Tree::isActive(math::Coord)
CGetTile	Return point to the root Tile where math::Coord maps to one of its values, i.e. terminates
CGetUpper	Return point to the upper internal node where math::Coord maps to one of its values, i.e. terminates
CGetValue	Below is an example of a struct used for random get methods
CGrid	Highest level of the data structure. Contains a tree and a world->index transform (that currently only supports uniform scaling and translation)
CGridBlindMetaData
CGridData	Struct with all the member data of the Grid (useful during serialization of an openvdb grid)
CGridHandle	This class serves to manage a buffer containing one or more NanoVDB Grids
CGridHandleMetaData
CGridMetaData	This is a convenient class that allows for access to grid meta-data that are independent of the value type of a grid. That is, this class can be used to get information about a grid without actually knowing its ValueType
CGridTree	Defines a tree type from a grid type while preserving constness
CGridTree< const GridT >
CHalf	Dummy type for a 16 bit floating point values (placeholder for IEEE 754 Half)
CHostBuffer	This is a buffer that contains a shared or private pool to either externally or internally managed host memory
CPool
CInternalData	Struct with all the member data of the InternalNode (useful during serialization of an openvdb InternalNode)
CTile
CInternalNode	Internal nodes of a VDB tree
CChildIter	Visits child nodes of this node only
CValueIterator	Visits all tile values in this node, i.e. both inactive and active tiles
CValueOnIterator	Visits active tile values of this node only
CDenseIterator	Visits all tile values and child nodes of this node
CLeafData	Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode)
CLeafData< bool, CoordT, MaskT, LOG2DIM >
CLeafData< Fp16, CoordT, MaskT, LOG2DIM >
CLeafData< Fp4, CoordT, MaskT, LOG2DIM >	Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode)
CLeafData< Fp8, CoordT, MaskT, LOG2DIM >
CLeafData< FpN, CoordT, MaskT, LOG2DIM >
CLeafData< Point, CoordT, MaskT, LOG2DIM >
CLeafData< ValueIndex, CoordT, MaskT, LOG2DIM >
CLeafData< ValueMask, CoordT, MaskT, LOG2DIM >
CLeafData< ValueOnIndex, CoordT, MaskT, LOG2DIM >
CLeafFnBase	Base-class for quantized float leaf nodes
CLeafIndexBase
CLeafNode	Leaf nodes of the VDB tree. (defaults to 8x8x8 = 512 voxels)
CChildNodeType
CValueOnIterator	Visits all active values in a leaf node
CValueOffIterator	Visits all inactive values in a leaf node
CValueIterator	Visits all values in a leaf node, i.e. both active and inactive values
CMap	Defines an affine transform and its inverse represented as a 3x3 matrix and a vec3 translation
CMask	Bit-mask to encode active states and facilitate sequential iterators and a fast codec for I/O compression
CIterator
CDenseIterator
CNanoNode	Trait to map from LEVEL to node type
CNanoNode< BuildT, 0 >
CNanoNode< BuildT, 1 >
CNanoNode< BuildT, 2 >
CNanoNode< BuildT, 3 >
CNodeManager	NodeManager allows for sequential access to nodes
CNodeManagerData
C[union].__unnamed0__
C[union].__unnamed1__
CNodeManagerHandle	NodeManagerHandle manages the memory of a NodeManager
CNodeTrait	Struct to derive node type from its level in a given grid, tree or root while preserving constness
CNodeTrait< const GridOrTreeOrRootT, 0 >
CNodeTrait< const GridOrTreeOrRootT, 1 >
CNodeTrait< const GridOrTreeOrRootT, 2 >
CNodeTrait< const GridOrTreeOrRootT, 3 >
CNodeTrait< GridOrTreeOrRootT, 0 >
CNodeTrait< GridOrTreeOrRootT, 1 >
CNodeTrait< GridOrTreeOrRootT, 2 >
CNodeTrait< GridOrTreeOrRootT, 3 >
CPoint	Dummy type for indexing points into voxels
CPointAccessor	Class to access points at a specific voxel location
CPointAccessor< AttT, Point >
CProbeValue	Implements Tree::probeLeaf(math::Coord)
CReadAccessor
CReadAccessor< BuildT, -1, -1, -1 >	A read-only value accessor with three levels of node caching. This allows for inverse tree traversal during lookup, which is on average significantly faster than calling the equivalent method on the tree (i.e. top-down traversal)
CReadAccessor< BuildT, 0, 1, 2 >	Node caching at all (three) tree levels
CReadAccessor< BuildT, LEVEL0, -1, -1 >	Node caching at a single tree level
CReadAccessor< BuildT, LEVEL0, LEVEL1, -1 >
CRootData	Struct with all the member data of the RootNode (useful during serialization of an openvdb RootNode)
CTile
CTileIter
CRootNode	Top-most node of the VDB tree structure
CBaseIter
CChildIter
CValueIter
CValueOnIter
CDenseIter
CSetValue
CSetVoxel
CTensorTraits
CTensorTraits< T, 0 >
CTensorTraits< T, 1 >
CTree	VDB Tree, which is a thin wrapper around a RootNode
CTreeData
CValueIndex	Dummy type for a voxel whose value equals an offset into an external value array
CValueMask	Dummy type for a voxel whose value equals its binary active state
CValueOnIndex	Dummy type for a voxel whose value equals an offset into an external value array of active values
CVersion	Bit-compacted representation of all three version numbers
Nopenvdb
Nv13_0
Nax
Nast
CArrayPack	ArrayPacks represent temporary container creations of arbitrary sizes, typically generated through the use of curly braces {}
CArrayUnpack	ArrayUnpack represent indexing operations into AX container types, primarily vectors and matrices indexed by the square brackets [] syntax. Multiple levels of indirection (multiple components) can be specified but current construction is limited to either a single or double component lookup. Providing two components infers a matrix indexing operation
CAssignExpression	AssignExpressions represents a similar object construction to a BinaryOperator. AssignExpressions can be chained together and are thus derived as Expressions rather than Statements
CAttribute	Attributes represent any access to a primitive value, typically associated with the '@' symbol syntax. Note that the AST does not store any additional information on the given attribute other than its name and type, which together form a unique Attribute identifier known as the Attribute 'token'. A 'primitive value' in this instance refers to a value on an OpenVDB Volume or OpenVDB Points tree
CBinaryOperator	A BinaryOperator represents a single binary operation between a left hand side (LHS) and right hand side (RHS) expression. The operation type is stored as a tokens::OperatorToken enumerated type on the node. AX grammar guarantees that this token will only ever be a valid binary operator token type when initialized by the parser
CBlock	A Block node represents a scoped list of statements. It may comprise of 0 or more statements, and specifically indicates that a new scope is activated, typically represented by curly braces. Note that a block does not alway have to be encapsulated by curly braces, but always represents a new scope
CCast	Cast nodes represent the conversion of an underlying expression to a target type. Cast nodes are typically constructed from functional notation and do not represent construction of the target type, rather a type-casted conversion
CCommaOperator
CConditionalStatement	ConditionalStatements represents all combinations of 'if', 'else' and 'else if' syntax and semantics. A single ConditionalStatement only ever represents up to two branches; an 'if' (true) and an optional 'else' (false). ConditionalStatements are nested within the second 'else' branch to support 'else if' logic. As well as both 'if' and 'else' branches, a ConditionalStatement also holds an Expression related to its primary condition
CCrement	A Crement node represents a single increment '++' and decrement '–' operation. As well as it's crement type, it also stores whether the semantics constructed a post or pre-crement i.e. ++a or a++
CDeclareLocal	DeclareLocal AST nodes symbolize a single type declaration of a local variable. These store the local variables that They also however store its specified type. These have the important distinction of representing the initial creation and allocation of a variable, in comparison to a Local node which only represents access
CExpression	Expressions are comprised of full or potentially partial parts of a full statement that may not necessary make up an entire valid statement on their own. For example, while a Binary Operator such as "3 + 5;"" is a valid statement on its own, the full statement "3 + 5 + 6;" must be broken down into two expressions which together form the statement as well as determining precedence
CExternalVariable	ExternalVariable represent any access to external (custom) data, typically associated with the '$' symbol syntax. Note that the AST does not store any additional information on the given external other than its name and type, which together form a unique external identifier known as the ExternalVariable 'token'. This token is used by the compiler to map user provided values to these external values
CFunctionCall	FunctionCalls represent a single call to a function and any provided arguments. The argument list can be empty. The function name is expected to exist in the AX function registry
CKeyword	Keywords represent keyword statements defining changes in execution. These include those that define changes in loop execution such as break and continue, as well as return statements
CLocal	Local AST nodes represent a single accesses to a local variable. The only store the name of the variable being accessed
CLoop	Loops represent for, while and do-while loop constructs. These all consist of a condition - evaluated to determine if loop iteration should continue, and a body which is the logic to be repeated. For loops also have initial statements which are evaluated prior to loop execution (at loop scope) and commonly used to set up iterators, and iteration expressions which are evaluated between iterations after the body and before the condition. Both conditions and initial statements can be declarations or expressions, so are Statements, and iteration expressions can consist of multiple expressions. The loop body is a Block defining its own scope (encapsulated by initial statement scope for for-loops)
CNode	The base abstract node which determines the interface and required methods for all derived concrete nodes which comprise a valid AST
CStatement	Abstract (pure-virtual) AST nodes
CStatementList	Concrete AST nodes
CTernaryOperator	A TernaryOperator represents a ternary (conditional) expression 'a ? b : c' which evaluates to 'b' if 'a' is true and 'c' if 'a' is false. Requires 'b' and 'c' to be convertibly typed expressions, or both void. The 'true' expression ('b') is optional with the conditional expression 'a' returned if it evaluates to true, otherwise returning 'c'. Note that 'a' will only be evaluated once in this case
CTree	A Tree is the highest concrete (non-abstract) node in the entire AX AST hierarchy. It represents an entire conversion of a valid AX string
CUnaryOperator	A UnaryOperator represents a single unary operation on an expression. The operation type is stored as a tokens::OperatorToken enumerated type on the node. AX grammar guarantees that this token will only every be a valid unary operator token type when initialized by the parser
CValue	A Value (literal) AST node holds either literal text or absolute value information on all numerical, string and boolean constants. A single instance of a Value is templated on the requested scalar, boolean or string type. If scalar or boolean value is constructed from a string (as typically is the case in the parser), the value is automatically converted to its numerical representation. If this fails, the original text is stored instead
CValue< std::string >	Specialization of Values for strings
CValueBase	ValueBases are a base class for anything that holds a value (literal). Derived classes store the actual typed values
CVariable	Variables are a base type for Locals, Attributes and ExternalVariables. Unlike other abstract types, they also consolidate data for the derived types
CVisitNodeType
CVisitor	The Visitor class uses the Curiously Recursive Template Pattern (CRTP) to provide a customizable interface intended to be used by clients wishing to perform custom operations over an AX Abstract Syntax Tree (AST). By default the Visitor implements simple traversal of all nodes, ensuring that each node on a well formed AST is visited at least once. By deriving from the Visitor, users are able to customize this default behavior and further manually override specific node behavior to their needs. The function options at the top of visitor can be overridden using CRTP to control the prior default behavior, with the ability to override the traverse() and visit() methods for the latter more granular control
Ncodegen
Ncodegen_internal
CComputeGenerator	Visitor object which will generate llvm IR for a syntax tree. This provides the majority of the code generation functionality except for attribute access. This design allows for custom geometry to define their IR implementations for these accesses by deriving and extending this generator with ast::Attribute handling (see PointComputeGenerator.h and VolumeComputeGenerator.h for examples)
CPointComputeGenerator	Visitor object which will generate llvm IR for a syntax tree which has been generated from AX that targets point grids. The IR will represent 2 functions : one that executes over single points and one that executes over a collection of points. This is primarily used by the Compiler class
CPointLeafLocalData	Various functions can request the use and initialization of point data from within the kernel that does not use the standard attribute handle methods. This data can then be accessed after execution to perform post-processes such as adding new groups, adding new string attributes or updating positions
CVolumeComputeGenerator	Visitor object which will generate llvm IR for a syntax tree which has been generated from AX that targets volumes. The IR will represent a single function. It is mainly used by the Compiler class
CAliasTypeMap	Alias mapping between two types, a frontend type T1 and a backend type T2. This class is the intended interface for binding objects which implement supported backend AX/IR types to this given backend type. More specifically, it's current and expected usage is limited to objects which hold a single member of a supported backend type and implements a StandardLayoutType as defined by the standard. Fundamentally, T1->T2 mapping should be supported by reinterpret_cast<> as defined by the type aliasing rules
CArgInfo	Metadata associated with a function argument or return value
CArgInfoVector	Container of ArgInfos. This class makes up part of the Function API for querying signature information
CArgType	Object to array conversion methods to allow functions to return vector types. These containers provided an interface for automatic conversion of C++ objects to LLVM types as array types
CArgumentIterator	Templated argument iterator which implements various small functions per argument type, resolved at compile time
CArgumentIterator< SignatureT, 0 >
CArguments	Arbitrary, potentially "non-native" arguments. This wrapper struct can be used when generating function which cannot be called from AX itself (e.g. VDB accessor functions or Volume/Point kernels etc). They do not support implicit function signature matching or casting
CCFunction	Represents a concrete C function binding
CCFunctionBase	The base class for all C bindings
CCFunctionSRet	Represents a concrete C function binding with the first argument as its return type
CCodec
CComputeKernel	The function definition and signature which is built by the ComputeGenerator
CConstantFolder	Constant folding support structure
CConstantFolder< SignatureT, 0 >
CCountNPtrs
CCountNPtrs< T * >
CCountNPtrs< T *const >
CCountNPtrs< T *const volatile >
CCountNPtrs< T *volatile >
CFunction	The base/abstract representation of an AX function. Derived classes must implement the Function::types call to describe their signature
CFunctionBuilder	Builder pattern framework to allow easy and valid construction of AX functions. There are a number of complex tasks which may need to be performed during construction of C or IR function which are delegated to this builder, whilst ensuring that the constructed functions are guaranteed to be valid
CSettings
CFunctionGroup	A group of functions which all have the same name but different signatures. For example: float abs(float) double abs(double) As well as serving as a way of grouping common functions, this class provides an API for selecting the best possible function signature, should a match exist, against a provided set of argument types
CFunctionRegistry	The function registry which is used for function code generation. Each time a function is visited within the AST, its identifier is used as a key into this registry for the corresponding function retrieval and execution. Functions can be inserted into the registry using insert() with a given identifier and pointer
CRegisteredFunction	An object to represent a registered function, storing its constructor, a pointer to the function definition and whether it should only be available internally (i.e. to a developer, not a user)
CFunctionTraits	Templated function traits which provides compile-time index access to the types of the function signature
CFunctionTraits< R(&)(Args...)>
CFunctionTraits< R(*)(Args...)>
CFunctionTraits< ReturnT(Args...)>
CArg
Cint_t
Cint_t< 16 >
Cint_t< 32 >
Cint_t< 64 >
Cint_t< 8 >
CIRFunction	Represents a concrete IR function
CIRFunctionBase	The base/abstract definition for an IR function
CIRFunctionSRet	Represents a concrete IR function with the first argument as its return type
CLLVMType	LLVM type mapping from pod types
CLLVMType< ArgType< T, S > >
CLLVMType< char >
CLLVMType< codegen::String >
CLLVMType< const T * >
CLLVMType< const T >
CLLVMType< openvdb::math::half >
CLLVMType< openvdb::math::Mat3< T > >
CLLVMType< openvdb::math::Mat4< T > >
CLLVMType< openvdb::math::Vec2< T > >	Supported aliasing for VDB math types, allowing use in external function signatures
CLLVMType< openvdb::math::Vec3< T > >
CLLVMType< openvdb::math::Vec4< T > >
CLLVMType< T * >
CLLVMType< T[S]>
CLLVMType< void * >
CLLVMType< void >
CNativeArguments	Wrapper struct to represent "native" function arguments; that is, the set of Value type that the AX grammar supports. NativeArguments have two benefits; they support casting and implicit function matching through FunctionGroups and can be used directly in IR generators (to leverage the AX Value API). Functions can still be generated and called with "non-native" arguments, but in these cases FunctionGroup::execute must result in an explicit signature match
CPointKernelAttributeArray
CPointKernelBuffer
CPointKernelBufferRange
CPointKernelValue
CRemoveAllPtrTypes
CRemoveAllPtrTypes< T * >
CRemoveAllPtrTypes< T *const >
CRemoveAllPtrTypes< T *const volatile >
CRemoveAllPtrTypes< T *volatile >
CSRetFunction	Templated interface class for SRET functions. This struct provides the interface for functions that wish to return arrays (vectors or matrices) by internally remapping the first argument for the user. As far as LLVM and any bindings are concerned, the function signature remains unchanged - however the first argument becomes "invisible" to the user and is instead allocated by LLVM before the function is executed. Importantly, the argument has no impact on the user facing AX signature and doesn't affect declaration selection
CString	An extremely basic but native representation of a string class with SSO support. This exists to provide an interface between the AX C++ API and backend IR string logic. It is not designed to fulfill any other use and should very rarely be used directly
CSymbolTable	A symbol table which can be used to represent a single scoped set of a programs variables. This is simply an unordered map of strings to llvm::Values
CSymbolTableBlocks	A map of unique ids to symbol tables which can be used to represent local variables within a program. New scopes can be added and erased where necessary and iterated through using find(). Find assumes that tables are added through parented ascending ids
CTypeToSymbol	Type to symbol conversions - these characters are used to build each functions unique signature. They differ from standard AX or LLVM syntax to be as short as possible i.e. vec4d, [4 x double] = d4
CTypeToSymbol< ArgType< T, S > >
CTypeToSymbol< char >
CTypeToSymbol< codegen::String >
CTypeToSymbol< const T * >
CTypeToSymbol< const T >
CTypeToSymbol< double >
CTypeToSymbol< float >
CTypeToSymbol< int16_t >
CTypeToSymbol< int32_t >
CTypeToSymbol< int64_t >
CTypeToSymbol< int8_t >
CTypeToSymbol< math::Mat3< T > >
CTypeToSymbol< math::Mat4< T > >
CTypeToSymbol< math::Vec2< T > >
CTypeToSymbol< math::Vec3< T > >
CTypeToSymbol< math::Vec4< T > >
CTypeToSymbol< T * >
CTypeToSymbol< T[S]>
CTypeToSymbol< uint16_t >
CTypeToSymbol< uint32_t >
CTypeToSymbol< uint64_t >
CTypeToSymbol< uint8_t >
CTypeToSymbol< void >
CValue	Intermediate representation wrapper for supported value types in AX as immutable instances
CVolumeKernelBuffer	The second volume kernel, responsible for providing the core layer of SIMD optimisations by invoking this kernel across a range of values
CVolumeKernelNode	The third volume kernel, providing an agnostic way to modify a single tile value without passing through the buffer states. Note that this kernel is mainly utility and one of the value kernels should almost always be preferred
CVolumeKernelValue	The primary volume kernel. This function holds the generated body of AX programs
CAttributeBindings	This class wraps an interface for a map of attribute bindings. These map attributes in AX code to context data. These mappings are one-to-one i.e. each AX name can only map to one data name, however each name can appear as either an AX name or data name or both, i.e. the following sets of bindings are valid: axname: a -> dataname: a axname: b -> dataname: c or axname: a -> dataname: b axname: b -> dataname: a
CAttributeRegistry	This class stores a list of access names, types and their dependency connections
CAccessData	Registered access details, including its name, type and whether a write handle is required
CCompiler	The compiler class. This holds a set of compiler options and constructs executable objects (e.g. PointExecutable or VolumeExecutable) from a syntax tree or snippet of code
CCompilerOptions	Settings which control how a Compiler class object behaves
CCustomData	The custom data class is a simple container for named openvdb metadata. Its primary use case is passing arbitrary "external" data to an AX executable object when calling Compiler::compile. For example, it is the mechanism by which we pass data held inside of a parent DCC to executable AX code
CFunctionOptions	Options that control how functions behave
CLogger	Logger for collecting errors and warnings that occur during AX compilation
CPointExecutable	Object that encapsulates compiled AX code which can be executed on a collection of VDB Point Data grids. Executables are created by the compiler and hold the final immutable JIT compiled function and context
CSettings
CCLI	Command Line Interface handling for the PointExecutable
CVolumeExecutable	Object that encapsulates compiled AX code which can be executed on a collection of VDB volume grids. Executables are created by the compiler and hold the final immutable JIT compiled function and context
CSettings
CCLI	Command Line Interface handling for the VolumeExecutable
Ncompression
CPage	Stores a variable-size, compressed, delayed-load Page of data that is loaded into memory when accessed. Access to the Page is thread-safe as loading and decompressing the data is protected by a mutex
CPageHandle	A PageHandle holds a unique ptr to a Page and a specific stream pointer to a point within the decompressed Page buffer
CPagedInputStream	A Paging wrapper to std::istream that is responsible for reading from a given input stream and creating Page objects and PageHandles that reference those pages for delayed reading
CPagedOutputStream	A Paging wrapper to std::ostream that is responsible for writing from a given output stream at intervals set by the PageSize. As Pages are variable in size, they are flushed to disk as soon as sufficiently large
Nio
CArchive	Grid serializer/unserializer
CDelayedLoadMetadata	Store a buffer of data that can be optionally used during reading for faster delayed-load I/O performance
CFile	Grid archive associated with a file on disk
CNameIterator
CGridDescriptor
CHalfReader
CHalfReader< false, T >	Partial specialization for non-floating-point types (no half to float promotion)
CHalfReader< true, T >	Partial specialization for floating-point types
CHalfWriter
CHalfWriter< false, T >	Partial specialization for non-floating-point types (no float to half quantization)
CHalfWriter< true, T >	Partial specialization for floating-point types
CMaskCompress
CMultiPass	Leaf nodes that require multi-pass I/O must inherit from this struct
CQueue	Queue for asynchronous output of grids to files or streams
CRealToHalf	RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types
CRealToHalf< double >
CRealToHalf< float >
CRealToHalf< Vec2d >
CRealToHalf< Vec2s >
CRealToHalf< Vec3d >
CRealToHalf< Vec3s >
CStream	Grid archive associated with arbitrary input and output streams (not necessarily files)
CStreamMetadata	Container for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use)
Nlogging
CLevelScope	A LevelScope object sets the logging level to a given level and restores it to the current level when the object goes out of scope
Nmath
Ninternal
Cimath_half_uif	Type for both C-only programs and C++ to use the same utilities
Chalf
Npcg
Ninternal
CCopyOp
CFillOp
CLinearOp
CVector	Lightweight, variable-length vector
CDeterministicDotProductOp
CInfNormOp
CIsFiniteOp
CSparseStencilMatrix	Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE
CConstValueIter	Iterator over the stored values in a row of this matrix
CConstRow	Read-only accessor to a row of this matrix
CRowEditor	Read/write accessor to a row of this matrix
CMatrixCopyOp
CIsFiniteOp
CPreconditioner	Base class for conjugate gradient preconditioners
CJacobiPreconditioner	Diagonal preconditioner
CIncompleteCholeskyPreconditioner	Preconditioner using incomplete Cholesky factorization
CState	Information about the state of a conjugate gradient solution
CAffineMap	A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation
CBaseStencil
CBBox	Axis-aligned bounding box
CBIAS_SCHEME
CISStencil
CBIAS_SCHEME< FIRST_BIAS >
CISStencil
CBIAS_SCHEME< HJWENO5_BIAS >
CISStencil
CBIAS_SCHEME< SECOND_BIAS >
CISStencil
CBIAS_SCHEME< THIRD_BIAS >
CISStencil
CBIAS_SCHEME< WENO5_BIAS >
CISStencil
CBoxStencil
CCompoundMap	Creates the composition of two maps, each of which could be a composition. In the case that each component of the composition classified as linear an acceleration AffineMap is stored
CConversion	Dummy class for tag dispatch of conversion constructors
CCoord	Signed (x, y, z) 32-bit integer coordinates
CCoordBBox	Axis-aligned bounding box of signed integer coordinates
CIterator	Iterator over the Coord domain covered by a CoordBBox
CCPT	Compute the closest-point transform to a level set
CCPT_RANGE	Compute the closest-point transform to a level set
CCurl	Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map
CCurl< UniformScaleMap, CD_2ND >	Full template specialization of Curl
CCurl< UniformScaleMap, DiffScheme >	Partial template specialization of Curl
CCurl< UniformScaleTranslateMap, CD_2ND >	Full template specialization of Curl
CCurl< UniformScaleTranslateMap, DiffScheme >	Partial template specialization of Curl
CCurvatureStencil
CD1
CD1< BD_1ST >
CD1< BD_2ND >
CD1< BD_3RD >
CD1< BD_HJWENO5 >
CD1< BD_WENO5 >
CD1< CD_2ND >
CD1< CD_2NDT >
CD1< CD_4TH >
CD1< CD_6TH >
CD1< FD_1ST >
CD1< FD_2ND >
CD1< FD_3RD >
CD1< FD_HJWENO5 >
CD1< FD_WENO5 >
CD1Vec
CD1Vec< CD_2ND >
CD1Vec< CD_2NDT >
CD1Vec< CD_4TH >
CD1Vec< CD_6TH >
CD2
CD2< CD_FOURTH >
CD2< CD_SECOND >
CD2< CD_SIXTH >
CDDA	A Digital Differential Analyzer specialized for OpenVDB grids
CDelta	Delta for small floating-point offsets
CDelta< double >
CDelta< float >
CDelta< math::half >
CDenseStencil	Dense stencil of a given width
CDivergence	Compute the divergence of a vector-valued grid using differencing of various orders, the result defined with respect to the range-space of the map
CDivergence< ScaleMap, CD_2ND >
CDivergence< ScaleMap, DiffScheme >
CDivergence< ScaleTranslateMap, CD_2ND >
CDivergence< ScaleTranslateMap, DiffScheme >
CDivergence< TranslationMap, DiffScheme >
CDivergence< UniformScaleMap, CD_2ND >
CDivergence< UniformScaleMap, DiffScheme >
CDivergence< UniformScaleTranslateMap, CD_2ND >
CDivergence< UniformScaleTranslateMap, DiffScheme >
CExtrema	This class computes the minimum and maximum values of a population of floating-point values
CFourthOrderDenseStencil
CGenericMap	A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators
CGradient	Center difference gradient operators, defined with respect to the range-space of the map
CGradient< ScaleMap, CD_2ND >
CGradient< ScaleTranslateMap, CD_2ND >
CGradient< TranslationMap, DiffScheme >
CGradient< UniformScaleMap, CD_2ND >
CGradient< UniformScaleTranslateMap, CD_2ND >
CGradientBiased	Biased gradient operators, defined with respect to the range-space of the map
CGradientNormSqrd
CGradientNormSqrd< UniformScaleMap, GradScheme >	Partial template specialization of GradientNormSqrd
CGradientNormSqrd< UniformScaleTranslateMap, GradScheme >	Partial template specialization of GradientNormSqrd
CGradStencil
CHistogram	This class computes a histogram, with a fixed interval width, of a population of floating-point values
Cis_diagonal_jacobian
Cis_double
Cis_double< double >
Cis_linear	Map traits
Cis_linear< AffineMap >
Cis_linear< CompoundMap< T1, T2 > >
Cis_linear< ScaleMap >
Cis_linear< ScaleTranslateMap >
Cis_linear< TranslationMap >
Cis_linear< UniformScaleMap >
Cis_linear< UniformScaleTranslateMap >
Cis_linear< UnitaryMap >
Cis_scale
Cis_scale< ScaleMap >
Cis_scale_translate
Cis_scale_translate< ScaleTranslateMap >
Cis_uniform_diagonal_jacobian
Cis_uniform_scale
Cis_uniform_scale< UniformScaleMap >
Cis_uniform_scale_translate
Cis_uniform_scale_translate< TranslationMap >
Cis_uniform_scale_translate< UniformScaleTranslateMap >
Cis_vec3d
Cis_vec3d< Vec3d >
CISCurl	Curl operator defined in index space using various first derivative schemes
CISDivergence	Divergence operator defined in index space using various first derivative schemes
CISGradient	Gradient operators defined in index space of various orders
CISGradientBiased	Biased Gradient Operators, using upwinding defined by the Vec3Bias input
CISGradientNormSqrd
CISLaplacian	Laplacian defined in index space, using various center-difference stencils
CISLaplacian< CD_FOURTH >
CISLaplacian< CD_SECOND >
CISLaplacian< CD_SIXTH >
CISMeanCurvature	Compute the mean curvature in index space
CISOpMagnitude	Adapter for vector-valued index-space operators to return the vector magnitude
CLaplacian	Compute the Laplacian at a given location in a grid using finite differencing of various orders. The result is defined in the range of the map
CLaplacian< ScaleMap, DiffScheme >
CLaplacian< ScaleTranslateMap, DiffScheme >
CLaplacian< TranslationMap, DiffScheme >
CLaplacian< UniformScaleMap, DiffScheme >
CLaplacian< UniformScaleTranslateMap, DiffScheme >
CLaplacian< UnitaryMap, DiffScheme >
CLevelSetHDDA	Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets
CLevelSetHDDA< TreeT, -1 >	Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set
CMapAdapter	Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator
CMapBase	Abstract base class for maps
CMapRegistry	Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function
CMat
CMat2
CMat3	3x3 matrix class
CMat4	4x4 -matrix class
CMeanCurvature	Compute the mean curvature
CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 >
CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 >
CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 >
CMinMax	Templated class to compute the minimum and maximum values
CNineteenPointStencil
CNonlinearFrustumMap	This map is composed of three steps. First it will take a box of size (Lx X Ly X Lz) defined by a member data bounding box and map it into a frustum with near plane (1 X Ly/Lx) and prescribed depth Then this frustum is transformed by an internal second map: most often a uniform scale, but other effects can be achieved by accumulating translation, shear and rotation: these are all applied to the second map
COpMagnitude	Adapter for vector-valued world-space operators to return the vector magnitude
Cpromote
CQuantizedUnitVec	Unit vector occupying only 16 bits
CQuat
CUnsafeConstruct
CRand01	Simple generator of random numbers over the range [0, 1)
CRandInt	Simple random integer generator
CRay
CTimeSpan
CScaleMap	A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions
CScaleTranslateMap	A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions, and then translates the result
CSecondOrderDenseStencil
CSevenPointStencil
CSixthOrderDenseStencil
CStats	This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values
CThirteenPointStencil
CTolerance	Tolerance for floating-point comparison
CTolerance< double >
CTolerance< float >
CTolerance< math::half >
CTransform
CTranslationMap	A specialized linear transform that performs a translation
CTuple
CUniformScaleMap	A specialized Affine transform that scales along the principal axis the scaling is uniform in the three-directions
CUniformScaleTranslateMap	A specialized Affine transform that uniformaly scales along the principal axis and then translates the result
CUnitaryMap	A specialized linear transform that performs a unitary maping i.e. rotation and or reflection
CVec2
CVec3
CVec4
CVolumeHDDA	Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume
CVolumeHDDA< TreeT, RayT, 0 >	Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume
CWenoStencil	This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test
Npoints
Nattribute_traits
CStringTypeTrait
CStringTypeTrait< true >
CTruncateTrait
CTruncateTrait< float >
CTruncateTrait< int >
CTruncateTrait< math::Vec3< T > >
CUIntTypeTrait
CUIntTypeTrait< false, math::Vec3< T > >
CUIntTypeTrait< false, T >
CUIntTypeTrait< true, math::Vec3< T > >
CUIntTypeTrait< true, T >
Nfuture	A container for ABI=5 to help ease introduction of upcoming features
CAdvect
CContainer
Ninternal
CPointDataNodeChain	Recursive node chain which generates a openvdb::TypeList value converted types of nodes to PointDataGrid nodes of the same configuration, rooted at RootNodeType in reverse order, from LeafNode to RootNode. See also TreeConverter<>
CPointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, 1 >
CPointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, HeadLevel >
CValueTypeTraits
CValueTypeTraits< T, void_t< typename T::value_type > >
Npca_internal
CNoTimer
CPcaTimer
CAttrIndices
CPcaTransfer
CWeightPosSumsTransfer
CCovarianceTransfer
Npoint_attribute_internal
CDefault
Npoint_move_internal
CBuildMoveMapsOp
CGlobalMovePointsOp
CCopyIterator
CLocalMovePointsOp
CCopyIterator
Npoint_rasterize_internal
CGridToRasterize
Nrasterize_sdf_internal
CEllipseIndicies
CEllipsoidTransfer
CEllipsoidTransferQuat	Specializations of the EllipsoidTransfer for different Xform attribute types
CEllipsoidTransferMat3	Specialization for mat3 types (see above comment)
CEllipseSurfaceMaskOp
Ntransfer_internal
CRasterizePoints
CAccessorEval	Accessor to call unsafe get and set methods based on templated Codec and Value
CAccessorEval< UnknownCodec, ValueType >	Partial specialization when Codec is not known at compile-time to use the supplied functor instead
CAttributeArray	Base class for storing attribute data
CAccessor
CScopedRegistryLock
CAccessorBase	Accessor base class for AttributeArray storage where type is not available
CAttributeHandle
CAttributeHashFilter
CAttributeSet	Ordered collection of uniquely-named attribute arrays
CUtil
CNameAndType	Attribute and type name pair
CDescriptor	An immutable object that stores name, type and AttributeSet position for a constant collection of attribute arrays
CInserter	Utility method to construct a NameAndType sequence
CAttributeWriteHandle	Write-able version of AttributeHandle
CBBoxFilter
CBinaryFilter
CCachedDeformer	A Deformer that caches the resulting positions from evaluating another Deformer
CCache
CLeaf
CDeformerTraits	Deformer Traits for optionally configuring deformers to be applied in index-space. The default is world-space
CDummySampleType
CEllipsoidSettings	Anisotropic point rasterization based on the principal component analysis of point neighbours. See the struct member documentation for detailed behavior
CFilteredTransfer	FilteredTransfer module, when derived from allows for schemes to apply point filtering. Note that this module handles the thread safe intialization and storage of the filter, but derived schemes must call FilteredTransfer::filter() per point id and handle the result
CFilteredTransfer< NullFilter >	Specialization of FilteredTransfer for NullFilters which do nothing
CFilterTraits
CFilterTraits< BBoxFilter >
CFilterTraits< BinaryFilter< T0, T1, And > >
CFilterTraits< LevelSetFilter< T > >
CFixedPointCodec
CStorage
CFrustumRasterizer	Efficient rasterization of one or more VDB Points grids into a linear or frustum volume with the option to bake in camera or geometry motion blur
CFrustumRasterizerMask
CFrustumRasterizerSettings	A group of shared settings to be used in the Volume Rasterizer
CGroupCodec
CStorage
CGroupFilter	Index filtering on group membership
CGroupHandle
CBitMask
CGroupWriteHandle
CIndexIter	A forward iterator over array indices with filtering IteratorT can be either IndexIter or ValueIndexIter (or some custom index iterator) FilterT should be a struct or class with a valid() method than can be evaluated per index Here's a simple filter example that only accepts even indices:
CValueIndexIter	A forward iterator over array indices from a value iterator (such as ValueOnCIter)
CInterruptableTransfer	InterruptableTransfer module, when derived from allows for schemes to callback into a interrupter, derived from util::NullInterrupter
CLevelSetFilter
CMultiGroupFilter
CNullCodec
CStorage
CNullDeformer	No-op deformer (adheres to the deformer interface documented in PointMove.h)
CNullFilter	A no-op filter that can be used when iterating over all indices
CPcaAttributes	The persistent attributes created by the PCA methods
CPcaSettings	Various settings for the neighborhood analysis of point distributions
CPointAttributeVector	Point-partitioner compatible STL vector attribute wrapper for convenience
CPointDataLeafNode
CPositionRange
CRandomLeafFilter
CRasterCamera	A camera class that provides an interface for camera motion blur when rasterizing
CRasterGroups	A struct that stores all include/exclude attribute names as strings and is internally converted into the resolved MultiGroupFilter
CSampleWithRounding
CSmoothSphereSettings	Smoothed point distribution based sphere stamping with a uniform radius or varying radius and optionally with closest point attribute transfer of arbitrary attributes. See the struct member documentation for detailed behavior
CSphereSettings	Generic settings for narrow band spherical stamping with a uniform or varying radius and optionally with closest point attribute transfer of arbitrary attributes. See the struct member documentation for detailed behavior
CStringAttributeHandle
CStringAttributeWriteHandle
CStringCodec
CStorage
CStringMetaCache	Class to compute a string->index map from all string:N metadata
CStringMetaInserter	Class to help with insertion of keyed string values into metadata
CTransformTransfer	The TransformTransfer module should be used if the source transform of the input points and the target transforms of the destination volumes differ. The default rasterizer will skip index to world (and vice versa) transformations unless a transfer scheme derives from a TransformTransfer
CTreeConverter	Similiar to ValueConverter, but allows for tree configuration conversion to a PointDataTree. ValueConverter<PointDataIndex32> cannot be used as a PointDataLeafNode is not a specialization of LeafNode
CTrilinearTraits
CTrilinearTraits< ValueT, false >
CTruncateCodec
CStorage
CTypedAttributeArray	Typed class for storing attribute data
CUnitRange
CUnitVecCodec
CStorage
CUnknownCodec
CValueMaskFilter	Index filtering on active / inactive state of host voxel
CValueVoxelCIter	A forward iterator over array indices in a single voxel
CParent
CVolumeTransfer	The VolumeTransfer module provides methods to automatically setup and access destination buffers for multiple target volumes of arbitrary types. Deriving from a VolumeTransfer ensures that the available buffers correlate to the order of the provided tree arguments
CTypeResolver
CVolumeTransfer< TreeT >	VolumeTransfer specialization for a single target volume
Ntools
Nds
COpOver	Point wise methods used to apply various compositing operations
COpAdd
COpSub
COpMin
COpMax
COpMult
CCompositeFunctorTranslator	Translator that converts an enum to compositing functor types
CCompositeFunctorTranslator< DS_OVER, ValueT >
CCompositeFunctorTranslator< DS_ADD, ValueT >
CCompositeFunctorTranslator< DS_SUB, ValueT >
CCompositeFunctorTranslator< DS_MIN, ValueT >
CCompositeFunctorTranslator< DS_MAX, ValueT >
CCompositeFunctorTranslator< DS_MULT, ValueT >
Ngridop
CToMaskGrid	ToMaskGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value equal to its active state
CGridOperator	Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type
Nlvlset
CCapsuleVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of a capsule
CDilatedMeshVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of a dilated mesh (surface mesh dilated by a radius in all directions)
COpenCapsuleWedgeVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of an open wedge. The only parts of the level set populated are within a sector of a capsule. The sector is defined by the intersection of two half spaces
COpenTriangularPrismVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of an open prism. The only parts of the level set populated are along both normals of the triangle. Negative background tiles that fit inside the closed dilated triangle are also populated
CPointArray	Internal class used by derived ConvexVoxelizer classes that make use of PointPartitioner
CTaperedCapsuleVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of a tapered capsule
CTriangleMeshEdgeConnectivity	Class representing the connectivity of edges in a triangle mesh, where each edge is associated with the cells (triangles) sharing it. Provides methods to retrieve adjacent cells, vertex coordinates, normals, and other geometric properties
CTubeComplexVoxelizer	Class used to generate a grid of type GridType containing a narrow-band level set representation of a tube complex
Nmorphology
CMorphology	Dilation/Erosion operations over a Trees leaf level voxel topology
CNodeMaskOp	Node Mask dilation/erosion operations for individual leaf nodes on a given tree. The leaf node may optionally belong to a different tree than the provided accessor, which will have the effect of dilating the leaf node mask into a different tree, or eroding the node mask based on corresponding neighbors in a different tree
Npoisson
CDirichletBoundaryOp	Dirichlet boundary condition functor
Nvalxform
CMinOp
CMaxOp
CSumOp
CSumOp< bool >
CMultOp
CMultOp< bool >
CSharedOpApplier
CCopyableOpApplier
CSharedOpTransformer
CCopyableOpTransformer
COpAccumulator
CABTransform	This class implements the Transformer functor interface (specifically, the isAffine(), transform() and invTransform() methods) for a transform that maps an A grid into a B grid's index space such that, after resampling, A's index space and transform match B's index space and transform
CAlphaMask
CBaseCamera	Abstract base class for the perspective and orthographic cameras
CBasePointScatter	Forward declaration of base class
CBaseShader	Abstract base class for the shaders
CBoxSampler
CChangeBackgroundOp
CChangeLevelSetBackgroundOp
CCheckDivergence	Checks the divergence against a range
CCheckEikonal	Checks the norm of the gradient at zero-crossing voxels against a range
CCheckFinite	Checks for both NaN and inf values, i.e. any value that is not finite
CCheckFogVolume	Class that performs various types of checks on fog volumes
CCheckInf	Checks for infinite values, e.g. 1/0 or -1/0
CCheckLevelSet	Class that performs various types of checks on narrow-band level sets
CCheckMagnitude	Check that the magnitude of a value, a, is close to a fixed magnitude, b, given a fixed tolerance c. That is | |a| - |b| | <= c
CCheckMax	Checks a value against a maximum
CCheckMin	Checks a value against a minimum
CCheckNan	Checks NaN values
CCheckNormGrad	Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max]
CCheckRange	Checks a value against a range
CClosestPointProjector
CClosestSurfacePoint	Accelerated closest surface point queries for narrow band level sets
CCompReplaceOp
CConstrainedPointAdvect
CContiguousOp	Wrapper struct used to avoid unnecessary computation of memory access from Coord when all offsets are guaranteed to be within the dense grid
CConvexVoxelizer	Base class used to generate a grid of type GridType containing a narrow-band level set representation of a convex region
CXYRangeData	Class that stores endpoints of a y range for each x value within a specified range and step size
CCopyFromDense	Copy the values from a dense grid into an OpenVDB tree
CCopyToDense	Copy an OpenVDB tree into an existing dense grid
CCpt	Compute the closest-point transform of a scalar grid
CCsgDifferenceOp	DynamicNodeManager operator to merge two trees using a CSG difference
CCsgUnionOrIntersectionOp	DynamicNodeManager operator to merge trees using a CSG union or intersection
CCurl	Compute the curl of a vector grid
CDense	Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below
CDenseBase	Base class for Dense which is defined below
CDenseBase< ValueT, LayoutXYZ >	Partial template specialization of DenseBase
CDenseBase< ValueT, LayoutZYX >	Partial template specialization of DenseBase
CDenseTransformer	Class that applies a functor to the index space intersection of a prescribed bounding box and the dense grid. NB: This class only supports DenseGrids with ZYX memory layout
CDenseUniformPointScatter	Scatters a fixed (and integer) number of points in all active voxels and tiles
CDepthFirstNodeVisitor	Visit all nodes that are downstream of a specific node in depth-first order and apply a user-supplied functor to each node
CDepthFirstNodeVisitor< NodeT, 0 >
CDiagnose	Performs multithreaded diagnostics of a grid
CDiffuseShader	Simple diffuse Lambertian surface shader
CDiffuseShader< Film::RGBA, SamplerType >
CDiracDelta	Smeared-out and continuous Dirac Delta function
CDiscreteField	Thin wrapper class for a velocity grid
CDivergence	Compute the divergence of a vector grid
CFunctor
CDSConverter
CDualGridSampler	This is a simple convenience class that allows for sampling from a source grid into the index space of a target grid. At construction the source and target grids are checked for alignment which potentially renders interpolation unnecessary. Else interpolation is performed according to the templated Sampler type
CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT >	Specialization of DualGridSampler for construction from a ValueAccessor type
CEnrightField	Analytical, divergence-free and periodic velocity field
CExtractAll	Simple utility class used by extractSparseTreeWithMask
CFastSweeping	Computes signed distance values from an initial iso-surface and optionally performs velocity extension at the same time. This is done by means of a novel sparse and parallel fast sweeping algorithm based on a first order Godunov's scheme
CMinMaxKernel
CPruneMinMaxFltKernel
CDilateKernel	Private class of FastSweeping to perform multi-threaded initialization
CInitSdf
CSweepingKernel	Private class of FastSweeping to perform concurrent fast sweeping in two directions
CNN
CFilm	A simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM file output
CRGBA	Floating-point RGBA components in the range [0, 1]
CFilter	Volume filtering (e.g., diffusion) with optional alpha masking
CFindActiveValues	Finds the active values in a tree which intersects a bounding box
CRootChild
CGradient	Compute the gradient of a scalar grid
CFunctor
CGridResampler
CGridSampler	Class that provides the interface for continuous sampling of values in a tree
CGridSampler< tree::ValueAccessor< TreeT >, SamplerType >	Specialization of GridSampler for construction from a ValueAccessor type
CGridTransformer	A GridTransformer applies a geometric transformation to an input grid using one of several sampling schemes, and stores the result in an output grid
CMatrixTransform
CHalfWidthOp
CHalfWidthOp< bool >
CHomogeneousMatMul
CInactivePruneOp
CLaplacian
CFunctor
CLevelSetAdvection	Hyperbolic advection of narrow-band level sets in an external velocity field
CLevelSetFilter	Filtering (e.g. diffusion) of narrow-band level sets. An optional scalar field can be used to produce a (smooth) alpha mask for the filtering
CLevelSetFracture	Level set fracturing
CLevelSetMeasure	Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets
CLevelSetMorphing	Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
CLevelSetPruneOp
CLevelSetRayIntersector	This class provides the public API for intersecting a ray with a narrow-band level set
CLevelSetRayTracer	A (very) simple multithreaded ray tracer specifically for narrow-band level sets
CLevelSetSphere	Generates a signed distance field (or narrow band level set) to a single sphere
CLevelSetTracker	Performs multi-threaded interface tracking of narrow band level sets
CState	Lightweight struct that stores the state of the LevelSetTracker
CLinearSearchImpl	Implements linear iterative search for an iso-value of the level set along the direction of the ray
CMagnitude
COpT
CFunctor
CMatMul
CMatMulNormalize
CMatteShader	Shader that produces a simple matte
CMatteShader< Film::RGBA, SamplerType >
CMeanCurvature
CFunctor
CMeshToVoxelEdgeData	Extracts and stores voxel edge intersection data from a mesh
CEdgeData	Internal edge data type
CGenEdgeData
CMultiResGrid
CMaskOp
CRestrictOp
CProlongateOp
CNonUniformPointScatter	Non-uniform scatters of point in the active voxels. The local point count is implicitly defined as a product of of a global density (called pointsPerVolume) and the local voxel (or tile) value
CNormalize
COpT
CFunctor
CNormalShader	Color shader that treats the surface normal (x, y, z) as an RGB color
CNormalShader< Film::RGBA, SamplerType >
COrthographicCamera
CParticleAtlas
CIterator	Provides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas
CParticlesToLevelSet
CPerspectiveCamera
CPointAdvect
CPointIndexFilter
CPointIndexIterator	Accelerated range and nearest-neighbor searches for point index grids
CPointIndexLeafNode
CPointPartitioner
CIndexIterator
CPointSampler
CPointsToMask	Makes every voxel of a grid active if it contains a point
CReducePool
CPolygonPool	Collection of quads and triangles
CPositionShader	Color shader that treats position (x, y, z) as an RGB color in a cube defined from an axis-aligned bounding box in world space
CPositionShader< Film::RGBA, SamplerType >
CQuadAndTriangleDataAdapter	Contiguous quad and triangle data adapter class
CQuadraticSampler
CSampler	Provises a unified interface for sampling, i.e. interpolation
CSampler< 0, false >
CSampler< 0, true >
CSampler< 1, false >
CSampler< 1, true >
CSampler< 2, false >
CSampler< 2, true >
CScalarToVectorConverter	ScalarToVectorConverter<ScalarGridType>::Type is the type of a grid having the same tree configuration as ScalarGridType but value type Vec3<T> where T is ScalarGridType::ValueType
CSignedFloodFillOp
CSparseExtractor	Functor-based class used to extract data that satisfies some criteria defined by the embedded OpType functor. The extractSparseTree function wraps this class
CSparseMaskedExtractor	Functor-based class used to extract data from a dense grid, at the index-space intersection with a supplied mask in the form of a sparse tree. The extractSparseTreeWithMask function wraps this class
CSparseToDenseCompositor
CStaggeredBoxSampler
CStaggeredPointSampler
CStaggeredQuadraticSampler
CSumMergeOp	DynamicNodeManager operator to merge trees using a sum operation
CTileData	Struct that encodes a bounding box, value and level of a tile
CTolerancePruneOp
CTreeToMerge	Convenience class that contains a pointer to a tree to be stolen or deep copied depending on the tag dispatch class used and a subset of methods to retrieve data from the tree
CMaskPtr	Wrapper around unique_ptr that deep-copies mask on copy construction
CMaskUnionOp	DynamicNodeManager operator used to generate a mask of the input tree, but with dense leaf nodes replaced with active tiles for compactness
CUniformPointScatter	The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes:
CVectorToScalarConverter	VectorToScalarConverter<VectorGridType>::Type is the type of a grid having the same tree configuration as VectorGridType but a scalar value type, T, where T is the type of the original vector components
CVectorToScalarGrid	Metafunction to convert a vector-valued grid type to a scalar grid type
CVelocityIntegrator	Performs Runge-Kutta time integration of variable order in a static velocity field
CVelocitySampler
CVolumeAdvection	Performs advections of an arbitrary type of volume in a static velocity field. The advections are performed by means of various derivatives of Semi-Lagrangian integration, i.e. backwards tracking along the hyperbolic characteristics followed by interpolation
CVolumeRayIntersector	This class provides the public API for intersecting a ray with a generic (e.g. density) volume
CVolumeRender	A (very) simple multithreaded volume render specifically for scalar density
CVolumeToMesh	Mesh any scalar grid that has a continuous isosurface
Ntree
Niter
CInvertedTree
CInvertedTree< HeadT, 1 >
Nleafmgr
CTreeTraits	Useful traits for Tree types
CTreeTraits< const TreeT >
CCombineOpAdapter	Helper class to adapt a three-argument (a, b, result) CombineOp functor into a single-argument functor that accepts a CombineArgs struct
CDenseIteratorBase	Base class for dense iterators over internal and leaf nodes
CDynamicNodeManager
CDynamicNodeManagerLink	This class is a link in a chain that each caches tree nodes of a specific type in a linear array
CForeachFilterOp
CInternalNode
CValueConverter	ValueConverter<T>::Type is the type of an InternalNode having the same child hierarchy and dimensions as this node but a different value type, T
CSameConfiguration	SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of an InternalNode with the same dimensions as this node and whose ChildNodeType has the same configuration as this node's ChildNodeType
CValueOn
CValueOff
CValueAll
CChildOn
CChildOff
CChildAll
CChildIter
CValueIter
CDenseIter
CDeepCopy
CTopologyCopy1
CTopologyCopy2
CTopologyUnion
CA
CTopologyDifference
CA
CB
CTopologyIntersection
CA
CVoxelizeActiveTiles
CIteratorBase	Base class for iterators over internal and leaf nodes
CIteratorRange
CIterListItem	An IterListItem is an element of a compile-time linked list of iterators to nodes of different types
CIterListItem< PrevItemT, NodeVecT, 1, _Level >	The final element of a compile-time linked list of iterators to nodes of different types
CIterListItem< PrevItemT, NodeVecT, VecSize, 0U >	The initial element of a compile-time linked list of iterators to nodes of different types
CIterTraits
CIterTraits< NodeT, typename NodeT::ChildAllCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ChildAllIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ChildOffCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ChildOffIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ChildOnCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ChildOnIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueAllCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueAllIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueOffCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueOffIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueOnCIter >
CNodeConverter
CIterTraits< NodeT, typename NodeT::ValueOnIter >
CNodeConverter
CLeafBuffer	Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode
CLeafBuffer< bool, Log2Dim >
CLeafIteratorBase	Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels)
CLeafManager	This class manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxiliary buffers (one or more per leaf) that can be swapped with the leaf nodes' voxel data buffers
CLeafRange
CIterator
CLeafManagerImpl
CLeafManagerImpl< LeafManager< const TreeT > >
CLeafNode	Templated block class to hold specific data types and a fixed number of values determined by Log2Dim. The actual coordinate dimension of the block is 2^Log2Dim, i.e. Log2Dim=3 corresponds to a LeafNode that spans a 8^3 block
CValueConverter	ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
CSameConfiguration	SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
CValueOn
CValueOff
CValueAll
CChildOn
CChildOff
CChildAll
CValueIter
CChildIter	Leaf nodes have no children, so their child iterators have no get/set accessors
CDenseIter
CLeafNode< bool, Log2Dim >	LeafNode specialization for values of type bool that stores both the active states and the values of (2^Log2Dim)^3 voxels as bit masks
CValueConverter	ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
CSameConfiguration	SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
CValueIter
CChildIter	Leaf nodes have no children, so their child iterators have no get/set accessors
CDenseIter
CLeafNode< ValueMask, Log2Dim >	LeafNode specialization for values of type ValueMask that encodes both the active states and the boolean values of (2^Log2Dim)^3 voxels in a single bit mask, i.e. voxel values and states are indistinguishable!
CValueConverter	ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
CSameConfiguration	SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
CValueIter
CChildIter	Leaf nodes have no children, so their child iterators have no get/set accessors
CDenseIter
CNodeChain	NodeChain<RootNodeType, RootNodeType::LEVEL>::Type is a openvdb::TypeList that lists the types of the nodes of the tree rooted at RootNodeType in reverse order, from LeafNode to RootNode
CNodeChain< HeadT, 1 >	Specialization to terminate NodeChain
CNodeFilter
CNodeIteratorBase	Base class for tree-traversal iterators over all nodes
CNodeList	This class caches tree nodes of a specific type in a linear array
CNodeRange
CIterator
CNodeManager	To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree
CNodeManagerLink	This class is a link in a chain that each caches tree nodes of a specific type in a linear array
CNodeUnion	Default implementation of a NodeUnion that stores the child pointer and the value separately (i.e., not in a union). Types which select this specialization usually do not conform to the requirements of a union member, that is that the type ValueT is not trivially copyable. This implementation is thus NOT used for POD, math::Vec, math::Mat, math::Quat or math::Coord types, but is used (for example) with std::string
CNodeUnion< ValueT, ChildT, typename std::enable_if< std::is_trivially_copyable< ValueT >::value >::type >	Template specialization of a NodeUnion that stores the child pointer and the value together (int, float, pointer, etc.)
CReduceFilterOp
CRootNode
CValueConverter	ValueConverter<T>::Type is the type of a RootNode having the same child hierarchy as this node but a different value type, T
CSameConfiguration	SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a RootNode whose ChildNodeType has the same configuration as this node's ChildNodeType
CRootNodeCombineHelper
CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true >
CRootNodeCopyHelper
CRootNodeCopyHelper< RootT, OtherRootT, true >
CSameInternalConfig
CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > >
CSameLeafConfig
CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > >
CSameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > >
CSameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > >
CSameRootConfig
CSameRootConfig< ChildT1, RootNode< ChildT2 > >
CSparseIteratorBase	Base class for sparse iterators over internal and leaf nodes
CTree
CValueConverter	ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T
CDeallocateNodes
CTree3	Tree3<T, N1, N2>::Type is the type of a three-level tree (Root, Internal, Leaf) with value type T and internal and leaf node log dimensions N1 and N2, respectively
CTree4	Tree4<T, N1, N2, N3>::Type is the type of a four-level tree (Root, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2 and N3, respectively
CTree5	Tree5<T, N1, N2, N3, N4>::Type is the type of a five-level tree (Root, Internal, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2, N3 and N4, respectively
CTreeBase	Base class for typed trees
CTreeIterTraits	TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type
CTreeIterTraits< TreeT, typename TreeT::LeafCIter >
CTreeIterTraits< TreeT, typename TreeT::LeafIter >
CTreeIterTraits< TreeT, typename TreeT::NodeCIter >
CTreeIterTraits< TreeT, typename TreeT::NodeIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter >
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter >
CTreeIterTraits< TreeT, typename TreeT::ValueAllCIter >
CTreeIterTraits< TreeT, typename TreeT::ValueAllIter >
CTreeIterTraits< TreeT, typename TreeT::ValueOffCIter >
CTreeIterTraits< TreeT, typename TreeT::ValueOffIter >
CTreeIterTraits< TreeT, typename TreeT::ValueOnCIter >
CTreeIterTraits< TreeT, typename TreeT::ValueOnIter >
CTreeValueIteratorBase	Base class for tree-traversal iterators over tile and voxel values
CValueAccessorBase	This base class for ValueAccessors manages registration of an accessor with a tree so that the tree can automatically clear the accessor whenever one of its nodes is deleted
CValueAccessorImpl	The Value Accessor Implementation and API methods. The majoirty of the API matches the API of a compatible OpenVDB Tree Node
CValueAccessorLeafBuffer	A small class that contains a cached pointer to a LeafNode data buffer which is derived from by the internal Value Accessor Implementation. This allows for the empty base class optimization to be performed in the case where a LeafNode does not store a contiguous index-able buffer. From C++20 we can instead switch to [[no_unique_address]]
CValueAccessorLeafBuffer< TreeTypeT, IntegerSequence, typename std::enable_if< !value_accessor_internal::EnableLeafBuffer< TreeTypeT, IntegerSequence >::value >::type >	Specialization for the case where a Leaf Buffer cannot be cached
CValueAccessorLock	A small class that contains a Mutex which is derived from by the internal Value Accessor Implementation. This allows for the empty base class optimization to be performed in the case where a Mutex/Lock is not in use. From C++20 we can instead switch to [[no_unique_address]]
CValueAccessorLock< void >	Specialization for the case where no Mutex is in use. See above
Ntypes_internal
Cint_t
Cint_t< 8ul, true >
Cint_t< 16ul, true >
Cint_t< 32ul, true >
Cint_t< 64ul, true >
Cint_t< 8ul, false >
Cint_t< 16ul, false >
Cint_t< 32ul, false >
Cint_t< 64ul, false >
Cflt_t
Cflt_t< 16ul >
Cflt_t< 32ul >
Cflt_t< 64ul >
Nutil
CBaseMaskIterator	Base class for the bit mask iterators
CCpuTimer	Simple timer for basic profiling
CDenseMaskIterator
CFormattedInt	I/O manipulator that formats integer values with thousands separators
CLeafTopologyDiffOp	Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees
CLeafTopologyIntOp	Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees
CNodeMask	Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation
CNodeMask< 1 >	Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes
CNodeMask< 2 >	Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes
CNullInterrupter	Base class for interrupters
COffMaskIterator
COnMaskIterator
CPagedArray	Concurrent, page-based, dynamically-sized linear data structure with O(1) random access and STL-compliant iterators. It is primarily intended for applications that concurrently insert (a possibly unkown number of) elements into a dynamically growing linear array, and fast random access to said elements
CValueBuffer
CConstIterator
CIterator
CPage
CArithmeticError
CAXCodeGenError
CAXCompilerError
CAXExecutionError
CAXSyntaxError
CAXTokenError
CCanConvertType	CanConvertType<FromType, ToType>::value is true if a value of type ToType can be constructed from a value of type FromType
CCanConvertType< math::Vec2< T >, math::Vec2< T > >
CCanConvertType< math::Vec3< T >, math::Vec3< T > >
CCanConvertType< math::Vec4< T >, math::Vec4< T > >
CCanConvertType< PointDataIndex32, PointIndex32 >
CCanConvertType< PointIndex32, PointDataIndex32 >
CCanConvertType< T, math::Vec2< T > >
CCanConvertType< T, math::Vec3< T > >
CCanConvertType< T, math::Vec4< T > >
CCanConvertType< T, ValueMask >
CCanConvertType< T0, math::Vec2< T1 > >
CCanConvertType< T0, math::Vec3< T1 > >
CCanConvertType< T0, math::Vec4< T1 > >
CCanConvertType< ValueMask, T >
CCLIError
CCombineArgs	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
CConvertElementType	Conversion classes for changing the underlying type of VDB types
CConvertElementType< math::Mat3< T >, SubT >
CConvertElementType< math::Mat4< T >, SubT >
CConvertElementType< math::Quat< T >, SubT >
CConvertElementType< math::Vec2< T >, SubT >
CConvertElementType< math::Vec3< T >, SubT >
CConvertElementType< math::Vec4< T >, SubT >
CCoord	Signed (x, y, z) 32-bit integer coordinates
CCoordBBox	Axis-aligned bounding box of signed integer coordinates
CIterator	Iterator over the Coord domain covered by a CoordBBox
CCopyConstness	CopyConstness<T1, T2>::Type is either const T2 or T2 with no const qualifier, depending on whether T1 is const
CDeepCopy	Tag dispatch class that distinguishes constructors that deep copy
CException
CGrid	Container class that associates a tree with a transform and metadata
CValueConverter	ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different value type, T
CGridBase	Abstract base class for typed grids
CGridNamePred	Predicate functor that returns true for grids that have a specified name
CHasMultiPassIO	Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data
CHasMultiPassIO< Grid< TreeType > >
CHasMultiPassIO< tree::Tree< RootNodeType > >
Cindex_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:
CIndexError
CIoError
Cis_arithmetic
Cis_arithmetic< math::half >
Cis_floating_point
Cis_floating_point< Half >
Cis_signed
Cis_signed< Half >
CIsSpecializationOf	Helper metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter
CIsSpecializationOf< Template< Args... >, Template >
CKeyError
CLookupError
CMatTraits
CMatTraits< T, false >
CMetadata	Base class for storing metadata information in a grid
CMetaMap	Container that maps names (strings) to values of arbitrary types
CNotImplementedError
CPartialCreate	Tag dispatch class that distinguishes constructors during file input
CPointIndex	Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid
CPromoteContainerType
CPromoteType	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)
CPromoteType< math::Mat3< T > >
CPromoteType< math::Mat4< T > >
CPromoteType< math::Quat< T > >
CPromoteType< math::Vec2< T > >
CPromoteType< math::Vec3< T > >
CPromoteType< math::Vec4< T > >
CQuatTraits
CQuatTraits< T, false >
CReferenceError
CRuntimeError
CShallowCopy	Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors
CSteal	Tag dispatch class that distinguishes constructors that steal
CSwappedCombineOp
CTopologyCopy	Tag dispatch class that distinguishes topology copy constructors from deep copy constructors
CTreeAdapter	This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type
CTreeAdapter< const Grid< _TreeType > >	Partial specialization for const Grid types
CTreeAdapter< Grid< _TreeType > >	Partial specialization for Grid types
CTreeAdapter< tree::ValueAccessor< _TreeType > >	Partial specialization for ValueAccessor types
CTupleList	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
CTupleList<>	Specilization of an empty TupleList. Required due to constructor selection
CTypedMetadata	Templated metadata class to hold specific types
CTypeError
CTypeList	A list of types (not necessarily unique)
CUnknownMetadata	Subclass to hold raw data of an unregistered type
CValueError
CValueMask
CValueTraits
CValueTraits< T, false >
CVecTraits
CVecTraits< T, false >
CVersionId
Nopenvdb_houdini
CAttributeCopy
CAttributeCopyBase
CAttributeDetail
CAttributeDetailBase
CGenAdaptivityMaskOp	TBB body object for threaded sharp feature construction
CGridResampleOp	GridResampleOp is a functor class for use with UTvdbProcessTypedGrid() that samples an input grid into an output grid of the same type through a given transform
CGridResampleToMatchOp	GridResampleToMatchOp is a functor class for use with GridBase::apply() that samples an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide, but the output grid's transform is unchanged
CGridTransformOp	GridTransformOp is a functor class for use with GridBase::apply() that samples an input grid into an output grid of the same type through a given affine transform
CGT_GEOPrimCollectVDB
CHoudiniInterrupter	Wrapper class that adapts a Houdini UT_Interrupt object for use with OpenVDB library routines
CMeshAttrTransfer
COpenVDBOpFactory	Use this class to register a new OpenVDB operator (SOP, POP, etc.)
CPointAttrTransfer
CPrimCpyOp	TBB body object for threaded primitive copy
CSharpenFeaturesOp	TBB body object for threaded sharp feature construction
CSOP_NodeVDB	Base class from which to derive OpenVDB-related Houdini SOPs
CStrAttributeCopy
CTransferPointAttributesOp
CTransferPrimitiveAttributesOp
CTransformOp	TBB body object for threaded world to voxel space transformation and copy of points
CVdbPrimCIterator	Iterator over const VDB primitives on a geometry detail
CVdbPrimIterator	Iterator over non-const VDB primitives on a geometry detail
CVertexNormalOp	TBB body object for threaded vertex normal generation
NOSN
COSNoise
Nstd
Chash< openvdb::math::Coord >
Cnumeric_limits< openvdb::math::internal::half >
CApplyFunc
CAXLTYPE
CAXSTYPE
Ccnanovdb_coord
Ccnanovdb_gridblindmetadata
Ccnanovdb_griddata
Ccnanovdb_map
Ccnanovdb_mask3
Ccnanovdb_mask4
Ccnanovdb_mask5
Ccnanovdb_node0F
Ccnanovdb_node0F3
Ccnanovdb_node1F
Ccnanovdb_node1F3
Ccnanovdb_node2F
Ccnanovdb_node2F3
Ccnanovdb_readaccessor
Ccnanovdb_rootdata_tileF
Ccnanovdb_rootdata_tileF3
Ccnanovdb_rootdataF
Ccnanovdb_rootdataF3
Ccnanovdb_tileentryF
Ccnanovdb_tileentryF3
Ccnanovdb_treedata
Ccnanovdb_Vec3F
CCompositeOp
CFilterType	Selectively extract and filter point data using a custom filter operator
CGU_VDBPointList	Houdini point attribute wrapper
CMeshDataAdapter	Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
CParticleArray	Partition particles and performs range and nearest-neighbor searches
Cpnanovdb_grid_handle_t
Cpnanovdb_grid_t
Cpnanovdb_grid_type_constants_t
Cpnanovdb_gridblindmetadata_handle_t
Cpnanovdb_gridblindmetadata_t
Cpnanovdb_leaf_handle_t
Cpnanovdb_leaf_t
Cpnanovdb_lower_handle_t
Cpnanovdb_lower_t
Cpnanovdb_map_handle_t
Cpnanovdb_map_t
Cpnanovdb_readaccessor_t
Cpnanovdb_root_handle_t
Cpnanovdb_root_t
Cpnanovdb_root_tile_handle_t
Cpnanovdb_root_tile_t
Cpnanovdb_tree_handle_t
Cpnanovdb_tree_t
Cpnanovdb_upper_handle_t
Cpnanovdb_upper_t
CPointArray	Partitions points into BucketLog2Dim aligned buckets using a parallel radix-based sorting algorithm
CRayGenOp
CSOP_VDBCacheOptions	SOP_NodeCacheOptions subclass that adds methods specific to SOP_NodeVDB
CTestLeafIO