MathHelper.h File Reference

#include <numbers>
#include "MathHelper.inl"

Go to the source code of this file.

Classes
struct	Divide::SimpleTime
struct	Divide::SimpleLocation
struct	Divide::Util::Circle
struct	std::hash< array< T, N > >

Namespaces
namespace	Divide
	Handle console commands that start with a forward slash.
namespace	Divide::Angle
namespace	Divide::Metric
namespace	Divide::Time
namespace	Divide::Util
namespace	std

Concepts
concept	Divide::ValidMathType

Macros
#define	DVD_CORE_MATH_MATH_HELPER_H_
#define	TO_MEGABYTES(X)   ((X) * 1024u * 1024u)

Typedefs
using	Divide::UColour3 = vec3< U8 >
using	Divide::FColour3 = vec3< F32 >
using	Divide::UColour4 = vec4< U8 >
using	Divide::FColour4 = vec4< F32 >
template<typename T >
using	Divide::SignedIntegerBasedOnSize = typename std::conditional< sizeof(T)==8, I64, I32 >::type
template<typename T >
using	Divide::UnsignedIntegerBasedOnSize = typename std::conditional< sizeof(T)==8, U64, U32 >::type
template<typename T >
using	Divide::IntegerTypeBasedOnSign = typename std::conditional< std::is_unsigned< T >::value, UnsignedIntegerBasedOnSize< T >, SignedIntegerBasedOnSize< T > >::type
template<typename T >
using	Divide::DefaultDistribution = typename std::conditional< std::is_integral< T >::value, std::uniform_int_distribution< IntegerTypeBasedOnSign< T > >, std::uniform_real_distribution< T > >::type
template<typename T >
using	Divide::Angle::RADIANS = T
template<typename T >
using	Divide::Angle::DEGREES = T

Functions
template<typename T , typename Engine = std::mt19937_64, typename Distribution = DefaultDistribution<T>> requires std::is_arithmetic_v<T>
T	Divide::Random (T min, T max)
template<typename T , typename Engine = std::mt19937_64, typename Distribution = DefaultDistribution<T>> requires std::is_arithmetic_v<T>
T	Divide::Random (T max)
template<typename T , typename Engine = std::mt19937_64, typename Distribution = DefaultDistribution<T>> requires std::is_arithmetic_v<T>
T	Divide::Random ()
template<typename Engine = std::mt19937_64>
void	Divide::SeedRandom ()
template<typename Engine = std::mt19937_64>
void	Divide::SeedRandom (U32 seed)
template<typename T >
constexpr I32	Divide::SIGN (const T val)
template<typename T > requires std::is_arithmetic<T>
::value constexpr void	Divide::CLAMP (T &n, T min, T max) noexcept
	Clamps value n between min and max.
template<typename T > requires std::is_arithmetic<T>
::value constexpr void	Divide::CLAMP_01 (T &n) noexcept
template<typename T > requires std::is_arithmetic<T>
::value constexpr T	Divide::CLAMPED (T n, T min, T max) noexcept
template<typename T > requires std::is_arithmetic<T>
::value constexpr T	Divide::CLAMPED_01 (T n) noexcept
template<typename T > requires std::is_arithmetic<T>
::value constexpr T	Divide::MAP (T input, T in_min, T in_max, T out_min, T out_max, D64 &slopeOut) noexcept
template<typename T >
constexpr void	Divide::REMAP (T &input, T in_min, T in_max, T out_min, T out_max, D64 &slopeOut) noexcept
template<typename T >
constexpr T	Divide::SQUARED (T input) noexcept
template<typename T >
constexpr T	Divide::MAP (const T input, const T in_min, const T in_max, const T out_min, const T out_max) noexcept
template<typename T >
constexpr void	Divide::REMAP (T &input, T in_min, T in_max, T out_min, T out_max) noexcept
template<typename T >
vec2< T >	Divide::COORD_REMAP (vec2< T > input, const Rect< T > &in_rect, const Rect< T > &out_rect) noexcept
template<typename T >
vec3< T >	Divide::COORD_REMAP (vec3< T > input, const Rect< T > &in_rect, const Rect< T > &out_rect) noexcept
template<typename T >
T	Divide::NORMALIZE (T input, const T range_min, const T range_max) noexcept
template<typename T >
void	Divide::CLAMP_IN_RECT (T &inout_x, T &inout_y, T rect_x, T rect_y, T rect_z, T rect_w) noexcept
template<typename T >
void	Divide::CLAMP_IN_RECT (T &inout_x, T &inout_y, const Rect< T > &rect) noexcept
template<typename T >
void	Divide::CLAMP_IN_RECT (T &inout_x, T &inout_y, const vec4< T > &rect) noexcept
template<typename T >
bool	Divide::COORDS_IN_RECT (T input_x, T input_y, T rect_x, T rect_y, T rect_z, T rect_w) noexcept
template<typename T >
bool	Divide::COORDS_IN_RECT (T input_x, T input_y, const Rect< T > &rect) noexcept
template<typename T >
bool	Divide::COORDS_IN_RECT (T input_x, T input_y, const vec4< T > &rect) noexcept
constexpr U32	Divide::nextPOW2 (U32 n) noexcept
constexpr U32	Divide::prevPOW2 (U32 n) noexcept
constexpr U32	Divide::minSquareMatrixSize (U32 elementCount) noexcept
template<typename T , typename U >
T	Divide::Lerp (T v1, T v2, U t) noexcept
template<typename T , typename U >
T	Divide::FastLerp (T v1, T v2, U t) noexcept
template<typename T >
T	Divide::Sqrt (T input) noexcept
template<typename T , typename U >
T	Divide::Sqrt (U input) noexcept
constexpr U8	Divide::PACKED_FLOAT_TO_CHAR_UNORM (F32_SNORM value) noexcept
	Helper methods to go from an snorm float (-1...1) to packed unorm char (value => (value + 1) * 0.5 => U8)
