A 3-component vector class. More...

#include <Vec3.h>

Public Types
using	ComponentType = Type

Public Member Functions
	EZ_DECLARE_POD_TYPE ()

	ezVec3Template ()
	default-constructed vector is uninitialized (for speed)

	ezVec3Template (Type x, Type y, Type z)
	Initializes the vector with x,y,z.

	ezVec3Template (Type v)
	Initializes all 3 components with xyz.

const ezVec2Template< Type >	GetAsVec2 () const
	Returns an ezVec2Template with x and y from this vector.

const ezVec4Template< Type >	GetAsVec4 (Type w) const
	Returns an ezVec4Template with x,y,z from this vector and w set to the parameter.

const ezVec4Template< Type >	GetAsPositionVec4 () const
	Returns an ezVec4Template with x,y,z from this vector and w set 1.

const ezVec4Template< Type >	GetAsDirectionVec4 () const
	Returns an ezVec4Template with x,y,z from this vector and w set 0.

const Type *	GetData () const
	Returns the data as an array.

Type *	GetData ()
	Returns the data as an array.

void	Set (Type xyz)
	Sets all 3 components to this value.

void	Set (Type x, Type y, Type z)
	Sets the vector to these values.

void	SetZero ()
	Sets the vector to all zero.

EZ_DECLARE_IF_FLOAT_TYPE Type	GetLength () const
	Returns the length of the vector.

EZ_DECLARE_IF_FLOAT_TYPE Type	GetDistanceTo (const ezVec3Template< Type > &rhs) const
	Returns the length between this position and rhs.

EZ_DECLARE_IF_FLOAT_TYPE Type	GetSquaredDistanceTo (const ezVec3Template< Type > &rhs) const
	Returns the squared length between this position and rhs.

EZ_DECLARE_IF_FLOAT_TYPE ezResult	SetLength (Type fNewLength, Type fEpsilon=ezMath::DefaultEpsilon< Type >())
	Tries to rescale the vector to the given length. If the vector is too close to zero, EZ_FAILURE is returned and the vector is set to zero.

Type	GetLengthSquared () const
	Returns the squared length. Faster, since no square-root is taken. Useful, if one only wants to compare the lengths of two vectors.

EZ_DECLARE_IF_FLOAT_TYPE Type	GetLengthAndNormalize ()
	Normalizes this vector and returns its previous length in one operation. More efficient than calling GetLength and then Normalize.

EZ_DECLARE_IF_FLOAT_TYPE const ezVec3Template< Type >	GetNormalized () const
	Returns a normalized version of this vector, leaves the vector itself unchanged.

EZ_DECLARE_IF_FLOAT_TYPE void	Normalize ()
	Normalizes this vector.

EZ_DECLARE_IF_FLOAT_TYPE ezResult	NormalizeIfNotZero (const ezVec3Template< Type > &vFallback=ezVec3Template< Type >(1, 0, 0), Type fEpsilon=ezMath::SmallEpsilon< Type >())
	Tries to normalize this vector. If the vector is too close to zero, EZ_FAILURE is returned and the vector is set to the given fallback value.

bool	IsZero () const
	Returns, whether this vector is (0, 0, 0).

bool	IsZero (Type fEpsilon) const
	Returns, whether this vector is (0, 0, 0) within a given epsilon.

EZ_DECLARE_IF_FLOAT_TYPE bool	IsNormalized (Type fEpsilon=ezMath::HugeEpsilon< Type >()) const
	Returns, whether the squared length of this vector is between 0.999f and 1.001f.

bool	IsNaN () const
	Returns true, if any of x, y or z is NaN.

bool	IsValid () const
	Checks that all components are finite numbers.

const ezVec3Template< Type >	operator- () const
	Returns the negation of this vector.

void	operator+= (const ezVec3Template< Type > &rhs)
	Adds rhs component-wise to this vector.

void	operator-= (const ezVec3Template< Type > &rhs)
	Subtracts rhs component-wise from this vector.

void	operator*= (const ezVec3Template< Type > &rhs)
	Multiplies rhs component-wise to this vector.

void	operator/= (const ezVec3Template< Type > &rhs)
	Divides this vector component-wise by rhs.

void	*operator=** (Type f)
	Multiplies all components of this vector with f.

void	operator/= (Type f)
	Divides all components of this vector by f.

bool	IsIdentical (const ezVec3Template< Type > &rhs) const
	Equality Check (bitwise)

bool	IsEqual (const ezVec3Template< Type > &rhs, Type fEpsilon) const
	Equality Check with epsilon.

ezAngle	GetAngleBetween (const ezVec3Template< Type > &rhs) const
	Returns the shortest angle between *this and rhs. Both this and rhs must be normalized.

