#include "version.h"
#include "Platform.h"
#include <OpenEXR/half.h>
#include <openvdb/math/Math.h>
#include <openvdb/math/BBox.h>
#include <openvdb/math/Quat.h>
#include <openvdb/math/Vec2.h>
#include <openvdb/math/Vec3.h>
#include <openvdb/math/Vec4.h>
#include <openvdb/math/Mat3.h>
#include <openvdb/math/Mat4.h>
#include <openvdb/math/Coord.h>
#include <memory>
#include <type_traits>

Classes
class	ValueMask

struct	PointIndex< IntType_, Kind >
	Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid. More...

struct	VecTraits< T >

struct	VecTraits< math::Vec2< T > >

struct	VecTraits< math::Vec3< T > >

struct	VecTraits< math::Vec4< T > >

struct	CanConvertType< FromType, ToType >
	CanConvertType<FromType, ToType>::value is `true` if a value of type ToType can be constructed from a value of type FromType. More...

struct	CanConvertType< T, math::Vec2< T > >

struct	CanConvertType< T, math::Vec3< T > >

struct	CanConvertType< T, math::Vec4< T > >

struct	CanConvertType< math::Vec2< T >, math::Vec2< T > >

struct	CanConvertType< math::Vec3< T >, math::Vec3< T > >

struct	CanConvertType< math::Vec4< T >, math::Vec4< T > >

struct	CanConvertType< T0, math::Vec2< T1 > >

struct	CanConvertType< T0, math::Vec3< T1 > >

struct	CanConvertType< T0, math::Vec4< T1 > >

struct	CanConvertType< PointIndex32, PointDataIndex32 >

struct	CanConvertType< PointDataIndex32, PointIndex32 >

struct	CanConvertType< T, ValueMask >

struct	CanConvertType< ValueMask, T >

class	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. More...

struct	SwappedCombineOp< ValueType, CombineOp >

class	ShallowCopy
	Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors. More...

class	TopologyCopy
	Tag dispatch class that distinguishes topology copy constructors from deep copy constructors. More...

class	PartialCreate
	Tag dispatch class that distinguishes constructors during file input. More...

Namespaces
	openvdb

	openvdb::v5_2

Macros
#define	OPENVDB_START_THREADSAFE_STATIC_REFERENCE

#define	OPENVDB_FINISH_THREADSAFE_STATIC_REFERENCE

#define	OPENVDB_START_THREADSAFE_STATIC_WRITE

#define	OPENVDB_FINISH_THREADSAFE_STATIC_WRITE

#define	OPENVDB_START_THREADSAFE_STATIC_ADDRESS

#define	OPENVDB_FINISH_THREADSAFE_STATIC_ADDRESS

#define	OPENVDB_START_NON_THREADSAFE_STATIC_REFERENCE

#define	OPENVDB_FINISH_NON_THREADSAFE_STATIC_REFERENCE

#define	OPENVDB_START_NON_THREADSAFE_STATIC_WRITE

#define	OPENVDB_FINISH_NON_THREADSAFE_STATIC_WRITE

#define	OPENVDB_START_NON_THREADSAFE_STATIC_ADDRESS

#define	OPENVDB_FINISH_NON_THREADSAFE_STATIC_ADDRESS

#define	OPENVDB_THREADSAFE_STATIC_REFERENCE(CODE) CODE

#define	OPENVDB_THREADSAFE_STATIC_WRITE(CODE) CODE

#define	OPENVDB_THREADSAFE_STATIC_ADDRESS(CODE) CODE

Typedefs
using	Index32 = uint32_t

using	Index64 = uint64_t

using	Index = Index32

using	Int16 = int16_t

using	Int32 = int32_t

using	Int64 = int64_t

using	Int = Int32

using	Byte = unsigned char

using	Real = double

using	Vec2R = math::Vec2< Real >

using	Vec2I = math::Vec2< Index32 >

using	Vec2f = math::Vec2< float >

using	Vec2H = math::Vec2< half >

using	Vec3R = math::Vec3< Real >

using	Vec3I = math::Vec3< Index32 >

using	Vec3f = math::Vec3< float >

using	Vec3H = math::Vec3< half >

using	Vec3U8 = math::Vec3< uint8_t >

using	Vec3U16 = math::Vec3< uint16_t >

using	BBoxd = math::BBox< Vec3d >

using	Vec4R = math::Vec4< Real >

using	Vec4I = math::Vec4< Index32 >

using	Vec4f = math::Vec4< float >

using	Vec4H = math::Vec4< half >

using	Mat3R = math::Mat3< Real >

using	Mat4R = math::Mat4< Real >

using	QuatR = math::Quat< Real >

template<typename T >
using	SharedPtr = std::shared_ptr< T >

template<typename T >
using	WeakPtr = std::weak_ptr< T >

using	PointIndex32 = PointIndex< Index32, 0 >

using	PointIndex64 = PointIndex< Index64, 0 >

