Harlinn::Math::Internal Namespace Reference

Classes
struct	DistanceType
struct	DistanceType< double >
struct	DistanceType< Int64 >
struct	DistanceType< UInt64 >
struct	FastPowImpl
struct	LineBase
struct	MatrixBase
struct	MatrixSimdBase
struct	NormalBase
struct	PlaneBase
struct	PlaneSimdBase
struct	PointBase
struct	QuaternionBase
struct	QuaternionSimdBase
struct	ScalarBase
struct	SimdFastPowImpl
struct	TupleBase
struct	TupleSimdBase
struct	VectorBase

Concepts
concept	VectorNormalOrPointSimdType
concept	VectorNormalOrPointType

Typedefs
template<SimdOrTupleType T>
using	MakeResultType = std::conditional_t< SimdType<T>, T, typename T::Simd >

Functions
template<FloatingPointType T>
constexpr bool	IsNaNImpl (T val) noexcept
template<FloatingPointType T>
constexpr bool	IsInfImpl (T val) noexcept
template<FloatingPointType T>
constexpr T	AbsImpl (T val) noexcept
template<FloatingPointType T>
constexpr bool	SignBitImpl (T val) noexcept
template<FloatingPointType T>
constexpr T	CopySignImpl (T magnitudeVal, T signVal) noexcept
	Returns a value with the magnitude of magnitudeVal and the sign of signVal.
template<FloatingPointType T>
constexpr T	LerpImpl (T a, T b, T t) noexcept
template<FloatingPointType T>
constexpr T	MaxImpl (T x, T y)
template<FloatingPointType T>
constexpr T	MinImpl (T x, T y)
constexpr double	Exp10Impl (double x) noexcept
constexpr float	Exp10Impl (float x) noexcept
template<typename FloatT > requires IsFloatingPoint<FloatT>
constexpr CompensatedFloat< FloatT >	InnerProduct (FloatT a, FloatT b)
template<typename FloatT , typename... T> requires IsFloatingPoint<FloatT>
constexpr CompensatedFloat< FloatT >	InnerProduct (FloatT a, FloatT b, T... terms)
constexpr float	HalfToFloat (const UInt16 value)
constexpr UInt16	FloatToHalf (float value)
template<SimdType T>
constexpr T::SIMDType	ToSimd (const T &v) noexcept
template<TupleType T>
T::SIMDType	ToSimd (const T &v) noexcept
template<SimdType T>
constexpr const T &	ToSimdType (const T &v) noexcept
template<TupleType T>
T::Simd	ToSimdType (const T &v) noexcept
template<SimdType S, SimdType T, SimdType U> requires IsCompatible<S, T, U>
S	ClampLengthImpl (const S &v, const T &lengthMin, const U &lengthMax) noexcept
template<SimdType S, SimdType T> requires IsCompatible<S, T>
S	ReflectImpl (const S &incident, const T &normal) noexcept
	Reflects an incident vector across a normal vector.
template<SimdType S, SimdType T, SimdType U> requires IsCompatible<S, T, U>
S	RefractImpl (const S &incident, const T &normal, const U &refractionIndex) noexcept
	Refracts an incident vector across a normal vector.
template<SimdType T>
T	ModAnglesImpl (const T &angles)
	Calculates the angle modulo 2PI.
template<SimdType T, SimdType U> requires IsCompatible<T, U>
T	AddAnglesImpl (const T &v1, const U &v2) noexcept
	Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)
template<SimdType T, SimdType U> requires IsCompatible<T, U>
T	SubtractAnglesImpl (const T &v1, const U &v2) noexcept
	Subtracts the angles in v2 from the corresponding elements of v1. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)
template<SimdType T, SimdType U, SimdType V, SimdType W> requires IsCompatible<T, U, V, W>
T	HermiteImpl (const T &firstPosition, const U &firstTangent, const V &secondPosition, const W &secondTangent, typename T::value_type t) noexcept
	Calculates the Hermite spline interpolation, using the specified arguments.
template<SimdType S, SimdType T, SimdType U, SimdType V, SimdType W> requires IsCompatible<S, T, U, V, W>
S	BaryCentricImpl (const S &p1, const T &p2, const U &p3, const V &f, const W &g) noexcept
	Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.