ezAngle	GetAngleBetween (const ezVec3Template< Type > &vForward, const ezVec3Template< Type > &vUp) const
	Returns the angle between vForward and *this, going around the vUp direction.

Type	Dot (const ezVec3Template< Type > &rhs) const
	Returns the Dot-product of the two vectors (commutative, order does not matter)

const ezVec3Template< Type >	CrossRH (const ezVec3Template< Type > &rhs) const
	Returns the Cross-product of the two vectors (NOT commutative, order DOES matter)

const ezVec3Template< Type >	CompMin (const ezVec3Template< Type > &rhs) const
	Returns the component-wise minimum of *this and rhs.

const ezVec3Template< Type >	CompMax (const ezVec3Template< Type > &rhs) const
	Returns the component-wise maximum of *this and rhs.

const ezVec3Template< Type >	CompClamp (const ezVec3Template< Type > &vLow, const ezVec3Template< Type > &vHigh) const
	Returns the component-wise clamped value of *this between low and high.

const ezVec3Template< Type >	CompMul (const ezVec3Template< Type > &rhs) const
	Returns the component-wise multiplication of *this and rhs.

const ezVec3Template< Type >	CompDiv (const ezVec3Template< Type > &rhs) const
	Returns the component-wise division of *this and rhs.

const ezVec3Template< Type >	Abs () const
	brief Returns the component-wise absolute of *this.

EZ_DECLARE_IF_FLOAT_TYPE ezResult	CalculateNormal (const ezVec3Template< Type > &v1, const ezVec3Template< Type > &v2, const ezVec3Template< Type > &v3)
	Calculates the normal of the triangle defined by the three vertices. Vertices are assumed to be ordered counter-clockwise.

EZ_DECLARE_IF_FLOAT_TYPE void	MakeOrthogonalTo (const ezVec3Template< Type > &vNormal)
	Modifies this direction vector to be orthogonal to the given (normalized) direction vector. The result is NOT normalized.

EZ_DECLARE_IF_FLOAT_TYPE const ezVec3Template< Type >	GetOrthogonalVector () const
	Returns some arbitrary vector orthogonal to this one. The vector is NOT normalized.

EZ_DECLARE_IF_FLOAT_TYPE const ezVec3Template< Type >	GetReflectedVector (const ezVec3Template< Type > &vNormal) const
	Returns this vector reflected at vNormal.

EZ_DECLARE_IF_FLOAT_TYPE const ezVec3Template< Type >	GetRefractedVector (const ezVec3Template< Type > &vNormal, Type fRefIndex1, Type fRefIndex2) const
	Returns this vector, refracted at vNormal, using the refraction index of the current medium and the medium it enters.

Static Public Member Functions
static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeNaN ()
	Returns a vector with all components set to Not-a-Number (NaN).

static ezVec3Template< Type >	MakeZero ()
	Returns a vector with all components set to zero.

static ezVec3Template< Type >	MakeAxisX ()
	Returns a vector initialized to the X unit vector (1, 0, 0).

static ezVec3Template< Type >	MakeAxisY ()
	Returns a vector initialized to the Y unit vector (0, 1, 0).

static ezVec3Template< Type >	MakeAxisZ ()
	Returns a vector initialized to the Z unit vector (0, 0, 1).

static ezVec3Template< Type >	Make (Type x, Type y, Type z)
	Returns a vector initialized to x,y,z.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeOrthogonalVector (const ezVec3Template< Type > &vDirection, const ezVec3Template< Type > &vBasis1=MakeAxisX(), const ezVec3Template< Type > &vBasis2=MakeAxisY())
	Returns a vector that is orthogonal to vDirection.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomPointInSphere (ezRandom &inout_rng)
	Returns a random point inside a unit sphere (radius 1).

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomDirection (ezRandom &inout_rng)
	Creates a random direction vector. The vector is normalized.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomDeviationX (ezRandom &inout_rng, const ezAngle &maxDeviation)
	Creates a random vector around the x axis with a maximum deviation angle of maxDeviation. The vector is normalized. The deviation angle must be larger than zero.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomDeviationY (ezRandom &inout_rng, const ezAngle &maxDeviation)
	Creates a random vector around the y axis with a maximum deviation angle of maxDeviation. The vector is normalized. The deviation angle must be larger than zero.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomDeviationZ (ezRandom &inout_rng, const ezAngle &maxDeviation)
	Creates a random vector around the z axis with a maximum deviation angle of maxDeviation. The vector is normalized. The deviation angle must be larger than zero.

