irr::core::vector3d< T > Class Template Reference

3d vector template class with lots of operators and methods. More...

#include <vector3d.h>

Public Member Functions
	vector3d ()
	Default constructor (null vector). More...
	vector3d (T nx, T ny, T nz)
	Constructor with three different values. More...
	vector3d (T n)
	Constructor with the same value for all elements. More...
	vector3d (const vector3d< T > &other)
	Copy constructor. More...
vector3d< T >	operator- () const
vector3d< T > &	operator= (const vector3d< T > &other)
vector3d< T >	operator+ (const vector3d< T > &other) const
vector3d< T > &	operator+= (const vector3d< T > &other)
vector3d< T >	operator+ (const T val) const
vector3d< T > &	operator+= (const T val)
vector3d< T >	operator- (const vector3d< T > &other) const
vector3d< T > &	operator-= (const vector3d< T > &other)
vector3d< T >	operator- (const T val) const
vector3d< T > &	operator-= (const T val)
vector3d< T >	operator * (const vector3d< T > &other) const
vector3d< T > &	operator *= (const vector3d< T > &other)
vector3d< T >	operator * (const T v) const
vector3d< T > &	operator *= (const T v)
vector3d< T >	operator/ (const vector3d< T > &other) const
vector3d< T > &	operator/= (const vector3d< T > &other)
vector3d< T >	operator/ (const T v) const
vector3d< T > &	operator/= (const T v)
T &	operator [] (u32 index)
const T &	operator [] (u32 index) const
bool	operator<= (const vector3d< T > &other) const
	sort in order X, Y, Z. Equality with rounding tolerance. More...
bool	operator>= (const vector3d< T > &other) const
	sort in order X, Y, Z. Equality with rounding tolerance. More...
bool	operator< (const vector3d< T > &other) const
	sort in order X, Y, Z. Difference must be above rounding tolerance. More...
bool	operator> (const vector3d< T > &other) const
	sort in order X, Y, Z. Difference must be above rounding tolerance. More...
bool	operator== (const vector3d< T > &other) const
	use weak float compare More...
bool	operator!= (const vector3d< T > &other) const
bool	equals (const vector3d< T > &other, const T tolerance=(T) ROUNDING_ERROR_f32) const
	returns if this vector equals the other one, taking floating point rounding errors into account More...
vector3d< T > &	set (const T nx, const T ny, const T nz)
vector3d< T > &	set (const vector3d< T > &p)
T	getLength () const
	Get length of the vector. More...
T	getLengthSQ () const
	Get squared length of the vector. More...
T	dotProduct (const vector3d< T > &other) const
	Get the dot product with another vector. More...
T	getDistanceFrom (const vector3d< T > &other) const
	Get distance from another point. More...
T	getDistanceFromSQ (const vector3d< T > &other) const
	Returns squared distance from another point. More...
vector3d< T >	crossProduct (const vector3d< T > &p) const
	Calculates the cross product with another vector. More...
bool	isBetweenPoints (const vector3d< T > &begin, const vector3d< T > &end) const
	Returns if this vector interpreted as a point is on a line between two other points. More...
vector3d< T > &	normalize ()
	Normalizes the vector. More...
vector3d< T > &	setLength (T newlength)
	Sets the length of the vector to a new value. More...
vector3d< T > &	invert ()
	Inverts the vector. More...
void	rotateXZBy (f64 degrees, const vector3d< T > &center=vector3d< T >())
	Rotates the vector by a specified number of degrees around the Y axis and the specified center. More...
void	rotateXYBy (f64 degrees, const vector3d< T > &center=vector3d< T >())
	Rotates the vector by a specified number of degrees around the Z axis and the specified center. More...
void	rotateYZBy (f64 degrees, const vector3d< T > &center=vector3d< T >())
	Rotates the vector by a specified number of degrees around the X axis and the specified center. More...
vector3d< T >	getInterpolated (const vector3d< T > &other, f64 d) const
	Creates an interpolated vector between this vector and another vector. More...
vector3d< T >	getInterpolated_quadratic (const vector3d< T > &v2, const vector3d< T > &v3, f64 d) const
	Creates a quadratically interpolated vector between this and two other vectors. More...
vector3d< T > &	interpolate (const vector3d< T > &a, const vector3d< T > &b, f64 d)
	Sets this vector to the linearly interpolated vector between a and b. More...
