Collaboration diagram for Vector3D Types:

Modules
	3D Vector Algebra

	Checks

	Assertions

Classes
struct	BasicVector3D< Type >::BasicRef< RType >

Typedefs
using	Ref = BasicRef< Type >

using	ConstRef = BasicRef< const Type >

Functions
constexpr	BasicRef (RType &x_in, RType &y_in, RType &z_in)

constexpr	BasicRef (const BasicRef &)=default

constexpr	BasicRef (const BasicVector3D< RType > &other)

constexpr BasicRef &	operator= (BasicRef input)

constexpr BasicRef &	operator= (const BasicVector3D< RType > &input)

constexpr	operator BasicVector3D< RType > () const

constexpr	operator std::tuple< RType, RType, RType > () const

constexpr value_type	normSquared () const

constexpr value_type	norm () const

constexpr value_type	magnitudeSquared () const

constexpr value_type	magnitude () const

constexpr BasicVector3D< Type >	normalized () const

Variables
RType &	x

RType &	y

RType &	z

Friends
template<class U > requires Concept::SameUnqualified<RType, U>
constexpr bool	operator== (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr bool	operator== (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator+ (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator+ (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator- (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator- (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator* (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator* (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator* (BasicRef left, const U &scalar)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator* (const U &scalar, BasicRef right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator/ (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator/ (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	operator/ (BasicRef left, const U &scalar)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
constexpr bool	approximately_equal_to (BasicRef value_to_test, BasicRef< U > value_it_should_be, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
constexpr bool	approximately_equal_to (BasicRef value_to_test, const BasicVector3D< U > &value_it_should_be, OT tolerance=OT{0.0002})

constexpr RType	accumulate (BasicRef input)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot_normalized (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot_normalized (BasicRef left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	cross (BasicRef left, BasicRef< U > right)

constexpr BasicVector3D< RType >	normalized (BasicRef input)

constexpr BasicVector3D< RType >	abs (BasicRef input)

constexpr BasicVector3D< RType >	fract (BasicRef input)

constexpr BasicVector3D< RType >	saturate (BasicRef input, RType lower_bound, RType upper_bound)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	lerp (BasicRef input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	lerp (BasicRef input_lower_bound, const BasicVector3D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	mix (BasicRef input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector3D< RType >	mix (BasicRef input_lower_bound, const BasicVector3D< U > &input_upper_bound, float percentage_zero_to_one)

std::string	format (BasicRef input)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_equal (BasicRef input, BasicRef< U > near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_equal (BasicRef input, const BasicVector3D< U > &near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_not_equal (BasicRef input, BasicRef near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_not_equal (BasicRef input, const BasicVector3D< U > &near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_EQUAL (BasicRef input, BasicRef< U > near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_EQUAL (BasicRef input, const BasicVector3D< U > &near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_NOT_EQUAL (BasicRef input, BasicRef< U > near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_NOT_EQUAL (BasicRef input, const BasicVector3D< U > &near_to, OT tolerance=OT{0.0002})

template<std::floating_point OT = float>
void	CHECK_IF_ZERO (BasicRef input, OT tolerance=OT{0.0002})

Types
using	value_type = Type
	The underlying implementation type.

Types
using	value_type = RType
	The underlying implementation type.

Type Aliases
using	Vector3Df = BasicVector3D< float >

using	Vector3Dd = BasicVector3D< double >

using	Vector3D = BasicVector3D< double >

using	Vector3Dl = BasicVector3D< long double >

Element Access
value_type	x {}

value_type	y {}

value_type	z {}

Constructors
constexpr	BasicVector3D ()=default

constexpr	BasicVector3D (const Type &x_in, const Type &y_in=0, const Type &z_in=0)

constexpr	BasicVector3D (const BasicVector2D< Type > &other, Type z_in=0)

constexpr	BasicVector3D (Type x_in, const BasicVector2D< Type > &other)

constexpr	BasicVector3D (const std::tuple< Type, Type, Type > &init_value)

Assignment
constexpr BasicVector3D< Type > &	operator= (const BasicVector3D &other)=default

constexpr BasicVector3D< Type > &	operator= (Ref other)

Conversion Operators
constexpr	operator std::tuple< Type, Type, Type > () const

Constants
static constexpr BasicVector3D< Type >	unit_x ()

static constexpr BasicVector3D< Type >	unit_y ()

static constexpr BasicVector3D< Type >	unit_z ()

static constexpr BasicVector3D< Type >	zero ()

Invalid Value Check
bool	isNaN () const

bool	isInf () const

Swizzle operations
constexpr BasicVector2D< Type >::ConstRef	xy () const &

constexpr BasicVector2D< Type >::Ref	xy () &

constexpr BasicVector2D< Type >	xy () &&

constexpr BasicVector2D< Type >::ConstRef	xz () const &

constexpr BasicVector2D< Type >::Ref	xz () &

constexpr BasicVector2D< Type >	xz () &&

constexpr BasicVector2D< Type >::ConstRef	yx () const &

constexpr BasicVector2D< Type >::Ref	yx () &

constexpr BasicVector2D< Type >	yx () &&

constexpr BasicVector2D< Type >::ConstRef	yz () const &

constexpr BasicVector2D< Type >::Ref	yz () &

constexpr BasicVector2D< Type >	yz () &&

constexpr BasicVector2D< Type >::ConstRef	zx () const &

constexpr BasicVector2D< Type >::Ref	zx () &

constexpr BasicVector2D< Type >	zx () &&

constexpr ConstRef	xyz () const &

constexpr Ref	xyz () &

constexpr BasicVector3D< Type >	xyz () &&

constexpr ConstRef	xzy () const &

constexpr Ref	xzy () &

constexpr BasicVector3D< Type >	xzy () &&

constexpr ConstRef	zxy () const &

constexpr Ref	zxy () &

constexpr BasicVector3D< Type >	zxy () &&

constexpr ConstRef	zyx () const &

constexpr Ref	zyx () &

constexpr BasicVector3D< Type >	zyx () &&

Equality
template<class U > requires Concept::SameUnqualified<Type, U>
constexpr bool	operator== (const BasicVector3D &left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr bool	operator== (const BasicVector3D &left, BasicRef< U > right)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<Type, U>
constexpr bool	approximately_equal_to (const BasicVector3D &value_to_test, const BasicVector3D< U > &value_it_should_be, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<Type, U>
constexpr bool	approximately_equal_to (const BasicVector3D &value_to_test, BasicRef< U > value_it_should_be, OT tolerance=OT{0.0002})

Global Functions
constexpr Type	accumulate (const BasicVector3D< Type > &input)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot (const BasicVector3D &left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot (const BasicVector3D &left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot_normalized (const BasicVector3D &left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot_normalized (const BasicVector3D &left, BasicRef< U > right)

constexpr BasicVector3D< Type >	normalized (const BasicVector3D< Type > &input)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	cross (const BasicVector3D &left, const BasicVector3D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	cross (const BasicVector3D &left, BasicRef< U > right)

constexpr BasicVector3D< Type >	abs (const BasicVector3D< Type > &input)

constexpr BasicVector3D< Type >	fract (const BasicVector3D< Type > &input)

constexpr BasicVector3D< Type >	saturate (const BasicVector3D< Type > &input, Type lower_bound, Type upper_bound)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	lerp (const BasicVector3D &input_lower_bound, const BasicVector3D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	lerp (const BasicVector3D &input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	mix (const BasicVector3D &input_lower_bound, const BasicVector3D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector3D< Type >	mix (const BasicVector3D &input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

std::string	format (const BasicVector3D< Type > &input)

Detailed Description

Here are the type aliases for BasicVector3D

Typedef Documentation

◆ ConstRef

template<class Type >

using ConstRef = BasicRef<const Type>

Definition at line 424 of file Vector3D.hpp.

◆ Ref

template<class Type >

using Ref = BasicRef<Type>

Definition at line 423 of file Vector3D.hpp.

◆ value_type [1/2]

template<class Type >

using value_type = Type

The underlying implementation type.

Definition at line 30 of file Vector3D.hpp.

◆ value_type [2/2]

template<class Type >

template<class RType >

using value_type = RType

The underlying implementation type.

Definition at line 45 of file Vector3D.hpp.

◆ Vector3D

template<class Type >

using Vector3D = BasicVector3D<double>

◆ Vector3Dd

template<class Type >

using Vector3Dd = BasicVector3D<double>

◆ Vector3Df

template<class Type >

using Vector3Df = BasicVector3D<float>

◆ Vector3Dl

template<class Type >

using Vector3Dl = BasicVector3D<long double>

Function Documentation

◆ BasicRef() [1/3]

template<class Type >

template<class RType >

constexpr BasicRef ( const BasicRef< RType > & )

constexprdefault

#include <lib/include/Math/math/Vector3D.hpp>

◆ BasicRef() [2/3]

template<class Type >

template<class RType >

constexpr BasicRef ( const BasicVector3D< RType > & other )

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 50 of file Vector3D.hpp.

◆ BasicRef() [3/3]

template<class Type >

template<class RType >

constexpr BasicRef	(	RType &	x_in,
		RType &	y_in,
		RType &	z_in
	)

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 48 of file Vector3D.hpp.

◆ BasicVector3D() [1/5]

template<class Type >

constexpr BasicVector3D ( )

constexprdefault

#include <lib/include/Math/math/Vector3D.hpp>

◆ BasicVector3D() [2/5]

template<class Type >

constexpr BasicVector3D	(	const BasicVector2D< Type > &	other,
		Type	z_in = `0`
	)

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 437 of file Vector3D.hpp.

◆ BasicVector3D() [3/5]

template<class Type >

constexpr BasicVector3D ( const std::tuple< Type, Type, Type > & init_value )

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 451 of file Vector3D.hpp.

◆ BasicVector3D() [4/5]

template<class Type >

constexpr BasicVector3D	(	const Type &	x_in,
		const Type &	y_in = `0`,
		const Type &	z_in = `0`
	)

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 430 of file Vector3D.hpp.

◆ BasicVector3D() [5/5]

template<class Type >

constexpr BasicVector3D	(	Type	x_in,
		const BasicVector2D< Type > &	other
	)

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 444 of file Vector3D.hpp.

◆ isInf()

template<class Type >

bool isInf ( ) const

inline

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 505 of file Vector3D.hpp.

◆ isNaN()

template<class Type >

bool isNaN ( ) const

inline

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 504 of file Vector3D.hpp.

◆ magnitude()

template<class Type >

constexpr value_type magnitude ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 492 of file Vector3D.hpp.

◆ magnitudeSquared()

template<class Type >

constexpr value_type magnitudeSquared ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 491 of file Vector3D.hpp.

◆ norm()

template<class Type >

constexpr value_type norm ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Todo:: See if we need to use std::hypot()

Definition at line 489 of file Vector3D.hpp.

◆ normalized()

template<class Type >

constexpr BasicVector3D< Type > normalized ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 494 of file Vector3D.hpp.

◆ normSquared()

template<class Type >

constexpr value_type normSquared ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 488 of file Vector3D.hpp.

◆ operator BasicVector3D< RType >()

template<class Type >

template<class RType >

constexpr operator BasicVector3D< RType > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 68 of file Vector3D.hpp.

◆ operator std::tuple< RType, RType, RType >()

template<class Type >

template<class RType >

constexpr operator std::tuple< RType, RType, RType > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 70 of file Vector3D.hpp.

◆ operator std::tuple< Type, Type, Type >()

template<class Type >

constexpr operator std::tuple< Type, Type, Type > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 475 of file Vector3D.hpp.

◆ operator=() [1/4]

template<class Type >

template<class RType >

constexpr BasicRef & operator= ( BasicRef< RType > input )

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 52 of file Vector3D.hpp.

◆ operator=() [2/4]

template<class Type >

constexpr BasicVector3D< Type > & operator= ( const BasicVector3D< Type > & other )

constexprdefault

#include <lib/include/Math/math/Vector3D.hpp>

◆ operator=() [3/4]

template<class Type >

template<class RType >

constexpr BasicRef & operator= ( const BasicVector3D< RType > & input )

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 60 of file Vector3D.hpp.

◆ operator=() [4/4]

template<class Type >

constexpr BasicVector3D< Type > & operator= ( Ref other )

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 464 of file Vector3D.hpp.

◆ unit_x()

template<class Type >

static constexpr BasicVector3D< Type > unit_x ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 481 of file Vector3D.hpp.

◆ unit_y()

template<class Type >

static constexpr BasicVector3D< Type > unit_y ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 482 of file Vector3D.hpp.

◆ unit_z()

template<class Type >

static constexpr BasicVector3D< Type > unit_z ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 483 of file Vector3D.hpp.

◆ xy() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref xy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 512 of file Vector3D.hpp.

◆ xy() [2/3]

template<class Type >

constexpr BasicVector2D< Type > xy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 513 of file Vector3D.hpp.

◆ xy() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef xy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 511 of file Vector3D.hpp.

◆ xyz() [1/3]

template<class Type >

constexpr Ref xyz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 532 of file Vector3D.hpp.

◆ xyz() [2/3]

template<class Type >

constexpr BasicVector3D< Type > xyz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 533 of file Vector3D.hpp.

◆ xyz() [3/3]

template<class Type >

constexpr ConstRef xyz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 531 of file Vector3D.hpp.

◆ xz() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref xz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 516 of file Vector3D.hpp.

◆ xz() [2/3]

template<class Type >

constexpr BasicVector2D< Type > xz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 517 of file Vector3D.hpp.

◆ xz() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef xz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 515 of file Vector3D.hpp.

◆ xzy() [1/3]

template<class Type >

constexpr Ref xzy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 536 of file Vector3D.hpp.

◆ xzy() [2/3]

template<class Type >

constexpr BasicVector3D< Type > xzy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 537 of file Vector3D.hpp.

◆ xzy() [3/3]

template<class Type >

constexpr ConstRef xzy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 535 of file Vector3D.hpp.

◆ yx() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref yx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 520 of file Vector3D.hpp.

◆ yx() [2/3]

template<class Type >

constexpr BasicVector2D< Type > yx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 521 of file Vector3D.hpp.

◆ yx() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef yx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 519 of file Vector3D.hpp.

◆ yz() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref yz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 524 of file Vector3D.hpp.

◆ yz() [2/3]

template<class Type >

constexpr BasicVector2D< Type > yz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 525 of file Vector3D.hpp.

◆ yz() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef yz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 523 of file Vector3D.hpp.

◆ zero()

template<class Type >

static constexpr BasicVector3D< Type > zero ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 485 of file Vector3D.hpp.

◆ zx() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref zx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 528 of file Vector3D.hpp.

◆ zx() [2/3]

template<class Type >

constexpr BasicVector2D< Type > zx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 529 of file Vector3D.hpp.

◆ zx() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef zx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 527 of file Vector3D.hpp.

◆ zxy() [1/3]

template<class Type >

constexpr Ref zxy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 540 of file Vector3D.hpp.

◆ zxy() [2/3]

template<class Type >

constexpr BasicVector3D< Type > zxy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 541 of file Vector3D.hpp.

◆ zxy() [3/3]

template<class Type >

constexpr ConstRef zxy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 539 of file Vector3D.hpp.

◆ zyx() [1/3]

template<class Type >

constexpr Ref zyx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 544 of file Vector3D.hpp.

◆ zyx() [2/3]

template<class Type >

constexpr BasicVector3D< Type > zyx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 545 of file Vector3D.hpp.

◆ zyx() [3/3]

template<class Type >

constexpr ConstRef zyx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 543 of file Vector3D.hpp.

Variable Documentation

◆ x [1/2]

template<class Type >

template<class RType >

RType& x

Definition at line 72 of file Vector3D.hpp.

◆ x [2/2]

template<class Type >

value_type x {}

Definition at line 551 of file Vector3D.hpp.

◆ y [1/2]

template<class Type >

template<class RType >

RType& y

Definition at line 73 of file Vector3D.hpp.

◆ y [2/2]

template<class Type >

value_type y {}

Definition at line 552 of file Vector3D.hpp.

◆ z [1/2]

template<class Type >

template<class RType >

RType& z

Definition at line 74 of file Vector3D.hpp.

◆ z [2/2]

template<class Type >

value_type z {}

Definition at line 553 of file Vector3D.hpp.

Friends

◆ abs [1/2]

template<class Type >

template<class RType >

constexpr BasicVector3D< RType > abs ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 234 of file Vector3D.hpp.

◆ abs [2/2]

template<class Type >

constexpr BasicVector3D< Type > abs ( const BasicVector3D< Type > & input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the absolute value of all components of a BasicVector3D

Parameters

input The BasicVector3D to operate on

Returns: The BasicVector3D with only positive values

Definition at line 856 of file Vector3D.hpp.

◆ accumulate [1/2]

template<class Type >

template<class RType >

constexpr RType accumulate ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 189 of file Vector3D.hpp.

◆ accumulate [2/2]

template<class Type >

constexpr Type accumulate ( const BasicVector3D< Type > & input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Sums up the components of input

Parameters

input The BasicVector3D to operate on

Returns: The sum of all the components

Definition at line 730 of file Vector3D.hpp.

◆ approximately_equal_to [1/4]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

constexpr bool approximately_equal_to	(	BasicRef< RType >	value_to_test,
		BasicRef< U >	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 169 of file Vector3D.hpp.

◆ approximately_equal_to [2/4]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

constexpr bool approximately_equal_to	(	BasicRef< RType >	value_to_test,
		const BasicVector3D< U > &	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 180 of file Vector3D.hpp.

◆ approximately_equal_to [3/4]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

constexpr bool approximately_equal_to	(	const BasicVector3D< Type > &	value_to_test,
		BasicRef< U >	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Compares two BasicVector3D inputs equal, component-wise, to within a tolerance

Parameters

value_to_test
value_it_should_be
tolerance	How close they should be to be considered equal

Returns: true if they are equal

Definition at line 619 of file Vector3D.hpp.

◆ approximately_equal_to [4/4]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

constexpr bool approximately_equal_to	(	const BasicVector3D< Type > &	value_to_test,
		const BasicVector3D< U > &	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Compares two BasicVector3D inputs equal, component-wise, to within a tolerance

Parameters

value_to_test
value_it_should_be
tolerance	How close they should be to be considered equal

Returns: true if they are equal

Definition at line 600 of file Vector3D.hpp.

◆ check_if_equal [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_equal	(	BasicRef< RType >	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 298 of file Vector3D.hpp.

◆ CHECK_IF_EQUAL [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_EQUAL	(	BasicRef< RType >	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 382 of file Vector3D.hpp.

◆ check_if_equal [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_equal	(	BasicRef< RType >	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 319 of file Vector3D.hpp.

◆ CHECK_IF_EQUAL [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_EQUAL	(	BasicRef< RType >	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 391 of file Vector3D.hpp.

◆ check_if_not_equal [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_not_equal	(	BasicRef< RType >	input,
		BasicRef< RType >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 340 of file Vector3D.hpp.

◆ CHECK_IF_NOT_EQUAL [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_NOT_EQUAL	(	BasicRef< RType >	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 400 of file Vector3D.hpp.

◆ check_if_not_equal [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_not_equal	(	BasicRef< RType >	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 361 of file Vector3D.hpp.

◆ CHECK_IF_NOT_EQUAL [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_NOT_EQUAL	(	BasicRef< RType >	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 409 of file Vector3D.hpp.

◆ CHECK_IF_ZERO

template<class Type >

template<class RType >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	BasicRef< RType >	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 417 of file Vector3D.hpp.

◆ cross [1/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > cross	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 224 of file Vector3D.hpp.

◆ cross [2/3]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > cross	(	const BasicVector3D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculates the cross product of two BasicVector3D objects

Parameters

left	The first vector
right	The second vector

Returns: The cross product of the input vectors

Definition at line 843 of file Vector3D.hpp.

◆ cross [3/3]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > cross	(	const BasicVector3D< Type > &	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculates the cross product of two BasicVector3D objects

Parameters

left	The first vector
right	The second vector

Returns: The cross product of the input vectors

Definition at line 827 of file Vector3D.hpp.

◆ dot [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 196 of file Vector3D.hpp.

◆ dot [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 203 of file Vector3D.hpp.

◆ dot [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot	(	const BasicVector3D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the dot product of two BasicVector3D objects

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Note: This is only a strict dot product and thus a normalized result will depend on if the input vectors are both normalized!

Definition at line 766 of file Vector3D.hpp.

◆ dot [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot	(	const BasicVector3D< Type > &	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the dot product of two BasicVector3D objects

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Note: This is only a strict dot product and thus a normalized result will depend on if the input vectors are both normalized!

Definition at line 748 of file Vector3D.hpp.

◆ dot_normalized [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot_normalized	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 210 of file Vector3D.hpp.

◆ dot_normalized [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot_normalized	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 217 of file Vector3D.hpp.

◆ dot_normalized [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot_normalized	(	const BasicVector3D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the normalized dot product of two BasicVector3D objects

The input vectors are not assumed to be normalized, so we go ahead and divide through by both the input vectors to arrive at a normalized output.

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Definition at line 802 of file Vector3D.hpp.

◆ dot_normalized [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot_normalized	(	const BasicVector3D< Type > &	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the normalized dot product of two BasicVector3D objects

The input vectors are not assumed to be normalized, so we go ahead and divide through by both the input vectors to arrive at a normalized output.

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Definition at line 784 of file Vector3D.hpp.

◆ format [1/2]

template<class Type >

template<class RType >

std::string format ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 291 of file Vector3D.hpp.

◆ format [2/2]

template<class Type >

std::string format ( const BasicVector3D< Type > & input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 919 of file Vector3D.hpp.

◆ fract [1/2]

template<class Type >

template<class RType >

constexpr BasicVector3D< RType > fract ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 239 of file Vector3D.hpp.

◆ fract [2/2]

template<class Type >

constexpr BasicVector3D< Type > fract ( const BasicVector3D< Type > & input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Calculate the fractional part of all components of a BasicVector3D

Parameters

input The BasicVector3D to operate on

Returns: The BasicVector3D with only fractional values

Definition at line 867 of file Vector3D.hpp.

◆ lerp [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > lerp	(	BasicRef< RType >	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 257 of file Vector3D.hpp.

◆ lerp [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > lerp	(	BasicRef< RType >	input_lower_bound,
		const BasicVector3D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 266 of file Vector3D.hpp.

◆ lerp [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > lerp	(	const BasicVector3D< Type > &	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 894 of file Vector3D.hpp.

◆ lerp [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > lerp	(	const BasicVector3D< Type > &	input_lower_bound,
		const BasicVector3D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 885 of file Vector3D.hpp.

◆ mix [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > mix	(	BasicRef< RType >	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 275 of file Vector3D.hpp.

◆ mix [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > mix	(	BasicRef< RType >	input_lower_bound,
		const BasicVector3D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 284 of file Vector3D.hpp.

◆ mix [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > mix	(	const BasicVector3D< Type > &	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 912 of file Vector3D.hpp.

◆ mix [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector3D< Type > mix	(	const BasicVector3D< Type > &	input_lower_bound,
		const BasicVector3D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 903 of file Vector3D.hpp.

◆ normalized [1/2]

template<class Type >

template<class RType >

constexpr BasicVector3D< RType > normalized ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 229 of file Vector3D.hpp.

◆ normalized [2/2]

template<class Type >

constexpr BasicVector3D< Type > normalized ( const BasicVector3D< Type > & input )

friend

#include <lib/include/Math/math/Vector3D.hpp>

Creates the normalized form of a BasicVector3D

Parameters

input The BasicVector3D to normalize

Returns: The normalized version of input

Definition at line 813 of file Vector3D.hpp.

◆ operator* [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator*	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 120 of file Vector3D.hpp.

◆ operator* [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator*	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 127 of file Vector3D.hpp.

◆ operator* [3/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator*	(	BasicRef< RType >	left,
		const U &	scalar
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 134 of file Vector3D.hpp.

◆ operator* [4/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator*	(	const U &	scalar,
		BasicRef< RType >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 141 of file Vector3D.hpp.

◆ operator+ [1/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator+	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 92 of file Vector3D.hpp.

◆ operator+ [2/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator+	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 99 of file Vector3D.hpp.

◆ operator- [1/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator-	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 106 of file Vector3D.hpp.

◆ operator- [2/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator-	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 113 of file Vector3D.hpp.

◆ operator/ [1/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator/	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 148 of file Vector3D.hpp.

◆ operator/ [2/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator/	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 155 of file Vector3D.hpp.

◆ operator/ [3/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector3D< RType > operator/	(	BasicRef< RType >	left,
		const U &	scalar
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 162 of file Vector3D.hpp.

◆ operator== [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr bool operator==	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 78 of file Vector3D.hpp.

◆ operator== [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr bool operator==	(	BasicRef< RType >	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 85 of file Vector3D.hpp.

◆ operator== [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr bool operator==	(	const BasicVector3D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Defines equality of a BasicVector3D and BasicRef objects

Note: Uses approximately_equal_to under-the-hood

See also: Equality

Definition at line 585 of file Vector3D.hpp.

◆ operator== [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr bool operator==	(	const BasicVector3D< Type > &	left,
		const BasicVector3D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Defines equality of two BasicVector3D objects

Note: Uses approximately_equal_to under-the-hood

See also: Equality

Definition at line 572 of file Vector3D.hpp.

◆ saturate [1/2]

template<class Type >

template<class RType >

constexpr BasicVector3D< RType > saturate	(	BasicRef< RType >	input,
		RType	lower_bound,
		RType	upper_bound
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 248 of file Vector3D.hpp.

◆ saturate [2/2]

template<class Type >

constexpr BasicVector3D< Type > saturate	(	const BasicVector3D< Type > &	input,
		Type	lower_bound,
		Type	upper_bound
	)

friend

#include <lib/include/Math/math/Vector3D.hpp>

Definition at line 874 of file Vector3D.hpp.

Modules

Classes

Typedefs

Functions

Variables

Friends

Types

Types

Type Aliases

Element Access

Constructors

Assignment

Conversion Operators

Constants

Invalid Value Check

Swizzle operations

Equality

Global Functions

Detailed Description

Typedef Documentation

◆ ConstRef

◆ Ref

◆ value_type [1/2]

◆ value_type [2/2]

◆ Vector3D

◆ Vector3Dd

◆ Vector3Df

◆ Vector3Dl

Function Documentation

◆ BasicRef() [1/3]

◆ BasicRef() [2/3]

◆ BasicRef() [3/3]

◆ BasicVector3D() [1/5]

◆ BasicVector3D() [2/5]

◆ BasicVector3D() [3/5]

◆ BasicVector3D() [4/5]

◆ BasicVector3D() [5/5]

◆ isInf()

◆ isNaN()

◆ magnitude()

◆ magnitudeSquared()

◆ norm()

◆ normalized()

◆ normSquared()

◆ operator BasicVector3D< RType >()

◆ operator std::tuple< RType, RType, RType >()

◆ operator std::tuple< Type, Type, Type >()

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ unit_x()

◆ unit_y()

◆ unit_z()

◆ xy() [1/3]

◆ xy() [2/3]

◆ xy() [3/3]

◆ xyz() [1/3]

◆ xyz() [2/3]

◆ xyz() [3/3]

◆ xz() [1/3]

◆ xz() [2/3]

◆ xz() [3/3]

◆ xzy() [1/3]

◆ xzy() [2/3]

◆ xzy() [3/3]

◆ yx() [1/3]

◆ yx() [2/3]

◆ yx() [3/3]

◆ yz() [1/3]

◆ yz() [2/3]

◆ yz() [3/3]

◆ zero()

◆ zx() [1/3]

◆ zx() [2/3]

◆ zx() [3/3]

◆ zxy() [1/3]

◆ zxy() [2/3]

◆ zxy() [3/3]

◆ zyx() [1/3]