template<SimdType S, SimdType T, SimdType U, SimdType V, SimdType W> requires IsCompatible<S, T, U, V, W>
S	CatmullRomImpl (const S &p1, const T &p2, const U &p3, const V &p4, const W &t) noexcept
	Calculates the Catmull-Rom interpolation, using the specified positions.
template<SimdType S, SimdType T, SimdType U, SimdType V> requires IsCompatible<S, T, U, V>
S	CatmullRomImpl (const S &p1, const T &p2, const U &p3, const V &p4, const typename S::value_type t) noexcept
	Calculates the Catmull-Rom interpolation, using the specified positions.
template<typename FloatT , size_t N>
constexpr size_t	MinIndex (const std::array< FloatT, N > &values, size_t first, size_t second)
template<typename FloatT , size_t N>
constexpr size_t	MaxIndex (const std::array< FloatT, N > &values, size_t first, size_t second)
template<VectorSimdType S, VectorSimdType T> requires IsCompatible<S, T>
S	AngleBetweenImpl (const S &v1, const T &v2) noexcept
	Calculates the angle in radians between two vectors.
template<VectorSimdType S, VectorSimdType T> requires IsCompatible<S, T>
S	AngleBetweenNormalizedImpl (const S &v1, const T &v2) noexcept
	Calculates the angle in radians between two normalized vectors.
template<PointSimdType S, PointSimdType T, PointSimdType U> requires IsCompatible<S, T>&& IsCompatible<S, U>
S	LinePointDistanceImpl (const S &linePoint1, const T &linePoint2, const U &point) noexcept
	Calculates the minimum distance between a line and a point.
template<QuaternionSimdType T>
constexpr const T::SIMDType	ToSimd (const T &q) noexcept
template<QuaternionType T>
const T::Simd	ToSimdType (const T &q) noexcept
template<QuaternionSimdType T>
T	InverseImpl (const T &q) noexcept
	Calculates the inverse of a quaternion.
template<QuaternionSimdType T>
T	LogImpl (const T &q1) noexcept
	Calculates the natural logarithm of a unit quaternion.
template<SimdType S, QuaternionSimdType T> requires ( S::Size == 3 )
S	RotateImpl (const S &v, const T &rotationQuaternion)
	Rotates a vector using a quaternion.
template<SimdType S, QuaternionSimdType T> requires ( S::Size == 3 )
S	InverseRotateImpl (const S &v, const T &rotationQuaternion)
	Rotates a vector using the inverse of a quaternion.
template<size_t N, size_t... I, typename FloatT , typename... Args>
constexpr void	InitMatrix (std::index_sequence< I... >, std::array< std::array< FloatT, N >, N > &dest, Args... args)
template<size_t N, size_t... I, typename FloatT , typename... Args>
constexpr void	InitDiagonalMatrix (std::index_sequence< I... >, std::array< std::array< FloatT, N >, N > &dest, Args... args)
template<SquareMatrixSimdType T>
const auto &	ToSimd (const T &m)
template<SquareMatrixType T>
auto	ToSimd (const T &m)
template<SquareMatrixSimdType T>
const auto &	ToSimdType (const T &m)
template<SquareMatrixType T>
auto	ToSimdType (const T &m)
template<SquareMatrixSimdType T1, SquareMatrixSimdType T2> requires IsCompatibleMatrix<T1, T2>
T1	AddImpl (const T1 &m1, const T2 &m2) noexcept
template<SquareMatrixSimdType T1, SquareMatrixSimdType T2> requires IsCompatibleMatrix<T1, T2>
T1	SubImpl (const T1 &m1, const T2 &m2) noexcept
template<SquareMatrixSimdType T1, ArithmeticType T2>
T1	MulImpl (const T1 &m, const T2 value) noexcept
template<SquareMatrixSimdType T1, ArithmeticType T2>
T1	DivImpl (const T1 &m, const T2 value) noexcept
SquareMatrix< float, 4 >::Simd	TransformationMatrixImpl (const Point3f::Simd &scalingOrigin, const Quaternion< float >::Simd &scalingOrientationQuaternion, const Vector< float, 3 >::Simd &scaling, const Point3f::Simd &rotationOrigin, const Quaternion< float >::Simd &rotationQuaternion, const Vector< float, 3 >::Simd &translation) noexcept
	Creates a transformation matrix.
template<SimdType S, SimdType T, typename U , SimdType W> requires ( S::Size > 2 ) && ( T::Size > 2 ) && ( W::Size > 2 ) && IsFloatingPoint<U>&& std::is_same_v<typename S::value_type, U>&& std::is_same_v<typename T::value_type, U>&& std::is_same_v<typename W::value_type, U>
SquareMatrix< U, 4 >::Simd	AffineTransformationMatrixImpl (const S &scaling, const T &rotationOrigin, const QuaternionSimd< Quaternion< U > > &rotationQuaternion, const W &translation) noexcept
	Creates an affine transformation matrix.
template<SimdType S, SimdType T, SimdType U> requires IsCompatible<S, T, U> && ( S::Size == 3 )
SquareMatrix< typenameS::value_type, 4 >::Simd	LookToImpl (const S &cameraPosition, const T &cameraDirection, const U &upDirection) noexcept
	Creates a view matrix using the left-handed coordinate system for the provided camera position, camera direction, and up direction.
template<FloatingPointType T>
void	RankDecompose (T x, T y, T z, size_t &a, size_t &b, size_t &c)

Variables
template<typename T >
constexpr bool	IsComplex = std::is_same_v<std::remove_cvref_t<T>, std::complex<float>> || std::is_same_v<std::remove_cvref_t<T>, std::complex<double>>
template<typename ... Args>
constexpr bool	HasSimdType = ( SimdType<Args> || ... )
template<typename ... Args>
constexpr bool	AllAreSimdType = ( SimdType<Args> && ... )
template<typename ... Args>
constexpr bool	HasTupleType = ( TupleType<Args> || ... )
template<typename ... Args>
constexpr bool	AllAreTupleType = ( TupleType<Args> && ... )
template<typename ... Args>
constexpr bool	HasSimdOrTupleType = ( SimdOrTupleType<Args> || ... )
template<typename ... Args>
constexpr bool	AllAreSimdOrTupleType = ( SimdOrTupleType<Args> && ... )
template<QuaternionOrQuaternionSimdType ... Args>
constexpr bool	HasQuaternionSimdType = ( QuaternionSimdType<Args> || ... )
template<QuaternionOrQuaternionSimdType ... Args>
constexpr bool	HasQuaternionType = ( QuaternionType<Args> || ... )
template<SquareMatrixOrSquareMatrixSimdType ... T>
constexpr bool	HasSquareMatrixSimdType = ( SquareMatrixSimdType<T> || ... )
template<SquareMatrixOrSquareMatrixSimdType ... T>
constexpr bool	HasSquareMatrixType = ( SquareMatrixType<T> || ... )

Typedef Documentation

MakeResultType

template<SimdOrTupleType T>

using Harlinn::Math::Internal::MakeResultType = std::conditional_t< SimdType<T>, T, typename T::Simd >

Function Documentation

AbsImpl()

template<FloatingPointType T>

T Harlinn::Math::Internal::AbsImpl ( T val )

inlineconstexprnoexcept

AddAnglesImpl()

template<SimdType T, SimdType U>
requires IsCompatible<T, U>

T Harlinn::Math::Internal::AddAnglesImpl ( const T & v1, const U & v2 )

inlinenoexcept

Adds the angles in the corresponding elements of v1 and v2. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)

AddImpl()

template<SquareMatrixSimdType T1, SquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2>

T1 Harlinn::Math::Internal::AddImpl ( const T1 & m1, const T2 & m2 )

inlinenoexcept

AffineTransformationMatrixImpl()

template<SimdType S, SimdType T, typename U , SimdType W>
requires ( S::Size > 2 ) && ( T::Size > 2 ) && ( W::Size > 2 ) && IsFloatingPoint<U>&& std::is_same_v<typename S::value_type, U>&& std::is_same_v<typename T::value_type, U>&& std::is_same_v<typename W::value_type, U>