vector3d< T >	getHorizontalAngle () const
	Get the rotations that would make a (0,0,1) direction vector point in the same direction as this direction vector. More...
vector3d< T >	getSphericalCoordinateAngles () const
	Get the spherical coordinate angles. More...
vector3d< T >	rotationToDirection (const vector3d< T > &forwards=vector3d< T >(0, 0, 1)) const
	Builds a direction vector from (this) rotation vector. More...
void	getAs4Values (T *array) const
	Fills an array of 4 values with the vector data (usually floats). More...
void	getAs3Values (T *array) const
	Fills an array of 3 values with the vector data (usually floats). More...
template<>
vector3d< s32 >	operator/ (s32 val) const
	partial specialization for integer vectors More...
template<>
vector3d< s32 > &	operator/= (s32 val)
template<>
vector3d< s32 >	getSphericalCoordinateAngles () const

Public Attributes
T	X
	X coordinate of the vector. More...
T	Y
	Y coordinate of the vector. More...
T	Z
	Z coordinate of the vector. More...

Detailed Description

template<class T>
class irr::core::vector3d< T >

3d vector template class with lots of operators and methods.

The vector3d class is used in Irrlicht for three main purposes: 1) As a direction vector (most of the methods assume this). 2) As a position in 3d space (which is synonymous with a direction vector from the origin to this position). 3) To hold three Euler rotations, where X is pitch, Y is yaw and Z is roll.

Definition at line 22 of file vector3d.h.

Constructor & Destructor Documentation

vector3d() [1/4]

template<class T>

irr::core::vector3d< T >::vector3d ( )

inline

Default constructor (null vector).

Definition at line 26 of file vector3d.h.

: X(0), Y(0), Z(0) {}

vector3d() [2/4]

template<class T>

irr::core::vector3d< T >::vector3d ( T  nx, T  ny, T  nz  )

inline

Constructor with three different values.

Definition at line 28 of file vector3d.h.

: X(nx), Y(ny), Z(nz) {}

vector3d() [3/4]

template<class T>

irr::core::vector3d< T >::vector3d ( T  n )

inlineexplicit

Constructor with the same value for all elements.

Definition at line 30 of file vector3d.h.

: X(n), Y(n), Z(n) {}

vector3d() [4/4]

template<class T>

irr::core::vector3d< T >::vector3d ( const vector3d< T > &  other )

inline

Copy constructor.

Definition at line 32 of file vector3d.h.

: X(other.X), Y(other.Y), Z(other.Z) {}

Member Function Documentation

crossProduct()

template<class T>

vector3d<T> irr::core::vector3d< T >::crossProduct ( const vector3d< T > &  p ) const

inline

Calculates the cross product with another vector.

Parameters

p	Vector to multiply with.

Returns

Crossproduct of this vector with p.

Definition at line 161 of file vector3d.h.

                {
                        return vector3d<T>(Y * p.Z - Z * p.Y, Z * p.X - X * p.Z, X * p.Y - Y * p.X);
                }

dotProduct()

template<class T>

T irr::core::vector3d< T >::dotProduct ( const vector3d< T > &  other ) const

inline

Get the dot product with another vector.

Definition at line 139 of file vector3d.h.

                {
                        return X*other.X + Y*other.Y + Z*other.Z;
                }

equals()

template<class T>

bool irr::core::vector3d< T >::equals ( const vector3d< T > &  other, const T  tolerance = (T)ROUNDING_ERROR_f32  ) const

inline

returns if this vector equals the other one, taking floating point rounding errors into account

Definition at line 120 of file vector3d.h.

                {
                        return core::equals(X, other.X, tolerance) &&
                                core::equals(Y, other.Y, tolerance) &&
                                core::equals(Z, other.Z, tolerance);
                }

getAs3Values()

template<class T>

void irr::core::vector3d< T >::getAs3Values ( T *  array ) const

inline

Fills an array of 3 values with the vector data (usually floats).

Useful for setting in shader constants for example.

Definition at line 415 of file vector3d.h.

                {
                        array[0] = X;
                        array[1] = Y;
                        array[2] = Z;
                }

getAs4Values()

template<class T>

void irr::core::vector3d< T >::getAs4Values ( T *  array ) const

inline

Fills an array of 4 values with the vector data (usually floats).

Useful for setting in shader constants for example. The fourth value will always be 0.

Definition at line 405 of file vector3d.h.

                {
                        array[0] = X;
                        array[1] = Y;
                        array[2] = Z;
                        array[3] = 0;
                }

getDistanceFrom()

template<class T>

T irr::core::vector3d< T >::getDistanceFrom ( const vector3d< T > &  other ) const

inline

Get distance from another point.

Here, the vector is interpreted as point in 3 dimensional space.

Definition at line 146 of file vector3d.h.

                {
                        return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z).getLength();
                }

getDistanceFromSQ()

template<class T>

T irr::core::vector3d< T >::getDistanceFromSQ ( const vector3d< T > &  other ) const

inline

Returns squared distance from another point.

Here, the vector is interpreted as point in 3 dimensional space.

Definition at line 153 of file vector3d.h.

                {
                        return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z).getLengthSQ();
                }

getHorizontalAngle()

template<class T>

vector3d<T> irr::core::vector3d< T >::getHorizontalAngle ( ) const

inline

Get the rotations that would make a (0,0,1) direction vector point in the same direction as this direction vector.

Thanks to Arras on the Irrlicht forums for this method. This utility method is very useful for orienting scene nodes towards specific targets. For example, if this vector represents the difference between two scene nodes, then applying the result of getHorizontalAngle() to one scene node will point it at the other one. Example code: Where target and seeker are of type ISceneNode* const vector3df toTarget(target->getAbsolutePosition() - seeker->getAbsolutePosition()); const vector3df requiredRotation = toTarget.getHorizontalAngle(); seeker->setRotation(requiredRotation);

Returns

A rotation vector containing the X (pitch) and Y (raw) rotations (in degrees) that when applied to a +Z (e.g. 0, 0, 1) direction vector would make it point in the same direction as this vector. The Z (roll) rotation is always 0, since two Euler rotations are sufficient to point in any given direction.

Definition at line 315 of file vector3d.h.

                {
                        vector3d<T> angle;

                        // tmp avoids some precision troubles on some compilers when working with T=s32
                        f64 tmp = (atan2((f64)X, (f64)Z) * RADTODEG64);
                        angle.Y = (T)tmp;

                        if (angle.Y < 0)
                                angle.Y += 360;
                        if (angle.Y >= 360)
                                angle.Y -= 360;

                        const f64 z1 = core::squareroot(X*X + Z*Z);

                        tmp = (atan2((f64)z1, (f64)Y) * RADTODEG64 - 90.0);
                        angle.X = (T)tmp;

                        if (angle.X < 0)
                                angle.X += 360;
                        if (angle.X >= 360)
                                angle.X -= 360;

                        return angle;
                }

getInterpolated()

template<class T>

vector3d<T> irr::core::vector3d< T >::getInterpolated ( const vector3d< T > &  other, f64  d  ) const

inline

Creates an interpolated vector between this vector and another vector.

Parameters

other	The other vector to interpolate with.
d	Interpolation value between 0.0f (all the other vector) and 1.0f (all this vector). Note that this is the opposite direction of interpolation to getInterpolated_quadratic()

Returns

An interpolated vector. This vector is not modified.

Definition at line 261 of file vector3d.h.

                {
                        const f64 inv = 1.0 - d;
                        return vector3d<T>((T)(other.X*inv + X*d), (T)(other.Y*inv + Y*d), (T)(other.Z*inv + Z*d));
                }

getInterpolated_quadratic()

template<class T>

vector3d<T> irr::core::vector3d< T >::getInterpolated_quadratic ( const vector3d< T > &  v2, const vector3d< T > &  v3, f64  d  ) const

inline

Creates a quadratically interpolated vector between this and two other vectors.

Parameters

v2	Second vector to interpolate with.
v3	Third vector to interpolate with (maximum at 1.0f)
d	Interpolation value between 0.0f (all this vector) and 1.0f (all the 3rd vector). Note that this is the opposite direction of interpolation to getInterpolated() and interpolate()

Returns

An interpolated vector. This vector is not modified.

Definition at line 273 of file vector3d.h.

                {
                        // this*(1-d)*(1-d) + 2 * v2 * (1-d) + v3 * d * d;
                        const f64 inv = (T) 1.0 - d;
                        const f64 mul0 = inv * inv;
                        const f64 mul1 = (T) 2.0 * d * inv;
                        const f64 mul2 = d * d;

                        return vector3d<T> ((T)(X * mul0 + v2.X * mul1 + v3.X * mul2),
                                        (T)(Y * mul0 + v2.Y * mul1 + v3.Y * mul2),
                                        (T)(Z * mul0 + v2.Z * mul1 + v3.Z * mul2));
                }