constexpr F32_SNORM	Divide::UNORM_CHAR_TO_PACKED_FLOAT (U8 value) noexcept
constexpr I8	Divide::FLOAT_TO_CHAR_SNORM (F32_SNORM value) noexcept
	Returns clamped value * 128.
constexpr F32_SNORM	Divide::SNORM_CHAR_TO_FLOAT (I8 value) noexcept
constexpr F32_NORM	Divide::UNORM_CHAR_TO_FLOAT (U8 value) noexcept
	Returns value / 255.f.
constexpr U8	Divide::FLOAT_TO_CHAR_UNORM (F32_NORM value) noexcept
	Returns round(value * 255)
F32	Divide::FRACT (F32 floatValue) noexcept
	Helper method to emulate GLSL.
template<typename T1 , typename T2 >
constexpr auto	Divide::BitSet (T1 &arg, const T2 pos)
template<typename T1 , typename T2 >
constexpr auto	Divide::BitClr (T1 &arg, const T2 pos)
template<typename T1 , typename T2 >
constexpr bool	Divide::BitTst (const T1 arg, const T2 pos)
template<typename T1 , typename T2 >
constexpr bool	Divide::BitDiff (const T1 arg1, const T2 arg2)
template<typename T1 , typename T2 , typename T3 >
constexpr bool	Divide::BitCmp (const T1 arg1, const T2 arg2, const T3 pos)
template<typename T1 , typename T2 >
constexpr auto	Divide::BitMaskSet (T1 &arg, const T2 mask)
template<typename T1 , typename T2 >
constexpr auto	Divide::BitMaskClear (T1 &arg, const T2 mask)
template<typename T1 , typename T2 >
constexpr auto	Divide::BitMaskFlip (T1 &arg, const T2 mask)
template<typename T1 , typename T2 >
constexpr auto	Divide::BitMaskCheck (T1 &arg, const T2 mask)
template<typename T >
constexpr DEGREES< T >	Divide::Angle::to_VerticalFoV (DEGREES< T > horizontalFoV, D64 aspectRatio) noexcept
template<typename T >
constexpr DEGREES< T >	Divide::Angle::to_HorizontalFoV (DEGREES< T > verticalFoV, D64 aspectRatio) noexcept
template<typename T >
constexpr RADIANS< T >	Divide::Angle::to_RADIANS (DEGREES< T > angle) noexcept
template<typename T >
constexpr DEGREES< T >	Divide::Angle::to_DEGREES (RADIANS< T > angle) noexcept
template<typename T >
constexpr vec2< RADIANS< T > >	Divide::Angle::to_RADIANS (vec2< DEGREES< T > > angle) noexcept
template<typename T >
constexpr vec2< DEGREES< T > >	Divide::Angle::to_DEGREES (vec2< RADIANS< T > > angle) noexcept
template<typename T >
constexpr vec3< RADIANS< T > >	Divide::Angle::to_RADIANS (const vec3< DEGREES< T > > &angle) noexcept
template<typename T >
constexpr vec3< DEGREES< T > >	Divide::Angle::to_DEGREES (const vec3< RADIANS< T > > &angle) noexcept
template<typename T >
constexpr vec4< RADIANS< T > >	Divide::Angle::to_RADIANS (const vec4< DEGREES< T > > &angle) noexcept
template<typename T >
constexpr vec4< DEGREES< T > >	Divide::Angle::to_DEGREES (const vec4< RADIANS< T > > &angle) noexcept
template<typename T >
constexpr T	Divide::Angle::DegreesToRadians (T angleDegrees) noexcept
	Return the radian equivalent of the given degree value.
