Math Library

Detailed Description

Classes
class	UInteger< N >
class	UInteger< SIZEOF(UIntegerBase) *8 >
class	LinearCongruentialRandom< FLOAT >
class	PseudoRandom< FLOAT >
struct	SqrMat3< V >
struct	Mat3< V >
struct	SqrMat2< V >
struct	Mat2< V >
struct	SqrMat4< V >
class	Range< T >
struct	IsZeroInitialized< Range< T > >
class	TimeValue
class	Hours
class	Minutes
class	Seconds
class	Milliseconds
class	Microseconds
class	Nanoseconds
class	LIMIT< T >
class	LIMIT< Bool >
class	LIMIT< Int64 >
class	LIMIT< UInt64 >
class	LIMIT< Int32 >
class	LIMIT< UInt32 >
class	LIMIT< Int16 >
class	LIMIT< UInt16 >
class	LIMIT< Char >
class	LIMIT< UChar >
class	LIMIT< Float32 >
class	LIMIT< Float64 >
struct	Sum< VALUES >
struct	Sum< X, Y... >
struct	Sum<>
struct	Or< T, VALUES >
struct	Or< T, X, Y... >
struct	Or< T >
class	Complex< T >
class	MatrixNxM< TYPE >
class	MatrixNxMInterface
class	ConstMatrixNxMInterface
class	NoiseInterface
class	RenderNoiseInterface
class	PolynomSolver< T >
class	Quaternion< ValueType >
class	FormulaParseErrorInterface
class	FormulaExecutionErrorInterface
class	FormulaNumberErrorInterface
class	FormulaParserCacheInterface
class	FormulaParserInterface

Macros
#define	MATH_VECTOR
#define	MATH_COLOR
#define	MATH_MATRIX
#define	MATH_SQUAREMATRIX
#define	MATH_VECTOR2
#define	MATH_MATRIX2
#define	MATH_SQUAREMATRIX2
#define	SIZEOF(...)
#define	COORDINATESYSTEM_LEFT_HANDED

Typedefs
using	UIntegerBase = UInt32
using	NativeUInteger = UInteger< SIZEOF(Int) *8 >
using	TransformColorDelegate32 = Delegate< Color32(const Color32 &)>
using	TransformColorDelegate64 = Delegate< Color64(const Color64 &)>
using	TransformValueDelegate32 = Delegate< Float32(const Float32 &)>
using	TransformValueDelegate64 = Delegate< Float64(const Float64 &)>
using	TransformColorDelegate = TransformColorDelegate64
using	TransformValueDelegate = TransformValueDelegate64
using	SquareMatrix32 = SqrMat3< Vector32 >
using	SquareMatrix64 = SqrMat3< Vector64 >
using	SquareMatrix = SqrMat3< Vector >
using	Matrix32 = Mat3< Vector32 >
using	Matrix64 = Mat3< Vector64 >
using	Matrix = Mat3< Vector >
using	SquareMatrix2d32 = SqrMat2< Vector2d32 >
using	SquareMatrix2d64 = SqrMat2< Vector2d64 >
using	SquareMatrix2d = SqrMat2< Vector2d >
using	Matrix2d32 = Mat2< Vector2d32 >
using	Matrix2d64 = Mat2< Vector2d64 >
using	Matrix2d = Mat2< Vector2d >
using	SquareMatrix4d32 = SqrMat4< Vector4d32 >
using	SquareMatrix4d64 = SqrMat4< Vector4d64 >
using	SquareMatrix4d = SqrMat4< Vector4d >
using	Frame = Range< Vector2d >
using	IntFrame = Range< IntVector2d >
using	Vector32 = Vec3< Float32, 1 >
using	Vector64 = Vec3< Float64, 1 >
using	Vector = Vec3< Float, 1 >
using	IntVector32 = Vec3< Int32, 1 >
using	UIntVector32 = Vec3< UInt32, 1 >
using	IntVector64 = Vec3< Int64, 1 >
using	IntVector = Vec3< Int, 1 >
using	Color32 = Col3< Float32, 1 >
using	Color64 = Col3< Float64, 1 >
using	Color = Col3< Float, 1 >
using	GenericVector = Vec3< GenericArithmetic, 1 >
using	Vector2d32 = Vec2< Float32, 1 >
using	Vector2d64 = Vec2< Float64, 1 >
using	Vector2d = Vec2< Float, 1 >
using	IntVector2d32 = Vec2< Int32, 1 >
using	UIntVector2d32 = Vec2< UInt32, 1 >
using	IntVector2d64 = Vec2< Int64, 1 >
using	UIntVector2d64 = Vec2< UInt64, 1 >
using	IntVector2d = Vec2< Int, 1 >
using	GenericVector2d = Vec2< GenericArithmetic, 1 >
using	Vector4d32 = Vec4< Float32, 1 >
using	Vector4d64 = Vec4< Float64, 1 >
using	Vector4d = Vec4< Float, 1 >
using	IntVector4d32 = Vec4< Int32, 1 >
using	IntVector4d64 = Vec4< Int64, 1 >
using	IntVector4d = Vec4< Int, 1 >
using	ColorA32 = Col4< Float32, 1 >
using	ColorA64 = Col4< Float64, 1 >
using	ColorA = Col4< Float, 1 >
using	GenericVector4d = Vec4< GenericArithmetic, 1 >
using	FbmTableRef = OpaqueRef
using	FbmTablePtr = OpaqueBase const *

Enumerations
enum class	ROTATIONORDER {   ZXYGLOBAL ,   ZYXGLOBAL ,   YXZGLOBAL ,   YZXGLOBAL ,   XZYGLOBAL ,   XYZGLOBAL ,   YXZLOCAL ,   XYZLOCAL ,   ZXYLOCAL ,   XZYLOCAL ,   YZXLOCAL ,   ZYXLOCAL }
enum class	TIMEFORMAT {   SECONDS ,   FRAMES ,   SMPTE ,   SMPTE_DROPFRAMES }
enum class	METRICUNIT {   NONE ,   KM ,   M ,   CM ,   MM ,   UM ,   NM ,   MILE ,   YARD ,   FEET ,   INCH }
enum class	ANGLEUNIT {   DEGREE ,   RADIANS }