SquareMatrix< U, 4 >::Simd Harlinn::Math::Internal::AffineTransformationMatrixImpl ( const S & scaling, const T & rotationOrigin, const QuaternionSimd< Quaternion< U > > & rotationQuaternion, const W & translation )

inlinenoexcept

Creates an affine transformation matrix.

Parameters

scaling	The scaling factors for each dimension.
rotationOrigin	The center of rotation.
rotationQuaternion	Rotation factors as a quaternion.
translation	The translation offsets.

Returns

AngleBetweenImpl()

template<VectorSimdType S, VectorSimdType T>
requires IsCompatible<S, T>

S Harlinn::Math::Internal::AngleBetweenImpl ( const S & v1, const T & v2 )

inlinenoexcept

Calculates the angle in radians between two vectors.

Parameters

v1	The first vector.
v2	The second vector.

Returns

A vector where with each element set to the angle between the two argument vectors.

AngleBetweenNormalizedImpl()

template<VectorSimdType S, VectorSimdType T>
requires IsCompatible<S, T>

S Harlinn::Math::Internal::AngleBetweenNormalizedImpl ( const S & v1, const T & v2 )

inlinenoexcept

Calculates the angle in radians between two normalized vectors.

Parameters

v1	The first normalized vector.
v2

The second normalized vector.

Returns

A vector where with each element set to the angle between the two argument vectors.

BaryCentricImpl()

template<SimdType S, SimdType T, SimdType U, SimdType V, SimdType W>
requires IsCompatible<S, T, U, V, W>

S Harlinn::Math::Internal::BaryCentricImpl ( const S & p1, const T & p2, const U & p3, const V & f, const W & g )

inlinenoexcept

Calculates a point in Barycentric coordinates, using the specified triangle. https://en.wikipedia.org/wiki/Barycentric_coordinate_system.

Parameters

p1	The first position.
p2	The second position.
p3	The third position.
f	Weighting factor.
g	Weighting factor.

CatmullRomImpl() [1/2]

template<SimdType S, SimdType T, SimdType U, SimdType V>
requires IsCompatible<S, T, U, V>

S Harlinn::Math::Internal::CatmullRomImpl ( const S & p1, const T & p2, const U & p3, const V & p4, const typename S::value_type t )

inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters

p1	The first position.
p2	The second position.
p3	The third position.
p4	The fourth position.
t	The interpolation control factors.

CatmullRomImpl() [2/2]

template<SimdType S, SimdType T, SimdType U, SimdType V, SimdType W>
requires IsCompatible<S, T, U, V, W>

S Harlinn::Math::Internal::CatmullRomImpl ( const S & p1, const T & p2, const U & p3, const V & p4, const W & t )

inlinenoexcept

Calculates the Catmull-Rom interpolation, using the specified positions.

Parameters

p1	The first position.
p2	The second position.
p3	The third position.
p4	The fourth position.
t	The interpolation control factors.

ClampLengthImpl()

template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U>

S Harlinn::Math::Internal::ClampLengthImpl ( const S & v, const T & lengthMin, const U & lengthMax )

inlinenoexcept

CopySignImpl()

template<FloatingPointType T>

T Harlinn::Math::Internal::CopySignImpl ( T magnitudeVal, T signVal )

inlineconstexprnoexcept

Returns a value with the magnitude of magnitudeVal and the sign of signVal.

Template Parameters

T	floating point type

Parameters

magnitudeVal	Value with the magnitude of the resulting value.
sourceVal	Value with the sign of the resulting value.

Returns

The value with the magnitude of magnitudeVal and the sign of signVal.

DivImpl()

template<SquareMatrixSimdType T1, ArithmeticType T2>

T1 Harlinn::Math::Internal::DivImpl ( const T1 & m, const T2 value )

noexcept

Exp10Impl() [1/2]

double Harlinn::Math::Internal::Exp10Impl ( double x )

constexprnoexcept

Exp10Impl() [2/2]

float Harlinn::Math::Internal::Exp10Impl ( float x )

constexprnoexcept

FloatToHalf()

UInt16 Harlinn::Math::Internal::FloatToHalf ( float value )