template<typename T >
constexpr T	Divide::Angle::RadiansToDegrees (T angleRadians) noexcept
	Return the degree equivalent of the given radian value.
template<typename T >
constexpr T	Divide::Angle::Degrees (T degrees) noexcept
	Returns the specified value. Used only for emphasis.
template<typename T >
constexpr T	Divide::Angle::Radians (T radians) noexcept
	Returns the specified value. Used only for emphasis.
template<typename T >
constexpr T	Divide::Metric::Tera (T a)
	Base value * 1000000000000.
template<typename T >
constexpr T	Divide::Metric::Giga (T a)
	Base value * 1000000000.
template<typename T >
constexpr T	Divide::Metric::Mega (T a)
	Base value * 1000000.
template<typename T >
constexpr T	Divide::Metric::Kilo (T a)
	Base value * 1000.
template<typename T >
constexpr T	Divide::Metric::Hecto (T a)
	Base value * 100.
template<typename T >
constexpr T	Divide::Metric::Deca (T a)
	Base value * 10.
template<typename T >
constexpr T	Divide::Metric::Base (T a)
	Base value.
template<typename T >
constexpr T	Divide::Metric::Deci (T a)
	Base value * 0.1.
template<typename T >
constexpr T	Divide::Metric::Centi (T a)
	Base value * 0.01.
template<typename T >
constexpr T	Divide::Metric::Milli (T a)
	Base value * 0.001.
template<typename T >
constexpr T	Divide::Metric::Micro (T a)
	Base value * 0.000001.
template<typename T >
constexpr T	Divide::Metric::Nano (T a)
	Base value * 0.000000001.
template<typename T >
constexpr T	Divide::Metric::Pico (T a)
	Base value * 0.000000000001.
template<typename T , typename U >
constexpr T	Divide::Metric::Tera (U a)
	Base value * 1000000000000.
template<typename T , typename U >
constexpr T	Divide::Metric::Giga (U a)
	Base value * 1000000000.
template<typename T , typename U >
constexpr T	Divide::Metric::Mega (U a)
	Base value * 1000000.
template<typename T , typename U >
constexpr T	Divide::Metric::Kilo (U a)
	Base value * 1000.
template<typename T , typename U >
constexpr T	Divide::Metric::Hecto (U a)
	Base value * 100.
template<typename T , typename U >
constexpr T	Divide::Metric::Deca (U a)
	Base value * 10.
template<typename T , typename U >
constexpr T	Divide::Metric::Base (U a)
	Base value.
template<typename T , typename U >
constexpr T	Divide::Metric::Deci (U a)
	Base value * 0.1.
template<typename T , typename U >
constexpr T	Divide::Metric::Centi (U a)
	Base value * 0.01.
template<typename T , typename U >
constexpr T	Divide::Metric::Milli (U a)
	Base value * 0.001.
template<typename T , typename U >
constexpr T	Divide::Metric::Micro (U a)
	Base value * 0.000001.
template<typename T , typename U >
constexpr T	Divide::Metric::Nano (U a)
	Base value * 0.000000001.
template<typename T , typename U >
constexpr T	Divide::Metric::Pico (U a)
	Base value * 0.000000000001.
