Namespaces
	d2

	detail

	GaussSeidel

Classes
class	AllocatedArray
	Allocated Array. More...

class	ArrayList
	Array list. More...

class	BlockAllocator

struct	BlockDeallocator
	Block deallocator. More...

class	BoundedValue
	Bounded value. More...

struct	ConstraintSolverConf

struct	ContactFeature
	Contact Feature. More...

class	ContactKey
	Key value class for contacts. More...

struct	Filter
	A holder for contact filtering data. More...

class	Fixed
	Template class for fixed-point numbers. More...

struct	FixtureProxy
	Fixture proxy. More...

class	FlagGuard
	Flag guard type. More...

class	GrowableStack

struct	HasOne

struct	HasOne< T, detail::VoidT< decltype(T{1}) > >
	Template specialization for valid/acceptable "arithmetic" types. More...

struct	HasType
	Has-type trait template class. More...

struct	HasType< T, std::tuple< T, Ts... > >
	Has-type trait true class. More...

struct	HasType< T, std::tuple< U, Ts... > >
	Has-type trait template super class. More...

struct	HasType< T, std::tuple<> >
	Has-type trait template class specialized for `std::tuple` classes. More...

class	Interval
	Interval template type. More...

class	InvalidArgument
	Invalid argument logic error. More...

struct	IsAddable
	Template for determining if the given types are addable. More...

struct	IsAddable< T1, T2, detail::VoidT< decltype(T1{}+T2{})> >
	Template specializing for addable types. More...

struct	IsArithmetic
	Template for determining if the given type is an "arithmetic" type. More...

struct	IsArithmetic< T, detail::VoidT< decltype(T{}+T{}), decltype(T{} - T{}), decltype(T{} *T{}), decltype(T{}/T{}) > >
	Template specialization for valid/acceptable "arithmetic" types. More...

struct	IsDivisable
	Template for determining if the given types are divisable. More...

struct	IsDivisable< T1, T2, detail::VoidT< decltype(T1{}/T2{})> >
	Template specializing for divisable types. More...

struct	IsEqualityComparable
	Template for determining if the given type is an equality comparable type. More...

struct	IsEqualityComparable< T1, T2, detail::VoidT< decltype(T1{}==T2{})> >
	Template specialization for equality comparable types. More...

struct	IsInequalityComparable
	Template for determining if the given type is an inequality comparable type. More...

struct	IsInequalityComparable< T1, T2, detail::VoidT< decltype(T1{} !=T2{})> >
	Template specialization for inequality comparable types. More...

struct	IslandStats
	Island solver statistics. More...

struct	IsMatrix
	Trait class for checking if type is a matrix type. More...

struct	IsMatrix< Vector< Vector< T, N >, M > >
	Trait class specialization for checking if type is a matrix type. More...

struct	IsMultipliable
	Template for determining if the given types are multipliable. More...

struct	IsMultipliable< T1, T2, detail::VoidT< decltype(T1{} *T2{})> >
	Template specializing for multipliable types. More...

struct	IsSquareMatrix
	Trait class for checking if type is a square matrix type. More...

struct	IsSquareMatrix< Vector< Vector< T, M >, M > >
	Trait class specialization for checking if type is a square matrix type. More...

struct	IsVector
	Trait class for checking if type is a `Vector` type. More...

struct	IsVector< Vector< T, N > >
	Trait class specialization for checking if type is a `Vector` type.. More...

class	LengthError
	Length based logic error. More...

struct	LengthIndexPair
	A length associated with two vertex counter indices. More...

struct	LexicographicalGreater
	Function object for performing lexicographical greater-than comparisons of containers. More...

struct	LexicographicalGreaterEqual
	Function object for performing lexicographical greater-than or equal-to comparisons of containers. More...

struct	LexicographicalLess
	Function object for performing lexicographical less-than comparisons of containers. More...

struct	LexicographicalLessEqual
	Function object for performing lexicographical less-than or equal-to comparisons of containers. More...

struct	MovementConf
	Movement configuration. More...

class	OptionalValue
	Optional value template class. More...

struct	PointStates
	Point states. More...

struct	PreStepStats
	Pre-phase per-step statistics. More...

class	Range
	Template range value class. More...

struct	RegStepStats
	Regular-phase per-step statistics. More...

class	SizedRange
	Template sized range value class. More...

class	Span
	A C++ encapsulation of an array and its size. More...

class	StackAllocator

class	StepConf
	Step configuration. More...

struct	StepStats
	Per-step statistics. More...

struct	ToiConf
	Time of impact configuration. More...

struct	TOIOutput
	Output data for time of impact. More...

struct	ToiStepStats
	TOI-phase per-step statistics. More...

struct	ValueCheckHelper
	Value check helper. More...

struct	ValueCheckHelper< T, std::enable_if_t< HasOne< T >::value > >
	Specialization of the value check helper. More...

struct	Vector
	Vector. More...

struct	Version
	Version numbering scheme. More...

struct	Wider
	Wider data type obtainer. More...

struct	Wider< double >
	Specialization of the Wider trait for double. More...

struct	Wider< float >
	Specialization of the Wider trait for float. More...

struct	Wider< std::int16_t >
	Specialization of the Wider trait for signed 16-bit integers. More...

struct	Wider< std::int32_t >
	Specialization of the Wider trait for signed 32-bit integers. More...

struct	Wider< std::int8_t >
	Specialization of the Wider trait for signed 8-bit integers. More...

struct	Wider< std::uint16_t >
	Specialization of the Wider trait for unsigned 16-bit integers. More...

struct	Wider< std::uint32_t >
	Specialization of the Wider trait for unsigned 32-bit integers. More...

struct	Wider< std::uint8_t >
	Specialization of the Wider trait for unsigned 8-bit integers. More...

class	WrongState
	Wrong state logic error. More...

Typedefs
using	PairLength2 = std::pair< Length2, Length2 >
	Pair of `Length2` values. More...

using	IndexPair = std::pair< VertexCounter, VertexCounter >
	Index pair. More...

using	IndexPair3 = std::array< IndexPair, MaxSimplexEdges >
	Array of three index-pair elements. More...

template<std::size_t N>
using	VertexCounterArray = std::array< VertexCounter, N >
	Vertex counter array template alias. More...

using	VertexCounter2 = VertexCounterArray< 2 >
	2-element vertex counter array. More...

template<typename T >
using	NonNegative = std::enable_if_t<!std::is_pointer< T >::value, BoundedValue< T, LoValueCheck::ZeroOrMore, HiValueCheck::Any > >
	Non negative bounded value type. More...

template<typename T >
using	NonPositive = BoundedValue< T, LoValueCheck::Any, HiValueCheck::ZeroOrLess >
	Non positive bounded value type. More...

template<typename T >
using	Positive = BoundedValue< T, LoValueCheck::AboveZero, HiValueCheck::Any >
	Positive bounded value type. More...

template<typename T >
using	Negative = BoundedValue< T, LoValueCheck::Any, HiValueCheck::BelowZero >
	Negative bounded value type. More...

template<typename T >
using	Finite = BoundedValue< T, LoValueCheck::AboveNegInf, HiValueCheck::BelowPosInf >
	Finite bounded value type. More...

template<typename T >
using	NonZero = std::enable_if_t<!std::is_pointer< T >::value, BoundedValue< T, LoValueCheck::NonZero, HiValueCheck::Any > >
	Non zero bounded value type. More...

template<typename T >
using	NonNull = std::enable_if_t< std::is_pointer< T >::value, BoundedValue< T, LoValueCheck::NonZero, HiValueCheck::Any > >
	Non-null pointer type. More...

template<typename T >
using	UnitInterval = BoundedValue< T, LoValueCheck::ZeroOrMore, HiValueCheck::OneOrLess >
	Unit interval bounded value type. More...

using	Fixed32 = Fixed< std::int32_t, 9 >
	32-bit fixed precision type. More...

template<typename T , std::size_t M, std::size_t N>
using	Matrix = Vector< Vector< T, N >, M >
	Generic M by N matrix. More...

template<typename T >
using	Matrix22 = Matrix< T, 2, 2 >
	2 by 2 matrix. More...

template<typename T >
using	Matrix33 = Matrix< T, 3, 3 >
	3 by 3 matrix. More...

using	Mat22 = Matrix22< Real >
	2 by 2 matrix of Real elements. More...

using	Mass22 = Matrix22< Mass >
	2 by 2 matrix of Mass elements. More...

using	InvMass22 = Matrix22< InvMass >
	2 by 2 matrix of `InvMass` elements. More...

using	Mat33 = Matrix33< Real >
	3 by 3 matrix of Real elements. More...

template<typename T >
using	Optional = OptionalValue< T >
	Optional type alias. More...

using	Real = float
	Real-number type. More...

using	ChildCounter = std::remove_const< decltype(MaxChildCount)>::type
	Child counter type. More...

using	TimestepIters = std::uint8_t

using	VertexCounter = std::remove_const< decltype(MaxShapeVertices)>::type
	Vertex count type. More...

using	BodyCounter = std::remove_const< decltype(MaxBodies)>::type
	Body count type. More...

using	ContactCounter = Wider< BodyCounter >::type
	Contact count type. More...

using	JointCounter = std::remove_const< decltype(MaxJoints)>::type
	Joint count type. More...

template<class T >
using	IsIterable = typename detail::IsIterableImpl< T >
	Determines whether the given type is an iterable type. More...

template<typename T , typename Tuple >
using	TupleContainsType = typename HasType< T, Tuple >::type
	Tuple contains type alias. More...

using	Time = PLAYRHO_QUANTITY(boost::units::si::time)
	Time quantity. More...

using	Frequency = PLAYRHO_QUANTITY(boost::units::si::frequency)
	Frequency quantity. More...

using	Length = PLAYRHO_QUANTITY(boost::units::si::length)
	Length quantity. More...

using	LinearVelocity = PLAYRHO_QUANTITY(boost::units::si::velocity)
	Linear velocity quantity. More...

using	LinearAcceleration = PLAYRHO_QUANTITY(boost::units::si::acceleration)
	Linear acceleration quantity. More...

using	Mass = PLAYRHO_QUANTITY(boost::units::si::mass)
	Mass quantity. More...

using	InvMass = PLAYRHO_QUANTITY(boost::units::si::inverse_mass)
	Inverse mass quantity. More...

using	Area = PLAYRHO_QUANTITY(boost::units::si::area)
	Area quantity. More...

using	AreaDensity = PLAYRHO_QUANTITY(boost::units::si::surface_density)
	Area (surface) density quantity. More...

using	Angle = PLAYRHO_QUANTITY(boost::units::si::plane_angle)
	Angle quantity. More...

using	AngularVelocity = PLAYRHO_QUANTITY(boost::units::si::angular_velocity)
	Angular velocity quantity. More...

using	AngularAcceleration = PLAYRHO_QUANTITY(boost::units::si::angular_acceleration)
	Angular acceleration quantity. More...

using	Force = PLAYRHO_QUANTITY(boost::units::si::force)
	Force quantity. More...

using	Torque = PLAYRHO_QUANTITY(boost::units::si::torque)
	Torque quantity. More...

using	SecondMomentOfArea = PLAYRHO_QUANTITY(boost::units::si::second_moment_of_area)
	Second moment of area quantity. More...

using	RotInertia = PLAYRHO_QUANTITY(boost::units::si::moment_of_inertia)
	Rotational inertia quantity. More...

using	InvRotInertia = PLAYRHO_QUANTITY(boost::units::si::inverse_moment_of_inertia)
	Inverse rotational inertia quantity. More...

using	Momentum = PLAYRHO_QUANTITY(boost::units::si::momentum)
	Momentum quantity. More...

using	AngularMomentum = PLAYRHO_QUANTITY(boost::units::si::angular_momentum)
	Angular momentum quantity. More...

template<typename T >
using	Vector2 = Vector< T, 2 >
	Vector with 2-elements. More...

using	Vec2 = Vector2< Real >
	Vector with 2 Real elements. More...

using	Length2 = Vector2< Length >
	2-element vector of Length quantities. More...

using	LinearVelocity2 = Vector2< LinearVelocity >
	2-element vector of linear velocity (`LinearVelocity`) quantities. More...

using	LinearAcceleration2 = Vector2< LinearAcceleration >
	2-element vector of linear acceleration (`LinearAcceleration`) quantities. More...

using	Force2 = Vector2< Force >
	2-element vector of Force quantities. More...

using	Mass2 = Vector2< Mass >
	2-element vector of Mass quantities. More...

using	InvMass2 = Vector2< InvMass >
	2-element vector of inverse mass (`InvMass`) quantities. More...

using	Momentum2 = Vector2< Momentum >
	2-element vector of Momentum quantities. More...

template<typename T >
using	Vector3 = Vector< T, 3 >
	Vector with 3-elements. More...

using	Vec3 = Vector3< Real >

using	Mass3 = Vector3< Mass >
	3-element vector of Mass quantities. More...

using	InvMass3 = Vector3< InvMass >
	3-element vector of inverse mass (`InvMass`) quantities. More...

Enumerations
enum	PointState { PointState::NullState, PointState::AddState, PointState::PersistState, PointState::RemoveState }
	Point state enumeration. More...

enum	RayCastOpcode { RayCastOpcode::Terminate, RayCastOpcode::IgnoreFixture, RayCastOpcode::ClipRay, RayCastOpcode::ResetRay }
	Ray cast opcode enumeration. More...

enum	LoValueCheck { LoValueCheck::Any, LoValueCheck::AboveZero, LoValueCheck::ZeroOrMore, LoValueCheck::AboveNegInf, LoValueCheck::NonZero }
	Lo value check. More...

enum	HiValueCheck { HiValueCheck::Any, HiValueCheck::BelowZero, HiValueCheck::ZeroOrLess, HiValueCheck::OneOrLess, HiValueCheck::BelowPosInf }
	Hi value check. More...

enum	BodyType { BodyType::Static = 0, BodyType::Kinematic, BodyType::Dynamic }
	Body Type. More...

Functions
template<>
PLAYRHO_CONSTEXPR d2::AABB	GetInvalid () noexcept
	Gets an invalid AABB value. More...

PLAYRHO_CONSTEXPR ContactFeature	GetVertexVertexContactFeature (ContactFeature::Index a, ContactFeature::Index b) noexcept
	Gets the vertex vertex contact feature for the given indices. More...

PLAYRHO_CONSTEXPR ContactFeature	GetVertexFaceContactFeature (ContactFeature::Index a, ContactFeature::Index b) noexcept
	Gets the vertex face contact feature for the given indices. More...

PLAYRHO_CONSTEXPR ContactFeature	GetFaceVertexContactFeature (ContactFeature::Index a, ContactFeature::Index b) noexcept
	Gets the face vertex contact feature for the given indices. More...

PLAYRHO_CONSTEXPR ContactFeature	GetFaceFaceContactFeature (ContactFeature::Index a, ContactFeature::Index b) noexcept
	Gets the face face contact feature for the given indices. More...

PLAYRHO_CONSTEXPR ContactFeature	Flip (ContactFeature val) noexcept
	Flips contact features information. More...

PLAYRHO_CONSTEXPR bool	operator== (ContactFeature lhs, ContactFeature rhs) noexcept
	Determines if the given two contact features are equal. More...

PLAYRHO_CONSTEXPR bool	operator!= (ContactFeature lhs, ContactFeature rhs) noexcept
	Determines if the given two contact features are not equal. More...

const char *	GetName (ContactFeature::Type type) noexcept
	Gets the human readable name for the given contact feature type. More...

inline ::std::ostream &	operator<< (::std::ostream &os, const ContactFeature &value)
	Stream output operator. More...

PLAYRHO_CONSTEXPR std::size_t	GetNumValidIndices (IndexPair3 pairs) noexcept
	Gets the number of valid indices in the given collection of index pairs. More...

PLAYRHO_CONSTEXPR bool	empty (IndexPair3 pairs) noexcept
	Checks whether the given collection of index pairs is empty. More...

PLAYRHO_CONSTEXPR auto	size (IndexPair3 pairs) -> decltype(GetNumValidIndices(pairs))
	Gets the dynamic size of the given collection of index pairs. More...

PLAYRHO_CONSTEXPR auto	max_size (IndexPair3 pairs) -> decltype(pairs.max_size())
	Gets the maximum size of the given container of index pairs. More...

template<std::size_t N>
VertexCounter	GetFirstShapeVertexIdx (const detail::SeparationInfo< N > &info) noexcept
	Gets first shape vertex index. More...

template<VertexCounter M, std::size_t N>
VertexCounter	GetSecondShapeVertexIdx (const detail::SeparationInfo< N > &info) noexcept
	Gets second shape vertex indices. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Manifold &value) noexcept
	Gets whether the given manifold is valid. More...

