Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:

InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::A |
InternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >::A |
InternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >::A |
AbsDiff | Compression oracle based on absolute difference
ABTransform | 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
AttributeArray::AccessorBase | Accessor base class for AttributeArray storage where type is not available
AttributeArray::Accessor< T > |
AccessorEval< CodecType, ValueType > | Accessor to call unsafe get and set methods based on templated Codec and Value
AccessorEval< UnknownCodec, ValueType > | Partial specialization when Codec is not known at compile-time to use the supplied functor instead
Advect |
AlphaMask< GridT, MaskT, SamplerT, FloatT > |
ApplyFunc< Fn, Args > |
Archive | Grid serializer/unserializer
File | Grid archive associated with a file on disk
Stream | Grid archive associated with arbitrary input and output streams (not necessarily files)
AttributeArray | Base class for storing attribute data
TypedAttributeArray< ValueType_, Codec_ > | Typed class for storing attribute data
AttributeHandle< ValueType, CodecType > |
AttributeWriteHandle< Index, openvdb::v11_0::points::StringCodec< false > > |
AttributeWriteHandle< ValueType, CodecType > | Write-able version of AttributeHandle
AttributeHandle< Index, openvdb::v11_0::points::StringCodec< false > > |
AttributeHandle< ValueType, UnknownCodec > |
AttributeHashFilter< RandGenT, IntType > |
LevelSetFilter< GridT, MaskT, InterruptT >::Filter::Avg< Axis > |
InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::B |
BaseBBox< Vec3T > |
BBox< Vec3T, true > | Partial template specialization for floating point coordinate types
BaseBBox< CoordT > |
BBox< CoordT, false > | Partial template specialization for integer coordinate types
BaseCamera | Abstract base class for the perspective and orthographic cameras
OrthographicCamera |
PerspectiveCamera |
RootNode< ChildT >::BaseIter< RootT > |
RootNode< ChildT >::ChildIter< RootT > |
RootNode< ChildT >::DenseIter< RootT > |
RootNode< ChildT >::ValueIter< RootT > |
RootNode< ChildT >::ValueOnIter< RootT > |
RootNodeMask::BaseIterator |
RootNodeMask::DenseIterator |
RootNodeMask::OffIterator |
RootNodeMask::OnIterator |
BaseMaskIterator< NodeMask > | Base class for the bit mask iterators
DenseMaskIterator< NodeMask > |
OffMaskIterator< NodeMask > |
OnMaskIterator< NodeMask > |
BasePointScatter< PointAccessorType, RandomGenerator, InterruptType > | Forward declaration of base class
DenseUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | Scatters a fixed (and integer) number of points in all active voxels and tiles
NonUniformPointScatter< 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
UniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes:
BasePointScatter< PointAccessorType, RandomGenerator, util::NullInterrupter > |
BaseShader | Abstract base class for the shaders
DiffuseShader< GridT, SamplerType > | Simple diffuse Lambertian surface shader
DiffuseShader< Film::RGBA, SamplerType > |
MatteShader< GridT, SamplerType > | Shader that produces a simple matte
MatteShader< Film::RGBA, SamplerType > |
NormalShader< GridT, SamplerType > | Color shader that treats the surface normal (x, y, z) as an RGB color
NormalShader< Film::RGBA, SamplerType > |
PositionShader< 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
PositionShader< Film::RGBA, SamplerType > |
BaseStencil< DerivedType, SIZE, GridT > |
BaseStencil< DerivedType, GridT, IsSafe > |
BoxStencil< GridT, IsSafe > |
CurvatureStencil< GridT, IsSafe > |
DenseStencil< GridT, IsSafe > | Dense stencil of a given width
FourthOrderDenseStencil< GridT, IsSafe > |
GradStencil< GridT, IsSafe > |
NineteenPointStencil< GridT, IsSafe > |
SecondOrderDenseStencil< GridT, IsSafe > |
SevenPointStencil< GridT, IsSafe > |
SixthOrderDenseStencil< GridT, IsSafe > |
ThirteenPointStencil< GridT, IsSafe > |
WenoStencil< 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
BaseStencil< BoxStencil< GridT >, 8, GridT > |
BoxStencil< GridT > |
BaseStencil< BoxStencil< GridT, true >, GridT, true > |
BaseStencil< CurvatureStencil< GridT >, 19, GridT > |
CurvatureStencil< GridT, RealT > |
BaseStencil< CurvatureStencil< GridT, IsSafe >, GridT, IsSafe > |
CurvatureStencil< GridT, false > |
BaseStencil< CurvatureStencil< GridT, true >, GridT, true > |
BaseStencil< DenseStencil< GridT, true >, GridT, true > |
BaseStencil< FourthOrderDenseStencil< GridT, true >, GridT, true > |
BaseStencil< GradStencil< GridT >, 7, GridT > |
GradStencil< GridT > |
BaseStencil< GradStencil< GridT, IsSafe >, GridT, IsSafe > |
GradStencil< GridT, false > |
BaseStencil< GradStencil< GridT, true >, GridT, true > |
BaseStencil< NineteenPointStencil< GridT, true >, GridT, true > |
BaseStencil< SecondOrderDenseStencil< GridT, true >, GridT, true > |
BaseStencil< SevenPointStencil< GridT, true >, GridT, true > |
BaseStencil< SixthOrderDenseStencil< GridT, true >, GridT, true > |
BaseStencil< ThirteenPointStencil< GridT, true >, GridT, true > |
BaseStencil< WenoStencil< GridT >, 19, GridT > |
WenoStencil< 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
BaseStencil< WenoStencil< GridT, true >, GridT, true > |
BBox< Vec3T, bool > |
BBox< Vec3T > | Axis-aligned bounding box
BBox< Coord > |
BBox< CoordT > |
BBox< nanovdb::Vec3 > |
BBox< Vec3d > |
BBoxFilter |
BIAS_SCHEME< bgs > |
BIAS_SCHEME< FIRST_BIAS > |
BIAS_SCHEME< HJWENO5_BIAS > |
BIAS_SCHEME< SECOND_BIAS > |
BIAS_SCHEME< THIRD_BIAS > |
BIAS_SCHEME< WENO5_BIAS > |
BinaryFilter< T1, T2, And > |
BitArray< N > |
BitFlags< 32 > |
BitFlags< N > |
BitArray< 16 > |
BitArray< 32 > |
BitArray< 64 > |
BitArray< 8 > |
GroupHandle::BitMask |
CreateNanoGrid< SrcGridT >::BlindMetaData |
BoxSampler |
Sampler< 1, false > |
BufferTraits< BufferT > |
BuildMoveMapsOp< DeformerT, TreeT, FilterT > |
BuildToValueMap< T > | Maps one type (e.g. the build types above) to other (actual) types
BuildToValueMap< BuildT > |
BuildToValueMap< Fp16 > |
BuildToValueMap< Fp4 > |
BuildToValueMap< Fp8 > |
BuildToValueMap< FpN > |
BuildToValueMap< Half > |
BuildToValueMap< nanovdb::ValueMask > |
BuildToValueMap< Point > |
BuildToValueMap< ValueIndex > |
BuildToValueMap< ValueIndexMask > |
BuildToValueMap< ValueMask > |
BuildToValueMap< ValueOnIndex > |
BuildToValueMap< ValueOnIndexMask > |
BuildTraits< T > | Define static boolean tests for template build types
CachedDeformer< T >::Cache |
CachedDeformer< T > | A Deformer that caches the resulting positions from evaluating another Deformer
CanConvertType< FromType, ToType > | CanConvertType<FromType, ToType>::value is `true` if a value of type ToType can be constructed from a value of type FromType
CanConvertType< math::Vec2< T >, math::Vec2< T > > |
CanConvertType< math::Vec3< T >, math::Vec3< T > > |
CanConvertType< math::Vec4< T >, math::Vec4< T > > |
CanConvertType< PointDataIndex32, PointIndex32 > |
CanConvertType< PointIndex32, PointDataIndex32 > |
CanConvertType< T, math::Vec2< T > > |
CanConvertType< T, math::Vec3< T > > |
CanConvertType< T, math::Vec4< T > > |
CanConvertType< T, ValueMask > |
CanConvertType< T0, math::Vec2< T1 > > |
CanConvertType< T0, math::Vec3< T1 > > |
CanConvertType< T0, math::Vec4< T1 > > |
CanConvertType< ValueMask, T > |
ChangeBackgroundOp< TreeOrLeafManagerT > |
ChangeLevelSetBackgroundOp< TreeOrLeafManagerT > |
CheckDivergence< GridT, TreeIterT, DiffScheme > | Checks the divergence against a range
CheckEikonal< GridT, TreeIterT, StencilT > | Checks the norm of the gradient at zero-crossing voxels against a range
CheckFinite< GridT, TreeIterT > | Checks for both NaN and inf values, i.e. any value that is not finite
CheckFogVolume< GridType > | Class that performs various types of checks on fog volumes
CheckInf< GridT, TreeIterT > | Checks for infinite values, e.g. 1/0 or -1/0
CheckLevelSet< GridType > | Class that performs various types of checks on narrow-band level sets
CheckMagnitude< 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
CheckMax< GridT, TreeIterT > | Checks a value against a maximum
CheckMin< GridT, TreeIterT > | Checks a value against a minimum
CheckNan< GridT, TreeIterT > | Checks NaN values
CheckNormGrad< GridT, TreeIterT, GradScheme > | Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max]
CheckRange< GridT, MinInclusive, MaxInclusive, TreeIterT > | Checks a value against a range
InternalNode< _ChildNodeType, Log2Dim >::ChildAll |
LeafNode< T, Log2Dim >::ChildAll |
RootNode< ChildT >::ChildIterator |
LeafNode< BuildT, CoordT, MaskT, Log2Dim >::ChildNodeType |
InternalNode< _ChildNodeType, Log2Dim >::ChildOff |
LeafNode< T, Log2Dim >::ChildOff |
InternalNode< _ChildNodeType, Log2Dim >::ChildOn |
LeafNode< T, Log2Dim >::ChildOn |
ClosestPointProjector< CptGridT > |
ClosestSurfacePoint< GridT > | Accelerated closest surface point queries for narrow band level sets
cnanovdb_coord |
cnanovdb_gridblindmetadata |
cnanovdb_griddata |
cnanovdb_map |
cnanovdb_mask3 |
cnanovdb_mask4 |
cnanovdb_mask5 |
cnanovdb_node0F |
cnanovdb_node0F3 |
cnanovdb_node1F |
cnanovdb_node1F3 |
cnanovdb_node2F |
cnanovdb_node2F3 |
cnanovdb_readaccessor |
cnanovdb_rootdata_tileF |
cnanovdb_rootdata_tileF3 |
cnanovdb_rootdataF |
cnanovdb_rootdataF3 |
cnanovdb_stencil1F |
cnanovdb_stencil1F3 |
cnanovdb_tileentryF |
cnanovdb_tileentryF3 |
cnanovdb_treedata |
cnanovdb_Vec3F |
CombineArgs< 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
CombineOpAdapter< 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
CompositeFunctorTranslator< OP, ValueT > | Translator that converts an enum to compositing functor types
CompositeFunctorTranslator< DS_ADD, ValueT > |
CompositeFunctorTranslator< DS_MAX, ValueT > |
CompositeFunctorTranslator< DS_MIN, ValueT > |
CompositeFunctorTranslator< DS_MULT, ValueT > |
CompositeFunctorTranslator< DS_OVER, ValueT > |
CompositeFunctorTranslator< DS_SUB, ValueT > |
CompositeOp |
CompoundMap< 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
CompReplaceOp< TreeT > |
PagedArray< ValueT, Log2PageSize >::ConstIterator |
ConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType > |
SparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstRow | Read-only accessor to a row of this matrix
SparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstValueIter | Iterator over the stored values in a row of this matrix
Container |
ContiguousOp< 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
Conversion | Dummy class for tag dispatch of conversion constructors
ConvertElementType< T, SubT > | Conversion classes for changing the underlying type of VDB types
ConvertElementType< math::Mat3< T >, SubT > |
ConvertElementType< math::Mat4< T >, SubT > |
ConvertElementType< math::Quat< T >, SubT > |
ConvertElementType< math::Vec2< T >, SubT > |
ConvertElementType< math::Vec3< T >, SubT > |
ConvertElementType< math::Vec4< T >, SubT > |
ConvertTrait< T > |
ConvertTrait< nanovdb::Fp16 > |
ConvertTrait< nanovdb::Fp4 > |
ConvertTrait< nanovdb::Fp8 > |
ConvertTrait< nanovdb::FpN > |
ConvertTrait< nanovdb::ValueMask > |
ConvertTrait< nanovdb::Vec3< T > > |
ConvertTrait< nanovdb::Vec4< T > > |
Coord | Signed (i, j, k) 32-bit integer coordinate class, similar to openvdb::math::Coord
Coord | Signed (x, y, z) 32-bit integer coordinates
CoordBBox | Axis-aligned bounding box of signed integer coordinates
CopyableOpApplier< IterT, OpT > |
CopyConstness< FromType, ToType > | CopyConstness<T1, T2>::Type is either `const T2` or `T2` with no `const` qualifier, depending on whether `T1` is `const`
CopyFromDense< _TreeT, _DenseT > | Copy the values from a dense grid into an OpenVDB tree
GlobalMovePointsOp< TreeT >::CopyIterator |
LocalMovePointsOp< TreeT >::CopyIterator |
CopyOp< T > |
CopyToDense< _TreeT, _DenseT > | Copy an OpenVDB tree into an existing dense grid
CPT< MapType, DiffScheme > | Compute the closest-point transform to a level set
Cpt< InGridT, MaskGridType, InterruptT > | Compute the closest-point transform of a scalar grid
CPT_RANGE< MapType, DiffScheme > | Compute the closest-point transform to a level set
CpuTimer |
CpuTimer | Simple timer for basic profiling
CreateNanoGrid< SrcGridT > | Creates any nanovdb Grid from any source grid (certain combinations are obviously not allowed)
CsgDifferenceOp< TreeT > | DynamicNodeManager operator to merge two trees using a CSG difference
CsgUnionOrIntersectionOp< TreeT, Union > | DynamicNodeManager operator to merge trees using a CSG union or intersection
Curl< 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
Curl< GridT, MaskGridType, InterruptT > | Compute the curl of a vector grid
Curl< UniformScaleMap, CD_2ND > | Full template specialization of Curl
Curl< UniformScaleMap, DiffScheme > | Partial template specialization of Curl
Curl< UniformScaleTranslateMap, CD_2ND > | Full template specialization of Curl
Curl< UniformScaleTranslateMap, DiffScheme > | Partial template specialization of Curl
D1< DiffScheme > |
D1< BD_1ST > |
D1< BD_2ND > |
D1< BD_3RD > |
D1< BD_HJWENO5 > |
D1< BD_WENO5 > |
D1< CD_2ND > |
D1< CD_2NDT > |
D1< CD_4TH > |
D1< CD_6TH > |
D1< FD_1ST > |
D1< FD_2ND > |
D1< FD_3RD > |
D1< FD_HJWENO5 > |
D1< FD_WENO5 > |
D1Vec< DiffScheme > |
D1Vec< CD_2ND > |
D1Vec< CD_2NDT > |
D1Vec< CD_4TH > |
D1Vec< CD_6TH > |
D2< DiffScheme > |
D2< CD_FOURTH > |
D2< CD_SECOND > |
D2< CD_SIXTH > |
DDA< RayT, CoordT, Dim > | A Digital Differential Analyzer. Unlike HDDA (defined above) this DDA uses a fixed step-size defined by the template parameter Dim!
DDA< RayT, Log2Dim > | A Digital Differential Analyzer specialized for OpenVDB grids
DDA< RayT, LeafT::TOTAL > |
DDA< RayT, NodeT::TOTAL > |
DDA< RayType, NodeT::TOTAL > |
Tree< _RootNodeType >::DeallocateNodes< NodeType > |
DeepCopy | Tag dispatch class that distinguishes constructors that deep copy
InternalNode< _ChildNodeType, Log2Dim >::DeepCopy< OtherInternalNode > |
Default< ValueType > |
DeformerTraits< DeformerT > | Deformer Traits for optionally configuring deformers to be applied in index-space. The default is world-space
Delta< T > | Delta for small floating-point offsets
Delta< T > | Delta for small floating-point offsets
Delta< double > |
Delta< double > |
Delta< float > |
Delta< float > |
DenseBase< ValueT, Layout > | Base class for Dense which is defined below
Dense< ValueT, Layout > | Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below
DenseBase< ValueT, LayoutXYZ > | Partial template specialization of DenseBase
DenseBase< ValueT, LayoutZYX > |
DenseBase< ValueT, LayoutZYX > | Partial template specialization of DenseBase
Mask< LOG2DIM >::DenseIterator |
InternalNode< ChildT, Log2Dim >::DenseIterator | Visits all tile values and child nodes of this node
InternalNode< ChildT >::DenseIterator | Visits all tile values and child nodes of this node
DenseTransformer< _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
DepthFirstNodeVisitor< 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
DepthFirstNodeVisitor< NodeT, 0 > |
Descriptor |
AttributeSet | Ordered collection of uniquely-named attribute arrays
Vector< T >::DeterministicDotProductOp |
Diagnose< GridT > | Performs multithreaded diagnostics of a grid
Diagnose< GridType > |
FastSweeping< SdfGridT, ExtValueT >::DilateKernel | Private class of FastSweeping to perform multi-threaded initialization
DiracDelta< RealT > | Smeared-out and continuous Dirac Delta function
DirichletBoundaryOp< ValueType > | Dirichlet boundary condition functor
disable_if< bool, T > |
disable_if< true, T > |
DiscreteField< VelGridT, Interpolator > | Thin wrapper class for a velocity grid
DitherLUT |
Divergence< 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
Divergence< InGridT, MaskGridType, InterruptT > | Compute the divergence of a vector grid
Divergence< ScaleMap, CD_2ND > |
Divergence< ScaleMap, DiffScheme > |
Divergence< ScaleTranslateMap, CD_2ND > |
Divergence< ScaleTranslateMap, DiffScheme > |
Divergence< TranslationMap, DiffScheme > |
Divergence< UniformScaleMap, CD_2ND > |
Divergence< UniformScaleMap, DiffScheme > |
Divergence< UniformScaleTranslateMap, CD_2ND > |
Divergence< UniformScaleTranslateMap, DiffScheme > |
DSConverter< DenseType, TreeType > |
DualGridSampler< 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
DualGridSampler< AccT, tools::BoxSampler > |
DualGridSampler< tree::ValueAccessor< TreeT >, SamplerT > | Specialization of DualGridSampler for construction from a ValueAccessor type
DummySampleType |
DynamicNodeManager< TreeOrLeafManagerT, _LEVELS > |
DynamicNodeManagerLink< NodeT, LEVEL > | This class is a link in a chain that each caches tree nodes of a specific type in a linear array
DynamicNodeManagerLink< ChildNodeType, LEVELS-1 > |
MeshToVoxelEdgeData::EdgeData | Internal edge data type
enable_if< bool, T > | C++11 implementation of std::enable_if
enable_if< true, T > |
EnrightField< ScalarT > | Analytical, divergence-free and periodic velocity field
EnrightField< typename GridT::ValueType > |
exception |
Exception |
ArithmeticError |
IndexError |
IoError |
KeyError |
LookupError |
NotImplementedError |
ReferenceError |
RuntimeError |
TypeError |
ValueError |
ExtractAll< _ResultTreeType, DenseValueType > | Simple utility class used by `extractSparseTreeWithMask`
Extrema< ValueT, Rank > |
Extrema | This class computes the minimum and maximum values of a population of floating-point values
Stats | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values
Extrema< ValueT, 0 > | Template specialization of Extrema on scalar value types, i.e. rank = 0
Stats< ValueT, 0 > | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values
Extrema< ValueT, 1 > |
Stats< ValueT, 1 > | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values
Extrema< VecT, 1 > | Template specialization of Extrema on vector value types, i.e. rank = 1
false_type |
IsSpecializationOf< 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
FastSweeping< 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
FileHeader | Data encoded at the head of each segment of a file or stream
FileMetaData |
FileGridMetaData | This class defines the meta data stored for each grid in a segment
FillOp< T > |
Film | A simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM file output
Filter< GridT, MaskT, InterruptT > | Volume filtering (e.g., diffusion) with optional alpha masking
FilterTraits< T > |
FilterTraits< BBoxFilter > |
FilterTraits< BinaryFilter< T0, T1, And > > |
FilterTraits< LevelSetFilter< T > > |
FilterType | Selectively extract and filter point data using a custom filter operator
FindActiveValues< TreeT > | Finds the active values in a tree which intersects a bounding box
FixedPointCodec< OneByte, Range > |
FloatTraits< T, int > |
FloatTraits< bool, 1 > |
FloatTraits< BuildT > |
FloatTraits< Point, 1 > |
FloatTraits< T, 8 > |
FloatTraits< ValueIndex, 1 > |
FloatTraits< ValueIndexMask, 1 > |
FloatTraits< ValueMask, 1 > |
FloatTraits< ValueOnIndex, 1 > |
FloatTraits< ValueOnIndexMask, 1 > |
FloatTraits< ValueT > |
flt_t< Bits > |
flt_t< 16ul > |
flt_t< 32ul > |
flt_t< 64ul > |
ForeachFilterOp< OpT > |
FormattedInt< IntT > | I/O manipulator that formats integer values with thousands separators
Fp16 | Dummy type for a 16bit quantization of float point values
Fp4 | Dummy type for a 4bit quantization of float point values
Fp8 | Dummy type for a 8bit quantization of float point values
FpN | Dummy type for a variable bit quantization of floating point values
FrustumRasterizer< PointDataGridT > | Efficient rasterization of one or more VDB Points grids into a linear or frustum volume with the option to bake in camera or geometry motion blur
FrustumRasterizerMask |
FrustumRasterizerSettings | A group of shared settings to be used in the Volume Rasterizer
Divergence< InGridT, MaskGridType, InterruptT >::Functor< DiffScheme > |
Gradient< InGridT, MaskGridType, InterruptT >::Functor |
Laplacian< GridT, MaskGridType, InterruptT >::Functor |
Magnitude< InGridT, MaskGridType, InterruptT >::Functor |
MeanCurvature< GridT, MaskGridType, InterruptT >::Functor |
Normalize< GridT, MaskGridType, InterruptT >::Functor |
MeshToVoxelEdgeData::GenEdgeData |
GenericMap | A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators
GetDim< BuildT > | Implements Tree::getDim(Coord)
GetLeaf< BuildT > | Return the pointer to the leaf node that contains Coord. Implements Tree::probeLeaf(Coord)
GetLower< BuildT > | Return point to the lower internal node where Coord maps to one of its values, i.e. terminates
GetNodeInfo< BuildT > | Implements Tree::getNodeInfo(Coord)
GetState< T > | Implements Tree::isActive(Coord)
GetState< BuildT > | Implements Tree::isActive(Coord)
GetUpper< BuildT > | Return point to the upper internal node where Coord maps to one of its values, i.e. terminates
GetValue< T > | Implements Tree::getValue(Coord), i.e. return the value associated with a specific coordinate `ijk`
GetValue< BuildT > | Implements Tree::getValue(Coord), i.e. return the value associated with a specific coordinate `ijk`
GlobalMovePointsOp< TreeT > |
Gradient< MapType, DiffScheme > | Center difference gradient operators, defined with respect to the range-space of the `map`
Gradient< InGridT, MaskGridType, InterruptT > | Compute the gradient of a scalar grid
Gradient< ScaleMap, CD_2ND > |
Gradient< ScaleTranslateMap, CD_2ND > |
Gradient< TranslationMap, DiffScheme > |
Gradient< UniformScaleMap, CD_2ND > |
Gradient< UniformScaleTranslateMap, CD_2ND > |
GradientBiased< MapType, GradScheme > | Biased gradient operators, defined with respect to the range-space of the map
GradientNormSqrd< MapType, GradScheme > |
GradientNormSqrd< UniformScaleMap, GradScheme > | Partial template specialization of GradientNormSqrd
GradientNormSqrd< UniformScaleTranslateMap, GradScheme > | Partial template specialization of GradientNormSqrd
GridBlindMetaData |
GridChecksum | Class that encapsulates two CRC32 checksums, one for the Grid, Tree and Root node meta data and one for the remaining grid nodes
GridData | Struct with all the member data of the Grid (useful during serialization of an openvdb grid)
Grid< ValueIndex > |
Grid< uint32_t > |
Grid< nanovdb::Point > |
Grid< TreeT > | Highest level of the data structure. Contains a tree and a world->index transform (that currently only supports uniform scaling and translation)
GridDescriptor |
GridHandle< BufferT > | This class serves to manage a buffer containing one or more NanoVDB Grids
GridHandleMetaData |
GridMetaData | 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
GridNamePred | Predicate functor that returns `true` for grids that have a specified name
GridOperator< 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
GridResampler |
GridTransformer | A GridTransformer applies a geometric transformation to an input grid using one of several sampling schemes, and stores the result in an output grid
GridSampler< GridOrTreeType, SamplerType > | Class that provides the interface for continuous sampling of values in a tree
GridSampler< tree::ValueAccessor< TreeT >, SamplerType > | Specialization of GridSampler for construction from a ValueAccessor type
GridStats< GridT, StatsT > | Allows for the construction of NanoVDB grids without any dependency
GridTree< GridT > | Defines a tree type from a grid type while preserving constness
GridTree< const GridT > |
GridValidator< ValueT > | Allows for the construction of NanoVDB grids without any dependecy
GroupCodec |
GroupFilter | Index filtering on group membership
GroupHandle |
GroupWriteHandle |
Half | Dummy type for a 16 bit floating point values
half |
HalfReader< IsReal, T > |
HalfReader< false, T > | Partial specialization for non-floating-point types (no half to float promotion)
HalfReader< true, T > | Partial specialization for floating-point types
HalfWidthOp< ValueType > |
HalfWidthOp< bool > |
HalfWriter< IsReal, T > |
HalfWriter< false, T > | Partial specialization for non-floating-point types (no float to half quantization)
HalfWriter< true, T > | Partial specialization for floating-point types
HasMultiPassIO< LeafNodeType > | Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data
HasMultiPassIO< Grid< TreeType > > |
HasMultiPassIO< tree::Tree< RootNodeType > > |
HDDA< RayT, CoordT > | A Digital Differential Analyzer specialized for OpenVDB grids
HDDA< RayT, nanovdb::Coord > |
Histogram | This class computes a histogram, with a fixed interval width, of a population of floating-point values
HomogeneousMatMul |
HostBuffer | This is a buffer that contains a shared or private pool to either externally or internally managed host memory
imath_half_uif | Type for both C-only programs and C++ to use the same utilities
InactivePruneOp< TreeT, TerminationLevel > |
index_sequence<... > |