constexpr

HalfToFloat()

float Harlinn::Math::Internal::HalfToFloat ( const UInt16 value )

constexpr

HermiteImpl()

template<SimdType T, SimdType U, SimdType V, SimdType W>
requires IsCompatible<T, U, V, W>

T Harlinn::Math::Internal::HermiteImpl ( const T & firstPosition, const U & firstTangent, const V & secondPosition, const W & secondTangent, typename T::value_type t )

inlinenoexcept

Calculates the Hermite spline interpolation, using the specified arguments.

InitDiagonalMatrix()

template<size_t N, size_t... I, typename FloatT , typename... Args>

void Harlinn::Math::Internal::InitDiagonalMatrix ( std::index_sequence< I... > , std::array< std::array< FloatT, N >, N > & dest, Args... args )

inlineconstexpr

InitMatrix()

template<size_t N, size_t... I, typename FloatT , typename... Args>

void Harlinn::Math::Internal::InitMatrix ( std::index_sequence< I... > , std::array< std::array< FloatT, N >, N > & dest, Args... args )

inlineconstexpr

InnerProduct() [1/2]

template<typename FloatT >
requires IsFloatingPoint<FloatT>

CompensatedFloat< FloatT > Harlinn::Math::Internal::InnerProduct ( FloatT a, FloatT b )

constexpr

InnerProduct() [2/2]

template<typename FloatT , typename... T>
requires IsFloatingPoint<FloatT>

CompensatedFloat< FloatT > Harlinn::Math::Internal::InnerProduct ( FloatT a, FloatT b, T... terms )

inlineconstexpr

InverseImpl()

template<QuaternionSimdType T>

T Harlinn::Math::Internal::InverseImpl ( const T & q )

noexcept

Calculates the inverse of a quaternion.

Parameters

q	The quaternion.

Returns

The inverse quaternion.

InverseRotateImpl()

template<SimdType S, QuaternionSimdType T>
requires ( S::Size == 3 )

S Harlinn::Math::Internal::InverseRotateImpl	(	const S &	v,
		const T &	rotationQuaternion )

Rotates a vector using the inverse of a quaternion.

Parameters

v	The vector to rotate.
rotationQuaternion	Quaternion describing the rotation to apply to the vector.

Returns

The rotated vector.

IsInfImpl()

template<FloatingPointType T>

bool Harlinn::Math::Internal::IsInfImpl ( T val )

inlineconstexprnoexcept

IsNaNImpl()

template<FloatingPointType T>

bool Harlinn::Math::Internal::IsNaNImpl ( T val )

inlineconstexprnoexcept

LerpImpl()

template<FloatingPointType T>

T Harlinn::Math::Internal::LerpImpl ( T a, T b, T t )

constexprnoexcept

LinePointDistanceImpl()

template<PointSimdType S, PointSimdType T, PointSimdType U>
requires IsCompatible<S, T>&& IsCompatible<S, U>

S Harlinn::Math::Internal::LinePointDistanceImpl ( const S & linePoint1, const T & linePoint2, const U & point )

inlinenoexcept

Calculates the minimum distance between a line and a point.

Parameters

linePoint1	First point on the line.
linePoint2	Second point on the line.
point	The reference point.

Returns

The minimum distance between a line and a point.

LogImpl()

template<QuaternionSimdType T>

T Harlinn::Math::Internal::LogImpl ( const T & q1 )

noexcept

Calculates the natural logarithm of a unit quaternion.

Parameters

q1	The unit quaternion.

Returns

The natural logarithm of q1.

LookToImpl()

template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U> && ( S::Size == 3 )

SquareMatrix< typenameS::value_type, 4 >::Simd Harlinn::Math::Internal::LookToImpl ( const S & cameraPosition, const T & cameraDirection, const U & upDirection )

inlinenoexcept

Creates a view matrix using the left-handed coordinate system for the provided camera position, camera direction, and up direction.

Parameters

cameraPosition	The camera position.
cameraDirection	The camera direction.
upDirection	The up direction of the camera, often [0 1 0]

Returns

The view matrix transforming coordinates from world space to view space.

MaxImpl()