template<>
bool	Visit< d2::Shape > (const d2::Shape &shape, void *userData)
	Visits the given shape with the potentially non-null user data pointer. More...

const char *	GetName (TOIOutput::State state) noexcept
	Gets a human readable name for the given output state. More...

ToiConf	GetToiConf (const StepConf &conf) noexcept
	Gets the time of impact configuration for the given step configuration. More...

PLAYRHO_CONSTEXPR auto	GetDefaultToiConf ()
	Gets the default time of impact configuration. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Acceleration &value) noexcept
	Determines if the given value is valid. More...

template<typename T , std::size_t S>
ArrayList< T, S > &	operator+= (ArrayList< T, S > &lhs, const typename ArrayList< T, S >::data_type &rhs)
	`ArrayList` append operator. More...

template<typename T , std::size_t S>
ArrayList< T, S >	operator+ (ArrayList< T, S > lhs, const typename ArrayList< T, S >::data_type &rhs)
	`ArrayList` add operator. More...

template<typename T >
void	Delete (const T *p, BlockAllocator &allocator)
	Deletes the given pointer by calling the pointed-to object's destructor and returning it to the given allocator. More...

bool	operator== (const BlockAllocator &a, const BlockAllocator &b)
	`BlockAllocator` equality operator. More...

bool	operator!= (const BlockAllocator &a, const BlockAllocator &b)
	`BlockAllocator` inequality operator. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< std::numeric_limits< T >::has_infinity, void >	CheckIfAboveNegInf (T value)
	Checks if the given value is above negative infinity. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t<!std::numeric_limits< T >::has_infinity, void >	CheckIfAboveNegInf (T)
	Checks if the given value is above negative infinity. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< std::numeric_limits< T >::has_infinity, void >	CheckIfBelowPosInf (T value)
	Checks that the given value is below positive infinity. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t<!std::numeric_limits< T >::has_infinity, void >	CheckIfBelowPosInf (T)
	Checks that the given value is below positive infinity. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator== (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value equality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator!= (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value inequality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator<= (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value less-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator>= (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value greater-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator< (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value less-than operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator> (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value greater-than operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator* (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value multiplication operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator/ (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value division operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator+ (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value addition operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator- (const BoundedValue< T, lo, hi > lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value subtraction operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator== (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value equality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator!= (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value inequality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator<= (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value less-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator>= (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value greater-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator< (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value less-than operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator> (const BoundedValue< T, lo, hi > lhs, const T rhs)
	Bounded value greater-than operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator* (const BoundedValue< T, lo, hi > lhs, const U rhs)
	Bounded value multiplication operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator/ (const BoundedValue< T, lo, hi > lhs, const U rhs)
	Bounded value division operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator+ (const BoundedValue< T, lo, hi > lhs, const U rhs)
	Bounded value addition operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator- (const BoundedValue< T, lo, hi > lhs, const U rhs)
	Bounded value subtraction operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator== (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value equality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator!= (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value inequality operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator<= (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value less-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator>= (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value greater-than or equal-to operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator< (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value less-than operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR bool	operator> (const T lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value greater-than operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator* (const U lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value multiplication operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator/ (const U lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value division operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator+ (const U lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value addition operator. More...

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	operator- (const U lhs, const BoundedValue< T, lo, hi > rhs)
	Bounded value subtraction operator. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
::std::ostream &	operator<< (::std::ostream &os, const BoundedValue< T, lo, hi > &value)
	Bounded value stream output operator. More...

void *	Alloc (std::size_t size)
	Allocates memory. More...

void *	Realloc (void *ptr, std::size_t new_size)
	Reallocates memory. More...

void	Free (void *mem)
	Frees memory. More...

template<typename T >
T *	Realloc (T *ptr, std::size_t size)
	Reallocates memory. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator== (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Equality operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator!= (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Inequality operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator< (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Less-than operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator> (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Greater-than operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator<= (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Less-than or equal-to operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	operator>= (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Greater-than or equal-to operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR Fixed< BT, FB >	operator+ (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Addition operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR Fixed< BT, FB >	operator- (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Subtraction operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR Fixed< BT, FB >	operator* (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Multiplication operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR Fixed< BT, FB >	operator/ (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Division operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR Fixed< BT, FB >	operator% (Fixed< BT, FB > lhs, Fixed< BT, FB > rhs) noexcept
	Modulo operator. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	AlmostZero (Fixed< BT, FB > value)
	Gets whether a given value is almost zero. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	AlmostEqual (Fixed< BT, FB > x, Fixed< BT, FB > y, int ulp=2)
	Determines whether the given two values are "almost equal". More...

template<typename BT , unsigned int FB>
inline ::std::ostream &	operator<< (::std::ostream &os, const Fixed< BT, FB > &value)
	Output stream operator. More...

PLAYRHO_CONSTEXPR Fixed32	operator+ (Fixed32 lhs, Fixed32 rhs) noexcept
	Addition operator. More...

PLAYRHO_CONSTEXPR Fixed32	operator- (Fixed32 lhs, Fixed32 rhs) noexcept
	Subtraction operator. More...

PLAYRHO_CONSTEXPR Fixed32	operator* (Fixed32 lhs, Fixed32 rhs) noexcept
	Multiplication operator. More...

PLAYRHO_CONSTEXPR Fixed32	operator/ (Fixed32 lhs, Fixed32 rhs) noexcept
	Division operator. More...

PLAYRHO_CONSTEXPR Fixed32	operator% (Fixed32 lhs, Fixed32 rhs) noexcept
	Modulo operator. More...

PLAYRHO_CONSTEXPR bool	operator== (Fixed32 lhs, Fixed32 rhs) noexcept
	Equality operator. More...

PLAYRHO_CONSTEXPR bool	operator!= (Fixed32 lhs, Fixed32 rhs) noexcept
	Inequality operator. More...

PLAYRHO_CONSTEXPR bool	operator<= (Fixed32 lhs, Fixed32 rhs) noexcept
	Less-than or equal-to operator. More...

PLAYRHO_CONSTEXPR bool	operator>= (Fixed32 lhs, Fixed32 rhs) noexcept
	Greater-than or equal-to operator. More...

PLAYRHO_CONSTEXPR bool	operator< (Fixed32 lhs, Fixed32 rhs) noexcept
	Less-than operator. More...

PLAYRHO_CONSTEXPR bool	operator> (Fixed32 lhs, Fixed32 rhs) noexcept
	Greater-than operator. More...

template<>
const char *	GetTypeName< Fixed32 > () noexcept
	Gets the specialized name for the `Fixed32` type. More...

template<typename BT , unsigned int FB, int N = 5>
constexpr Fixed< BT, FB >	abs (Fixed< BT, FB > arg)
	Computes the absolute value. More...

template<typename BT , unsigned int FB>
constexpr Fixed< BT, FB >	pow (Fixed< BT, FB > value, int n)
	Computes the value of the given number raised to the given power. More...

template<typename BT , unsigned int FB>
constexpr Fixed< BT, FB >	trunc (Fixed< BT, FB > arg)
	Truncates the given value. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	nextafter (Fixed< BT, FB > from, Fixed< BT, FB > to) noexcept
	Next after function for Fixed types. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	fmod (Fixed< BT, FB > dividend, Fixed< BT, FB > divisor) noexcept
	Computes the remainder of the division of the given dividend by the given divisor. More...

template<typename BT , unsigned int FB>
auto	sqrt (Fixed< BT, FB > arg)
	Square root's the given value. More...

template<typename BT , unsigned int FB>
bool	isnormal (Fixed< BT, FB > arg)
	Gets whether the given value is normal - i.e. not 0 nor infinite. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	sin (Fixed< BT, FB > arg)
	Computes the sine of the argument for Fixed types. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	cos (Fixed< BT, FB > arg)
	Computes the cosine of the argument for Fixed types. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	atan (Fixed< BT, FB > arg)
	Computes the arc tangent. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	atan2 (Fixed< BT, FB > y, Fixed< BT, FB > x)
	Computes the multi-valued inverse tangent. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	log (Fixed< BT, FB > arg)
	Computes the natural logarithm of the given argument. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	exp (Fixed< BT, FB > arg)
	Computes the Euler number raised to the power of the given argument. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	pow (Fixed< BT, FB > base, Fixed< BT, FB > exponent)
	Computes the value of the base number raised to the power of the exponent. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	hypot (Fixed< BT, FB > x, Fixed< BT, FB > y)
	Computes the square root of the sum of the squares. More...

template<typename BT , unsigned int FB>
Fixed< BT, FB >	round (Fixed< BT, FB > value) noexcept
	Rounds the given value. More...

template<typename BT , unsigned int FB>
bool	signbit (Fixed< BT, FB > value) noexcept
	Determines whether the given value is negative. More...

template<typename BT , unsigned int FB>
PLAYRHO_CONSTEXPR bool	isnan (Fixed< BT, FB > value) noexcept
	Gets whether the given value is not-a-number. More...

template<typename BT , unsigned int FB>
bool	isfinite (Fixed< BT, FB > value) noexcept
	Gets whether the given value is finite. More...

template<typename T >
PLAYRHO_CONSTEXPR T	GetSize (const Interval< T > &v) noexcept
	Gets the size of the given interval. More...

template<typename T >
PLAYRHO_CONSTEXPR T	GetCenter (const Interval< T > &v) noexcept
	Gets the center of the given interval. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsIntersecting (const Interval< T > &a, const Interval< T > &b) noexcept
	Checks whether two value ranges have any intersection/overlap at all. More...

template<typename T >
PLAYRHO_CONSTEXPR Interval< T >	GetIntersection (Interval< T > a, const Interval< T > &b) noexcept
	Gets the intersecting interval of two given ranges. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsEntirelyBefore (const Interval< T > &a, const Interval< T > &b)
	Determines whether the first range is entirely before the second range. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsEntirelyAfter (const Interval< T > &a, const Interval< T > &b)
	Determines whether the first range is entirely after the second range. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsEntirelyEnclosing (const Interval< T > &a, const Interval< T > &b)
	Determines whether the first range entirely encloses the second. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator== (const Interval< T > &a, const Interval< T > &b) noexcept
	Equality operator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator!= (const Interval< T > &a, const Interval< T > &b) noexcept
	Inequality operator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator< (const Interval< T > &lhs, const Interval< T > &rhs) noexcept
	Less-than operator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator<= (const Interval< T > &lhs, const Interval< T > &rhs) noexcept
	Less-than or equal-to operator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator> (const Interval< T > &lhs, const Interval< T > &rhs) noexcept
	Greater-than operator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	operator>= (const Interval< T > &lhs, const Interval< T > &rhs) noexcept
	Greater-than or equal-to operator. More...

template<typename T >
::std::ostream &	operator<< (::std::ostream &os, const Interval< T > &value)
	Output stream operator. More...

Angle	GetDelta (Angle a1, Angle a2) noexcept
	Gets the shortest angular distance to go from angle 1 to angle 2. More...

Length2	ComputeCentroid (const Span< const Length2 > &vertices)
	Computes the centroid of a counter-clockwise array of 3 or more vertices. More...

std::vector< Length2 >	GetCircleVertices (Length radius, unsigned slices, Angle start=0_deg, Real turns=Real{1})
	Gets the vertices for a circle described by the given parameters. More...

NonNegative< Area >	GetAreaOfCircle (Length radius)
	Gets the area of a circle. More...

NonNegative< Area >	GetAreaOfPolygon (Span< const Length2 > vertices)
	Gets the area of a polygon. More...

SecondMomentOfArea	GetPolarMoment (Span< const Length2 > vertices)
	Gets the polar moment of the area enclosed by the given vertices. More...

template<typename T >
PLAYRHO_CONSTEXPR auto &	GetX (T &value)
	Gets the "X" element of the given value - i.e. the first element. More...

template<typename T >
PLAYRHO_CONSTEXPR auto &	GetY (T &value)
	Gets the "Y" element of the given value - i.e. the second element. More...

template<typename T >
PLAYRHO_CONSTEXPR auto &	GetZ (T &value)
	Gets the "Z" element of the given value - i.e. the third element. More...

template<typename T >
PLAYRHO_CONSTEXPR auto	GetX (const T &value)
	Gets the "X" element of the given value - i.e. the first element. More...

template<typename T >
PLAYRHO_CONSTEXPR auto	GetY (const T &value)
	Gets the "Y" element of the given value - i.e. the second element. More...

template<typename T >
PLAYRHO_CONSTEXPR auto	GetZ (const T &value)
	Gets the "Z" element of the given value - i.e. the third element. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_signed< T >::value, std::make_unsigned_t< T > >	MakeUnsigned (const T &arg) noexcept
	Makes the given value into an unsigned value. More...

template<typename T , LoValueCheck lo, HiValueCheck hi>
PLAYRHO_CONSTEXPR auto	StripUnit (const BoundedValue< T, lo, hi > &v)
	Strips the unit from the given value. More...

template<typename T , typename U >
PLAYRHO_CONSTEXPR U	Secant (T target, U a1, T s1, U a2, T s2) noexcept
	Secant method. More...

template<typename T >
PLAYRHO_CONSTEXPR T	Bisect (T a1, T a2) noexcept
	Bisection method. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsOdd (T val) noexcept
	Is-odd. More...

template<class TYPE >
PLAYRHO_CONSTEXPR auto	Square (TYPE t) noexcept
	Squares the given value. More...

template<typename T >
auto	Atan2 (T y, T x)
	Computes the arc-tangent of the given y and x values. More...

template<typename T , typename = std::enable_if_t< IsIterable<T>::value && IsAddable<decltype(*begin(std::declval<T>()))>::value>
auto	Average (const T &span)
	Computes the average of the given values. More...

template<typename T >
std::enable_if_t< IsArithmetic< T >::value, T >	RoundOff (T value, unsigned precision=100000)
	Computes the rounded value of the given value. More...

Vec2	RoundOff (Vec2 value, std::uint32_t precision=100000)
	Computes the rounded value of the given value. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR Vector< T, N >	abs (const Vector< T, N > &v) noexcept
	Absolute value function for vectors. More...

d2::UnitVec	abs (const d2::UnitVec &v) noexcept
	Gets the absolute value of the given value. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_arithmetic< T >::value, bool >	AlmostZero (T value)
	Gets whether a given value is almost zero. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_floating_point< T >::value, bool >	AlmostEqual (T x, T y, int ulp=2)
	Determines whether the given two values are "almost equal". More...

template<typename T >
auto	ModuloViaFmod (T dividend, T divisor) noexcept
	Modulo operation using `std::fmod`. More...

template<typename T >
auto	ModuloViaTrunc (T dividend, T divisor) noexcept
	Modulo operation using `std::trunc`. More...

Angle	GetNormalized (Angle value) noexcept
	Gets the "normalized" value of the given angle. More...

template<class T >
Angle	GetAngle (const Vector2< T > value)
	Gets the angle. More...

template<typename T >
PLAYRHO_CONSTEXPR auto	GetMagnitudeSquared (T value) noexcept
	Gets the square of the magnitude of the given iterable value. More...

template<typename T >
auto	GetMagnitude (T value)
	Gets the magnitude of the given value. More...

template<typename T1 , typename T2 >
PLAYRHO_CONSTEXPR auto	Dot (const T1 a, const T2 b) noexcept
	Performs the dot product on two vectors (A and B). More...

template<class T1 , class T2 , std::enable_if_t< std::tuple_size< T1 >::value==2 &&std::tuple_size< T2 >::value==2, int > = 0>
PLAYRHO_CONSTEXPR auto	Cross (T1 a, T2 b) noexcept
	Performs the 2-element analog of the cross product of two vectors. More...

template<typename T , typename U >
PLAYRHO_CONSTEXPR auto	Solve (const Matrix22< U > mat, const Vector2< T > b) noexcept
	Solves A * x = b, where b is a column vector. More...

template<class IN_TYPE >
PLAYRHO_CONSTEXPR auto	Invert (const Matrix22< IN_TYPE > value) noexcept
	Inverts the given value. More...

PLAYRHO_CONSTEXPR Vec3	Solve33 (const Mat33 &mat, const Vec3 b) noexcept
	Solves A * x = b, where b is a column vector. More...

template<typename T >
PLAYRHO_CONSTEXPR T	Solve22 (const Mat33 &mat, const T b) noexcept
	Solves A * x = b, where b is a column vector. More...

PLAYRHO_CONSTEXPR Mat33	GetInverse22 (const Mat33 &value) noexcept
	Gets the inverse of the given matrix as a 2-by-2. More...

PLAYRHO_CONSTEXPR Mat33	GetSymInverse33 (const Mat33 &value) noexcept
	Gets the symmetric inverse of this matrix as a 3-by-3. More...

template<class T >
PLAYRHO_CONSTEXPR auto	GetRevPerpendicular (const T vector) noexcept
	Gets a vector counter-clockwise (reverse-clockwise) perpendicular to the given vector. More...

template<class T >
PLAYRHO_CONSTEXPR auto	GetFwdPerpendicular (const T vector) noexcept
	Gets a vector clockwise (forward-clockwise) perpendicular to the given vector. More...

template<std::size_t M, typename T1 , std::size_t N, typename T2 >
PLAYRHO_CONSTEXPR auto	Transform (const Vector< T1, M > v, const Matrix< T2, M, N > &m) noexcept
	Multiplies an M-element vector by an M-by-N matrix. More...

PLAYRHO_CONSTEXPR Vec2	Transform (const Vec2 v, const Mat33 &A) noexcept
	Multiplies a vector by a matrix. More...

PLAYRHO_CONSTEXPR Vec2	InverseTransform (const Vec2 v, const Mat22 &A) noexcept

PLAYRHO_CONSTEXPR Mat22	MulT (const Mat22 &A, const Mat22 &B) noexcept
	Computes A^T * B. More...

Mat22	abs (const Mat22 &A)
	Gets the absolute value of the given value. More...

std::uint64_t	NextPowerOfTwo (std::uint64_t x)
	Gets the next largest power of 2. More...

Real	Normalize (Vec2 &vector)
	Converts the given vector into a unit vector and returns its original length. More...

template<typename T >
PLAYRHO_CONSTEXPR T	GetModuloNext (T value, T count) noexcept
	Gets the modulo next value. More...

template<typename T >
PLAYRHO_CONSTEXPR T	GetModuloPrev (T value, T count) noexcept
	Gets the modulo previous value. More...

PLAYRHO_CONSTEXPR Angle	GetRevRotationalAngle (Angle a1, Angle a2) noexcept

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector< T >::value, Matrix< T, N, N > >	GetIdentityMatrix ()
	Gets the identity matrix of the template type and size. More...

template<typename T >
PLAYRHO_CONSTEXPR std::enable_if_t< IsSquareMatrix< T >::value, T >	GetIdentity ()
	Gets the identity matrix of the template type and size as given by the argument. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector< T >::value, Vector< Vector< T, N >, 1 > >	GetRowMatrix (Vector< T, N > arg)
	Gets the specified row of the given matrix as a row matrix. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector< T >::value, Vector< Vector< T, 1 >, N > >	GetColumnMatrix (Vector< T, N > arg)
	Gets the specified column of the given matrix as a column matrix. More...

template<typename T , std::size_t M, std::size_t N>
PLAYRHO_CONSTEXPR auto	operator+ (const Matrix< T, M, N > &lhs, const Matrix< T, M, N > &rhs) noexcept
	Matrix addition operator for two same-type, same-sized matrices. More...

template<typename T , std::size_t M, std::size_t N>
PLAYRHO_CONSTEXPR auto	operator- (const Matrix< T, M, N > &lhs, const Matrix< T, M, N > &rhs) noexcept
	Matrix subtraction operator for two same-type, same-sized matrices. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const Mat22 &value) noexcept
	Determines if the given value is valid. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Position &value) noexcept
	Determines if the given value is valid. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Sweep &value) noexcept
	Determines if the given value is valid. More...

template<class... T>
void	NOT_USED (T &&...)
	"Not used" annotator. More...

template<typename T >
PLAYRHO_CONSTEXPR bool	IsValid (const T &value) noexcept
	Determines if the given value is valid. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const std::size_t &value) noexcept
	Determines if the given value is valid. More...

template<class T >
const PLAYRHO_CONSTEXPR T *	GetPtr (const T *value) noexcept
	Gets a pointer for the given variable. More...

template<class T >
PLAYRHO_CONSTEXPR T *	GetPtr (T *value) noexcept
	Gets a pointer for the given variable. More...

template<class T >
const PLAYRHO_CONSTEXPR T *	GetPtr (const T &value) noexcept
	Gets a pointer for the given variable. More...

template<class T >
PLAYRHO_CONSTEXPR T *	GetPtr (T &value) noexcept
	Gets a pointer for the given variable. More...

template<class T >
const PLAYRHO_CONSTEXPR T &	GetRef (const T *value) noexcept
	Gets a reference for the given variable. More...

template<class T >
PLAYRHO_CONSTEXPR T &	GetRef (T *value) noexcept
	Gets a reference for the given variable. More...

template<class T >
const PLAYRHO_CONSTEXPR T &	GetRef (const T &value) noexcept
	Gets a reference for the given variable. More...

template<class T >
PLAYRHO_CONSTEXPR T &	GetRef (T &value) noexcept
	Gets a reference for the given variable. More...

template<typename T >
bool	Visit (const T &, void *)
	Template function for visiting objects. More...

template<typename T >
const char *	GetTypeName () noexcept
	Gets the library defined name for the given type. More...

template<>
const char *	GetTypeName< float > () noexcept
	Gets a human recognizable name for the float type. More...

template<>
const char *	GetTypeName< double > () noexcept
	Gets a human recognizable name for the double type. More...

template<>
const char *	GetTypeName< long double > () noexcept
	Gets a human recognizable name for the long double type. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Transformation &value) noexcept
	Determines if the given value is valid. More...

PLAYRHO_CONSTEXPR Mass	operator""_g (unsigned long long int v) noexcept
	SI unit symbol for a gram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_g (long double v) noexcept
	SI unit symbol for a gram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_kg (unsigned long long int v) noexcept
	SI unit symbol for a kilogram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_kg (long double v) noexcept
	SI unit symbol for a kilogram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_Pg (unsigned long long int v) noexcept
	SI unit symbol for a petagram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_Pg (long double v) noexcept
	SI unit symbol for a petagram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_Yg (unsigned long long int v) noexcept
	SI unit symbol for a yottagram unit of Mass. More...

PLAYRHO_CONSTEXPR Mass	operator""_Yg (long double v) noexcept
	SI unit symbol for a yottagram unit of Mass. More...

PLAYRHO_CONSTEXPR Length	operator""_m (unsigned long long int v) noexcept
	SI unit symbol for a meter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_m (long double v) noexcept
	SI unit symbol for a meter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_dm (unsigned long long int v) noexcept
	SI unit symbol for a decimeter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_dm (long double v) noexcept
	SI unit symbol for a decimeter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_cm (unsigned long long int v) noexcept
	SI unit symbol for a centimeter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_cm (long double v) noexcept
	SI unit symbol for a centimeter of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_Gm (unsigned long long int v) noexcept
	SI unit symbol for a gigameter unit of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_Gm (long double v) noexcept
	SI unit symbol for a gigameter unit of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_Mm (unsigned long long int v) noexcept
	SI unit symbol for a megameter unit of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_Mm (long double v) noexcept
	SI unit symbol for a megameter unit of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_km (unsigned long long int v) noexcept
	SI symbol for a kilometer unit of Length. More...

PLAYRHO_CONSTEXPR Length	operator""_km (long double v) noexcept
	SI symbol for a kilometer unit of Length. More...

PLAYRHO_CONSTEXPR Time	operator""_s (unsigned long long int v) noexcept
	SI symbol for a second unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_s (long double v) noexcept
	SI symbol for a second unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_min (unsigned long long int v) noexcept
	SI symbol for a minute unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_min (long double v) noexcept
	SI symbol for a minute unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_h (unsigned long long int v) noexcept
	Symbol for an hour unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_h (long double v) noexcept
	Symbol for an hour unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_d (unsigned long long int v) noexcept
	Symbol for a day unit of Time. More...

PLAYRHO_CONSTEXPR Time	operator""_d (long double v) noexcept
	Symbol for a day unit of Time. More...

PLAYRHO_CONSTEXPR Angle	operator""_rad (unsigned long long int v) noexcept
	SI symbol for a radian unit of Angle. More...

PLAYRHO_CONSTEXPR Angle	operator""_rad (long double v) noexcept
	SI symbol for a radian unit of Angle. More...

PLAYRHO_CONSTEXPR Angle	operator""_deg (unsigned long long int v) noexcept
	Abbreviation for a degree unit of Angle. More...

PLAYRHO_CONSTEXPR Angle	operator""_deg (long double v) noexcept
	Abbreviation for a degree unit of Angle. More...

PLAYRHO_CONSTEXPR Force	operator""_N (unsigned long long int v) noexcept
	SI symbol for a newton unit of Force. More...

PLAYRHO_CONSTEXPR Force	operator""_N (long double v) noexcept
	SI symbol for a newton unit of Force. More...

PLAYRHO_CONSTEXPR Area	operator""_m2 (unsigned long long int v) noexcept
	Abbreviation for meter squared unit of Area. More...

PLAYRHO_CONSTEXPR Area	operator""_m2 (long double v) noexcept
	Abbreviation for meter squared unit of Area. More...

PLAYRHO_CONSTEXPR LinearVelocity	operator""_mps (unsigned long long int v) noexcept
	Abbreviation for meter per second. More...

PLAYRHO_CONSTEXPR LinearVelocity	operator""_mps (long double v) noexcept
	Abbreviation for meter per second. More...

PLAYRHO_CONSTEXPR LinearVelocity	operator""_kps (unsigned long long int v) noexcept
	Abbreviation for kilometer per second. More...

PLAYRHO_CONSTEXPR LinearVelocity	operator""_kps (long double v) noexcept
	Abbreviation for kilometer per second. More...

PLAYRHO_CONSTEXPR LinearAcceleration	operator""_mps2 (unsigned long long int v) noexcept
	Abbreviation for meter per second squared. More...

PLAYRHO_CONSTEXPR LinearAcceleration	operator""_mps2 (long double v) noexcept
	Abbreviation for meter per second squared. More...

PLAYRHO_CONSTEXPR Frequency	operator""_Hz (unsigned long long int v) noexcept
	SI symbol for a hertz unit of Frequency. More...

PLAYRHO_CONSTEXPR Frequency	operator""_Hz (long double v) noexcept
	SI symbol for a hertz unit of Frequency. More...

PLAYRHO_CONSTEXPR Torque	operator""_Nm (unsigned long long int v) noexcept
	Abbreviation for newton-meter unit of torque. More...

PLAYRHO_CONSTEXPR Torque	operator""_Nm (long double v) noexcept
	Abbreviation for newton-meter unit of torque. More...

PLAYRHO_CONSTEXPR Momentum	operator""_Ns (unsigned long long int v) noexcept
	SI symbol for a newton second of impulse. More...

PLAYRHO_CONSTEXPR Momentum	operator""_Ns (long double v) noexcept
	SI symbol for a newton second of impulse. More...

PLAYRHO_CONSTEXPR AreaDensity	operator""_kgpm2 (unsigned long long int v) noexcept
	Abbreviation for kilogram per square meter. More...

PLAYRHO_CONSTEXPR AreaDensity	operator""_kgpm2 (long double v) noexcept
	Abbreviation for kilogram per square meter. More...

PLAYRHO_CONSTEXPR AngularVelocity	operator""_rpm (unsigned long long int v) noexcept
	Abbreviation for revolutions per minute. More...

PLAYRHO_CONSTEXPR AngularVelocity	operator""_rpm (long double v) noexcept
	Abbreviation for revolutions per minute. More...

PLAYRHO_CONSTEXPR Real	StripUnit (const Real value)
	Strips the units off of the given value. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::UnitVec &value) noexcept
	Determines if the given value is valid. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR bool	operator== (const Vector< T, N > &lhs, const Vector< T, N > &rhs) noexcept
	Equality operator. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR bool	operator!= (const Vector< T, N > &lhs, const Vector< T, N > &rhs) noexcept
	Inequality operator. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(+T{})>::value, Vector< T, N > >	operator+ (Vector< T, N > v) noexcept
	Unary plus operator. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(-T{})>::value, Vector< T, N > >	operator- (Vector< T, N > v) noexcept
	Unary negation operator. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{}+T{})>::value, Vector< T, N > & >	operator+= (Vector< T, N > &lhs, const Vector< T, N > rhs) noexcept
	Increments the left hand side value by the right hand side value. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{} - T{})>::value, Vector< T, N > & >	operator-= (Vector< T, N > &lhs, const Vector< T, N > rhs) noexcept
	Decrements the left hand side value by the right hand side value. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{}+T{})>::value, Vector< T, N > >	operator+ (Vector< T, N > lhs, const Vector< T, N > rhs) noexcept
	Adds two vectors component-wise. More...

template<typename T , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{} - T{})>::value, Vector< T, N > >	operator- (Vector< T, N > lhs, const Vector< T, N > rhs) noexcept
	Subtracts two vectors component-wise. More...

template<typename T1 , typename T2 , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T1, decltype(T1{} *T2{})>::value, Vector< T1, N > & >	operator*= (Vector< T1, N > &lhs, const T2 rhs) noexcept
	Multiplication assignment operator. More...

template<typename T1 , typename T2 , std::size_t N>
PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T1, decltype(T1{}/T2{})>::value, Vector< T1, N > & >	operator/= (Vector< T1, N > &lhs, const T2 rhs) noexcept
	Division assignment operator. More...

template<typename T1 , typename T2 , std::size_t A, std::size_t B, std::size_t C, typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value, Vector< Vector< OT, C >, A > >	operator* (const Vector< Vector< T1, B >, A > &lhs, const Vector< Vector< T2, C >, B > &rhs) noexcept
	Calculates the matrix product of the two given vector of vectors (matrices). More...

template<typename T1 , typename T2 , std::size_t A, std::size_t B, typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T1 >::value, Vector< OT, B > >	operator* (const Vector< T1, A > &lhs, const Vector< Vector< T2, B >, A > &rhs) noexcept
	Multiplies an A-element vector by a A-by-B vector of vectors. More...

template<typename T1 , typename T2 , std::size_t A, std::size_t B, typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T2 >::value, Vector< OT, B > >	operator* (const Vector< Vector< T1, A >, B > &lhs, const Vector< T2, A > &rhs) noexcept
	Multiplies a B-by-A vector of vectors by an A-element vector. More...

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T1 >::value, Vector< OT, N > >	operator* (const T1 s, Vector< T2, N > a) noexcept
	Multiplication operator for non-vector times vector. More...

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T2 >::value, Vector< OT, N > >	operator* (Vector< T1, N > a, const T2 s) noexcept
	Multiplication operator for vector times non-vector. More...

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} / T2{})>
PLAYRHO_CONSTEXPR std::enable_if_t< IsDivisable< T1, T2 >::value &&!IsVector< T2 >::value, Vector< OT, N > >	operator/ (Vector< T1, N > a, const T2 s) noexcept
	Division operator. More...

template<std::size_t I, std::size_t N, typename T >
PLAYRHO_CONSTEXPR auto &	get (Vector< T, N > &v) noexcept
	Gets the specified element of the given collection. More...

template<std::size_t I, std::size_t N, typename T >
PLAYRHO_CONSTEXPR auto	get (const Vector< T, N > &v) noexcept
	Gets the specified element of the given collection. More...

template<typename T , std::size_t N>
::std::ostream &	operator<< (::std::ostream &os, const Vector< T, N > &value)
	Output stream operator. More...

PLAYRHO_CONSTEXPR Vec2	GetVec2 (const Vector2< Real > value)
	Gets the given value as a 2-element vector of reals (`Vec2`). More...

template<typename TYPE >
PLAYRHO_CONSTEXPR bool	IsValid (const Vector2< TYPE > &value) noexcept
	Determines whether the given vector contains finite coordinates. More...

template<>
PLAYRHO_CONSTEXPR bool	IsValid (const d2::Velocity &value) noexcept
	Determines if the given value is valid. More...

Version	GetVersion () noexcept
	Gets the version information of the library. More...

std::string	GetBuildDetails () noexcept
	Gets the build details of the library. More...

PLAYRHO_CONSTEXPR bool	operator== (Version lhs, Version rhs)
	Equality operator. More...

PLAYRHO_CONSTEXPR bool	operator!= (Version lhs, Version rhs)
	Inequality operator. More...

Real	MixFriction (Real friction1, Real friction2)
	Mixes friction. More...

Real	MixRestitution (Real restitution1, Real restitution2) noexcept
	Mixes restitution. More...

PLAYRHO_CONSTEXPR bool	operator== (const ContactKey lhs, const ContactKey rhs) noexcept
	Equality operator. More...

PLAYRHO_CONSTEXPR bool	operator!= (const ContactKey lhs, const ContactKey rhs) noexcept
	Inequality operator. More...

PLAYRHO_CONSTEXPR bool	operator< (const ContactKey lhs, const ContactKey rhs) noexcept
	Less-than operator. More...

PLAYRHO_CONSTEXPR bool	operator<= (const ContactKey lhs, const ContactKey rhs) noexcept
	Less-than or equal-to operator. More...

PLAYRHO_CONSTEXPR bool	operator> (const ContactKey lhs, const ContactKey rhs) noexcept
	Greater-than operator. More...

PLAYRHO_CONSTEXPR bool	operator>= (const ContactKey lhs, const ContactKey rhs) noexcept
	Greater-than or equal-to operator. More...

ConstraintSolverConf	GetRegConstraintSolverConf (const StepConf &conf) noexcept
	Gets the regular phase constraint solver configuration for the given step configuration. More...

ConstraintSolverConf	GetToiConstraintSolverConf (const StepConf &conf) noexcept
	Gets the TOI phase constraint solver configuration for the given step configuration. More...

ConstraintSolverConf	GetDefaultPositionSolverConf ()
	Gets the default position solver configuration. More...

ConstraintSolverConf	GetDefaultToiPositionSolverConf ()
	Gets the default TOI position solver configuration. More...

PLAYRHO_CONSTEXPR bool	operator== (const Filter lhs, const Filter rhs) noexcept
	Equality operator. More...

PLAYRHO_CONSTEXPR bool	operator!= (const Filter lhs, const Filter rhs) noexcept
	Inequality operator. More...

bool	ShouldCollide (const Filter filterA, const Filter filterB) noexcept
	Determines whether collision processing should be performed. More...

PLAYRHO_CONSTEXPR bool	operator== (const FixtureProxy &lhs, const FixtureProxy &rhs) noexcept
	Equality operator. More...

PLAYRHO_CONSTEXPR bool	operator!= (const FixtureProxy &lhs, const FixtureProxy &rhs) noexcept
	Inequality operator. More...

MovementConf	GetMovementConf (const StepConf &conf) noexcept
	Gets the movement configuration from the given value. More...

bool	IsMaxTranslationWithinTolerance (const StepConf &conf) noexcept
	Determines whether the maximum translation is within tolerance. More...

Length	GetMaxRegLinearCorrection (const StepConf &conf) noexcept
	Gets the maximum regular linear correction from the given value. More...

RegStepStats &	Update (RegStepStats &lhs, const IslandStats &rhs) noexcept
	Updates the given regular step statistics. More...

Variables
const PLAYRHO_CONSTEXPR auto	InvalidIndexPair
	Invalid index-pair value. More...

const PLAYRHO_CONSTEXPR auto	InvalidIndexPair3
	Invalid array of three index-pair elements. More...

const PLAYRHO_CONSTEXPR std::size_t	AllocatorBlockSizes []
	Allocator block sizes array data. More...

const PLAYRHO_CONSTEXPR auto	Pi = Real(3.14159265358979323846264338327950288)
	Pi. More...

const PLAYRHO_CONSTEXPR auto	SquareRootTwo
	Square root of two. More...

const PLAYRHO_CONSTEXPR auto	Centi = Real(1e-2)
	Centi- (1 x 10^-2). More...

const PLAYRHO_CONSTEXPR auto	Deci = Real(1e-1)
	Deci- (1 x 10^-1). More...

const PLAYRHO_CONSTEXPR auto	Kilo = Real(1e3)
	Kilo- (1 x 10^3). More...

const PLAYRHO_CONSTEXPR auto	Mega = Real(1e6)
	Mega- (1 x 10^6). More...

const PLAYRHO_CONSTEXPR auto	Giga = Real(1e9)
	Giga- (1 x 10^9). More...

const PLAYRHO_CONSTEXPR auto	Tera = Real(1e12)
	Tera- (1 x 10^12). More...

const PLAYRHO_CONSTEXPR auto	Peta = Real(1e15)
	Peta- (1 x 10^15). More...

const PLAYRHO_CONSTEXPR auto	Yotta = Real(1e24)
	Yotta- (1 x 10^24). More...

const PLAYRHO_CONSTEXPR auto	MaxSimplexEdges = std::uint8_t{3}
	Maximum number of supportable edges in a simplex. More...

const PLAYRHO_CONSTEXPR auto	MaxChildCount = std::numeric_limits<std::uint32_t>::max() >> 6
	Max child count. More...

const PLAYRHO_CONSTEXPR auto	MaxFloat = std::numeric_limits<Real>::max()
	Maximum float value. More...

const PLAYRHO_CONSTEXPR auto	MaxManifoldPoints = std::uint8_t{2}

const PLAYRHO_CONSTEXPR auto	MaxShapeVertices = std::uint8_t{254}
	Maximum number of vertices for any shape type. More...

const PLAYRHO_CONSTEXPR auto	InvalidVertex = static_cast<VertexCounter>(-1)
	Invalid vertex index. More...

const PLAYRHO_CONSTEXPR auto	DefaultLinearSlop = detail::Defaults<Real>::GetLinearSlop()
	Default linear slop. More...

const PLAYRHO_CONSTEXPR auto	DefaultMinVertexRadius = DefaultLinearSlop * Real{2}
	Default minimum vertex radius. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxVertexRadius = detail::Defaults<Real>::GetMaxVertexRadius()
	Default maximum vertex radius. More...

const PLAYRHO_CONSTEXPR auto	DefaultAabbExtension = DefaultLinearSlop * Real{20}
	Default AABB extension amount. More...

const PLAYRHO_CONSTEXPR auto	DefaultDistanceMultiplier = Real{2}
	Default distance multiplier. More...

const PLAYRHO_CONSTEXPR auto	DefaultAngularSlop = (Pi * 2_rad) / Real{180}
	Default angular slop. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxLinearCorrection = 0.2_m
	Default maximum linear correction. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxAngularCorrection = Real(8.0f / 180.0f) * Pi * 1_rad
	Default maximum angular correction. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxTranslation = 2_m
	Default maximum translation amount. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxRotation = Angle{Pi * 1_rad / Real(2)}
	Default maximum rotation per world step. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxToiIters = std::uint8_t{20}
	Default maximum time of impact iterations. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxToiRootIters = std::uint8_t{30}
	Default maximum time of impact root iterator count. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxDistanceIters = std::uint8_t{20}
	Default max number of distance iterations. More...

const PLAYRHO_CONSTEXPR auto	DefaultMaxSubSteps = std::uint8_t{8}

const PLAYRHO_CONSTEXPR auto	DefaultVelocityThreshold = 1_mps
	Default velocity threshold. More...

const PLAYRHO_CONSTEXPR auto	DefaultRegMinMomentum = Momentum{0_Ns / 100}
	Default regular-phase minimum momentum. More...

const PLAYRHO_CONSTEXPR auto	DefaultToiMinMomentum = Momentum{0_Ns / 100}
	Default TOI-phase minimum momentum. More...

const PLAYRHO_CONSTEXPR auto	MaxBodies
	Maximum number of bodies in a world. More...

const PLAYRHO_CONSTEXPR auto	InvalidContactIndex = static_cast<ContactCounter>(-1)
	Invalid contact index. More...

const PLAYRHO_CONSTEXPR auto	MaxContacts = ContactCounter{MaxBodies} * ContactCounter{MaxBodies - 1} / ContactCounter{2}
	Maximum number of contacts in a world (2147319811). More...

const PLAYRHO_CONSTEXPR auto	MaxJoints
	Maximum number of joints in a world. More...

const PLAYRHO_CONSTEXPR auto	DefaultStepTime = Time{1_s / 60}
	Default step time. More...

const PLAYRHO_CONSTEXPR auto	DefaultStepFrequency = 60_Hz
	Default step frequency. More...

const PLAYRHO_CONSTEXPR auto	DefaultMinStillTimeToSleep = Time{1_s / 2}

const PLAYRHO_CONSTEXPR auto	DefaultLinearSleepTolerance = 0.01_mps

const PLAYRHO_CONSTEXPR auto	DefaultAngularSleepTolerance = Real{(Pi * 2) / 180} * RadianPerSecond

const PLAYRHO_CONSTEXPR auto	DefaultCirclesRatio = Real{10}

const PLAYRHO_CONSTEXPR auto	Second = PLAYRHO_UNIT(Time, boost::units::si::second)
	Second unit of time. More...

const PLAYRHO_CONSTEXPR auto	SquareSecond = Second * Second
	Square second unit. More...

const PLAYRHO_CONSTEXPR auto	Hertz = PLAYRHO_UNIT(Frequency, boost::units::si::hertz)
	Hertz unit of Frequency. More...

const PLAYRHO_CONSTEXPR auto	Meter = PLAYRHO_UNIT(Length, boost::units::si::meter)
	Meter unit of Length. More...

const PLAYRHO_CONSTEXPR auto	MeterPerSecond
	Meter per second unit of linear velocity. More...

const PLAYRHO_CONSTEXPR auto	MeterPerSquareSecond
	Meter per square second unit of linear acceleration. More...

const PLAYRHO_CONSTEXPR auto	Kilogram = PLAYRHO_UNIT(Mass, boost::units::si::kilogram)
	Kilogram unit of mass. More...

const PLAYRHO_CONSTEXPR auto	SquareMeter = PLAYRHO_UNIT(Area, boost::units::si::square_meter)
	Square meter unit of area. More...

const PLAYRHO_CONSTEXPR auto	CubicMeter = Meter * Meter * Meter
	Cubic meter unit of volume. More...

const PLAYRHO_CONSTEXPR auto	KilogramPerSquareMeter
	Kilogram per square meter unit of area density. More...

const PLAYRHO_CONSTEXPR auto	Radian = PLAYRHO_UNIT(Angle, boost::units::si::radian)
	Radian unit of angle. More...

const PLAYRHO_CONSTEXPR auto	Degree = Angle{Radian * Pi / Real{180}}
	Degree unit of angle quantity. More...

const PLAYRHO_CONSTEXPR auto	SquareRadian = Radian * Radian
	Square radian unit type. More...

const PLAYRHO_CONSTEXPR auto	RadianPerSecond
	Radian per second unit of angular velocity. More...

const PLAYRHO_CONSTEXPR auto	DegreePerSecond = AngularVelocity{RadianPerSecond * Degree / Radian}
	Degree per second unit of angular velocity. More...

const PLAYRHO_CONSTEXPR auto	RadianPerSquareSecond = Radian / (Second * Second)
	Radian per square second unit of angular acceleration. More...

const PLAYRHO_CONSTEXPR auto	DegreePerSquareSecond = Degree / (Second * Second)
	Degree per square second unit of angular acceleration. More...

const PLAYRHO_CONSTEXPR auto	Newton = PLAYRHO_UNIT(Force, boost::units::si::newton)
	Newton unit of force. More...

const PLAYRHO_CONSTEXPR auto	NewtonMeter = PLAYRHO_UNIT(Torque, boost::units::si::newton_meter)
	Newton meter unit of torque. More...

const PLAYRHO_CONSTEXPR auto	NewtonSecond = Newton * Second
	Newton second unit of momentum. More...

const PLAYRHO_CONSTEXPR auto	NewtonMeterSecond = NewtonMeter * Second
	Newton meter second unit of angular momentum. More...

const PLAYRHO_CONSTEXPR auto	RevolutionsPerMinute = 2 * Pi * Radian / (Real{60} * Second)
	Revolutions per minute units of angular velocity. More...

const PLAYRHO_CONSTEXPR auto	EarthlyLinearAcceleration = Real{-9.8f} * MeterPerSquareSecond
	Earthly gravity. More...

const PLAYRHO_CONSTEXPR auto	BigG = Real{6.67408e-11f} * CubicMeter / (Kilogram * SquareSecond)
	Big "G". More...

Detailed Description

Name space for all PlayRho related names.

Typedef Documentation

◆ PairLength2

using playrho::PairLength2 = typedef std::pair<Length2, Length2>

Pair of Length2 values.

Note: Uses std::pair because this is a pair and also because std::pair has more support for constant expressions.

Definition at line 31 of file Distance.hpp.

◆ IndexPair

using playrho::IndexPair = typedef std::pair<VertexCounter, VertexCounter>

Index pair.

Note: This data structure is at least 2-bytes large.; Using std::array would make more sense if it weren't for the fact that std::pair, but not std::array, has constexpr equality and inequality operators.

Definition at line 36 of file IndexPair.hpp.

◆ IndexPair3

using playrho::IndexPair3 = typedef std::array<IndexPair, MaxSimplexEdges>

Array of three index-pair elements.

Note: An element having the InvalidIndexPair value, denotes an unused or invalid elements.; This data type is 6-bytes large (on at least one 64-bit platform).

Definition at line 47 of file IndexPair.hpp.

◆ VertexCounterArray

template<std::size_t N>

using playrho::VertexCounterArray = typedef std::array<VertexCounter, N>

Vertex counter array template alias.

Definition at line 91 of file IndexPair.hpp.

◆ VertexCounter2

using playrho::VertexCounter2 = typedef VertexCounterArray<2>

2-element vertex counter array.

Definition at line 94 of file IndexPair.hpp.

◆ Fixed32

using playrho::Fixed32 = typedef Fixed<std::int32_t,9>

32-bit fixed precision type.

This is a 32-bit fixed precision type with a Q number-format of Q23.9.

Warning: The available numeric fidelity of any 32-bit fixed point type is very limited. Using a 32-bit fixed point type for Real should only be considered for simulations where it's been found to work and where the dynamics won't be changing between runs.

Note: Maximum value (with 9 fraction bits) is approximately 4194303.99609375.; Minimum value (with 9 fraction bits) is approximately 0.001953125.

See also: Fixed, Real; https://en.wikipedia.org/wiki/Q_(number_format)

Definition at line 709 of file Fixed.hpp.

◆ Matrix

template<typename T , std::size_t M, std::size_t N>

using playrho::Matrix = typedef Vector<Vector<T, N>, M>

Generic M by N matrix.

Note: M is the number of rows of the matrix.; N is the number of columns of the matrix.

See also: https://en.wikipedia.org/wiki/Matrix_(mathematics); Vector, Matrix Traits, IsVector

Definition at line 39 of file Matrix.hpp.

◆ Matrix22

template<typename T >

using playrho::Matrix22 = typedef Matrix<T, 2, 2>

2 by 2 matrix.

Definition at line 178 of file Matrix.hpp.

◆ Matrix33

template<typename T >

using playrho::Matrix33 = typedef Matrix<T, 3, 3>

3 by 3 matrix.

Definition at line 182 of file Matrix.hpp.

◆ Mat22

using playrho::Mat22 = typedef Matrix22<Real>

2 by 2 matrix of Real elements.

Definition at line 185 of file Matrix.hpp.

◆ Mass22

using playrho::Mass22 = typedef Matrix22<Mass>

2 by 2 matrix of Mass elements.

Definition at line 188 of file Matrix.hpp.

◆ InvMass22

using playrho::InvMass22 = typedef Matrix22<InvMass>

2 by 2 matrix of InvMass elements.

Definition at line 191 of file Matrix.hpp.

◆ Mat33

using playrho::Mat33 = typedef Matrix33<Real>

3 by 3 matrix of Real elements.

Definition at line 194 of file Matrix.hpp.

◆ Optional

template<typename T >

using playrho::Optional = typedef OptionalValue<T>

Optional type alias.

An alias setup to facilitate switching between implementations of the optional type idea.

Note: This is meant to be used directly for optional values.

Definition at line 190 of file OptionalValue.hpp.

◆ Real

using playrho::Real = typedef float

Real-number type.

This is the number type underlying numerical calculations conceptually involving real-numbers. Ideally the implementation of this type doesn't suffer from things like: catastrophic cancellation, catastrophic division, overflows, nor underflows.

Note

This can be implemented using any of the fundamental floating point types ( float, double, or long double).

This can also be implemented using a LiteralType that has the necessary support: all common mathematical functions, support for infinity and NaN, and a specialization of the std::numeric_limits class template for it.

At present, the Fixed32 and Fixed64 aliases of the Fixed template type are provided as examples of qualifying literal types though the usability of these are limited and their use is discouraged.

Regarding division:

While dividing 1 by a real, caching the result, and then doing multiplications with the result may well be faster (than repeatedly dividing), dividing 1 by the real can also result in an underflow situation that's then compounded every time it's multiplied with other values.
Meanwhile, dividing every time by a real isolates any underflows to the particular division where underflow occurs.

Warning: Using Fixed32 is not advised as its numerical limitations are more likely to result in problems like overflows or underflows.; The note regarding division applies even more so when using a fixed-point type (for Real).

See also: http://en.cppreference.com/w/cpp/language/types; http://en.cppreference.com/w/cpp/types/is_floating_point; http://en.cppreference.com/w/cpp/concept/LiteralType

Examples: Body.cpp, Contact.cpp, and World.cpp.

Definition at line 69 of file Real.hpp.

◆ ChildCounter

using playrho::ChildCounter = typedef std::remove_const<decltype(MaxChildCount)>::type

Child counter type.

Relating to "children" of shape where each child is a convex shape possibly comprising a concave shape.

Note: This type must always be able to contain the MaxChildCount value.

Examples: World.cpp.

Definition at line 97 of file Settings.hpp.

◆ TimestepIters

using playrho::TimestepIters = typedef std::uint8_t

Time step iterations type.

A type for counting iterations per time-step.

Definition at line 101 of file Settings.hpp.

◆ VertexCounter

using playrho::VertexCounter = typedef std::remove_const<decltype(MaxShapeVertices)>::type

Vertex count type.

Note: This type must not support more than 255 vertices as that would conflict with the ContactFeature::Index type.

Definition at line 122 of file Settings.hpp.

◆ BodyCounter

using playrho::BodyCounter = typedef std::remove_const<decltype(MaxBodies)>::type

Body count type.

Note: This type must always be able to contain the MaxBodies value.

Examples: Body.cpp, and World.cpp.

Definition at line 208 of file Settings.hpp.

◆ ContactCounter

using playrho::ContactCounter = typedef Wider<BodyCounter>::type

Contact count type.

Note: This type must be able to contain the squared value of BodyCounter.

Examples: World.cpp.

Definition at line 212 of file Settings.hpp.

◆ JointCounter

using playrho::JointCounter = typedef std::remove_const<decltype(MaxJoints)>::type

Joint count type.

Note: This type must be able to contain the MaxJoints value.

Examples: World.cpp.

Definition at line 230 of file Settings.hpp.

◆ IsIterable

template<class T >

using playrho::IsIterable = typedef typename detail::IsIterableImpl<T>

Determines whether the given type is an iterable type.

Definition at line 333 of file Templates.hpp.

◆ TupleContainsType

template<typename T , typename Tuple >

using playrho::TupleContainsType = typedef typename HasType<T, Tuple>::type

Tuple contains type alias.

Alias in case the trait itself should be std::true_type or std::false_type.

Note: This is from Piotr Skotnicki's answer on the StackOverflow website to the question of: "How do I find out if a tuple contains a type?".

See also: https://stackoverflow.com/a/25958302/7410358

Definition at line 370 of file Templates.hpp.

◆ Vector2

template<typename T >

using playrho::Vector2 = typedef Vector<T, 2>

Vector with 2-elements.

Note: This is just a C++11 alias template for 2-element uses of the Vector template.

Definition at line 34 of file Vector2.hpp.

◆ Vec2

using playrho::Vec2 = typedef Vector2<Real>

Vector with 2 Real elements.

Note: This data structure is two-times the size of the Real type (or 8 using Real of float).

Examples: Body.cpp, and World.cpp.

Definition at line 39 of file Vector2.hpp.

◆ Length2

using playrho::Length2 = typedef Vector2<Length>

2-element vector of Length quantities.

Note: Often used as a 2-dimensional distance or location vector.

Examples: Body.cpp, and World.cpp.

Definition at line 43 of file Vector2.hpp.

◆ LinearVelocity2

using playrho::LinearVelocity2 = typedef Vector2<LinearVelocity>

2-element vector of linear velocity (LinearVelocity) quantities.

Note: Often used as a 2-dimensional speed vector.

Examples: Body.cpp.

Definition at line 47 of file Vector2.hpp.

◆ LinearAcceleration2

using playrho::LinearAcceleration2 = typedef Vector2<LinearAcceleration>

2-element vector of linear acceleration (LinearAcceleration) quantities.

Note: Often used as a 2-dimensional linear acceleration vector.

Definition at line 51 of file Vector2.hpp.

◆ Force2

using playrho::Force2 = typedef Vector2<Force>

2-element vector of Force quantities.

Note: Often used as a 2-dimensional force vector.

Examples: World.cpp.

Definition at line 55 of file Vector2.hpp.

◆ Mass2

using playrho::Mass2 = typedef Vector2<Mass>

2-element vector of Mass quantities.

Definition at line 58 of file Vector2.hpp.

◆ InvMass2

using playrho::InvMass2 = typedef Vector2<InvMass>

2-element vector of inverse mass (InvMass) quantities.

Definition at line 61 of file Vector2.hpp.

◆ Momentum2

using playrho::Momentum2 = typedef Vector2<Momentum>

2-element vector of Momentum quantities.

Note: Often used as a 2-dimensional momentum vector.

Definition at line 65 of file Vector2.hpp.

◆ Vector3

template<typename T >

using playrho::Vector3 = typedef Vector<T, 3>

Vector with 3-elements.

Note: This is just a C++11 alias template for 3-element uses of the Vector template.

Definition at line 33 of file Vector3.hpp.

◆ Vec3

using playrho::Vec3 = typedef Vector3<Real>

A 3-dimensional column vector with 3 elements.

Note: This data structure is 3 times the size of Real - i.e. 12-bytes (with 4-byte Real).

Definition at line 38 of file Vector3.hpp.

◆ Mass3

using playrho::Mass3 = typedef Vector3<Mass>

3-element vector of Mass quantities.

Definition at line 41 of file Vector3.hpp.

◆ InvMass3

using playrho::InvMass3 = typedef Vector3<InvMass>

3-element vector of inverse mass (InvMass) quantities.

Definition at line 44 of file Vector3.hpp.

Enumeration Type Documentation

◆ PointState

enum playrho::PointState

strong

Point state enumeration.

Note: This is used for determining the state of contact points.

Enumerator
NullState	point does not exist
AddState	point was added in the update
PersistState	point persisted across the update
RemoveState	point was removed in the update

Definition at line 38 of file Collision.hpp.

◆ RayCastOpcode

enum playrho::RayCastOpcode

strong

Ray cast opcode enumeration.

Instructs some ray casting methods on what to do next.

Enumerator
Terminate	End the ray-cast search for fixtures. Use this to stop searching for fixtures.
IgnoreFixture	Ignore the current fixture. Use this to continue searching for fixtures along the ray.
ClipRay	Clip the ray end to the current point. Use this shorten the ray to the current point and to continue searching for fixtures now along the newly shortened ray.
ResetRay	Reset the ray end back to the second point. Use this to restore the ray to its full length and to continue searching for fixtures now along the restored full length ray.

Definition at line 42 of file RayCastOutput.hpp.

◆ LoValueCheck

enum playrho::LoValueCheck

strong

Lo value check.

Enumerator
Any
AboveZero
ZeroOrMore
AboveNegInf
NonZero

Definition at line 35 of file BoundedValue.hpp.

◆ HiValueCheck

enum playrho::HiValueCheck

strong

Hi value check.

Enumerator
Any
BelowZero
ZeroOrLess
OneOrLess
BelowPosInf

Definition at line 45 of file BoundedValue.hpp.

◆ BodyType

enum playrho::BodyType

strong

Body Type.

Note: static: zero mass, zero velocity, may be manually moved; kinematic: zero mass, non-zero velocity set by user, moved by solver; dynamic: positive mass, non-zero velocity determined by forces, moved by solver

Enumerator

Static

Static body type.

Static bodies have no mass, have no forces applied to them, and aren't moved by physical processes. They are impenetrable.

Note: Physics applied: none.

Kinematic

Kinematic body type.

Kinematic bodies have no mass and have no forces applied to them, but can move at set velocities. They are impenetrable.

Note: Physics applied: velocity.

Dynamic

Dynamic body type.

Dynamic bodies are fully simulated bodies. Dynamic bodies always have a positive non-zero mass. They may be penetrable.

Note: Physics applied: velocity, acceleration.

Definition at line 31 of file BodyType.hpp.

Function Documentation

◆ GetInvalid()

template<>

PLAYRHO_CONSTEXPR Vec3 playrho::GetInvalid ( )

inlinenoexcept

Gets an invalid AABB value.

Gets an invalid value for the 3-element vector of real (Vec3) type.

Gets an invalid value for the Vec2 type.

Gets an invalid value for the UnitVec type.

Gets an invalid value for the std::size_t type.

Gets an invalid value for the long double type.

Gets an invalid value for the double type.

Gets an invalid value for the float type.

Gets an invalid value for the type.

Gets an invalid value for a Mat22.

Gets an invalid value.

Definition at line 483 of file AABB.hpp.

◆ GetVertexVertexContactFeature()

PLAYRHO_CONSTEXPR ContactFeature GetVertexVertexContactFeature	(	ContactFeature::Index	a,
		ContactFeature::Index	b
	)

inlinenoexcept

Gets the vertex vertex contact feature for the given indices.

Definition at line 60 of file ContactFeature.hpp.

◆ GetVertexFaceContactFeature()

PLAYRHO_CONSTEXPR ContactFeature GetVertexFaceContactFeature	(	ContactFeature::Index	a,
		ContactFeature::Index	b
	)

inlinenoexcept

Gets the vertex face contact feature for the given indices.

Definition at line 68 of file ContactFeature.hpp.

◆ GetFaceVertexContactFeature()

PLAYRHO_CONSTEXPR ContactFeature GetFaceVertexContactFeature	(	ContactFeature::Index	a,
		ContactFeature::Index	b
	)

inlinenoexcept

Gets the face vertex contact feature for the given indices.

Definition at line 76 of file ContactFeature.hpp.

◆ GetFaceFaceContactFeature()

PLAYRHO_CONSTEXPR ContactFeature GetFaceFaceContactFeature	(	ContactFeature::Index	a,
		ContactFeature::Index	b
	)

inlinenoexcept

Gets the face face contact feature for the given indices.

Definition at line 84 of file ContactFeature.hpp.

◆ Flip()

PLAYRHO_CONSTEXPR ContactFeature Flip ( ContactFeature val )

inlinenoexcept

Flips contact features information.

Definition at line 92 of file ContactFeature.hpp.

◆ operator==() [1/13]

PLAYRHO_CONSTEXPR bool operator==	(	ContactFeature	lhs,
		ContactFeature	rhs
	)

inlinenoexcept

Determines if the given two contact features are equal.

Definition at line 99 of file ContactFeature.hpp.

◆ operator!=() [1/13]

PLAYRHO_CONSTEXPR bool operator!=	(	ContactFeature	lhs,
		ContactFeature	rhs
	)

inlinenoexcept

Determines if the given two contact features are not equal.

Definition at line 107 of file ContactFeature.hpp.

◆ GetName() [1/2]

const char* playrho::GetName ( ContactFeature::Type type )

inlinenoexcept

Gets the human readable name for the given contact feature type.

Definition at line 113 of file ContactFeature.hpp.

◆ operator<<() [1/5]

inline ::std::ostream& playrho::operator<<	(	::std::ostream &	os,
		const ContactFeature &	value
	)

Stream output operator.

Definition at line 124 of file ContactFeature.hpp.

◆ GetNumValidIndices()

PLAYRHO_CONSTEXPR std::size_t playrho::GetNumValidIndices ( IndexPair3 pairs )

inlinenoexcept

Gets the number of valid indices in the given collection of index pairs.

Note: Any element with a value of InvalidIndexPair is interpreted as being invalid in this context.

Returns: Value between 0 and 3 inclusive.

Definition at line 60 of file IndexPair.hpp.

◆ empty()

PLAYRHO_CONSTEXPR bool playrho::empty ( IndexPair3 pairs )

inlinenoexcept

Checks whether the given collection of index pairs is empty.

Definition at line 69 of file IndexPair.hpp.

◆ size()

PLAYRHO_CONSTEXPR auto playrho::size ( IndexPair3 pairs ) -> decltype(GetNumValidIndices(pairs))

inline

Gets the dynamic size of the given collection of index pairs.

Note: This just calls GetNumValidIndices.

See also: GetNumValidIndices

Definition at line 77 of file IndexPair.hpp.

◆ max_size()

PLAYRHO_CONSTEXPR auto playrho::max_size ( IndexPair3 pairs ) -> decltype(pairs.max_size())

inline

Gets the maximum size of the given container of index pairs.

Returns: Always returns 3.

Definition at line 84 of file IndexPair.hpp.

◆ GetFirstShapeVertexIdx()

template<std::size_t N>

VertexCounter playrho::GetFirstShapeVertexIdx ( const detail::SeparationInfo< N > & info )

noexcept

Gets first shape vertex index.

Definition at line 119 of file IndexPair.hpp.

◆ GetSecondShapeVertexIdx()

template<VertexCounter M, std::size_t N>

VertexCounter playrho::GetSecondShapeVertexIdx ( const detail::SeparationInfo< N > & info )

noexcept

Gets second shape vertex indices.

Definition at line 126 of file IndexPair.hpp.

◆ IsValid() [1/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Manifold & value )

inlinenoexcept

Gets whether the given manifold is valid.

Definition at line 620 of file Manifold.hpp.

◆ Visit< d2::Shape >()

template<>

bool playrho::Visit< d2::Shape >	(	const d2::Shape &	shape,
		void *	userData
	)

inline

Visits the given shape with the potentially non-null user data pointer.

Note: This is a specialization of the Visit function template for the d2::Shape class.

See also: https://en.wikipedia.org/wiki/Visitor_pattern

Definition at line 443 of file Shape.hpp.

◆ GetName() [2/2]

const char * playrho::GetName ( TOIOutput::State state )

noexcept

Gets a human readable name for the given output state.

Definition at line 31 of file TimeOfImpact.cpp.

◆ GetToiConf()

ToiConf playrho::GetToiConf ( const StepConf & conf )

noexcept

Gets the time of impact configuration for the given step configuration.

Definition at line 53 of file TimeOfImpact.cpp.

◆ GetDefaultToiConf()

PLAYRHO_CONSTEXPR auto GetDefaultToiConf ( )

inline

Gets the default time of impact configuration.

Definition at line 147 of file TimeOfImpact.hpp.

◆ IsValid() [2/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Acceleration & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 144 of file Acceleration.hpp.

◆ operator+=() [1/2]

template<typename T , std::size_t S>

ArrayList<T, S>& playrho::operator+=	(	ArrayList< T, S > &	lhs,
		const typename ArrayList< T, S >::data_type &	rhs
	)

ArrayList append operator.

Definition at line 170 of file ArrayList.hpp.

◆ operator+() [1/9]

template<typename T , std::size_t S>

ArrayList<T, S> playrho::operator+	(	ArrayList< T, S >	lhs,
		const typename ArrayList< T, S >::data_type &	rhs
	)

ArrayList add operator.

Definition at line 178 of file ArrayList.hpp.

◆ Delete()

template<typename T >

void playrho::Delete	(	const T *	p,
		BlockAllocator &	allocator
	)

inline

Deletes the given pointer by calling the pointed-to object's destructor and returning it to the given allocator.

Definition at line 117 of file BlockAllocator.hpp.

◆ operator==() [2/13]

bool playrho::operator==	(	const BlockAllocator &	a,
		const BlockAllocator &	b
	)

inline

BlockAllocator equality operator.

Definition at line 149 of file BlockAllocator.hpp.

◆ operator!=() [2/13]

bool playrho::operator!=	(	const BlockAllocator &	a,
		const BlockAllocator &	b
	)

inline

BlockAllocator inequality operator.

Definition at line 155 of file BlockAllocator.hpp.

◆ CheckIfAboveNegInf() [1/2]

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<std::numeric_limits<T>::has_infinity, void> playrho::CheckIfAboveNegInf ( T value )

inline

Checks if the given value is above negative infinity.

Definition at line 86 of file BoundedValue.hpp.

◆ CheckIfAboveNegInf() [2/2]

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<!std::numeric_limits<T>::has_infinity, void> playrho::CheckIfAboveNegInf ( T )

inline

Checks if the given value is above negative infinity.

Definition at line 97 of file BoundedValue.hpp.

◆ CheckIfBelowPosInf() [1/2]

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<std::numeric_limits<T>::has_infinity, void> playrho::CheckIfBelowPosInf ( T value )

inline

Checks that the given value is below positive infinity.

Definition at line 105 of file BoundedValue.hpp.

◆ CheckIfBelowPosInf() [2/2]

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<!std::numeric_limits<T>::has_infinity, void> playrho::CheckIfBelowPosInf ( T )

inline

Checks that the given value is below positive infinity.

Definition at line 116 of file BoundedValue.hpp.

◆ operator==() [3/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator==	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value equality operator.

Definition at line 313 of file BoundedValue.hpp.

◆ operator!=() [3/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value inequality operator.

Definition at line 320 of file BoundedValue.hpp.

◆ operator<=() [1/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value less-than or equal-to operator.

Definition at line 329 of file BoundedValue.hpp.

◆ operator>=() [1/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value greater-than or equal-to operator.

Definition at line 336 of file BoundedValue.hpp.

◆ operator<() [1/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value less-than operator.

Definition at line 343 of file BoundedValue.hpp.

◆ operator>() [1/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value greater-than operator.

Definition at line 350 of file BoundedValue.hpp.

◆ operator*() [1/10]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator*	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value multiplication operator.

Definition at line 357 of file BoundedValue.hpp.

◆ operator/() [1/6]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator/	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value division operator.

Definition at line 364 of file BoundedValue.hpp.

◆ operator+() [2/9]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator+	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value addition operator.

Definition at line 371 of file BoundedValue.hpp.

◆ operator-() [1/8]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator-	(	const BoundedValue< T, lo, hi >	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value subtraction operator.

Definition at line 378 of file BoundedValue.hpp.

◆ operator==() [4/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator==	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value equality operator.

Definition at line 387 of file BoundedValue.hpp.

◆ operator!=() [4/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value inequality operator.

Definition at line 394 of file BoundedValue.hpp.

◆ operator<=() [2/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value less-than or equal-to operator.

Definition at line 403 of file BoundedValue.hpp.

◆ operator>=() [2/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value greater-than or equal-to operator.

Definition at line 410 of file BoundedValue.hpp.

◆ operator<() [2/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value less-than operator.

Definition at line 417 of file BoundedValue.hpp.

◆ operator>() [2/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>	(	const BoundedValue< T, lo, hi >	lhs,
		const T	rhs
	)

inline

Bounded value greater-than operator.

Definition at line 424 of file BoundedValue.hpp.

◆ operator*() [2/10]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator*	(	const BoundedValue< T, lo, hi >	lhs,
		const U	rhs
	)

inline

Bounded value multiplication operator.

Definition at line 431 of file BoundedValue.hpp.

◆ operator/() [2/6]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator/	(	const BoundedValue< T, lo, hi >	lhs,
		const U	rhs
	)

inline

Bounded value division operator.

Definition at line 438 of file BoundedValue.hpp.

◆ operator+() [3/9]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator+	(	const BoundedValue< T, lo, hi >	lhs,
		const U	rhs
	)

inline

Bounded value addition operator.

Definition at line 445 of file BoundedValue.hpp.

◆ operator-() [2/8]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator-	(	const BoundedValue< T, lo, hi >	lhs,
		const U	rhs
	)

inline

Bounded value subtraction operator.

Definition at line 452 of file BoundedValue.hpp.

◆ operator==() [5/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator==	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value equality operator.

Definition at line 461 of file BoundedValue.hpp.

◆ operator!=() [5/13]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value inequality operator.

Definition at line 468 of file BoundedValue.hpp.

◆ operator<=() [3/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value less-than or equal-to operator.

Definition at line 477 of file BoundedValue.hpp.

◆ operator>=() [3/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value greater-than or equal-to operator.

Definition at line 484 of file BoundedValue.hpp.

◆ operator<() [3/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator<	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value less-than operator.

Definition at line 491 of file BoundedValue.hpp.

◆ operator>() [3/7]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR bool playrho::operator>	(	const T	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value greater-than operator.

Definition at line 498 of file BoundedValue.hpp.

◆ operator*() [3/10]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator*	(	const U	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value multiplication operator.

Definition at line 505 of file BoundedValue.hpp.

◆ operator/() [3/6]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator/	(	const U	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value division operator.

Definition at line 512 of file BoundedValue.hpp.

◆ operator+() [4/9]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator+	(	const U	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value addition operator.

Definition at line 519 of file BoundedValue.hpp.

◆ operator-() [3/8]

template<typename T , typename U , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::operator-	(	const U	lhs,
		const BoundedValue< T, lo, hi >	rhs
	)

inline

Bounded value subtraction operator.

Definition at line 526 of file BoundedValue.hpp.

◆ operator<<() [2/5]

template<typename T , LoValueCheck lo, HiValueCheck hi>

::std::ostream& playrho::operator<<	(	::std::ostream &	os,
		const BoundedValue< T, lo, hi > &	value
	)

Bounded value stream output operator.

Definition at line 584 of file BoundedValue.hpp.

◆ Alloc()

void * playrho::Alloc ( std::size_t size )

Allocates memory.

Note: Implement this function to use your own memory allocator.

Definition at line 28 of file DynamicMemory.cpp.

◆ Realloc() [1/2]

void * playrho::Realloc	(	void *	ptr,
		std::size_t	new_size
	)

Reallocates memory.

Note: Implement this function to use your own memory allocator.

Definition at line 33 of file DynamicMemory.cpp.

◆ Free()

void playrho::Free ( void * mem )

Frees memory.

Note: If you implement Alloc, you should also implement this function.

Definition at line 38 of file DynamicMemory.cpp.

◆ Realloc() [2/2]

template<typename T >

T* playrho::Realloc	(	T *	ptr,
		std::size_t	size
	)

Reallocates memory.

Definition at line 51 of file DynamicMemory.hpp.

◆ operator==() [6/13]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator==	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 579 of file Fixed.hpp.

◆ operator!=() [6/13]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 586 of file Fixed.hpp.

◆ operator<() [4/7]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator<	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Less-than operator.

Definition at line 593 of file Fixed.hpp.

◆ operator>() [4/7]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator>	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Greater-than operator.

Definition at line 600 of file Fixed.hpp.

◆ operator<=() [4/7]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Less-than or equal-to operator.

Definition at line 607 of file Fixed.hpp.

◆ operator>=() [4/7]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Greater-than or equal-to operator.

Definition at line 616 of file Fixed.hpp.

◆ operator+() [5/9]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR Fixed<BT, FB> playrho::operator+	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Addition operator.

Definition at line 624 of file Fixed.hpp.

◆ operator-() [4/8]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR Fixed<BT, FB> playrho::operator-	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Subtraction operator.

Definition at line 632 of file Fixed.hpp.

◆ operator*() [4/10]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR Fixed<BT, FB> playrho::operator*	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Multiplication operator.

Definition at line 640 of file Fixed.hpp.

◆ operator/() [4/6]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR Fixed<BT, FB> playrho::operator/	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Division operator.

Definition at line 648 of file Fixed.hpp.

◆ operator%() [1/2]

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR Fixed<BT, FB> playrho::operator%	(	Fixed< BT, FB >	lhs,
		Fixed< BT, FB >	rhs
	)

inlinenoexcept

Modulo operator.

Definition at line 656 of file Fixed.hpp.

◆ AlmostZero()

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::AlmostZero ( Fixed< BT, FB > value )

inline

Gets whether a given value is almost zero.

An almost zero value is "subnormal". Dividing by these values can lead to odd results like a divide by zero trap occurring.

Returns: true if the given value is almost zero, false otherwise.

Definition at line 667 of file Fixed.hpp.

◆ AlmostEqual()

template<typename BT , unsigned int FB>

PLAYRHO_CONSTEXPR bool playrho::AlmostEqual	(	Fixed< BT, FB >	x,
		Fixed< BT, FB >	y,
		int	ulp = `2`
	)

inline

Determines whether the given two values are "almost equal".

Examples: World.cpp.

Definition at line 674 of file Fixed.hpp.

◆ operator<<() [3/5]

template<typename BT , unsigned int FB>

inline ::std::ostream& playrho::operator<<	(	::std::ostream &	os,
		const Fixed< BT, FB > &	value
	)

Output stream operator.

Definition at line 690 of file Fixed.hpp.

◆ operator+() [6/9]

PLAYRHO_CONSTEXPR Fixed32 playrho::operator+	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Addition operator.

Definition at line 721 of file Fixed.hpp.

◆ operator-() [5/8]

PLAYRHO_CONSTEXPR Fixed32 playrho::operator-	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Subtraction operator.

Definition at line 728 of file Fixed.hpp.

◆ operator*() [5/10]

PLAYRHO_CONSTEXPR Fixed32 playrho::operator*	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Multiplication operator.

Definition at line 735 of file Fixed.hpp.

◆ operator/() [5/6]

PLAYRHO_CONSTEXPR Fixed32 playrho::operator/	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Division operator.

Definition at line 742 of file Fixed.hpp.

◆ operator%() [2/2]

PLAYRHO_CONSTEXPR Fixed32 playrho::operator%	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Modulo operator.

Definition at line 749 of file Fixed.hpp.

◆ operator==() [7/13]

PLAYRHO_CONSTEXPR bool playrho::operator==	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 756 of file Fixed.hpp.

◆ operator!=() [7/13]

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 762 of file Fixed.hpp.

◆ operator<=() [5/7]

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Less-than or equal-to operator.

Definition at line 768 of file Fixed.hpp.

◆ operator>=() [5/7]

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Greater-than or equal-to operator.

Definition at line 775 of file Fixed.hpp.

◆ operator<() [5/7]

PLAYRHO_CONSTEXPR bool playrho::operator<	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Less-than operator.

Definition at line 782 of file Fixed.hpp.

◆ operator>() [5/7]

PLAYRHO_CONSTEXPR bool playrho::operator>	(	Fixed32	lhs,
		Fixed32	rhs
	)

inlinenoexcept

Greater-than operator.

Definition at line 789 of file Fixed.hpp.

◆ GetTypeName< Fixed32 >()

template<>

const char* playrho::GetTypeName< Fixed32 > ( )

inlinenoexcept

Gets the specialized name for the Fixed32 type.

Provides an interface to a specialized function for getting C-style null-terminated array of characters that names the Fixed32 type.

Returns: Non-null pointer to C-style string name of specified type.

Definition at line 800 of file Fixed.hpp.

◆ GetSize()

template<typename T >

PLAYRHO_CONSTEXPR T playrho::GetSize ( const Interval< T > & v )

inlinenoexcept

Gets the size of the given interval.

Gets the difference between the max and min values.

Warning: Behavior is undefined if the difference between the given range's max and min values overflows the range of the Interval::value_type.

Returns: Non-negative value unless the given interval is "unset" or invalid.

Definition at line 232 of file Interval.hpp.

◆ GetCenter()

template<typename T >

PLAYRHO_CONSTEXPR T GetCenter ( const Interval< T > & v )

inlinenoexcept

Gets the center of the given interval.

Warning: Behavior is undefined if the difference between the given range's max and min values overflows the range of the Interval::value_type.

Definition at line 242 of file Interval.hpp.

◆ IsIntersecting()

template<typename T >

PLAYRHO_CONSTEXPR bool IsIntersecting	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inlinenoexcept

Checks whether two value ranges have any intersection/overlap at all.

Definition at line 251 of file Interval.hpp.

◆ GetIntersection()

template<typename T >

PLAYRHO_CONSTEXPR Interval< T > GetIntersection	(	Interval< T >	a,
		const Interval< T > &	b
	)

inlinenoexcept

Gets the intersecting interval of two given ranges.

Definition at line 261 of file Interval.hpp.

◆ IsEntirelyBefore()

template<typename T >

PLAYRHO_CONSTEXPR bool playrho::IsEntirelyBefore	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inline

Determines whether the first range is entirely before the second range.

Definition at line 268 of file Interval.hpp.

◆ IsEntirelyAfter()

template<typename T >

PLAYRHO_CONSTEXPR bool playrho::IsEntirelyAfter	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inline

Determines whether the first range is entirely after the second range.

Definition at line 275 of file Interval.hpp.

◆ IsEntirelyEnclosing()

template<typename T >

PLAYRHO_CONSTEXPR bool playrho::IsEntirelyEnclosing	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inline

Determines whether the first range entirely encloses the second.

Definition at line 282 of file Interval.hpp.

◆ operator==() [8/13]

template<typename T >

PLAYRHO_CONSTEXPR bool operator==	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inlinenoexcept

Equality operator.

Note: Satisfies the EqualityComparable concept for Interval objects.

See also: http://en.cppreference.com/w/cpp/concept/EqualityComparable

Definition at line 292 of file Interval.hpp.

◆ operator!=() [8/13]

template<typename T >

PLAYRHO_CONSTEXPR bool operator!=	(	const Interval< T > &	a,
		const Interval< T > &	b
	)

inlinenoexcept

Inequality operator.

Note: Satisfies the EqualityComparable concept for Interval objects.

See also: http://en.cppreference.com/w/cpp/concept/EqualityComparable

Definition at line 302 of file Interval.hpp.

◆ operator<() [6/7]

template<typename T >

PLAYRHO_CONSTEXPR bool operator<	(	const Interval< T > &	lhs,
		const Interval< T > &	rhs
	)

inlinenoexcept

Less-than operator.

Note: Provides a "strict weak ordering" relation.; This is a lexicographical comparison.; Obeys the LessThanComparable concept: for all a, !(a < a); if (a < b) then !(b < a); if (a < b) and (b < c) then (a < c); with equiv = !(a < b) && !(b < a), if equiv(a, b) and equiv(b, c), then equiv(a, c).

See also: https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings; http://en.cppreference.com/w/cpp/concept/LessThanComparable

Definition at line 318 of file Interval.hpp.

◆ operator<=() [6/7]

template<typename T >

PLAYRHO_CONSTEXPR bool operator<=	(	const Interval< T > &	lhs,
		const Interval< T > &	rhs
	)

inlinenoexcept

Less-than or equal-to operator.

Note: Provides a "strict weak ordering" relation.; This is a lexicographical comparison.

See also: https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings

Definition at line 330 of file Interval.hpp.

◆ operator>() [6/7]

template<typename T >

PLAYRHO_CONSTEXPR bool operator>	(	const Interval< T > &	lhs,
		const Interval< T > &	rhs
	)

inlinenoexcept

Greater-than operator.

Note: Provides a "strict weak ordering" relation.; This is a lexicographical comparison.

See also: https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings

Definition at line 342 of file Interval.hpp.

◆ operator>=() [6/7]

template<typename T >

PLAYRHO_CONSTEXPR bool operator>=	(	const Interval< T > &	lhs,
		const Interval< T > &	rhs
	)

inlinenoexcept

Greater-than or equal-to operator.

Note: Provides a "strict weak ordering" relation.; This is a lexicographical comparison.

See also: https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings

Definition at line 354 of file Interval.hpp.

◆ operator<<() [4/5]

template<typename T >

::std::ostream& playrho::operator<<	(	::std::ostream &	os,
		const Interval< T > &	value
	)

Output stream operator.

Definition at line 362 of file Interval.hpp.

◆ GetX() [1/2]

template<typename T >

PLAYRHO_CONSTEXPR auto& playrho::GetX ( T & value )

inline

Gets the "X" element of the given value - i.e. the first element.

Examples: Body.cpp, HelloWorld.cpp, and World.cpp.

Definition at line 66 of file Math.hpp.

◆ GetY() [1/2]

template<typename T >

PLAYRHO_CONSTEXPR auto& playrho::GetY ( T & value )

inline

Gets the "Y" element of the given value - i.e. the second element.

Examples: Body.cpp, HelloWorld.cpp, and World.cpp.

Definition at line 73 of file Math.hpp.

◆ GetZ() [1/2]

template<typename T >

PLAYRHO_CONSTEXPR auto& playrho::GetZ ( T & value )

inline

Gets the "Z" element of the given value - i.e. the third element.

Definition at line 80 of file Math.hpp.

◆ GetX() [2/2]

template<typename T >

PLAYRHO_CONSTEXPR auto playrho::GetX ( const T & value )

inline

Gets the "X" element of the given value - i.e. the first element.

Definition at line 87 of file Math.hpp.

◆ GetY() [2/2]

template<typename T >

PLAYRHO_CONSTEXPR auto playrho::GetY ( const T & value )

inline

Gets the "Y" element of the given value - i.e. the second element.

Definition at line 94 of file Math.hpp.

◆ GetZ() [2/2]

template<typename T >

PLAYRHO_CONSTEXPR auto playrho::GetZ ( const T & value )

inline

Gets the "Z" element of the given value - i.e. the third element.

Definition at line 101 of file Math.hpp.

◆ MakeUnsigned()

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<std::is_signed<T>::value, std::make_unsigned_t<T> > playrho::MakeUnsigned ( const T & arg )

inlinenoexcept

Makes the given value into an unsigned value.

Note: If the given value is negative, this will result in an unsigned value which is the two's complement modulo-wrapped value.

Definition at line 111 of file Math.hpp.

◆ StripUnit() [1/2]

template<typename T , LoValueCheck lo, HiValueCheck hi>

PLAYRHO_CONSTEXPR auto playrho::StripUnit ( const BoundedValue< T, lo, hi > & v )

inline

Strips the unit from the given value.

Examples: World.cpp.

Definition at line 118 of file Math.hpp.

◆ GetIdentityMatrix()

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector<T>::value, Matrix<T, N, N> > playrho::GetIdentityMatrix ( )

inline

Gets the identity matrix of the template type and size.

See also: https://en.wikipedia.org/wiki/Identity_matrix; Matrix, IsMatrix, IsSquareMatrix

Definition at line 102 of file Matrix.hpp.

◆ GetIdentity()

template<typename T >

PLAYRHO_CONSTEXPR std::enable_if_t<IsSquareMatrix<T>::value, T> playrho::GetIdentity ( )

inline

Gets the identity matrix of the template type and size as given by the argument.

See also: https://en.wikipedia.org/wiki/Identity_matrix; Matrix, IsMatrix, IsSquareMatrix

Definition at line 116 of file Matrix.hpp.

◆ GetRowMatrix()

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector<T>::value, Vector<Vector<T, N>, 1> > playrho::GetRowMatrix ( Vector< T, N > arg )

inline

Gets the specified row of the given matrix as a row matrix.

Definition at line 124 of file Matrix.hpp.

◆ GetColumnMatrix()

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t<!IsVector<T>::value, Vector<Vector<T, 1>, N> > playrho::GetColumnMatrix ( Vector< T, N > arg )

inline

Gets the specified column of the given matrix as a column matrix.

Definition at line 132 of file Matrix.hpp.

◆ operator+() [7/9]

template<typename T , std::size_t M, std::size_t N>

PLAYRHO_CONSTEXPR auto playrho::operator+	(	const Matrix< T, M, N > &	lhs,
		const Matrix< T, M, N > &	rhs
	)

inlinenoexcept

Matrix addition operator for two same-type, same-sized matrices.

See also: https://en.wikipedia.org/wiki/Matrix_addition

Definition at line 146 of file Matrix.hpp.

◆ operator-() [6/8]

template<typename T , std::size_t M, std::size_t N>

PLAYRHO_CONSTEXPR auto playrho::operator-	(	const Matrix< T, M, N > &	lhs,
		const Matrix< T, M, N > &	rhs
	)

inlinenoexcept

Matrix subtraction operator for two same-type, same-sized matrices.

See also: https://en.wikipedia.org/wiki/Matrix_addition

Definition at line 163 of file Matrix.hpp.

◆ IsValid() [3/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const Mat22 & value )

inlinenoexcept

Determines if the given value is valid.

Determines whether the given vector contains finite coordinates.

Definition at line 198 of file Matrix.hpp.

◆ IsValid() [4/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Position & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 121 of file Position.hpp.

◆ IsValid() [5/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Sweep & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 135 of file Sweep.hpp.

◆ NOT_USED()

template<class... T>

void playrho::NOT_USED ( T && ... )

"Not used" annotator.

Examples: Body.cpp.

Definition at line 108 of file Templates.hpp.

◆ IsValid() [6/11]

template<typename T >

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const T & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 119 of file Templates.hpp.

◆ IsValid() [7/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const std::size_t & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 168 of file Templates.hpp.

◆ GetPtr() [1/4]

template<class T >

const PLAYRHO_CONSTEXPR T* playrho::GetPtr ( const T * value )

noexcept

Gets a pointer for the given variable.

Examples: Body.cpp, and World.cpp.

Definition at line 177 of file Templates.hpp.

◆ GetPtr() [2/4]

template<class T >

PLAYRHO_CONSTEXPR T* playrho::GetPtr ( T * value )

inlinenoexcept

Gets a pointer for the given variable.

Definition at line 184 of file Templates.hpp.

◆ GetPtr() [3/4]

template<class T >

const PLAYRHO_CONSTEXPR T* playrho::GetPtr ( const T & value )

noexcept

Gets a pointer for the given variable.

Definition at line 191 of file Templates.hpp.

◆ GetPtr() [4/4]

template<class T >

PLAYRHO_CONSTEXPR T* playrho::GetPtr ( T & value )

inlinenoexcept

Gets a pointer for the given variable.

Definition at line 198 of file Templates.hpp.

◆ GetRef() [1/4]

template<class T >

const PLAYRHO_CONSTEXPR T& playrho::GetRef ( const T * value )

noexcept

Gets a reference for the given variable.

Examples: Body.cpp, and World.cpp.

Definition at line 205 of file Templates.hpp.

◆ GetRef() [2/4]

template<class T >

PLAYRHO_CONSTEXPR T& playrho::GetRef ( T * value )

inlinenoexcept

Gets a reference for the given variable.

Definition at line 212 of file Templates.hpp.

◆ GetRef() [3/4]

template<class T >

const PLAYRHO_CONSTEXPR T& playrho::GetRef ( const T & value )

noexcept

Gets a reference for the given variable.

Definition at line 219 of file Templates.hpp.

◆ GetRef() [4/4]

template<class T >

PLAYRHO_CONSTEXPR T& playrho::GetRef ( T & value )

inlinenoexcept

Gets a reference for the given variable.

Definition at line 226 of file Templates.hpp.

◆ Visit()

template<typename T >

bool playrho::Visit	(	const T &	,
		void *
	)

Template function for visiting objects.

Note: Specialize this function to tie in application specific handling for types which don't already have specialized handling. Specializations should always return true.; First parameter is the object to visit.; Second parameter is user data or the nullptr.

See also: https://en.wikipedia.org/wiki/Visitor_pattern

Definition at line 239 of file Templates.hpp.

◆ GetTypeName()

template<typename T >

const char* playrho::GetTypeName ( )

inlinenoexcept

Gets the library defined name for the given type.

Provides an interface to a function that can be specialized for getting a C-style null-terminated array of characters that names the type.

Returns: Non-null pointer to C-style string name of specified type.

Definition at line 249 of file Templates.hpp.

◆ GetTypeName< float >()

template<>

const char* playrho::GetTypeName< float > ( )

inlinenoexcept

Gets a human recognizable name for the float type.

Definition at line 258 of file Templates.hpp.

◆ GetTypeName< double >()

template<>

const char* playrho::GetTypeName< double > ( )

inlinenoexcept

Gets a human recognizable name for the double type.

Definition at line 265 of file Templates.hpp.

◆ GetTypeName< long double >()

template<>

const char* playrho::GetTypeName< long double > ( )

inlinenoexcept

Gets a human recognizable name for the long double type.

Definition at line 272 of file Templates.hpp.

◆ IsValid() [8/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Transformation & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 71 of file Transformation.hpp.

◆ StripUnit() [2/2]

PLAYRHO_CONSTEXPR Real playrho::StripUnit ( const Real value )

inline

Strips the units off of the given value.

Definition at line 792 of file Units.hpp.

◆ IsValid() [9/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::UnitVec & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 397 of file UnitVec.hpp.

◆ operator==() [9/13]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR bool operator==	(	const Vector< T, N > &	lhs,
		const Vector< T, N > &	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 245 of file Vector.hpp.

◆ operator!=() [9/13]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR bool operator!=	(	const Vector< T, N > &	lhs,
		const Vector< T, N > &	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 260 of file Vector.hpp.

◆ operator+() [8/9]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(+T{})>::value, Vector< T, N > > operator+ ( Vector< T, N > v )

inlinenoexcept

Unary plus operator.

Definition at line 270 of file Vector.hpp.

◆ operator-() [7/8]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(-T{})>::value, Vector< T, N > > operator- ( Vector< T, N > v )

inlinenoexcept

Unary negation operator.

Definition at line 280 of file Vector.hpp.

◆ operator+=() [2/2]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{}+T{})>::value, Vector< T, N > & > operator+=	(	Vector< T, N > &	lhs,
		const Vector< T, N >	rhs
	)

inlinenoexcept

Increments the left hand side value by the right hand side value.

Definition at line 294 of file Vector.hpp.

◆ operator-=()

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{} - T{})>::value, Vector< T, N > & > operator-=	(	Vector< T, N > &	lhs,
		const Vector< T, N >	rhs
	)

inlinenoexcept

Decrements the left hand side value by the right hand side value.

Definition at line 308 of file Vector.hpp.

◆ operator+() [9/9]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{}+T{})>::value, Vector< T, N > > operator+	(	Vector< T, N >	lhs,
		const Vector< T, N >	rhs
	)

inlinenoexcept

Adds two vectors component-wise.

Definition at line 322 of file Vector.hpp.

◆ operator-() [8/8]

template<typename T , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T, decltype(T{} - T{})>::value, Vector< T, N > > operator-	(	Vector< T, N >	lhs,
		const Vector< T, N >	rhs
	)

inlinenoexcept

Subtracts two vectors component-wise.

Definition at line 332 of file Vector.hpp.

◆ operator*=()

template<typename T1 , typename T2 , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T1, decltype(T1{} T2{})>::value, Vector< T1, N > & > operator=	(	Vector< T1, N > &	lhs,
		const T2	rhs
	)

inlinenoexcept

Multiplication assignment operator.

Definition at line 342 of file Vector.hpp.

◆ operator/=()

template<typename T1 , typename T2 , std::size_t N>

PLAYRHO_CONSTEXPR std::enable_if_t< std::is_same< T1, decltype(T1{}/T2{})>::value, Vector< T1, N > & > operator/=	(	Vector< T1, N > &	lhs,
		const T2	rhs
	)

inlinenoexcept

Division assignment operator.

Definition at line 356 of file Vector.hpp.

◆ operator*() [6/10]

template<typename T1 , typename T2 , std::size_t A, std::size_t B, std::size_t C, typename OT = decltype(T1{} * T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value, Vector< Vector< OT, C >, A > > operator*	(	const Vector< Vector< T1, B >, A > &	lhs,
		const Vector< Vector< T2, C >, B > &	rhs
	)

inlinenoexcept

Calculates the matrix product of the two given vector of vectors (matrices).

Multiplies an A-by-B vector of vectors by a B-by-C vector of vectors returning an A-by-C vector of vectors.

Note: From Wikipedia:

Multiplication of two matrices is defined if and only if the number of columns of the left matrix is the same as the number of rows of the right matrix.; Matrix multiplication is not commutative.; Algorithmically speaking, this implementation is called the "naive" algorithm. For small matrices, like 3-by-3 or smaller matrices, its complexity shouldn't be an issue. The matrix dimensions are compile time constants anyway which can help compilers automatically identify loop unrolling and hardware level parallelism opportunities.

Parameters

lhs	Left-hand-side matrix.
rhs	Right-hand-side matrix.

Returns: A-by-C matrix product of the left-hand-side matrix and the right-hand-side matrix.

See also: https://en.wikipedia.org/wiki/Matrix_multiplication; https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm; https://en.wikipedia.org/wiki/Commutative_property

Definition at line 388 of file Vector.hpp.

◆ operator*() [7/10]

template<typename T1 , typename T2 , std::size_t A, std::size_t B, typename OT = decltype(T1{} * T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T1>::value, Vector<OT, B> > playrho::operator*	(	const Vector< T1, A > &	lhs,
		const Vector< Vector< T2, B >, A > &	rhs
	)

inlinenoexcept

Multiplies an A-element vector by a A-by-B vector of vectors.

Note: This algorithm favors column major ordering of the vector of vectors.; This treats the left-hand-side argument as though it's a 1-by-A vector of vectors.

Parameters

lhs	Left-hand-side vector treated as if it were of type: `Vector<Vector<T1, A>, 1>`.
rhs	Right-hand-side vector of vectors.

Returns: B-element vector product.

Definition at line 424 of file Vector.hpp.

◆ operator*() [8/10]

template<typename T1 , typename T2 , std::size_t A, std::size_t B, typename OT = decltype(T1{} * T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T2>::value, Vector<OT, B> > playrho::operator*	(	const Vector< Vector< T1, A >, B > &	lhs,
		const Vector< T2, A > &	rhs
	)

inlinenoexcept

Multiplies a B-by-A vector of vectors by an A-element vector.

Note: This algorithm favors row major ordering of the vector of vectors.; This treats the right-hand-side argument as though it's an A-by-1 vector of vectors.

Parameters

lhs	Left-hand-side vector of vectors.
rhs	Right-hand-side vector treated as if it were of type: `Vector<Vector<T2, 1>, A>`.

Returns: B-element vector product.

Definition at line 450 of file Vector.hpp.

◆ operator*() [9/10]

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} * T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T1 >::value, Vector< OT, N > > operator*	(	const T1	s,
		Vector< T2, N >	a
	)

inlinenoexcept

Multiplication operator for non-vector times vector.

Note: Explicitly disabled for Vector * Vector to prevent this function from existing in that case and prevent errors like "use of overloaded operator '*' is ambiguous".

Definition at line 472 of file Vector.hpp.

◆ operator*() [10/10]

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} * T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t< IsMultipliable< T1, T2 >::value &&!IsVector< T2 >::value, Vector< OT, N > > operator*	(	Vector< T1, N >	a,
		const T2	s
	)

inlinenoexcept

Multiplication operator for vector times non-vector.

Note: Explicitly disabled for Vector * Vector to prevent this function from existing in that case and prevent errors like "use of overloaded operator '*' is ambiguous".

Definition at line 490 of file Vector.hpp.

◆ operator/() [6/6]

template<std::size_t N, typename T1 , typename T2 , typename OT = decltype(T1{} / T2{})>

PLAYRHO_CONSTEXPR std::enable_if_t< IsDivisable< T1, T2 >::value &&!IsVector< T2 >::value, Vector< OT, N > > operator/	(	Vector< T1, N >	a,
		const T2	s
	)

inlinenoexcept

Division operator.

Definition at line 506 of file Vector.hpp.

◆ get() [1/2]

template<std::size_t I, std::size_t N, typename T >

PLAYRHO_CONSTEXPR auto & get ( Vector< T, N > & v )

inlinenoexcept

Gets the specified element of the given collection.

Definition at line 521 of file Vector.hpp.

◆ get() [2/2]

template<std::size_t I, std::size_t N, typename T >

PLAYRHO_CONSTEXPR auto playrho::get ( const Vector< T, N > & v )

inlinenoexcept

Gets the specified element of the given collection.

Definition at line 529 of file Vector.hpp.

◆ operator<<() [5/5]

template<typename T , std::size_t N>

::std::ostream& playrho::operator<<	(	::std::ostream &	os,
		const Vector< T, N > &	value
	)

Output stream operator.

Definition at line 538 of file Vector.hpp.

◆ GetVec2()

PLAYRHO_CONSTEXPR Vec2 playrho::GetVec2 ( const Vector2< Real > value )

inline

Gets the given value as a 2-element vector of reals (Vec2).

Definition at line 68 of file Vector2.hpp.

◆ IsValid() [10/11]

template<typename TYPE >

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const Vector2< TYPE > & value )

inlinenoexcept

Determines whether the given vector contains finite coordinates.

Definition at line 82 of file Vector2.hpp.

◆ IsValid() [11/11]

template<>

PLAYRHO_CONSTEXPR bool playrho::IsValid ( const d2::Velocity & value )

inlinenoexcept

Determines if the given value is valid.

Definition at line 152 of file Velocity.hpp.

◆ GetVersion()

Version playrho::GetVersion ( )

noexcept

Gets the version information of the library.

Definition at line 34 of file Version.cpp.

◆ GetBuildDetails()

std::string playrho::GetBuildDetails ( )

noexcept

Gets the build details of the library.

Definition at line 39 of file Version.cpp.

◆ operator==() [10/13]

PLAYRHO_CONSTEXPR bool playrho::operator==	(	Version	lhs,
		Version	rhs
	)

inline

Equality operator.

Definition at line 64 of file Version.hpp.

◆ operator!=() [10/13]

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	Version	lhs,
		Version	rhs
	)

inline

Inequality operator.

Definition at line 70 of file Version.hpp.

◆ MixFriction()

Real playrho::MixFriction	(	Real	friction1,
		Real	friction2
	)

inline

Mixes friction.

Friction mixing formula. The idea is to allow either fixture to drive the resulting friction to zero. For example, anything slides on ice.

Warning: Behavior is undefined if either friction values is less than zero.

Parameters

friction1	A zero or greater value.
friction2	A zero or greater value.

Definition at line 43 of file Contact.hpp.

◆ MixRestitution()

Real playrho::MixRestitution	(	Real	restitution1,
		Real	restitution2
	)

inlinenoexcept

Mixes restitution.

Restitution mixing law. The idea is allow for anything to bounce off an inelastic surface. For example, a super ball bounces on anything.

Definition at line 54 of file Contact.hpp.

◆ operator==() [11/13]

PLAYRHO_CONSTEXPR bool playrho::operator==	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 73 of file ContactKey.hpp.

◆ operator!=() [11/13]

PLAYRHO_CONSTEXPR bool playrho::operator!=	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 79 of file ContactKey.hpp.

◆ operator<() [7/7]

PLAYRHO_CONSTEXPR bool playrho::operator<	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Less-than operator.

Definition at line 85 of file ContactKey.hpp.

◆ operator<=() [7/7]

PLAYRHO_CONSTEXPR bool playrho::operator<=	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Less-than or equal-to operator.

Definition at line 92 of file ContactKey.hpp.

◆ operator>() [7/7]

PLAYRHO_CONSTEXPR bool playrho::operator>	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Greater-than operator.

Definition at line 99 of file ContactKey.hpp.

◆ operator>=() [7/7]

PLAYRHO_CONSTEXPR bool playrho::operator>=	(	const ContactKey	lhs,
		const ContactKey	rhs
	)

inlinenoexcept

Greater-than or equal-to operator.

Definition at line 106 of file ContactKey.hpp.

◆ GetRegConstraintSolverConf()

ConstraintSolverConf playrho::GetRegConstraintSolverConf ( const StepConf & conf )

noexcept

Gets the regular phase constraint solver configuration for the given step configuration.

Definition at line 459 of file ContactSolver.cpp.

◆ GetToiConstraintSolverConf()

ConstraintSolverConf playrho::GetToiConstraintSolverConf ( const StepConf & conf )

noexcept

Gets the TOI phase constraint solver configuration for the given step configuration.

Definition at line 469 of file ContactSolver.cpp.

◆ GetDefaultPositionSolverConf()

ConstraintSolverConf playrho::GetDefaultPositionSolverConf ( )

inline

Gets the default position solver configuration.

Definition at line 149 of file ContactSolver.hpp.

◆ GetDefaultToiPositionSolverConf()

ConstraintSolverConf playrho::GetDefaultToiPositionSolverConf ( )

inline

Gets the default TOI position solver configuration.

Definition at line 155 of file ContactSolver.hpp.

◆ operator==() [12/13]

PLAYRHO_CONSTEXPR bool operator==	(	const Filter	lhs,
		const Filter	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 66 of file Filter.hpp.

◆ operator!=() [12/13]

PLAYRHO_CONSTEXPR bool operator!=	(	const Filter	lhs,
		const Filter	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 75 of file Filter.hpp.

◆ ShouldCollide()

bool ShouldCollide	(	const Filter	filterA,
		const Filter	filterB
	)

inlinenoexcept

Determines whether collision processing should be performed.

Definition at line 82 of file Filter.hpp.

◆ operator==() [13/13]

PLAYRHO_CONSTEXPR bool operator==	(	const FixtureProxy &	lhs,
		const FixtureProxy &	rhs
	)

inlinenoexcept

Equality operator.

Definition at line 45 of file FixtureProxy.hpp.

◆ operator!=() [13/13]

PLAYRHO_CONSTEXPR bool operator!=	(	const FixtureProxy &	lhs,
		const FixtureProxy &	rhs
	)

inlinenoexcept

Inequality operator.

Definition at line 52 of file FixtureProxy.hpp.

◆ GetMovementConf()

MovementConf GetMovementConf ( const StepConf & conf )

noexcept

Gets the movement configuration from the given value.

Returns: The maxTranslation and maxRotation fields of the given value respectively are returned.

Definition at line 26 of file MovementConf.cpp.

◆ IsMaxTranslationWithinTolerance()

bool IsMaxTranslationWithinTolerance ( const StepConf & conf )

noexcept

Determines whether the maximum translation is within tolerance.

Definition at line 27 of file StepConf.cpp.

◆ GetMaxRegLinearCorrection()

Length GetMaxRegLinearCorrection ( const StepConf & conf )

inlinenoexcept

Gets the maximum regular linear correction from the given value.

Definition at line 331 of file StepConf.hpp.

◆ Update()

RegStepStats & playrho::Update	(	RegStepStats &	lhs,
		const IslandStats &	rhs
	)

noexcept

Updates the given regular step statistics.

Definition at line 2697 of file World.cpp.

Variable Documentation

◆ InvalidIndexPair

const PLAYRHO_CONSTEXPR auto playrho::InvalidIndexPair

Initial value:

= IndexPair{
    InvalidVertex, InvalidVertex
}

Invalid index-pair value.

Definition at line 39 of file IndexPair.hpp.

◆ InvalidIndexPair3

const PLAYRHO_CONSTEXPR auto playrho::InvalidIndexPair3

Initial value:

= IndexPair3{{
    InvalidIndexPair, InvalidIndexPair, InvalidIndexPair
}}

Invalid array of three index-pair elements.

Definition at line 50 of file IndexPair.hpp.

◆ AllocatorBlockSizes

const PLAYRHO_CONSTEXPR std::size_t playrho::AllocatorBlockSizes[]

Initial value:

=
    {
        16, 32, 64, 96, 128, 160, 192, 224, 256, 320, 384, 448, 512, 640,
    }

Allocator block sizes array data.

Definition at line 28 of file BlockAllocator.hpp.

◆ Pi

const PLAYRHO_CONSTEXPR auto playrho::Pi = Real(3.14159265358979323846264338327950288)

Pi.

An "irrational number" that's defined as the ratio of a circle's circumference to its diameter.

Note: While the include file definition of M_PI may be a POSIX compliance requirement and initially attractive to use, it's apparently not a C++ standards requirement and casually including it pollutes the name space of all code that uses this library. Whatever the case, MSVC 2017 doesn't make it part of the cmath include without enabling _USE_MATH_DEFINES. So rather than add yet more C preprocessor macros to all sources that this library may be compiled with, it's simply hard-coded in here instead using a C++ mechanism that also keeps it with the enclosing name space.; Any narrowing is intentional.

See also: https://en.wikipedia.org/wiki/Pi

Examples: World.cpp.

Definition at line 54 of file RealConstants.hpp.

◆ SquareRootTwo

const PLAYRHO_CONSTEXPR auto playrho::SquareRootTwo

Initial value:

=

Real(1.414213562373095048801688724209698078569671875376948073176679737990732478462)

Square root of two.

See also: https://en.wikipedia.org/wiki/Square_root_of_2

Definition at line 60 of file RealConstants.hpp.

◆ MaxSimplexEdges

const PLAYRHO_CONSTEXPR auto playrho::MaxSimplexEdges = std::uint8_t{3}

Maximum number of supportable edges in a simplex.

Definition at line 88 of file Settings.hpp.

◆ MaxChildCount

const PLAYRHO_CONSTEXPR auto playrho::MaxChildCount = std::numeric_limits<std::uint32_t>::max() >> 6

Max child count.

Definition at line 91 of file Settings.hpp.

◆ MaxFloat

const PLAYRHO_CONSTEXPR auto playrho::MaxFloat = std::numeric_limits<Real>::max()

Maximum float value.

Definition at line 104 of file Settings.hpp.

◆ MaxManifoldPoints

const PLAYRHO_CONSTEXPR auto playrho::MaxManifoldPoints = std::uint8_t{2}

Maximum manifold points. This is the maximum number of contact points between two convex shapes. Do not change this value.

Note: For memory efficiency, uses the smallest integral type that can hold the value.

Definition at line 112 of file Settings.hpp.

◆ MaxShapeVertices

const PLAYRHO_CONSTEXPR auto playrho::MaxShapeVertices = std::uint8_t{254}

Maximum number of vertices for any shape type.

Note: For memory efficiency, uses the smallest integral type that can hold the value minus one that's left out as a sentinel value.

Definition at line 117 of file Settings.hpp.

◆ InvalidVertex

const PLAYRHO_CONSTEXPR auto playrho::InvalidVertex = static_cast<VertexCounter>(-1)

Invalid vertex index.

Definition at line 125 of file Settings.hpp.

◆ DefaultLinearSlop

const PLAYRHO_CONSTEXPR auto playrho::DefaultLinearSlop = detail::Defaults<Real>::GetLinearSlop()

Default linear slop.

Length used as a collision and constraint tolerance. Usually chosen to be numerically significant, but visually insignificant. Lower or raise to decrease or increase respectively the minimum of space between bodies at rest.

Note: Smaller values relative to sizes of bodies increases the time it takes for bodies to come to rest.

Definition at line 134 of file Settings.hpp.

◆ DefaultMinVertexRadius

const PLAYRHO_CONSTEXPR auto playrho::DefaultMinVertexRadius = DefaultLinearSlop * Real{2}

Default minimum vertex radius.

Definition at line 137 of file Settings.hpp.

◆ DefaultMaxVertexRadius

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxVertexRadius = detail::Defaults<Real>::GetMaxVertexRadius()

Default maximum vertex radius.

Definition at line 140 of file Settings.hpp.

◆ DefaultAabbExtension

const PLAYRHO_CONSTEXPR auto playrho::DefaultAabbExtension = DefaultLinearSlop * Real{20}

Default AABB extension amount.

Definition at line 143 of file Settings.hpp.

◆ DefaultDistanceMultiplier

const PLAYRHO_CONSTEXPR auto playrho::DefaultDistanceMultiplier = Real{2}

Default distance multiplier.

Definition at line 146 of file Settings.hpp.

◆ DefaultAngularSlop

const PLAYRHO_CONSTEXPR auto playrho::DefaultAngularSlop = (Pi * 2_rad) / Real{180}

Default angular slop.

A small angle used as a collision and constraint tolerance. Usually it is chosen to be numerically significant, but visually insignificant.

Definition at line 152 of file Settings.hpp.

◆ DefaultMaxLinearCorrection

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxLinearCorrection = 0.2_m

Default maximum linear correction.

The maximum linear position correction used when solving constraints. This helps to prevent overshoot.

Note: This value should be greater than the linear slop value.

Definition at line 158 of file Settings.hpp.

◆ DefaultMaxAngularCorrection

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxAngularCorrection = Real(8.0f / 180.0f) * Pi * 1_rad

Default maximum angular correction.

Note: This value should be greater than the angular slop value.

Definition at line 162 of file Settings.hpp.

◆ DefaultMaxTranslation

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxTranslation = 2_m

Default maximum translation amount.

Definition at line 165 of file Settings.hpp.

◆ DefaultMaxRotation

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxRotation = Angle{Pi * 1_rad / Real(2)}

Default maximum rotation per world step.

Warning: This value should be less than Pi * Radian.

Note: This limit is meant to prevent numerical problems. Adjusting this value isn't advised.

See also: StepConf::maxRotation.

Definition at line 171 of file Settings.hpp.

◆ DefaultMaxToiIters

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxToiIters = std::uint8_t{20}

Default maximum time of impact iterations.

Definition at line 174 of file Settings.hpp.

◆ DefaultMaxToiRootIters

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxToiRootIters = std::uint8_t{30}

Default maximum time of impact root iterator count.

Definition at line 177 of file Settings.hpp.

◆ DefaultMaxDistanceIters

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxDistanceIters = std::uint8_t{20}

Default max number of distance iterations.

Definition at line 180 of file Settings.hpp.

◆ DefaultMaxSubSteps

const PLAYRHO_CONSTEXPR auto playrho::DefaultMaxSubSteps = std::uint8_t{8}

Default maximum number of sub steps.

This is the default maximum number of sub-steps per contact in continuous physics simulation. In other words, this is the default maximum number of times in a world step that a contact will have continuous collision resolution done for it.

Note: Used in the TOI phase of step processing.

Definition at line 188 of file Settings.hpp.

◆ DefaultVelocityThreshold

const PLAYRHO_CONSTEXPR auto playrho::DefaultVelocityThreshold = 1_mps

Default velocity threshold.

Definition at line 193 of file Settings.hpp.

◆ DefaultRegMinMomentum

const PLAYRHO_CONSTEXPR auto playrho::DefaultRegMinMomentum = Momentum{0_Ns / 100}

Default regular-phase minimum momentum.

Definition at line 196 of file Settings.hpp.

◆ DefaultToiMinMomentum

const PLAYRHO_CONSTEXPR auto playrho::DefaultToiMinMomentum = Momentum{0_Ns / 100}

Default TOI-phase minimum momentum.

Definition at line 199 of file Settings.hpp.

◆ MaxBodies

const PLAYRHO_CONSTEXPR auto playrho::MaxBodies

Initial value:

= static_cast<std::uint16_t>(std::numeric_limits<std::uint16_t>::max() -

std::uint16_t{1})

Maximum number of bodies in a world.

Note: This is 65534 based off std::uint16_t and eliminating one value for invalid.

Examples: World.cpp.

Definition at line 203 of file Settings.hpp.

◆ InvalidContactIndex

const PLAYRHO_CONSTEXPR auto playrho::InvalidContactIndex = static_cast<ContactCounter>(-1)

Invalid contact index.

Definition at line 215 of file Settings.hpp.

◆ MaxContacts

const PLAYRHO_CONSTEXPR auto playrho::MaxContacts = ContactCounter{MaxBodies} * ContactCounter{MaxBodies - 1} / ContactCounter{2}

Maximum number of contacts in a world (2147319811).

Uses the formula for the maximum number of edges in an unidirectional graph of MaxBodies nodes. This occurs when every possible body is connected to every other body.

Definition at line 221 of file Settings.hpp.

◆ MaxJoints

const PLAYRHO_CONSTEXPR auto playrho::MaxJoints

Initial value:

= static_cast<std::uint16_t>(std::numeric_limits<std::uint16_t>::max() -

std::uint16_t{1})

Maximum number of joints in a world.

Note: This is 65534 based off std::uint16_t and eliminating one value for invalid.

Examples: World.cpp.

Definition at line 225 of file Settings.hpp.

◆ DefaultStepTime

const PLAYRHO_CONSTEXPR auto playrho::DefaultStepTime = Time{1_s / 60}

Default step time.

Definition at line 233 of file Settings.hpp.

◆ DefaultStepFrequency

const PLAYRHO_CONSTEXPR auto playrho::DefaultStepFrequency = 60_Hz

Default step frequency.

Definition at line 236 of file Settings.hpp.

◆ DefaultMinStillTimeToSleep

const PLAYRHO_CONSTEXPR auto playrho::DefaultMinStillTimeToSleep = Time{1_s / 2}

Default minimum still time to sleep.

The default minimum time bodies must be still for bodies to be put to sleep.

Definition at line 242 of file Settings.hpp.

◆ DefaultLinearSleepTolerance

const PLAYRHO_CONSTEXPR auto playrho::DefaultLinearSleepTolerance = 0.01_mps

Default linear sleep tolerance.

A body cannot sleep if the magnitude of its linear velocity is above this amount.

Definition at line 246 of file Settings.hpp.

◆ DefaultAngularSleepTolerance

const PLAYRHO_CONSTEXPR auto playrho::DefaultAngularSleepTolerance = Real{(Pi * 2) / 180} * RadianPerSecond

Default angular sleep tolerance.

A body cannot sleep if its angular velocity is above this amount.

Definition at line 250 of file Settings.hpp.

◆ DefaultCirclesRatio

const PLAYRHO_CONSTEXPR auto playrho::DefaultCirclesRatio = Real{10}

Default circles ratio.

Ratio used for switching between rounded-corner collisions and closest-face biased normal collisions.

Definition at line 255 of file Settings.hpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ PairLength2

◆ IndexPair

◆ IndexPair3

◆ VertexCounterArray

◆ VertexCounter2

◆ Fixed32

◆ Matrix

◆ Matrix22

◆ Matrix33

◆ Mat22

◆ Mass22

◆ InvMass22

◆ Mat33

◆ Optional

◆ Real

◆ ChildCounter

◆ TimestepIters

◆ VertexCounter

◆ BodyCounter

◆ ContactCounter

◆ JointCounter

◆ IsIterable

◆ TupleContainsType

◆ Vector2

◆ Vec2

◆ Length2

◆ LinearVelocity2

◆ LinearAcceleration2

◆ Force2

◆ Mass2

◆ InvMass2

◆ Momentum2

◆ Vector3

◆ Vec3

◆ Mass3

◆ InvMass3

Enumeration Type Documentation

◆ PointState

◆ RayCastOpcode

◆ LoValueCheck

◆ HiValueCheck

◆ BodyType

Function Documentation

◆ GetInvalid()

◆ GetVertexVertexContactFeature()

◆ GetVertexFaceContactFeature()

◆ GetFaceVertexContactFeature()

◆ GetFaceFaceContactFeature()

◆ Flip()

◆ operator==() [1/13]

◆ operator!=() [1/13]

◆ GetName() [1/2]

◆ operator<<() [1/5]

◆ GetNumValidIndices()

◆ empty()

◆ size()

◆ max_size()

◆ GetFirstShapeVertexIdx()

◆ GetSecondShapeVertexIdx()

◆ IsValid() [1/11]

◆ Visit< d2::Shape >()

◆ GetName() [2/2]

◆ GetToiConf()

◆ GetDefaultToiConf()

◆ IsValid() [2/11]

◆ operator+=() [1/2]

◆ operator+() [1/9]

◆ Delete()

◆ operator==() [2/13]

◆ operator!=() [2/13]

◆ CheckIfAboveNegInf() [1/2]

◆ CheckIfAboveNegInf() [2/2]