index_sequence< Ns >

Re-implementation of C++17's index_sequence and the helper alias make_index_sequence. This was introduced to fix an issue with clang's builtin implementation which treats template specializations of builtin templates differently when a subsequent parameter is dependent. The result is a resolution failure during partial specialization selection. For example, the following will fail to specialize:

index_sequence< Is... > |
make_index_sequence< 0, Is... > |
IndexIter< 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:
PointPartitioner< PointIndexType, BucketLog2Dim >::IndexIterator |
Vector< T >::InfNormOp |
FastSweeping< SdfGridT, ExtValueT >::InitSdf |
AttributeSet::Inserter | Utility method to construct a NameAndType sequence
int_t< Bits, Signed > |
int_t< 16ul, false > |
int_t< 16ul, true > |
int_t< 32ul, false > |
int_t< 32ul, true > |
int_t< 64ul, false > |
int_t< 64ul, true > |
int_t< 8ul, false > |
int_t< 8ul, true > |
InternalData< ChildT, LOG2DIM > | Struct with all the member data of the InternalNode (useful during serialization of an openvdb InternalNode)
InternalNode< ChildT, Log2Dim > | Internal nodes of a VDB treedim(),
InternalData< ChildT, ChildT::LOG2DIM+1 > |
InternalNode< ChildT > |
InternalNode< _ChildNodeType, Log2Dim > |
InvertedTree< HeadT, HeadLevel > |
InvertedTree< HeadT, 1 > |
is_const< T > |
is_const< const T > |
is_diagonal_jacobian< T > |
is_double< T > |
is_double< double > |
is_floating_point< T > | C++11 implementation of std::is_floating_point
is_linear< T > | Map traits
is_linear< AffineMap > |
is_linear< CompoundMap< T1, T2 > > |
is_linear< ScaleMap > |
is_linear< ScaleTranslateMap > |
is_linear< TranslationMap > |
is_linear< UniformScaleMap > |
is_linear< UniformScaleTranslateMap > |
is_linear< UnitaryMap > |
is_pointer< T > | Trait used to identify template parameter that are pointers
is_pointer< const T * > | Template specialization of const pointers
is_pointer< T * > | Template specialization of non-const pointers
is_same< T0, T1, T > | C++11 implementation of std::is_same
is_same< T, T > |
is_same< T0, T1 > |
is_scale< T > |
is_scale< ScaleMap > |
is_scale_translate< T > |
is_scale_translate< ScaleTranslateMap > |
is_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
is_specialization< TemplateType< Args... >, TemplateType > |
is_uniform_diagonal_jacobian< T > |
is_uniform_scale< T > |
is_uniform_scale< UniformScaleMap > |
is_uniform_scale_translate< T > |
is_uniform_scale_translate< TranslationMap > |
is_uniform_scale_translate< UniformScaleTranslateMap > |
is_vec3d< Vec3T > |
is_vec3d< Vec3d > |
ISCurl< DiffScheme > | Curl operator defined in index space using various first derivative schemes
ISDivergence< DiffScheme > | Divergence operator defined in index space using various first derivative schemes
SparseStencilMatrix< ValueType_, STENCIL_SIZE >::IsFiniteOp |
Vector< T >::IsFiniteOp |
ISGradient< DiffScheme > | Gradient operators defined in index space of various orders
ISGradientBiased< GradScheme, Vec3Bias > | Biased Gradient Operators, using upwinding defined by the `Vec3Bias` input
ISGradientNormSqrd< GradScheme > |
ISLaplacian< DiffScheme > | Laplacian defined in index space, using various center-difference stencils
ISLaplacian< CD_FOURTH > |
ISLaplacian< CD_SECOND > |
ISLaplacian< CD_SIXTH > |
ISMeanCurvature< DiffScheme2, DiffScheme1 > | Compute the mean curvature in index space
ISOpMagnitude< OpType > | Adapter for vector-valued index-space operators to return the vector magnitude
BIAS_SCHEME< bgs >::ISStencil< GridType, IsSafe > |
BIAS_SCHEME< FIRST_BIAS >::ISStencil |
BIAS_SCHEME< HJWENO5_BIAS >::ISStencil |
BIAS_SCHEME< SECOND_BIAS >::ISStencil |
BIAS_SCHEME< THIRD_BIAS >::ISStencil |
BIAS_SCHEME< WENO5_BIAS >::ISStencil |
BBox< CoordT, false >::Iterator | Iterator over the domain covered by a BBox
Mask< LOG2DIM >::Iterator< On > |
CoordBBox::Iterator< ZYXOrder > | Iterator over the Coord domain covered by a CoordBBox
ParticleAtlas< PointIndexGridType >::Iterator | Provides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas
LeafManager< TreeT >::LeafRange::Iterator |
NodeList< NodeT >::NodeRange::Iterator |
PagedArray< ValueT, Log2PageSize >::Iterator |
IteratorBase< MaskIterT, NodeT > | Base class for iterators over internal and leaf nodes
DenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ChildT, ValueT, TagT >, NodeT, ChildT, ValueT > |
InternalNode< _ChildNodeType, Log2Dim >::DenseIter< NodeT, ChildT, ValueT, TagT > |
DenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ValueT, TagT >, NodeT, void, ValueT > |
LeafNode< T, Log2Dim >::DenseIter< NodeT, ValueT, TagT > |
DenseIteratorBase< MaskDenseIter, DenseIter< NodeT, ValueT >, NodeT, void, ValueT > |
LeafNode< ValueMask, Log2Dim >::DenseIter< NodeT, ValueT > |
LeafNode< bool, Log2Dim >::DenseIter< NodeT, ValueT > |
SparseIteratorBase< MaskIterT, ChildIter< NodeT, ChildT, MaskIterT, TagT >, NodeT, ChildT > |
InternalNode< _ChildNodeType, Log2Dim >::ChildIter< NodeT, ChildT, MaskIterT, TagT > |
SparseIteratorBase< MaskIterT, ValueIter< NodeT, ValueT, MaskIterT, TagT >, NodeT, ValueT > |
InternalNode< _ChildNodeType, Log2Dim >::ValueIter< NodeT, ValueT, MaskIterT, TagT > |
SparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT, TagT >, NodeT, ValueType > |
LeafNode< T, Log2Dim >::ChildIter< MaskIterT, NodeT, TagT > | Leaf nodes have no children, so their child iterators have no get/set accessors
SparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT, TagT >, NodeT, ValueT > |
LeafNode< T, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT, TagT > |
SparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT >, NodeT, bool > |
LeafNode< ValueMask, Log2Dim >::ChildIter< MaskIterT, NodeT > | Leaf nodes have no children, so their child iterators have no get/set accessors
LeafNode< bool, Log2Dim >::ChildIter< MaskIterT, NodeT > | Leaf nodes have no children, so their child iterators have no get/set accessors
SparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT >, NodeT, ValueT > |
LeafNode< ValueMask, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT > |
LeafNode< bool, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT > |
DenseIteratorBase< MaskIterT, IterT, NodeT, SetItemT, UnsetItemT > | Base class for dense iterators over internal and leaf nodes
SparseIteratorBase< MaskIterT, IterT, NodeT, ItemT > | Base class for sparse iterators over internal and leaf nodes
IteratorBase< MaskDenseIter, NodeT > |
IteratorBase< MaskDenseIterator, NodeT > |
IteratorRange< IterT > |
IterListItem< PrevItemT, NodeVecT, VecSize, _Level > | An IterListItem is an element of a compile-time linked list of iterators to nodes of different types
IterListItem< IterListItem, RestT, VecSize - 1, 1 > |
IterListItem< PrevChildItem, InvTreeT, ROOT_LEVEL+1, 0 > |
IterListItem< PrevItem, InvTreeT, ROOT_LEVEL+1, LEAF_LEVEL > |
IterListItem< PrevItemT, NodeVecT, 1, _Level > | The final element of a compile-time linked list of iterators to nodes of different types
IterListItem< PrevItemT, NodeVecT, VecSize, 0U > | The initial element of a compile-time linked list of iterators to nodes of different types
IterListItem< PrevValueItem, InvTreeT, ROOT_LEVEL+1, 0 > |
IterTraits< NodeT, IterT > |
IterTraits< NodeT, typename NodeT::ChildAllCIter > |
IterTraits< NodeT, typename NodeT::ChildAllIter > |
IterTraits< NodeT, typename NodeT::ChildOffCIter > |
IterTraits< NodeT, typename NodeT::ChildOffIter > |
IterTraits< NodeT, typename NodeT::ChildOnCIter > |
IterTraits< NodeT, typename NodeT::ChildOnIter > |
IterTraits< NodeT, typename NodeT::ValueAllCIter > |
IterTraits< NodeT, typename NodeT::ValueAllIter > |
IterTraits< NodeT, typename NodeT::ValueOffCIter > |
IterTraits< NodeT, typename NodeT::ValueOffIter > |
IterTraits< NodeT, typename NodeT::ValueOnCIter > |
IterTraits< NodeT, typename NodeT::ValueOnIter > |
IterTraits< typename PrevIterT::NonConstNodeType, PrevIterT > |
Laplacian< 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
Laplacian< GridT, MaskGridType, InterruptT > |
Laplacian< ScaleMap, DiffScheme > |
Laplacian< ScaleTranslateMap, DiffScheme > |
Laplacian< TranslationMap, DiffScheme > |
Laplacian< UniformScaleMap, DiffScheme > |
Laplacian< UniformScaleTranslateMap, DiffScheme > |
Laplacian< UnitaryMap, DiffScheme > |
CachedDeformer< T >::Cache::Leaf |
LeafBuffer< T, Log2Dim > | Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode
LeafBuffer< bool, Log2Dim > |
LeafBuffer< ValueType, Log2Dim > |
LeafData< ValueT, CoordT, MaskT, LOG2DIM > | Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode)
LeafNode< BuildT, CoordT, MaskT, Log2Dim > | Leaf nodes of the VDB tree. (defaults to 8x8x8 = 512 voxels)
LeafData< bool, CoordT, MaskT, LOG2DIM > |
LeafData< BuildT, Coord, Mask, 3 > |
LeafData< Point, CoordT, MaskT, LOG2DIM > |
LeafData< ValueMask, CoordT, MaskT, LOG2DIM > |
LeafFnBase< CoordT, MaskT, LOG2DIM > | Base-class for quantized float leaf nodes
LeafData< Fp16, CoordT, MaskT, LOG2DIM > |
LeafData< Fp4, CoordT, MaskT, LOG2DIM > | Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode)
LeafData< Fp8, CoordT, MaskT, LOG2DIM > |
LeafData< FpN, CoordT, MaskT, LOG2DIM > |
LeafIndexBase< CoordT, MaskT, LOG2DIM > |
LeafData< ValueIndex, CoordT, MaskT, LOG2DIM > |
LeafData< ValueIndexMask, CoordT, MaskT, LOG2DIM > |
LeafData< ValueOnIndex, CoordT, MaskT, LOG2DIM > |
LeafData< ValueOnIndexMask, CoordT, MaskT, LOG2DIM > |
LeafIteratorBase< TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels)
LeafManager< 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
LeafManager< TreeType > |
LeafManagerImpl< ManagerT > |
LeafManagerImpl< LeafManager< const TreeT > > |
LeafNode< BuildT > |
LeafNode< 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
PointDataLeafNode< T, Log2Dim > |
PointIndexLeafNode< T, Log2Dim > |
LeafNode< bool > |
LeafNode< 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
LeafNode< nanovdb::ValueMask > |
LeafNode< ValueMask > |
LeafNode< 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!
LeafManager< TreeT >::LeafRange |
LeafTopologyDiffOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees
LeafTopologyIntOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees
LevelScope | 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
LevelSetAdvection< GridT, FieldT, InterruptT > | Hyperbolic advection of narrow-band level sets in an external velocity field
LevelSetFilter< LevelSetGridT > |
LevelSetFracture< GridType, InterruptType > | Level set fracturing
LevelSetHDDA< TreeT, NodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets
LevelSetHDDA< TreeT, -1 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set
LevelSetMeasure< GridT, InterruptT > | Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets
LevelSetMorphing< GridT, InterruptT > | Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
LevelSetPruneOp< TreeT, TerminationLevel > |
LevelSetRayIntersector< GridT, SearchImplT, NodeLevel, RayT > | This class provides the public API for intersecting a ray with a narrow-band level set
LevelSetRayTracer< GridT, IntersectorT > | A (very) simple multithreaded ray tracer specifically for narrow-band level sets
LevelSetSphere< GridT, InterruptT > | Generates a signed distance field (or narrow band level set) to a single sphere
LevelSetTracker< GridT, InterruptT > | Performs multi-threaded interface tracking of narrow band level sets
LevelSetFilter< 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
LevelSetTracker< GridT, util::NullInterrupter > |
LinearOp< T > |
LinearSearchImpl< GridT, Iterations, RealT > | Implements linear iterative search for an iso-value of the level set along the direction of the ray
LinearSearchImpl< GridT > |
LocalMovePointsOp< TreeT > |
Magnitude< InGridT, MaskGridType, InterruptT > |
make_index_sequence< N, Is > |
Map | Defines an affine transform and its inverse represented as a 3x3 matrix and a vec3 translation
MapAdapter< MapType, OpType, ResultType > | Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator
MapBase | Abstract base class for maps
AffineMap | A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation

NonlinearFrustumMap

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

ScaleMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions
UniformScaleMap | A specialized Affine transform that scales along the principal axis the scaling is uniform in the three-directions
ScaleTranslateMap | 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
UniformScaleTranslateMap | A specialized Affine transform that uniformaly scales along the principal axis and then translates the result
TranslationMap | A specialized linear transform that performs a translation
UnitaryMap | A specialized linear transform that performs a unitary maping i.e. rotation and or reflection
MapRegistry | Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function
MapToNano< T > | Trait that maps any type to the corresponding nanovdb type
BaseStencil< DerivedType, SIZE, GridT >::Mask |
Mask< LOG2DIM > | Bit-mask to encode active states and facilitate sequential iterators and a fast codec for I/O compression
MaskCompress< ValueT, MaskT > |
MaskIterT |
InternalNode< ChildT, Log2Dim >::ChildIter< ParentT > | Visits child nodes of this node only
InternalNode< ChildT, Log2Dim >::ValueIterator | Visits all tile values in this node, i.e. both inactive and active tiles
InternalNode< ChildT, Log2Dim >::ValueOnIterator | Visits active tile values of this node only
LeafNode< BuildT, CoordT, MaskT, Log2Dim >::ValueOffIterator | Visits all inactive values in a leaf node
LeafNode< BuildT, CoordT, MaskT, Log2Dim >::ValueOnIterator | Visits all active values in a leaf node
InternalNode< ChildT >::ChildIterator | Visits child nodes of this node only
InternalNode< ChildT >::ValueIterator | Visits all tile values in this node, i.e. both inactive and active tiles
InternalNode< ChildT >::ValueOnIterator | Visits active tile values of this node only
LeafNode< BuildT >::ValueOffIterator | Visits all inactive values in a leaf node
LeafNode< BuildT >::ValueOnIterator | Visits all active values in a leaf node
LeafNode< ValueMask >::ValueOffIterator | Visits all inactive values in a leaf node
LeafNode< ValueMask >::ValueOnIterator | Visits all active values in a leaf node
LeafNode< bool >::ValueOffIterator | Visits all inactive values in a leaf node
LeafNode< bool >::ValueOnIterator | Visits all active values in a leaf node
MultiResGrid< TreeType >::MaskOp |
TreeToMerge< TreeT >::MaskPtr | Wrapper around unique_ptr that deep-copies mask on copy construction
TreeToMerge< TreeT >::MaskUnionOp | DynamicNodeManager operator used to generate a mask of the input tree, but with dense leaf nodes replaced with active tiles for compactness
Mat< SIZE, T > |
Mat3< double > |
Mat4< double > |
Mat4< Real > |
Mat2< T > |
Mat< 3, double > |
Mat< 3, T > |
Mat3< T > | 3x3 matrix class
Mat< 4, double > |
Mat< 4, Real > |
Mat< 4, T > |
Mat4< T > | 4x4 -matrix class
match_const< T, ReferenceT > | Trait used to transfer the const-ness of a reference type to another type
match_const< T, const ReferenceT > | Template specialization used to transfer the const-ness of a reference type to another type
MatMul |
MatMulNormalize |
SparseStencilMatrix< ValueType_, STENCIL_SIZE >::MatrixCopyOp |
GridTransformer::MatrixTransform |
MatTraits< T, bool > |
MatTraits< T, false > |
Maximum< T > | Maximum floating-point values
MaxOp< ValueType > |
MeanCurvature< MapType, DiffScheme2, DiffScheme1 > | Compute the mean curvature
MeanCurvature< GridT, MaskGridType, InterruptT > |
MeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 > |
MeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 > |
MeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 > |
MeshDataAdapter | Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
MeshToVoxelEdgeData | Extracts and stores voxel edge intersection data from a mesh
Metadata | Base class for storing metadata information in a grid
TypedMetadata< T > | Templated metadata class to hold specific types
UnknownMetadata | Subclass to hold raw data of an unregistered type
DelayedLoadMetadata | Store a buffer of data that can be optionally used during reading for faster delayed-load I/O performance
MetaMap | Container that maps names (strings) to values of arbitrary types
GridBase | Abstract base class for typed grids
Grid< _TreeType > | Container class that associates a tree with a transform and metadata
MultiResGrid< TreeType > |
MinMax< ValueType, Less > | Templated class to compute the minimum and maximum values
FastSweeping< SdfGridT, ExtValueT >::MinMaxKernel |
MinOp< ValueType > |
Morphology< TreeType > | Dilation/Erosion operations over a Trees leaf level voxel topology
MultiGroupFilter |
MultiPass | Leaf nodes that require multi-pass I/O must inherit from this struct
PointDataLeafNode< T, Log2Dim > |
MultOp< ValueType > |
MultOp< bool > |
AttributeSet::Util::NameAndType | Attribute and type name pair
File::NameIterator |
NanoNode< BuildT, LEVEL > | Trait to map from LEVEL to node type
NanoNode< BuildT, 0 > |
NanoNode< BuildT, 1 > |
NanoNode< BuildT, 2 > |
NanoNode< BuildT, 3 > |
NanoToOpenVDB< NanoBuildT > | This class will serialize an OpenVDB grid into a NanoVDB grid managed by a GridHandle
FastSweeping< SdfGridT, ExtValueT >::SweepingKernel::NN |
NodeAccessor< GridT > | The NodeAccessor provides a uniform API for accessing nodes got NanoVDB, OpenVDB and build Grids
NodeAccessor< NanoGrid< BuildT > > | Template specialization for nanovdb::Grid which is special since its NodeManage uses a handle in order to support node access on the GPU!
NodeChain< 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
NodeChain< HeadT, 1 > | Specialization to terminate NodeChain
IterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueAllIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT > |
IterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT > |
NodeFilter |
GetNodeInfo< BuildT >::NodeInfo |
NodeIteratorBase< _TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all nodes
NodeList< NodeT > | This class caches tree nodes of a specific type in a linear array
NodeList< ChildNodeType > |
NodeList< NodeT0 > |
NodeList< NodeT1 > |
NodeList< NodeT2 > |
NodeList< NodeT3 > |
NodeManager< GridT > |
NodeManager< TreeOrLeafManagerT, _LEVELS > | To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree
NodeManagerData |
NodeManager< BuildT > | NodeManager allows for sequential access to nodes
NodeManagerHandle< BufferT > | NodeManagerHandle manages the memory of a NodeManager
NodeManagerHandle< nanovdb::HostBuffer > |
NodeManagerLink< NodeT, LEVEL > | This class is a link in a chain that each caches tree nodes of a specific type in a linear array
NodeManagerLink< ChildNodeType, LEVELS-1 > |
NodeMask< Log2Dim > | Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation
NodeMask< 1 > | Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes
NodeMask< 2 > | Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes
Morphology< 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
NodeList< NodeT >::NodeRange |
GridStats< GridT, StatsT >::NodeStats |
NodeTrait< GridOrTreeOrRootT, LEVEL > | Struct to derive node type from its level in a given grid, tree or root while preserving constness
NodeTrait< const GridOrTreeOrRootT, 0 > |
NodeTrait< const GridOrTreeOrRootT, 1 > |
NodeTrait< const GridOrTreeOrRootT, 2 > |
NodeTrait< const GridOrTreeOrRootT, 3 > |
NodeTrait< GridOrTreeOrRootT, 0 > |
NodeTrait< GridOrTreeOrRootT, 1 > |
NodeTrait< GridOrTreeOrRootT, 2 > |
NodeTrait< GridOrTreeOrRootT, 3 > |