using	PointDataIndex32 = PointIndex< Index32, 1 >

using	PointDataIndex64 = PointIndex< Index64, 1 >

Enumerations
enum	GridClass { GRID_UNKNOWN = 0, GRID_LEVEL_SET, GRID_FOG_VOLUME, GRID_STAGGERED }

enum	{ NUM_GRID_CLASSES = GRID_STAGGERED + 1 }

enum	VecType { VEC_INVARIANT = 0, VEC_COVARIANT, VEC_COVARIANT_NORMALIZE, VEC_CONTRAVARIANT_RELATIVE, VEC_CONTRAVARIANT_ABSOLUTE }

enum	{ NUM_VEC_TYPES = VEC_CONTRAVARIANT_ABSOLUTE + 1 }

enum	MergePolicy { MERGE_ACTIVE_STATES = 0, MERGE_NODES, MERGE_ACTIVE_STATES_AND_NODES }

Functions
template<typename T , typename U >
SharedPtr< T >	ConstPtrCast (const SharedPtr< U > &ptr)
	Return a new shared pointer that points to the same object as the given pointer but with possibly different `const`-ness. More...

template<typename T , typename U >
SharedPtr< T >	DynamicPtrCast (const SharedPtr< U > &ptr)
	Return a new shared pointer that is either null or points to the same object as the given pointer after a `dynamic_cast`. More...

template<typename T , typename U >
SharedPtr< T >	StaticPtrCast (const SharedPtr< U > &ptr)
	Return a new shared pointer that points to the same object as the given pointer after a `static_cast`. More...

template<typename T >
const char *	typeNameAsString ()

template<>
const char *	typeNameAsString< bool > ()

template<>
const char *	typeNameAsString< ValueMask > ()

template<>
const char *	typeNameAsString< half > ()

template<>
const char *	typeNameAsString< float > ()

template<>
const char *	typeNameAsString< double > ()

template<>
const char *	typeNameAsString< uint8_t > ()

template<>
const char *	typeNameAsString< int16_t > ()

template<>
const char *	typeNameAsString< uint16_t > ()

template<>
const char *	typeNameAsString< int32_t > ()

template<>
const char *	typeNameAsString< uint32_t > ()

template<>
const char *	typeNameAsString< int64_t > ()

template<>
const char *	typeNameAsString< Vec2i > ()

template<>
const char *	typeNameAsString< Vec2s > ()

template<>
const char *	typeNameAsString< Vec2d > ()

template<>
const char *	typeNameAsString< Vec3U8 > ()

template<>
const char *	typeNameAsString< Vec3U16 > ()

template<>
const char *	typeNameAsString< Vec3i > ()

template<>
const char *	typeNameAsString< Vec3f > ()

template<>
const char *	typeNameAsString< Vec3d > ()

template<>
const char *	typeNameAsString< std::string > ()

template<>
const char *	typeNameAsString< Mat3s > ()

template<>
const char *	typeNameAsString< Mat3d > ()

template<>
const char *	typeNameAsString< Mat4s > ()

template<>
const char *	typeNameAsString< Mat4d > ()

template<>
const char *	typeNameAsString< math::Quats > ()

template<>
const char *	typeNameAsString< math::Quatd > ()

template<>
const char *	typeNameAsString< PointIndex32 > ()

template<>
const char *	typeNameAsString< PointIndex64 > ()

template<>
const char *	typeNameAsString< PointDataIndex32 > ()

template<>
const char *	typeNameAsString< PointDataIndex64 > ()

Variables
static const Real	LEVEL_SET_HALF_WIDTH = 3

Macro Definition Documentation

#define OPENVDB_FINISH_NON_THREADSAFE_STATIC_ADDRESS

#define OPENVDB_FINISH_NON_THREADSAFE_STATIC_REFERENCE

#define OPENVDB_FINISH_NON_THREADSAFE_STATIC_WRITE

#define OPENVDB_FINISH_THREADSAFE_STATIC_ADDRESS

#define OPENVDB_FINISH_THREADSAFE_STATIC_REFERENCE

#define OPENVDB_FINISH_THREADSAFE_STATIC_WRITE

#define OPENVDB_START_NON_THREADSAFE_STATIC_ADDRESS

#define OPENVDB_START_NON_THREADSAFE_STATIC_REFERENCE

#define OPENVDB_START_NON_THREADSAFE_STATIC_WRITE

#define OPENVDB_START_THREADSAFE_STATIC_ADDRESS

#define OPENVDB_START_THREADSAFE_STATIC_REFERENCE

#define OPENVDB_START_THREADSAFE_STATIC_WRITE

#define OPENVDB_THREADSAFE_STATIC_ADDRESS ( CODE ) CODE

#define OPENVDB_THREADSAFE_STATIC_REFERENCE ( CODE ) CODE

#define OPENVDB_THREADSAFE_STATIC_WRITE ( CODE ) CODE

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation