ezEngine  Milestone 9
ezVec3Template< Type > Struct Template Reference

A 3-component vector class. More...

#include <Vec3.h>

Public Types

typedef Type ComponentType
 

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 xyz)
 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.
 
Type GetLength () const
 Returns the length of the vector.
 
ezResult SetLength (Type fNewLength, Type fEpsilon=ezMath::BasicType< Type >::DefaultEpsilon())
 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.
 
Type GetLengthAndNormalize ()
 Normalizes this vector and returns its previous length in one operation. More efficient than calling GetLength and then Normalize.
 
const ezVec3Template GetNormalized () const
 Returns a normalized version of this vector, leaves the vector itself unchanged.
 
void Normalize ()
 Normalizes this vector.
 
ezResult NormalizeIfNotZero (const ezVec3Template &vFallback=ezVec3Template(1, 0, 0), Type fEpsilon=ezMath::BasicType< Type >::SmallEpsilon())
 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.
 
bool IsNormalized (Type fEpsilon=ezMath::BasicType< Type >::HugeEpsilon()) const
 Returns, whether the squared length of this vector is between 0.999f and 1.001f. More...
 
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 operator- () const
 Returns the negation of this vector.
 
void operator+= (const ezVec3Template &rhs)
 Adds rhs component-wise to this vector.
 
void operator-= (const ezVec3Template &rhs)
 Subtracts rhs component-wise from this vector.
 
void operator*= (const ezVec3Template &rhs)
 Multiplies rhs component-wise to this vector. More...
 
void operator/= (const ezVec3Template &rhs)
 Divides this vector component-wise by rhs. More...
 
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 &rhs) const
 Equality Check (bitwise)
 
bool IsEqual (const ezVec3Template &rhs, Type fEpsilon) const
 Equality Check with epsilon.
 
ezAngle GetAngleBetween (const ezVec3Template &rhs) const
 Returns the positive angle between *this and rhs. Both this and rhs must be normalized.
 
Type Dot (const ezVec3Template &rhs) const
 Returns the Dot-product of the two vectors (commutative, order does not matter)
 
const ezVec3Template CrossRH (const ezVec3Template &rhs) const
 Returns the Cross-product of the two vectors (NOT commutative, order DOES matter)
 
const ezVec3Template CompMin (const ezVec3Template &rhs) const
 Returns the component-wise minimum of *this and rhs.
 
const ezVec3Template CompMax (const ezVec3Template &rhs) const
 Returns the component-wise maximum of *this and rhs.
 
const ezVec3Template CompMul (const ezVec3Template &rhs) const
 Returns the component-wise multiplication of *this and rhs.
 
const ezVec3Template CompDiv (const ezVec3Template &rhs) const
 Returns the component-wise division of *this and rhs.
 
const ezVec3Template Abs () const
 brief Returns the component-wise absolute of *this.
 
ezResult CalculateNormal (const ezVec3Template &v1, const ezVec3Template &v2, const ezVec3Template &v3)
 Calculates the normal of the triangle defined by the three vertices. Vertices are assumed to be ordered counter-clockwise.
 
void MakeOrthogonalTo (const ezVec3Template &vNormal)
 Modifies this direction vector to be orthogonal to the given (normalized) direction vector. The result is NOT normalized. More...
 
const ezVec3Template GetOrthogonalVector () const
 Returns some arbitrary vector orthogonal to this one. The vector is NOT normalized.
 
const ezVec3Template GetReflectedVector (const ezVec3Template &vNormal) const
 Returns this vector reflected at vNormal.
 
const ezVec3Template GetRefractedVector (const ezVec3Template &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 const ezVec3Template ZeroVector ()
 Static function that returns a zero-vector.
 
static ezVec3Template CreateRandomPointInSphere (ezRandom &rng)
 Sets the vector to a random point inside a unit sphere (radius 1).
 
static ezVec3Template CreateRandomDirection (ezRandom &rng)
 Creates a random direction vector. The vector is normalized.
 
static ezVec3Template CreateRandomDeviationX (ezRandom &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 ezVec3Template CreateRandomDeviationY (ezRandom &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 ezVec3Template CreateRandomDeviationZ (ezRandom &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 ezVec3Template CreateRandomDeviation (ezRandom &rng, const ezAngle &maxDeviation, const ezVec3 &vNormal)
 Creates a random vector around the given normal with a maximum deviation. More...
 

Public Attributes

Type x
 
Type y
 
Type z
 

Detailed Description

template<typename Type>
struct ezVec3Template< Type >

A 3-component vector class.

Member Function Documentation

◆ CreateRandomDeviation()

template<typename Type >
ezVec3Template< Type > ezVec3Template< Type >::CreateRandomDeviation ( ezRandom rng,
const ezAngle maxDeviation,
const ezVec3 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.

◆ IsNormalized()

template<typename Type>
EZ_FORCE_INLINE bool ezVec3Template< Type >::IsNormalized ( Type  fEpsilon = ezMath::BasicType<Type>::HugeEpsilon()) 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 >
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.

◆ 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 struct was generated from the following files: