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 |
CActivationOp< TreeType > | |
CAdaptivePrimBuilder | |
►CArchive | Grid serializer/unserializer |
CFile | Grid archive associated with a file on disk |
CStream | Grid archive associated with arbitrary input and output streams (not necessarily files) |
►CBaseCamera | Abstract base class for the perspective and orthographic cameras |
COrthographicCamera | |
CPerspectiveCamera | |
►CRootNodeMask::BaseIterator | |
CRootNodeMask::DenseIterator | |
CRootNodeMask::OffIterator | |
CRootNodeMask::OnIterator | |
►CBaseMaskIterator< NodeMask > | Base class for the bit mask iterators |
CDenseMaskIterator< NodeMask > | |
COffMaskIterator< NodeMask > | |
COnMaskIterator< NodeMask > | |
►CBaseShader | Abstract base class for the shaders |
CDiffuseShader | Simple diffuse Lambertian surface shader |
CMatteShader | Shader that produces a simple matte |
CNormalShader | Color shader that treats the surface normal (x, y, z) as an RGB color |
CPositionShader | |
CBaseStencil< _GridType, StencilType > | |
►CBaseStencil< GridT, BoxStencil< GridT > > | |
CBoxStencil< GridT > | |
►CBaseStencil< GridType, BoxStencil< GridType > > | |
CBoxStencil< GridType > | |
►CBaseStencil< GridType, CurvatureStencil< GridType > > | |
CCurvatureStencil< GridType > | |
►CBaseStencil< GridType, DenseStencil< GridType > > | |
CDenseStencil< GridType > | Dense stencil of a given width |
►CBaseStencil< GridType, FourthOrderDenseStencil< GridType > > | |
CFourthOrderDenseStencil< GridType > | |
►CBaseStencil< GridType, GradStencil< GridType > > | |
CGradStencil< GridType > | |
►CBaseStencil< GridType, NineteenPointStencil< GridType > > | |
CNineteenPointStencil< GridType > | |
►CBaseStencil< GridType, SecondOrderDenseStencil< GridType > > | |
CSecondOrderDenseStencil< GridType > | |
►CBaseStencil< GridType, SevenPointStencil< GridType > > | |
CSevenPointStencil< GridType > | |
►CBaseStencil< GridType, SixthOrderDenseStencil< GridType > > | |
CSixthOrderDenseStencil< GridType > | |
►CBaseStencil< GridType, ThirteenPointStencil< GridType > > | |
CThirteenPointStencil< GridType > | |
►CBaseStencil< GridType, WenoStencil< GridType > > | |
CWenoStencil< GridType > | This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test |
CBBox< Vec3T > | Axis-aligned bounding box |
CBBox< Vec3d > | |
CBIAS_SCHEME< bgs > | |
CBIAS_SCHEME< FIRST_BIAS > | |
CBIAS_SCHEME< HJWENO5_BIAS > | |
CBIAS_SCHEME< SECOND_BIAS > | |
CBIAS_SCHEME< THIRD_BIAS > | |
CBIAS_SCHEME< WENO5_BIAS > | |
CBlindData< VisibleT, BlindT > | |
CBoxSampler | |
CLeafNode< T, Log2Dim >::Buffer | Stores the actual values in the LeafNode. Its dimension it fixed to 2^(3*Log2Dim) |
CLeafNode< bool, Log2Dim >::Buffer | |
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, boost::mpl::size< SubtreeT >::value==1 > | |
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< T, math::Vec2< T > > | |
CCanConvertType< T, math::Vec3< T > > | |
CCanConvertType< T, math::Vec4< T > > | |
CCanConvertType< T0, math::Vec2< T1 > > | |
CCanConvertType< T0, math::Vec3< T1 > > | |
CCanConvertType< T0, math::Vec4< T1 > > | |
CLeafNode< T, Log2Dim >::ChildAll | |
CInternalNode< _ChildNodeType, Log2Dim >::ChildAll | |
CInternalNode< _ChildNodeType, Log2Dim >::ChildOff | |
CLeafNode< T, Log2Dim >::ChildOff | |
CInternalNode< _ChildNodeType, Log2Dim >::ChildOn | |
CLeafNode< T, Log2Dim >::ChildOn | |
CClosestPointDist< IntLeafT > | |
CClosestPointProjector< CptGridT > | |
CClosestSurfacePoint< GridT > | Accelerated closest surface point queries for narrow band level sets. Supports queries that originate at arbitrary worldspace locations, is not confined to the narrow band region of the input volume geometry |
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 |
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 > | |
CCompoundMap< T1, T2 > | 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 > | |
CConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType > | |
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 |
CContourTracer< FloatTreeT, InterruptT > | TBB body object that partitions a volume into 2D slices that can be processed in parallel and marks the exterior contour of disjoint voxel sets in each slice |
CCoord | Signed (x, y, z) 32-bit integer coordinates |
CCoordBBox | Axis-aligned bounding box of signed integer coordinates |
CCopyableOpApplier< IterT, OpT > | |
CCopyableOpTransformer< InIterT, OutTreeT, OpT > | |
CCopyActiveVoxelsOp< TreeType > | |
CCopyConstness< FromType, ToType > | |
CCopyConstness< const FromType, ToType > | |
CCopyFromDense< _TreeT, _DenseT > | Copy the values from a dense grid into an OpenVDB tree |
CCopyToDense< _TreeT, _DenseT > | Copy an OpenVDB tree into an existing dense grid |
CCountPoints | Counts the total number of points per leaf, accounts for cells with multiple points |
CCountRegions< IntTreeT > | Counts the total number of points per collapsed region |
CCpt< InGridT, MaskGridType, InterruptT > | Compute the closest-point transform of a scalar grid |
CCPT< MapType, DiffScheme > | Compute the closest-point transform to a level set |
CCPT_RANGE< MapType, DiffScheme > | Compute the closest-point transform to a level set |
►CCsgVisitorBase< TreeType > | |
CCsgDiffVisitor< TreeType > | |
CCsgIntersectVisitor< TreeType > | |
CCsgUnionVisitor< TreeType > | |
CCurl< GridT, MaskGridType, InterruptT > | Compute the curl of a vector grid |
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< 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 |
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, LeafT::TOTAL > | |
CDDA< RayT, NodeT::TOTAL > | |
CDDA< RayType, NodeT::TOTAL > | |
CDelta< T > | Delta for small floating-point offsets |
CDelta< double > | |
CDelta< float > | |
►CDenseBase< ValueT, Layout > | Base class for Dense which is defined below |
CDense< ValueT, Layout > | Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below |
CDenseBase< ValueT, LayoutXYZ > | Partial template specialization of DenseBase |
CDenseBase< ValueT, LayoutZYX > | Partial template specialization of DenseBase |
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 |
CDimToWord< Log2Dim > | Mapping from a Log2Dim to a data type of size 2^Log2Dim bits |
CDimToWord< 3 > | |
CDimToWord< 4 > | |
CDimToWord< 5 > | |
CDimToWord< 6 > | |
CDiracDelta< RealT > | Smeared-out and continuous Dirac Delta function |
CDiscreteField< VelGridT, Interpolator > | Thin wrapper class for a velocity grid |
CDivergence< InGridT, MaskGridType, InterruptT > | Compute the divergence of a vector grid |
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< 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< AccType, tools::openvdb::v2_3_0::tools::BoxSampler > | |
CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT > | Specialization of DualGridSampler for construction from a ValueAccessor type |
CMeshToVoxelEdgeData::EdgeData | Internal edge data type |
CEnrightField< ScalarT > | Analytical, divergence-free and periodic vecloity field |
►Cexception | |
►CException | |
CArithmeticError | |
CIllegalValueException | |
CIndexError | |
CIoError | |
CKeyError | |
CLookupError | |
CNotImplementedError | |
CReferenceError | |
CRuntimeError | |
CTypeError | |
CValueError | |
CExpandNB< FloatTreeT > | TBB body object to expand the level set narrow band |
CExtractAll< _ResultTreeType, DenseValueType > | Simple utility class used by extractSparseTreeWithMask |
CFilm | A simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM or EXR file output |
CFilter< GridT, MaskT, InterruptT > | Volume filtering (e.g., diffusion) with optional alpha masking |
CFlagUsedPoints | |
CFogVolumeOp< ValueType > | |
CFormattedInt< IntT > | I/O manipulator that formats integer values with thousands separators |
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 | |
CNormalize< GridT, MaskGridType, InterruptT >::Functor | |
CGenBoundaryMask< SrcTreeT > | |
CMeshToVoxelEdgeData::GenEdgeData | |
CGenericMap | A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators |
CGenPoints< TreeT, LeafManagerT > | |
CGenPolygons< LeafManagerT, PrimBuilder > | |
CGenSeamMask< TreeT, LeafManagerT > | |
CGenTileMask< TreeT > | |
CGenTopologyMask< SrcTreeT > | |
CGetVal< IterT, StatsT > | |
CGetValImpl< T, IsVector > | |
CGetValImpl< T, false > | |
CGetValImpl< T, true > | |
CGradient< InGridT, MaskGridType, InterruptT > | Compute the gradient of a scalar grid |
CGradient< MapType, DiffScheme > | 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< 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 |
CGridDescriptor | |
CGridNamePred | Predicate functor that returns true for grids that have a specified name |
CGridOperator< InGridT, MaskGridType, OutGridT, MapT, OperatorT, InterruptT > | Apply an operator on an input grid to produce an output grid with the same topology but a possibly different value type |
►CGridResampler | |
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 |
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 |
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 |
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 |
CHermite | Quantized Hermite data object that stores compressed intersection information (offsets and normlas) for the up-wind edges of a voxel. (Size 10 bytes) |
CHistogram | This class computes a histogram, with a fixed interval width, of a population of floating-point values |
CHistOp< IterT, ValueOp > | |
CHomogeneousMatMul | |
CInactivePrune< ValueType > | Helper class for use with Tree::pruneOp() to replace inactive branches with more memory-efficient inactive tiles with the provided value |
CInteriorMaskOp< TreeType > | |
CInternalNode< _ChildNodeType, Log2Dim > | |
CIntersectingVoxelCleaner< FloatTreeT > | TBB body object that removes intersecting voxels that were set via voxelization of self-intersecting parts of a mesh |
CIntersectingVoxelSign< FloatTreeT > | TBB body object that traversers all intersecting voxels (defined by the intersectingVoxelsGrid) and potentially flips their sign, by comparing the "closest point" directions of outside-marked and non-intersecting neighboring voxels |
CInvertedTree< HeadT, HeadLevel > | |
CInvertedTree< HeadT, 1 > | |
Cis_diagonal_jacobian< T > | |
Cis_double< T > | |
Cis_double< double > | |
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_scale< T > | |
Cis_scale< ScaleMap > | |
Cis_scale_translate< T > | |
Cis_scale_translate< ScaleTranslateMap > | |
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 |
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 > | |
CBIAS_SCHEME< FIRST_BIAS >::ISStencil< GridType > | |
CBIAS_SCHEME< SECOND_BIAS >::ISStencil< GridType > | |
CBIAS_SCHEME< THIRD_BIAS >::ISStencil< GridType > | |
CBIAS_SCHEME< WENO5_BIAS >::ISStencil< GridType > | |
CBIAS_SCHEME< HJWENO5_BIAS >::ISStencil< GridType > | |
CLeafManager< TreeT >::LeafRange::Iterator | |
►CIteratorBase< MaskIterT, NodeT > | Base class for iterators over internal and leaf nodes |
CDenseIteratorBase< MaskIterT, IterT, NodeT, SetItemT, UnsetItemT > | Base class for dense iterators over internal and leaf nodes |
CSparseIteratorBase< MaskIterT, IterT, NodeT, ItemT > | Base class for sparse iterators over internal and leaf nodes |
►CSparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT >, NodeT, bool > | |
CLeafNode< bool, Log2Dim >::ChildIter< MaskIterT, NodeT > | Leaf nodes have no children, so their child iterators have no get/set accessors |
►CSparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT, TagT >, NodeT, ValueType > | |
CLeafNode< T, Log2Dim >::ChildIter< MaskIterT, NodeT, TagT > | Leaf nodes have no children, so their child iterators have no get/set accessors |
►CSparseIteratorBase< MaskIterT, ChildIter< NodeT, ChildT, MaskIterT, TagT >, NodeT, ChildT > | |
CInternalNode< _ChildNodeType, Log2Dim >::ChildIter< NodeT, ChildT, MaskIterT, TagT > | |
►CSparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT >, NodeT, ValueT > | |
CLeafNode< bool, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT > | |
►CSparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT, TagT >, NodeT, ValueT > | |
CLeafNode< T, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT, TagT > | |
►CSparseIteratorBase< MaskIterT, ValueIter< NodeT, ValueT, MaskIterT, TagT >, NodeT, ValueT > | |
CInternalNode< _ChildNodeType, Log2Dim >::ValueIter< NodeT, ValueT, MaskIterT, TagT > | |
►CIteratorBase< MaskDenseIter, NodeT > | |
►CDenseIteratorBase< MaskDenseIter, DenseIter< NodeT, ValueT >, NodeT, void, ValueT > | |
CLeafNode< bool, Log2Dim >::DenseIter< NodeT, ValueT > | |
►CIteratorBase< MaskDenseIterator, NodeT > | |
►CDenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ChildT, ValueT, TagT >, NodeT, ChildT, ValueT > | |
CInternalNode< _ChildNodeType, Log2Dim >::DenseIter< NodeT, ChildT, ValueT, TagT > | |
►CDenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ValueT, TagT >, NodeT, void, ValueT > | |
CLeafNode< T, Log2Dim >::DenseIter< NodeT, ValueT, TagT > | |
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< IterT, AuxT > | |
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< tree::TreeValueIteratorBase< TreeT, ValueIterT > > | |
CIterTraits< typename PrevIterT::NonConstNodeType, PrevIterT > | |
CLaplacian< GridT, MaskGridType, InterruptT > | |
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< ScaleMap, DiffScheme > | |
CLaplacian< ScaleTranslateMap, DiffScheme > | |
CLaplacian< TranslationMap, DiffScheme > | |
CLaplacian< UniformScaleMap, DiffScheme > | |
CLaplacian< UniformScaleTranslateMap, DiffScheme > | |
CLaplacian< UnitaryMap, DiffScheme > | |
CLeafBS< IntLeafT > | |
CLeafIteratorBase< TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels) |
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 |
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 |
CLeafManager< TreeT >::LeafRange | |
CLeafTopologyDiffOp< TreeType > | |
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 |
CLegacyFrustum | LegacyFrustum class used at DreamWorks for converting old vdb files |
CLevelSetAdvection< GridT, FieldT, InterruptT > | Hyperbolic advection of narrow-band level sets in an external velocity field |
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 |
CLevelSetPrune< ValueType > | Helper class for use with Tree::pruneOp() to prune any branches whose values are all inactive and replace each with an inactive tile whose value is equal in magnitude to the background value and whose sign is equal to that of the first value encountered in the (inactive) child |
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 |
CLevelSetFilter< GridT, MaskT, InterruptT > | 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 |
CLinearSearchImpl< GridT, Iterations, RealT > | Implements linear iterative search for an iso-value of the level set along along the direction of the ray |
CMagnitude< InGridT, MaskGridType, InterruptT > | |
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 |
►CMapBase | Abstract base class for maps |
CAffineMap | A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation |
CNonlinearFrustumMap | This map is composed of three steps. Frist it will take a box of size (Lx X Ly X Lz) defined by an member data bounding box and map it into a frustum with near plane (1 X Ly/Lx) and precribed depth Then this frustum is transformed by an internal second map: most often a uniform scale, but other affects can be achieved by accumulating translation, shear and rotation: these are all applied to the second map |
►CScaleMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions |
CUniformScaleMap | A specialized Affine transform that scales along the principal axis the scaling is 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 |
CUniformScaleTranslateMap | A specialized Affine transform that uniformaly scales along the principal axis and then translates the result |
CTranslationMap | A specialized linear transform that performs a translation |
CUnitaryMap | A specialized linear transform that performs a unitary maping i.e. rotation and or reflection |
CMapPoints< Int16TreeT > | Computes the point list indices for the index tree |
CMapRegistry | Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function |
CMaskEdges< BoolTreeT > | |
►CMat< SIZE, T > | |
CMat3< double > | |
CMat2< T > | |
►CMat< 3, T > | |
CMat3< T > | 3x3 matrix class |
►CMat< 4, double > | |
CMat4< double > | |
►CMat< 4, Real > | |
CMat4< Real > | |
►CMat< 4, T > | |
CMat4< T > | 4x4 -matrix class |
CMathOp< IterT, OpT > | |
CMatMul | |
CMatMulNormalize | |
CGridTransformer::MatrixTransform | |
CMaxOp< ValueType > | |
CMeanCurvature< GridT, MaskGridType, InterruptT > | |
CMeanCurvature< MapType, DiffScheme2, DiffScheme1 > | Compute the mean curvature |
CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 > | |
CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 > | |
CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 > | |
CMergeBufferOp< TreeType, ValueType > | |
CMergeVoxelRegions< TreeT, LeafManagerT > | |
CMeshToVolume< FloatGridT, InterruptT > | |
CMeshToVoxelEdgeData | Extracts and stores voxel edge intersection data from a mesh |
CMeshVoxelizer< FloatTreeT, InterruptT > | TBB body object to voxelize a mesh of triangles and/or quads into a collection of VDB grids, namely a squared distance grid, a closest primitive grid and an intersecting voxels grid (masks the mesh intersecting voxels) |
►CMetadata | Base class for storing metadata information in a grid |
CTypedMetadata< T > | Templated metadata class to hold specific types |
CUnknownMetadata | Subclass to read (and ignore) data of an unregistered type |
►CMetaMap | Provides functionality storing type agnostic metadata information. Grids and other structures can inherit from this to attain metadata functionality |
►CGridBase | Abstract base class for typed grids |
CGrid< typename > | Container class that associates a tree with a transform and metadata |
CMinMaxVoxel< TreeType > | Threaded operator that finds the minimum and maximum values among the active leaf-level voxels of a grid |
CMinOp< TreeType, ValueType > | |
CMinOp< ValueType > | |
CMorphology< TreeType > | |
CMovePoints | |
CMultOp< ValueType > | |
CFile::NameIterator | |
CNodeBS | |
CNodeChain< HeadType, HeadLevel > | NodeChain<RootNodeType, RootNodeType::LEVEL>::Type is a boost::mpl::vector 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::ValueAllIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT > | |
CIterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT > | |
CNodeIteratorBase< _TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all nodes |
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 |
CNodeUnionImpl< ValueIsClass, ValueT, ChildT > | |
►CNodeUnionImpl< boost::is_class< ValueT >::value, ValueT, ChildT > | |
CNodeUnion< ValueT, ChildT > | |
►CNodeUnionImpl< boost::is_class< ValueType >::value, ValueType, ChildNodeType > | |
CNodeUnion< ValueType, ChildNodeType > | |
CNodeUnionImpl< false, ValueT, ChildT > | |
CNodeUnionImpl< true, ValueT, ChildT > | |
CNonUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | Non-uniform scatters of point in the active voxels. The local point count is implicitly defined as a product of of a global density and the local voxel (or tile) value |
CNormalize< GridT, MaskGridType, InterruptT > | |
CNullInterrupter | Dummy NOOP interrupter class defining interface |
COffsetOp< ValueType > | |
COpAccumulator< IterT, OpT > | |
COpAdd< ValueT > | |
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 |
COpSub< ValueT > | |
CMagnitude< InGridT, MaskGridType, InterruptT >::OpT | |
CNormalize< GridT, MaskGridType, InterruptT >::OpT | |
CPartGen< SrcTreeT > | |
CParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT > | |
CPartOp | |
CPointAccessor | |
CPointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType > | |
CPointListCopy | |
CPointListTransform | |
►CPointSampler | |
CTileSampler< PointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership |
CPointTransform | |
CPolygonPool | Collection of quads and triangles |
CPrimCpy | |
Cpromote< S, T > | |
CPropagateSign< FloatTreeT, InterruptT > | TBB body object that performs a parallel flood fill |
CQuadraticSampler | |
CQuantizedUnitVec | |
CQuat< T > | |
CQueue | Queue for asynchronous output of grids to files or streams |
CRand01< FloatType, EngineType > | Simple generator of random numbers over the range [0, 1) |
CRandInt< EngineType > | Simple random integer generator |
CRay< RealT > | |
CRay< double > | |
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 > | |
CRemapIndices | |
CRenormOp< GridType, ValueType > | |
CReturnValue< T > | |
CFilm::RGBA | Floating-point RGBA components in the range [0, 1] |
CRootNode< ChildType > | |
CRootNodeCombineHelper< typename, typename, typename, bool > | |
CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true > | |
CRootNodeCopyHelper< typename, typename, bool > | |
CRootNodeCopyHelper< RootT, OtherRootT, true > | |
CRootNodeMask | |
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 |
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 |
CSameInternalConfig< typename, Index, typename > | |
CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > > | |
CSameLeafConfig< Index, typename > | |
CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > > | |
CSameRootConfig< typename, typename > | |
CSameRootConfig< ChildT1, RootNode< ChildT2 > > | |
►CSampler | |
CTileSampler< Sampler, TreeT > | A TileSampler wraps a grid sampler of another type (BoxSampler, QuadraticSampler, etc.), and for samples that fall within a given tile of the grid, it returns a cached tile value instead of accessing the grid |
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 |
CSDFPrune< ValueType > | |
CSeamWeights< TreeT > | |
CShallowCopy | |
CSharedOpApplier< IterT, OpT > | |
CSharedOpTransformer< InIterT, OutTreeT, OpT > | |
CShellVoxelCleaner< FloatTreeT > | TBB body object that removes non-intersecting voxels that where set by rasterizing self-intersecting parts of the mesh |
CSignData< TreeT, LeafManagerT > | |
CSignMask< FloatTreeT, InterruptT > | TBB body object that that finds seed points for the parallel flood fill |
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 suppiled maks in the form of a sparse tree. The extractSparseTreeWithMask function wraps this class |
CSparseToDenseCompositor< CompositeMethod, _TreeT > | |
CSqrtAndScaleOp< ValueType > | |
CStaggeredBoxSampler | |
►CStaggeredPointSampler | |
CTileSampler< StaggeredPointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership |
CStaggeredQuadraticSampler | |
CStats | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values |
CStatsOp< IterT, ValueOp > | |
CSumOp< ValueType > | |
CSwappedCombineOp< ValueType, CombineOp > | |
CTagSeamEdges< TreeT > | |
CTestLeafIO< typename > | |
CRay< RealT >::TimeSpan | |
CToBoolGrid< GridType > | ToBoolGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value type of bool |
CTolerance< T > | Tolerance for floating-point comparison |
CTolerance< ValueType > | |
CTolerance< double > | |
CTolerance< float > | |
CTolerancePrune< ValueType, TerminationLevel > | Helper class for use with Tree::pruneOp() to replace constant branches (to within the provided tolerance) with more memory-efficient tiles |
CTopologyCopy | |
CTransform | Calculate an axis-aligned bounding box in index space from a bounding sphere in world space |
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 |
►CTreeBase | Base class for typed trees |
CTree< _RootNodeType > | |
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 > | |
CTreeTraits< TreeT > | Useful traits for Tree types |
CTreeTraits< const TreeT > | |
CTreeValueIteratorBase< _TreeT, ValueIterT > | Base class for tree-traversal iterators over tile and voxel values |
CTrimOp< ValueType > | |
CTuple< SIZE, T > | |
►CTuple< 2, T > | |
CVec2< T > | |
►CTuple< 3, double > | |
CVec3< double > | |
►CTuple< 3, Real > | |
CVec3< Real > | |
►CTuple< 3, T > | |
CVec3< T > | |
►CTuple< 4, T > | |
CVec4< T > | |
CTupleAbs< SIZE, T, IsInteger > | Helper class to compute the absolute value of a Tuple |
CTupleAbs< SIZE, T, true > | |
CUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes: |
CUniformPrimBuilder | |
CUniquePtr< T > | |
CUniquePtr< openvdb::Vec3s > | |
CUpdatePoints | |
►CValueAccessorBase< TreeType > | 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 |
CValueAccessor< TreeType > | |
►CValueAccessor< TreeType, TreeType::DEPTH-1, tbb::spin_mutex > | |
CValueAccessorRW< TreeType > | This accessor is thread-safe (at the cost of speed) for both reading and writing to a tree. That is, multiple threads may safely access a single, shared ValueAccessorRW |
►CValueAccessorBase< _TreeType > | |
CValueAccessor< _TreeType, CacheLevels, MutexType > | |
►CValueAccessor0< TreeType > | ValueAccessor with no mutex and no node caching |
CValueAccessor< TreeType, 0, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and no cache levels |
CValueAccessor1< TreeType, L0 > | Value accessor with one level of node caching |
CValueAccessor2< TreeType, L0, L1 > | Value accessor with two levels of node caching |
CValueAccessor3< TreeType, L0, L1, L2 > | Value accessor with three levels of node caching |
►CValueAccessor1< TreeType > | |
CValueAccessor< TreeType, 1, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and one cache level |
►CValueAccessor2< TreeType > | |
CValueAccessor< TreeType, 2, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and two cache levels |
►CValueAccessor3< TreeType > | |
CValueAccessor< TreeType, 3, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and three cache levels |
►CValueAccessorBase< BoolTreeT > | |
CValueAccessor< BoolTreeT > | |
►CValueAccessorBase< const BoolTreeT > | |
CValueAccessor< const BoolTreeT > | |
►CValueAccessorBase< const Int16TreeT > | |
CValueAccessor< const Int16TreeT > | |
►CValueAccessorBase< const IntTreeT > | |
CValueAccessor< const IntTreeT > | |
►CValueAccessorBase< const TreeT > | |
CValueAccessor< const TreeT > | |
►CValueAccessorBase< FloatTreeT > | |
CValueAccessor< FloatTreeT > | |
►CValueAccessorBase< Int16TreeT > | |
CValueAccessor< Int16TreeT > | |
►CValueAccessorBase< IntTreeT > | |
CValueAccessor< IntTreeT > | |
►CValueAccessorBase< TreeT > | |
CValueAccessor< TreeT > | |
CLeafNode< T, Log2Dim >::ValueAll | |
CInternalNode< _ChildNodeType, Log2Dim >::ValueAll | |
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 |
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 |
CGrid< typename >::ValueConverter< OtherValueType > | ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid 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 |
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 |
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 |
CTree< _RootNodeType >::ValueConverter< Int32 > | |
CInternalNode< _ChildNodeType, Log2Dim >::ValueOff | |
CLeafNode< T, Log2Dim >::ValueOff | |
CInternalNode< _ChildNodeType, Log2Dim >::ValueOn | |
CLeafNode< T, Log2Dim >::ValueOn | |
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 |
CVecTraits< T > | |
CVecTraits< math::Vec2< T > > | |
CVecTraits< math::Vec3< T > > | |
CVecTraits< math::Vec4< T > > | |
CVelocityIntegrator< GridT, StaggeredVelocity > | Performs runge-kutta time integration of variable order in a static velocity field |
CVelocitySampler< GridT, StaggeredVelocity > | |
CVersionId | |
CVolumeHDDA< TreeT, RayT, ChildNodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume |
CVolumeHDDA< openvdb::v2_3_0::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 |
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 |
CVolumeToMesh | Mesh any scalar grid that has a continuous isosurface |
CVoxelSignOp< ValueType > | |