getLength()

template<class T>

T irr::core::vector3d< T >::getLength ( ) const

inline

Get length of the vector.

Definition at line 131 of file vector3d.h.

{ return core::squareroot( X*X + Y*Y + Z*Z ); }

getLengthSQ()

template<class T>

T irr::core::vector3d< T >::getLengthSQ ( ) const

inline

Get squared length of the vector.

This is useful because it is much faster than getLength().

Returns

Squared length of the vector.

Definition at line 136 of file vector3d.h.

{ return X*X + Y*Y + Z*Z; }

getSphericalCoordinateAngles() [1/2]

template<class T>

vector3d<T> irr::core::vector3d< T >::getSphericalCoordinateAngles ( ) const

inline

Get the spherical coordinate angles.

This returns Euler degrees for the point represented by this vector. The calculation assumes the pole at (0,1,0) and returns the angles in X and Y.

Definition at line 346 of file vector3d.h.

                {
                        vector3d<T> angle;
                        const f64 length = X*X + Y*Y + Z*Z;

                        if (length)
                        {
                                if (X!=0)
                                {
                                        angle.Y = (T)(atan2((f64)Z,(f64)X) * RADTODEG64);
                                }
                                else if (Z<0)
                                        angle.Y=180;

                                angle.X = (T)(acos(Y * core::reciprocal_squareroot(length)) * RADTODEG64);
                        }
                        return angle;
                }

getSphericalCoordinateAngles() [2/2]

template<>

vector3d< s32 > irr::core::vector3d< s32 >::getSphericalCoordinateAngles ( ) const

inline

Definition at line 441 of file vector3d.h.

        {
                vector3d<s32> angle;
                const f64 length = X*X + Y*Y + Z*Z;

                if (length)
                {
                        if (X!=0)
                        {
                                angle.Y = round32((f32)(atan2((f64)Z,(f64)X) * RADTODEG64));
                        }
                        else if (Z<0)
                                angle.Y=180;

                        angle.X = round32((f32)(acos(Y * core::reciprocal_squareroot(length)) * RADTODEG64));
                }
                return angle;
        }

interpolate()

template<class T>

vector3d<T>& irr::core::vector3d< T >::interpolate ( const vector3d< T > &  a, const vector3d< T > &  b, f64  d  )

inline

Sets this vector to the linearly interpolated vector between a and b.

Parameters

a	first vector to interpolate with, maximum at 1.0f
b	second vector to interpolate with, maximum at 0.0f
d	Interpolation value between 0.0f (all vector b) and 1.0f (all vector a) Note that this is the opposite direction of interpolation to getInterpolated_quadratic()

Definition at line 292 of file vector3d.h.

                {
                        X = (T)((f64)b.X + ( ( a.X - b.X ) * d ));
                        Y = (T)((f64)b.Y + ( ( a.Y - b.Y ) * d ));
                        Z = (T)((f64)b.Z + ( ( a.Z - b.Z ) * d ));
                        return *this;
                }

invert()

template<class T>

vector3d<T>& irr::core::vector3d< T >::invert ( )

inline

Inverts the vector.

Definition at line 203 of file vector3d.h.

                {
                        X *= -1;
                        Y *= -1;
                        Z *= -1;
                        return *this;
                }

isBetweenPoints()

template<class T>

bool irr::core::vector3d< T >::isBetweenPoints ( const vector3d< T > &  begin, const vector3d< T > &  end  ) const

inline

Returns if this vector interpreted as a point is on a line between two other points.

It is assumed that the point is on the line.

Parameters

begin	Beginning vector to compare between.
end	Ending vector to compare between.

Returns

True if this vector is between begin and end, false if not.

Definition at line 171 of file vector3d.h.

                {
                        const T f = (end - begin).getLengthSQ();
                        return getDistanceFromSQ(begin) <= f &&
                                getDistanceFromSQ(end) <= f;
                }

normalize()

template<class T>

vector3d<T>& irr::core::vector3d< T >::normalize ( )

inline

Normalizes the vector.

In case of the 0 vector the result is still 0, otherwise the length of the vector will be 1.

Returns

Reference to this vector after normalization.