Functions
Int	Ctz32 (Int32 x)
Int	Ctz64 (Int64 x)
Int	Clz32 (Int32 x)
Int	Clz64 (Int64 x)
template<typename T >
Int	Clz (T x)
template<typename T >
Int	Ctz (T x)
Bool	CompareFloat (Float32 a, Float32 b, Float32 epsilon=1e-10f)
Bool	CompareFloat (Float64 a, Float64 b, Float64 epsilon=1e-10)
Bool	CompareFloatTolerant (Float32 a, Float32 b)
Bool	CompareFloatTolerant (Float64 a, Float64 b)
Bool	CheckFloat (Float32 r)
Bool	CheckFloat (Float64 r)
Float32	RepairFloat (Float32 r)
Float64	RepairFloat (Float64 r)
Float32	BoxStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
Float64	BoxStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
Float32	SmoothStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
Float64	SmoothStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
Float32	Modulo (Float32 a, Float32 b)
Float64	Modulo (Float64 a, Float64 b)
Int32	Modulo (Int32 a, Int32 b)
Int64	Modulo (Int64 a, Int64 b)
Float32	Bias (Float32 b, Float32 x)
Float64	Bias (Float64 b, Float64 x)
Float32	Truncate (Float32 x)
Float64	Truncate (Float64 x)
Bool	LessThan (UInt a1, UInt a2, UInt b1, UInt b2)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	VectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	CheckedVectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
template<typename FLOAT >
Mat3< Vec3< FLOAT > >	VectorToMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
template<typename FLOAT >
Mat3< Vec3< FLOAT > >	GetTranslationMatrix (const Vec3< FLOAT > &translation)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetScaleMatrix (const Vec3< FLOAT > &scale)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetRotationMatrixX (FLOAT angle)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetRotationMatrixY (FLOAT angle)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetRotationMatrixZ (FLOAT angle)
template<typename FLOAT >
Mat2< Vec2< FLOAT > >	GetTranslationMatrix (const Vec2< FLOAT > &translation)
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > >	GetScaleMatrix (const Vec2< FLOAT > &scale)
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > >	GetRotationMatrix (FLOAT angle)
enum maxon::ROTATIONORDER	MAXON_ENUM_LIST (ROTATIONORDER)
template<typename FLOAT >
Vec3< FLOAT >	GetRotationAngles (const SqrMat3< Vec3< FLOAT >> &m, ROTATIONORDER rotationOrder)
template<typename FLOAT >
Vec3< FLOAT >	GetRotationAngles (const Vec3< FLOAT > &direction, ROTATIONORDER rotationOrder)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetRotationMatrix (const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
template<typename FLOAT >
Mat3< Vec3< FLOAT > >	GetPSRMatrix (const Vec3< FLOAT > &position, const Vec3< FLOAT > &scale, const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
template<typename FLOAT >
Vec3< FLOAT >	GetOptimumRotation (const Vec3< FLOAT > &oldRotation, const Vec3< FLOAT > &newRotation, ROTATIONORDER rotationOrder)
template<typename FLOAT >
Vec3< FLOAT >	GetClosestPointOnLine (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
template<typename FLOAT >
FLOAT	GetPointLineDistance (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
template<typename FLOAT >
Vec3< FLOAT >	ReflectRay (const Vec3< FLOAT > &direction, const Vec3< FLOAT > &normal)
template<typename FLOAT >
Vec3< FLOAT >	RGBToHSV (const Col3< FLOAT > &color)
template<typename FLOAT >
Col3< FLOAT >	HSVToRGB (const Vec3< FLOAT > &color)
template<typename FLOAT >
Vec3< FLOAT >	RGBToHSL (const Col3< FLOAT > &color)
template<typename FLOAT >
Col3< FLOAT >	HSLToRGB (const Vec3< FLOAT > &color)
template<typename FLOAT >
void	GetRotationAxis (const SqrMat3< Vec3< FLOAT >> &m, Vec3< FLOAT > &axisVector, FLOAT &axisRotation)
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > >	GetRotationMatrixFromAxis (const Vec3< FLOAT > &axisVector, FLOAT axisRotation)
template<typename MATRIXTYPE >
Bool	IsMatrixRectangular (const MATRIXTYPE &m, typename MATRIXTYPE::ValueType epsilon=1e-10_f)
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType	GetSum (ITERABLETYPE &&array)
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType	GetAverage (ITERABLETYPE &&array)
template<typename V , typename V2 >
Mat3< typename MultiplicativePromotion< V, typename V2::ValueType >::type >	operator* (const SqrMat3< V > &m, const Mat3< V2 > &m2)
template<typename V , typename V2 >
Mat2< typename MultiplicativePromotion< V, typename V2::ValueType >::type >	operator* (const SqrMat2< V > &m, const Mat2< V2 > &m2)
template<typename T >
T	PrivateRangeValueTypeHelper (OverloadRank0)
template<typename T >
T::ValueType	PrivateRangeValueTypeHelper (OverloadRank1)
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Range< T > **, OverloadRank0)
enum maxon::TIMEFORMAT	MAXON_ENUM_LIST (TIMEFORMAT)
const TimeValue	operator""_h (long double value)
const TimeValue	operator""_min (long double value)
const TimeValue	operator""_sec (long double value)
const TimeValue	operator""_ms (long double value)
const TimeValue	operator""_us (long double value)
const TimeValue	operator""_ns (long double value)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Clamp01 (Float32 a)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Clamp01 (Float64 a)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Sin (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Sin (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Cos (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Cos (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Tan (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Tan (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	ATan (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	ATan (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	ATan2 (Float32 valY, Float32 valX)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	ATan2 (Float64 valY, Float64 valX)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Exp (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Exp (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Exp2 (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Exp2 (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Ln (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Ln (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Log10 (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Log10 (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Log2 (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Log2 (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Sqrt (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Sqrt (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Floor (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Floor (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Ceil (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Ceil (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Round (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Round (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Pow (Float32 v1, Float32 v2)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Pow (Float64 v1, Float64 v2)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Sinh (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Sinh (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Cosh (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Cosh (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Tanh (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Tanh (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	FMod (Float32 v1, Float32 v2)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	FMod (Float64 v1, Float64 v2)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Abs (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Abs (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Inverse (Float32 f)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Inverse (Float64 f)
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X	Abs (X f)
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X	Min (X a, X b)
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X	Max (X a, X b)
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE void	Swap (X &a, X &b)
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X	ClampValue (X value, X lowerLimit, X upperLimit)
template<typename X , typename Y >
MAXON_ATTRIBUTE_FORCE_INLINE X	Blend (const X &value1, const X &value2, Y blendValue)
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X	Sqr (X a, X b)
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X	Sqr (X a)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Gamma (Float32 value, Float32 gamma)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Gamma (Float64 value, Float64 gamma)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Si (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Si (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	Sinc (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	Sinc (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	ASin (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	ASin (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	ACos (Float32 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	ACos (Float64 val)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	DegToRad (Float32 r)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	DegToRad (Float64 r)
MAXON_ATTRIBUTE_FORCE_INLINE Float32	RadToDeg (Float32 r)
MAXON_ATTRIBUTE_FORCE_INLINE Float64	RadToDeg (Float64 r)
MAXON_ATTRIBUTE_FORCE_INLINE void	SinCos (Float32 val, Float32 &sn, Float32 &cs)
MAXON_ATTRIBUTE_FORCE_INLINE void	SinCos (Float64 val, Float64 &sn, Float64 &cs)
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST	SafeConvert (Float64 src)
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST	SafeConvert (Float32 src)
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void	SetMax (T &a, const typename SFINAEHelper< T >::type &b)
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void	SetMin (T &a, const typename SFINAEHelper< T >::type &b)
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE Int	Sign (X f)
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T	Mod (T a, T b)
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool	IsPowerOfTwo (UInt32 x)
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool	IsPowerOfTwo (UInt64 x)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	IntToColor (UInt r, UInt g, UInt b, UInt a)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	IntToColor (UInt r, UInt g, UInt b)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	FloatToColor (Float r, Float g, Float b, Float a)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	FloatToColor (Float r, Float g, Float b)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	ColorSetAlpha (const ColorA &col, Float alpha)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	ColorMultiplyAlpha (const ColorA &col, Float alpha)
MAXON_ATTRIBUTE_FORCE_INLINE Color	BlendColors (const Color &col1, const Color &col2, Float alpha)
MAXON_ATTRIBUTE_FORCE_INLINE ColorA	BlendColors (const ColorA &col1, const ColorA &col2, Float alpha)
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE	BlendColor (const COLORTYPE &col1, const COLORTYPE &col2, const typename COLORTYPE::ValueType blendValue)
MAXON_ATTRIBUTE_FORCE_INLINE Float	GetPerceivedBrightness (const ColorA &color)
MAXON_ATTRIBUTE_FORCE_INLINE Bool	IsColorPerceivedAsDark (const ColorA &color)
	MAXON_REGISTRY (Class< RenderNoiseRef >, RenderNoiseClasses, "net.maxon.render.registry.rendernoiseclasses")
enum maxon::METRICUNIT	MAXON_ENUM_LIST (METRICUNIT)
enum maxon::ANGLEUNIT	MAXON_ENUM_LIST (ANGLEUNIT)

Variables
const Float64	FRAMERATE_DEFAULT
const Float64	FRAMERATE_NTSC
const Float64	FRAMERATE_PAL
const Float64	FRAMERATE_FILM
const Float64	FRAMERATE_FILM_NTSC
static const TimeValue	TIMEVALUE_INFINITE
static const TimeValue	TIMEVALUE_INVALID
static constexpr Float32	MINVALUE_FLOAT32
static constexpr Float32	MAXVALUE_FLOAT32
static constexpr Float64	MINVALUE_FLOAT64
static constexpr Float64	MAXVALUE_FLOAT64
static constexpr Float32	MINVALUE_INT32_FLOAT32
static constexpr Float32	MAXVALUE_INT32_FLOAT32
static constexpr Float64	MINVALUE_INT64_FLOAT64
static constexpr Float64	MAXVALUE_INT64_FLOAT64
static constexpr Float32	MINRANGE_FLOAT32
static constexpr Float32	MAXRANGE_FLOAT32
static constexpr Float64	MINRANGE_FLOAT64
static constexpr Float64	MAXRANGE_FLOAT64
static constexpr Float	MINVALUE_FLOAT
static constexpr Float	MAXVALUE_FLOAT
static constexpr Float	MINRANGE_FLOAT
static constexpr Float	MAXRANGE_FLOAT
static constexpr Int	NOTOK
static constexpr Float64	PI
static constexpr Float64	PI_INV
static constexpr Float64	PI2
static constexpr Float64	PI2_INV
static constexpr Float64	PI05
static constexpr Float64	PI05_INV
static constexpr Float64	SQRT2
static constexpr Float64	SQRT_PI2
static constexpr Float64	SQRT2_INV
static constexpr Float64	SQRT3
static constexpr Float64	LOG2
static const Float	PERCEIVED_BRIGHTNESS_FACTOR_RED
static const Float	PERCEIVED_BRIGHTNESS_FACTOR_GREEN
static const Float	PERCEIVED_BRIGHTNESS_FACTOR_BLUE
static const Float	PERCEIVED_BRIGHTNESS_CUTOFF

Macro Definition Documentation

MATH_VECTOR

#define MATH_VECTOR

MATH_COLOR

#define MATH_COLOR

MATH_MATRIX

#define MATH_MATRIX

MATH_SQUAREMATRIX

#define MATH_SQUAREMATRIX

MATH_VECTOR2

#define MATH_VECTOR2

MATH_MATRIX2

#define MATH_MATRIX2

MATH_SQUAREMATRIX2

#define MATH_SQUAREMATRIX2

SIZEOF

#define SIZEOF

(

...

)

Calculates the size of a datatype or element.

COORDINATESYSTEM_LEFT_HANDED

#define COORDINATESYSTEM_LEFT_HANDED

Major control to define the used coordinate system. So far C4D runs only with left-handed coordinates.

Typedef Documentation

UIntegerBase

using UIntegerBase = UInt32

NativeUInteger

using NativeUInteger = UInteger<SIZEOF(Int) * 8>

TransformColorDelegate32

using TransformColorDelegate32 = Delegate<Color32(const Color32&)>

TransformColorDelegate64

using TransformColorDelegate64 = Delegate<Color64(const Color64&)>

TransformValueDelegate32

using TransformValueDelegate32 = Delegate<Float32(const Float32&)>

TransformValueDelegate64

using TransformValueDelegate64 = Delegate<Float64(const Float64&)>

TransformColorDelegate

using TransformColorDelegate = TransformColorDelegate64

TransformValueDelegate

using TransformValueDelegate = TransformValueDelegate64

SquareMatrix32

using SquareMatrix32 = SqrMat3<Vector32>

Single-precision 3×3 matrix.

SquareMatrix64

using SquareMatrix64 = SqrMat3<Vector64>

Double-precision 3×3 matrix.

SquareMatrix

using SquareMatrix = SqrMat3<Vector>

3×3 matrix with the precision of Float.

Matrix32

using Matrix32 = Mat3<Vector32>

Single-Precision Matrix.

The matrix has a dimension of 4×4 and consists of four rows and four columns. The first row is always "1, 0, 0, 0" and not stored in the class, which means that there are 12 actual numbers used. These numbers are grouped into four vectors, one for the remaining numbers in each column. The four vectors are called off, v1, v2 and v3, together these four vectors can be used to represent the coordinate system. A coordinate system consists of three axes, one for each coordinate (X, Y and Z). The system also has a base position, from which the three axes originate. This base position is stored in off, and the three axis vectors are stored in v1, v2 and v3 respectively. For a rectangular, normalized matrix v3 equals the cross product of v1 and v2 (v1v2). C4D by default uses a left-handed coordinate system (see define COORDINATESYSTEM_LEFT_HANDED).

Matrix64

using Matrix64 = Mat3<Vector64>

Double-Precision Matrix.

The matrix has a dimension of 4×4 and consists of four rows and four columns. The first row is always "1, 0, 0, 0" and not stored in the class, which means that there are 12 actual numbers used. These numbers are grouped into four vectors, one for the remaining numbers in each column. The four vectors are called off, v1, v2 and v3, together these four vectors can be used to represent the coordinate system. A coordinate system consists of three axes, one for each coordinate (X, Y and Z). The system also has a base position, from which the three axes originate. This base position is stored in off, and the three axis vectors are stored in v1, v2 and v3 respectively. For a rectangular, normalized matrix v3 equals the cross product of v1 and v2 (v1v2). C4D by default uses a left-handed coordinate system (see define COORDINATESYSTEM_LEFT_HANDED).

Matrix

using Matrix = Mat3<Vector>

Matrix with the precision of Float.

The matrix has a dimension of 4×4 and consists of four rows and four columns. The first row is always "1, 0, 0, 0" and not stored in the class, which means that there are 12 actual numbers used. These numbers are grouped into four vectors, one for the remaining numbers in each column. The four vectors are called off, v1, v2 and v3, together these four vectors can be used to represent the coordinate system. A coordinate system consists of three axes, one for each coordinate (X, Y and Z). The system also has a base position, from which the three axes originate. This base position is stored in off, and the three axis vectors are stored in v1, v2 and v3 respectively. For a rectangular, normalized matrix v3 equals the cross product of v1 and v2 (v1v2). C4D by default uses a left-handed coordinate system (see define COORDINATESYSTEM_LEFT_HANDED).

SquareMatrix2d32

using SquareMatrix2d32 = SqrMat2<Vector2d32>

Single-precision 2×2 matrix.

SquareMatrix2d64

using SquareMatrix2d64 = SqrMat2<Vector2d64>

Double-precision 2×2 matrix.

SquareMatrix2d

using SquareMatrix2d = SqrMat2<Vector2d>

2×2 matrix with the precision of Float.

Matrix2d32

using Matrix2d32 = Mat2<Vector2d32>

Single-Precision Matrix. The matrix has a dimension of 3×3 and consists of three rows and three columns. The first row is always "1, 0, 0" and not stored in the class, which means that there are 6 actual numbers used. These numbers are grouped into three vectors, one for the remaining numbers in each column. The three vectors are called off, v1 and v2, together these three vectors can be used to represent the coordinate system. A coordinate system consists of two axes, one for each coordinate (X and Y). The system also has a base position, from which the two axes originate. This base position is stored in off, and the two axis vectors are stored in v1 and v2 respectively

Matrix2d64

using Matrix2d64 = Mat2<Vector2d64>

Double-Precision Matrix. The matrix has a dimension of 3×3 and consists of three rows and three columns. The first row is always "1, 0, 0" and not stored in the class, which means that there are 6 actual numbers used. These numbers are grouped into three vectors, one for the remaining numbers in each column. The three vectors are called off, v1 and v2, together these three vectors can be used to represent the coordinate system. A coordinate system consists of two axes, one for each coordinate (X and Y). The system also has a base position, from which the two axes originate. This base position is stored in off, and the two axis vectors are stored in v1 and v2 respectively

Matrix2d

using Matrix2d = Mat2<Vector2d>

Matrix with the precision of Float. The matrix has a dimension of 3×3 and consists of three rows and three columns. The first row is always "1, 0, 0" and not stored in the class, which means that there are 6 actual numbers used. These numbers are grouped into three vectors, one for the remaining numbers in each column. The three vectors are called off, v1 and v2, together these three vectors can be used to represent the coordinate system. A coordinate system consists of two axes, one for each coordinate (X and Y). The system also has a base position, from which the two axes originate. This base position is stored in off, and the two axis vectors are stored in v1 and v2 respectively

SquareMatrix4d32

using SquareMatrix4d32 = SqrMat4<Vector4d32>

Single-Precision Matrix.

SquareMatrix4d64

using SquareMatrix4d64 = SqrMat4<Vector4d64>

Double-Precision Matrix.

SquareMatrix4d

using SquareMatrix4d = SqrMat4<Vector4d>

Matrix with the precision of Float.

Frame

using Frame = Range<Vector2d>

Range with the precision of Float.

IntFrame

using IntFrame = Range<IntVector2d>

Range with the precision of Int.

Vector32

using Vector32 = Vec3<Float32, 1>

Single-Precision Vector. A vector contains three components X, Y and Z

Vector64

using Vector64 = Vec3<Float64, 1>

Double-Precision Vector. A vector contains three components X, Y and Z

Vector

using Vector = Vec3<Float, 1>

Vector with the precision of Float. A vector contains three components X, Y and Z

IntVector32

using IntVector32 = Vec3<Int32, 1>

32-bit Int Vector. A vector contains three components X, Y and Z

UIntVector32

using UIntVector32 = Vec3<UInt32, 1>

32-bit UInt Vector. A vector contains three components X, Y and Z

IntVector64

using IntVector64 = Vec3<Int64, 1>

64-bit Int Vector. A vector contains three components X, Y and Z

IntVector

using IntVector = Vec3<Int, 1>

Vector of Int. A vector contains three components X, Y and Z

Color32

using Color32 = Col3<Float32, 1>

Single-Precision Color. A color contains three components R, G and B

Color64

using Color64 = Col3<Float64, 1>

Double-Precision Color. A color contains three components R, G and B

Color

using Color = Col3<Float, 1>

Color with the precision of Float. A color contains three components R, G and B

GenericVector

using GenericVector = Vec3<GenericArithmetic, 1>

Generic arithmetic vector type.

Vector2d32

using Vector2d32 = Vec2<Float32, 1>

Single-Precision Vector. A vector contains two components X and Y

Vector2d64

using Vector2d64 = Vec2<Float64, 1>

Double-Precision Vector. A vector contains two components X and Y

Vector2d

using Vector2d = Vec2<Float, 1>

Vector with the precision of Float. A vector contains two components X and Y

IntVector2d32

using IntVector2d32 = Vec2<Int32, 1>

32-bit Int Vector. A vector contains three components X, Y and Z

UIntVector2d32

using UIntVector2d32 = Vec2<UInt32, 1>

32-bit UInt Vector. A vector contains three components X, Y and Z

IntVector2d64

using IntVector2d64 = Vec2<Int64, 1>

64-bit Int Vector. A vector contains three components X, Y and Z

UIntVector2d64

using UIntVector2d64 = Vec2<UInt64, 1>

64-bit UInt Vector. A vector contains three components X, Y and Z

IntVector2d

using IntVector2d = Vec2<Int, 1>

Vector of Int. A vector contains three components X, Y and Z

GenericVector2d

using GenericVector2d = Vec2<GenericArithmetic, 1>

Generic arithmetic vector type.

Vector4d32

using Vector4d32 = Vec4<Float32, 1>

Single-Precision Vector. A vector contains three components X, Y, Z and W

Vector4d64

using Vector4d64 = Vec4<Float64, 1>

Double-Precision Vector. A vector contains three components X, Y, Z and W

Vector4d

using Vector4d = Vec4<Float, 1>

Vector with the precision of Float. A vector contains four components X, Y, Z and W

IntVector4d32

using IntVector4d32 = Vec4<Int32, 1>

32-bit Int Vector. A vector contains four components X, Y, Z and W

IntVector4d64

using IntVector4d64 = Vec4<Int64, 1>

64-bit Int Vector. A vector contains four components X, Y, Z and W

IntVector4d

using IntVector4d = Vec4<Int, 1>

Vector of Int. A vector contains four components X, Y, Z and W

ColorA32

using ColorA32 = Col4<Float32, 1>

Single-Precision Color with Alpha. A color contains three components R, G, B and A

ColorA64

using ColorA64 = Col4<Float64, 1>

Double-Precision Color with Alpha. A color contains three components R, G, B and A

ColorA

using ColorA = Col4<Float, 1>

Color with Alpha with the precision of Float. A color contains four components R, G, B and A

GenericVector4d

using GenericVector4d = Vec4<GenericArithmetic, 1>

Generic arithmetic vector type.

FbmTableRef

using FbmTableRef = OpaqueRef

FbmTablePtr

using FbmTablePtr = OpaqueBase const*

Enumeration Type Documentation

ROTATIONORDER

enum ROTATIONORDER

strong

Defines in which order rotations are executed. Global means that the rotation will always be done around the world axes. Local means that the rotation will always be done around an already rotated axis of an axis system. For each global rotation there is a local counterpart and vice versa. All rotations are done so that a positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

Enumerator
ZXYGLOBAL
ZYXGLOBAL
YXZGLOBAL
YZXGLOBAL
XZYGLOBAL
XYZGLOBAL
YXZLOCAL
XYZLOCAL
ZXYLOCAL
XZYLOCAL
YZXLOCAL
ZYXLOCAL

TIMEFORMAT

enum TIMEFORMAT

strong

format in which time values are displayed

Enumerator
SECONDS	display time in seconds
FRAMES	display time as a frame number
SMPTE	display time as SMPTE time code
SMPTE_DROPFRAMES	display clock time as SMPTE time code (see here for information on drop frames)

METRICUNIT

enum METRICUNIT

strong

Metric unit.

Enumerator
NONE	No metric unit.
KM	kilometer
M	meter
CM	centimeter
MM	millimeter
UM	micrometer
NM	nanometer
MILE	mile (1.609344 km)
YARD	yard (91.44 cm)
FEET	feet (30.48 cm)
INCH	inch (2.54 cm)

ANGLEUNIT

enum ANGLEUNIT

strong

Angle unit.

Enumerator
DEGREE	trigonometric functions expect degree values
RADIANS	trigonometric functions expect radians values

Function Documentation

Ctz32()

Int maxon::Ctz32

(

Int32

x

)

Ctz64()

Int maxon::Ctz64

(

Int64

x

)

Clz32()

Int maxon::Clz32

(

Int32

x

)

Clz64()

Int maxon::Clz64

(

Int64

x

)

Clz()

Int maxon::Clz

(

T

x

)

Counts the number of leading zero bits of x. If x is zero, the bit width of T is returned. Note that the result depends on the bit width, i.e., Clz((Int16) 0xff) will return 8, while Clz((Int32) 0xff) will return 24.

Parameters

[in]

x

Value of which leading zero bits shall be counted.

Template Parameters

T	Type of x, this has to be an integral type.

Returns

Number of leading zero bits of x.

Ctz()

Int maxon::Ctz

(

T

x

)

Counts the number of trailing zero bits of x. If x is zero, the 0 is returned.

Parameters

[in]

x

Value of which trailing zero bits shall be counted.

Template Parameters

T	Type of x, this has to be an integral type.

Returns

Number of trailing zero bits of x.

CompareFloat() [1/2]

Bool maxon::CompareFloat	(	Float32	a,
		Float32	b,
		Float32	epsilon = 1e-10f
	)

Compare two floating point values according to a given epsilon.

Returns

The result is true if the values are identical or nearly identical (according to epsilon)

CompareFloat() [2/2]

Bool maxon::CompareFloat	(	Float64	a,
		Float64	b,
		Float64	epsilon = 1e-10
	)

Compare two floating point values according to a given epsilon.

Returns

The result is true if the values are identical or nearly identical (according to epsilon)

CompareFloatTolerant() [1/2]

Bool maxon::CompareFloatTolerant	(	Float32	a,
		Float32	b
	)

Compare two floating point values.

Returns

The result is true if the values are identical or nearly identical (the last 3 bits may be different)

CompareFloatTolerant() [2/2]

Bool maxon::CompareFloatTolerant	(	Float64	a,
		Float64	b
	)

Compare two floating point values.

Returns

The result is true if the values are identical or nearly identical (the last 3 bits may be different)

CheckFloat() [1/2]

Bool maxon::CheckFloat

(

Float32

r

)

Tests if a floating point number is valid.

Returns

True for FP_NORMAL, FP_SUBNORMAL, FP_ZERO and false for FP_NAN, FP_INFINITE.

CheckFloat() [2/2]

Bool maxon::CheckFloat

(

Float64

r

)

Tests if a floating point number is valid.

Returns

True for FP_NORMAL, FP_SUBNORMAL, FP_ZERO and false for FP_NAN, FP_INFINITE.

RepairFloat() [1/2]

Float32 maxon::RepairFloat

(

Float32

r

)

Repair floating point number. Only NANs and Infinity are corrected - denormalized numbers stay unchanged

RepairFloat() [2/2]

Float64 maxon::RepairFloat

(

Float64

r

)

Repair floating point number. Only NANs and Infinity are corrected - denormalized numbers stay unchanged

BoxStep() [1/2]

Float32 maxon::BoxStep	(	Float32	lowerLimit,
		Float32	upperLimit,
		Float32	x
	)

calculates the relative position of x in the range [lowerLimit..upperLimit]. if x <= lowerLimit the return value is 0.0, if x >= upperLimit it is 1.0, otherwise the relative position: (x - lowerLimit) / (upperLimit - lowerLimit)

BoxStep() [2/2]

Float64 maxon::BoxStep	(	Float64	lowerLimit,
		Float64	upperLimit,
		Float64	x
	)

calculates the relative position of x in the range [lowerLimit..upperLimit]. if x <= lowerLimit the return value is 0.0, if x >= upperLimit it is 1.0, otherwise the relative position: (x - lowerLimit) / (upperLimit - lowerLimit)

SmoothStep() [1/2]

Float32 maxon::SmoothStep	(	Float32	lowerLimit,
		Float32	upperLimit,
		Float32	x
	)

identical to Boxstep, but with a soft curve instead of linear behaviour in the range of [lowerLimit..upperLimit].

SmoothStep() [2/2]

Float64 maxon::SmoothStep	(	Float64	lowerLimit,
		Float64	upperLimit,
		Float64	x
	)

identical to Boxstep, but with a soft curve instead of linear behaviour in the range of [lowerLimit..upperLimit].

Modulo() [1/4]

Float32 maxon::Modulo	(	Float32	a,
		Float32	b
	)

Calculates the modulo of two floating point values. If the first value is positive, it behaves like a regular C++ modulo. Below zero the results are different though as the modulo continues to operate like in the positive domain: e.g. -1 % 7 = 6 or -8 % 7 = 6.

Parameters

[in]	a	Positive or negative value.
[in]	b	This value must be positive, otherwise the return value will be zero.

Modulo() [2/4]

Float64 maxon::Modulo	(	Float64	a,
		Float64	b
	)

Calculates the modulo of two floating point values. If the first value is positive, it behaves like a regular C++ modulo. Below zero the results are different though as the modulo continues to operate like in the positive domain: e.g. -1 % 7 = 6 or -8 % 7 = 6.

Parameters

[in]	a	Positive or negative value.
[in]	b	This value must be positive, otherwise the return value will be zero.

Modulo() [3/4]

Int32 maxon::Modulo	(	Int32	a,
		Int32	b
	)

Calculates the modulo of two integer values. If the first value is positive, it behaves like a regular C++ modulo. Below zero the results are different though as the modulo continues to operate like in the positive domain: e.g. -1 % 7 = 6 or -8 % 7 = 6.

Parameters

[in]	a	Positive or negative value.
[in]	b	This value must be positive, otherwise the return value will be zero.

Modulo() [4/4]

Int64 maxon::Modulo	(	Int64	a,
		Int64	b
	)

Calculates the modulo of two integer values. If the first value is positive, it behaves like a regular C++ modulo. Below zero the results are different though as the modulo continues to operate like in the positive domain: e.g. -1 % 7 = 6 or -8 % 7 = 6.

Parameters

[in]	a	Positive or negative value.
[in]	b	This value must be positive, otherwise the return value will be zero.

Bias() [1/2]

Float32 maxon::Bias	(	Float32	b,
		Float32	x
	)

calculates x ^ log2(b). b must be > 0.0

Bias() [2/2]

Float64 maxon::Bias	(	Float64	b,
		Float64	x
	)

calculates x ^ log2(b) b must be > 0.0

Truncate() [1/2]

Float32 maxon::Truncate

(

Float32

x

)

returns Floor for positive values and zero or Ceil for negative values

Truncate() [2/2]

Float64 maxon::Truncate

(

Float64

x

)

returns Floor for positive values and zero or Ceil for negative values

LessThan()

Bool maxon::LessThan	(	UInt	a1,
		UInt	a2,
		UInt	b1,
		UInt	b2
	)

Returns true if a1*a2 is less than b1*b2. The products and the comparison are carried out with the double bit width of Int so that no overflow occurs.

Parameters

[in]	a1	First factor of first comparison operand.
[in]	a2	Second factor of first comparison operand.
[in]	b1	First factor of second comparison operand.
[in]	b2	Second factor of second comparison operand.

Returns

True if a1*a2 < b1*b2.

VectorToSquareMatrix()

SqrMat3<Vec3<FLOAT> > maxon::VectorToSquareMatrix	(	const Vec3< FLOAT > &	dirVector,
		const Vec3< FLOAT > &	upVector
	)

Convert a facing direction and up direction to a square matrix.

Template Parameters

FLOAT

The vector's internal type.

Parameters

[in]	dirVector	The matrix's z axis.
[in]	upVector	World's up vector used to calculate matrix.

Returns

The matrix.

CheckedVectorToSquareMatrix()

SqrMat3<Vec3<FLOAT> > maxon::CheckedVectorToSquareMatrix	(	const Vec3< FLOAT > &	dirVector,
		const Vec3< FLOAT > &	upVector
	)

See also

VectorToSquareMatrix. Same but will add a parallel check between the supplied vector and rotate #dirVector 90 degrees until they are not parallel anymore.

VectorToMatrix()

Mat3<Vec3<FLOAT> > maxon::VectorToMatrix	(	const Vec3< FLOAT > &	dirVector,
		const Vec3< FLOAT > &	upVector
	)

Convert a facing direction and up direction to a matrix.

Template Parameters

FLOAT

The vector's internal type.

Parameters

[in]	dirVector	The matrix's z axis.
[in]	upVector	World's up vector used to calculate matrix.

Returns

The matrix.

GetTranslationMatrix() [1/2]

Mat3<Vec3<FLOAT> > maxon::GetTranslationMatrix

(

const Vec3< FLOAT > &

translation

)

Calculates a matrix to move / translate.

GetScaleMatrix() [1/2]

SqrMat3<Vec3<FLOAT> > maxon::GetScaleMatrix

(

const Vec3< FLOAT > &

scale

)

Calculates a matrix to scale.

GetRotationMatrixX()

SqrMat3<Vec3<FLOAT> > maxon::GetRotationMatrixX

(

FLOAT

angle

)

Calculates a matrix to rotate around the X axis. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

GetRotationMatrixY()

SqrMat3<Vec3<FLOAT> > maxon::GetRotationMatrixY

(

FLOAT

angle

)

Calculates a matrix to rotate around the Y axis. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

GetRotationMatrixZ()

SqrMat3<Vec3<FLOAT> > maxon::GetRotationMatrixZ

(

FLOAT

angle

)

Calculates a matrix to rotate around the Z axis. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

GetTranslationMatrix() [2/2]

Mat2<Vec2<FLOAT> > maxon::GetTranslationMatrix

(

const Vec2< FLOAT > &

translation

)

Calculates a matrix to move / translate.

GetScaleMatrix() [2/2]

SqrMat2<Vec2<FLOAT> > maxon::GetScaleMatrix

(

const Vec2< FLOAT > &

scale

)

Calculates a matrix to scale.

GetRotationMatrix() [1/2]

SqrMat2<Vec2<FLOAT> > maxon::GetRotationMatrix

(

FLOAT

angle

)

Calculates a rotation matrix. A positive angle rotates counter-clockwise. Note that the 2d rotation is different from the GetRotationMatrixZ rotation in 3d - the latter one rotates looking onto the axis, thus clockwise if you look from the front.

MAXON_ENUM_LIST() [1/4]

enum maxon::ROTATIONORDER maxon::MAXON_ENUM_LIST

(

ROTATIONORDER

)

GetRotationAngles() [1/2]

Vec3<FLOAT> maxon::GetRotationAngles	(	const SqrMat3< Vec3< FLOAT >> &	m,
		ROTATIONORDER	rotationOrder
	)

Calculates rotation values of a matrix.

Parameters

[in]	m	Matrix. The axes do not need to be normalized, but should be perpendicular. The 'offset' component has no influence on the outcome.
[in]	rotationOrder	Rotation order in which the rotations shall be executed.

Returns

Calculated rotation values, which can be used to re-create the matrix again using GetRotationMatrix. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

GetRotationAngles() [2/2]

Vec3<FLOAT> maxon::GetRotationAngles	(	const Vec3< FLOAT > &	direction,
		ROTATIONORDER	rotationOrder
	)

Calculates a rotation from a given direction vector.

Parameters

[in]	direction	Direction vector, does not need to be normalized. The direction vector defines the first rotation axis of any (global) rotation order. So, e.g. for ROTATIONORDER::XYZGLOBAL 'direction' defines the +X direction.
[in]	rotationOrder	Rotation order in which the rotations shall be executed.

Returns

Rotation that can be transformed into a matrix using GetRotationMatrix. The first rotation axis (according to the rotation order) will be parallel to 'direction' (e.g. for ROTATIONORDER::XYZGLOBAL this is the +X axis).

GetRotationMatrix() [2/2]

SqrMat3<Vec3<FLOAT> > maxon::GetRotationMatrix	(	const Vec3< FLOAT > &	rotation,
		ROTATIONORDER	rotationOrder
	)

Constructs a rotation matrix from a given rotation. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

Parameters

[in]	rotation	Rotation value that is interpreted depending on the rotation order.
[in]	rotationOrder	Rotation order in which the rotations shall be executed.

Returns

A matrix with normalized, perpendicular vectors and offset 0.0.

GetPSRMatrix()

Mat3<Vec3<FLOAT> > maxon::GetPSRMatrix	(	const Vec3< FLOAT > &	position,
		const Vec3< FLOAT > &	scale,
		const Vec3< FLOAT > &	rotation,
		ROTATIONORDER	rotationOrder
	)

Constructs a matrix from a given position, scale and rotation. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

Parameters

[in]	position	Translation value (offset of the resulting matrix).
[in]	scale	Scale value (length of the resulting axes).
[in]	rotation	Rotation value that is interpreted depending on the rotation order.
[in]	rotationOrder	Rotation order in which the rotations shall be executed.

Returns

A matrix with normalized, perpendicular vectors and offset 0.0.

GetOptimumRotation()

Vec3<FLOAT> maxon::GetOptimumRotation	(	const Vec3< FLOAT > &	oldRotation,
		const Vec3< FLOAT > &	newRotation,
		ROTATIONORDER	rotationOrder
	)

Corrects a new rotational value to match an old one as close as possible. This will avoid singularity effects (sudden 'flips' when a rotation jumps from 360 to 0 degrees).

Parameters

[in]	oldRotation	Last rotation value.
[in]	newRotation	New rotation value that needs to be corrected.
[in]	rotationOrder	Rotation order in which the rotations shall be executed.

Returns

The rotation value that is closest to oldRotation, but creates the same matrix.

GetClosestPointOnLine()

Vec3<FLOAT> maxon::GetClosestPointOnLine	(	const Vec3< FLOAT > &	lineOrigin,
		const Vec3< FLOAT > &	lineDirection,
		const Vec3< FLOAT > &	point
	)

Calculates the closest point on a line.

Parameters

[in]	lineOrigin	The starting point of the line.
[in]	lineDirection	The direction vector of the line (does not need to be normalized)
[in]	point	The point.

Returns

The closest point on the line (with the minimum distance to the given point). If lineDirection was a null vector, the result will be lineOrigin.

GetPointLineDistance()

FLOAT maxon::GetPointLineDistance	(	const Vec3< FLOAT > &	lineOrigin,
		const Vec3< FLOAT > &	lineDirection,
		const Vec3< FLOAT > &	point
	)

Calculates the distance of a point and a line.

Parameters

[in]	lineOrigin	The starting point of the line.
[in]	lineDirection	The direction vector of the line (does not need to be normalized)
[in]	point	The point.

Returns

The minimum distance of the given line and point. If lineDirection was a null vector, the result will be 0.0.

ReflectRay()

Vec3<FLOAT> maxon::ReflectRay	(	const Vec3< FLOAT > &	direction,
		const Vec3< FLOAT > &	normal
	)

Reflects a ray on a surface.

Parameters

[in]	direction	The direction of the ray, must be normalized.
[in]	normal	Surface normal, must be normalized.

Returns

The reflected ray, which is also normalized.

RGBToHSV()

Vec3<FLOAT> maxon::RGBToHSV

(

const Col3< FLOAT > &

color

)

Converts RGB into HSV color space.

Parameters

[in]

color

The RGB color (with r/g/b >= 0.0)

Returns

The HSV (hue, saturation, value) color.

HSVToRGB()

Col3<FLOAT> maxon::HSVToRGB

(

const Vec3< FLOAT > &

color

)

Converts HSV into RGB color space.

Parameters

[in]

color

The HSV (hue, saturation, value) color (with h/s/v >= 0.0)

Returns

The RGB color.

RGBToHSL()

Vec3<FLOAT> maxon::RGBToHSL

(

const Col3< FLOAT > &

color

)

Converts RGB into HSL color space.

Parameters

[in]

color

The RGB color (with r/g/b >= 0.0)

Returns

The HSL (hue, saturation, lightness) color.

HSLToRGB()

Col3<FLOAT> maxon::HSLToRGB

(

const Vec3< FLOAT > &

color

)

Converts HSL into RGB color space.

Parameters

[in]

color

The HSL (hue, saturation, lightness) color (with h/s/l >= 0.0)

Returns

The RGB color.

GetRotationAxis()

void maxon::GetRotationAxis	(	const SqrMat3< Vec3< FLOAT >> &	m,
		Vec3< FLOAT > &	axisVector,
		FLOAT &	axisRotation
	)

Calculates axis and rotation from a matrix. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

Parameters

[in]	m	Matrix with perpendicular vectors. Its vectors do not need to be normalized.
[out]	axisVector	The calculated axis (normalized vector)
[out]	axisRotation	The calculated rotation. If the matrix was singular a null vector will be returned for axisVector.

GetRotationMatrixFromAxis()

SqrMat3<Vec3<FLOAT> > maxon::GetRotationMatrixFromAxis	(	const Vec3< FLOAT > &	axisVector,
		FLOAT	axisRotation
	)

Calculates matrix from axis and rotation. A positive angle rotates counter-clockwise (when the rotation axis is facing towards the viewer).

Parameters

[in]	axisVector	Axis vector, does not need to be normalized.
[in]	axisRotation	The rotation.

Returns

The calculated matrix (perpendicular & normalized vectors). If the passed axis was a null vector an identity matrix will be returned.

IsMatrixRectangular()

Bool maxon::IsMatrixRectangular	(	const MATRIXTYPE &	m,
		typename MATRIXTYPE::ValueType	epsilon = 1e-10_f
	)

Verify if matrix is orthogonal.

Template Parameters

MATRIXTYPE

The Matrix type, 32 or 64.

Parameters

[in]	m	Matrix to verify.
[in]	epsilon	Allowed epsilon.

Returns

True if Matrix is valid.

GetSum()

MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference<ITERABLETYPE>::type::ValueType maxon::GetSum

(

ITERABLETYPE &&

array

)

Returns the sum of all elements.

GetAverage()

MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference<ITERABLETYPE>::type::ValueType maxon::GetAverage

(

ITERABLETYPE &&

array

)

Returns the average of all elements.

operator*() [1/2]

Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> maxon::operator*	(	const SqrMat3< V > &	m,
		const Mat3< V2 > &	m2
	)

Multiplies two matrices. The rule is m1 AFTER m2 If you transform a point with the result matrix this is identical to first transforming with m2 and then with m1

operator*() [2/2]

Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> maxon::operator*	(	const SqrMat2< V > &	m,
		const Mat2< V2 > &	m2
	)

Multiplies two matrices. The rule is m1 AFTER m2 If you transform a point with the result matrix this is identical to first transforming with m2 and then with m1

PrivateRangeValueTypeHelper() [1/2]

T maxon::PrivateRangeValueTypeHelper

(

OverloadRank0

)

PrivateRangeValueTypeHelper() [2/2]

T::ValueType maxon::PrivateRangeValueTypeHelper

(

OverloadRank1

)

PrivateGetDataType()

Result<DataType> maxon::PrivateGetDataType	(	Range< T > **	,
		OverloadRank0
	)

MAXON_ENUM_LIST() [2/4]

enum maxon::TIMEFORMAT maxon::MAXON_ENUM_LIST

(

TIMEFORMAT

)

operator""_h()

const TimeValue maxon::operator""_h

(

long double

value

)

Literal to allow definition of hours.

operator""_min()

const TimeValue maxon::operator""_min

(

long double

value

)

Literal to allow definition of minutes.

operator""_sec()

const TimeValue maxon::operator""_sec

(

long double

value

)

Literal to allow definition of seconds.

operator""_ms()

const TimeValue maxon::operator""_ms

(

long double

value

)

Literal to allow definition of milliseconds.

operator""_us()

const TimeValue maxon::operator""_us

(

long double

value

)

Literal to allow definition of microseconds.

operator""_ns()

const TimeValue maxon::operator""_ns

(

long double

value

)

Literal to allow definition of nanoseconds.

Clamp01() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Clamp01

(

Float32

a

)

Clip a floating point number against the lower limit 0 and the upper limit 1. The result will be returned.

Clamp01() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Clamp01

(

Float64

a

)

Clip a floating point number against the lower limit 0 and the upper limit 1. The result will be returned.

Sin() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Sin

(

Float32

val

)

Calculates the sine of a value.

Sin() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Sin

(

Float64

val

)

Calculates the sine of a value.

Cos() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Cos

(

Float32

val

)

Calculates the cosine of a value.

Cos() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Cos

(

Float64

val

)

Calculates the cosine of a value.

Tan() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Tan

(

Float32

val

)

Calculates the tangent of a value. Note that the input needs to be checked for proper range, so that no exceptions will be generated.

Tan() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Tan

(

Float64

val

)

Calculates the tangent of a value. Note that the input needs to be checked for proper range, so that no exceptions will be generated.

ATan() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::ATan

(

Float32

val

)

Calculates the arcustangens of a value.

ATan() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::ATan

(

Float64

val

)

Calculates the arcustangens of a value.

ATan2() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::ATan2	(	Float32	valY,
		Float32	valX
	)

Calculates the arcustangens2 of a value. Returns the principal value of the arc tangent of y/x, expressed in radians. To compute the value, the function takes into account the sign of both arguments in order to determine the quadrant. If x is zero, depending on the sign of y +/- PI05 is returned. If x and y are both zero the function returns zero.

ATan2() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::ATan2	(	Float64	valY,
		Float64	valX
	)

Calculates the arcustangens2 of a value. Returns the principal value of the arc tangent of y/x, expressed in radians. To compute the value, the function takes into account the sign of both arguments in order to determine the quadrant. If x is zero, depending on the sign of y +/- PI05 is returned. If x and y are both zero the function returns zero.

Exp() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Exp

(

Float32

val

)

Calculates e^value.

Exp() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Exp

(

Float64

val

)

Calculates e^value.

Exp2() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Exp2

(

Float32

val

)

Returns the base-2 exponential function of x, which is 2 raised to the power x: 2x.

Exp2() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Exp2

(

Float64

val

)

Returns the base-2 exponential function of x, which is 2 raised to the power x: 2x.

Ln() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Ln

(

Float32

val

)

Calculates logarithm of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Ln() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Ln

(

Float64

val

)

Calculates logarithm of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Log10() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Log10

(

Float32

val

)

Calculates logarithm with base 10 of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Log10() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Log10

(

Float64

val

)

Calculates logarithm with base 10 of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Log2() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Log2

(

Float32

val

)

Calculates logarithm with base 2 of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Log2() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Log2

(

Float64

val

)

Calculates logarithm with base 2 of a value. Note that the input needs to be positive, so that no exceptions will be generated.

Sqrt() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Sqrt

(

Float32

val

)

Calculates square root of a value. Note that the input must not be be negative, so that no exceptions will be generated.

Sqrt() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Sqrt

(

Float64

val

)

Calculates square root of a value. Note that the input must not be be negative, so that no exceptions will be generated.

Floor() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Floor

(

Float32

val

)

Rounds to the largest previous integer number.

Floor() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Floor

(

Float64

val

)

Rounds to the largest previous integer number.

Ceil() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Ceil

(

Float32

val

)

Rounds to the smallest following integer number.

Ceil() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Ceil

(

Float64

val

)

Rounds to the smallest following integer number.

Round() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Round

(

Float32

val

)

Rounds to the nearest integer number.

Round() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Round

(

Float64

val

)

Rounds to the nearest integer number.

Pow() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Pow	(	Float32	v1,
		Float32	v2
	)

Calculates v1^v2.

Pow() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Pow	(	Float64	v1,
		Float64	v2
	)

Calculates v1^v2.

Sinh() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Sinh

(

Float32

val

)

Calculates hyperbolic sine.

Sinh() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Sinh

(

Float64

val

)

Calculates hyperbolic sine.

Cosh() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Cosh

(

Float32

val

)

Calculates hyperbolic cosine.

Cosh() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Cosh

(

Float64

val

)

Calculates hyperbolic cosine.

Tanh() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Tanh

(

Float32

val

)

Calculates hyperbolic tangent.

Tanh() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Tanh

(

Float64

val

)

Calculates hyperbolic tangent.

FMod() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::FMod	(	Float32	v1,
		Float32	v2
	)

Calculates floating point modulo.

FMod() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::FMod	(	Float64	v1,
		Float64	v2
	)

Calculates floating point modulo.

Abs() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Abs

(

Float32

val

)

Calculates the absolute value of a floating point number.

Abs() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Abs

(

Float64

val

)

Calculates the absolute value of a floating point number.

Inverse() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Inverse

(

Float32

f

)

Calculates the reciprocal value (multiplicative inverse). If the input value is zero, zero will be returned for safety to avoid exceptions.

Inverse() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Inverse

(

Float64

f

)

Calculates the reciprocal value (multiplicative inverse). If the input value is zero, zero will be returned for safety to avoid exceptions.

Abs() [3/3]

constexpr MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Abs ( X  f )

constexpr

Calculates the absolute value of any data type.

Min()

constexpr MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Min ( X  a, X  b  )

constexpr

Calculates the minimum of two values and return it.

Max()

constexpr MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Max ( X  a, X  b  )

constexpr

Calculates the maximum of two values and return it.

Swap()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::Swap	(	X &	a,
		X &	b
	)

Swaps two values. If available, move semantics will be used.

ClampValue()

MAXON_ATTRIBUTE_FORCE_INLINE X maxon::ClampValue	(	X	value,
		X	lowerLimit,
		X	upperLimit
	)

Clips a value against a lower and upper limit. The new value is returned.

Blend()

MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Blend	(	const X &	value1,
		const X &	value2,
		Y	blendValue
	)

Blends two values. If blendValue is 0.0 value1 is returned, if blendValue is 1.0 value2 is returned. No clipping below 0.0 or 1.0 takes place (in that case use BoxStep).

Sqr() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Sqr	(	X	a,
		X	b
	)

Calculates square difference of two values.

Sqr() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE X maxon::Sqr

(

X

a

)

Calculates square of a value.

Gamma() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Gamma	(	Float32	value,
		Float32	gamma
	)

Calculates the gamma correction. The input value is clipped to [0.0, 1.0] for safety to avoid exceptions.

Gamma() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Gamma	(	Float64	value,
		Float64	gamma
	)

Calculates the gamma correction. The input value is clipped to [0.0, 1.0] for safety to avoid exceptions.

Si() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Si

(

Float32

val

)

Calculates si (the unnormalized sinc function). The input value is checked for 0 to avoid exceptions.

Si() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Si

(

Float64

val

)

Calculates si (the unnormalized sinc function). The input value is checked for 0 to avoid exceptions.

Sinc() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Sinc

(

Float32

val

)

Calculates sinc. The input value is checked for 0 to avoid exceptions.

Sinc() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Sinc

(

Float64

val

)

Calculates sinc. The input value is checked for 0 to avoid exceptions.

ASin() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::ASin

(

Float32

val

)

Calculates arcsine. The input value is clipped for safety to avoid exceptions.

ASin() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::ASin

(

Float64

val

)

Calculates arcsine. The input value is clipped for safety to avoid exceptions. @MAXON_ANNOTATION{reflection="net.maxon.ASin"}

ACos() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::ACos

(

Float32

val

)

Calculates arccosine. The input value is clipped for safety to avoid exceptions.

ACos() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::ACos

(

Float64

val

)

Calculates arccosine. The input value is clipped for safety to avoid exceptions.

DegToRad() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::DegToRad

(

Float32

r

)

Converts float value from degrees to radians.

DegToRad() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::DegToRad

(

Float64

r

)

Converts float value from degrees to radians.

RadToDeg() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::RadToDeg

(

Float32

r

)

Converts float value from radians to degrees.

RadToDeg() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::RadToDeg

(

Float64

r

)

Converts float value from radians to degrees.

SinCos() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SinCos	(	Float32	val,
		Float32 &	sn,
		Float32 &	cs
	)

Calculates both sine and cosine of a value.

SinCos() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SinCos	(	Float64	val,
		Float64 &	sn,
		Float64 &	cs
	)

Calculates both sine and cosine of a value.

SafeConvert() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE DEST maxon::SafeConvert

(

Float64

src

)

Safely converts a 64 bit float value into another scalar value. The resulting value will be clipped against its boundaries, without raising an exception.

SafeConvert() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE DEST maxon::SafeConvert

(

Float32

src

)

Safely converts a 32 bit float value into another scalar value. The resulting value will be clipped against its boundaries, without raising an exception.

SetMax()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SetMax	(	T &	a,
		const typename SFINAEHelper< T >::type &	b
	)

Assigns the maximum of two values to the first value.

Parameters

[in,out]	a	First value.
[in]	b	Second value.

SetMin()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SetMin	(	T &	a,
		const typename SFINAEHelper< T >::type &	b
	)

Assigns the minimum of two values to the first value.

Parameters

[in,out]	a	First value.
[in]	b	Second value.

Sign()

MAXON_ATTRIBUTE_FORCE_INLINE Int maxon::Sign

(

X

f

)

Calculates the sign of a value.

Parameters

[in]

f

Value to test.

Returns

1 if the value is 0 or positive, -1 otherwise.

Mod()

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::Mod	(	T	a,
		T	b
	)

Calculates the modulo (non-negative remainder of division) value for integer values. It works continuously for negative dividends, e.g. Mod(-1, 9) == 8 and Mod(1, 9) == 1.

Parameters

[in]	a	Dividend.
[in]	b	Divisor, must be > 0 (positive).

Returns

Modulo result.

IsPowerOfTwo() [1/2]

constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsPowerOfTwo ( UInt32  x )

constexpr

Returns true if x is a power of two, i.e., if it has exactly one bit set.

Parameters

[in]

x

Value to check.

Returns

True if x is a power of two.

IsPowerOfTwo() [2/2]

constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsPowerOfTwo ( UInt64  x )

constexpr

Returns true if x is a power of two, i.e., if it has exactly one bit set.

Parameters

[in]

x

Value to check.

Returns

True if x is a power of two.

IntToColor() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::IntToColor	(	UInt	r,
		UInt	g,
		UInt	b,
		UInt	a
	)

Converts RGBA UInt [0, 255] values to a ColorA.

Parameters

[in]	r	Red value.
[in]	g	Green value
[in]	b	Blue value.
[in]	a	Alpha value.

Returns

Converted ColorA.

IntToColor() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::IntToColor	(	UInt	r,
		UInt	g,
		UInt	b
	)

Converts RGB UInt [0, 255] values to a ColorA.

Parameters

[in]	r	Red value.
[in]	g	Green value
[in]	b	Blue value.

Returns

Converted ColorA.

FloatToColor() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::FloatToColor	(	Float	r,
		Float	g,
		Float	b,
		Float	a
	)

Converts RGBA Float [0.0, 1.0] values to a ColorA.

Parameters

[in]	r	Red value.
[in]	g	Green value
[in]	b	Blue value.
[in]	a	Alpha value.

Returns

Converted ColorA.

FloatToColor() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::FloatToColor	(	Float	r,
		Float	g,
		Float	b
	)

Converts RGB Float [0.0, 1.0] values to a ColorA.

Parameters

[in]	r	Red value.
[in]	g	Green value
[in]	b	Blue value.

Returns

Converted ColorA.

ColorSetAlpha()

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::ColorSetAlpha	(	const ColorA &	col,
		Float	alpha
	)

Sets the alpha value of a ColorA.

Parameters

[in]	col	Given ColorA.
[in]	alpha	Alpha value.

Returns

Converted ColorA.

ColorMultiplyAlpha()

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::ColorMultiplyAlpha	(	const ColorA &	col,
		Float	alpha
	)

Multiplies a ColorA with an alpha value.

Parameters

[in]	col	Given ColorA.
[in]	alpha	Multiply alpha value.

Returns

Converted ColorA.

BlendColors() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::BlendColors	(	const Color &	col1,
		const Color &	col2,
		Float	alpha
	)

Blends two colors based on an alpha factor.

Parameters

[in]	col1	First color.
[in]	col2	Second color.
[in]	alpha	Alpha blending factor. Valid range goes from 0.0 (Col1) to 1.0 (Col2).

Returns

Blended color.

BlendColors() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE ColorA maxon::BlendColors	(	const ColorA &	col1,
		const ColorA &	col2,
		Float	alpha
	)

Blends two colors based on an alpha factor. Note: only RGB values are used, color alpha values are ignored.

Parameters

[in]	col1	First color. Alpha is ignored.
[in]	col2	Second color. Alpha is ignored.
[in]	alpha	Alpha blending factor. Valid range goes from 0.0 (Col1) to 1.0 (Col2).

Returns

Blended color with an alpha value of 1.0.

BlendColor()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendColor	(	const COLORTYPE &	col1,
		const COLORTYPE &	col2,
		const typename COLORTYPE::ValueType	blendValue
	)

Blend linear between two CanvasColors.

Parameters

[in]	col1	First ColorA.
[in]	col2	Second ColorA.
[in]	blendValue	Blend value [0.0, 1.0].

Returns

Blended ColorA value

GetPerceivedBrightness()

MAXON_ATTRIBUTE_FORCE_INLINE Float maxon::GetPerceivedBrightness

(

const ColorA &

color

)

Gets the perceived brightness from the color. Source: http://stackoverflow.com/a/596243/1577282

Parameters

[in]

color

The color whose perceived brightness will be calculated.

Returns

The perceived brightness value.

IsColorPerceivedAsDark()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsColorPerceivedAsDark

(

const ColorA &

color

)

Checks if a color is perceived as dark by the human eye. Source: http://www.nbdtech.com/Blog/archive/2008/04/27/Calculating-the-Perceived-Brightness-of-a-Color.aspx Source: https://robots.thoughtbot.com/closer-look-color-lightness

Parameters

[in]

color

The color whose darkness will be evaluated.

Returns

True: the color is perceived as dark, False: the color is perceived as light.

MAXON_REGISTRY()

maxon::MAXON_REGISTRY	(	Class< RenderNoiseRef >	,
		RenderNoiseClasses	,
		"net.maxon.render.registry.rendernoiseclasses"
	)

MAXON_ENUM_LIST() [3/4]

enum maxon::METRICUNIT maxon::MAXON_ENUM_LIST

(

METRICUNIT

)

MAXON_ENUM_LIST() [4/4]

enum maxon::ANGLEUNIT maxon::MAXON_ENUM_LIST

(

ANGLEUNIT

)

Variable Documentation

FRAMERATE_DEFAULT

const Float64 FRAMERATE_DEFAULT

Default frame rate of 30 fps.

FRAMERATE_NTSC

const Float64 FRAMERATE_NTSC

NTSC frame rate is approximately 29.97 fps.

FRAMERATE_PAL

const Float64 FRAMERATE_PAL

PAL frame rate is 25 fps.

FRAMERATE_FILM

const Float64 FRAMERATE_FILM

Movie frame rate is 24 fps.

FRAMERATE_FILM_NTSC

const Float64 FRAMERATE_FILM_NTSC

Modified movie frame rate to avoid frame roll when transfering video to NTSC, approx. 23.976 fps.

TIMEVALUE_INFINITE

const TimeValue TIMEVALUE_INFINITE

static

TIMEVALUE_INVALID

const TimeValue TIMEVALUE_INVALID

static

MINVALUE_FLOAT32

constexpr Float32 MINVALUE_FLOAT32

staticconstexpr

the minimum value a Float32 can represent

MAXVALUE_FLOAT32

constexpr Float32 MAXVALUE_FLOAT32

staticconstexpr

the maximum value a Float32 can represent

MINVALUE_FLOAT64

constexpr Float64 MINVALUE_FLOAT64

staticconstexpr

the minimum value a Float64 can represent

MAXVALUE_FLOAT64

constexpr Float64 MAXVALUE_FLOAT64

staticconstexpr

the maximum value a Float64 can represent

MINVALUE_INT32_FLOAT32

constexpr Float32 MINVALUE_INT32_FLOAT32

staticconstexpr

minimum Float32 value that can be represented by Int32 (-0x7FFFFF80). Lower values will results in an overflow

MAXVALUE_INT32_FLOAT32

constexpr Float32 MAXVALUE_INT32_FLOAT32

staticconstexpr

maximum Float32 value that can be represented by Int32 ( 0x7FFFFF80). Higher values will results in an overflow

MINVALUE_INT64_FLOAT64

constexpr Float64 MINVALUE_INT64_FLOAT64

staticconstexpr

minimum Float64 value that can be represented by Int64 (-0x7ffffffffffffdff). Lower values will results in an overflow

MAXVALUE_INT64_FLOAT64

constexpr Float64 MAXVALUE_INT64_FLOAT64

staticconstexpr

maximum Float64 value that can be represented by Int64 ( 0x7ffffffffffffdff). Higher values will results in an overflow

MINRANGE_FLOAT32

constexpr Float32 MINRANGE_FLOAT32

staticconstexpr

'safe' minimum range for Float32. Guarantees that multiplication of two numbers doesn't produce an overflow

MAXRANGE_FLOAT32

constexpr Float32 MAXRANGE_FLOAT32

staticconstexpr

'safe' maximum range for Float32. Guarantees that multiplication of two numbers doesn't produce an overflow

MINRANGE_FLOAT64

constexpr Float64 MINRANGE_FLOAT64

staticconstexpr

'safe' minimum range for Float. Guarantees that multiplication of two numbers doesn't produce an overflow

MAXRANGE_FLOAT64

constexpr Float64 MAXRANGE_FLOAT64

staticconstexpr

'safe' maximum range for Float. Guarantees that multiplication of two numbers doesn't produce an overflow

MINVALUE_FLOAT

constexpr Float MINVALUE_FLOAT

staticconstexpr

the minimum value a Float can represent

MAXVALUE_FLOAT

constexpr Float MAXVALUE_FLOAT

staticconstexpr

the maximum value a Float can represent

MINRANGE_FLOAT

constexpr Float MINRANGE_FLOAT

staticconstexpr

'safe' minimum range for Float64. Guarantees that multiplication of two numbers doesn't produce an overflow

MAXRANGE_FLOAT

constexpr Float MAXRANGE_FLOAT

staticconstexpr

'safe' maximum range for Float64. Guarantees that multiplication of two numbers doesn't produce an overflow

NOTOK

constexpr Int NOTOK

staticconstexpr

constant used for special cases

PI

constexpr Float64 PI

staticconstexpr

floating point constant: PI

PI_INV

constexpr Float64 PI_INV

staticconstexpr

floating point constant: 1.0 / PI

PI2

constexpr Float64 PI2

staticconstexpr

floating point constant: 2.0 * PI

PI2_INV

constexpr Float64 PI2_INV

staticconstexpr

floating point constant: 1.0 / (2.0 * PI)

PI05

constexpr Float64 PI05

staticconstexpr

floating point constant: 0.5 * PI

PI05_INV

constexpr Float64 PI05_INV

staticconstexpr

floating point constant: 1.0 / (0.5 * PI)

SQRT2

constexpr Float64 SQRT2

staticconstexpr

floating point constant: Sqrt(2.0)

SQRT_PI2

constexpr Float64 SQRT_PI2

staticconstexpr

floating point constant: Sqrt(2.0 * PI)

SQRT2_INV

constexpr Float64 SQRT2_INV

staticconstexpr

floating point constant: 1.0 / Sqrt(2.0)

SQRT3

constexpr Float64 SQRT3

staticconstexpr

floating point constant: Sqrt(3.0)

LOG2

constexpr Float64 LOG2

staticconstexpr

floating point constant: Log(2.0)

PERCEIVED_BRIGHTNESS_FACTOR_RED

const Float PERCEIVED_BRIGHTNESS_FACTOR_RED

static

PERCEIVED_BRIGHTNESS_FACTOR_GREEN

const Float PERCEIVED_BRIGHTNESS_FACTOR_GREEN

static

PERCEIVED_BRIGHTNESS_FACTOR_BLUE

const Float PERCEIVED_BRIGHTNESS_FACTOR_BLUE

static

PERCEIVED_BRIGHTNESS_CUTOFF

const Float PERCEIVED_BRIGHTNESS_CUTOFF

static