▼Nopenvdb | |
▼Nv6_0 | |
►Ncompression | |
CPage | Stores a variable-size, compressed, delayed-load Page of data that is loaded into memory when accessed. Access to the Page is thread-safe as loading and decompressing the data is protected by a mutex |
CPagedInputStream | A Paging wrapper to std::istream that is responsible for reading from a given input stream and creating Page objects and PageHandles that reference those pages for delayed reading |
CPagedOutputStream | A Paging wrapper to std::ostream that is responsible for writing from a given output stream at intervals set by the PageSize. As Pages are variable in size, they are flushed to disk as soon as sufficiently large |
CPageHandle | A PageHandle holds a unique ptr to a Page and a specific stream pointer to a point within the decompressed Page buffer |
►Nio | |
CArchive | Grid serializer/unserializer |
►CFile | Grid archive associated with a file on disk |
CNameIterator | |
CGridDescriptor | |
CHalfReader | |
CHalfReader< false, T > | Partial specialization for non-floating-point types (no half to float promotion) |
CHalfReader< true, T > | Partial specialization for floating-point types |
CHalfWriter | |
CHalfWriter< false, T > | Partial specialization for non-floating-point types (no float to half quantization) |
CHalfWriter< true, T > | Partial specialization for floating-point types |
CMappedFile | Handle to control the lifetime of a memory-mapped .vdb file |
CMultiPass | Leaf nodes that require multi-pass I/O must inherit from this struct |
CQueue | Queue for asynchronous output of grids to files or streams |
CRealToHalf | RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types |
CRealToHalf< double > | |
CRealToHalf< float > | |
CRealToHalf< Vec2d > | |
CRealToHalf< Vec2s > | |
CRealToHalf< Vec3d > | |
CRealToHalf< Vec3s > | |
CStream | Grid archive associated with arbitrary input and output streams (not necessarily files) |
CStreamMetadata | Container for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use) |
CTempFile | Output stream to a unique temporary file |
►Nlogging | |
►Ninternal | |
CColoredPatternLayout | Log4cplus layout that outputs text in different colors for different log levels, using ANSI escape codes |
CLevelScope | A LevelScope object sets the logging level to a given level and restores it to the current level when the object goes out of scope |
►Nmath | |
►Ninternal | |
CLegacyFrustum | LegacyFrustum class used at DreamWorks for converting old vdb files |
CReturnValue | |
►Npcg | |
►Ninternal | |
CCopyOp | |
CFillOp | |
CLinearOp | |
CIncompleteCholeskyPreconditioner | Preconditioner using incomplete Cholesky factorization |
CJacobiPreconditioner | Diagonal preconditioner |
CPreconditioner | Base class for conjugate gradient preconditioners |
►CSparseStencilMatrix | Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE |
CConstRow | Read-only accessor to a row of this matrix |
CConstValueIter | Iterator over the stored values in a row of this matrix |
CIsFiniteOp | |
CMatrixCopyOp | |
CRowEditor | Read/write accessor to a row of this matrix |
CState | Information about the state of a conjugate gradient solution |
►CVector | Lightweight, variable-length vector |
CDeterministicDotProductOp | |
CInfNormOp | |
CIsFiniteOp | |
CAffineMap | A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation |
CBaseStencil | |
CBBox | Axis-aligned bounding box |
►CBIAS_SCHEME | |
CISStencil | |
►CBIAS_SCHEME< FIRST_BIAS > | |
CISStencil | |
►CBIAS_SCHEME< HJWENO5_BIAS > | |
CISStencil | |
►CBIAS_SCHEME< SECOND_BIAS > | |
CISStencil | |
►CBIAS_SCHEME< THIRD_BIAS > | |
CISStencil | |
►CBIAS_SCHEME< WENO5_BIAS > | |
CISStencil | |
CBoxStencil | |
CCompoundMap | Creates the composition of two maps, each of which could be a composition. In the case that each component of the composition classified as linear an acceleration AffineMap is stored |
CConversion | Dummy class for tag dispatch of conversion constructors |
CCoord | Signed (x, y, z) 32-bit integer coordinates |
►CCoordBBox | Axis-aligned bounding box of signed integer coordinates |
CIterator | Iterator over the Coord domain covered by a CoordBBox |
CCPT | Compute the closest-point transform to a level set |
CCPT_RANGE | Compute the closest-point transform to a level set |
CCurl | Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map |
CCurl< UniformScaleMap, CD_2ND > | Full template specialization of Curl |
CCurl< UniformScaleMap, DiffScheme > | Partial template specialization of Curl |
CCurl< UniformScaleTranslateMap, CD_2ND > | Full template specialization of Curl |
CCurl< UniformScaleTranslateMap, DiffScheme > | Partial template specialization of Curl |
CCurvatureStencil | |
CD1 | |
CD1< BD_1ST > | |
CD1< BD_2ND > | |
CD1< BD_3RD > | |
CD1< BD_HJWENO5 > | |
CD1< BD_WENO5 > | |
CD1< CD_2ND > | |
CD1< CD_2NDT > | |
CD1< CD_4TH > | |
CD1< CD_6TH > | |
CD1< FD_1ST > | |
CD1< FD_2ND > | |
CD1< FD_3RD > | |
CD1< FD_HJWENO5 > | |
CD1< FD_WENO5 > | |
CD1Vec | |
CD1Vec< CD_2ND > | |
CD1Vec< CD_2NDT > | |
CD1Vec< CD_4TH > | |
CD1Vec< CD_6TH > | |
CD2 | |
CD2< CD_FOURTH > | |
CD2< CD_SECOND > | |
CD2< CD_SIXTH > | |
CDDA | A Digital Differential Analyzer specialized for OpenVDB grids |
CDelta | Delta for small floating-point offsets |
CDelta< double > | |
CDelta< float > | |
CDenseStencil | Dense stencil of a given width |
CDivergence | Compute the divergence of a vector-valued grid using differencing of various orders, the result defined with respect to the range-space of the map |
CDivergence< ScaleMap, CD_2ND > | |
CDivergence< ScaleMap, DiffScheme > | |
CDivergence< ScaleTranslateMap, CD_2ND > | |
CDivergence< ScaleTranslateMap, DiffScheme > | |
CDivergence< TranslationMap, DiffScheme > | |
CDivergence< UniformScaleMap, CD_2ND > | |
CDivergence< UniformScaleMap, DiffScheme > | |
CDivergence< UniformScaleTranslateMap, CD_2ND > | |
CDivergence< UniformScaleTranslateMap, DiffScheme > | |
CExtrema | This class computes the minimum and maximum values of a population of floating-point values |
CFourthOrderDenseStencil | |
CGenericMap | A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators |
CGradient | Center difference gradient operators, defined with respect to the range-space of the map |
CGradient< ScaleMap, CD_2ND > | |
CGradient< ScaleTranslateMap, CD_2ND > | |
CGradient< TranslationMap, DiffScheme > | |
CGradient< UniformScaleMap, CD_2ND > | |
CGradient< UniformScaleTranslateMap, CD_2ND > | |
CGradientBiased | Biased gradient operators, defined with respect to the range-space of the map |
CGradientNormSqrd | |
CGradientNormSqrd< UniformScaleMap, GradScheme > | Partial template specialization of GradientNormSqrd |
CGradientNormSqrd< UniformScaleTranslateMap, GradScheme > | Partial template specialization of GradientNormSqrd |
CGradStencil | |
CHistogram | This class computes a histogram, with a fixed interval width, of a population of floating-point values |
Cis_diagonal_jacobian | |
Cis_double | |
Cis_double< double > | |
Cis_linear | Map traits |
Cis_linear< AffineMap > | |
Cis_linear< CompoundMap< T1, T2 > > | |
Cis_linear< ScaleMap > | |
Cis_linear< ScaleTranslateMap > | |
Cis_linear< TranslationMap > | |
Cis_linear< UniformScaleMap > | |
Cis_linear< UniformScaleTranslateMap > | |
Cis_linear< UnitaryMap > | |
Cis_scale | |
Cis_scale< ScaleMap > | |
Cis_scale_translate | |
Cis_scale_translate< ScaleTranslateMap > | |
Cis_uniform_diagonal_jacobian | |
Cis_uniform_scale | |
Cis_uniform_scale< UniformScaleMap > | |
Cis_uniform_scale_translate | |
Cis_uniform_scale_translate< TranslationMap > | |
Cis_uniform_scale_translate< UniformScaleTranslateMap > | |
Cis_vec3d | |
Cis_vec3d< Vec3d > | |
CISCurl | Curl operator defined in index space using various first derivative schemes |
CISDivergence | Divergence operator defined in index space using various first derivative schemes |
CISGradient | Gradient operators defined in index space of various orders |
CISGradientBiased | Biased Gradient Operators, using upwinding defined by the Vec3Bias input |
CISGradientNormSqrd | |
CISLaplacian | Laplacian defined in index space, using various center-difference stencils |
CISLaplacian< CD_FOURTH > | |
CISLaplacian< CD_SECOND > | |
CISLaplacian< CD_SIXTH > | |
CISMeanCurvature | Compute the mean curvature in index space |
CISOpMagnitude | Adapter for vector-valued index-space operators to return the vector magnitude |
CLaplacian | Compute the Laplacian at a given location in a grid using finite differencing of various orders. The result is defined in the range of the map |
CLaplacian< ScaleMap, DiffScheme > | |
CLaplacian< ScaleTranslateMap, DiffScheme > | |
CLaplacian< TranslationMap, DiffScheme > | |
CLaplacian< UniformScaleMap, DiffScheme > | |
CLaplacian< UniformScaleTranslateMap, DiffScheme > | |
CLaplacian< UnitaryMap, DiffScheme > | |
CLevelSetHDDA | Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets |
CLevelSetHDDA< TreeT, -1 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set |
CMapAdapter | Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator |
CMapBase | Abstract base class for maps |
CMapRegistry | Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function |
CMat | |
CMat2 | |
CMat3 | 3x3 matrix class |
CMat4 | 4x4 -matrix class |
CMeanCurvature | Compute the mean curvature |
CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 > | |
CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 > | |
CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 > | |
CMinMax | Templated class to compute the minimum and maximum values |
CNineteenPointStencil | |
CNonlinearFrustumMap | This map is composed of three steps. First it will take a box of size (Lx X Ly X Lz) defined by a member data bounding box and map it into a frustum with near plane (1 X Ly/Lx) and prescribed depth Then this frustum is transformed by an internal second map: most often a uniform scale, but other effects can be achieved by accumulating translation, shear and rotation: these are all applied to the second map |
COpMagnitude | Adapter for vector-valued world-space operators to return the vector magnitude |
Cpromote | |
CQuantizedUnitVec | Unit vector occupying only 16 bits |
CQuat | |
CRand01 | Simple generator of random numbers over the range [0, 1) |
CRandInt | Simple random integer generator |
►CRay | |
CTimeSpan | |
CScaleMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions |
CScaleTranslateMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions, and then translates the result |
CSecondOrderDenseStencil | |
CSevenPointStencil | |
CSixthOrderDenseStencil | |
CStats | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values |
CThirteenPointStencil | |
CTolerance | Tolerance for floating-point comparison |
CTolerance< double > | |
CTolerance< float > | |
CTransform | |
CTranslationMap | A specialized linear transform that performs a translation |
CTuple | |
CUniformScaleMap | A specialized Affine transform that scales along the principal axis the scaling is uniform in the three-directions |
CUniformScaleTranslateMap | A specialized Affine transform that uniformaly scales along the principal axis and then translates the result |
CUnitaryMap | A specialized linear transform that performs a unitary maping i.e. rotation and or reflection |
CVec2 | |
CVec3 | |
CVec4 | |
CVolumeHDDA | Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume |
CVolumeHDDA< TreeT, RayT, 0 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume |
CWenoStencil | This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test |
►Npoints | |
►Nattribute_traits | |
CStringTypeTrait | |
CStringTypeTrait< true > | |
CTruncateTrait | |
CTruncateTrait< float > | |
CTruncateTrait< int > | |
CTruncateTrait< math::Vec3< T > > | |
CUIntTypeTrait | |
CUIntTypeTrait< false, math::Vec3< T > > | |
CUIntTypeTrait< false, T > | |
CUIntTypeTrait< true, math::Vec3< T > > | |
CUIntTypeTrait< true, T > | |
►Nfuture | A container for ABI=5 to help ease introduction of upcoming features |
CAdvect | |
CContainer | |
►Ninternal | |
CPointDataNodeChain | Recursive node chain which generates a boost::mpl::vector listing 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 > | |
►Npoint_advect_internal | |
CAdvectionDeformer | |
CAdvectionOp | |
►Npoint_attribute_internal | |
CAppendAttributeOp | |
CAttributeTypeConversion | |
CAttributeTypeConversion< Name, CodecType > | |
CCollapseAttributeOp | |
CCollapseAttributeOp< Name, PointDataTreeT > | |
CCompactAttributesOp | |
CDefault | |
CDropAttributesOp | |
CMetadataStorage | |
CMetadataStorage< PointDataTreeT, Name > | |
►Npoint_conversion_internal | |
CCalculatePositionBounds | |
CConversionTraits | |
CConversionTraits< openvdb::Name > | |
CConvertPointDataGridAttributeOp | |
CConvertPointDataGridGroupOp | |
CConvertPointDataGridPositionOp | |
CInitialiseAttributesOp | |
CPopulateAttributeOp | |
CPopulatePositionAttributeOp | |
►Npoint_delete_internal | |
CDeleteByFilterOp | |
CVectorWrapper | |
►Npoint_group_internal | |
CCopyGroupOp | Copy a group attribute value from one group offset to another |
CGroupInfo | Convenience class with methods for analyzing group data |
CSetGroupByFilterOp | |
CSetGroupFromIndexOp | |
CSetGroupOp | Set membership on or off for the specified group |
►Npoint_mask_internal | |
CGridCombinerOp | Combines multiple grids into one by stealing leaf nodes and summing voxel values This class is designed to work with thread local storage containers such as tbb::combinable |
CPointsToScalarOp | Compute scalar grid from PointDataGrid while evaluating the point filter |
CPointsToTransformedScalarOp | Compute scalar grid from PointDataGrid using a different transform and while evaluating the point filter |
►Npoint_move_internal | |
CArrayProcessor | Helper class used internally by processTypedArray() |
►CAttributeHandles | Cache read and write attribute handles to amortize construction cost |
CCacheHandleOp | Create a handle and reinterpret cast as an int handle to store |
CBuildMoveMapsOp | |
►CGlobalMovePointsOp | |
CPerformTypedMoveOp | |
►CLocalMovePointsOp | |
CPerformTypedMoveOp | |
►Npoint_sample_internal | |
CAppendAttributeOp | |
CAppendAttributeOp< PointDataGridT, DummySampleType > | |
CCompatibleTypes | |
CCompatibleTypes< math::Vec2< T >, math::Vec2< T > > | |
CCompatibleTypes< math::Vec2< T0 >, math::Vec2< T1 > > | |
CCompatibleTypes< math::Vec3< T >, math::Vec3< T > > | |
CCompatibleTypes< math::Vec3< T0 >, math::Vec3< T1 > > | |
CCompatibleTypes< math::Vec4< T >, math::Vec4< T > > | |
CCompatibleTypes< math::Vec4< T0 >, math::Vec4< T1 > > | |
CCompatibleTypes< T, math::Vec2< T > > | |
CCompatibleTypes< T, math::Vec3< T > > | |
CCompatibleTypes< T, math::Vec4< T > > | |
CCompatibleTypes< T, T > | |
CCompatibleTypes< ValueMask, T > | |
CPointDataSampler | |
CSamplerTraits | |
CSamplerTraits< tools::Sampler< T0, T1 > > | |
CSampleWithRoundingOp | |
CSampleWithRoundingOp< ValueT, SamplerT, AccessorT, false, true > | |
CSampleWithRoundingOp< ValueT, SamplerT, AccessorT, true, true > | |
CAccessorEval | Accessor to call unsafe get and set methods based on templated Codec and Value |
CAccessorEval< UnknownCodec, ValueType > | Partial specialization when Codec is not known at compile-time to use the supplied functor instead |
►CAttributeArray | Base class for storing attribute data |
CAccessor | |
CAccessorBase | Accessor base class for AttributeArray storage where type is not available |
CAttributeHandle | |
CAttributeHashFilter | |
►CAttributeSet | Ordered collection of uniquely-named attribute arrays |
CInserter | Utility method to construct a NameAndType sequence |
►CUtil | |
CNameAndType | Attribute and type name pair |
CAttributeWriteHandle | Write-able version of AttributeHandle |
CBBoxFilter | |
CBinaryFilter | |
►CCachedDeformer | A Deformer that caches the resulting positions from evaluating another Deformer |
►CCache | |
CLeaf | |
CDeformerTraits | Deformer Traits for optionally configuring deformers to be applied in index-space. The default is world-space |
CDummySampleType | |
CFilterTraits | |
CFilterTraits< BBoxFilter > | |
CFilterTraits< BinaryFilter< T0, T1, And > > | |
CFilterTraits< LevelSetFilter< T > > | |
►CFixedPointCodec | |
CStorage | |
►CGroupCodec | |
CStorage | |
CGroupFilter | Index filtering on group membership |
►CGroupHandle | |
CBitMask | |
CGroupWriteHandle | |
►CIndexIter | A forward iterator over array indices with filtering IteratorT can be either IndexIter or ValueIndexIter (or some custom index iterator) FilterT should be a struct or class with a valid() method than can be evaluated per index Here's a simple filter example that only accepts even indices: |
CValueIndexIter | A forward iterator over array indices from a value iterator (such as ValueOnCIter) |
CLevelSetFilter | |
CMultiGroupFilter | |
►CNullCodec | |
CStorage | |
CNullDeformer | No-op deformer (adheres to the deformer interface documented in PointMove.h) |
CNullFilter | A no-op filter that can be used when iterating over all indices |
CPointAttributeVector | Point-partitioner compatible STL vector attribute wrapper for convenience |
CPointDataLeafNode | |
CPositionRange | |
CRandomLeafFilter | |
CSampleWithRounding | |
CStringAttributeHandle | |
CStringAttributeWriteHandle | |
►CStringCodec | |
CStorage | |
CStringMetaInserter | |
CTreeConverter | Similiar to ValueConverter, but allows for tree configuration conversion to a PointDataTree. ValueConverter<PointDataIndex32> cannot be used as a PointDataLeafNode is not a specialization of LeafNode |
►CTruncateCodec | |
CStorage | |
CTypedAttributeArray | Typed class for storing attribute data |
CUnitRange | |
►CUnitVecCodec | |
CStorage | |
CUnknownCodec | |
CValueMaskFilter | Index filtering on active / inactive state of host voxel |
►CValueVoxelCIter | A forward iterator over array indices in a single voxel |
CParent | |
►Ntools | |
►Nactivation | |
CActivationOp | |
►Nclip_internal | |
CBoolSampler | |
CConvertGrid | |
CConvertGrid< GridT, GridT > | |
CCopyLeafNodes | |
CMaskInteriorVoxels | |
►Ncomposite | |
CBuildPrimarySegment | |
CBuildSecondarySegment | |
CGridOrTreeConstructor | |
CGridOrTreeConstructor< Grid< TreeType > > | |
►Ndiagnostics_internal | |
CInactiveTileValues | |
CInactiveVoxelValues | |
►Nds | |
CCompositeFunctorTranslator | 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 > | |
COpAdd | |
COpMax | |
COpMin | |
COpMult | |
COpOver | Point wise methods used to apply various compositing operations |
COpSub | |
►Ngridop | |
CGridOperator | Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type |
CToMaskGrid | ToMaskGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value equal to its active state |
►Ninternal | |
CPointListTransform | |
CPrimCpy | |
CTileSampler | 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 |
CTileSampler< PointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership |
CTileSampler< StaggeredPointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership |
►Nlevel_set_fracture_internal | |
CFindMinMaxVoxelValue | |
►Nlevel_set_util_internal | |
CComputeActiveVoxelCount | |
CConnectNodeMaskSegments | |
CExpandLeafNodeRegion | |
CExpandNarrowbandMask | |
CFillLeafNodeVoxels | |
CFillMaskBoundary | |
CFindMinTileValue | |
CFindMinVoxelValue | |
CFlipRegionSign | |
CFloodFillSign | |
CGreaterCount | |
CGridOrTreeConstructor | |
CGridOrTreeConstructor< Grid< TreeType > > | |
CLabelBoundaryVoxels | Negative active values are set 0 , everything else is set to 1 |
CMaskedCopy | |
CMaskInteriorTiles | |
CMaskInteriorVoxels | |
CMaskIsovalueCrossingVoxels | |
CMaskSegmentGroup | |
CNodeMaskSegment | |
CPopulateTree | |
CSDFTilesToFogVolume | |
CSDFVoxelsToFogVolume | |
CSegmentNodeMask | |
►Nmesh_to_volume_internal | |
CAddNodes | |
CCombineLeafNodes | |
CComputeIntersectingVoxelSign | |
CComputeNodeConnectivity | |
CConstructVoxelMask | |
CDiffLeafNodeMask | |
►CExpandNarrowband | |
CFragment | |
CFillArray | |
CInactivateValues | |
CLeafNodeConnectivityTable | |
CMinCombine | |
COffsetValues | |
CReleaseChildNodes | |
►CRemoveSelfIntersectingSurface | |
CComp | |
CRenormalize | |
CRestoreOrigin | |
CSeedFillExteriorSign | |
CSeedPoints | |
CStashOriginAndStoreOffset | |
CStealUniqueLeafNodes | |
CSweepExteriorSign | |
CSyncVoxelMask | |
CTolerance | |
CTransformPoints | |
CTransformValues | |
CUnionValueMasks | |
►CValidateIntersectingVoxels | |
CIsNegative | |
CVoxelizationData | 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) |
CVoxelizePolygons | |
►Nparticle_atlas_internal | |
CBBoxFilter | |
CComputeExtremas | |
CRadialRangeFilter | |
CRemapIndices | |
CSplittableParticleArray | |
►Npoint_index_grid_internal | |
CBBoxFilter | |
CPopulateLeafNodesOp | |
CRadialRangeFilter | |
CValidPartitioningOp | |
►Npoint_partitioner_internal | |
CArray | |
CBinPointIndicesOp | |
CComputePointOrderOp | |
CCreateOrderedPointIndexArrayOp | |
CLeafNodeOriginOp | |
CMergeBinsOp | |
CMoveSegmentDataOp | |
COrderSegmentsOp | |
CVoxelOrderOp | |
►Npoisson | |
►Ninternal | |
CCopyFromVecOp | Functor for use with LeafManager::foreach() to populate a tree with values from a vector |
CCopyToVecOp | Functor for use with LeafManager::foreach() to populate a vector with the values of a tree's active voxels |
CISLaplacianOp | Functor for use with LeafManager::foreach() to populate a sparse Laplacian matrix |
CISStaggeredLaplacianOp | Functor for use with LeafManager::foreach() to populate a sparse Laplacian matrix |
CLeafCountOp | Functor for use with LeafManager::foreach() to populate an array with per-leaf active voxel counts |
CLeafIndexOp | Functor for use with LeafManager::foreach() to populate active leaf voxels with sequential indices |
CDirichletBoundaryOp | Dirichlet boundary condition functor |
►Npotential_flow_internal | |
CComputeNeumannVelocityOp | |
CSolveBoundaryOp | |
►Nstats_internal | |
CGetVal | |
CGetValImpl | |
CGetValImpl< T, false > | |
CGetValImpl< T, true > | |
CHistOp | |
CIterTraits | |
CIterTraits< tree::TreeValueIteratorBase< TreeT, ValueIterT > > | |
CMathOp | |
CStatsOp | |
►Nttls_internal | |
CDilateOp | |
CErodeOp | |
COffsetAndMinComp | |
►Nv2s_internal | |
CClosestPointDist | |
CLeafOp | |
CNodeOp | |
CPointAccessor | |
CUpdatePoints | |
►Nvalxform | |
CCopyableOpApplier | |
CCopyableOpTransformer | |
CMaxOp | |
CMinOp | |
CMultOp | |
COpAccumulator | |
CSharedOpApplier | |
CSharedOpTransformer | |
CSumOp | |
►Nvolume_to_mesh_internal | |
CAdaptiveLeafNodePointCount | |
CAdaptivePrimBuilder | |
CComputeAuxiliaryData | |
CComputePoints | |
CComputePolygons | |
CCopyArray | |
CFillArray | |
CFlagAndCountQuadsToSubdivide | |
CIdentifyIntersectingVoxels | |
CLeafNodePointCount | |
CLeafNodeVoxelOffsets | |
CMapPoints | |
CMaskBorderVoxels | |
CMaskDisorientedTrianglePoints | |
CMaskIntersectingVoxels | |
CMaskSeamLineVoxels | |
CMaskSurface | |
CMaskTileBorders | |
CMergeVoxelRegions | |
CPointListCopy | |
CReviseSeamLineFlags | |
CSeamLineWeights | |
CSetSeamLineFlags | |
CSubdivideQuads | |
CSyncMaskValues | |
CTransferSeamLineFlags | |
CUniformPrimBuilder | |
CVoxelEdgeAccessor | Utility method to marks all voxels that share an edge |
CABTransform | This class implements the Transformer functor interface (specifically, the isAffine(), transform() and invTransform() methods) for a transform that maps an A grid into a B grid's index space such that, after resampling, A's index space and transform match B's index space and transform |
CAlphaMask | |
CBaseCamera | Abstract base class for the perspective and orthographic cameras |
CBasePointScatter | Forward declaration of base class |
CBaseShader | Abstract base class for the shaders |
CBoxSampler | |
CChangeBackgroundOp | |
CChangeLevelSetBackgroundOp | |
CCheckDivergence | Checks the divergence against a range |
CCheckEikonal | Checks the norm of the gradient at zero-crossing voxels against a range |
CCheckFinite | Checks for both NaN and inf values, i.e. any value that is not finite |
CCheckFogVolume | Class that performs various types of checks on fog volumes |
CCheckInf | Checks for infinite values, e.g. 1/0 or -1/0 |
CCheckLevelSet | Class that performs various types of checks on narrow-band level sets |
CCheckMagnitude | Check that the magnitude of a value, a, is close to a fixed magnitude, b, given a fixed tolerance c. That is | |a| - |b| | <= c |
CCheckMax | Checks a value against a maximum |
CCheckMin | Checks a value against a minimum |
CCheckNan | Checks NaN values |
CCheckNormGrad | Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max] |
CCheckRange | Checks a value against a range |
CClosestPointProjector | |
CClosestSurfacePoint | Accelerated closest surface point queries for narrow band level sets |
CCompReplaceOp | |
CConstrainedPointAdvect | |
CContiguousOp | Wrapper struct used to avoid unnecessary computation of memory access from Coord when all offsets are guaranteed to be within the dense grid |
CCopyFromDense | Copy the values from a dense grid into an OpenVDB tree |
CCopyToDense | Copy an OpenVDB tree into an existing dense grid |
CCpt | Compute the closest-point transform of a scalar grid |
CCsgDiffVisitor | |
CCsgIntersectVisitor | |
CCsgUnionVisitor | |
CCsgVisitorBase | |
CCurl | Compute the curl of a vector grid |
CDense | Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below |
CDenseBase | Base class for Dense which is defined below |
CDenseBase< ValueT, LayoutXYZ > | Partial template specialization of DenseBase |
CDenseBase< ValueT, LayoutZYX > | Partial template specialization of DenseBase |
CDenseTransformer | Class that applies a functor to the index space intersection of a prescribed bounding box and the dense grid. NB: This class only supports DenseGrids with ZYX memory layout |
CDenseUniformPointScatter | Scatters a fixed (and integer) number of points in all active voxels and tiles |
CDiagnose | Performs multithreaded diagnostics of a grid |
CDiffuseShader | Simple diffuse Lambertian surface shader |
CDiffuseShader< Film::RGBA, SamplerType > | |
CDilationOp | Class that performs multi-threaded dilation with support for active tiles |
CDimToWord | Mapping from a Log2Dim to a data type of size 2^Log2Dim bits |
CDimToWord< 3 > | |
CDimToWord< 4 > | |
CDimToWord< 5 > | |
CDimToWord< 6 > | |
CDiracDelta | Smeared-out and continuous Dirac Delta function |
CDiscreteField | Thin wrapper class for a velocity grid |
►CDivergence | Compute the divergence of a vector grid |
CFunctor | |
CDSConverter | |
CDualGridSampler | This is a simple convenience class that allows for sampling from a source grid into the index space of a target grid. At construction the source and target grids are checked for alignment which potentially renders interpolation unnecessary. Else interpolation is performed according to the templated Sampler type |
CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT > | Specialization of DualGridSampler for construction from a ValueAccessor type |
CEnrightField | Analytical, divergence-free and periodic velocity field |
CExtractAll | Simple utility class used by extractSparseTreeWithMask |
►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 |
CRGBA | Floating-point RGBA components in the range [0, 1] |
CFilter | Volume filtering (e.g., diffusion) with optional alpha masking |
►CGradient | Compute the gradient of a scalar grid |
CFunctor | |
CGridResampler | |
CGridSampler | Class that provides the interface for continuous sampling of values in a tree |
CGridSampler< tree::ValueAccessor< TreeT >, SamplerType > | Specialization of GridSampler for construction from a ValueAccessor type |
►CGridTransformer | A GridTransformer applies a geometric transformation to an input grid using one of several sampling schemes, and stores the result in an output grid |
CMatrixTransform | |
CHomogeneousMatMul | |
CInactivePruneOp | |
►CLaplacian | |
CFunctor | |
CLevelSetAdvection | Hyperbolic advection of narrow-band level sets in an external velocity field |
CLevelSetFilter | Filtering (e.g. diffusion) of narrow-band level sets. An optional scalar field can be used to produce a (smooth) alpha mask for the filtering |
CLevelSetFracture | Level set fracturing |
CLevelSetMeasure | Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets |
CLevelSetMorphing | Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set |
CLevelSetPruneOp | |
CLevelSetRayIntersector | This class provides the public API for intersecting a ray with a narrow-band level set |
CLevelSetRayTracer | A (very) simple multithreaded ray tracer specifically for narrow-band level sets |
CLevelSetSphere | Generates a signed distance field (or narrow band level set) to a single sphere |
►CLevelSetTracker | Performs multi-threaded interface tracking of narrow band level sets |
CState | Lightweight struct that stores the state of the LevelSetTracker |
CLinearSearchImpl | Implements linear iterative search for an iso-value of the level set along the direction of the ray |
►CMagnitude | |
CFunctor | |
COpT | |
CMatMul | |
CMatMulNormalize | |
CMatteShader | Shader that produces a simple matte |
CMatteShader< Film::RGBA, SamplerType > | |
►CMeanCurvature | |
CFunctor | |
►CMeshToVoxelEdgeData | Extracts and stores voxel edge intersection data from a mesh |
CEdgeData | Internal edge data type |
CGenEdgeData | |
►CMorphology | |
CCopyMasks | |
CErodeVoxelsOp | |
CLeafCache | |
CMaskManager | |
CNeighbor | |
CUpdateMasks | |
►CMultiResGrid | |
CMaskOp | |
CProlongateOp | |
CRestrictOp | |
CNonUniformPointScatter | Non-uniform scatters of point in the active voxels. The local point count is implicitly defined as a product of of a global density (called pointsPerVolume) and the local voxel (or tile) value |
►CNormalize | |
CFunctor | |
COpT | |
CNormalShader | Color shader that treats the surface normal (x, y, z) as an RGB color |
CNormalShader< Film::RGBA, SamplerType > | |
COrthographicCamera | |
►CParticleAtlas | |
CIterator | Provides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas |
CParticlesToLevelSet | |
CPerspectiveCamera | |
CPointAdvect | |
CPointIndexFilter | |
CPointIndexIterator | Accelerated range and nearest-neighbor searches for point index grids |
CPointIndexLeafNode | |
►CPointPartitioner | |
CIndexIterator | |
CPointSampler | |
►CPointsToMask | Makes every voxel of a grid active if it contains a point |
CReducePool | |
CPolygonPool | Collection of quads and triangles |
CPositionShader | Color shader that treats position (x, y, z) as an RGB color in a cube defined from an axis-aligned bounding box in world space |
CPositionShader< Film::RGBA, SamplerType > | |
CQuadAndTriangleDataAdapter | Contiguous quad and triangle data adapter class |
CQuadraticSampler | |
CSampler | Provises a unified interface for sampling, i.e. interpolation |
CSampler< 0, false > | |
CSampler< 0, true > | |
CSampler< 1, false > | |
CSampler< 1, true > | |
CSampler< 2, false > | |
CSampler< 2, true > | |
CScalarToVectorConverter | ScalarToVectorConverter<ScalarGridType>::Type is the type of a grid having the same tree configuration as ScalarGridType but value type Vec3<T> where T is ScalarGridType::ValueType |
CSignedFloodFillOp | |
CSparseExtractor | Functor-based class used to extract data that satisfies some criteria defined by the embedded OpType functor. The extractSparseTree function wraps this class |
CSparseMaskedExtractor | Functor-based class used to extract data from a dense grid, at the index-space intersection with a supplied mask in the form of a sparse tree. The extractSparseTreeWithMask function wraps this class |
CSparseToDenseCompositor | |
CStaggeredBoxSampler | |
CStaggeredPointSampler | |
CStaggeredQuadraticSampler | |
CTolerancePruneOp | |
CUniformPointScatter | The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes: |
CVectorToScalarConverter | VectorToScalarConverter<VectorGridType>::Type is the type of a grid having the same tree configuration as VectorGridType but a scalar value type, T, where T is the type of the original vector components |
CVectorToScalarGrid | Metafunction to convert a vector-valued grid type to a scalar grid type |
CVelocityIntegrator | Performs Runge-Kutta time integration of variable order in a static velocity field |
CVelocitySampler | |
CVolumeAdvection | Performs advections of an arbitrary type of volume in a static velocity field. The advections are performed by means of various derivatives of Semi-Lagrangian integration, i.e. backwards tracking along the hyperbolic characteristics followed by interpolation |
CVolumeRayIntersector | This class provides the public API for intersecting a ray with a generic (e.g. density) volume |
CVolumeRender | A (very) simple multithreaded volume render specifically for scalar density |
CVolumeToMesh | Mesh any scalar grid that has a continuous isosurface |
►Ntree | |
►Ninternal | |
CLeafBufferFlags | |
►Niter | |
CInvertedTree | |
CInvertedTree< HeadT, 1 > | |
►Nleafmgr | |
CTreeTraits | Useful traits for Tree types |
CTreeTraits< const TreeT > | |
CCacheItem | |
CCacheItem< TreeCacheT, NodeVecT, true > | The tail of a compile-time list of cached node pointers, ordered from LeafNode to RootNode |
CCombineOpAdapter | Helper class to adapt a three-argument (a, b, result) CombineOp functor into a single-argument functor that accepts a CombineArgs struct |
CCopyConstness | |
CCopyConstness< const FromType, ToType > | |
CCopyTraits | |
CCopyTraits< math::Coord > | |
CCopyTraits< math::Vec2< T > > | |
CCopyTraits< math::Vec3< T > > | |
CCopyTraits< math::Vec4< T > > | |
CDenseIteratorBase | Base class for dense iterators over internal and leaf nodes |
►CInternalNode | |
CChildAll | |
CChildIter | |
CChildOff | |
CChildOn | |
CDeepCopy | |
CDenseIter | |
CSameConfiguration | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of an InternalNode with the same dimensions as this node and whose ChildNodeType has the same configuration as this node's ChildNodeType |
CTopologyCopy1 | |
CTopologyCopy2 | |
►CTopologyDifference | |
CA | |
CB | |
►CTopologyIntersection | |
CA | |
►CTopologyUnion | |
CA | |
CValueAll | |
CValueConverter | ValueConverter<T>::Type is the type of an InternalNode having the same child hierarchy and dimensions as this node but a different value type, T |
CValueIter | |
CValueOff | |
CValueOn | |
CVoxelizeActiveTiles | |
CIteratorBase | Base class for iterators over internal and leaf nodes |
CIteratorRange | |
CIterListItem | An IterListItem is an element of a compile-time linked list of iterators to nodes of different types |
CIterListItem< PrevItemT, NodeVecT, 1, _Level > | The final element of a compile-time linked list of iterators to nodes of different types |
CIterListItem< PrevItemT, NodeVecT, VecSize, 0U > | The initial element of a compile-time linked list of iterators to nodes of different types |
CIterTraits | |
►CIterTraits< NodeT, typename NodeT::ChildAllCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ChildAllIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ChildOffCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ChildOffIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ChildOnCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ChildOnIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueAllCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueAllIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueOffCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueOffIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueOnCIter > | |
CNodeConverter | |
►CIterTraits< NodeT, typename NodeT::ValueOnIter > | |
CNodeConverter | |
►CLeafBuffer | Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode |
CFileInfo | |
CLeafBuffer< bool, Log2Dim > | |
CLeafIteratorBase | Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels) |
►CLeafManager | This class manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxiliary buffers (one or more per leaf) that can be swapped with the leaf nodes' voxel data buffers |
►CLeafRange | |
CIterator | |
CLeafManagerImpl | |
CLeafManagerImpl< LeafManager< const TreeT > > | |
►CLeafNode | Templated block class to hold specific data types and a fixed number of values determined by Log2Dim. The actual coordinate dimension of the block is 2^Log2Dim, i.e. Log2Dim=3 corresponds to a LeafNode that spans a 8^3 block |
CChildAll | |
CChildIter | Leaf nodes have no children, so their child iterators have no get/set accessors |
CChildOff | |
CChildOn | |
CDenseIter | |
CSameConfiguration | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
CValueAll | |
CValueConverter | ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T |
CValueIter | |
CValueOff | |
CValueOn | |
►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 |
CChildIter | Leaf nodes have no children, so their child iterators have no get/set accessors |
CDenseIter | |
CSameConfiguration | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
CValueConverter | ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T |
CValueIter | |
►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! |
CChildIter | Leaf nodes have no children, so their child iterators have no get/set accessors |
CDenseIter | |
CSameConfiguration | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
CValueConverter | ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T |
CValueIter | |
CNodeChain | 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 |
CNodeIteratorBase | Base class for tree-traversal iterators over all nodes |
►CNodeList | This class caches tree nodes of a specific type in a linear array |
►CNodeRange | |
CIterator | |
CNodeManager | To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree |
CNodeManagerLink | This class is a link in a chain that each caches tree nodes of a specific type in a linear array |
CNodeUnion | |
CNodeUnion< ValueT, ChildT, typename std::enable_if< CopyTraits< ValueT >::IsCopyable >::type > | |
CNodeUnion< ValueT, ChildT, typename std::enable_if< std::is_pod< ValueT >::value >::type > | |
►CRootNode | |
CSameConfiguration | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a RootNode whose ChildNodeType has the same configuration as this node's ChildNodeType |
CValueConverter | ValueConverter<T>::Type is the type of a RootNode having the same child hierarchy as this node but a different value type, T |
CRootNodeCombineHelper | |
CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true > | |
CRootNodeCopyHelper | |
CRootNodeCopyHelper< RootT, OtherRootT, true > | |
CSameInternalConfig | |
CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > > | |
CSameLeafConfig | |
CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > > | |
CSameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > > | |
CSameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > > | |
CSameRootConfig | |
CSameRootConfig< ChildT1, RootNode< ChildT2 > > | |
CSparseIteratorBase | Base class for sparse iterators over internal and leaf nodes |
►CTree | |
CDeallocateNodes | |
CValueConverter | ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T |
CTree3 | Tree3<T, N1, N2>::Type is the type of a three-level tree (Root, Internal, Leaf) with value type T and internal and leaf node log dimensions N1 and N2, respectively |
CTree4 | Tree4<T, N1, N2, N3>::Type is the type of a four-level tree (Root, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2 and N3, respectively |
CTree5 | Tree5<T, N1, N2, N3, N4>::Type is the type of a five-level tree (Root, Internal, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2, N3 and N4, respectively |
CTreeBase | Base class for typed trees |
CTreeIterTraits | TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type |
CTreeIterTraits< TreeT, typename TreeT::LeafCIter > | |
CTreeIterTraits< TreeT, typename TreeT::LeafIter > | |
CTreeIterTraits< TreeT, typename TreeT::NodeCIter > | |
CTreeIterTraits< TreeT, typename TreeT::NodeIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter > | |
CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueAllCIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueAllIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueOffCIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueOffIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueOnCIter > | |
CTreeIterTraits< TreeT, typename TreeT::ValueOnIter > | |
CTreeValueIteratorBase | Base class for tree-traversal iterators over tile and voxel values |
CValueAccessor | |
CValueAccessor0 | ValueAccessor with no mutex and no node caching |
CValueAccessor1 | Value accessor with one level of node caching |
CValueAccessor2 | Value accessor with two levels of node caching |
CValueAccessor3 | Value accessor with three levels of node caching |
CValueAccessor< TreeType, IsSafe, 0, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and no cache levels |
CValueAccessor< TreeType, IsSafe, 1, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and one cache level |
CValueAccessor< TreeType, IsSafe, 2, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and two cache levels |
CValueAccessor< TreeType, IsSafe, 3, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and three cache levels |
CValueAccessorBase | This base class for ValueAccessors manages registration of an accessor with a tree so that the tree can automatically clear the accessor whenever one of its nodes is deleted |
CValueAccessorRW | 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 |
►Nutil | |
CBaseMaskIterator | Base class for the bit mask iterators |
CCpuTimer | Simple timer for basic profiling |
CDenseMaskIterator | |
CFormattedInt | I/O manipulator that formats integer values with thousands separators |
CLeafTopologyDiffOp | Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees |
CLeafTopologyIntOp | Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees |
CNodeMask | Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation |
CNodeMask< 1 > | Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes |
CNodeMask< 2 > | Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes |
CNullInterrupter | Dummy NOOP interrupter class defining interface |
COffMaskIterator | |
COnMaskIterator | |
►CPagedArray | Concurrent, page-based, dynamically-sized linear data structure with O(1) random access and STL-compliant iterators. It is primarily intended for applications that concurrently insert (a possibly unkown number of) elements into a dynamically growing linear array, and fast random access to said elements |
CConstIterator | |
CIterator | |
CPage | |
CValueBuffer | |
►CRootNodeMask | |
CBaseIterator | |
CDenseIterator | |
COffIterator | |
COnIterator | |
CArithmeticError | |
CCanConvertType | CanConvertType<FromType, ToType>::value is true if a value of type ToType can be constructed from a value of type FromType |
CCanConvertType< math::Vec2< T >, math::Vec2< T > > | |
CCanConvertType< math::Vec3< T >, math::Vec3< T > > | |
CCanConvertType< math::Vec4< T >, math::Vec4< T > > | |
CCanConvertType< PointDataIndex32, PointIndex32 > | |
CCanConvertType< PointIndex32, PointDataIndex32 > | |
CCanConvertType< T, math::Vec2< T > > | |
CCanConvertType< T, math::Vec3< T > > | |
CCanConvertType< T, math::Vec4< T > > | |
CCanConvertType< T, ValueMask > | |
CCanConvertType< T0, math::Vec2< T1 > > | |
CCanConvertType< T0, math::Vec3< T1 > > | |
CCanConvertType< T0, math::Vec4< T1 > > | |
CCanConvertType< ValueMask, T > | |
CCombineArgs | This struct collects both input and output arguments to "grid combiner" functors used with the tree::TypedGrid::combineExtended() and combine2Extended() methods. AValueType and BValueType are the value types of the two grids being combined |
CException | |
►CGrid | Container class that associates a tree with a transform and metadata |
CValueConverter | ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different value type, T |
CGridBase | Abstract base class for typed grids |
CGridNamePred | Predicate functor that returns true for grids that have a specified name |
CHasMultiPassIO | Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data |
CHasMultiPassIO< Grid< TreeType > > | |
CHasMultiPassIO< tree::Tree< RootNodeType > > | |
CIllegalValueException | |
CIndexError | |
CIoError | |
CKeyError | |
CLookupError | |
CMetadata | Base class for storing metadata information in a grid |
CMetaMap | Container that maps names (strings) to values of arbitrary types |
CNotImplementedError | |
CPartialCreate | Tag dispatch class that distinguishes constructors during file input |
CPointIndex | Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid |
CReferenceError | |
CRuntimeError | |
CShallowCopy | Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors |
CSwappedCombineOp | |
CTopologyCopy | Tag dispatch class that distinguishes topology copy constructors from deep copy constructors |
CTreeAdapter | This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type |
CTreeAdapter< Grid< _TreeType > > | Partial specialization for Grid types |
CTreeAdapter< tree::ValueAccessor< _TreeType > > | Partial specialization for ValueAccessor types |
CTypedMetadata | Templated metadata class to hold specific types |
CTypeError | |
CUnknownMetadata | Subclass to hold raw data of an unregistered type |
CValueError | |
CValueMask | |
CVecTraits | |
CVecTraits< math::Vec2< T > > | |
CVecTraits< math::Vec3< T > > | |
CVecTraits< math::Vec4< T > > | |
CVersionId | |
CFilterType | Selectively extract and filter point data using a custom filter operator |
CMeshDataAdapter | Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes |
CParticleArray | Partition particles and performs range and nearest-neighbor searches |
CPointArray | |
CPointArray | Partitions points into BucketLog2Dim aligned buckets using a parallel radix-based sorting algorithm |
CTestLeafIO | |