static EZ_DECLARE_IF_FLOAT_TYPE ezVec3Template< Type >	MakeRandomDeviation (ezRandom &inout_rng, const ezAngle &maxDeviation, const ezVec3Template< Type > &vNormal)
	Creates a random vector around the given normal with a maximum deviation.

Public Attributes
Type	x

Type	y

Type	z

Detailed Description

template<typename Type>
class ezVec3Template< Type >

A 3-component vector class.

Member Function Documentation

◆ GetAngleBetween()

template<typename Type >

ezAngle ezVec3Template< Type >::GetAngleBetween	(	const ezVec3Template< Type > &	vForward,
		const ezVec3Template< Type > &	vUp
	)		const

Returns the angle between vForward and *this, going around the vUp direction.

Clockwise rotations (looking top down) would result in a small angle, counter-clockwise rotations give a large angle (360 degree minus the shortest angle). All vectors must be normalized. vUp must not coincide with vForward, but doesn't need to be orthogonal to it.

NOTE: This function assumes a right-handed coordinate system. If you put in vectors from a left-handed coordinate system, the angles will simply invert.

The order of operands is also important, if you swap this and vForward, the result also inverts.

◆ IsNormalized()

template<typename Type >

EZ_IMPLEMENT_IF_FLOAT_TYPE EZ_FORCE_INLINE bool ezVec3Template< Type >::IsNormalized ( Type fEpsilon = ezMath::HugeEpsilon<Type>() ) const

Returns, whether the squared length of this vector is between 0.999f and 1.001f.

Note: Normalization, especially with SSE is not very precise. So this function checks whether the (squared) length is between a lower and upper limit.

◆ MakeOrthogonalTo()

template<typename Type >

EZ_IMPLEMENT_IF_FLOAT_TYPE void ezVec3Template< Type >::MakeOrthogonalTo ( const ezVec3Template< Type > & vNormal )

Modifies this direction vector to be orthogonal to the given (normalized) direction vector. The result is NOT normalized.

Note: This function may fail, e.g. create a vector that is zero, if the given normal is parallel to the vector itself. If you need to handle such cases, you should manually check afterwards, whether the result is zero, or cannot be normalized.

◆ MakeOrthogonalVector()

template<typename Type >

EZ_IMPLEMENT_IF_FLOAT_TYPE ezVec3Template< Type > ezVec3Template< Type >::MakeOrthogonalVector	(	const ezVec3Template< Type > &	vDirection,
		const ezVec3Template< Type > &	vBasis1 = `MakeAxisX()`,
		const ezVec3Template< Type > &	vBasis2 = `MakeAxisY()`
	)

static

Returns a vector that is orthogonal to vDirection.

Uses the vBasis1 and vBasis2 vectors as candidates to create the orthogonal vector from. The basis that is less similar to the direction will be used to to compute the orthogonal vector.

All input vectors must be normalized.

◆ MakeRandomDeviation()

template<typename Type >

EZ_IMPLEMENT_IF_FLOAT_TYPE ezVec3Template< Type > ezVec3Template< Type >::MakeRandomDeviation	(	ezRandom &	inout_rng,
		const ezAngle &	maxDeviation,
		const ezVec3Template< Type > &	vNormal
	)

static

Creates a random vector around the given normal with a maximum deviation.

Note: If you are going to do this many times with the same axis, rather than calling this function, instead manually do what this function does (see inline code) and only compute the quaternion once.

◆ operator*=()

template<typename Type >

EZ_FORCE_INLINE void ezVec3Template< Type >::operator*= ( const ezVec3Template< Type > & rhs )

Multiplies rhs component-wise to this vector.

Test:: this is new

◆ operator/=()

template<typename Type >

EZ_FORCE_INLINE void ezVec3Template< Type >::operator/= ( const ezVec3Template< Type > & rhs )

Divides this vector component-wise by rhs.

Test:: this is new

The documentation for this class was generated from the following files:

/home/runner/work/ezEngine/ezEngine/Code/Engine/Foundation/Math/Declarations.h
/home/runner/work/ezEngine/ezEngine/Code/Engine/Foundation/Math/Vec3.h
/home/runner/work/ezEngine/ezEngine/Code/Engine/Foundation/Math/Implementation/AllClassesRandom_inl.h
/home/runner/work/ezEngine/ezEngine/Code/Engine/Foundation/Math/Implementation/Vec3_inl.h
/home/runner/work/ezEngine/ezEngine/Code/Engine/Foundation/Math/Implementation/Vec4_inl.h

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ GetAngleBetween()

◆ IsNormalized()

◆ MakeOrthogonalTo()

◆ MakeOrthogonalVector()

◆ MakeRandomDeviation()

◆ operator*=()

◆ operator/=()