template<FloatingPointType T>

T Harlinn::Math::Internal::MaxImpl ( T x, T y )

inlineconstexpr

MaxIndex()

template<typename FloatT , size_t N>

size_t Harlinn::Math::Internal::MaxIndex ( const std::array< FloatT, N > & values, size_t first, size_t second )

constexpr

MinImpl()

template<FloatingPointType T>

T Harlinn::Math::Internal::MinImpl ( T x, T y )

inlineconstexpr

MinIndex()

template<typename FloatT , size_t N>

size_t Harlinn::Math::Internal::MinIndex ( const std::array< FloatT, N > & values, size_t first, size_t second )

constexpr

ModAnglesImpl()

template<SimdType T>

T Harlinn::Math::Internal::ModAnglesImpl ( const T & angles )

inline

Calculates the angle modulo 2PI.

Template Parameters

T	A TupleN SimdType

Parameters

angles

The angles in radians

Returns

Returns a SimdType holding the angles modulo 2PI.

MulImpl()

template<SquareMatrixSimdType T1, ArithmeticType T2>

T1 Harlinn::Math::Internal::MulImpl ( const T1 & m, const T2 value )

noexcept

RankDecompose()

template<FloatingPointType T>

void Harlinn::Math::Internal::RankDecompose	(	T	x,
		T	y,
		T	z,
		size_t &	a,
		size_t &	b,
		size_t &	c )

ReflectImpl()

template<SimdType S, SimdType T>
requires IsCompatible<S, T>

S Harlinn::Math::Internal::ReflectImpl ( const S & incident, const T & normal )

inlinenoexcept

Reflects an incident vector across a normal vector.

Parameters

incident	Incident vector to reflect.
normal	Normal vector to reflect the incident vector across.

Returns

The reflected incident angle.

RefractImpl()

template<SimdType S, SimdType T, SimdType U>
requires IsCompatible<S, T, U>

S Harlinn::Math::Internal::RefractImpl ( const S & incident, const T & normal, const U & refractionIndex )

inlinenoexcept

Refracts an incident vector across a normal vector.

Parameters

incident	The incident vector to refract.
normal	The normal vector to refract the incident vector through.
refractionIndex	A vector whose elements are equal to the index of refraction.

Returns

Returns the refracted incident vector. If the refraction index and the angle between the incident vector and the normal are such that the result is a total internal reflection, the function will return a vector with all elements set to zero.

RotateImpl()

template<SimdType S, QuaternionSimdType T>
requires ( S::Size == 3 )

S Harlinn::Math::Internal::RotateImpl	(	const S &	v,
		const T &	rotationQuaternion )

Rotates a vector using a quaternion.

Parameters

v	The vector to rotate.
rotationQuaternion	Quaternion describing the rotation to apply to the vector.

Returns

The rotated vector.

SignBitImpl()

template<FloatingPointType T>

bool Harlinn::Math::Internal::SignBitImpl ( T val )

inlineconstexprnoexcept

SubImpl()

template<SquareMatrixSimdType T1, SquareMatrixSimdType T2>
requires IsCompatibleMatrix<T1, T2>

T1 Harlinn::Math::Internal::SubImpl ( const T1 & m1, const T2 & m2 )

inlinenoexcept

SubtractAnglesImpl()

template<SimdType T, SimdType U>
requires IsCompatible<T, U>

T Harlinn::Math::Internal::SubtractAnglesImpl ( const T & v1, const U & v2 )

inlinenoexcept

Subtracts the angles in v2 from the corresponding elements of v1. The argument angles must be in the range [-PI,PI), and the computed angles will be in the range [-PI,PI)

ToSimd() [1/5]

template<SquareMatrixSimdType T>

const auto & Harlinn::Math::Internal::ToSimd

(

const T &

m

)

ToSimd() [2/5]

template<SquareMatrixType T>

auto Harlinn::Math::Internal::ToSimd

(

const T &

m

)

ToSimd() [3/5]

template<QuaternionSimdType T>

const T::SIMDType Harlinn::Math::Internal::ToSimd ( const T & q )

inlineconstexprnoexcept

ToSimd() [4/5]

template<SimdType T>