NodeUnion< 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

NodeUnion< 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.)
NodeUnion< ValueType, ChildNodeType > |
NoopStats< ValueT > | No-op Stats class
Normalize< GridT, MaskGridType, InterruptT > |
NullCodec |
NullDeformer | No-op deformer (adheres to the deformer interface documented in PointMove.h)
NullFilter | A no-op filter that can be used when iterating over all indices
NullInterrupter | Base class for interrupters
numeric_limits< openvdb::math::internal::half > |
OpAdd< ValueT > |
OpMagnitude< OpType, MapT > | Adapter for vector-valued world-space operators to return the vector magnitude
OpMax< ValueT > |
OpMin< ValueT > |
OpMult< ValueT > |
OpOver< ValueT > | Point wise methods used to apply various compositing operations
OpSub< ValueT > |
Magnitude< InGridT, MaskGridType, InterruptT >::OpT |
Normalize< GridT, MaskGridType, InterruptT >::OpT |
Page | 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
PagedArray< ValueT, Log2PageSize >::Page |
PagedArray< 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
PagedInputStream | 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
PagedOutputStream | 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
PageHandle | A PageHandle holds a unique ptr to a Page and a specific stream pointer to a point within the decompressed Page buffer
Extrema< VecT, 1 >::Pair |
ValueVoxelCIter::Parent |
PartialCreate | Tag dispatch class that distinguishes constructors during file input
ParticleArray | Partition particles and performs range and nearest-neighbor searches
ParticleAtlas< PointIndexGridType > |
ParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT > |
pnanovdb_grid_handle_t |
pnanovdb_grid_t |
pnanovdb_grid_type_constants_t |
pnanovdb_gridblindmetadata_handle_t |
pnanovdb_gridblindmetadata_t |
pnanovdb_leaf_handle_t |
pnanovdb_leaf_t |
pnanovdb_lower_handle_t |
pnanovdb_lower_t |
pnanovdb_map_handle_t |
pnanovdb_map_t |
pnanovdb_readaccessor_t |
pnanovdb_root_handle_t |
pnanovdb_root_t |
pnanovdb_root_tile_handle_t |
pnanovdb_root_tile_t |
pnanovdb_tree_handle_t |
pnanovdb_tree_t |
pnanovdb_upper_handle_t |
pnanovdb_upper_t |
Point | @dummy type for indexing points into voxels
PointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType > |
PointArray | Partitions points into `BucketLog2Dim` aligned buckets using a parallel radix-based sorting algorithm
PointAttributeVector< ValueType > | Point-partitioner compatible STL vector attribute wrapper for convenience
PointDataNodeChain< 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<>
PointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, 1 > |
PointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, HeadLevel > |
PointIndex< IntType_, Kind > | Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid
PointIndexFilter< PointArray, TreeType > |
PointIndexIterator< TreeType > | Accelerated range and nearest-neighbor searches for point index grids
PointIndexIterator< PointIndexTree > |
PointPartitioner< PointIndexType, BucketLog2Dim > |
PointSampler |
Sampler< 0, false > |
PointsToMask< GridT, InterrupterT > | Makes every voxel of a grid active if it contains a point
PolygonPool | Collection of quads and triangles
HostBuffer::Pool |
PositionRange |
Preconditioner< T > | Base class for conjugate gradient preconditioners
Preconditioner< MatrixType::ValueType > |
IncompleteCholeskyPreconditioner< MatrixType > | Preconditioner using incomplete Cholesky factorization
JacobiPreconditioner< MatrixType > | Diagonal preconditioner
ProbeValue< T > | Implements Tree::probeLeaf(Coord)
ProbeValue< BuildT > | Implements Tree::probeLeaf(Coord)
MultiResGrid< TreeType >::ProlongateOp |
promote< S, T > |
PromoteContainerType< T, ContainerT > |
PromoteContainerType< T, math::Mat3 > |
PromoteType< math::Mat3< T > > |
PromoteContainerType< T, math::Mat4 > |
PromoteType< math::Mat4< T > > |
PromoteContainerType< T, math::Quat > |
PromoteType< math::Quat< T > > |
PromoteContainerType< T, math::Vec2 > |
PromoteType< math::Vec2< T > > |
PromoteContainerType< T, math::Vec3 > |
PromoteType< math::Vec3< T > > |
PromoteContainerType< T, math::Vec4 > |
PromoteType< math::Vec4< T > > |
PromoteType< 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)
FastSweeping< SdfGridT, ExtValueT >::PruneMinMaxFltKernel |
QuadAndTriangleDataAdapter< PointType, PolygonType > | Contiguous quad and triangle data adapter class
QuadraticSampler |
Sampler< 2, false > |
QuantizedUnitVec | Unit vector occupying only 16 bits
Quat< T > |
QuatTraits< T, bool > |
QuatTraits< T, false > |
Queue | Queue for asynchronous output of grids to files or streams
Rand01< FloatType, EngineType > | Simple generator of random numbers over the range [0, 1)
Rand01< double, RandomGenerator > |
RandInt< IntType, EngineType > | Simple random integer generator
RandomLeafFilter< PointDataTreeT, RandGenT > |
Range< int, typename > |
Range< 1, T > |
Range< 2, T > |
Range< 3, T > |
RasterCamera | A camera class that provides an interface for camera motion blur when rasterizing
RasterGroups | A struct that stores all include/exclude attribute names as strings and is internally converted into the resolved MultiGroupFilter
Ray< RealT > |
Ray< RealT > |
Ray< double > |
Ray< Real > |
Ray< RealT > |
RayGenOp< Vec3T > |
ReadAccessor< BuildT, LEVEL0, LEVEL1, LEVEL2 > |
ReadAccessor< 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)
ReadAccessor< BuildT, 0, 1, 2 > | Node caching at all (three) tree levels
ChannelAccessor< ChannelT, IndexT > | Class to access values in channels at a specific voxel location
PointAccessor< AttT, BuildT > | Class to access points at a specific voxel location
PointAccessor< AttT, Point > |
ReadAccessor< BuildT, LEVEL0, -1, -1 > | Node caching at a single tree level
ReadAccessor< BuildT, LEVEL0, LEVEL1, -1 > |
RealToHalf< T > | RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types
RealToHalf< double > |
RealToHalf< float > |
RealToHalf< Vec2d > |
RealToHalf< Vec2s > |
RealToHalf< Vec3d > |
RealToHalf< Vec3s > |
ReduceFilterOp< OpT > |
PointsToMask< GridT, InterrupterT >::ReducePool |
RelDiff | Compression oracle based on relative difference
remove_const< T > | Trait use to const from type. Default implementation is just a pass-through
remove_const< const T > | Template specialization of trait class use to remove const qualifier type from a type
remove_pointer< T > | Trait use to remove pointer, i.e. "*", qualifier from a type. Default implementation is just a pass-through
remove_pointer< T * > | Template specialization of trait class use to to remove pointer, i.e. "*", qualifier from a type
remove_reference< T > | Trait use to remove reference, i.e. "&", qualifier from a type. Default implementation is just a pass-through
remove_reference< T & > | Template specialization of trait class use to remove reference, i.e. "&", qualifier from a type
MultiResGrid< TreeType >::RestrictOp |
Film::RGBA | Floating-point RGBA components in the range [0, 1]
Rgba8 | 8-bit red, green, blue, alpha packed into 32 bit unsigned int
FindActiveValues< TreeT >::RootChild |
RootData< ChildT > | Struct with all the member data of the RootNode (useful during serialization of an openvdb RootNode)
RootNode< ChildT > | Top-most node of the VDB tree structure
RootNode< ChildT > |
RootNode< ChildType > |
RootNode< Node2 > |
RootNodeCombineHelper< CombineOp, RootT, OtherRootT, Compatible > |
RootNodeCombineHelper< CombineOp, RootT, OtherRootT, true > |
RootNodeCopyHelper< RootT, OtherRootT, Compatible > |
RootNodeCopyHelper< RootT, OtherRootT, true > |
RootNodeMask |
SparseStencilMatrix< ValueType_, STENCIL_SIZE >::RowEditor | Read/write accessor to a row of this matrix
InternalNode< _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
LeafNode< 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
LeafNode< 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
LeafNode< 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
RootNode< 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
SameInternalConfig< ChildT1, Dim1, NodeT2 > |
SameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > > |
SameLeafConfig< Dim1, NodeT2 > |
SameLeafConfig< Dim1, LeafNode< T2, Dim1 > > |
SameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > > |
SameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > > |
SameRootConfig< ChildT1, NodeT2 > |
SameRootConfig< ChildT1, RootNode< ChildT2 > > |
SampleFromVoxels< TreeT, Order, UseCache > |
SampleFromVoxels< TreeOrAccT, 0, false > | Nearest neighbor, i.e. zero order, interpolator without caching
SampleFromVoxels< TreeOrAccT, 0, true > | Nearest neighbor, i.e. zero order, interpolator with caching
Sampler< Order, Staggered > | Provises a unified interface for sampling, i.e. interpolation
SampleWithRounding |
ScalarToVectorConverter< 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
AttributeArray::ScopedRegistryLock |
Segment | This class defines all the data stored in segment of a file
SetValue< T > | Set the value and its state at the leaf level mapped to by ijk, and create the leaf node and branch if needed
SetValue< BuildT > |
SetVoxel< BuildT > |
ShallowCopy | Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors
SharedOpApplier< IterT, OpT > |
SignedFloodFillOp< TreeOrLeafManagerT > |
SparseExtractor< 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
SparseMaskedExtractor< 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
SparseStencilMatrix< ValueType_, STENCIL_SIZE > | Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE
SparseStencilMatrix< OtherValueType, STENCIL_SIZE > |
SparseStencilMatrix< ValueType, 4 > |
SparseToDenseCompositor< CompositeMethod, _TreeT > |
Split |
StaggeredBoxSampler |
Sampler< 1, true > |
StaggeredPointSampler |
Sampler< 0, true > |
StaggeredQuadraticSampler |
Sampler< 2, true > |
State | Information about the state of a conjugate gradient solution
LevelSetTracker< GridT, InterruptT >::State | Lightweight struct that stores the state of the LevelSetTracker
Stats< ValueT, Rank > |
Steal | Tag dispatch class that distinguishes constructors that steal
FixedPointCodec< OneByte, Range >::Storage< T > |
GroupCodec::Storage< T > |
NullCodec::Storage< T > |
StringCodec< Truncate >::Storage< T > |
TruncateCodec::Storage< T > |
UnitVecCodec::Storage< T > |
StreamMetadata | Container for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use)
StringAttributeHandle |
StringAttributeWriteHandle |
StringCodec< Truncate > |
StringMetaCache | Class to compute a string->index map from all string:N metadata
StringMetaInserter | Class to help with insertion of keyed string values into metadata
StringTypeTrait< Truncate > |
StringTypeTrait< true > |
SumMergeOp< TreeT > | DynamicNodeManager operator to merge trees using a sum operation
SumOp< ValueType > |
SumOp< bool > |
SwappedCombineOp< ValueType, CombineOp > |
FastSweeping< SdfGridT, ExtValueT >::SweepingKernel | Private class of FastSweeping to perform concurrent fast sweeping in two directions
TensorTraits< T, Rank > |
TensorTraits< T, 0 > |
TensorTraits< T, 1 > |
TestLeafIO< typename > |
InternalNode< ChildT >::Tile |
RootNode< ChildT >::Tile |
InternalData< ChildT, LOG2DIM >::Tile |
RootData< ChildT >::Tile |
TileData< ValueType > | Struct that encodes a bounding box, value and level of a tile
RootNode< ChildT >::TileIterator |
Ray< RealT >::TimeSpan |
Ray< RealT >::TimeSpan |
Tolerance< T > | Tolerance for floating-point comparison
Tolerance< T > | Tolerance for floating-point comparison
Tolerance< double > |
Tolerance< double > |
Tolerance< float > |
Tolerance< float > |
TolerancePruneOp< TreeT, TerminationLevel > |
ToMaskGrid< 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
ToMaskGrid< GridT > |
ToMaskGrid< InGridT > |
TopologyCopy | Tag dispatch class that distinguishes topology copy constructors from deep copy constructors
InternalNode< _ChildNodeType, Log2Dim >::TopologyCopy1< OtherInternalNode > |
InternalNode< _ChildNodeType, Log2Dim >::TopologyCopy2< OtherInternalNode > |
InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode > |
InternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode > |
InternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode > |
TouchLeaf< T > |
Transform |
TransformTransfer | The TransformTransfer module should be used if the source transform of the input points and the target transforms of the destination volumes differ. The default rasterizer will skip index to world (and vice versa) transformations unless a transfer scheme derives from a TransformTransfer
Tree< BuildT > |
Grid< BuildT > |
Tree3< 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
Tree4< 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
Tree4< EdgeData, 5, 4, 3 > |
Tree5< 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
TreeAdapter< _TreeType > | This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type
TreeAdapter< Grid< _TreeType > > | Partial specialization for Grid types
TreeAdapter< tree::ValueAccessor< _TreeType > > | Partial specialization for ValueAccessor types
TreeBase | Base class for typed trees
Tree< _RootNodeType > |
TreeConverter< 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
TreeData |
Tree< RootT > | VDB Tree, which is a thin wrapper around a RootNode
TreeIterTraits< TreeT, IterT > | TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type
TreeIterTraits< TreeT, typename TreeT::LeafCIter > |
TreeIterTraits< TreeT, typename TreeT::LeafIter > |
TreeIterTraits< TreeT, typename TreeT::NodeCIter > |
TreeIterTraits< TreeT, typename TreeT::NodeIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter > |
TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter > |
TreeIterTraits< TreeT, typename TreeT::ValueAllCIter > |
TreeIterTraits< TreeT, typename TreeT::ValueAllIter > |
TreeIterTraits< TreeT, typename TreeT::ValueOffCIter > |
TreeIterTraits< TreeT, typename TreeT::ValueOffIter > |
TreeIterTraits< TreeT, typename TreeT::ValueOnCIter > |
TreeIterTraits< TreeT, typename TreeT::ValueOnIter > |
TreeMarcher< NodeT, RayT, AccT, CoordT > | A Tree Marcher for Generic Grids
PointTreeMarcher< AccT, RayT, CoordT > | A Tree Marcher for Point Grids
TreeMarcher< LeafNode< AccT::ValueType >, RayT, AccT, Coord > |
TreeToMerge< 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
TreeTraits< TreeT > | Useful traits for Tree types
TreeTraits< const TreeT > |
TreeValueIteratorBase< _TreeT, _ValueIterT > | Base class for tree-traversal iterators over tile and voxel values
TricubicSampler< TreeOrAccT > | Tri-cubic sampler, i.e. third order, interpolator
SampleFromVoxels< TreeOrAccT, 3, false > |
SampleFromVoxels< TreeOrAccT, 3, true > |
TrilinearSampler< TreeOrAccT > | Tri-linear sampler, i.e. first order, interpolator
SampleFromVoxels< TreeOrAccT, 1, false > | Template specialization that does not use caching of stencil points
SampleFromVoxels< TreeOrAccT, 1, true > | Template specialization with caching of stencil values
TrilinearTraits< ValueT, Staggered > |
TrilinearTraits< ValueT, false > |
TriquadraticSampler< TreeOrAccT > | Tri-quadratic sampler, i.e. second order, interpolator
SampleFromVoxels< TreeOrAccT, 2, false > | Template specialization that does not use caching of stencil points
SampleFromVoxels< TreeOrAccT, 2, true > | Template specialization with caching of stencil values
true_type |
IsSpecializationOf< Template< Args... >, Template > |
TruncateCodec |
TruncateTrait< T > |
TruncateTrait< float > |
TruncateTrait< int > |
TruncateTrait< math::Vec3< T > > |
Tuple< SIZE, T > |
Vec3< Real > |
Tuple< 2, T > |
Vec2< T > |
Tuple< 3, Real > |
Tuple< 3, T > |
Vec3< T > |
Tuple< 4, T > |
Vec4< T > |
TupleList< Ts > | A trivial wrapper around a std::tuple but with compatible TypeList methods. Importantly can be instatiated from a TypeList and implements a similar foreach interface
TupleList<> | Specilization of an empty TupleList. Required due to constructor selection
TypeList< Ts > | A list of types (not necessarily unique)
VolumeTransfer< TreeTypes >::TypeResolver< T > |
UIntTypeTrait< OneByte, T > |
UIntTypeTrait< false, math::Vec3< T > > |
UIntTypeTrait< false, T > |
UIntTypeTrait< true, math::Vec3< T > > |
UIntTypeTrait< true, T > |
UnitRange |
UnitVecCodec |
UnknownCodec |
AttributeSet::Util |
ValueAccessor< BuildT > |
ValueAccessorBase< 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
ValueAccessorImpl< const TreeType, IsSafe > |
ValueAccessorImpl< const TreeT, false > |
ValueAccessorImpl< const TreeT > |
ValueAccessorImpl< TreeT > |
ValueAccessorImpl< TreeType > |
ValueAccessorImpl< IntTreeT > |
ValueAccessorImpl< const PointIndexTree > |
ValueAccessorBase< _TreeType, IsSafe > |
ValueAccessorImpl< _TreeType, IsSafe, MutexT, IntegerSequence > | The Value Accessor Implementation and API methods. The majoirty of the API matches the API of a compatible OpenVDB Tree Node
ValueAccessorBase< const PointIndexTree, IsSafe > |
ValueAccessorBase< const TreeT, IsSafe > |
ValueAccessorBase< const TreeType, IsSafe > |
ValueAccessorBase< IntTreeT, IsSafe > |
ValueAccessorBase< TreeT, IsSafe > |

ValueAccessorLeafBuffer< TreeTypeT, IntegerSequence, Enable >

A small class that contains a cached pointer to a LeafNode data buffer which is derived from by the internal Value Accessor Implementation. This allows for the empty base class optimization to be performed in the case where a LeafNode does not store a contiguous index-able buffer. From C++20 we can instead switch to [[no_unique_address]]

ValueAccessorImpl< const TreeType, IsSafe > |
ValueAccessorImpl< const TreeT, false > |
ValueAccessorImpl< const TreeT > |
ValueAccessorImpl< TreeT > |
ValueAccessorImpl< TreeType > |
ValueAccessorImpl< IntTreeT > |
ValueAccessorImpl< const PointIndexTree > |
ValueAccessorLeafBuffer< _TreeType, IntegerSequence > |
ValueAccessorImpl< _TreeType, IsSafe, MutexT, IntegerSequence > | The Value Accessor Implementation and API methods. The majoirty of the API matches the API of a compatible OpenVDB Tree Node
ValueAccessorLeafBuffer< const PointIndexTree, IntegerSequence > |
ValueAccessorLeafBuffer< const TreeT, IntegerSequence > |
ValueAccessorLeafBuffer< const TreeType, IntegerSequence > |
ValueAccessorLeafBuffer< IntTreeT, IntegerSequence > |
ValueAccessorLeafBuffer< TreeT, IntegerSequence > |
ValueAccessorLeafBuffer< TreeType, IntegerSequence > |
ValueAccessorLeafBuffer< TreeTypeT, IntegerSequence, typename std::enable_if< !value_accessor_internal::EnableLeafBuffer< TreeTypeT, IntegerSequence >::value >::type > | Specialization for the case where a Leaf Buffer cannot be cached
ValueAccessorLock< MutexT > | A small class that contains a Mutex which is derived from by the internal Value Accessor Implementation. This allows for the empty base class optimization to be performed in the case where a Mutex/Lock is not in use. From C++20 we can instead switch to [[no_unique_address]]
ValueAccessorImpl< const TreeType, IsSafe > |
ValueAccessorImpl< const TreeT, false > |
ValueAccessorImpl< const TreeT > |
ValueAccessorImpl< TreeT > |
ValueAccessorImpl< TreeType > |
ValueAccessorImpl< IntTreeT > |
ValueAccessorImpl< const PointIndexTree > |
ValueAccessorImpl< _TreeType, IsSafe, MutexT, IntegerSequence > | The Value Accessor Implementation and API methods. The majoirty of the API matches the API of a compatible OpenVDB Tree Node
ValueAccessorLock< void > | Specialization for the case where no Mutex is in use. See above
InternalNode< _ChildNodeType, Log2Dim >::ValueAll |
LeafNode< T, Log2Dim >::ValueAll |
PagedArray< ValueT, Log2PageSize >::ValueBuffer |
Grid< _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
InternalNode< _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
LeafNode< 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
LeafNode< 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
LeafNode< 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
RootNode< 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
Tree< _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
Tree< _RootNodeType >::ValueConverter< Int32 > |
ValueIndex | Dummy type for a voxel whose value equals an offset into an external value array
IndexIter< IteratorT, FilterT >::ValueIndexIter | A forward iterator over array indices from a value iterator (such as ValueOnCIter)
ValueIndexMask | Like `ValueIndex` but with a mutable mask
LeafNode< BuildT >::ValueIterator | Visits all values in a leaf node, i.e. both active and inactive values
LeafNode< bool >::ValueIterator | Visits all values in a leaf node, i.e. both active and inactive values
LeafNode< ValueMask >::ValueIterator | Visits all values in a leaf node, i.e. both active and inactive values
RootNode< ChildT >::ValueIterator |
LeafNode< BuildT, CoordT, MaskT, Log2Dim >::ValueIterator | Visits all values in a leaf node, i.e. both active and inactive values
ValueMask | Dummy type for a voxel whose value equals its binary active state
ValueMask |
ValueMaskFilter< On > | Index filtering on active / inactive state of host voxel
InternalNode< _ChildNodeType, Log2Dim >::ValueOff |
LeafNode< T, Log2Dim >::ValueOff |
InternalNode< _ChildNodeType, Log2Dim >::ValueOn |
LeafNode< T, Log2Dim >::ValueOn |
ValueOnIndex | Dummy type for a voxel whose value equals an offset into an external value array of active values
ValueOnIndexMask | Like `ValueOnIndex` but with a mutable mask
RootNode< ChildT >::ValueOnIterator |
ValueTraits< T, bool > |
ValueTraits< T, false > |
ValueVoxelCIter | A forward iterator over array indices in a single voxel
Vec3< T > | A simple vector class with three components, similar to openvdb::math::Vec3
Vec3< double > |
Vec4< T > | A simple vector class with four components, similar to openvdb::math::Vec4
Vector< T > | Lightweight, variable-length vector
Vector< ValueType > |
VectorToScalarConverter< 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
VectorToScalarGrid< VecGridT > | Metafunction to convert a vector-valued grid type to a scalar grid type
VecTraits< T, bool > |
VecTraits< T, false > |
VelocityIntegrator< GridT, Staggered, SampleOrder > | Performs Runge-Kutta time integration of variable order in a static velocity field
VelocitySampler< GridT, Staggered, Order > |
VelocitySampler< Vec3fGrid, false, 1 > |
Version | Bit-compacted representation of all three version numbers
VersionId |
VolumeAdvection< 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
VolumeHDDA< TreeT, RayT, ChildNodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume
VolumeHDDA< openvdb::v11_0::tree::Tree, RayType, GridT::TreeType::RootNodeType::ChildNodeType::LEVEL > |
VolumeHDDA< TreeT, RayT, 0 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume
VolumeRayIntersector< GridT, NodeLevel, RayT > | This class provides the public API for intersecting a ray with a generic (e.g. density) volume
VolumeRender< IntersectorT, SamplerT > | A (very) simple multithreaded volume render specifically for scalar density
VolumeToMesh | Mesh any scalar grid that has a continuous isosurface
VolumeTransfer< TreeTypes > | The VolumeTransfer module provides methods to automatically setup and access destination buffers for multiple target volumes of arbitrary types. Deriving from a VolumeTransfer ensures that the available buffers correlate to the order of the provided tree arguments
VolumeTransfer< TreeT > | VolumeTransfer specialization for a single target volume
InternalNode< _ChildNodeType, Log2Dim >::VoxelizeActiveTiles |
Tree< BuildT >::WriteAccessor |