| CGridBuilder< ValueT, BuildT, StatsT >:: BuildLeaf | |
| CGridBuilder< ValueT, BuildT, StatsT >:: BuildNode< ChildT > | |
| CGridBuilder< ValueT, BuildT, StatsT >:: ValueAccessor | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >::A | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::A | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >::A | |
| CAbsDiff | Compression oracle based on absolute difference |
| 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 |
| CAttributeRegistry::AccessData | Registered access details, including its name, type and whether a write handle is required |
| ►CAttributeArray::AccessorBase | Accessor base class for AttributeArray storage where type is not available |
| CAttributeArray::Accessor< T > | |
| CAccessorEval< CodecType, ValueType > | Accessor to call unsafe get and set methods based on templated Codec and Value |
| CAccessorEval< UnknownCodec, ValueType > | Partial specialization when Codec is not known at compile-time to use the supplied functor instead |
| CAdvect | |
| CAliasTypeMap< T1, T2 > | Alias mapping between two types, a frontend type T1 and a backend type T2. This class is the intended interface for binding objects which implement supported backend AX/IR types to this given backend type. More specifically, it's current and expected usage is limited to objects which hold a single member of a supported backend type and implements a StandardLayoutType as defined by the standard. Fundamentally, T1->T2 mapping should be supported by reinterpret_cast<> as defined by the type aliasing rules |
| ►CAliasTypeMap< ArgType< T, S >, T[S]> | |
| CLLVMType< ArgType< T, S > > | |
| ►CAliasTypeMap< math::Mat3< T >, T[9]> | |
| CLLVMType< math::Mat3< T > > | |
| ►CAliasTypeMap< math::Mat4< T >, T[16]> | |
| CLLVMType< math::Mat4< T > > | |
| ►CAliasTypeMap< math::Vec2< T >, T[2]> | |
| CLLVMType< math::Vec2< T > > | Supported aliasing for VDB math types, allowing use in external function signatures |
| ►CAliasTypeMap< math::Vec3< T >, T[3]> | |
| CLLVMType< math::Vec3< T > > | |
| ►CAliasTypeMap< math::Vec4< T >, T[4]> | |
| CLLVMType< math::Vec4< T > > | |
| CAlphaMask< GridT, MaskT, SamplerT, FloatT > | |
| CApplyFunc< Fn, Args > | |
| ►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) |
| CFunctionTraits< ReturnT(Args...)>::Arg< I > | |
| CArgType< T, _SIZE > | Object to array conversion methods to allow functions to return vector types. These containers provided an interface for automatic conversion of C++ objects to LLVM types as array types |
| CArgumentIterator< SignatureT, I > | Templated argument iterator which implements various small functions per argument type, resolved at compile time |
| CArgumentIterator< SignatureT, 0 > | |
| ►CAttributeArray | Base class for storing attribute data |
| CTypedAttributeArray< ValueType_, Codec_ > | Typed class for storing attribute data |
| CAttributeBindings | This class wraps an interface for a map of attribute bindings. These map attributes in AX code to context data. These mappings are one-to-one i.e. each AX name can only map to one data name, however each name can appear as either an AX name or data name or both, i.e. the following sets of bindings are valid: axname: a -> dataname: a axname: b -> dataname: c or axname: a -> dataname: b axname: b -> dataname: a |
| ►CAttributeCopyBase | |
| CAttributeCopy< ValueType > | |
| CStrAttributeCopy | |
| ►CAttributeDetailBase | |
| CAttributeDetail< VDBGridType > | |
| ►CAttributeHandle< ValueType, CodecType > | |
| CAttributeWriteHandle< ValueType, CodecType > | Write-able version of AttributeHandle |
| ►CAttributeHandle< Index, openvdb::v9_0::points::StringCodec< false > > | |
| CAttributeWriteHandle< Index, openvdb::v9_0::points::StringCodec< false > > | |
| CAttributeHashFilter< RandGenT, IntType > | |
| CAttributeRegistry | This class stores a list of access names, types and their dependency connections |
| CLevelSetFilter< GridT, MaskT, InterruptT >::Filter::Avg< Axis > | |
| CAXLTYPE | |
| CAXSTYPE | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::B | |
| ►CBaseBBox< Vec3T > | |
| CBBox< Vec3T, true > | Partial template specialization for floating point coordinate types |
| ►CBaseBBox< CoordT > | |
| CBBox< CoordT, false > | Partial template specialization for integer coordinate types |
| ►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 > | |
| ►CBasePointScatter< PointAccessorType, RandomGenerator, InterruptType > | Forward declaration of base class |
| CDenseUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | Scatters a fixed (and integer) number of points in all active voxels and tiles |
| 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 (called pointsPerVolume) and the local voxel (or tile) value |
| CUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes: |
| ►CBaseShader | Abstract base class for the shaders |
| CDiffuseShader< GridT, SamplerType > | Simple diffuse Lambertian surface shader |
| CDiffuseShader< Film::RGBA, SamplerType > | |
| CMatteShader< GridT, SamplerType > | Shader that produces a simple matte |
| CMatteShader< Film::RGBA, SamplerType > | |
| CNormalShader< GridT, SamplerType > | Color shader that treats the surface normal (x, y, z) as an RGB color |
| CNormalShader< Film::RGBA, SamplerType > | |
| CPositionShader< GridT, SamplerType > | 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 > | |
| CBaseStencil< DerivedType, GridT, IsSafe > | |
| CBaseStencil< DerivedType, SIZE, GridT > | |
| ►CBaseStencil< BoxStencil< GridT >, 8, GridT > | |
| CBoxStencil< GridT > | |
| ►CBaseStencil< BoxStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CBoxStencil< GridT, IsSafe > | |
| ►CBaseStencil< BoxStencil< GridT, true >, GridT, true > | |
| CBoxStencil< GridT > | |
| ►CBaseStencil< CurvatureStencil< GridT >, 19, GridT > | |
| CCurvatureStencil< GridT, RealT > | |
| ►CBaseStencil< CurvatureStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CCurvatureStencil< GridT, false > | |
| CCurvatureStencil< GridT, IsSafe > | |
| ►CBaseStencil< DenseStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CDenseStencil< GridT, IsSafe > | Dense stencil of a given width |
| ►CBaseStencil< FourthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CFourthOrderDenseStencil< GridT, IsSafe > | |
| ►CBaseStencil< GradStencil< GridT >, 7, GridT > | |
| CGradStencil< GridT > | |
| ►CBaseStencil< GradStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CGradStencil< GridT, false > | |
| CGradStencil< GridT, IsSafe > | |
| ►CBaseStencil< NineteenPointStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CNineteenPointStencil< GridT, IsSafe > | |
| ►CBaseStencil< SecondOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CSecondOrderDenseStencil< GridT, IsSafe > | |
| ►CBaseStencil< SevenPointStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CSevenPointStencil< GridT, IsSafe > | |
| ►CBaseStencil< SixthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CSixthOrderDenseStencil< GridT, IsSafe > | |
| ►CBaseStencil< ThirteenPointStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CThirteenPointStencil< GridT, IsSafe > | |
| ►CBaseStencil< WenoStencil< GridT >, 19, GridT > | |
| CWenoStencil< GridT, RealT > | This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test |
| ►CBaseStencil< WenoStencil< GridT, IsSafe >, GridT, IsSafe > | |
| CWenoStencil< GridT, IsSafe > | 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, bool > | |
| CBBox< Vec3T > | Axis-aligned bounding box |
| CBBox< Coord > | |
| CBBox< CoordT > | |
| CBBox< nanovdb::Vec3 > | |
| CBBox< Vec3< double > > | |
| CBBox< Vec3d > | |
| CBBoxFilter | |
| CBIAS_SCHEME< bgs > | |
| CBIAS_SCHEME< FIRST_BIAS > | |
| CBIAS_SCHEME< HJWENO5_BIAS > | |
| CBIAS_SCHEME< SECOND_BIAS > | |
| CBIAS_SCHEME< THIRD_BIAS > | |
| CBIAS_SCHEME< WENO5_BIAS > | |
| CBinaryFilter< T1, T2, And > | |
| CGroupHandle::BitMask | |
| COpenToNanoVDB< OpenBuildT, NanoBuildT, OracleT, BufferT >::BlindMetaData | |
| ►CBoxSampler | |
| CSampler< 1, false > | |
| CBufferTraits< BufferT > | |
| CBufferTraits< CudaDeviceBuffer > | |
| CBuildMoveMapsOp< DeformerT, TreeT, FilterT > | |
| CBuildToValueMap< T > | Maps one type (e.g. the build types above) to other (actual) types |
| CBuildToValueMap< Fp16 > | |
| CBuildToValueMap< Fp4 > | |
| CBuildToValueMap< Fp8 > | |
| CBuildToValueMap< FpN > | |
| CBuildToValueMap< Half > | |
| CBuildToValueMap< NanoBuildT > | |
| CBuildToValueMap< ValueMask > | |
| CCachedDeformer< T >::Cache | |
| CCachedDeformer< T > | A Deformer that caches the resulting positions from evaluating another Deformer |
| CCacheItem< TreeCacheT, NodeVecT, AtRoot > | |
| CCacheItem< TreeCacheT, NodeVecT, true > | The tail of a compile-time list of cached node pointers, ordered from LeafNode to RootNode |
| CCacheItem< ValueAccessor, SubtreeT, SubtreeT::Size==1 > | |
| CCamera< RealT, Vec3T, RayT > | A minimal perspective camera for ray generation |
| CCanConvertType< FromType, ToType > | CanConvertType<FromType, ToType>::value is true if a value of type ToType can be constructed from a value of type FromType |
| CCanConvertType< math::Vec2< T >, math::Vec2< T > > | |
| CCanConvertType< math::Vec3< T >, math::Vec3< T > > | |
| CCanConvertType< math::Vec4< T >, math::Vec4< T > > | |
| CCanConvertType< PointDataIndex32, PointIndex32 > | |
| CCanConvertType< PointIndex32, PointDataIndex32 > | |
| CCanConvertType< T, math::Vec2< T > > | |
| CCanConvertType< T, math::Vec3< T > > | |
| CCanConvertType< T, math::Vec4< T > > | |
| CCanConvertType< T, ValueMask > | |
| CCanConvertType< T0, math::Vec2< T1 > > | |
| CCanConvertType< T0, math::Vec3< T1 > > | |
| CCanConvertType< T0, math::Vec4< T1 > > | |
| CCanConvertType< ValueMask, T > | |
| CChangeBackgroundOp< TreeOrLeafManagerT > | |
| CChangeLevelSetBackgroundOp< TreeOrLeafManagerT > | |
| CCheckDivergence< GridT, TreeIterT, DiffScheme > | Checks the divergence against a range |
| CCheckEikonal< GridT, TreeIterT, StencilT > | Checks the norm of the gradient at zero-crossing voxels against a range |
| CCheckFinite< GridT, TreeIterT > | Checks for both NaN and inf values, i.e. any value that is not finite |
| CCheckFogVolume< GridType > | Class that performs various types of checks on fog volumes |
| CCheckInf< GridT, TreeIterT > | Checks for infinite values, e.g. 1/0 or -1/0 |
| CCheckLevelSet< GridType > | Class that performs various types of checks on narrow-band level sets |
| CCheckMagnitude< GridT, TreeIterT > | Check that the magnitude of a value, a, is close to a fixed magnitude, b, given a fixed tolerance c. That is | |a| - |b| | <= c |
| CCheckMax< GridT, TreeIterT > | Checks a value against a maximum |
| CCheckMin< GridT, TreeIterT > | Checks a value against a minimum |
| CCheckNan< GridT, TreeIterT > | Checks NaN values |
| CCheckNormGrad< GridT, TreeIterT, GradScheme > | Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max] |
| CCheckRange< GridT, MinInclusive, MaxInclusive, TreeIterT > | Checks a value against a range |
| CInternalNode< _ChildNodeType, Log2Dim >::ChildAll | |
| CLeafNode< T, Log2Dim >::ChildAll | |
| CLeafNode< BuildT, CoordT, MaskT, Log2Dim >::ChildNodeType | |
| CInternalNode< _ChildNodeType, Log2Dim >::ChildOff | |
| CLeafNode< T, Log2Dim >::ChildOff | |
| CInternalNode< _ChildNodeType, Log2Dim >::ChildOn | |
| CLeafNode< T, Log2Dim >::ChildOn | |
| CClosestPointProjector< CptGridT > | |
| CClosestSurfacePoint< GridT > | Accelerated closest surface point queries for narrow band level sets |
| Ccnanovdb_coord | |
| Ccnanovdb_gridblindmetadata | |
| Ccnanovdb_griddata | |
| Ccnanovdb_map | |
| Ccnanovdb_mask3 | |
| Ccnanovdb_mask4 | |
| Ccnanovdb_mask5 | |
| Ccnanovdb_node0F | |
| Ccnanovdb_node0F3 | |
| Ccnanovdb_node1F | |
| Ccnanovdb_node1F3 | |
| Ccnanovdb_node2F | |
| Ccnanovdb_node2F3 | |
| Ccnanovdb_readaccessor | |
| Ccnanovdb_rootdata_tileF | |
| Ccnanovdb_rootdata_tileF3 | |
| Ccnanovdb_rootdataF | |
| Ccnanovdb_rootdataF3 | |
| Ccnanovdb_stencil1F | |
| Ccnanovdb_stencil1F3 | |
| Ccnanovdb_tileentryF | |
| Ccnanovdb_tileentryF3 | |
| Ccnanovdb_treedata | |
| Ccnanovdb_Vec3F | |
| CImage::ColorRGB | |
| CCombineArgs< AValueType, BValueType > | This struct collects both input and output arguments to "grid combiner" functors used with the tree::TypedGrid::combineExtended() and combine2Extended() methods. AValueType and BValueType are the value types of the two grids being combined |
| CCombineOpAdapter< AValueT, CombineOp, BValueT > | Helper class to adapt a three-argument (a, b, result) CombineOp functor into a single-argument functor that accepts a CombineArgs struct |
| CCompiler | The compiler class. This holds an llvm context and set of compiler options, and constructs executable objects (e.g. PointExecutable or VolumeExecutable) from a syntax tree or snippet of code |
| CCompilerOptions | Settings which control how a Compiler class object behaves |
| CComponentExtent< VecT > | Vector component-wise op to evaluate the min/max of vector components and return the result as a vector of equal size and precision |
| CCompositeFunctorTranslator< OP, ValueT > | Translator that converts an enum to compositing functor types |
| CCompositeFunctorTranslator< DS_ADD, ValueT > | |
| CCompositeFunctorTranslator< DS_MAX, ValueT > | |
| CCompositeFunctorTranslator< DS_MIN, ValueT > | |
| CCompositeFunctorTranslator< DS_MULT, ValueT > | |
| CCompositeFunctorTranslator< DS_OVER, ValueT > | |
| CCompositeFunctorTranslator< DS_SUB, ValueT > | |
| CCompositeOp | |
| CCompoundMap< FirstMapType, SecondMapType > | Creates the composition of two maps, each of which could be a composition. In the case that each component of the composition classified as linear an acceleration AffineMap is stored |
| CCompReplaceOp< TreeT > | |
| CComputeKernel | The function definition and signature which is built by the ComputeGenerator |
| CConstantFolder< SignatureT, I > | Constant folding support structure |
| CConstantFolder< SignatureT, 0 > | |
| CConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType > | |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstRow | Read-only accessor to a row of this matrix |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstValueIter | Iterator over the stored values in a row of this matrix |
| CContainer | |
| CContiguousOp< ValueT, PointWiseOp > | Wrapper struct used to avoid unnecessary computation of memory access from Coord when all offsets are guaranteed to be within the dense grid |
| CConversion | Dummy class for tag dispatch of conversion constructors |
| CConvertElementType< T, SubT > | Conversion classes for changing the underlying type of VDB types |
| CConvertElementType< math::Mat3< T >, SubT > | |
| CConvertElementType< math::Mat4< T >, SubT > | |
| CConvertElementType< math::Quat< T >, SubT > | |
| CConvertElementType< math::Vec2< T >, SubT > | |
| CConvertElementType< math::Vec3< T >, SubT > | |
| CConvertElementType< math::Vec4< T >, SubT > | |
| CConvertTrait< T > | |
| CConvertTrait< Vec3< T > > | |
| CConvertTrait< Vec4< T > > | |
| CCoord | Signed (x, y, z) 32-bit integer coordinates |
| CCoord | Signed (i, j, k) 32-bit integer coordinate class, similar to openvdb::math::Coord |
| CCoordBBox | Axis-aligned bounding box of signed integer coordinates |
| CCopyableOpApplier< IterT, OpT > | |
| CCopyableOpTransformer< InIterT, OutTreeT, OpT > | |
| CCopyConstness< FromType, ToType > | CopyConstness<T1, T2>::Type is either const T2 or T2 with no const qualifier, depending on whether T1 is const |
| CCopyFromDense< _TreeT, _DenseT > | Copy the values from a dense grid into an OpenVDB tree |
| CLocalMovePointsOp< TreeT >::CopyIterator | |
| CGlobalMovePointsOp< TreeT >::CopyIterator | |
| CCopyOp< T > | |
| CCopyToDense< _TreeT, _DenseT > | Copy an OpenVDB tree into an existing dense grid |
| CCPT< MapType, DiffScheme > | Compute the closest-point transform to a level set |
| CCpt< InGridT, MaskGridType, InterruptT > | Compute the closest-point transform of a scalar grid |
| CCPT_RANGE< MapType, DiffScheme > | Compute the closest-point transform to a level set |
| CCpuTimer | Simple timer for basic profiling |
| CCpuTimer< Accuracy > | |
| CCRC32 | Class that computes the Cyclic Redundancy Check (CRC) |
| CCsgDifferenceOp< TreeT > | DynamicNodeManager operator to merge two trees using a CSG difference |
| CCsgUnionOrIntersectionOp< TreeT, Union > | DynamicNodeManager operator to merge trees using a CSG union or intersection |
| CCudaDeviceBuffer | Simple memory buffer using un-managed pinned host memory when compiled with NVCC. Obviously this class is making explicit used of CUDA so replace it with your own memory allocator if you are not using CUDA |
| CCurl< MapType, DiffScheme > | Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map |
| CCurl< GridT, MaskGridType, InterruptT > | Compute the curl of a vector grid |
| CCurl< UniformScaleMap, CD_2ND > | Full template specialization of Curl |
| CCurl< UniformScaleMap, DiffScheme > | Partial template specialization of Curl |
| CCurl< UniformScaleTranslateMap, CD_2ND > | Full template specialization of Curl |
| CCurl< UniformScaleTranslateMap, DiffScheme > | Partial template specialization of Curl |
| CCustomData | The custom data class is a simple container for named openvdb metadata. Its primary use case is passing arbitrary "external" data to an AX executable object when calling Compiler::compile. For example, it is the mechanism by which we pass data held inside of a parent DCC to executable AX code |
| CD1< DiffScheme > | |
| CD1< BD_1ST > | |
| CD1< BD_2ND > | |
| CD1< BD_3RD > | |
| CD1< BD_HJWENO5 > | |
| CD1< BD_WENO5 > | |
| CD1< CD_2ND > | |
| CD1< CD_2NDT > | |
| CD1< CD_4TH > | |
| CD1< CD_6TH > | |
| CD1< FD_1ST > | |
| CD1< FD_2ND > | |
| CD1< FD_3RD > | |
| CD1< FD_HJWENO5 > | |
| CD1< FD_WENO5 > | |
| CD1Vec< DiffScheme > | |
| CD1Vec< CD_2ND > | |
| CD1Vec< CD_2NDT > | |
| CD1Vec< CD_4TH > | |
| CD1Vec< CD_6TH > | |
| CD2< DiffScheme > | |
| CD2< CD_FOURTH > | |
| CD2< CD_SECOND > | |
| CD2< CD_SIXTH > | |
| CDDA< RayT, Log2Dim > | A Digital Differential Analyzer specialized for OpenVDB grids |
| CDDA< RayT, CoordT, Dim > | A Digital Differential Analyzer. Unlike HDDA (defined above) this DDA uses a fixed step-size defined by the template parameter Dim! |
| CDDA< RayT, LeafT::TOTAL > | |
| CDDA< RayT, NodeT::TOTAL > | |
| CDDA< RayType, NodeT::TOTAL > | |
| CTree< _RootNodeType >::DeallocateNodes< NodeType > | |
| CDeepCopy | Tag dispatch class that distinguishes constructors that deep copy |
| CInternalNode< _ChildNodeType, Log2Dim >::DeepCopy< OtherInternalNode > | |
| CDefault< ValueType > | |
| CDeformerTraits< DeformerT > | Deformer Traits for optionally configuring deformers to be applied in index-space. The default is world-space |
| CDelta< T > | Delta for small floating-point offsets |
| CDelta< T > | Delta for small floating-point offsets |
| CDelta< double > | |
| CDelta< double > | |
| CDelta< float > | |
| CDelta< float > | |
| ►CDenseBase< ValueT, Layout > | Base class for Dense which is defined below |
| 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 |
| ►CDenseData | |
| CDenseGrid< ValueT > | Simple dense grid class |
| CDenseGridHandle< BufferT > | |
| CDenseTransformer< _ValueT, OpType > | Class that applies a functor to the index space intersection of a prescribed bounding box and the dense grid. NB: This class only supports DenseGrids with ZYX memory layout |
| CDepthFirstNodeVisitor< NodeT, LEVEL > | Visit all nodes that are downstream of a specific node in depth-first order and apply a user-supplied functor to each node |
| CDepthFirstNodeVisitor< NodeT, 0 > | |
| ►CDescriptor | |
| CAttributeSet | Ordered collection of uniquely-named attribute arrays |
| CVector< T >::DeterministicDotProductOp | |
| CDiagnose< GridT > | Performs multithreaded diagnostics of a grid |
| CDiagnose< GridType > | |
| CFastSweeping< SdfGridT, ExtValueT >::DilateKernel | Private class of FastSweeping to perform multi-threaded initialization |
| CDiracDelta< RealT > | Smeared-out and continuous Dirac Delta function |
| CDirichletBoundaryOp< ValueType > | Dirichlet boundary condition functor |
| CDiscreteField< VelGridT, Interpolator > | Thin wrapper class for a velocity grid |
| CDitherLUT | |
| CDivergence< MapType, DiffScheme > | Compute the divergence of a vector-valued grid using differencing of various orders, the result defined with respect to the range-space of the map |
| CDivergence< InGridT, MaskGridType, InterruptT > | Compute the divergence of a vector grid |
| CDivergence< ScaleMap, CD_2ND > | |
| CDivergence< ScaleMap, DiffScheme > | |
| CDivergence< ScaleTranslateMap, CD_2ND > | |
| CDivergence< ScaleTranslateMap, DiffScheme > | |
| CDivergence< TranslationMap, DiffScheme > | |
| CDivergence< UniformScaleMap, CD_2ND > | |
| CDivergence< UniformScaleMap, DiffScheme > | |
| CDivergence< UniformScaleTranslateMap, CD_2ND > | |
| CDivergence< UniformScaleTranslateMap, DiffScheme > | |
| CDSConverter< DenseType, TreeType > | |
| CDualGridSampler< GridOrTreeT, SamplerT > | This is a simple convenience class that allows for sampling from a source grid into the index space of a target grid. At construction the source and target grids are checked for alignment which potentially renders interpolation unnecessary. Else interpolation is performed according to the templated Sampler type |
| CDualGridSampler< AccT, SamplerT > | |
| CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT > | Specialization of DualGridSampler for construction from a ValueAccessor type |
| CDummySampleType | |
| CDynamicNodeManager< TreeOrLeafManagerT, _LEVELS > | |
| CDynamicNodeManagerLink< NodeT, LEVEL > | This class is a link in a chain that each caches tree nodes of a specific type in a linear array |
| CDynamicNodeManagerLink< ChildNodeType, LEVELS-1 > | |
| CMeshToVoxelEdgeData::EdgeData | Internal edge data type |
| Cenable_if< bool, T > | C++11 implementation of std::enable_if |
| Cenable_if< true, T > | |
| CEnrightField< ScalarT > | Analytical, divergence-free and periodic velocity field |
| ►Cexception | |
| ►CException | |
| CArithmeticError | |
| CAXCodeGenError | |
| CAXCompilerError | |
| CAXExecutionError | |
| CAXSyntaxError | |
| CAXTokenError | |
| CIndexError | |
| CIoError | |
| CKeyError | |
| CLookupError | |
| CNotImplementedError | |
| CReferenceError | |
| CRuntimeError | |
| CTypeError | |
| CValueError | |
| CExtractAll< _ResultTreeType, DenseValueType > | Simple utility class used by extractSparseTreeWithMask |
| ►CExtrema | This class computes the minimum and maximum values of a population of floating-point values |
| CStats | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values |
| CExtrema< ValueT, Rank > | |
| ►CExtrema< ValueT, 0 > | Template specialization of Extrema on scalar value types, i.e. rank = 0 |
| CStats< ValueT, 0 > | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values |
| ►CExtrema< ValueT, 1 > | |
| CStats< ValueT, 1 > | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values |
| CExtrema< VecT, 1 > | Template specialization of Extrema on vector value types, i.e. rank = 1 |
| ►Cfalse_type | |
| CIsSpecializationOf< T, Template > | Helper metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter |
| CFastSweeping< SdfGridT, ExtValueT > | Computes signed distance values from an initial iso-surface and optionally performs velocity extension at the same time. This is done by means of a novel sparse and parallel fast sweeping algorithm based on a first order Godunov's scheme |
| CLeafBuffer< T, Log2Dim >::FileInfo | |
| CFillOp< T > | |
| CFilm | A simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM file output |
| CFilter< GridT, MaskT, InterruptT > | Volume filtering (e.g., diffusion) with optional alpha masking |
| CFilterTraits< T > | |
| CFilterTraits< BBoxFilter > | |
| CFilterTraits< BinaryFilter< T0, T1, And > > | |
| CFilterTraits< LevelSetFilter< T > > | |
| CFilterType | Selectively extract and filter point data using a custom filter operator |
| CFindActiveValues< TreeT > | Finds the active values in a tree which intersects a bounding box |
| CFixedPointCodec< OneByte, Range > | |
| CFloatTraits< T, int > | |
| CFloatTraits< bool, 1 > | |
| CFloatTraits< BuildT > | |
| CFloatTraits< T, 8 > | |
| CFloatTraits< ValueMask, 1 > | |
| CFloatTraits< ValueT > | |
| Cflt_t< Bits > | |
| Cflt_t< 16ul > | |
| Cflt_t< 32ul > | |
| Cflt_t< 64ul > | |
| CForeachFilterOp< OpT > | |
| CFormattedInt< IntT > | I/O manipulator that formats integer values with thousands separators |
| CFp16 | Dummy type for a 16bit quantization of float point values |
| CFp4 | Dummy type for a 4bit quantization of float point values |
| CFp8 | Dummy type for a 8bit quantization of float point values |
| CFpN | Dummy type for a variable bit quantization of floating point values |
| ►CFunction | The base/abstract representation of an AX function. Derived classes must implement the Function::types call to describe their signature |
| ►CCFunctionBase | The base class for all C bindings |
| ►CCFunction< SignatureT > | Represents a concrete C function binding |
| ►CSRetFunction< SignatureT, CFunction< SignatureT > > | |
| CCFunctionSRet< SignatureT > | Represents a concrete C function binding with the first argument as its return type |
| ►CIRFunctionBase | The base/abstract definition for an IR function |
| ►CIRFunction< SignatureT > | Represents a concrete IR function |
| ►CSRetFunction< SignatureT, IRFunction< SignatureT > > | |
| CIRFunctionSRet< SignatureT > | Represents a concrete IR function with the first argument as its return type |
| CFunctionBuilder | Builder pattern framework to allow easy and valid construction of AX functions. There are a number of complex tasks which may need to be performed during construction of C or IR function which are delegated to this builder, whilst ensuring that the constructed functions are guaranteed to be valid |
| CFunctionGroup | Todo |
| CFunctionOptions | Options that control how functions behave |
| CFunctionRegistry | The function registry which is used for function code generation. Each time a function is visited within the AST, its identifier is used as a key into this registry for the corresponding function retrieval and execution. Functions can be inserted into the registry using insert() with a given identifier and pointer |
| CFunctionTraits< SignatureT > | Templated function traits which provides compile-time index access to the types of the function signature |
| ►CFunctionTraits< R(Args...)> | |
| CFunctionTraits< R(&)(Args...)> | |
| CFunctionTraits< R(*)(Args...)> | |
| CFunctionTraits< ReturnT(Args...)> | |
| 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 | |
| CGenAdaptivityMaskOp< IndexTreeType, BoolTreeType > | TBB body object for threaded sharp feature construction |
| CMeshToVoxelEdgeData::GenEdgeData | |
| CGenericMap | A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators |
| CGlobalMovePointsOp< TreeT > | |
| CGradient< MapType, DiffScheme > | Center difference gradient operators, defined with respect to the range-space of the map |
| CGradient< InGridT, MaskGridType, InterruptT > | Compute the gradient of a scalar grid |
| CGradient< ScaleMap, CD_2ND > | |
| CGradient< ScaleTranslateMap, CD_2ND > | |
| CGradient< TranslationMap, DiffScheme > | |
| CGradient< UniformScaleMap, CD_2ND > | |
| CGradient< UniformScaleTranslateMap, CD_2ND > | |
| CGradientBiased< MapType, GradScheme > | Biased gradient operators, defined with respect to the range-space of the map |
| CGradientNormSqrd< MapType, GradScheme > | |
| CGradientNormSqrd< UniformScaleMap, GradScheme > | Partial template specialization of GradientNormSqrd |
| CGradientNormSqrd< UniformScaleTranslateMap, GradScheme > | Partial template specialization of GradientNormSqrd |
| CGridBlindMetaData | |
| CGridBuilder< ValueT, BuildT, StatsT > | Allows for the construction of NanoVDB grids without any dependecy |
| CGridChecksum | Class that encapsulates two CRC32 checksums, one for the Grid, Tree and Root node meta data and one for the remaining grid nodes |
| ►CGridData | Struct with all the member data of the Grid (useful during serialization of an openvdb grid) |
| CGrid< TreeT > | Highest level of the data structure. Contains a tree and a world->index transform (that currently only supports uniform scaling and translation) |
| CGridDescriptor | |
| ►CGridHandleBase | |
| CGridHandle< BufferT > | This class serves to manage a raw memory buffer of a NanoVDB Grid |
| CGridMetaData | This is a convenient class that allows for access to grid meta-data that are independent of the value type of a grid. That is, this class can be used to get information about a grid without actually knowing its ValueType |
| CGridNamePred | Predicate functor that returns true for grids that have a specified name |
| CGridOperator< InGridT, MaskGridType, OutGridT, MapT, OperatorT, InterruptT > | Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type |
| CGridResampleOp< Sampler, TransformerType > | GridResampleOp is a functor class for use with UTvdbProcessTypedGrid() that samples an input grid into an output grid of the same type through a given transform |
| ►CGridResampler | |
| 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 |
| CGridResampleToMatchOp< Sampler > | GridResampleToMatchOp is a functor class for use with GridBase::apply() that samples an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide, but the output grid's transform is unchanged |
| CGridSampler< GridOrTreeType, SamplerType > | Class that provides the interface for continuous sampling of values in a tree |
| CGridSampler< tree::ValueAccessor< TreeT >, SamplerType > | Specialization of GridSampler for construction from a ValueAccessor type |
| CGridStats< GridT, StatsT > | Allows for the construction of NanoVDB grids without any dependecy |
| CGridTransformOp< Sampler > | GridTransformOp is a functor class for use with GridBase::apply() that samples an input grid into an output grid of the same type through a given affine transform |
| CGridTree< GridT > | Defines a tree type from a grid type while perserving constness |
| CGridTree< const GridT > | |
| CGridValidator< ValueT > | Allows for the construction of NanoVDB grids without any dependecy |
| CGroupCodec | |
| CGroupFilter | Index filtering on group membership |
| ►CGroupHandle | |
| CGroupWriteHandle | |
| ►CGT_GEOPrimCollect | |
| CGT_GEOPrimCollectVDB | |
| CGU_VDBPointList< VectorType > | Houdini point attribute wrapper |
| Chalf | |
| CHalf | Dummy type for a 16 bit floating point values |
| CHalfReader< IsReal, T > | |
| CHalfReader< false, T > | Partial specialization for non-floating-point types (no half to float promotion) |
| CHalfReader< true, T > | Partial specialization for floating-point types |
| CHalfWidthOp< ValueType > | |
| CHalfWidthOp< bool > | |
| CHalfWriter< IsReal, T > | |
| CHalfWriter< false, T > | Partial specialization for non-floating-point types (no float to half quantization) |
| CHalfWriter< true, T > | Partial specialization for floating-point types |
| Chash< openvdb::math::Coord > | |
| CHasMultiPassIO< LeafNodeType > | Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data |
| CHasMultiPassIO< Grid< TreeType > > | |
| CHasMultiPassIO< tree::Tree< RootNodeType > > | |
| CHDDA< RayT, CoordT > | A Digital Differential Analyzer specialized for OpenVDB grids |
| CHDDA< RayT, nanovdb::Coord > | |
| CHeader | Data encoded at the head of each segment of a file or stream |
| CHistogram | This class computes a histogram, with a fixed interval width, of a population of floating-point values |
| CHomogeneousMatMul | |
| CHostBuffer | This is a buffer that contains a shared or private pool to either externally or internally managed host memory |
| ►CImageData | |
| CImage | |
| CImageHandle< BufferT > | |
| CInactivePruneOp< TreeT, TerminationLevel > | |
| Cindex_sequence<... > | |
| ►Cindex_sequence< Is... > | |
| Cmake_index_sequence< 0, Is... > | |
| CIndexIter< IteratorT, FilterT > | A forward iterator over array indices with filtering IteratorT can be either IndexIter or ValueIndexIter (or some custom index iterator) FilterT should be a struct or class with a valid() method than can be evaluated per index Here's a simple filter example that only accepts even indices: |
| CPointPartitioner< PointIndexType, BucketLog2Dim >::IndexIterator | |
| CIndexToOffsetOp< PointArrayType > | |
| CVector< T >::InfNormOp | |
| CFastSweeping< SdfGridT, ExtValueT >::InitSdf | |
| CAttributeSet::Inserter | Utility method to construct a NameAndType sequence |
| Cint_t< Bits > | |
| Cint_t< Bits, Signed > | |
| Cint_t< 16 > | |
| Cint_t< 16ul, false > | |
| Cint_t< 16ul, true > | |
| Cint_t< 32 > | |
| Cint_t< 32ul, false > | |
| Cint_t< 32ul, true > | |
| Cint_t< 64 > | |
| Cint_t< 64ul, false > | |
| Cint_t< 64ul, true > | |
| Cint_t< 8 > | |
| Cint_t< 8ul, false > | |
| Cint_t< 8ul, true > | |
| CInternalData< ChildT, LOG2DIM > | Struct with all the member data of the InternalNode (useful during serialization of an openvdb InternalNode) |
| ►CInternalData< ChildT, Log2Dim > | |
| CInternalNode< ChildT, Log2Dim > | Internal nodes of a VDB treedim(), |
| CInternalNode< _ChildNodeType, Log2Dim > | |
| CInterrupter | Deprecated wrapper class with the same interface as HoudiniInterrupter, however it does not derive from openvdb::util::NullInterrupter. Intended for backwards-compatibility only |
| CInvertedTree< HeadT, HeadLevel > | |
| CInvertedTree< HeadT, 1 > | |
| Cis_diagonal_jacobian< T > | |
| Cis_double< T > | |
| Cis_double< double > | |
| Cis_floating_point< T > | C++11 implementation of std::is_floating_point |
| Cis_linear< T > | Map traits |
| Cis_linear< AffineMap > | |
| Cis_linear< CompoundMap< T1, T2 > > | |
| Cis_linear< ScaleMap > | |
| Cis_linear< ScaleTranslateMap > | |
| Cis_linear< TranslationMap > | |
| Cis_linear< UniformScaleMap > | |
| Cis_linear< UniformScaleTranslateMap > | |
| Cis_linear< UnitaryMap > | |
| Cis_same< T1, T2 > | C++11 implementation of std::is_same |
| Cis_same< T, T > | |
| Cis_scale< T > | |
| Cis_scale< ScaleMap > | |
| Cis_scale_translate< T > | |
| Cis_scale_translate< ScaleTranslateMap > | |
| Cis_specialization< AnyType, TemplateType > | Metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter |
| Cis_specialization< TemplateType< Args... >, TemplateType > | |
| Cis_uniform_diagonal_jacobian< T > | |
| Cis_uniform_scale< T > | |
| Cis_uniform_scale< UniformScaleMap > | |
| Cis_uniform_scale_translate< T > | |
| Cis_uniform_scale_translate< TranslationMap > | |
| Cis_uniform_scale_translate< UniformScaleTranslateMap > | |
| Cis_vec3d< Vec3T > | |
| Cis_vec3d< Vec3d > | |
| CISCurl< DiffScheme > | Curl operator defined in index space using various first derivative schemes |
| CISDivergence< DiffScheme > | Divergence operator defined in index space using various first derivative schemes |
| CVector< T >::IsFiniteOp | |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::IsFiniteOp | |
| CISGradient< DiffScheme > | Gradient operators defined in index space of various orders |
| CISGradientBiased< GradScheme, Vec3Bias > | Biased Gradient Operators, using upwinding defined by the Vec3Bias input |
| CISGradientNormSqrd< GradScheme > | |
| CISLaplacian< DiffScheme > | Laplacian defined in index space, using various center-difference stencils |
| CISLaplacian< CD_FOURTH > | |
| CISLaplacian< CD_SECOND > | |
| CISLaplacian< CD_SIXTH > | |
| CISMeanCurvature< DiffScheme2, DiffScheme1 > | Compute the mean curvature in index space |
| CISOpMagnitude< OpType > | Adapter for vector-valued index-space operators to return the vector magnitude |
| CBIAS_SCHEME< bgs >::ISStencil< GridType, IsSafe > | |
| CBIAS_SCHEME< FIRST_BIAS >::ISStencil< GridType, IsSafe > | |
| CBIAS_SCHEME< SECOND_BIAS >::ISStencil< GridType, IsSafe > | |
| CBIAS_SCHEME< THIRD_BIAS >::ISStencil< GridType, IsSafe > | |
| CBIAS_SCHEME< WENO5_BIAS >::ISStencil< GridType, IsSafe > | |
| CBIAS_SCHEME< HJWENO5_BIAS >::ISStencil< GridType, IsSafe > | |
| CCoordBBox::Iterator< ZYXOrder > | Iterator over the Coord domain covered by a CoordBBox |
| CBBox< CoordT, false >::Iterator | Iterator over the domain covered by a BBox |
| CMask< LOG2DIM >::Iterator | |
| CParticleAtlas< PointIndexGridType >::Iterator | Provides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas |
| ►Citerator | |
| CPagedArray< ValueT, Log2PageSize >::ConstIterator | |
| CPagedArray< ValueT, Log2PageSize >::Iterator | |
| CLeafManager< TreeT >::LeafRange::Iterator | |
| CNodeList< NodeT >::NodeRange::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 |
| CLeafNode< ValueMask, 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 > | |
| CLeafNode< ValueMask, 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 > | |
| CLeafNode< ValueMask, 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< NodeT, IterT > | |
| CIterTraits< NodeT, typename NodeT::ChildAllCIter > | |
| CIterTraits< NodeT, typename NodeT::ChildAllIter > | |
| CIterTraits< NodeT, typename NodeT::ChildOffCIter > | |
| CIterTraits< NodeT, typename NodeT::ChildOffIter > | |
| CIterTraits< NodeT, typename NodeT::ChildOnCIter > | |
| CIterTraits< NodeT, typename NodeT::ChildOnIter > | |
| CIterTraits< NodeT, typename NodeT::ValueAllCIter > | |
| CIterTraits< NodeT, typename NodeT::ValueAllIter > | |
| CIterTraits< NodeT, typename NodeT::ValueOffCIter > | |
| CIterTraits< NodeT, typename NodeT::ValueOffIter > | |
| CIterTraits< NodeT, typename NodeT::ValueOnCIter > | |
| CIterTraits< NodeT, typename NodeT::ValueOnIter > | |
| CIterTraits< typename PrevIterT::NonConstNodeType, PrevIterT > | |
| CLaplacian< MapType, DiffScheme > | Compute the Laplacian at a given location in a grid using finite differencing of various orders. The result is defined in the range of the map |
| CLaplacian< GridT, MaskGridType, InterruptT > | |
| CLaplacian< ScaleMap, DiffScheme > | |
| CLaplacian< ScaleTranslateMap, DiffScheme > | |
| CLaplacian< TranslationMap, DiffScheme > | |
| CLaplacian< UniformScaleMap, DiffScheme > | |
| CLaplacian< UniformScaleTranslateMap, DiffScheme > | |
| CLaplacian< UnitaryMap, DiffScheme > | |
| CCachedDeformer< T >::Cache::Leaf | |
| CLeafBuffer< T, Log2Dim > | Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode |
| CLeafBuffer< bool, Log2Dim > | |
| CLeafBuffer< ValueType, Log2Dim > | |
| CLeafData< ValueT, CoordT, MaskT, LOG2DIM > | Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode) |
| CLeafData< bool, CoordT, MaskT, LOG2DIM > | |
| ►CLeafData< BuildT, CoordT, MaskT, Log2Dim > | |
| CLeafNode< BuildT, CoordT, MaskT, Log2Dim > | Leaf nodes of the VDB tree. (defaults to 8x8x8 = 512 voxels) |
| CLeafData< ValueMask, CoordT, MaskT, LOG2DIM > | |
| ►CLeafFnBase< CoordT, MaskT, LOG2DIM > | Base-class for quantized float leaf nodes |
| CLeafData< Fp16, CoordT, MaskT, LOG2DIM > | |
| CLeafData< Fp4, CoordT, MaskT, LOG2DIM > | Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode) |
| CLeafData< Fp8, CoordT, MaskT, LOG2DIM > | |
| CLeafData< FpN, CoordT, MaskT, LOG2DIM > | |
| CLeafIteratorBase< TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels) |
| CLeafManager< GridT > | LeafNanager maintains a linear array of leaf nodes |
| CLeafManager< TreeT > | This class manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxiliary buffers (one or more per leaf) that can be swapped with the leaf nodes' voxel data buffers |
| CLeafManager< TreeType > | |
| CLeafManagerImpl< ManagerT > | |
| CLeafManagerImpl< LeafManager< const TreeT > > | |
| ►CLeafNode< T, Log2Dim > | Templated block class to hold specific data types and a fixed number of values determined by Log2Dim. The actual coordinate dimension of the block is 2^Log2Dim, i.e. Log2Dim=3 corresponds to a LeafNode that spans a 8^3 block |
| CPointDataLeafNode< T, Log2Dim > | |
| CPointIndexLeafNode< T, Log2Dim > | |
| CLeafNode< bool, Log2Dim > | LeafNode specialization for values of type bool that stores both the active states and the values of (2^Log2Dim)^3 voxels as bit masks |
| CLeafNode< ValueMask, Log2Dim > | LeafNode specialization for values of type ValueMask that encodes both the active states and the boolean values of (2^Log2Dim)^3 voxels in a single bit mask, i.e. voxel values and states are indistinguishable! |
| CLeafManager< TreeT >::LeafRange | |
| CLeafTopologyDiffOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees |
| CLeafTopologyIntOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees |
| 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 |
| CLevelSetAdvection< GridT, FieldT, InterruptT > | Hyperbolic advection of narrow-band level sets in an external velocity field |
| CLevelSetFilter< LevelSetGridT > | |
| CLevelSetFracture< GridType, InterruptType > | Level set fracturing |
| CLevelSetHDDA< TreeT, NodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets |
| CLevelSetHDDA< TreeT,-1 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set |
| CLevelSetMeasure< GridT, InterruptT > | Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets |
| CLevelSetMorphing< GridT, InterruptT > | Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set |
| CLevelSetPruneOp< TreeT, TerminationLevel > | |
| CLevelSetRayIntersector< GridT, SearchImplT, NodeLevel, RayT > | This class provides the public API for intersecting a ray with a narrow-band level set |
| CLevelSetRayTracer< GridT, IntersectorT > | A (very) simple multithreaded ray tracer specifically for narrow-band level sets |
| CLevelSetSphere< GridT, InterruptT > | Generates a signed distance field (or narrow band level set) to a single sphere |
| ►CLevelSetTracker< GridT, InterruptT > | Performs multi-threaded interface tracking of narrow band level sets |
| 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 |
| CLinearOp< T > | |
| CLinearSearchImpl< GridT, Iterations, RealT > | Implements linear iterative search for an iso-value of the level set along the direction of the ray |
| ►CLLVMType< T > | LLVM type mapping from pod types |
| CLLVMType< const T > | |
| CLLVMType< codegen::String > | |
| ►CLLVMType< int_t< sizeof(void *)>::type * > | |
| CLLVMType< void * > | |
| ►CLLVMType< T * > | |
| CLLVMType< const T * > | |
| CLLVMType< T[S]> | |
| ►CLLVMType< uint8_t > | |
| CLLVMType< char > | |
| CLLVMType< void > | |
| CLocalMovePointsOp< TreeT > | |
| CLogger | Logger for collecting errors and warnings that occur during AX compilation |
| CMagnitude< InGridT, MaskGridType, InterruptT > | |
| CMagnitudeExtent< VecT, false > | Vector squared magnitude op to evaluate the min/max of a vector attribute and return the result as the original vector |
| Cmake_index_sequence< N, Is > | |
| CMap | Defines an affine transform and its inverse represented as a 3x3 matrix and a vec3 translation |
| CMapAdapter< MapType, OpType, ResultType > | Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator |
| ►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. 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 |
| ►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 |
| CMappedFile | Handle to control the lifetime of a memory-mapped .vdb file |
| CMapRegistry | Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function |
| CMask< LOG2DIM > | Bit-mask to encode active states and facilitate sequential iterators and a fast codec for I/O compression |
| CBaseStencil< DerivedType, SIZE, GridT >::Mask | |
| CMaskCompress< ValueT, MaskT > | |
| CMultiResGrid< TreeType >::MaskOp | |
| CTreeToMerge< TreeT >::MaskPtr | Wrapper around unique_ptr that deep-copies mask on copy construction |
| CTreeToMerge< TreeT >::MaskUnionOp | DynamicNodeManager operator used to generate a mask of the input tree, but with dense leaf nodes replaced with active tiles for compactness |
| ►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 |
| CMatMul | |
| CMatMulNormalize | |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::MatrixCopyOp | |
| CGridTransformer::MatrixTransform | |
| CMatTraits< T, bool > | |
| CMatTraits< T, false > | |
| CMaximum< T > | Maximum floating-point values |
| CMaxOp< ValueType > | |
| CMeanCurvature< MapType, DiffScheme2, DiffScheme1 > | Compute the mean curvature |
| CMeanCurvature< GridT, MaskGridType, InterruptT > | |
| CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 > | |
| CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 > | |
| CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 > | |
| CMeshAttrTransfer | |
| CMeshDataAdapter | Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes |
| CMeshToVoxelEdgeData | Extracts and stores voxel edge intersection data from a mesh |
| ►CMetadata | Base class for storing metadata information in a grid |
| CDelayedLoadMetadata | Store a buffer of data that can be optionally used during reading for faster delayed-load I/O performance |
| CTypedMetadata< T > | Templated metadata class to hold specific types |
| CUnknownMetadata | Subclass to hold raw data of an unregistered type |
| ►CMetaData | Data encoded for each of the grids associated with a segment |
| CGridMetaData | |
| ►CMetaMap | Container that maps names (strings) to values of arbitrary types |
| ►CGridBase | Abstract base class for typed grids |
| CGrid< _TreeType > | Container class that associates a tree with a transform and metadata |
| CMultiResGrid< TreeType > | |
| CMinMax< ValueType, Less > | Templated class to compute the minimum and maximum values |
| CFastSweeping< SdfGridT, ExtValueT >::MinMaxKernel | |
| CMinOp< ValueType > | |
| CMorphology< TreeType > | Dilation/Erosion operations over a Trees leaf level voxel topology |
| CMultiGroupFilter | |
| ►CMultiPass | Leaf nodes that require multi-pass I/O must inherit from this struct |
| CPointDataLeafNode< T, Log2Dim > | |
| CMultOp< ValueType > | |
| CMultOp< bool > | |
| CAttributeSet::Util::NameAndType | Attribute and type name pair |
| CFile::NameIterator | |
| CNanoNode< BuildT, LEVEL > | Trait to map from LEVEL to node type |
| CNanoNode< BuildT, 0 > | |
| CNanoNode< BuildT, 1 > | |
| CNanoNode< BuildT, 2 > | |
| CNanoNode< BuildT, 3 > | |
| CNanoToOpenVDB< ValueType > | This class will serialize an OpenVDB grid into a NanoVDB grid managed by a GridHandle |
| CFastSweeping< SdfGridT, ExtValueT >::SweepingKernel::NN | |
| ►CNode | The base abstract node which determines the interface and required methods for all derived concrete nodes which comprise a valid AST |
| ►CStatement | Abstract (pure-virtual) AST nodes |
| CBlock | A Block node represents a scoped list of statements. It may comprise of 0 or more statements, and specifically indicates that a new scope is activated, typically represented by curly braces. Note that a block does not alway have to be encapsulated by curly braces, but always represents a new scope |
| CConditionalStatement | ConditionalStatements represents all combinations of 'if', 'else' and 'else if' syntax and semantics. A single ConditionalStatement only ever represents up to two branches; an 'if' (true) and an optional 'else' (false). ConditionalStatements are nested within the second 'else' branch to support 'else if' logic. As well as both 'if' and 'else' branches, a ConditionalStatement also holds an Expression related to its primary condition |
| CDeclareLocal | DeclareLocal AST nodes symbolize a single type declaration of a local variable. These store the local variables that They also however store its specified type. These have the important distinction of representing the initial creation and allocation of a variable, in comparison to a Local node which only represents access |
| ►CExpression | Expressions are comprised of full or potentially partial parts of a full statement that may not necessary make up an entire valid statement on their own. For example, while a Binary Operator such as "3 + 5;"" is a valid statement on its own, the full statement
"3 + 5 + 6;" must be broken down into two expressions which together form the statement as well as determining precedence |
| CArrayPack | ArrayPacks represent temporary container creations of arbitrary sizes, typically generated through the use of curly braces {} |
| CArrayUnpack | ArrayUnpack represent indexing operations into AX container types, primarily vectors and matrices indexed by the square brackets [] syntax. Multiple levels of indirection (multiple components) can be specified but current construction is limited to either a single or double component lookup. Providing two components infers a matrix indexing operation |
| CAssignExpression | AssignExpressions represents a similar object construction to a BinaryOperator. AssignExpressions can be chained together and are thus derived as Expressions rather than Statements |
| CBinaryOperator | A BinaryOperator represents a single binary operation between a left hand side (LHS) and right hand side (RHS) expression. The operation type is stored as a tokens::OperatorToken enumerated type on the node. AX grammar guarantees that this token will only ever be a valid binary operator token type when initialized by the parser |
| CCast | Cast nodes represent the conversion of an underlying expression to a target type. Cast nodes are typically constructed from functional notation and do not represent construction of the target type, rather a type-casted conversion |
| CCommaOperator | |
| CCrement | A Crement node represents a single increment '++' and decrement '–' operation. As well as it's crement type, it also stores whether the semantics constructed a post or pre-crement i.e. ++a or a++ |
| CFunctionCall | FunctionCalls represent a single call to a function and any provided arguments. The argument list can be empty. The function name is expected to exist in the AX function registry |
| CTernaryOperator | A TernaryOperator represents a ternary (conditional) expression 'a ? b : c' which evaluates to 'b' if 'a' is true and 'c' if 'a' is false. Requires 'b' and 'c' to be convertibly typed expressions, or both void. The 'true' expression ('b') is optional with the conditional expression 'a' returned if it evaluates to true, otherwise returning 'c'. Note that 'a' will only be evaluated once in this case |
| CUnaryOperator | A UnaryOperator represents a single unary operation on an expression. The operation type is stored as a tokens::OperatorToken enumerated type on the node. AX grammar guarantees that this token will only every be a valid unary operator token type when initialized by the parser |
| ►CValueBase | ValueBases are a base class for anything that holds a value (literal). Derived classes store the actual typed values |
| CValue< T > | A Value (literal) AST node holds either literal text or absolute value information on all numerical, string and boolean constants. A single instance of a Value is templated on the requested scalar, boolean or string type. If scalar or boolean value is constructed from a string (as typically is the case in the parser), the value is automatically converted to its numerical representation. If this fails, the original text is stored instead |
| CValue< std::string > | Specialization of Values for strings |
| ►CVariable | Variables are a base type for Locals, Attributes and ExternalVariables. Unlike other abstract types, they also consolidate data for the derived types |
| CAttribute | Attributes represent any access to a primitive value, typically associated with the '@' symbol syntax. Note that the AST does not store any additional information on the given attribute other than its name and type, which together form a unique Attribute identifier known as the Attribute 'token'. A 'primitive value' in this instance refers to a value on an OpenVDB Volume or OpenVDB Points tree |
| CExternalVariable | ExternalVariable represent any access to external (custom) data, typically associated with the '$' symbol syntax. Note that the AST does not store any additional information on the given external other than its name and type, which together form a unique external identifier known as the ExternalVariable 'token'. This token is used by the compiler to map user provided values to these external values |
| CLocal | Local AST nodes represent a single accesses to a local variable. The only store the name of the variable being accessed |
| CKeyword | Keywords represent keyword statements defining changes in execution. These include those that define changes in loop execution such as break and continue, as well as return statements |
| CLoop | Loops represent for, while and do-while loop constructs. These all consist of a condition - evaluated to determine if loop iteration should continue, and a body which is the logic to be repeated. For loops also have initial statements which are evaluated prior to loop execution (at loop scope) and commonly used to set up iterators, and iteration expressions which are evaluated between iterations after the body and before the condition. Both conditions and initial statements can be declarations or expressions, so are Statements, and iteration expressions can consist of multiple expressions. The loop body is a Block defining its own scope (encapsulated by initial statement scope for for-loops) |
| CStatementList | Concrete AST nodes |
| CTree | A Tree is the highest concrete (non-abstract) node in the entire AX AST hierarchy. It represents an entire conversion of a valid AX string |
| CNodeChain< HeadT, HeadLevel > | NodeChain<RootNodeType, RootNodeType::LEVEL>::Type is a openvdb::TypeList that lists the types of the nodes of the tree rooted at RootNodeType in reverse order, from LeafNode to RootNode |
| CNodeChain< HeadT, 1 > | Specialization to terminate NodeChain |
| CIterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueAllIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT > | |
| CIterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT > | |
| CNodeFilter | |
| CReadAccessor< BuildT,-1,-1,-1 >::NodeInfo | |
| CNodeIteratorBase< _TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all nodes |
| CNodeList< NodeT > | This class caches tree nodes of a specific type in a linear array |
| CNodeList< ChildNodeType > | |
| CNodeList< NodeT0 > | |
| CNodeList< NodeT1 > | |
| CNodeList< NodeT2 > | |
| CNodeList< NodeT3 > | |
| CNodeManager< GridT > | NodeNanager maintains separate linear arrays of the three nodes types |
| CNodeManager< TreeOrLeafManagerT, _LEVELS > | To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree |
| CNodeManagerLink< NodeT, LEVEL > | This class is a link in a chain that each caches tree nodes of a specific type in a linear array |
| CNodeManagerLink< ChildNodeType, LEVELS-1 > | |
| CNodeMask< Log2Dim > | Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation |
| CNodeMask< 1 > | Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes |
| CNodeMask< 2 > | Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes |
| CMorphology< TreeType >::NodeMaskOp | Node Mask dilation/erosion operations for individual leaf nodes on a given tree. The leaf node may optionally belong to a different tree than the provided accessor, which will have the effect of dilating the leaf node mask into a different tree, or eroding the node mask based on corresponding neighbors in a different tree |
| CNodeList< NodeT >::NodeRange | |
| CGridStats< GridT, StatsT >::NodeStats | |
| CNodeTrait< GridOrTreeOrRootT, LEVEL > | Struct to derive node type from its level in a given grid, tree or root while perserving constness |
| CNodeTrait< const GridOrTreeOrRootT, 0 > | |
| CNodeTrait< const GridOrTreeOrRootT, 1 > | |
| CNodeTrait< const GridOrTreeOrRootT, 2 > | |
| CNodeTrait< const GridOrTreeOrRootT, 3 > | |
| CNodeTrait< GridOrTreeOrRootT, 0 > | |
| CNodeTrait< GridOrTreeOrRootT, 1 > | |
| CNodeTrait< GridOrTreeOrRootT, 2 > | |
| CNodeTrait< GridOrTreeOrRootT, 3 > | |
| CNodeUnion< ValueT, ChildT, Enable > | Default implementation of a NodeUnion that stores the child pointer and the value separately (i.e., not in a union). Types which select this specialization usually do not conform to the requirements of a union member, that is that the type ValueT is not trivially copyable. This implementation is thus NOT used for POD, math::Vec, math::Mat, math::Quat or math::Coord types, but is used (for example) with std::string |
| CNodeUnion< ValueT, ChildT, typename std::enable_if< std::is_trivially_copyable< ValueT >::value >::type > | |
| CNodeUnion< ValueT, ChildT, typename std::enable_if< std::is_trivially_copyable< ValueT >::value >::type > | Template specialization of a NodeUnion that stores the child pointer and the value together (int, float, pointer, etc.) |
| CNodeUnion< ValueType, ChildNodeType > | |
| CNoopStats< ValueT > | No-op Stats class |
| CNormalize< GridT, MaskGridType, InterruptT > | |
| CNullCodec | |
| 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 |
| CNullInterrupter | Base class for interrupters |
| ►CNullInterrupter | |
| CHoudiniInterrupter | Wrapper class that adapts a Houdini UT_Interrupt object for use with OpenVDB library routines |
| Cnumeric_limits< openvdb::v9_0::math::half > | |
| COpAccumulator< IterT, OpT > | |
| COpAdd< ValueT > | |
| COpenGridType< BuildT > | Grid trait that defines OpenVDB grids with the exact same configuration as NanoVDB grids |
| COpenGridType< openvdb::PointDataIndex32 > | Template specialization for the PointDataGrid |
| COpenGridType< openvdb::PointIndex32 > | Template specialization for the PointIndexGrid |
| COpenToNanoType< T > | Converts OpenVDB types to NanoVDB types, e.g. openvdb::Vec3f to nanovdb::Vec3f Template specializations are defined below |
| COpenToNanoType< openvdb::Coord > | Template specialization for openvdb::Coord |
| COpenToNanoType< openvdb::CoordBBox > | Template specialization for openvdb::CoordBBox |
| COpenToNanoType< openvdb::math::BBox< T > > | Template specialization for openvdb::math::BBox |
| COpenToNanoType< openvdb::math::Vec3< T > > | Template specialization for openvdb::math::Vec3 |
| COpenToNanoType< openvdb::math::Vec4< T > > | Template specialization for openvdb::math::Vec4 |
| COpenToNanoType< openvdb::ValueMask > | Template specialization for openvdb::ValueMask |
| COpenToNanoVDB< OpenBuildT, NanoBuildT, OracleT, BufferT > | This class will convert an OpenVDB grid into a NanoVDB grid managed by a GridHandle |
| ►COpFactory | Helper class to simplify operator registration |
| COpenVDBOpFactory | Use this class to register a new OpenVDB operator (SOP, POP, etc.) |
| 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 |
| COpPolicy | An OpPolicy customizes the behavior of an OpFactory. This base class specifies the required interface |
| COpSub< ValueT > | |
| CMagnitude< InGridT, MaskGridType, InterruptT >::OpT | |
| CNormalize< GridT, MaskGridType, InterruptT >::OpT | |
| COSNoise | |
| ►Costream | |
| CTempFile | Output stream to a unique temporary file |
| CPackedMaskConstructor | |
| 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 |
| CPagedArray< ValueT, Log2PageSize >::Page | |
| CPagedArray< ValueT, Log2PageSize > | Concurrent, page-based, dynamically-sized linear data structure with O(1) random access and STL-compliant iterators. It is primarily intended for applications that concurrently insert (a possibly unkown number of) elements into a dynamically growing linear array, and fast random access to said elements |
| 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 |
| CExtrema< VecT, 1 >::Pair | |
| CValueVoxelCIter::Parent | |
| CParmFactory | Helper class to simplify construction of PRM_Templates and dynamic user interfaces |
| CParmList | Parameter template list that is always terminated |
| CPartialCreate | Tag dispatch class that distinguishes constructors during file input |
| CParticleArray | Partition particles and performs range and nearest-neighbor searches |
| CParticleAtlas< PointIndexGridType > | |
| CParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT > | |
| Cpnanovdb_grid_handle_t | |
| Cpnanovdb_grid_t | |
| Cpnanovdb_grid_type_constants_t | |
| Cpnanovdb_gridblindmetadata_handle_t | |
| Cpnanovdb_gridblindmetadata_t | |
| Cpnanovdb_leaf_handle_t | |
| Cpnanovdb_leaf_t | |
| Cpnanovdb_lower_handle_t | |
| Cpnanovdb_lower_t | |
| Cpnanovdb_map_handle_t | |
| Cpnanovdb_map_t | |
| Cpnanovdb_readaccessor_t | |
| Cpnanovdb_root_handle_t | |
| Cpnanovdb_root_t | |
| Cpnanovdb_root_tile_handle_t | |
| Cpnanovdb_root_tile_t | |
| Cpnanovdb_tree_handle_t | |
| Cpnanovdb_tree_t | |
| Cpnanovdb_upper_handle_t | |
| Cpnanovdb_upper_t | |
| CPointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType > | |
| CPointArray | |
| CPointArray | Partitions points into BucketLog2Dim aligned buckets using a parallel radix-based sorting algorithm |
| CPointAttributeVector< ValueType > | Point-partitioner compatible STL vector attribute wrapper for convenience |
| CPointAttrTransfer | |
| CPointDataNodeChain< HeadT, HeadLevel > | Recursive node chain which generates a openvdb::TypeList value converted types of nodes to PointDataGrid nodes of the same configuration, rooted at RootNodeType in reverse order, from LeafNode to RootNode. See also TreeConverter<> |
| CPointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, 1 > | |
| CPointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, HeadLevel > | |
| CPointExecutable | Object that encapsulates compiled AX code which can be executed on a collection of VDB Point Data grids. Executables are created by the compiler and hold the final immutable JIT compiled function and context |
| CPointIndex< IntType_, Kind > | Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid |
| CPointIndexFilter< PointArray, TreeType > | |
| CPointIndexIterator< TreeType > | Accelerated range and nearest-neighbor searches for point index grids |
| ►CPointKernel | The function definition and signature which is built by the PointComputeGenerator |
| CPointRangeKernel | An additional function built by the PointComputeGenerator. Currently both compute and compute range functions have the same signature |
| CPointLeafLocalData | Various functions can request the use and initialization of point data from within the kernel that does not use the standard attribute handle methods. This data can then be accessed after execution to perform post-processes such as adding new groups, adding new string attributes or updating positions |
| CPointPartitioner< PointIndexType, BucketLog2Dim > | |
| ►CPointSampler | |
| CSampler< 0, false > | |
| CPointsToMask< GridT, InterrupterT > | Makes every voxel of a grid active if it contains a point |
| CPolygonPool | Collection of quads and triangles |
| CHostBuffer::Pool | |
| CPositionRange | |
| CPreconditioner< T > | Base class for conjugate gradient preconditioners |
| ►CPreconditioner< MatrixType::ValueType > | |
| CIncompleteCholeskyPreconditioner< MatrixType > | Preconditioner using incomplete Cholesky factorization |
| CJacobiPreconditioner< MatrixType > | Diagonal preconditioner |
| CPrimCpyOp | TBB body object for threaded primitive copy |
| CMultiResGrid< TreeType >::ProlongateOp | |
| Cpromote< S, T > | |
| CPromoteContainerType< T, ContainerT > | |
| ►CPromoteContainerType< T, math::Mat3 > | |
| CPromoteType< math::Mat3< T > > | |
| ►CPromoteContainerType< T, math::Mat4 > | |
| CPromoteType< math::Mat4< T > > | |
| ►CPromoteContainerType< T, math::Quat > | |
| CPromoteType< math::Quat< T > > | |
| ►CPromoteContainerType< T, math::Vec2 > | |
| CPromoteType< math::Vec2< T > > | |
| ►CPromoteContainerType< T, math::Vec3 > | |
| CPromoteType< math::Vec3< T > > | |
| ►CPromoteContainerType< T, math::Vec4 > | |
| CPromoteType< math::Vec4< T > > | |
| CPromoteType< T > | Promotion classes which provide an interface for elevating and demoting a scalar or VDB type to a higher or lower precision. Integer types preserve their sign. Types promotion are only valid between 8 to 64 bits (long doubles are not supported) |
| CQuadAndTriangleDataAdapter< PointType, PolygonType > | Contiguous quad and triangle data adapter class |
| ►CQuadraticSampler | |
| CSampler< 2, false > | |
| CQuantizedUnitVec | Unit vector occupying only 16 bits |
| CQuat< T > | |
| CQuatTraits< T, bool > | |
| CQuatTraits< T, false > | |
| CQueue | Queue for asynchronous output of grids to files or streams |
| CRand01< FloatType, EngineType > | Simple generator of random numbers over the range [0, 1) |
| CRand01< double, RandomGenerator > | |
| CRandInt< IntType, EngineType > | Simple random integer generator |
| CRandomLeafFilter< PointDataTreeT, RandGenT > | |
| CRange< int, typename > | |
| CRange< 1, T > | |
| CRange< 2, T > | |
| CRange< 3, T > | |
| CRay< RealT > | |
| CRay< RealT > | |
| CRay< double > | |
| CRayGenOp< Vec3T > | |
| CReadAccessor< BuildT, LEVEL0, LEVEL1, LEVEL2 > | |
| ►CReadAccessor< BuildT, 0, 1, 2 > | Node caching at all (three) tree levels |
| CPointAccessor< AttT > | Class to access points at a specific voxel location |
| CReadAccessor< BuildT, LEVEL0, LEVEL1,-1 > | |
| CReadAccessor< BuildT, LEVEL0,-1,-1 > | Node caching at a single tree level |
| CReadAccessor< BuildT,-1,-1,-1 > | A read-only value accessor with three levels of node caching. This allows for inverse tree traversal during lookup, which is on average significantly faster than calling the equivalent method on the tree (i.e. top-down traversal) |
| CReadAccessor< ValueType > | |
| CRealToHalf< T > | RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types |
| CRealToHalf< double > | |
| CRealToHalf< float > | |
| CRealToHalf< Vec2d > | |
| CRealToHalf< Vec2s > | |
| CRealToHalf< Vec3d > | |
| CRealToHalf< Vec3s > | |
| CReduceFilterOp< OpT > | |
| CPointsToMask< GridT, InterrupterT >::ReducePool | |
| CFunctionRegistry::RegisteredFunction | An object to represent a registered function, storing its constructor, a pointer to the function definition and whether it should only be available internally (i.e. to a developer, not a user) |
| CRelDiff | Compression oracle based on relative difference |
| CMultiResGrid< TreeType >::RestrictOp | |
| CFilm::RGBA | Floating-point RGBA components in the range [0, 1] |
| CRgba8 | 8-bit red, green, blue, alpha packed into 32 bit unsigned int |
| CFindActiveValues< TreeT >::RootChild | |
| ►CRootData< ChildT > | Struct with all the member data of the RootNode (useful during serialization of an openvdb RootNode) |
| CRootNode< ChildT > | Top-most node of the VDB tree structure |
| CRootNode< ChildType > | |
| CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, Compatible > | |
| CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true > | |
| CRootNodeCopyHelper< RootT, OtherRootT, Compatible > | |
| CRootNodeCopyHelper< RootT, OtherRootT, true > | |
| CRootNodeMask | |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::RowEditor | Read/write accessor to a row of this matrix |
| CInternalNode< _ChildNodeType, Log2Dim >::SameConfiguration< OtherNodeType > | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of an InternalNode with the same dimensions as this node and whose ChildNodeType has the same configuration as this node's ChildNodeType |
| CLeafNode< T, Log2Dim >::SameConfiguration< OtherNodeType > | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
| CLeafNode< bool, Log2Dim >::SameConfiguration< OtherNodeType > | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
| CLeafNode< ValueMask, Log2Dim >::SameConfiguration< OtherNodeType > | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node |
| CRootNode< ChildType >::SameConfiguration< OtherNodeType > | SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a RootNode whose ChildNodeType has the same configuration as this node's ChildNodeType |
| CSameInternalConfig< ChildT1, Dim1, NodeT2 > | |
| CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > > | |
| CSameLeafConfig< Dim1, NodeT2 > | |
| CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > > | |
| CSameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > > | |
| CSameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > > | |
| CSameRootConfig< ChildT1, NodeT2 > | |
| CSameRootConfig< ChildT1, RootNode< ChildT2 > > | |
| CSampleFromVoxels< TreeT, Order, UseCache > | |
| CSampleFromVoxels< TreeOrAccT, 0, false > | Nearest neighbor, i.e. zero order, interpolator without caching |
| CSampleFromVoxels< TreeOrAccT, 0, true > | Nearest neighbor, i.e. zero order, interpolator with caching |
| CSampler< Order, Staggered > | Provises a unified interface for sampling, i.e. interpolation |
| CSampleWithRounding | |
| CScalarMinMax< ValueT > | Scalar extent op to evaluate the min/max values of a single integral or floating point attribute type |
| ►CScalarMinMax< ValueTraits< VecT >::ElementType > | |
| CMagnitudeExtent< VecT, MagResult > | Vector squared magnitude op to evaluate the min/max of a vector attribute and return the result as a scalar of the appropriate precision |
| 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 |
| CScopedInputLock | Helper class to manage input locking |
| CAttributeArray::ScopedRegistryLock | |
| CSegment | |
| CFunctionBuilder::Settings | |
| CShallowCopy | Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors |
| CSharedOpApplier< IterT, OpT > | |
| CSharedOpTransformer< InIterT, OutTreeT, OpT > | |
| CSharpenFeaturesOp | TBB body object for threaded sharp feature construction |
| CSignedFloodFillOp< TreeOrLeafManagerT > | |
| ►CSOP_Node | |
| CSOP_NodeVDB | Base class from which to derive OpenVDB-related Houdini SOPs |
| ►CSOP_NodeCacheOptions | |
| CSOP_VDBCacheOptions | SOP_NodeCacheOptions subclass that adds methods specific to SOP_NodeVDB |
| CSparseExtractor< OpType, DenseType > | Functor-based class used to extract data that satisfies some criteria defined by the embedded OpType functor. The extractSparseTree function wraps this class |
| CSparseMaskedExtractor< DenseType, MaskTreeType > | Functor-based class used to extract data from a dense grid, at the index-space intersection with a supplied mask in the form of a sparse tree. The extractSparseTreeWithMask function wraps this class |
| CSparseStencilMatrix< ValueType_, STENCIL_SIZE > | Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE |
| CSparseStencilMatrix< OtherValueType, STENCIL_SIZE > | |
| CSparseStencilMatrix< ValueType, 4 > | |
| CSparseToDenseCompositor< CompositeMethod, _TreeT > | |
| CSplit | |
| ►CStaggeredBoxSampler | |
| CSampler< 1, true > | |
| ►CStaggeredPointSampler | |
| CSampler< 0, true > | |
| ►CStaggeredQuadraticSampler | |
| CSampler< 2, true > | |
| CLevelSetTracker< GridT, InterruptT >::State | Lightweight struct that stores the state of the LevelSetTracker |
| CState | Information about the state of a conjugate gradient solution |
| CStats< ValueT, Rank > | |
| CSteal | Tag dispatch class that distinguishes constructors that steal |
| CNullCodec::Storage< T > | |
| CGroupCodec::Storage< T > | |
| CStringCodec< Truncate >::Storage< T > | |
| CFixedPointCodec< OneByte, Range >::Storage< T > | |
| CTruncateCodec::Storage< T > | |
| CUnitVecCodec::Storage< T > | |
| 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) |
| CString | An extremely basic but native representation of a string class with SSO support. This exists to provide an interface between the AX C++ API and backend IR string logic. It is not designed to fulfill any other use and should very rarely be used directly |
| ►CStringAttributeHandle | |
| CStringAttributeWriteHandle | |
| CStringCodec< Truncate > | |
| CStringMetaCache | Class to compute a string->index map from all string:N metadata |
| CStringMetaInserter | Class to help with insertion of keyed string values into metadata |
| CStringTypeTrait< Truncate > | |
| CStringTypeTrait< true > | |
| CSumMergeOp< TreeT > | DynamicNodeManager operator to merge trees using a sum operation |
| CSumOp< ValueType > | |
| CSumOp< bool > | |
| CSwappedCombineOp< ValueType, CombineOp > | |
| CFastSweeping< SdfGridT, ExtValueT >::SweepingKernel | Private class of FastSweeping to perform concurrent fast sweeping in two directions |
| CSymbolTable | A symbol table which can be used to represent a single scoped set of a programs variables. This is simply an unordered map of strings to llvm::Values |
| CSymbolTableBlocks | A map of unique ids to symbol tables which can be used to represent local variables within a program. New scopes can be added and erased where necessary and iterated through using find(). Find assumes that tables are added through parented ascending ids |
| CTensorTraits< T, Rank > | |
| CTensorTraits< T, 0 > | |
| CTensorTraits< T, 1 > | |
| CTestLeafIO< typename > | |
| CInternalData< ChildT, LOG2DIM >::Tile | |
| CRootData< ChildT >::Tile | |
| CGridBuilder< ValueT, BuildT, StatsT >::BuildRoot< ChildT >::Tile | |
| CGridBuilder< ValueT, BuildT, StatsT >:: BuildNode< ChildT >::Tile | |
| CTileData< ValueType > | Struct that encodes a bounding box, value and level of a tile |
| CRay< RealT >::TimeSpan | |
| CRay< RealT >::TimeSpan | |
| CTolerance< T > | Tolerance for floating-point comparison |
| CTolerance< T > | Tolerance for floating-point comparison |
| CTolerance< double > | |
| CTolerance< double > | |
| CTolerance< float > | |
| CTolerance< float > | |
| CTolerancePruneOp< TreeT, TerminationLevel > | |
| CToMaskGrid< GridType > | ToMaskGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value equal to its active state |
| CTopologyCopy | Tag dispatch class that distinguishes topology copy constructors from deep copy constructors |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy1< OtherInternalNode > | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy2< OtherInternalNode > | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode > | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode > | |
| CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode > | |
| CTransferPointAttributesOp< GridType > | |
| CTransferPrimitiveAttributesOp< GridType > | |
| CTransform | |
| CTransformOp | TBB body object for threaded world to voxel space transformation and copy of points |
| 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 > | |
| CTreeConverter< TreeType > | Similiar to ValueConverter, but allows for tree configuration conversion to a PointDataTree. ValueConverter<PointDataIndex32> cannot be used as a PointDataLeafNode is not a specialization of LeafNode |
| CTreeData< ROOT_LEVEL > | |
| ►CTreeData< RootT::LEVEL > | |
| CTree< RootT > | VDB Tree, which is a thin wrapper around a RootNode |
| CTreeIterTraits< TreeT, IterT > | TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type |
| CTreeIterTraits< TreeT, typename TreeT::LeafCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::LeafIter > | |
| CTreeIterTraits< TreeT, typename TreeT::NodeCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::NodeIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueAllCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueAllIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueOffCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueOffIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueOnCIter > | |
| CTreeIterTraits< TreeT, typename TreeT::ValueOnIter > | |
| CTreeMarcher< NodeT, RayT, AccT, CoordT > | A Tree Marcher for Generic Grids |
| ►CTreeMarcher< LeafNode< AccT::ValueType >, RayT, AccT, CoordT > | |
| CPointTreeMarcher< AccT, RayT, CoordT > | A Tree Marcher for Point Grids |
| CTreeToMerge< TreeT > | Convenience class that contains a pointer to a tree to be stolen or deep copied depending on the tag dispatch class used and a subset of methods to retrieve data from the tree |
| CTreeTraits< TreeT > | Useful traits for Tree types |
| CTreeTraits< const TreeT > | |
| CTreeValueIteratorBase< _TreeT, _ValueIterT > | Base class for tree-traversal iterators over tile and voxel values |
| ►CTricubicSampler< TreeOrAccT > | Tri-cubic sampler, i.e. third order, interpolator |
| CSampleFromVoxels< TreeOrAccT, 3, false > | |
| CSampleFromVoxels< TreeOrAccT, 3, true > | |
| ►CTrilinearSampler< TreeOrAccT > | Tri-linear sampler, i.e. first order, interpolator |
| CSampleFromVoxels< TreeOrAccT, 1, false > | Template specialization that does not use caching of stencil points |
| CSampleFromVoxels< TreeOrAccT, 1, true > | Template specialization with caching of stencil values |
| ►CTriquadraticSampler< TreeOrAccT > | Tri-quadratic sampler, i.e. second order, interpolator |
| CSampleFromVoxels< TreeOrAccT, 2, false > | Template specialization that does not use caching of stencil points |
| CSampleFromVoxels< TreeOrAccT, 2, true > | Template specialization with caching of stencil values |
| ►Ctrue_type | |
| CIsSpecializationOf< Template< Args... >, Template > | |
| CTruncateCodec | |
| CTruncateTrait< T > | |
| CTruncateTrait< float > | |
| CTruncateTrait< int > | |
| CTruncateTrait< math::Vec3< T > > | |
| 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 > | |
| CTypeList< Ts > | A list of types (not necessarily unique) |
| ►CTypeToSymbol< T > | Type to symbol conversions - these characters are used to build each functions unique signature. They differ from standard AX or LLVM syntax to be as short as possible i.e. vec4d, [4 x double] = d4 |
| CTypeToSymbol< const T > | |
| CTypeToSymbol< char > | |
| CTypeToSymbol< codegen::String > | |
| CTypeToSymbol< double > | |
| CTypeToSymbol< float > | |
| CTypeToSymbol< int16_t > | |
| CTypeToSymbol< int32_t > | |
| CTypeToSymbol< int64_t > | |
| ►CTypeToSymbol< T * > | |
| CTypeToSymbol< const T * > | |
| ►CTypeToSymbol< T[16]> | |
| CTypeToSymbol< math::Mat4< T > > | |
| ►CTypeToSymbol< T[2]> | |
| CTypeToSymbol< math::Vec2< T > > | |
| ►CTypeToSymbol< T[3]> | |
| CTypeToSymbol< math::Vec3< T > > | |
| ►CTypeToSymbol< T[4]> | |
| CTypeToSymbol< math::Vec4< T > > | |
| ►CTypeToSymbol< T[9]> | |
| CTypeToSymbol< math::Mat3< T > > | |
| ►CTypeToSymbol< T[S]> | |
| CTypeToSymbol< ArgType< T, S > > | |
| CTypeToSymbol< void > | |
| Chalf::uif | |
| CUIntTypeTrait< OneByte, T > | |
| CUIntTypeTrait< false, math::Vec3< T > > | |
| CUIntTypeTrait< false, T > | |
| CUIntTypeTrait< true, math::Vec3< T > > | |
| CUIntTypeTrait< true, T > | |
| CUnitRange | |
| CUnitVecCodec | |
| CUnknownCodec | |
| CAttributeSet::Util | |
| ►CValueAccessorBase< TreeType, IsSafe > | This base class for ValueAccessors manages registration of an accessor with a tree so that the tree can automatically clear the accessor whenever one of its nodes is deleted |
| ►CValueAccessor0< TreeType, IsSafe > | |
| CValueAccessor< TreeType, IsSafe, 0, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and no cache levels |
| ►CValueAccessor1< TreeType, IsSafe > | |
| CValueAccessor< TreeType, IsSafe, 1, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and one cache level |
| ►CValueAccessor2< TreeType, IsSafe > | |
| CValueAccessor< TreeType, IsSafe, 2, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and two cache levels |
| ►CValueAccessor3< TreeType, IsSafe > | |
| CValueAccessor< TreeType, IsSafe, 3, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and three cache levels |
| ►CValueAccessor< TreeType, IsSafe, TreeType::DEPTH-1, tbb::spin_mutex > | |
| CValueAccessorRW< TreeType, IsSafe > | 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, IsSafe > | |
| CValueAccessor< _TreeType, IsSafe, CacheLevels, MutexType > | |
| CValueAccessor0< _TreeType, IsSafe > | ValueAccessor with no mutex and no node caching |
| CValueAccessor1< _TreeType, IsSafe, L0 > | Value accessor with one level of node caching |
| CValueAccessor2< _TreeType, IsSafe, L0, L1 > | Value accessor with two levels of node caching |
| CValueAccessor3< _TreeType, IsSafe, L0, L1, L2 > | Value accessor with three levels of node caching |
| ►CValueAccessorBase< const TreeT, IsSafe > | |
| CValueAccessor< const TreeT, false > | |
| ►CValueAccessorBase< const TreeT, true > | |
| CValueAccessor< const TreeT > | |
| ►CValueAccessorBase< const TreeType, IsSafe > | |
| CValueAccessor< const TreeType, IsSafe > | |
| ►CValueAccessorBase< const TreeType, true > | |
| CValueAccessor< const TreeType > | |
| ►CValueAccessorBase< IntTreeT, true > | |
| CValueAccessor< IntTreeT > | |
| ►CValueAccessorBase< TreeT, true > | |
| CValueAccessor< TreeT > | |
| ►CValueAccessorBase< TreeType, true > | |
| CValueAccessor< TreeType > | |
| CLeafNode< T, Log2Dim >::ValueAll | |
| CInternalNode< _ChildNodeType, Log2Dim >::ValueAll | |
| CPagedArray< ValueT, Log2PageSize >::ValueBuffer | |
| CTree< _RootNodeType >::ValueConverter< OtherValueType > | ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T |
| CLeafNode< ValueMask, Log2Dim >::ValueConverter< OtherValueType > | ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T |
| 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 |
| CGrid< _TreeType >::ValueConverter< OtherValueType > | ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different value type, T |
| CLeafNode< bool, Log2Dim >::ValueConverter< ValueType > | ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T |
| CInternalNode< _ChildNodeType, Log2Dim >::ValueConverter< OtherValueType > | ValueConverter<T>::Type is the type of an InternalNode having the same child hierarchy and dimensions as this node but a different value type, T |
| CTree< _RootNodeType >::ValueConverter< Int32 > | |
| CIndexIter< IteratorT, FilterT >::ValueIndexIter | A forward iterator over array indices from a value iterator (such as ValueOnCIter) |
| CValueMask | Dummy type for a voxel with a binary mask value, e.g. the active state |
| CValueMask | |
| CValueMaskFilter< On > | Index filtering on active / inactive state of host voxel |
| CInternalNode< _ChildNodeType, Log2Dim >::ValueOff | |
| CLeafNode< T, Log2Dim >::ValueOff | |
| CLeafNode< T, Log2Dim >::ValueOn | |
| CInternalNode< _ChildNodeType, Log2Dim >::ValueOn | |
| CValueTraits< T, bool > | |
| CValueTraits< T, false > | |
| CValueTypeTraits< T, typename > | |
| CValueTypeTraits< T, void_t< typename T::value_type > > | |
| CValueVoxelCIter | A forward iterator over array indices in a single voxel |
| ►CVdbPrimCIterator | Iterator over const VDB primitives on a geometry detail |
| CVdbPrimIterator | Iterator over non-const VDB primitives on a geometry detail |
| CVec3< T > | A simple vector class with three double components, similar to openvdb::math::Vec3 |
| CVec3< double > | |
| CVec4< T > | A simple vector class with three double components, similar to openvdb::math::Vec4 |
| CVector< T > | Lightweight, variable-length vector |
| CVector< ValueType > | |
| CVectorToScalarConverter< VectorGridType > | VectorToScalarConverter<VectorGridType>::Type is the type of a grid having the same tree configuration as VectorGridType but a scalar value type, T, where T is the type of the original vector components |
| CVectorToScalarGrid< VecGridT > | Metafunction to convert a vector-valued grid type to a scalar grid type |
| CVecTraits< T, bool > | |
| CVecTraits< T, false > | |
| CVelocityIntegrator< GridT, Staggered, SampleOrder > | Performs Runge-Kutta time integration of variable order in a static velocity field |
| CVelocitySampler< GridT, Staggered, Order > | |
| CVelocitySampler< GridT, Staggered, SampleOrder > | |
| CVersion | Bit-compacted representation of all three version numbers |
| CVersionId | |
| CVertexNormalOp | TBB body object for threaded vertex normal generation |
| CVisitor< Derived, ConstVisit > | The Visitor class uses the Curiously Recursive Template Pattern (CRTP) to provide a customizable interface intended to be used by clients wishing to perform custom operations over an AX Abstract Syntax Tree (AST). By default the Visitor implements simple traversal of all nodes, ensuring that each node on a well formed AST is visited at least once. By deriving from the Visitor, users are able to customize this default behavior and further manually override specific node behavior to their needs. The function options at the top of visitor can be overridden using CRTP to control the prior default behavior, with the ability to override the traverse() and visit() methods for the latter more granular control |
| ►CVisitor< ComputeGenerator > | |
| ►CComputeGenerator | Visitor object which will generate llvm IR for a syntax tree. This provides the majority of the code generation functionality except for attribute access. This design allows for custom geometry to define their IR implementations for these accesses by deriving and extending this generator with ast::Attribute handling (see PointComputeGenerator.h and VolumeComputeGenerator.h for examples) |
| CPointComputeGenerator | Visitor object which will generate llvm IR for a syntax tree which has been generated from AX that targets point grids. The IR will represent 2 functions : one that executes over single points and one that executes over a collection of points. This is primarily used by the Compiler class |
| CVolumeComputeGenerator | Visitor object which will generate llvm IR for a syntax tree which has been generated from AX that targets volumes. The IR will represent a single function. It is mainly used by the Compiler class |
| ►CVisitor< std::conditional< std::is_same< Derived, void >::value, VisitNodeType< NodeT, OpT >, Derived >::type > | |
| CVisitNodeType< NodeT, OpT, Derived > | |
| CVolumeAdvection< VelocityGridT, StaggeredVelocity, InterrupterType > | Performs advections of an arbitrary type of volume in a static velocity field. The advections are performed by means of various derivatives of Semi-Lagrangian integration, i.e. backwards tracking along the hyperbolic characteristics followed by interpolation |
| CVolumeExecutable | Object that encapsulates compiled AX code which can be executed on a collection of VDB volume grids. Executables are created by the compiler and hold the final immutable JIT compiled function and context |
| CVolumeHDDA< TreeT, RayT, ChildNodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume |
| CVolumeHDDA< openvdb::v9_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 |
| CVolumeKernelBuffer | The second volume kernel, responsible for providing the core layer of SIMD optimisations by invoking this kernel across a range of values |
| CVolumeKernelNode | The third volume kernel, providing an agnostic way to modify a single tile value without passing through the buffer states. Note that this kernel is mainly utility and one of the value kernels should almost always be preferred |
| CVolumeKernelValue | The primary volume kernel. This function holds the generated body of AX programs |
| 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 |
| CInternalNode< _ChildNodeType, Log2Dim >::VoxelizeActiveTiles | |
| ►CDerivedFunction | |
| CSRetFunction< SignatureT, DerivedFunction > | Templated interface class for SRET functions. This struct provides the interface for functions that wish to return arrays (vectors or matrices) by internally remapping the first argument for the user. As far as LLVM and any bindings are concerned, the function signature remains unchanged - however the first argument becomes "invisible" to the user and is instead allocated by LLVM before the function is executed. Importantly, the argument has no impact on the user facing AX signature and doesn't affect declaration selection |
1.8.11