template<typename T >
constexpr T	Divide::Time::Hours (T a)
template<typename T >
constexpr T	Divide::Time::Minutes (T a)
template<typename T >
constexpr T	Divide::Time::Seconds (T a)
template<typename T >
constexpr T	Divide::Time::Milliseconds (T a)
template<typename T >
constexpr T	Divide::Time::Microseconds (T a)
template<typename T >
constexpr T	Divide::Time::Nanoseconds (T a)
template<typename T , typename U >
constexpr T	Divide::Time::Hours (U a)
template<typename T , typename U >
constexpr T	Divide::Time::Minutes (U a)
template<typename T , typename U >
constexpr T	Divide::Time::Seconds (U a)
template<typename T , typename U >
constexpr T	Divide::Time::Milliseconds (U a)
template<typename T , typename U >
constexpr T	Divide::Time::Microseconds (U a)
template<typename T , typename U >
constexpr T	Divide::Time::Nanoseconds (U a)
template<typename T = D64, typename U >
constexpr T	Divide::Time::NanosecondsToSeconds (U a) noexcept
template<typename T = D64, typename U >
constexpr T	Divide::Time::NanosecondsToMilliseconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::NanosecondsToMicroseconds (U a) noexcept
template<typename T = D64, typename U >
constexpr T	Divide::Time::MicrosecondsToSeconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::MicrosecondsToMilliseconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::MicrosecondsToNanoseconds (U a) noexcept
template<typename T = D64, typename U >
constexpr T	Divide::Time::MillisecondsToSeconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::MillisecondsToMicroseconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::MillisecondsToNanoseconds (U a) noexcept
template<typename T = D64, typename U >
constexpr T	Divide::Time::SecondsToMilliseconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::SecondsToMicroseconds (U a) noexcept
template<typename T = U64, typename U >
constexpr T	Divide::Time::SecondsToNanoseconds (U a) noexcept
bool	Divide::Util::IntersectCircles (const Circle &cA, const Circle &cB, vec2< F32 > *pointsOut) noexcept
ptrdiff_t	Divide::Util::size_tGetAlignmentCorrected (const size_t value, const size_t alignment) noexcept
template<typename T , typename... Rest>
void	Divide::Util::Hash_combine (size_t &seed, const T &v, const Rest &... rest) noexcept
	a la Boost
template<typename U , typename T >
U	Divide::Util::ConvertData (const T &data)
template<class FwdIt , class Compare = std::less<typename std::iterator_traits<FwdIt>::value_type>>
void	Divide::Util::InsertionSort (FwdIt first, FwdIt last, Compare cmp=Compare())
void	Divide::Util::Normalize (vec3< F32 > &inputRotation, bool degrees=false, bool normYaw=true, bool normPitch=true, bool normRoll=true) noexcept
	Normalise the selected rotations to be within the +/-180 degree range.
UColour4	Divide::Util::ToByteColour (const FColour4 &floatColour) noexcept
UColour3	Divide::Util::ToByteColour (const FColour3 &floatColour) noexcept
FColour4	Divide::Util::ToFloatColour (const UColour4 &byteColour) noexcept
FColour3	Divide::Util::ToFloatColour (const UColour3 &byteColour) noexcept
FColour4	Divide::Util::ToFloatColour (const vec4< U32 > &colour) noexcept
FColour3	Divide::Util::ToFloatColour (const vec3< U32 > &colour) noexcept
void	Divide::Util::ToByteColour (const FColour4 &floatColour, UColour4 &colourOut) noexcept
void	Divide::Util::ToByteColour (const FColour3 &floatColour, UColour3 &colourOut) noexcept
void	Divide::Util::ToFloatColour (const UColour4 &byteColour, FColour4 &colourOut) noexcept
void	Divide::Util::ToFloatColour (const UColour3 &byteColour, FColour3 &colourOut) noexcept
void	Divide::Util::ToFloatColour (const vec4< U32 > &uintColour, FColour4 &colourOut) noexcept
void	Divide::Util::ToFloatColour (const vec3< U32 > &uintColour, FColour3 &colourOut) noexcept
bool	Divide::Util::decomposeMatrix (const mat4< F32 > &transform, vec3< F32 > &translationOut, vec3< F32 > &scaleOut, vec3< Angle::RADIANS< F32 > > &rotationOut, bool &isUniformScaleOut)
bool	Divide::Util::decomposeMatrix (const mat4< F32 > &transform, vec3< F32 > &translationOut, vec3< F32 > &scaleOut, vec3< Angle::RADIANS< F32 > > &rotationOut)
bool	Divide::Util::decomposeMatrix (const mat4< F32 > &transform, vec3< F32 > &translationOut, vec3< F32 > &scaleOut)
bool	Divide::Util::decomposeMatrix (const mat4< F32 > &transform, vec3< F32 > &translationOut)
F32	Divide::Util::PACK_VEC3 (F32_SNORM x, F32_SNORM y, F32_SNORM z) noexcept
F32	Divide::Util::PACK_VEC3 (U8 x, U8 y, U8 z) noexcept
F32	Divide::Util::PACK_VEC3 (const vec3< F32_SNORM > &value) noexcept
U32	Divide::Util::PACK_HALF2x16 (vec2< F32 > value)
void	Divide::Util::UNPACK_HALF2x16 (U32 src, vec2< F32 > &value)
vec2< F32 >	Divide::Util::UNPACK_HALF2x16 (U32 src)
U32	Divide::Util::PACK_HALF2x16 (F32 x, F32 y)
void	Divide::Util::UNPACK_HALF2x16 (U32 src, F32 &x, F32 &y)
U16	Divide::Util::PACK_HALF1x16 (F32 value)
	Only convert the range [-1024., 1024.] for accurate results.
