OpenVDB  9.1.1
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 CGridBuilder< ValueT, BuildT, StatsT >:: BuildLeaf
 CGridBuilder< ValueT, BuildT, StatsT >:: BuildNode< ChildT >
 CGridBuilder< ValueT, BuildT, StatsT >:: ValueAccessor
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >::A
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::A
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >::A
 CAbsDiffCompression oracle based on absolute difference
 CABTransformThis 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
 CAttributeRegistry::AccessDataRegistered access details, including its name, type and whether a write handle is required
 CAttributeArray::AccessorBaseAccessor base class for AttributeArray storage where type is not available
 CAccessorEval< CodecType, ValueType >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
 CAdvect
 CAliasTypeMap< T1, T2 >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
 CAliasTypeMap< ArgType< T, S >, T[S]>
 CAliasTypeMap< openvdb::math::Mat3< T >, T[9]>
 CAliasTypeMap< openvdb::math::Mat4< T >, T[16]>
 CAliasTypeMap< openvdb::math::Vec2< T >, T[2]>
 CAliasTypeMap< openvdb::math::Vec3< T >, T[3]>
 CAliasTypeMap< openvdb::math::Vec4< T >, T[4]>
 CAlphaMask< GridT, MaskT, SamplerT, FloatT >
 CApplyFunc< Fn, Args >
 CArchiveGrid serializer/unserializer
 CFunctionTraits< ReturnT(Args...)>::Arg< I >
 CArgType< T, _SIZE >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< SignatureT, I >Templated argument iterator which implements various small functions per argument type, resolved at compile time
 CArgumentIterator< SignatureT, 0 >
 CAttributeArrayBase class for storing attribute data
 CAttributeBindingsThis 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
 CAttributeCopyBase
 CAttributeDetailBase
 CAttributeHandle< ValueType, CodecType >
 CAttributeHandle< Index, openvdb::v9_1::points::StringCodec< false > >
 CAttributeHashFilter< RandGenT, IntType >
 CAttributeRegistryThis class stores a list of access names, types and their dependency connections
 CLevelSetFilter< GridT, MaskT, InterruptT >::Filter::Avg< Axis >
 CAXLTYPE
 CAXSTYPE
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::B
 CBaseBBox< Vec3T >
 CBaseBBox< CoordT >
 CBaseCameraAbstract base class for the perspective and orthographic cameras
 CRootNodeMask::BaseIterator
 CBaseMaskIterator< NodeMask >Base class for the bit mask iterators
 CBasePointScatter< PointAccessorType, RandomGenerator, InterruptType >Forward declaration of base class
 CBaseShaderAbstract base class for the shaders
 CBaseStencil< DerivedType, GridT, IsSafe >
 CBaseStencil< DerivedType, SIZE, GridT >
 CBaseStencil< BoxStencil< GridT >, 8, GridT >
 CBaseStencil< BoxStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< BoxStencil< GridT, true >, GridT, true >
 CBaseStencil< CurvatureStencil< GridT >, 19, GridT >
 CBaseStencil< CurvatureStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< DenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< FourthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< GradStencil< GridT >, 7, GridT >
 CBaseStencil< GradStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< NineteenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SecondOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SevenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SixthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< ThirteenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< WenoStencil< GridT >, 19, GridT >
 CBaseStencil< WenoStencil< GridT, IsSafe >, GridT, IsSafe >
 CBBox< Vec3T, bool >
 CBBox< Vec3T >Axis-aligned bounding box
 CBBox< Coord >
 CBBox< CoordT >
 CBBox< nanovdb::Vec3 >
 CBBox< Vec3< double > >
 CBBox< Vec3d >
 CBBoxFilter
 CBIAS_SCHEME< bgs >
 CBIAS_SCHEME< FIRST_BIAS >
 CBIAS_SCHEME< HJWENO5_BIAS >
 CBIAS_SCHEME< SECOND_BIAS >
 CBIAS_SCHEME< THIRD_BIAS >
 CBIAS_SCHEME< WENO5_BIAS >
 CBinaryFilter< T1, T2, And >
 CGroupHandle::BitMask
 COpenToNanoVDB< OpenBuildT, NanoBuildT, OracleT, BufferT >::BlindMetaData
 CBoxSampler
 CBufferTraits< BufferT >
 CBufferTraits< CudaDeviceBuffer >
 CBuildMoveMapsOp< DeformerT, TreeT, FilterT >
 CBuildToValueMap< T >Maps one type (e.g. the build types above) to other (actual) types
 CBuildToValueMap< Fp16 >
 CBuildToValueMap< Fp4 >
 CBuildToValueMap< Fp8 >
 CBuildToValueMap< FpN >
 CBuildToValueMap< Half >
 CBuildToValueMap< NanoBuildT >
 CBuildToValueMap< ValueMask >
 CCachedDeformer< T >::Cache
 CCachedDeformer< T >A Deformer that caches the resulting positions from evaluating another Deformer
 CCacheItem< TreeCacheT, NodeVecT, AtRoot >
 CCacheItem< TreeCacheT, NodeVecT, true >The tail of a compile-time list of cached node pointers, ordered from LeafNode to RootNode
 CCacheItem< ValueAccessor, SubtreeT, SubtreeT::Size==1 >
 CCamera< RealT, Vec3T, RayT >A minimal perspective camera for ray generation
 CCanConvertType< FromType, ToType >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 >
 CChangeBackgroundOp< TreeOrLeafManagerT >
 CChangeLevelSetBackgroundOp< TreeOrLeafManagerT >
 CCheckDivergence< GridT, TreeIterT, DiffScheme >Checks the divergence against a range
 CCheckEikonal< GridT, TreeIterT, StencilT >Checks the norm of the gradient at zero-crossing voxels against a range
 CCheckFinite< GridT, TreeIterT >Checks for both NaN and inf values, i.e. any value that is not finite
 CCheckFogVolume< GridType >Class that performs various types of checks on fog volumes
 CCheckInf< GridT, TreeIterT >Checks for infinite values, e.g. 1/0 or -1/0
 CCheckLevelSet< GridType >Class that performs various types of checks on narrow-band level sets
 CCheckMagnitude< GridT, TreeIterT >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< GridT, TreeIterT >Checks a value against a maximum
 CCheckMin< GridT, TreeIterT >Checks a value against a minimum
 CCheckNan< GridT, TreeIterT >Checks NaN values
 CCheckNormGrad< GridT, TreeIterT, GradScheme >Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max]
 CCheckRange< GridT, MinInclusive, MaxInclusive, TreeIterT >Checks a value against a range
 CInternalNode< _ChildNodeType, Log2Dim >::ChildAll
 CLeafNode< T, Log2Dim >::ChildAll
 CLeafNode< BuildT, CoordT, MaskT, Log2Dim >::ChildNodeType
 CInternalNode< _ChildNodeType, Log2Dim >::ChildOff
 CLeafNode< T, Log2Dim >::ChildOff
 CInternalNode< _ChildNodeType, Log2Dim >::ChildOn
 CLeafNode< T, Log2Dim >::ChildOn
 CClosestPointProjector< CptGridT >
 CClosestSurfacePoint< GridT >Accelerated closest surface point queries for narrow band level sets
 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_stencil1F
 Ccnanovdb_stencil1F3
 Ccnanovdb_tileentryF
 Ccnanovdb_tileentryF3
 Ccnanovdb_treedata
 Ccnanovdb_Vec3F
 CCodec
 CImage::ColorRGB
 CCombineArgs< AValueType, BValueType >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
 CCombineOpAdapter< AValueT, CombineOp, BValueT >Helper class to adapt a three-argument (a, b, result) CombineOp functor into a single-argument functor that accepts a CombineArgs struct
 CCompilerThe compiler class. This holds an llvm context and set of compiler options, and constructs executable objects (e.g. PointExecutable or VolumeExecutable) from a syntax tree or snippet of code
 CCompilerOptionsSettings which control how a Compiler class object behaves
 CComponentExtent< VecT >Vector component-wise op to evaluate the min/max of vector components and return the result as a vector of equal size and precision
 CCompositeFunctorTranslator< OP, ValueT >Translator that converts an enum to compositing functor types
 CCompositeFunctorTranslator< DS_ADD, ValueT >
 CCompositeFunctorTranslator< DS_MAX, ValueT >
 CCompositeFunctorTranslator< DS_MIN, ValueT >
 CCompositeFunctorTranslator< DS_MULT, ValueT >
 CCompositeFunctorTranslator< DS_OVER, ValueT >
 CCompositeFunctorTranslator< DS_SUB, ValueT >
 CCompositeOp
 CCompoundMap< FirstMapType, SecondMapType >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
 CCompReplaceOp< TreeT >
 CComputeKernelThe function definition and signature which is built by the ComputeGenerator
 CConstantFolder< SignatureT, I >Constant folding support structure
 CConstantFolder< SignatureT, 0 >
 CConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType >
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstRowRead-only accessor to a row of this matrix
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstValueIterIterator over the stored values in a row of this matrix
 CContainer
 CContiguousOp< ValueT, PointWiseOp >Wrapper struct used to avoid unnecessary computation of memory access from Coord when all offsets are guaranteed to be within the dense grid
 CConversionDummy class for tag dispatch of conversion constructors
 CConvertElementType< T, SubT >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 >
 CConvertTrait< T >
 CConvertTrait< Vec3< T > >
 CConvertTrait< Vec4< T > >
 CCoordSigned (x, y, z) 32-bit integer coordinates
 CCoordSigned (i, j, k) 32-bit integer coordinate class, similar to openvdb::math::Coord
 CCoordBBoxAxis-aligned bounding box of signed integer coordinates
 CCopyableOpApplier< IterT, OpT >
 CCopyableOpTransformer< InIterT, OutTreeT, OpT >
 CCopyConstness< FromType, ToType >CopyConstness<T1, T2>::Type is either const T2 or T2 with no const qualifier, depending on whether T1 is const
 CCopyFromDense< _TreeT, _DenseT >Copy the values from a dense grid into an OpenVDB tree
 CLocalMovePointsOp< TreeT >::CopyIterator
 CGlobalMovePointsOp< TreeT >::CopyIterator
 CCopyOp< T >
 CCopyToDense< _TreeT, _DenseT >Copy an OpenVDB tree into an existing dense grid
 CCPT< MapType, DiffScheme >Compute the closest-point transform to a level set
 CCpt< InGridT, MaskGridType, InterruptT >Compute the closest-point transform of a scalar grid
 CCPT_RANGE< MapType, DiffScheme >Compute the closest-point transform to a level set
 CCpuTimerSimple timer for basic profiling
 CCpuTimer< Accuracy >
 CCRC32Class that computes the Cyclic Redundancy Check (CRC)
 CCsgDifferenceOp< TreeT >DynamicNodeManager operator to merge two trees using a CSG difference
 CCsgUnionOrIntersectionOp< TreeT, Union >DynamicNodeManager operator to merge trees using a CSG union or intersection
 CCudaDeviceBufferSimple memory buffer using un-managed pinned host memory when compiled with NVCC. Obviously this class is making explicit used of CUDA so replace it with your own memory allocator if you are not using CUDA
 CCurl< MapType, DiffScheme >Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map
 CCurl< GridT, MaskGridType, InterruptT >Compute the curl of a vector grid
 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
 CCustomDataThe 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
 CD1< DiffScheme >
 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< DiffScheme >
 CD1Vec< CD_2ND >
 CD1Vec< CD_2NDT >
 CD1Vec< CD_4TH >
 CD1Vec< CD_6TH >
 CD2< DiffScheme >
 CD2< CD_FOURTH >
 CD2< CD_SECOND >
 CD2< CD_SIXTH >
 CDDA< RayT, Log2Dim >A Digital Differential Analyzer specialized for OpenVDB grids
 CDDA< RayT, CoordT, Dim >A Digital Differential Analyzer. Unlike HDDA (defined above) this DDA uses a fixed step-size defined by the template parameter Dim!
 CDDA< RayT, LeafT::TOTAL >
 CDDA< RayT, NodeT::TOTAL >
 CDDA< RayType, NodeT::TOTAL >
 CTree< _RootNodeType >::DeallocateNodes< NodeType >
 CDeepCopyTag dispatch class that distinguishes constructors that deep copy
 CInternalNode< _ChildNodeType, Log2Dim >::DeepCopy< OtherInternalNode >
 CDefault< ValueType >
 CDeformerTraits< DeformerT >Deformer Traits for optionally configuring deformers to be applied in index-space. The default is world-space
 CDelta< T >Delta for small floating-point offsets
 CDelta< T >Delta for small floating-point offsets
 CDelta< double >
 CDelta< double >
 CDelta< float >
 CDelta< float >
 CDenseBase< ValueT, Layout >Base class for Dense which is defined below
 CDenseBase< ValueT, LayoutXYZ >Partial template specialization of DenseBase
 CDenseBase< ValueT, LayoutZYX >Partial template specialization of DenseBase
 CDenseData
 CDenseGridHandle< BufferT >
 CDenseTransformer< _ValueT, OpType >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
 CDepthFirstNodeVisitor< NodeT, LEVEL >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 >
 CDescriptor
 CVector< T >::DeterministicDotProductOp
 CDiagnose< GridT >Performs multithreaded diagnostics of a grid
 CDiagnose< GridType >
 CFastSweeping< SdfGridT, ExtValueT >::DilateKernelPrivate class of FastSweeping to perform multi-threaded initialization
 CDiracDelta< RealT >Smeared-out and continuous Dirac Delta function
 CDirichletBoundaryOp< ValueType >Dirichlet boundary condition functor
 CDiscreteField< VelGridT, Interpolator >Thin wrapper class for a velocity grid
 CDitherLUT
 CDivergence< MapType, DiffScheme >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< InGridT, MaskGridType, InterruptT >Compute the divergence of a vector grid
 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 >
 CDSConverter< DenseType, TreeType >
 CDualGridSampler< GridOrTreeT, SamplerT >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< AccT, SamplerT >
 CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT >Specialization of DualGridSampler for construction from a ValueAccessor type
 CDummySampleType
 CDynamicNodeManager< TreeOrLeafManagerT, _LEVELS >
 CDynamicNodeManagerLink< NodeT, LEVEL >This class is a link in a chain that each caches tree nodes of a specific type in a linear array
 CDynamicNodeManagerLink< ChildNodeType, LEVELS-1 >
 CMeshToVoxelEdgeData::EdgeDataInternal edge data type
 Cenable_if< bool, T >C++11 implementation of std::enable_if
 Cenable_if< true, T >
 CEnrightField< ScalarT >Analytical, divergence-free and periodic velocity field
 Cexception
 CExtractAll< _ResultTreeType, DenseValueType >Simple utility class used by extractSparseTreeWithMask
 CExtremaThis class computes the minimum and maximum values of a population of floating-point values
 CExtrema< ValueT, Rank >
 CExtrema< ValueT, 0 >Template specialization of Extrema on scalar value types, i.e. rank = 0
 CExtrema< ValueT, 1 >
 CExtrema< VecT, 1 >Template specialization of Extrema on vector value types, i.e. rank = 1
 Cfalse_type
 CFastSweeping< SdfGridT, ExtValueT >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
 CLeafBuffer< T, Log2Dim >::FileInfo
 CFillOp< T >
 CFilmA simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM file output
 CFilter< GridT, MaskT, InterruptT >Volume filtering (e.g., diffusion) with optional alpha masking
 CFilterTraits< T >
 CFilterTraits< BBoxFilter >
 CFilterTraits< BinaryFilter< T0, T1, And > >
 CFilterTraits< LevelSetFilter< T > >
 CFilterTypeSelectively extract and filter point data using a custom filter operator
 CFindActiveValues< TreeT >Finds the active values in a tree which intersects a bounding box
 CFixedPointCodec< OneByte, Range >
 CFloatTraits< T, int >
 CFloatTraits< bool, 1 >
 CFloatTraits< BuildT >
 CFloatTraits< T, 8 >
 CFloatTraits< ValueMask, 1 >
 CFloatTraits< ValueT >
 Cflt_t< Bits >
 Cflt_t< 16ul >
 Cflt_t< 32ul >
 Cflt_t< 64ul >
 CForeachFilterOp< OpT >
 CFormattedInt< IntT >I/O manipulator that formats integer values with thousands separators
 CFp16Dummy type for a 16bit quantization of float point values
 CFp4Dummy type for a 4bit quantization of float point values
 CFp8Dummy type for a 8bit quantization of float point values
 CFpNDummy type for a variable bit quantization of floating point values
 CFrustumRasterizer< PointDataGridT >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
 CFrustumRasterizerSettingsA group of shared settings to be used in the Volume Rasterizer
 CFunctionThe base/abstract representation of an AX function. Derived classes must implement the Function::types call to describe their signature
 CFunctionBuilderBuilder 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
 CFunctionGroupTodo
 CFunctionOptionsOptions that control how functions behave
 CFunctionRegistryThe 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
 CFunctionTraits< SignatureT >Templated function traits which provides compile-time index access to the types of the function signature
 CFunctionTraits< R(Args...)>
 CFunctionTraits< ReturnT(Args...)>
 CNormalize< GridT, MaskGridType, InterruptT >::Functor
 CDivergence< InGridT, MaskGridType, InterruptT >::Functor< DiffScheme >
 CGradient< InGridT, MaskGridType, InterruptT >::Functor
 CLaplacian< GridT, MaskGridType, InterruptT >::Functor
 CMeanCurvature< GridT, MaskGridType, InterruptT >::Functor
 CMagnitude< InGridT, MaskGridType, InterruptT >::Functor
 CGenAdaptivityMaskOp< IndexTreeType, BoolTreeType >TBB body object for threaded sharp feature construction
 CMeshToVoxelEdgeData::GenEdgeData
 CGenericMapA wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators
 CGlobalMovePointsOp< TreeT >
 CGradient< MapType, DiffScheme >Center difference gradient operators, defined with respect to the range-space of the map
 CGradient< InGridT, MaskGridType, InterruptT >Compute the gradient of a scalar grid
 CGradient< ScaleMap, CD_2ND >
 CGradient< ScaleTranslateMap, CD_2ND >
 CGradient< TranslationMap, DiffScheme >
 CGradient< UniformScaleMap, CD_2ND >
 CGradient< UniformScaleTranslateMap, CD_2ND >
 CGradientBiased< MapType, GradScheme >Biased gradient operators, defined with respect to the range-space of the map
 CGradientNormSqrd< MapType, GradScheme >
 CGradientNormSqrd< UniformScaleMap, GradScheme >Partial template specialization of GradientNormSqrd
 CGradientNormSqrd< UniformScaleTranslateMap, GradScheme >Partial template specialization of GradientNormSqrd
 CGridBlindMetaData
 CGridBuilder< ValueT, BuildT, StatsT >Allows for the construction of NanoVDB grids without any dependecy
 CGridChecksumClass that encapsulates two CRC32 checksums, one for the Grid, Tree and Root node meta data and one for the remaining grid nodes
 CGridDataStruct with all the member data of the Grid (useful during serialization of an openvdb grid)
 CGridDescriptor
 CGridHandleBase
 CGridMetaDataThis 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
 CGridNamePredPredicate functor that returns true for grids that have a specified name
 CGridOperator< InGridT, MaskGridType, OutGridT, MapT, OperatorT, InterruptT >Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type
 CGridResampleOp< Sampler, TransformerType >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
 CGridResampler
 CGridResampleToMatchOp< Sampler >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
 CGridSampler< GridOrTreeType, SamplerType >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
 CGridStats< GridT, StatsT >Allows for the construction of NanoVDB grids without any dependecy
 CGridToRasterize< PointDataGridT >
 CGridTransformOp< Sampler >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
 CGridTree< GridT >Defines a tree type from a grid type while perserving constness
 CGridTree< const GridT >
 CGridValidator< ValueT >Allows for the construction of NanoVDB grids without any dependecy
 CGroupCodec
 CGroupFilterIndex filtering on group membership
 CGroupHandle
 CGT_GEOPrimCollect
 CGU_VDBPointList< VectorType >Houdini point attribute wrapper
 CHalfDummy type for a 16 bit floating point values
 Chalf
 CHalfReader< IsReal, T >
 CHalfReader< false, T >Partial specialization for non-floating-point types (no half to float promotion)
 CHalfReader< true, T >Partial specialization for floating-point types
 CHalfWidthOp< ValueType >
 CHalfWidthOp< bool >
 CHalfWriter< IsReal, T >
 CHalfWriter< false, T >Partial specialization for non-floating-point types (no float to half quantization)
 CHalfWriter< true, T >Partial specialization for floating-point types
 Chash< openvdb::math::Coord >
 CHasMultiPassIO< LeafNodeType >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 > >
 CHDDA< RayT, CoordT >A Digital Differential Analyzer specialized for OpenVDB grids
 CHDDA< RayT, nanovdb::Coord >
 CHeaderData encoded at the head of each segment of a file or stream
 CHistogramThis class computes a histogram, with a fixed interval width, of a population of floating-point values
 CHomogeneousMatMul
 CHostBufferThis is a buffer that contains a shared or private pool to either externally or internally managed host memory
 CImageData
 CImageHandle< BufferT >
 CInactivePruneOp< TreeT, TerminationLevel >
 Cindex_sequence<... >
 Cindex_sequence< Is... >
 CIndexIter< IteratorT, FilterT >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:
 CPointPartitioner< PointIndexType, BucketLog2Dim >::IndexIterator
 CIndexToOffsetOp< PointArrayType >
 CVector< T >::InfNormOp
 CFastSweeping< SdfGridT, ExtValueT >::InitSdf
 CAttributeSet::InserterUtility method to construct a NameAndType sequence
 Cint_t< Bits >
 Cint_t< Bits, Signed >
 Cint_t< 16 >
 Cint_t< 16ul, false >
 Cint_t< 16ul, true >
 Cint_t< 32 >
 Cint_t< 32ul, false >
 Cint_t< 32ul, true >
 Cint_t< 64 >
 Cint_t< 64ul, false >
 Cint_t< 64ul, true >
 Cint_t< 8 >
 Cint_t< 8ul, false >
 Cint_t< 8ul, true >
 CInternalData< ChildT, LOG2DIM >Struct with all the member data of the InternalNode (useful during serialization of an openvdb InternalNode)
 CInternalData< ChildT, Log2Dim >
 CInternalNode< _ChildNodeType, Log2Dim >
 CInterrupterDeprecated wrapper class with the same interface as HoudiniInterrupter, however it does not derive from openvdb::util::NullInterrupter. Intended for backwards-compatibility only
 CInvertedTree< HeadT, HeadLevel >
 CInvertedTree< HeadT, 1 >
 Cis_diagonal_jacobian< T >
 Cis_double< T >
 Cis_double< double >
 Cis_floating_point< T >C++11 implementation of std::is_floating_point
 Cis_linear< T >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_same< T1, T2 >C++11 implementation of std::is_same
 Cis_same< T, T >
 Cis_scale< T >
 Cis_scale< ScaleMap >
 Cis_scale_translate< T >
 Cis_scale_translate< ScaleTranslateMap >
 Cis_specialization< AnyType, TemplateType >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 >
 Cis_uniform_diagonal_jacobian< T >
 Cis_uniform_scale< T >
 Cis_uniform_scale< UniformScaleMap >
 Cis_uniform_scale_translate< T >
 Cis_uniform_scale_translate< TranslationMap >
 Cis_uniform_scale_translate< UniformScaleTranslateMap >
 Cis_vec3d< Vec3T >
 Cis_vec3d< Vec3d >
 CISCurl< DiffScheme >Curl operator defined in index space using various first derivative schemes
 CISDivergence< DiffScheme >Divergence operator defined in index space using various first derivative schemes
 CVector< T >::IsFiniteOp
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::IsFiniteOp
 CISGradient< DiffScheme >Gradient operators defined in index space of various orders
 CISGradientBiased< GradScheme, Vec3Bias >Biased Gradient Operators, using upwinding defined by the Vec3Bias input
 CISGradientNormSqrd< GradScheme >
 CISLaplacian< DiffScheme >Laplacian defined in index space, using various center-difference stencils
 CISLaplacian< CD_FOURTH >
 CISLaplacian< CD_SECOND >
 CISLaplacian< CD_SIXTH >
 CISMeanCurvature< DiffScheme2, DiffScheme1 >Compute the mean curvature in index space
 CISOpMagnitude< OpType >Adapter for vector-valued index-space operators to return the vector magnitude
 CBIAS_SCHEME< bgs >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< FIRST_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< SECOND_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< THIRD_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< WENO5_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< HJWENO5_BIAS >::ISStencil< GridType, IsSafe >
 CCoordBBox::Iterator< ZYXOrder >Iterator over the Coord domain covered by a CoordBBox
 CBBox< CoordT, false >::IteratorIterator over the domain covered by a BBox
 CMask< LOG2DIM >::Iterator
 CParticleAtlas< PointIndexGridType >::IteratorProvides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas
 Citerator
 CLeafManager< TreeT >::LeafRange::Iterator
 CNodeList< NodeT >::NodeRange::Iterator
 CIteratorBase< MaskIterT, NodeT >Base class for iterators over internal and leaf nodes
 CIteratorBase< MaskDenseIter, NodeT >
 CIteratorBase< MaskDenseIterator, NodeT >
 CIteratorRange< IterT >
 CIterListItem< PrevItemT, NodeVecT, VecSize, _Level >An IterListItem is an element of a compile-time linked list of iterators to nodes of different types
 CIterListItem< IterListItem, RestT, VecSize-1, 1 >
 CIterListItem< PrevChildItem, InvTreeT, ROOT_LEVEL+1, 0 >
 CIterListItem< PrevItem, InvTreeT, ROOT_LEVEL+1, LEAF_LEVEL >
 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
 CIterListItem< PrevValueItem, InvTreeT, ROOT_LEVEL+1, 0 >
 CIterTraits< NodeT, IterT >
 CIterTraits< NodeT, typename NodeT::ChildAllCIter >
 CIterTraits< NodeT, typename NodeT::ChildAllIter >
 CIterTraits< NodeT, typename NodeT::ChildOffCIter >
 CIterTraits< NodeT, typename NodeT::ChildOffIter >
 CIterTraits< NodeT, typename NodeT::ChildOnCIter >
 CIterTraits< NodeT, typename NodeT::ChildOnIter >
 CIterTraits< NodeT, typename NodeT::ValueAllCIter >
 CIterTraits< NodeT, typename NodeT::ValueAllIter >
 CIterTraits< NodeT, typename NodeT::ValueOffCIter >
 CIterTraits< NodeT, typename NodeT::ValueOffIter >
 CIterTraits< NodeT, typename NodeT::ValueOnCIter >
 CIterTraits< NodeT, typename NodeT::ValueOnIter >
 CIterTraits< typename PrevIterT::NonConstNodeType, PrevIterT >
 CLaplacian< MapType, DiffScheme >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< GridT, MaskGridType, InterruptT >
 CLaplacian< ScaleMap, DiffScheme >
 CLaplacian< ScaleTranslateMap, DiffScheme >
 CLaplacian< TranslationMap, DiffScheme >
 CLaplacian< UniformScaleMap, DiffScheme >
 CLaplacian< UniformScaleTranslateMap, DiffScheme >
 CLaplacian< UnitaryMap, DiffScheme >
 CCachedDeformer< T >::Cache::Leaf
 CLeafBuffer< T, Log2Dim >Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode
 CLeafBuffer< bool, Log2Dim >
 CLeafBuffer< ValueType, Log2Dim >
 CLeafData< ValueT, CoordT, MaskT, LOG2DIM >Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode)
 CLeafData< bool, CoordT, MaskT, LOG2DIM >
 CLeafData< BuildT, CoordT, MaskT, Log2Dim >
 CLeafData< ValueMask, CoordT, MaskT, LOG2DIM >
 CLeafFnBase< CoordT, MaskT, LOG2DIM >Base-class for quantized float leaf nodes
 CLeafIteratorBase< TreeT, RootChildOnIterT >Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels)
 CLeafManager< GridT >LeafNanager maintains a linear array of leaf nodes
 CLeafManager< TreeT >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
 CLeafManager< TreeType >
 CLeafManagerImpl< ManagerT >
 CLeafManagerImpl< LeafManager< const TreeT > >
 CLeafNode< T, Log2Dim >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
 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
 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!
 CLeafManager< TreeT >::LeafRange
 CLeafTopologyDiffOp< TreeType1, TreeType2 >Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees
 CLeafTopologyIntOp< TreeType1, TreeType2 >Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees
 CLevelScopeA LevelScope object sets the logging level to a given level and restores it to the current level when the object goes out of scope
 CLevelSetAdvection< GridT, FieldT, InterruptT >Hyperbolic advection of narrow-band level sets in an external velocity field
 CLevelSetFilter< LevelSetGridT >
 CLevelSetFracture< GridType, InterruptType >Level set fracturing
 CLevelSetHDDA< TreeT, NodeLevel >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
 CLevelSetMeasure< GridT, InterruptT >Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets
 CLevelSetMorphing< GridT, InterruptT >Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
 CLevelSetPruneOp< TreeT, TerminationLevel >
 CLevelSetRayIntersector< GridT, SearchImplT, NodeLevel, RayT >This class provides the public API for intersecting a ray with a narrow-band level set
 CLevelSetRayTracer< GridT, IntersectorT >A (very) simple multithreaded ray tracer specifically for narrow-band level sets
 CLevelSetSphere< GridT, InterruptT >Generates a signed distance field (or narrow band level set) to a single sphere
 CLevelSetTracker< GridT, InterruptT >Performs multi-threaded interface tracking of narrow band level sets
 CLinearOp< T >
 CLinearSearchImpl< GridT, Iterations, RealT >Implements linear iterative search for an iso-value of the level set along the direction of the ray
 CLLVMType< T >LLVM type mapping from pod types
 CLLVMType< codegen::String >
 CLLVMType< int_t< sizeof(void *)>::type * >
 CLLVMType< openvdb::math::half >
 CLLVMType< T * >
 CLLVMType< T[S]>
 CLLVMType< uint8_t >
 CLLVMType< void >
 CLocalMovePointsOp< TreeT >
 CLoggerLogger for collecting errors and warnings that occur during AX compilation
 CMagnitude< InGridT, MaskGridType, InterruptT >
 CMagnitudeExtent< VecT, false >Vector squared magnitude op to evaluate the min/max of a vector attribute and return the result as the original vector
 Cmake_index_sequence< N, Is >
 CMapDefines an affine transform and its inverse represented as a 3x3 matrix and a vec3 translation
 CMapAdapter< MapType, OpType, ResultType >Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator
 CMapBaseAbstract base class for maps
 CMappedFileHandle to control the lifetime of a memory-mapped .vdb file
 CMapRegistryThreadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function
 CMask< LOG2DIM >Bit-mask to encode active states and facilitate sequential iterators and a fast codec for I/O compression
 CBaseStencil< DerivedType, SIZE, GridT >::Mask
 CMaskCompress< ValueT, MaskT >
 CMultiResGrid< TreeType >::MaskOp
 CTreeToMerge< TreeT >::MaskPtrWrapper around unique_ptr that deep-copies mask on copy construction
 CTreeToMerge< TreeT >::MaskUnionOpDynamicNodeManager operator used to generate a mask of the input tree, but with dense leaf nodes replaced with active tiles for compactness
 CMat< SIZE, T >
 CMat2< T >
 CMat< 3, T >
 CMat< 4, double >
 CMat< 4, Real >
 CMat< 4, T >
 CMatMul
 CMatMulNormalize
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::MatrixCopyOp
 CGridTransformer::MatrixTransform
 CMatTraits< T, bool >
 CMatTraits< T, false >
 CMaximum< T >Maximum floating-point values
 CMaxOp< ValueType >
 CMeanCurvature< MapType, DiffScheme2, DiffScheme1 >Compute the mean curvature
 CMeanCurvature< GridT, MaskGridType, InterruptT >
 CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 >
 CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 >
 CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 >
 CMeshAttrTransfer
 CMeshDataAdapterConvert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
 CMeshToVoxelEdgeDataExtracts and stores voxel edge intersection data from a mesh
 CMetaDataData encoded for each of the grids associated with a segment
 CMetadataBase class for storing metadata information in a grid
 CMetaMapContainer that maps names (strings) to values of arbitrary types
 CMinMax< ValueType, Less >Templated class to compute the minimum and maximum values
 CFastSweeping< SdfGridT, ExtValueT >::MinMaxKernel
 CMinOp< ValueType >
 CMorphology< TreeType >Dilation/Erosion operations over a Trees leaf level voxel topology
 CMultiGroupFilter
 CMultiPassLeaf nodes that require multi-pass I/O must inherit from this struct
 CMultOp< ValueType >
 CMultOp< bool >
 CAttributeSet::Util::NameAndTypeAttribute and type name pair
 CFile::NameIterator
 CNanoNode< BuildT, LEVEL >Trait to map from LEVEL to node type
 CNanoNode< BuildT, 0 >
 CNanoNode< BuildT, 1 >
 CNanoNode< BuildT, 2 >
 CNanoNode< BuildT, 3 >
 CNanoToOpenVDB< ValueType >This class will serialize an OpenVDB grid into a NanoVDB grid managed by a GridHandle
 CFastSweeping< SdfGridT, ExtValueT >::SweepingKernel::NN
 CNodeThe base abstract node which determines the interface and required methods for all derived concrete nodes which comprise a valid AST
 CNodeChain< HeadT, HeadLevel >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
 CIterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueAllIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT >
 CNodeFilter
 CReadAccessor< BuildT,-1,-1,-1 >::NodeInfo
 CNodeIteratorBase< _TreeT, RootChildOnIterT >Base class for tree-traversal iterators over all nodes
 CNodeList< NodeT >This class caches tree nodes of a specific type in a linear array
 CNodeList< ChildNodeType >
 CNodeList< NodeT0 >
 CNodeList< NodeT1 >
 CNodeList< NodeT2 >
 CNodeList< NodeT3 >
 CNodeManager< GridT >NodeNanager maintains separate linear arrays of the three nodes types
 CNodeManager< TreeOrLeafManagerT, _LEVELS >To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree
 CNodeManagerLink< NodeT, LEVEL >This class is a link in a chain that each caches tree nodes of a specific type in a linear array
 CNodeManagerLink< ChildNodeType, LEVELS-1 >
 CNodeMask< Log2Dim >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
 CMorphology< TreeType >::NodeMaskOpNode 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
 CNodeList< NodeT >::NodeRange
 CGridStats< GridT, StatsT >::NodeStats
 CNodeTrait< GridOrTreeOrRootT, LEVEL >Struct to derive node type from its level in a given grid, tree or root while perserving 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 >
 CNodeUnion< ValueT, ChildT, Enable >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 >
 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.)
 CNodeUnion< ValueType, ChildNodeType >
 CNoopStats< ValueT >No-op Stats class
 CNormalize< GridT, MaskGridType, InterruptT >
 CNullCodec
 CNullDeformerNo-op deformer (adheres to the deformer interface documented in PointMove.h)
 CNullFilterA no-op filter that can be used when iterating over all indices
 CNullInterrupterBase class for interrupters
 CNullInterrupter
 Cnumeric_limits< openvdb::v9_1::math::half >
 COpAccumulator< IterT, OpT >
 COpAdd< ValueT >
 COpenGridType< BuildT >Grid trait that defines OpenVDB grids with the exact same configuration as NanoVDB grids
 COpenGridType< openvdb::PointDataIndex32 >Template specialization for the PointDataGrid
 COpenGridType< openvdb::PointIndex32 >Template specialization for the PointIndexGrid
 COpenToNanoType< T >Converts OpenVDB types to NanoVDB types, e.g. openvdb::Vec3f to nanovdb::Vec3f Template specializations are defined below
 COpenToNanoType< openvdb::Coord >Template specialization for openvdb::Coord
 COpenToNanoType< openvdb::CoordBBox >Template specialization for openvdb::CoordBBox
 COpenToNanoType< openvdb::math::BBox< T > >Template specialization for openvdb::math::BBox
 COpenToNanoType< openvdb::math::Vec3< T > >Template specialization for openvdb::math::Vec3
 COpenToNanoType< openvdb::math::Vec4< T > >Template specialization for openvdb::math::Vec4
 COpenToNanoType< openvdb::ValueMask >Template specialization for openvdb::ValueMask
 COpenToNanoVDB< OpenBuildT, NanoBuildT, OracleT, BufferT >This class will convert an OpenVDB grid into a NanoVDB grid managed by a GridHandle
 COpFactoryHelper class to simplify operator registration
 COpMagnitude< OpType, MapT >Adapter for vector-valued world-space operators to return the vector magnitude
 COpMax< ValueT >
 COpMin< ValueT >
 COpMult< ValueT >
 COpOver< ValueT >Point wise methods used to apply various compositing operations
 COpPolicyAn OpPolicy customizes the behavior of an OpFactory. This base class specifies the required interface
 COpSub< ValueT >
 CMagnitude< InGridT, MaskGridType, InterruptT >::OpT
 CNormalize< GridT, MaskGridType, InterruptT >::OpT
 COSNoise
 Costream
 CPackedMaskConstructor
 CPageStores 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
 CPagedArray< ValueT, Log2PageSize >::Page
 CPagedArray< ValueT, Log2PageSize >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
 CPagedInputStreamA 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
 CPagedOutputStreamA 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
 CPageHandleA PageHandle holds a unique ptr to a Page and a specific stream pointer to a point within the decompressed Page buffer
 CExtrema< VecT, 1 >::Pair
 CValueVoxelCIter::Parent
 CParmFactoryHelper class to simplify construction of PRM_Templates and dynamic user interfaces
 CParmListParameter template list that is always terminated
 CPartialCreateTag dispatch class that distinguishes constructors during file input
 CParticleArrayPartition particles and performs range and nearest-neighbor searches
 CParticleAtlas< PointIndexGridType >
 CParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT >
 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
 CPointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType >
 CPointArray
 CPointArrayPartitions points into BucketLog2Dim aligned buckets using a parallel radix-based sorting algorithm
 CPointAttributeVector< ValueType >Point-partitioner compatible STL vector attribute wrapper for convenience
 CPointAttrTransfer
 CPointDataNodeChain< HeadT, HeadLevel >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 >
 CPointExecutableObject 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
 CPointIndex< IntType_, Kind >Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid
 CPointIndexFilter< PointArray, TreeType >
 CPointIndexIterator< TreeType >Accelerated range and nearest-neighbor searches for point index grids
 CPointKernelAttributeArray
 CPointKernelBuffer
 CPointKernelBufferRange
 CPointKernelValue
 CPointLeafLocalDataVarious 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
 CPointPartitioner< PointIndexType, BucketLog2Dim >
 CPointSampler
 CPointsToMask< GridT, InterrupterT >Makes every voxel of a grid active if it contains a point
 CPolygonPoolCollection of quads and triangles
 CHostBuffer::Pool
 CPositionRange
 CPreconditioner< T >Base class for conjugate gradient preconditioners
 CPreconditioner< MatrixType::ValueType >
 CPrimCpyOpTBB body object for threaded primitive copy
 CMultiResGrid< TreeType >::ProlongateOp
 Cpromote< S, T >
 CPromoteContainerType< T, ContainerT >
 CPromoteContainerType< T, math::Mat3 >
 CPromoteContainerType< T, math::Mat4 >
 CPromoteContainerType< T, math::Quat >
 CPromoteContainerType< T, math::Vec2 >
 CPromoteContainerType< T, math::Vec3 >
 CPromoteContainerType< T, math::Vec4 >
 CPromoteType< T >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)
 CQuadAndTriangleDataAdapter< PointType, PolygonType >Contiguous quad and triangle data adapter class
 CQuadraticSampler
 CQuantizedUnitVecUnit vector occupying only 16 bits
 CQuat< T >
 CQuatTraits< T, bool >
 CQuatTraits< T, false >
 CQueueQueue for asynchronous output of grids to files or streams
 CRand01< FloatType, EngineType >Simple generator of random numbers over the range [0, 1)
 CRand01< double, RandomGenerator >
 CRandInt< IntType, EngineType >Simple random integer generator
 CRandomLeafFilter< PointDataTreeT, RandGenT >
 CRange< int, typename >
 CRange< 1, T >
 CRange< 2, T >
 CRange< 3, T >
 CRasterCameraA camera class that provides an interface for camera motion blur when rasterizing
 CRasterGroupsA struct that stores all include/exclude attribute names as strings and is internally converted into the resolved MultiGroupFilter
 CRasterizePoints< TransferT, TopologyT, PointFilterT, InterrupterT >
 CRay< RealT >
 CRay< RealT >
 CRay< double >
 CRayGenOp< Vec3T >
 CReadAccessor< BuildT, LEVEL0, LEVEL1, LEVEL2 >
 CReadAccessor< BuildT, 0, 1, 2 >Node caching at all (three) tree levels
 CReadAccessor< BuildT, LEVEL0, LEVEL1,-1 >
 CReadAccessor< BuildT, LEVEL0,-1,-1 >Node caching at a single tree level
 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< ValueType >
 CRealToHalf< T >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 >
 CReduceFilterOp< OpT >
 CPointsToMask< GridT, InterrupterT >::ReducePool
 CFunctionRegistry::RegisteredFunctionAn 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)
 CRelDiffCompression oracle based on relative difference
 CMultiResGrid< TreeType >::RestrictOp
 CFilm::RGBAFloating-point RGBA components in the range [0, 1]
 CRgba88-bit red, green, blue, alpha packed into 32 bit unsigned int
 CFindActiveValues< TreeT >::RootChild
 CRootData< ChildT >Struct with all the member data of the RootNode (useful during serialization of an openvdb RootNode)
 CRootNode< ChildType >
 CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, Compatible >
 CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true >
 CRootNodeCopyHelper< RootT, OtherRootT, Compatible >
 CRootNodeCopyHelper< RootT, OtherRootT, true >
 CRootNodeMask
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::RowEditorRead/write accessor to a row of this matrix
 CInternalNode< _ChildNodeType, Log2Dim >::SameConfiguration< OtherNodeType >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
 CLeafNode< T, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
 CLeafNode< bool, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
 CLeafNode< ValueMask, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
 CRootNode< ChildType >::SameConfiguration< OtherNodeType >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
 CSameInternalConfig< ChildT1, Dim1, NodeT2 >
 CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > >
 CSameLeafConfig< Dim1, NodeT2 >
 CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > >
 CSameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > >
 CSameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > >
 CSameRootConfig< ChildT1, NodeT2 >
 CSameRootConfig< ChildT1, RootNode< ChildT2 > >
 CSampleFromVoxels< TreeT, Order, UseCache >
 CSampleFromVoxels< TreeOrAccT, 0, false >Nearest neighbor, i.e. zero order, interpolator without caching
 CSampleFromVoxels< TreeOrAccT, 0, true >Nearest neighbor, i.e. zero order, interpolator with caching
 CSampler< Order, Staggered >Provises a unified interface for sampling, i.e. interpolation
 CSampleWithRounding
 CScalarMinMax< ValueT >Scalar extent op to evaluate the min/max values of a single integral or floating point attribute type
 CScalarMinMax< ValueTraits< VecT >::ElementType >
 CScalarToVectorConverter< ScalarGridType >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
 CScopedInputLockHelper class to manage input locking
 CAttributeArray::ScopedRegistryLock
 CSegment
 CFunctionBuilder::Settings
 CShallowCopyTag dispatch class that distinguishes shallow copy constructors from deep copy constructors
 CSharedOpApplier< IterT, OpT >
 CSharedOpTransformer< InIterT, OutTreeT, OpT >
 CSharpenFeaturesOpTBB body object for threaded sharp feature construction
 CSignedFloodFillOp< TreeOrLeafManagerT >
 CSOP_Node
 CSOP_NodeCacheOptions
 CSparseExtractor< OpType, DenseType >Functor-based class used to extract data that satisfies some criteria defined by the embedded OpType functor. The extractSparseTree function wraps this class
 CSparseMaskedExtractor< DenseType, MaskTreeType >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
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE
 CSparseStencilMatrix< OtherValueType, STENCIL_SIZE >
 CSparseStencilMatrix< ValueType, 4 >
 CSparseToDenseCompositor< CompositeMethod, _TreeT >
 CSplit
 CStaggeredBoxSampler
 CStaggeredPointSampler
 CStaggeredQuadraticSampler
 CStateInformation about the state of a conjugate gradient solution
 CLevelSetTracker< GridT, InterruptT >::StateLightweight struct that stores the state of the LevelSetTracker
 CStats< ValueT, Rank >
 CStealTag dispatch class that distinguishes constructors that steal
 CFixedPointCodec< OneByte, Range >::Storage< T >
 CUnitVecCodec::Storage< T >
 CNullCodec::Storage< T >
 CStringCodec< Truncate >::Storage< T >
 CGroupCodec::Storage< T >
 CTruncateCodec::Storage< T >
 CStreamMetadataContainer for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use)
 CStringAn 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
 CStringAttributeHandle
 CStringCodec< Truncate >
 CStringMetaCacheClass to compute a string->index map from all string:N metadata
 CStringMetaInserterClass to help with insertion of keyed string values into metadata
 CStringTypeTrait< Truncate >
 CStringTypeTrait< true >
 CSumMergeOp< TreeT >DynamicNodeManager operator to merge trees using a sum operation
 CSumOp< ValueType >
 CSumOp< bool >
 CSwappedCombineOp< ValueType, CombineOp >
 CFastSweeping< SdfGridT, ExtValueT >::SweepingKernelPrivate class of FastSweeping to perform concurrent fast sweeping in two directions
 CSymbolTableA 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
 CSymbolTableBlocksA 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
 CTensorTraits< T, Rank >
 CTensorTraits< T, 0 >
 CTensorTraits< T, 1 >
 CTestLeafIO< typename >
 CGridBuilder< ValueT, BuildT, StatsT >:: BuildNode< ChildT >::Tile
 CRootData< ChildT >::Tile
 CGridBuilder< ValueT, BuildT, StatsT >::BuildRoot< ChildT >::Tile
 CInternalData< ChildT, LOG2DIM >::Tile
 CTileData< ValueType >Struct that encodes a bounding box, value and level of a tile
 CRay< RealT >::TimeSpan
 CRay< RealT >::TimeSpan
 CTolerance< T >Tolerance for floating-point comparison
 CTolerance< T >Tolerance for floating-point comparison
 CTolerance< double >
 CTolerance< double >
 CTolerance< float >
 CTolerance< float >
 CTolerancePruneOp< TreeT, TerminationLevel >
 CToMaskGrid< GridType >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
 CTopologyCopyTag dispatch class that distinguishes topology copy constructors from deep copy constructors
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy1< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy2< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >
 CTransferPointAttributesOp< GridType >
 CTransferPrimitiveAttributesOp< GridType >
 CTransform
 CTransformOpTBB body object for threaded world to voxel space transformation and copy of points
 CTransformTransferThe 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
 CTree3< T, N1, N2 >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< T, N1, N2, N3 >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
 CTree4< EdgeData, 5, 4, 3 >
 CTree5< T, N1, N2, N3, N4 >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
 CTreeAdapter< _TreeType >This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type
 CTreeAdapter< Grid< _TreeType > >Partial specialization for Grid types
 CTreeAdapter< tree::ValueAccessor< _TreeType > >Partial specialization for ValueAccessor types
 CTreeBaseBase class for typed trees
 CTreeConverter< TreeType >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
 CTreeData< ROOT_LEVEL >
 CTreeData< RootT::LEVEL >
 CTreeIterTraits< TreeT, IterT >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 >
 CTreeMarcher< NodeT, RayT, AccT, CoordT >A Tree Marcher for Generic Grids
 CTreeMarcher< LeafNode< AccT::ValueType >, RayT, AccT, CoordT >
 CTreeToMerge< TreeT >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
 CTreeTraits< TreeT >Useful traits for Tree types
 CTreeTraits< const TreeT >
 CTreeValueIteratorBase< _TreeT, _ValueIterT >Base class for tree-traversal iterators over tile and voxel values
 CTricubicSampler< TreeOrAccT >Tri-cubic sampler, i.e. third order, interpolator
 CTrilinearSampler< TreeOrAccT >Tri-linear sampler, i.e. first order, interpolator
 CTrilinearTraits< ValueT, Staggered >
 CTrilinearTraits< ValueT, false >
 CTriquadraticSampler< TreeOrAccT >Tri-quadratic sampler, i.e. second order, interpolator
 Ctrue_type
 CTruncateCodec
 CTruncateTrait< T >
 CTruncateTrait< float >
 CTruncateTrait< int >
 CTruncateTrait< math::Vec3< T > >
 CTuple< SIZE, T >
 CTuple< 2, T >
 CTuple< 3, double >
 CTuple< 3, Real >
 CTuple< 3, T >
 CTuple< 4, T >
 CTypeList< Ts >A list of types (not necessarily unique)
 CVolumeTransfer< TreeTypes >::TypeResolver< T >
 CTypeToSymbol< T >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< char >
 CTypeToSymbol< codegen::String >
 CTypeToSymbol< double >
 CTypeToSymbol< float >
 CTypeToSymbol< int16_t >
 CTypeToSymbol< int32_t >
 CTypeToSymbol< int64_t >
 CTypeToSymbol< int8_t >
 CTypeToSymbol< T * >
 CTypeToSymbol< T[16]>
 CTypeToSymbol< T[2]>
 CTypeToSymbol< T[3]>
 CTypeToSymbol< T[4]>
 CTypeToSymbol< T[9]>
 CTypeToSymbol< T[S]>
 CTypeToSymbol< uint16_t >
 CTypeToSymbol< uint32_t >
 CTypeToSymbol< uint64_t >
 CTypeToSymbol< uint8_t >
 CTypeToSymbol< void >
 Chalf::uif
 CUIntTypeTrait< OneByte, T >
 CUIntTypeTrait< false, math::Vec3< T > >
 CUIntTypeTrait< false, T >
 CUIntTypeTrait< true, math::Vec3< T > >
 CUIntTypeTrait< true, T >
 CUnitRange
 CUnitVecCodec
 CUnknownCodec
 CAttributeSet::Util
 CValueAccessorBase< TreeType, IsSafe >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
 CValueAccessorBase< _TreeType, IsSafe >
 CValueAccessorBase< const TreeT, IsSafe >
 CValueAccessorBase< const TreeT, true >
 CValueAccessorBase< const TreeType, IsSafe >
 CValueAccessorBase< const TreeType, true >
 CValueAccessorBase< IntTreeT, true >
 CValueAccessorBase< TreeT, true >
 CValueAccessorBase< TreeType, true >
 CInternalNode< _ChildNodeType, Log2Dim >::ValueAll
 CLeafNode< T, Log2Dim >::ValueAll
 CPagedArray< ValueT, Log2PageSize >::ValueBuffer
 CLeafNode< bool, Log2Dim >::ValueConverter< ValueType >ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
 CInternalNode< _ChildNodeType, Log2Dim >::ValueConverter< OtherValueType >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
 CLeafNode< ValueMask, Log2Dim >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
 CGrid< _TreeType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different value type, T
 CRootNode< ChildType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a RootNode having the same child hierarchy as this node but a different value type, T
 CTree< _RootNodeType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T
 CLeafNode< T, Log2Dim >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
 CTree< _RootNodeType >::ValueConverter< Int32 >
 CIndexIter< IteratorT, FilterT >::ValueIndexIterA forward iterator over array indices from a value iterator (such as ValueOnCIter)
 CValueMaskDummy type for a voxel with a binary mask value, e.g. the active state
 CValueMask
 CValueMaskFilter< On >Index filtering on active / inactive state of host voxel
 CLeafNode< T, Log2Dim >::ValueOff
 CInternalNode< _ChildNodeType, Log2Dim >::ValueOff
 CInternalNode< _ChildNodeType, Log2Dim >::ValueOn
 CLeafNode< T, Log2Dim >::ValueOn
 CValueTraits< T, bool >
 CValueTraits< T, false >
 CValueTypeTraits< T, typename >
 CValueTypeTraits< T, void_t< typename T::value_type > >
 CValueVoxelCIterA forward iterator over array indices in a single voxel
 CVdbPrimCIteratorIterator over const VDB primitives on a geometry detail
 CVec3< T >A simple vector class with three double components, similar to openvdb::math::Vec3
 CVec3< double >
 CVec4< T >A simple vector class with three double components, similar to openvdb::math::Vec4
 CVector< T >Lightweight, variable-length vector
 CVector< ValueType >
 CVectorToScalarConverter< VectorGridType >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< VecGridT >Metafunction to convert a vector-valued grid type to a scalar grid type
 CVecTraits< T, bool >
 CVecTraits< T, false >
 CVelocityIntegrator< GridT, Staggered, SampleOrder >Performs Runge-Kutta time integration of variable order in a static velocity field
 CVelocitySampler< GridT, Staggered, Order >
 CVelocitySampler< GridT, Staggered, SampleOrder >
 CVersionBit-compacted representation of all three version numbers
 CVersionId
 CVertexNormalOpTBB body object for threaded vertex normal generation
 CVisitor< Derived, ConstVisit >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
 CVisitor< ComputeGenerator >
 CVisitor< std::conditional< std::is_same< Derived, void >::value, VisitNodeType< NodeT, OpT >, Derived >::type >
 CVolumeAdvection< VelocityGridT, StaggeredVelocity, InterrupterType >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
 CVolumeExecutableObject 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
 CVolumeHDDA< TreeT, RayT, ChildNodeLevel >Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume
 CVolumeHDDA< openvdb::v9_1::tree::Tree, RayType, NodeLevel >
 CVolumeHDDA< TreeT, RayT, 0 >Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume
 CVolumeKernelBufferThe second volume kernel, responsible for providing the core layer of SIMD optimisations by invoking this kernel across a range of values
 CVolumeKernelNodeThe 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
 CVolumeKernelValueThe primary volume kernel. This function holds the generated body of AX programs
 CVolumeRayIntersector< GridT, NodeLevel, RayT >This class provides the public API for intersecting a ray with a generic (e.g. density) volume
 CVolumeRender< IntersectorT, SamplerT >A (very) simple multithreaded volume render specifically for scalar density
 CVolumeToMeshMesh any scalar grid that has a continuous isosurface
 CVolumeTransfer< TreeTypes >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
 CVolumeTransfer< TreeT >VolumeTransfer specialization for a single target volume
 CInternalNode< _ChildNodeType, Log2Dim >::VoxelizeActiveTiles
 CDerivedFunction