owl::common Namespace Reference

Namespaces
	array2D
	array3D
	polymorphic

Classes
struct	AffineSpaceT
struct	BinaryOpResultType
struct	BinaryOpResultType< double, int >
struct	BinaryOpResultType< double, unsigned int >
struct	BinaryOpResultType< float, int >
struct	BinaryOpResultType< float, unsigned int >
struct	BinaryOpResultType< int, double >
struct	BinaryOpResultType< int, float >
struct	BinaryOpResultType< ScalarType, ScalarType >
struct	BinaryOpResultType< unsigned int, double >
struct	BinaryOpResultType< unsigned int, float >
struct	box_t
struct	DRand48
struct	interval
struct	LCG
struct	limits_traits
struct	limits_traits< false >
struct	limits_traits< true >
struct	LinearSpace2
	2D Linear Transform (2x2 Matrix) More...
struct	LinearSpace3
	3D Linear Transform (3x3 Matrix) More...
struct	long_type_of
struct	long_type_of< int32_t >
struct	long_type_of< uint32_t >
struct	NaNTy
struct	NegInfTy
struct	OneTy
struct	PosInfTy
struct	QuaternionT
struct	UlpTy
struct	vec_t
struct	vec_t< T, 1 >
struct	vec_t< T, 2 >
struct	vec_t< T, 3 >
struct	vec_t< T, 4 >
struct	ZeroTy

Typedefs
using	AffineSpace2f = AffineSpaceT< LinearSpace2f >
using	AffineSpace3f = AffineSpaceT< LinearSpace3f >
using	AffineSpace3fa = AffineSpaceT< LinearSpace3fa >
using	OrthonormalSpace3f = AffineSpaceT< Quaternion3f >
using	affine2f = AffineSpace2f
using	affine3f = AffineSpace3f
using	LinearSpace2f = LinearSpace2< vec2f >
using	LinearSpace3f = LinearSpace3< vec3f >
using	LinearSpace3fa = LinearSpace3< vec3fa >
using	linear2f = LinearSpace2f
using	linear3f = LinearSpace3f
typedef QuaternionT< float >	Quaternion3f
typedef QuaternionT< double >	Quaternion3d

Functions
template<typename L >
AffineSpaceT< L >	operator- (const AffineSpaceT< L > &a)
template<typename L >
AffineSpaceT< L >	operator+ (const AffineSpaceT< L > &a)
template<typename L >
AffineSpaceT< L >	rcp (const AffineSpaceT< L > &a)
template<typename L >
AffineSpaceT< L >	operator+ (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L >	operator- (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L >	operator* (const ScalarT &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L >	operator* (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L >	operator/ (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L >	operator/ (const AffineSpaceT< L > &a, const ScalarT &b)
template<typename L >
AffineSpaceT< L > &	operator*= (AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L > &	operator*= (AffineSpaceT< L > &a, const ScalarT &b)
template<typename L >
AffineSpaceT< L > &	operator/= (AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
AffineSpaceT< L > &	operator/= (AffineSpaceT< L > &a, const ScalarT &b)
template<typename L >
__both__ const VectorT	xfmPoint (const AffineSpaceT< L > &m, const VectorT &p)
template<typename L >
__both__ const VectorT	xfmVector (const AffineSpaceT< L > &m, const VectorT &v)
template<typename L >
__both__ const VectorT	xfmNormal (const AffineSpaceT< L > &m, const VectorT &n)
template<typename L >
bool	operator== (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
	Comparison Operators. More...
template<typename L >
bool	operator!= (const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
template<typename L >
std::ostream &	operator<< (std::ostream &cout, const AffineSpaceT< L > &m)
__both__ box3f	xfmBounds (const affine3f &xfm, const box3f &box)
template<typename T >
__both__ std::ostream &	operator<< (std::ostream &o, const interval< T > &b)
template<typename T >
__both__ interval< T >	build_interval (const T &a, const T &b)
template<typename T >
__both__ interval< T >	intersect (const interval< T > &a, const interval< T > &b)
template<typename T >
__both__ interval< T >	operator- (const interval< T > &a, const T &b)
template<typename T >
__both__ interval< T >	operator* (const interval< T > &a, const T &b)
template<typename T >
__both__ bool	operator== (const interval< T > &a, const interval< T > &b)
template<typename T >
__both__ bool	operator!= (const interval< T > &a, const interval< T > &b)
template<typename T >
__both__ long_type_of< T >::type	area (const box_t< vec_t< T, 2 >> &b)
template<typename T >
__both__ long_type_of< T >::type	area (const box_t< vec_t< T, 3 >> &b)
template<typename T >
__both__ long_type_of< T >::type	volume (const box_t< vec_t< T, 3 >> &b)
template<typename T >
__both__ std::ostream &	operator<< (std::ostream &o, const box_t< T > &b)
template<typename T >
__both__ box_t< T >	intersection (const box_t< T > &a, const box_t< T > &b)
template<typename T >
__both__ bool	operator== (const box_t< T > &a, const box_t< T > &b)
template<typename T >
__both__ bool	operator!= (const box_t< T > &a, const box_t< T > &b)
	_define_box_types (short int, s)
	_define_box_types (unsigned short int, us)
	_define_box_types (int, i)
	_define_box_types (unsigned int, ui)
	_define_box_types (float, f)
__both__ float	infty ()
template<typename T >
__both__ T	empty_bounds_lower ()
template<typename T >
__both__ T	empty_bounds_upper ()
template<typename T >
__both__ T	empty_range_lower ()
template<typename T >
__both__ T	empty_range_upper ()
template<typename T >
__both__ T	open_range_lower ()
template<typename T >
__both__ T	open_range_upper ()
template<typename T >
__both__ LinearSpace2< T >	operator- (const LinearSpace2< T > &a)
template<typename T >
__both__ LinearSpace2< T >	operator+ (const LinearSpace2< T > &a)
template<typename T >
__both__ LinearSpace2< T >	rcp (const LinearSpace2< T > &a)
template<typename T >
LinearSpace2< T >	operator+ (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
LinearSpace2< T >	operator- (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
LinearSpace2< T >	operator* (const typename T::scalar_t &a, const LinearSpace2< T > &b)
template<typename T >
T	operator* (const LinearSpace2< T > &a, const T &b)
template<typename T >
LinearSpace2< T >	operator* (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
LinearSpace2< T >	operator/ (const LinearSpace2< T > &a, const typename T::scalar_t &b)
template<typename T >
LinearSpace2< T >	operator/ (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
LinearSpace2< T > &	operator*= (LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
LinearSpace2< T > &	operator/= (LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
bool	operator== (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
	Comparison Operators. More...
template<typename T >
bool	operator!= (const LinearSpace2< T > &a, const LinearSpace2< T > &b)
template<typename T >
static std::ostream &	operator<< (std::ostream &cout, const LinearSpace2< T > &m)
	Output Operators. More...
template<typename T >
__both__ LinearSpace3< T >	operator- (const LinearSpace3< T > &a)
template<typename T >
__both__ LinearSpace3< T >	operator+ (const LinearSpace3< T > &a)
template<typename T >
__both__ LinearSpace3< T >	rcp (const LinearSpace3< T > &a)
template<typename T >
__both__ LinearSpace3< T >	frame (const T &N)
template<typename T >
__both__ LinearSpace3< T >	frame (const T &N, const T &dxi)
template<typename T >
__both__ LinearSpace3< T >	clamp (const LinearSpace3< T > &space)
template<typename T >
__both__ LinearSpace3< T >	operator+ (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
__both__ LinearSpace3< T >	operator- (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
__both__ LinearSpace3< T >	operator* (const typename T::scalar_t &a, const LinearSpace3< T > &b)
template<typename T >
T	operator* (const LinearSpace3< T > &a, const T &b)
template<typename T >
__both__ LinearSpace3< T >	operator* (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
__both__ LinearSpace3< T >	operator/ (const LinearSpace3< T > &a, const typename T::scalar_t &b)
template<typename T >
__both__ LinearSpace3< T >	operator/ (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
LinearSpace3< T > &	operator*= (LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
LinearSpace3< T > &	operator/= (LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
__both__ T	xfmPoint (const LinearSpace3< T > &s, const T &a)
template<typename T >
__both__ T	xfmVector (const LinearSpace3< T > &s, const T &a)
template<typename T >
__both__ T	xfmNormal (const LinearSpace3< T > &s, const T &a)
template<typename T >
bool	operator== (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
	Comparison Operators. More...
template<typename T >
bool	operator!= (const LinearSpace3< T > &a, const LinearSpace3< T > &b)
template<typename T >
std::ostream &	operator<< (std::ostream &cout, const LinearSpace3< T > &m)
	Output Operators. More...
template<typename T >
__both__ QuaternionT< T >	operator* (const T &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator* (const QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T >	operator+ (const QuaternionT< T > &a)
template<typename T >
__both__ QuaternionT< T >	operator- (const QuaternionT< T > &a)
template<typename T >
__both__ QuaternionT< T >	conj (const QuaternionT< T > &a)
template<typename T >
__both__ T	abs (const QuaternionT< T > &a)
template<typename T >
__both__ QuaternionT< T >	rcp (const QuaternionT< T > &a)
template<typename T >
__both__ QuaternionT< T >	normalize (const QuaternionT< T > &a)
template<typename T >
__both__ QuaternionT< T >	operator+ (const T &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator+ (const QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T >	operator+ (const QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator- (const T &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator- (const QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T >	operator- (const QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >::Vector	operator* (const QuaternionT< T > &a, const typename QuaternionT< T >::Vector &b)
template<typename T >
__both__ QuaternionT< T >	operator* (const QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator/ (const T &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >	operator/ (const QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T >	operator/ (const QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T > &	operator+= (QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T > &	operator+= (QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T > &	operator-= (QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T > &	operator-= (QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T > &	operator*= (QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T > &	operator*= (QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T > &	operator/= (QuaternionT< T > &a, const T &b)
template<typename T >
__both__ QuaternionT< T > &	operator/= (QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
__both__ QuaternionT< T >::Vector	xfmPoint (const QuaternionT< T > &a, const typename QuaternionT< T >::Vector &b)
template<typename T >
__both__ QuaternionT< T >::Vector	xfmQuaternion (const QuaternionT< T > &a, const typename QuaternionT< T >::Vector &b)
template<typename T >
__both__ QuaternionT< T >::Vector	xfmNormal (const QuaternionT< T > &a, const typename QuaternionT< T >::Vector &b)
template<typename T >
__both__ bool	operator== (const QuaternionT< T > &a, const QuaternionT< T > &b)
	Comparison Operators. More...
template<typename T >
__both__ bool	operator!= (const QuaternionT< T > &a, const QuaternionT< T > &b)
template<typename T >
static std::ostream &	operator<< (std::ostream &cout, const QuaternionT< T > &q)
	Output Operators. More...
template<typename T >
__both__ bool	operator== (const vec_t< T, 2 > &a, const vec_t< T, 2 > &b)
template<typename T >
__both__ bool	operator== (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
template<typename T >
__both__ bool	operator== (const vec_t< T, 4 > &a, const vec_t< T, 4 > &b)
template<typename T , int N>
__both__ bool	operator!= (const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T >
__both__ auto	nt (const vec_t< T, 2 > &a) -> vec_t< decltype(!a.x), 2 >
template<typename T >
__both__ auto	nt (const vec_t< T, 3 > &a) -> vec_t< decltype(!a.x), 3 >
template<typename T >
__both__ auto	nt (const vec_t< T, 4 > &a) -> vec_t< decltype(!a.x), 4 >
template<typename T >
__both__ auto	eq (const vec_t< T, 2 > &a, const vec_t< T, 2 > &b) -> vec_t< decltype(a.x==b.x), 2 >
template<typename T >
__both__ auto	eq (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b) -> vec_t< decltype(a.x==b.x), 3 >
template<typename T >
__both__ auto	eq (const vec_t< T, 4 > &a, const vec_t< T, 4 > &b) -> vec_t< decltype(a.x==b.x), 4 >
template<typename T , int N>
__both__ auto	neq (const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(eq(a, b)))
template<typename T >
__both__ auto	lt (const vec_t< T, 2 > &a, const vec_t< T, 2 > &b) -> vec_t< decltype(a.x< b.x), 2 >
template<typename T >
__both__ auto	lt (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b) -> vec_t< decltype(a.x< b.x), 3 >
template<typename T >
__both__ auto	lt (const vec_t< T, 4 > &a, const vec_t< T, 4 > &b) -> vec_t< decltype(a.x< b.x), 4 >
template<typename T , int N>
__both__ auto	le (const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(lt(b, a)))
template<typename T , int N>
__both__ auto	gt (const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(lt(b, a))
template<typename T , int N>
__both__ auto	ge (const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(lt(a, b)))
template<typename T , int N>
__both__ bool	any (const vec_t< T, N > &a)
template<typename T , int N>
__both__ bool	all (const vec_t< T, N > &a)
template<typename T >
__both__ vec_t< T, 2 >	select (const vec_t< bool, 2 > &mask, const vec_t< T, 2 > &a, const vec_t< T, 2 > &b)
template<typename T >
__both__ vec_t< T, 3 >	select (const vec_t< bool, 3 > &mask, const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
template<typename T >
__both__ vec_t< T, 4 >	select (const vec_t< bool, 4 > &mask, const vec_t< T, 4 > &a, const vec_t< T, 4 > &b)
template<typename T , int N>
__both__ vec_t< T, N >	select (const vec_t< bool, N > &mask, const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T , int N>
__both__ bool	any_less_than (const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T , int N>
__both__ bool	all_less_than (const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T , int N>
__both__ bool	any_greater_than (const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T , int N>
__both__ bool	any_greater_or_equal (const vec_t< T, N > &a, const vec_t< T, N > &b)
template<typename T >
__both__ T	clamp (const T &val, const T &lo, const T &hi)
template<typename T >
__both__ T	clamp (const T &val, const T &hi)
	_define_float_functor (rcp) _define_float_functor(sin) _define_float_functor(cos) _define_float_functor(abs) _define_float_functor(saturate) _define_binary_functor(divRoundUp) _define_binary_functor(min) _define_binary_functor(max) _define_operator(*)
	_define_operator (/)
	_define_operator (+)
	_define_operator (-)
template<typename T >
__both__ vec_t< T, 2 >	operator- (const vec_t< T, 2 > &v)
template<typename T >
__both__ vec_t< T, 2 >	operator+ (const vec_t< T, 2 > &v)
template<typename T >
__both__ vec_t< T, 3 >	operator- (const vec_t< T, 3 > &v)
template<typename T >
__both__ vec_t< T, 3 >	operator+ (const vec_t< T, 3 > &v)
	_define_op_assign_operator (operator*=, *=)
	_define_op_assign_operator (operator/=,/=)
	_define_op_assign_operator (operator+=,+=)
	_define_op_assign_operator (operator-=,-=)
template<typename T >
__both__ T	reduce_min (const vec_t< T, 1 > &v)
template<typename T >
__both__ T	reduce_min (const vec_t< T, 2 > &v)
template<typename T >
__both__ T	reduce_min (const vec_t< T, 3 > &v)
template<typename T >
__both__ T	reduce_min (const vec_t< T, 4 > &v)
template<typename T >
__both__ T	reduce_max (const vec_t< T, 2 > &v)
template<typename T >
__both__ T	reduce_max (const vec_t< T, 3 > &v)
template<typename T >
__both__ T	reduce_max (const vec_t< T, 4 > &v)
template<typename T , int N>
__both__ vec_t< T, 3 >	madd (const vec_t< T, N > &a, const vec_t< T, N > &b, const vec_t< T, N > &c)
template<typename T , int N>
__both__ int	arg_max (const vec_t< T, N > &v)
template<typename T , int N>
__both__ int	arg_min (const vec_t< T, N > &v)
template<typename T >
__both__ bool	operator< (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
__both__ vec3f	randomColor (int i)
__both__ vec3f	randomColor (size_t idx)
template<typename T >
__both__ vec3f	randomColor (const T *ptr)
__both__ float	sqrt (const float v)
__both__ vec2f	sqrt (const vec2f v)
__both__ vec3f	sqrt (const vec3f v)
__both__ vec4f	sqrt (const vec4f v)
__both__ float	rotate (const float a, const float b)
__both__ vec2f	rotate (const vec2f a, const vec2f b)
template<typename T >
__both__ long_type_of< T >::type	area (const vec_t< T, 2 > &v)
template<typename T >
__both__ long_type_of< T >::type	volume (const vec_t< T, 3 > &v)
template<typename T >
__both__ long_type_of< T >::type	volume (const vec_t< T, 4 > &v)
template<typename T >
__both__ long_type_of< T >::type	area (const vec_t< T, 3 > &v)
template<typename T >
__both__ vec_t< T, 3 >	cross (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
template<typename T >
__both__ T	dot (const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
template<typename T >
__both__ vec_t< T, 3 >	normalize (const vec_t< T, 3 > &v)
template<typename T >
__both__ T	length (const vec_t< T, 3 > &v)
template<typename T >
__owl_host std::ostream &	operator<< (std::ostream &o, const vec_t< T, 1 > &v)
template<typename T >
__owl_host std::ostream &	operator<< (std::ostream &o, const vec_t< T, 2 > &v)
template<typename T >
__owl_host std::ostream &	operator<< (std::ostream &o, const vec_t< T, 3 > &v)
template<typename T >
__owl_host std::ostream &	operator<< (std::ostream &o, const vec_t< T, 4 > &v)
	_define_vec_types (int8_t, c)
	_define_vec_types (int16_t, s)
	_define_vec_types (int32_t, i)
	_define_vec_types (int64_t, l)
	_define_vec_types (uint8_t, uc)
	_define_vec_types (uint16_t, us)
	_define_vec_types (uint32_t, ui)
	_define_vec_types (uint64_t, ul)
	_define_vec_types (float, f)
	_define_vec_types (double, d)
__both__ float	saturate (const float &f)
__both__ float	rcp (float f)
__both__ double	rcp (double d)
__both__ int32_t	divRoundUp (int32_t a, int32_t b)
__both__ uint32_t	divRoundUp (uint32_t a, uint32_t b)
__both__ int64_t	divRoundUp (int64_t a, int64_t b)
__both__ uint64_t	divRoundUp (uint64_t a, uint64_t b)
std::string	prettyDouble (const double val)
std::string	prettyNumber (const size_t s)
double	getCurrentTime ()
bool	hasSuffix (const std::string &s, const std::string &suffix)
tbb::task_scheduler_init	tbb_init (tbb::task_scheduler_init::automatic)
template<typename INDEX_T , typename TASK_T >
void	serial_for (INDEX_T nTasks, TASK_T &&taskFunction)
template<typename INDEX_T , typename TASK_T >
void	parallel_for (INDEX_T nTasks, TASK_T &&taskFunction, size_t blockSize=1)
template<typename TASK_T >
void	serial_for_blocked (size_t begin, size_t end, size_t blockSize, TASK_T &&taskFunction)
template<typename TASK_T >
void	parallel_for_blocked (size_t begin, size_t end, size_t blockSize, const TASK_T &taskFunction)

Variables
static struct owl::common::ZeroTy	MAYBE_UNUSED

Typedef Documentation

affine2f

using owl::common::affine2f = typedef AffineSpace2f

affine3f

using owl::common::affine3f = typedef AffineSpace3f

AffineSpace2f

using owl::common::AffineSpace2f = typedef AffineSpaceT<LinearSpace2f>

AffineSpace3f

using owl::common::AffineSpace3f = typedef AffineSpaceT<LinearSpace3f>

AffineSpace3fa

using owl::common::AffineSpace3fa = typedef AffineSpaceT<LinearSpace3fa>

linear2f

using owl::common::linear2f = typedef LinearSpace2f

linear3f

using owl::common::linear3f = typedef LinearSpace3f

LinearSpace2f

using owl::common::LinearSpace2f = typedef LinearSpace2<vec2f>

Shortcuts for common linear spaces.

LinearSpace3f

using owl::common::LinearSpace3f = typedef LinearSpace3<vec3f>

LinearSpace3fa

using owl::common::LinearSpace3fa = typedef LinearSpace3<vec3fa>

OrthonormalSpace3f

using owl::common::OrthonormalSpace3f = typedef AffineSpaceT<Quaternion3f >

Quaternion3d

typedef QuaternionT<double> owl::common::Quaternion3d

Quaternion3f

typedef QuaternionT<float> owl::common::Quaternion3f

default template instantiations

Function Documentation

_define_box_types() [1/5]

owl::common::_define_box_types	(	float	,
		f
	)

_define_box_types() [2/5]

owl::common::_define_box_types	(	int	,
		i
	)

_define_box_types() [3/5]

owl::common::_define_box_types	(	short int	,
		s
	)

_define_box_types() [4/5]

owl::common::_define_box_types	(	unsigned int	,
		ui
	)

_define_box_types() [5/5]

owl::common::_define_box_types	(	unsigned short int	,
		us
	)

_define_float_functor()

owl::common::_define_float_functor

(

rcp

)

_define_op_assign_operator() [1/4]

owl::common::_define_op_assign_operator	(	operator*	,
		*
	)

_define_op_assign_operator() [2/4]

owl::common::_define_op_assign_operator	(	operator+	,
		+
	)

_define_op_assign_operator() [3/4]

owl::common::_define_op_assign_operator	(	operator-	,
		-
	)

_define_op_assign_operator() [4/4]

owl::common::_define_op_assign_operator	(	operator/	,
		/
	)

_define_operator() [1/3]

owl::common::_define_operator

(

+

)

_define_operator() [2/3]

owl::common::_define_operator

(

-

)

_define_operator() [3/3]

owl::common::_define_operator

(

/

)

_define_vec_types() [1/10]

owl::common::_define_vec_types	(	double	,
		d
	)

_define_vec_types() [2/10]

owl::common::_define_vec_types	(	float	,
		f
	)

_define_vec_types() [3/10]

owl::common::_define_vec_types	(	int16_t	,
		s
	)

_define_vec_types() [4/10]

owl::common::_define_vec_types	(	int32_t	,
		i
	)

_define_vec_types() [5/10]

owl::common::_define_vec_types	(	int64_t	,
		l
	)

_define_vec_types() [6/10]

owl::common::_define_vec_types	(	int8_t	,
		c
	)

_define_vec_types() [7/10]

owl::common::_define_vec_types	(	uint16_t	,
		us
	)

_define_vec_types() [8/10]

owl::common::_define_vec_types	(	uint32_t	,
		ui
	)

_define_vec_types() [9/10]

owl::common::_define_vec_types	(	uint64_t	,
		ul
	)

_define_vec_types() [10/10]

owl::common::_define_vec_types	(	uint8_t	,
		uc
	)

abs()

template<typename T >

__both__ T owl::common::abs

(

const QuaternionT< T > &

a

)

all()

template<typename T , int N>

__both__ bool owl::common::all ( const vec_t< T, N > &  a )

inline

all_less_than()

template<typename T , int N>

__both__ bool owl::common::all_less_than ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

any()

template<typename T , int N>

__both__ bool owl::common::any ( const vec_t< T, N > &  a )

inline

any_greater_or_equal()

template<typename T , int N>

__both__ bool owl::common::any_greater_or_equal ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

particularly useful for doing some range testing as in "if (any_greater_or_equal(pixelID,frameBufferSize)" etc

any_greater_than()

template<typename T , int N>

__both__ bool owl::common::any_greater_than ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

any_less_than()

template<typename T , int N>

__both__ bool owl::common::any_less_than ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

area() [1/4]

template<typename T >

__both__ long_type_of<T>::type owl::common::area ( const box_t< vec_t< T, 2 >> &  b )

inline

area() [2/4]

template<typename T >

__both__ long_type_of<T>::type owl::common::area ( const box_t< vec_t< T, 3 >> &  b )

inline

area() [3/4]

template<typename T >

__both__ long_type_of<T>::type owl::common::area ( const vec_t< T, 2 > &  v )

inline

area() [4/4]

template<typename T >

__both__ long_type_of<T>::type owl::common::area ( const vec_t< T, 3 > &  v )

inline

arg_max()

template<typename T , int N>

__both__ int owl::common::arg_max

(

const vec_t< T, N > &

v

)

arg_min()

template<typename T , int N>

__both__ int owl::common::arg_min

(

const vec_t< T, N > &

v

)

build_interval()

template<typename T >

__both__ interval<T> owl::common::build_interval ( const T &  a, const T &  b  )

inline

clamp() [1/3]

template<typename T >

__both__ LinearSpace3<T> owl::common::clamp ( const LinearSpace3< T > &  space )

inline

clamp() [2/3]

template<typename T >

__both__ T owl::common::clamp ( const T &  val, const T &  hi  )

inline

clamp() [3/3]

template<typename T >

__both__ T owl::common::clamp ( const T &  val, const T &  lo, const T &  hi  )

inline

conj()

template<typename T >

__both__ QuaternionT<T> owl::common::conj

(

const QuaternionT< T > &

a

)

cross()

template<typename T >

__both__ vec_t<T,3> owl::common::cross ( const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  )

inline

vector cross product

divRoundUp() [1/4]

__both__ int32_t owl::common::divRoundUp ( int32_t  a, int32_t  b  )

inline

divRoundUp() [2/4]

__both__ int64_t owl::common::divRoundUp ( int64_t  a, int64_t  b  )

inline

divRoundUp() [3/4]

__both__ uint32_t owl::common::divRoundUp ( uint32_t  a, uint32_t  b  )

inline

divRoundUp() [4/4]

__both__ uint64_t owl::common::divRoundUp ( uint64_t  a, uint64_t  b  )

inline

dot()

template<typename T >

__both__ T owl::common::dot ( const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  )

inline

vector cross product

empty_bounds_lower()

template<typename T >

__both__ T owl::common::empty_bounds_lower ( )

inline

lower value of a completely empty range [+inf..-inf]

empty_bounds_upper()

template<typename T >

__both__ T owl::common::empty_bounds_upper ( )

inline

upper value of a completely empty range [+inf..-inf]

empty_range_lower()

template<typename T >

__both__ T owl::common::empty_range_lower ( )

inline

lower value of a completely empty range [+inf..-inf]

empty_range_upper()

template<typename T >

__both__ T owl::common::empty_range_upper ( )

inline

upper value of a completely empty range [+inf..-inf]

eq() [1/3]

template<typename T >

__both__ auto owl::common::eq ( const vec_t< T, 2 > &  a, const vec_t< T, 2 > &  b  ) -> vec_t<decltype(a.x==b.x),2>

inline

eq() [2/3]

template<typename T >

__both__ auto owl::common::eq ( const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  ) -> vec_t<decltype(a.x==b.x),3>

inline

eq() [3/3]

template<typename T >

__both__ auto owl::common::eq ( const vec_t< T, 4 > &  a, const vec_t< T, 4 > &  b  ) -> vec_t<decltype(a.x==b.x),4>

inline

frame() [1/2]

template<typename T >

__both__ LinearSpace3<T> owl::common::frame ( const T &  N )

inline

frame() [2/2]

template<typename T >

__both__ LinearSpace3<T> owl::common::frame ( const T &  N, const T &  dxi  )

inline

ge()

template<typename T , int N>

__both__ auto owl::common::ge ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  ) -> decltype(nt(lt(a,b)))

inline

getCurrentTime()

double owl::common::getCurrentTime ( )

inline

gt()

template<typename T , int N>

__both__ auto owl::common::gt ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  ) -> decltype(lt(b,a))

inline

hasSuffix()

bool owl::common::hasSuffix ( const std::string &  s, const std::string &  suffix  )

inline

infty()

__both__ float owl::common::infty ( )

inline

intersect()

template<typename T >

__both__ interval<T> owl::common::intersect ( const interval< T > &  a, const interval< T > &  b  )

inline

intersection()

template<typename T >

__both__ box_t<T> owl::common::intersection ( const box_t< T > &  a, const box_t< T > &  b  )

inline

le()

template<typename T , int N>

__both__ auto owl::common::le ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  ) -> decltype(nt(lt(b,a)))

inline

length()

template<typename T >

__both__ T owl::common::length ( const vec_t< T, 3 > &  v )

inline

vector cross product

lt() [1/3]

template<typename T >

__both__ auto owl::common::lt ( const vec_t< T, 2 > &  a, const vec_t< T, 2 > &  b  ) -> vec_t<decltype(a.x<b.x),2>

inline

lt() [2/3]

template<typename T >

__both__ auto owl::common::lt ( const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  ) -> vec_t<decltype(a.x<b.x),3>

inline

lt() [3/3]

template<typename T >

__both__ auto owl::common::lt ( const vec_t< T, 4 > &  a, const vec_t< T, 4 > &  b  ) -> vec_t<decltype(a.x<b.x),4>

inline

madd()

template<typename T , int N>

__both__ vec_t<T,3> owl::common::madd	(	const vec_t< T, N > &	a,
		const vec_t< T, N > &	b,
		const vec_t< T, N > &	c
	)

neq()

template<typename T , int N>

__both__ auto owl::common::neq ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  ) -> decltype(nt(eq(a,b)))

inline

normalize() [1/2]

template<typename T >

__both__ QuaternionT<T> owl::common::normalize

(

const QuaternionT< T > &

a

)

normalize() [2/2]

template<typename T >

__both__ vec_t<T,3> owl::common::normalize ( const vec_t< T, 3 > &  v )

inline

vector cross product

nt() [1/3]

template<typename T >

__both__ auto owl::common::nt ( const vec_t< T, 2 > &  a ) -> vec_t<decltype(!a.x),2>

inline

nt() [2/3]

template<typename T >

__both__ auto owl::common::nt ( const vec_t< T, 3 > &  a ) -> vec_t<decltype(!a.x),3>

inline

nt() [3/3]

template<typename T >

__both__ auto owl::common::nt ( const vec_t< T, 4 > &  a ) -> vec_t<decltype(!a.x),4>

inline

open_range_lower()

template<typename T >

__both__ T owl::common::open_range_lower ( )

inline

lower value of a completely open range [-inf..+inf]

open_range_upper()

template<typename T >

__both__ T owl::common::open_range_upper ( )

inline

upper value of a completely open range [-inf..+inf]

operator!=() [1/7]

template<typename L >

bool owl::common::operator!= ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator!=() [2/7]

template<typename T >

__both__ bool owl::common::operator!= ( const box_t< T > &  a, const box_t< T > &  b  )

inline

operator!=() [3/7]

template<typename T >

__both__ bool owl::common::operator!= ( const interval< T > &  a, const interval< T > &  b  )

inline

operator!=() [4/7]

template<typename T >

bool owl::common::operator!= ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator!=() [5/7]

template<typename T >

bool owl::common::operator!= ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator!=() [6/7]

template<typename T >

__both__ bool owl::common::operator!=	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator!=() [7/7]

template<typename T , int N>

__both__ bool owl::common::operator!= ( const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

operator*() [1/13]

template<typename L >

AffineSpaceT<L> owl::common::operator* ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator*() [2/13]

template<typename T >

__both__ interval<T> owl::common::operator* ( const interval< T > &  a, const T &  b  )

inline

operator*() [3/13]

template<typename T >

LinearSpace2<T> owl::common::operator* ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator*() [4/13]

template<typename T >

T owl::common::operator* ( const LinearSpace2< T > &  a, const T &  b  )

inline

operator*() [5/13]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator* ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator*() [6/13]

template<typename T >

T owl::common::operator* ( const LinearSpace3< T > &  a, const T &  b  )

inline

operator*() [7/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator*	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator*() [8/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator*	(	const QuaternionT< T > &	a,
		const T &	b
	)

operator*() [9/13]

template<typename T >

__both__ QuaternionT<T>::Vector owl::common::operator*	(	const QuaternionT< T > &	a,
		const typename QuaternionT< T >::Vector &	b
	)

operator*() [10/13]

template<typename L >

AffineSpaceT<L> owl::common::operator* ( const ScalarT &  a, const AffineSpaceT< L > &  b  )

inline

operator*() [11/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator*	(	const T &	a,
		const QuaternionT< T > &	b
	)

operator*() [12/13]

template<typename T >

LinearSpace2<T> owl::common::operator* ( const typename T::scalar_t &  a, const LinearSpace2< T > &  b  )

inline

operator*() [13/13]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator* ( const typename T::scalar_t &  a, const LinearSpace3< T > &  b  )

inline

operator*=() [1/6]

template<typename L >

AffineSpaceT<L>& owl::common::operator*= ( AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator*=() [2/6]

template<typename L >

AffineSpaceT<L>& owl::common::operator*= ( AffineSpaceT< L > &  a, const ScalarT &  b  )

inline

operator*=() [3/6]

template<typename T >

LinearSpace2<T>& owl::common::operator*= ( LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator*=() [4/6]

template<typename T >

LinearSpace3<T>& owl::common::operator*= ( LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator*=() [5/6]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator*=	(	QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator*=() [6/6]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator*=	(	QuaternionT< T > &	a,
		const T &	b
	)

operator+() [1/12]

template<typename L >

AffineSpaceT<L> owl::common::operator+ ( const AffineSpaceT< L > &  a )

inline

operator+() [2/12]

template<typename L >

AffineSpaceT<L> owl::common::operator+ ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator+() [3/12]

template<typename T >

__both__ LinearSpace2<T> owl::common::operator+ ( const LinearSpace2< T > &  a )

inline

operator+() [4/12]

template<typename T >

LinearSpace2<T> owl::common::operator+ ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator+() [5/12]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator+ ( const LinearSpace3< T > &  a )

inline

operator+() [6/12]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator+ ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator+() [7/12]

template<typename T >

__both__ QuaternionT<T> owl::common::operator+

(

const QuaternionT< T > &

a

)

operator+() [8/12]

template<typename T >

__both__ QuaternionT<T> owl::common::operator+	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator+() [9/12]

template<typename T >

__both__ QuaternionT<T> owl::common::operator+	(	const QuaternionT< T > &	a,
		const T &	b
	)

operator+() [10/12]

template<typename T >

__both__ QuaternionT<T> owl::common::operator+	(	const T &	a,
		const QuaternionT< T > &	b
	)

operator+() [11/12]

template<typename T >

__both__ vec_t<T,2> owl::common::operator+ ( const vec_t< T, 2 > &  v )

inline

operator+() [12/12]

template<typename T >

__both__ vec_t<T,3> owl::common::operator+ ( const vec_t< T, 3 > &  v )

inline

operator+=() [1/2]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator+=	(	QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator+=() [2/2]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator+=	(	QuaternionT< T > &	a,
		const T &	b
	)

operator-() [1/13]

template<typename L >

AffineSpaceT<L> owl::common::operator- ( const AffineSpaceT< L > &  a )

inline

operator-() [2/13]

template<typename L >

AffineSpaceT<L> owl::common::operator- ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator-() [3/13]

template<typename T >

__both__ interval<T> owl::common::operator- ( const interval< T > &  a, const T &  b  )

inline

operator-() [4/13]

template<typename T >

__both__ LinearSpace2<T> owl::common::operator- ( const LinearSpace2< T > &  a )

inline

operator-() [5/13]

template<typename T >

LinearSpace2<T> owl::common::operator- ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator-() [6/13]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator- ( const LinearSpace3< T > &  a )

inline

operator-() [7/13]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator- ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator-() [8/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator-

(

const QuaternionT< T > &

a

)

operator-() [9/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator-	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator-() [10/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator-	(	const QuaternionT< T > &	a,
		const T &	b
	)

operator-() [11/13]

template<typename T >

__both__ QuaternionT<T> owl::common::operator-	(	const T &	a,
		const QuaternionT< T > &	b
	)

operator-() [12/13]

template<typename T >

__both__ vec_t<T,2> owl::common::operator- ( const vec_t< T, 2 > &  v )

inline

operator-() [13/13]

template<typename T >

__both__ vec_t<T,3> owl::common::operator- ( const vec_t< T, 3 > &  v )

inline

operator-=() [1/2]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator-=	(	QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator-=() [2/2]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator-=	(	QuaternionT< T > &	a,
		const T &	b
	)

operator/() [1/9]

template<typename L >

AffineSpaceT<L> owl::common::operator/ ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator/() [2/9]

template<typename L >

AffineSpaceT<L> owl::common::operator/ ( const AffineSpaceT< L > &  a, const ScalarT &  b  )

inline

operator/() [3/9]

template<typename T >

LinearSpace2<T> owl::common::operator/ ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator/() [4/9]

template<typename T >

LinearSpace2<T> owl::common::operator/ ( const LinearSpace2< T > &  a, const typename T::scalar_t &  b  )

inline

operator/() [5/9]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator/ ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator/() [6/9]

template<typename T >

__both__ LinearSpace3<T> owl::common::operator/ ( const LinearSpace3< T > &  a, const typename T::scalar_t &  b  )

inline

operator/() [7/9]

template<typename T >

__both__ QuaternionT<T> owl::common::operator/	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator/() [8/9]

template<typename T >

__both__ QuaternionT<T> owl::common::operator/	(	const QuaternionT< T > &	a,
		const T &	b
	)

operator/() [9/9]

template<typename T >

__both__ QuaternionT<T> owl::common::operator/	(	const T &	a,
		const QuaternionT< T > &	b
	)

operator/=() [1/6]

template<typename L >

AffineSpaceT<L>& owl::common::operator/= ( AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

operator/=() [2/6]

template<typename L >

AffineSpaceT<L>& owl::common::operator/= ( AffineSpaceT< L > &  a, const ScalarT &  b  )

inline

operator/=() [3/6]

template<typename T >

LinearSpace2<T>& owl::common::operator/= ( LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

operator/=() [4/6]

template<typename T >

LinearSpace3<T>& owl::common::operator/= ( LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

operator/=() [5/6]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator/=	(	QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

operator/=() [6/6]

template<typename T >

__both__ QuaternionT<T>& owl::common::operator/=	(	QuaternionT< T > &	a,
		const T &	b
	)

operator<()

template<typename T >

__both__ bool owl::common::operator<	(	const vec_t< T, 3 > &	a,
		const vec_t< T, 3 > &	b
	)

operator<<() [1/10]

template<typename L >

std::ostream& owl::common::operator<< ( std::ostream &  cout, const AffineSpaceT< L > &  m  )

inline

operator<<() [2/10]

template<typename T >

static std::ostream& owl::common::operator<< ( std::ostream &  cout, const LinearSpace2< T > &  m  )

static

Output Operators.

operator<<() [3/10]

template<typename T >

std::ostream& owl::common::operator<< ( std::ostream &  cout, const LinearSpace3< T > &  m  )

inline

Output Operators.

operator<<() [4/10]

template<typename T >

static std::ostream& owl::common::operator<< ( std::ostream &  cout, const QuaternionT< T > &  q  )

static

Output Operators.

operator<<() [5/10]

template<typename T >

__both__ std::ostream& owl::common::operator<< ( std::ostream &  o, const box_t< T > &  b  )

inline

operator<<() [6/10]

template<typename T >

__both__ std::ostream& owl::common::operator<< ( std::ostream &  o, const interval< T > &  b  )

inline

operator<<() [7/10]

template<typename T >

__owl_host std::ostream& owl::common::operator<< ( std::ostream &  o, const vec_t< T, 1 > &  v  )

inline

operator<<() [8/10]

template<typename T >

__owl_host std::ostream& owl::common::operator<< ( std::ostream &  o, const vec_t< T, 2 > &  v  )

inline

operator<<() [9/10]

template<typename T >

__owl_host std::ostream& owl::common::operator<< ( std::ostream &  o, const vec_t< T, 3 > &  v  )

inline

operator<<() [10/10]

template<typename T >

__owl_host std::ostream& owl::common::operator<< ( std::ostream &  o, const vec_t< T, 4 > &  v  )

inline

operator==() [1/9]

template<typename L >

bool owl::common::operator== ( const AffineSpaceT< L > &  a, const AffineSpaceT< L > &  b  )

inline

Comparison Operators.

operator==() [2/9]

template<typename T >

__both__ bool owl::common::operator== ( const box_t< T > &  a, const box_t< T > &  b  )

inline

operator==() [3/9]

template<typename T >

__both__ bool owl::common::operator== ( const interval< T > &  a, const interval< T > &  b  )

inline

operator==() [4/9]

template<typename T >

bool owl::common::operator== ( const LinearSpace2< T > &  a, const LinearSpace2< T > &  b  )

inline

Comparison Operators.

operator==() [5/9]

template<typename T >

bool owl::common::operator== ( const LinearSpace3< T > &  a, const LinearSpace3< T > &  b  )

inline

Comparison Operators.

operator==() [6/9]

template<typename T >

__both__ bool owl::common::operator==	(	const QuaternionT< T > &	a,
		const QuaternionT< T > &	b
	)

Comparison Operators.

operator==() [7/9]

template<typename T >

__both__ bool owl::common::operator== ( const vec_t< T, 2 > &  a, const vec_t< T, 2 > &  b  )

inline

operator==() [8/9]

template<typename T >

__both__ bool owl::common::operator== ( const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  )

inline

operator==() [9/9]

template<typename T >

__both__ bool owl::common::operator== ( const vec_t< T, 4 > &  a, const vec_t< T, 4 > &  b  )

inline

parallel_for()

template<typename INDEX_T , typename TASK_T >

void owl::common::parallel_for ( INDEX_T  nTasks, TASK_T &&  taskFunction, size_t  blockSize = 1  )

inline

parallel_for_blocked()

template<typename TASK_T >

void owl::common::parallel_for_blocked	(	size_t	begin,
		size_t	end,
		size_t	blockSize,
		const TASK_T &	taskFunction
	)

prettyDouble()

std::string owl::common::prettyDouble ( const double  val )

inline

added pretty-print function for large numbers, printing 10000000 as "10M" instead

prettyNumber()

std::string owl::common::prettyNumber ( const size_t  s )

inline

randomColor() [1/3]

template<typename T >

__both__ vec3f owl::common::randomColor ( const T *  ptr )

inline

helper function that creates a semi-random color from an ID

randomColor() [2/3]

__both__ vec3f owl::common::randomColor ( int  i )

inline

helper function that creates a semi-random color from an ID

randomColor() [3/3]

__both__ vec3f owl::common::randomColor ( size_t  idx )

inline

helper function that creates a semi-random color from an ID

rcp() [1/6]

template<typename L >

AffineSpaceT<L> owl::common::rcp ( const AffineSpaceT< L > &  a )

inline

rcp() [2/6]

template<typename T >

__both__ LinearSpace2<T> owl::common::rcp ( const LinearSpace2< T > &  a )

inline

rcp() [3/6]

template<typename T >

__both__ LinearSpace3<T> owl::common::rcp ( const LinearSpace3< T > &  a )

inline

rcp() [4/6]

template<typename T >

__both__ QuaternionT<T> owl::common::rcp

(

const QuaternionT< T > &

a

)

rcp() [5/6]

__both__ double owl::common::rcp ( double  d )

inline

rcp() [6/6]

__both__ float owl::common::rcp ( float  f )

inline

reduce_max() [1/3]

template<typename T >

__both__ T owl::common::reduce_max

(

const vec_t< T, 2 > &

v

)

reduce_max() [2/3]

template<typename T >

__both__ T owl::common::reduce_max

(

const vec_t< T, 3 > &

v

)

reduce_max() [3/3]

template<typename T >

__both__ T owl::common::reduce_max

(

const vec_t< T, 4 > &

v

)

reduce_min() [1/4]

template<typename T >

__both__ T owl::common::reduce_min

(

const vec_t< T, 1 > &

v

)

reduce_min() [2/4]

template<typename T >

__both__ T owl::common::reduce_min

(

const vec_t< T, 2 > &

v

)

reduce_min() [3/4]

template<typename T >

__both__ T owl::common::reduce_min

(

const vec_t< T, 3 > &

v

)

reduce_min() [4/4]

template<typename T >

__both__ T owl::common::reduce_min

(

const vec_t< T, 4 > &

v

)

rotate() [1/2]

__both__ float owl::common::rotate ( const float  a, const float  b  )

inline

perform 'rotation' of float a by amount b. Both a and b must be in 0,1 range, the result will be (a+1) clamped to that same range (ie, it is the value a shifted by the amount b to the right, and re-entering the [0,1) range on the left if it "rotates" out on the right

rotate() [2/2]

__both__ vec2f owl::common::rotate ( const vec2f  a, const vec2f  b  )

inline

perform 'rotation' of float a by amount b. Both a and b must be in 0,1 range, the result will be (a+1) clamped to that same range (ie, it is the value a shifted by the amount b to the right, and re-entering the [0,1) range on the left if it "rotates" out on the right

saturate()

__both__ float owl::common::saturate ( const float &  f )

inline

select() [1/4]

template<typename T >

__both__ vec_t<T,2> owl::common::select ( const vec_t< bool, 2 > &  mask, const vec_t< T, 2 > &  a, const vec_t< T, 2 > &  b  )

inline

select() [2/4]

template<typename T >

__both__ vec_t<T,3> owl::common::select ( const vec_t< bool, 3 > &  mask, const vec_t< T, 3 > &  a, const vec_t< T, 3 > &  b  )

inline

select() [3/4]

template<typename T >

__both__ vec_t<T,4> owl::common::select ( const vec_t< bool, 4 > &  mask, const vec_t< T, 4 > &  a, const vec_t< T, 4 > &  b  )

inline

select() [4/4]

template<typename T , int N>

__both__ vec_t<T,N> owl::common::select ( const vec_t< bool, N > &  mask, const vec_t< T, N > &  a, const vec_t< T, N > &  b  )

inline

serial_for()

template<typename INDEX_T , typename TASK_T >

void owl::common::serial_for ( INDEX_T  nTasks, TASK_T &&  taskFunction  )

inline

serial_for_blocked()

template<typename TASK_T >

void owl::common::serial_for_blocked	(	size_t	begin,
		size_t	end,
		size_t	blockSize,
		TASK_T &&	taskFunction
	)

sqrt() [1/4]

__both__ float owl::common::sqrt ( const float  v )

inline

sqrt() [2/4]

__both__ vec2f owl::common::sqrt ( const vec2f  v )

inline

sqrt() [3/4]

__both__ vec3f owl::common::sqrt ( const vec3f  v )

inline

sqrt() [4/4]

__both__ vec4f owl::common::sqrt ( const vec4f  v )

inline

tbb_init()

tbb::task_scheduler_init owl::common::tbb_init

(

tbb::task_scheduler_init::automatic

)

volume() [1/3]

template<typename T >

__both__ long_type_of<T>::type owl::common::volume ( const box_t< vec_t< T, 3 >> &  b )

inline

volume() [2/3]

template<typename T >

__both__ long_type_of<T>::type owl::common::volume ( const vec_t< T, 3 > &  v )

inline

volume() [3/3]

template<typename T >

__both__ long_type_of<T>::type owl::common::volume ( const vec_t< T, 4 > &  v )

inline

xfmBounds()

__both__ box3f owl::common::xfmBounds ( const affine3f &  xfm, const box3f &  box  )

inline

xfmNormal() [1/3]

template<typename L >

__both__ const VectorT owl::common::xfmNormal ( const AffineSpaceT< L > &  m, const VectorT &  n  )

inline

xfmNormal() [2/3]

template<typename T >

__both__ T owl::common::xfmNormal ( const LinearSpace3< T > &  s, const T &  a  )

inline

xfmNormal() [3/3]

template<typename T >

__both__ QuaternionT<T>::Vector owl::common::xfmNormal	(	const QuaternionT< T > &	a,
		const typename QuaternionT< T >::Vector &	b
	)

xfmPoint() [1/3]

template<typename L >

__both__ const VectorT owl::common::xfmPoint ( const AffineSpaceT< L > &  m, const VectorT &  p  )

inline

xfmPoint() [2/3]

template<typename T >

__both__ T owl::common::xfmPoint ( const LinearSpace3< T > &  s, const T &  a  )

inline

xfmPoint() [3/3]

template<typename T >

__both__ QuaternionT<T>::Vector owl::common::xfmPoint	(	const QuaternionT< T > &	a,
		const typename QuaternionT< T >::Vector &	b
	)

xfmQuaternion()

template<typename T >

__both__ QuaternionT<T>::Vector owl::common::xfmQuaternion	(	const QuaternionT< T > &	a,
		const typename QuaternionT< T >::Vector &	b
	)

xfmVector() [1/2]

template<typename L >

__both__ const VectorT owl::common::xfmVector ( const AffineSpaceT< L > &  m, const VectorT &  v  )

inline

xfmVector() [2/2]

template<typename T >

__both__ T owl::common::xfmVector ( const LinearSpace3< T > &  s, const T &  a  )

inline

Variable Documentation

MAYBE_UNUSED

static struct owl::common::UlpTy owl::common::MAYBE_UNUSED

static