T::SIMDType Harlinn::Math::Internal::ToSimd ( const T & v )

constexprnoexcept

ToSimd() [5/5]

template<TupleType T>

T::SIMDType Harlinn::Math::Internal::ToSimd ( const T & v )

inlinenoexcept

ToSimdType() [1/5]

template<SquareMatrixSimdType T>

const auto & Harlinn::Math::Internal::ToSimdType

(

const T &

m

)

ToSimdType() [2/5]

template<SquareMatrixType T>

auto Harlinn::Math::Internal::ToSimdType

(

const T &

m

)

ToSimdType() [3/5]

template<QuaternionType T>

const T::Simd Harlinn::Math::Internal::ToSimdType ( const T & q )

inlinenoexcept

ToSimdType() [4/5]

template<SimdType T>

const T & Harlinn::Math::Internal::ToSimdType ( const T & v )

inlineconstexprnoexcept

ToSimdType() [5/5]

template<TupleType T>

T::Simd Harlinn::Math::Internal::ToSimdType ( const T & v )

noexcept

TransformationMatrixImpl()

SquareMatrix< float, 4 >::Simd Harlinn::Math::Internal::TransformationMatrixImpl ( const Point3f::Simd & scalingOrigin, const Quaternion< float >::Simd & scalingOrientationQuaternion, const Vector< float, 3 >::Simd & scaling, const Point3f::Simd & rotationOrigin, const Quaternion< float >::Simd & rotationQuaternion, const Vector< float, 3 >::Simd & translation )

inlinenoexcept

Creates a transformation matrix.

Parameters

scalingOrigin	The center of the scaling.
scalingOrientationQuaternion	The orientation of the scaling.
scaling	The scaling factors for the x-axis, y-axis, and z-axis.
rotationOrigin	The center of the rotation.
rotationQuaternion	The rotation around the origin provided by rotationOrigin parameter.
translation	The translations along the x-axis, y-axis, and z-axis.

Returns

The transformation matrix.

Variable Documentation

AllAreSimdOrTupleType

template<typename ... Args>

bool Harlinn::Math::Internal::AllAreSimdOrTupleType = ( SimdOrTupleType<Args> && ... )

constexpr

AllAreSimdType

template<typename ... Args>

bool Harlinn::Math::Internal::AllAreSimdType = ( SimdType<Args> && ... )

constexpr

AllAreTupleType

template<typename ... Args>

bool Harlinn::Math::Internal::AllAreTupleType = ( TupleType<Args> && ... )

constexpr

HasQuaternionSimdType

template<QuaternionOrQuaternionSimdType ... Args>

bool Harlinn::Math::Internal::HasQuaternionSimdType = ( QuaternionSimdType<Args> || ... )

constexpr

HasQuaternionType

template<QuaternionOrQuaternionSimdType ... Args>

bool Harlinn::Math::Internal::HasQuaternionType = ( QuaternionType<Args> || ... )

constexpr

HasSimdOrTupleType

template<typename ... Args>

bool Harlinn::Math::Internal::HasSimdOrTupleType = ( SimdOrTupleType<Args> || ... )

constexpr

HasSimdType

template<typename ... Args>

bool Harlinn::Math::Internal::HasSimdType = ( SimdType<Args> || ... )

constexpr

HasSquareMatrixSimdType

template<SquareMatrixOrSquareMatrixSimdType ... T>

bool Harlinn::Math::Internal::HasSquareMatrixSimdType = ( SquareMatrixSimdType<T> || ... )

constexpr

HasSquareMatrixType

template<SquareMatrixOrSquareMatrixSimdType ... T>

bool Harlinn::Math::Internal::HasSquareMatrixType = ( SquareMatrixType<T> || ... )

constexpr

HasTupleType

template<typename ... Args>

bool Harlinn::Math::Internal::HasTupleType = ( TupleType<Args> || ... )

constexpr

IsComplex

template<typename T >

bool Harlinn::Math::Internal::IsComplex = std::is_same_v<std::remove_cvref_t<T>, std::complex<float>> || std::is_same_v<std::remove_cvref_t<T>, std::complex<double>>

inlineconstexpr