Definition at line 182 of file vector3d.h.

                {
                        f64 length = X*X + Y*Y + Z*Z;
                        if (length == 0 ) // this check isn't an optimization but prevents getting NAN in the sqrt.
                                return *this;
                        length = core::reciprocal_squareroot(length);

                        X = (T)(X * length);
                        Y = (T)(Y * length);
                        Z = (T)(Z * length);
                        return *this;
                }

operator *() [1/2]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator * ( const vector3d< T > &  other ) const

inline

Definition at line 50 of file vector3d.h.

{ return vector3d<T>(X * other.X, Y * other.Y, Z * other.Z); }

operator *() [2/2]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator * ( const T  v ) const

inline

Definition at line 52 of file vector3d.h.

{ return vector3d<T>(X * v, Y * v, Z * v); }

operator *=() [1/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator *= ( const vector3d< T > &  other )

inline

Definition at line 51 of file vector3d.h.

{ X*=other.X; Y*=other.Y; Z*=other.Z; return *this; }

operator *=() [2/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator *= ( const T  v )

inline

Definition at line 53 of file vector3d.h.

{ X*=v; Y*=v; Z*=v; return *this; }

operator []() [1/2]

template<class T>

T& irr::core::vector3d< T >::operator [] ( u32  index )

inline

Definition at line 60 of file vector3d.h.

                {
                        _IRR_DEBUG_BREAK_IF(index>2) // access violation

                        return *(&X+index);
                }

operator []() [2/2]

template<class T>

const T& irr::core::vector3d< T >::operator [] ( u32  index ) const

inline

Definition at line 67 of file vector3d.h.

                {
                        _IRR_DEBUG_BREAK_IF(index>2) // access violation

                        return *(&X+index);
                }

operator!=()

template<class T>

bool irr::core::vector3d< T >::operator!= ( const vector3d< T > &  other ) const

inline

Definition at line 112 of file vector3d.h.

                {
                        return !this->equals(other);
                }

operator+() [1/2]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator+ ( const vector3d< T > &  other ) const

inline

Definition at line 40 of file vector3d.h.

{ return vector3d<T>(X + other.X, Y + other.Y, Z + other.Z); }

operator+() [2/2]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator+ ( const T  val ) const

inline

Definition at line 42 of file vector3d.h.

{ return vector3d<T>(X + val, Y + val, Z + val); }

operator+=() [1/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator+= ( const vector3d< T > &  other )

inline

Definition at line 41 of file vector3d.h.

{ X+=other.X; Y+=other.Y; Z+=other.Z; return *this; }

operator+=() [2/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator+= ( const T  val )

inline

Definition at line 43 of file vector3d.h.

{ X+=val; Y+=val; Z+=val; return *this; }

operator-() [1/3]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator- ( ) const

inline

Definition at line 36 of file vector3d.h.

{ return vector3d<T>(-X, -Y, -Z); }

operator-() [2/3]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator- ( const vector3d< T > &  other ) const

inline

Definition at line 45 of file vector3d.h.

{ return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z); }

operator-() [3/3]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator- ( const T  val ) const

inline

Definition at line 47 of file vector3d.h.

{ return vector3d<T>(X - val, Y - val, Z - val); }

operator-=() [1/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator-= ( const vector3d< T > &  other )

inline

Definition at line 46 of file vector3d.h.

{ X-=other.X; Y-=other.Y; Z-=other.Z; return *this; }

operator-=() [2/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator-= ( const T  val )

inline

Definition at line 48 of file vector3d.h.

{ X-=val; Y-=val; Z-=val; return *this; }

operator/() [1/3]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator/ ( const vector3d< T > &  other ) const

inline

Definition at line 55 of file vector3d.h.

{ return vector3d<T>(X / other.X, Y / other.Y, Z / other.Z); }

operator/() [2/3]

template<class T>

vector3d<T> irr::core::vector3d< T >::operator/ ( const T  v ) const

inline

Definition at line 57 of file vector3d.h.

{ T i=(T)1.0/v; return vector3d<T>(X * i, Y * i, Z * i); }

operator/() [3/3]

template<>

vector3d< s32 > irr::core::vector3d< s32 >::operator/ ( s32  val ) const

inline

partial specialization for integer vectors

Definition at line 436 of file vector3d.h.

{return core::vector3d<s32>(X/val,Y/val,Z/val);}

operator/=() [1/3]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator/= ( const vector3d< T > &  other )

inline

Definition at line 56 of file vector3d.h.

{ X/=other.X; Y/=other.Y; Z/=other.Z; return *this; }

operator/=() [2/3]

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator/= ( const T  v )

inline

Definition at line 58 of file vector3d.h.

{ T i=(T)1.0/v; X*=i; Y*=i; Z*=i; return *this; }

operator/=() [3/3]

template<>

vector3d< s32 > & irr::core::vector3d< s32 >::operator/= ( s32  val )

inline

Definition at line 438 of file vector3d.h.

{X/=val;Y/=val;Z/=val; return *this;}

operator<()

template<class T>

bool irr::core::vector3d< T >::operator< ( const vector3d< T > &  other ) const

inline

sort in order X, Y, Z. Difference must be above rounding tolerance.

Definition at line 91 of file vector3d.h.

                {
                        return (X<other.X && !core::equals(X, other.X)) ||
                                        (core::equals(X, other.X) && Y<other.Y && !core::equals(Y, other.Y)) ||
                                        (core::equals(X, other.X) && core::equals(Y, other.Y) && Z<other.Z && !core::equals(Z, other.Z));
                }

operator<=()

template<class T>

bool irr::core::vector3d< T >::operator<= ( const vector3d< T > &  other ) const

inline

sort in order X, Y, Z. Equality with rounding tolerance.

Definition at line 75 of file vector3d.h.

                {
                        return (X<other.X || core::equals(X, other.X)) ||
                                        (core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y))) ||
                                        (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z<other.Z || core::equals(Z, other.Z)));
                }

operator=()

template<class T>

vector3d<T>& irr::core::vector3d< T >::operator= ( const vector3d< T > &  other )

inline

Definition at line 38 of file vector3d.h.

{ X = other.X; Y = other.Y; Z = other.Z; return *this; }

operator==()

template<class T>

bool irr::core::vector3d< T >::operator== ( const vector3d< T > &  other ) const

inline

use weak float compare

Definition at line 107 of file vector3d.h.

                {
                        return this->equals(other);
                }

operator>()

template<class T>

bool irr::core::vector3d< T >::operator> ( const vector3d< T > &  other ) const

inline

sort in order X, Y, Z. Difference must be above rounding tolerance.

Definition at line 99 of file vector3d.h.

                {
                        return (X>other.X && !core::equals(X, other.X)) ||
                                        (core::equals(X, other.X) && Y>other.Y && !core::equals(Y, other.Y)) ||
                                        (core::equals(X, other.X) && core::equals(Y, other.Y) && Z>other.Z && !core::equals(Z, other.Z));
                }

operator>=()

template<class T>

bool irr::core::vector3d< T >::operator>= ( const vector3d< T > &  other ) const

inline

sort in order X, Y, Z. Equality with rounding tolerance.

Definition at line 83 of file vector3d.h.

                {
                        return (X>other.X || core::equals(X, other.X)) ||
                                        (core::equals(X, other.X) && (Y>other.Y || core::equals(Y, other.Y))) ||
                                        (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z>other.Z || core::equals(Z, other.Z)));
                }

rotateXYBy()

template<class T>

void irr::core::vector3d< T >::rotateXYBy ( f64  degrees, const vector3d< T > &  center = vector3d<T>()  )

inline

Rotates the vector by a specified number of degrees around the Z axis and the specified center.

Parameters

degrees	Number of degrees to rotate around the Z axis.
center	The center of the rotation.

Definition at line 229 of file vector3d.h.

                {
                        degrees *= DEGTORAD64;
                        f64 cs = cos(degrees);
                        f64 sn = sin(degrees);
                        X -= center.X;
                        Y -= center.Y;
                        set((T)(X*cs - Y*sn), (T)(X*sn + Y*cs), Z);
                        X += center.X;
                        Y += center.Y;
                }

rotateXZBy()

template<class T>

void irr::core::vector3d< T >::rotateXZBy ( f64  degrees, const vector3d< T > &  center = vector3d<T>()  )

inline

Rotates the vector by a specified number of degrees around the Y axis and the specified center.

Parameters

degrees	Number of degrees to rotate around the Y axis.
center	The center of the rotation.

Definition at line 214 of file vector3d.h.

                {
                        degrees *= DEGTORAD64;
                        f64 cs = cos(degrees);
                        f64 sn = sin(degrees);
                        X -= center.X;
                        Z -= center.Z;
                        set((T)(X*cs - Z*sn), Y, (T)(X*sn + Z*cs));
                        X += center.X;
                        Z += center.Z;
                }

rotateYZBy()

template<class T>

void irr::core::vector3d< T >::rotateYZBy ( f64  degrees, const vector3d< T > &  center = vector3d<T>()  )

inline

Rotates the vector by a specified number of degrees around the X axis and the specified center.

Parameters

degrees	Number of degrees to rotate around the X axis.
center	The center of the rotation.

Definition at line 244 of file vector3d.h.

                {
                        degrees *= DEGTORAD64;
                        f64 cs = cos(degrees);
                        f64 sn = sin(degrees);
                        Z -= center.Z;
                        Y -= center.Y;
                        set(X, (T)(Y*cs - Z*sn), (T)(Y*sn + Z*cs));
                        Z += center.Z;
                        Y += center.Y;
                }

rotationToDirection()

template<class T>

vector3d<T> irr::core::vector3d< T >::rotationToDirection ( const vector3d< T > &  forwards = vector3d<T>(0, 0, 1) ) const

inline

Builds a direction vector from (this) rotation vector.

This vector is assumed to be a rotation vector composed of 3 Euler angle rotations, in degrees. The implementation performs the same calculations as using a matrix to do the rotation.

Parameters

[in]

forwards

The direction representing "forwards" which will be rotated by this vector. If you do not provide a direction, then the +Z axis (0, 0, 1) will be assumed to be forwards.

Returns

A direction vector calculated by rotating the forwards direction by the 3 Euler angles (in degrees) represented by this vector.

Definition at line 373 of file vector3d.h.

                {
                        const f64 cr = cos( core::DEGTORAD64 * X );
                        const f64 sr = sin( core::DEGTORAD64 * X );
                        const f64 cp = cos( core::DEGTORAD64 * Y );
                        const f64 sp = sin( core::DEGTORAD64 * Y );
                        const f64 cy = cos( core::DEGTORAD64 * Z );
                        const f64 sy = sin( core::DEGTORAD64 * Z );

                        const f64 srsp = sr*sp;
                        const f64 crsp = cr*sp;

                        const f64 pseudoMatrix[] = {
                                ( cp*cy ), ( cp*sy ), ( -sp ),
                                ( srsp*cy-cr*sy ), ( srsp*sy+cr*cy ), ( sr*cp ),
                                ( crsp*cy+sr*sy ), ( crsp*sy-sr*cy ), ( cr*cp )};

                        return vector3d<T>(
                                (T)(forwards.X * pseudoMatrix[0] +
                                        forwards.Y * pseudoMatrix[3] +
                                        forwards.Z * pseudoMatrix[6]),
                                (T)(forwards.X * pseudoMatrix[1] +
                                        forwards.Y * pseudoMatrix[4] +
                                        forwards.Z * pseudoMatrix[7]),
                                (T)(forwards.X * pseudoMatrix[2] +
                                        forwards.Y * pseudoMatrix[5] +
                                        forwards.Z * pseudoMatrix[8]));
                }

set() [1/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::set ( const T  nx, const T  ny, const T  nz  )

inline

Definition at line 127 of file vector3d.h.

{X=nx; Y=ny; Z=nz; return *this;}

set() [2/2]

template<class T>

vector3d<T>& irr::core::vector3d< T >::set ( const vector3d< T > &  p )

inline

Definition at line 128 of file vector3d.h.

{X=p.X; Y=p.Y; Z=p.Z;return *this;}

setLength()

template<class T>

vector3d<T>& irr::core::vector3d< T >::setLength ( T  newlength )

inline

Sets the length of the vector to a new value.

Definition at line 196 of file vector3d.h.

                {
                        normalize();
                        return (*this *= newlength);
                }

Member Data Documentation

X

template<class T>

T irr::core::vector3d< T >::X

X coordinate of the vector.

Definition at line 424 of file vector3d.h.

Y

template<class T>

T irr::core::vector3d< T >::Y

Y coordinate of the vector.

Definition at line 427 of file vector3d.h.

Z

template<class T>

T irr::core::vector3d< T >::Z

Z coordinate of the vector.

Definition at line 430 of file vector3d.h.

---

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

• include/irrlicht/vector3d.h