void	Divide::Util::UNPACK_HALF1x16 (U16 src, F32 &value)
	Only convert the range [-1024., 1024.] for accurate results.
F32	Divide::Util::UNPACK_HALF1x16 (U16 src)
	Only convert the range [-1024., 1024.] for accurate results.
F32	Divide::Util::UINT_TO_FLOAT (U32 src)
U32	Divide::Util::FLOAT_TO_UINT (F32 src)
F32	Divide::Util::INT_TO_FLOAT (I32 src)
I32	Divide::Util::FLOAT_TO_INT (F32 src)
U32	Divide::Util::PACK_UNORM4x8 (const vec4< F32_NORM > &value)
U32	Divide::Util::PACK_UNORM4x8 (vec4< U8 > value)
void	Divide::Util::UNPACK_UNORM4x8 (U32 src, vec4< F32_NORM > &value)
U32	Divide::Util::PACK_UNORM4x8 (F32_NORM x, F32_NORM y, F32_NORM z, F32_NORM w)
U32	Divide::Util::PACK_UNORM4x8 (U8 x, U8 y, U8 z, U8 w)
void	Divide::Util::UNPACK_UNORM4x8 (U32 src, F32_NORM &x, F32_NORM &y, F32_NORM &z, F32_NORM &w)
void	Divide::Util::UNPACK_UNORM4x8 (U32 src, U8 &x, U8 &y, U8 &z, U8 &w)
vec4< U8 >	Divide::Util::UNPACK_UNORM4x8_U8 (U32 src)
vec4< F32_NORM >	Divide::Util::UNPACK_UNORM4x8_F32 (U32 src)
void	Divide::Util::UNPACK_VEC3 (F32 src, F32_SNORM &x, F32_SNORM &y, F32_SNORM &z) noexcept
void	Divide::Util::UNPACK_VEC3 (F32 src, vec3< F32_SNORM > &res) noexcept
vec3< F32_SNORM >	Divide::Util::UNPACK_VEC3 (F32 src) noexcept
U32	Divide::Util::PACK_11_11_10 (const vec3< F32_NORM > &value)
void	Divide::Util::UNPACK_11_11_10 (U32 src, vec3< F32_NORM > &res)
vec3< F32_NORM >	Divide::Util::UNPACK_11_11_10 (U32 src)
U32	Divide::Util::PACK_11_11_10 (F32_NORM x, F32_NORM y, F32_NORM z)
void	Divide::Util::UNPACK_11_11_10 (U32 src, F32_NORM &x, F32_NORM &y, F32_NORM &z)

Variables
constexpr D64	Divide::M_PI = std::numbers::pi
constexpr D64	Divide::M_PI_2 = M_PI / 2
constexpr D64	Divide::M_2PI = M_PI * 2
constexpr D64	Divide::M_PIDIV180 = 0.01745329251994329576
constexpr D64	Divide::M_180DIVPI = 57.29577951308232087679
constexpr D64	Divide::M_PIDIV360 = 0.00872664625997164788
constexpr D64	Divide::M_PI2 = M_2PI
constexpr F32	Divide::M_PI_f = to_F32(M_PI)
constexpr F32	Divide::M_PI_2_f = to_F32(M_PI_2)
constexpr F32	Divide::M_PI_4_f = M_PI_f / 4
constexpr F32	Divide::M_2PI_f = to_F32(M_2PI)
constexpr F32	Divide::M_PIDIV180_f = to_F32(M_PIDIV180)
constexpr F32	Divide::M_180DIVPI_f = to_F32(M_180DIVPI)
constexpr F32	Divide::M_PIDIV360_f = to_F32(M_PIDIV360)
constexpr F32	Divide::M_PI2_f = M_2PI_f
constexpr F32	Divide::INV_RAND_MAX = 0.0000305185094f

Macro Definition Documentation

DVD_CORE_MATH_MATH_HELPER_H_

#define DVD_CORE_MATH_MATH_HELPER_H_

Definition at line 41 of file MathHelper.h.

TO_MEGABYTES

#define TO_MEGABYTES

(

X

)

((X) * 1024u * 1024u)

Definition at line 47 of file MathHelper.h.