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

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

#include <dimension2d.h>

Public Member Functions
	vector2d ()
	Default constructor (null vector) More...
	vector2d (T nx, T ny)
	Constructor with two different values. More...
	vector2d (T n)
	Constructor with the same value for both members. More...
	vector2d (const vector2d< T > &other)
	Copy constructor. More...
	vector2d (const dimension2d< T > &other)
vector2d< T >	operator- () const
vector2d< T > &	operator= (const vector2d< T > &other)
vector2d< T > &	operator= (const dimension2d< T > &other)
vector2d< T >	operator+ (const vector2d< T > &other) const
vector2d< T >	operator+ (const dimension2d< T > &other) const
vector2d< T > &	operator+= (const vector2d< T > &other)
vector2d< T >	operator+ (const T v) const
vector2d< T > &	operator+= (const T v)
vector2d< T > &	operator+= (const dimension2d< T > &other)
vector2d< T >	operator- (const vector2d< T > &other) const
vector2d< T >	operator- (const dimension2d< T > &other) const
vector2d< T > &	operator-= (const vector2d< T > &other)
vector2d< T >	operator- (const T v) const
vector2d< T > &	operator-= (const T v)
vector2d< T > &	operator-= (const dimension2d< T > &other)
vector2d< T >	operator * (const vector2d< T > &other) const
vector2d< T > &	operator *= (const vector2d< T > &other)
vector2d< T >	operator * (const T v) const
vector2d< T > &	operator *= (const T v)
vector2d< T >	operator/ (const vector2d< T > &other) const
vector2d< T > &	operator/= (const vector2d< T > &other)
vector2d< T >	operator/ (const T v) const
vector2d< T > &	operator/= (const T v)
T &	operator [] (u32 index)
const T &	operator [] (u32 index) const
bool	operator<= (const vector2d< T > &other) const
	sort in order X, Y. Equality with rounding tolerance. More...
bool	operator>= (const vector2d< T > &other) const
	sort in order X, Y. Equality with rounding tolerance. More...
bool	operator< (const vector2d< T > &other) const
	sort in order X, Y. Difference must be above rounding tolerance. More...
bool	operator> (const vector2d< T > &other) const
	sort in order X, Y. Difference must be above rounding tolerance. More...
bool	operator== (const vector2d< T > &other) const
bool	operator!= (const vector2d< T > &other) const
bool	equals (const vector2d< T > &other, const T tolerance=(T) ROUNDING_ERROR_f32) const
	Checks if this vector equals the other one. More...
vector2d< T > &	set (T nx, T ny)
vector2d< T > &	set (const vector2d< T > &p)
T	getLength () const
	Gets the length of the vector. More...
T	getLengthSQ () const
	Get the squared length of this vector. More...
T	dotProduct (const vector2d< T > &other) const
	Get the dot product of this vector with another. More...
bool	nearlyParallel (const vector2d< T > &other, const T factor=relativeErrorFactor< T >()) const
	check if this vector is parallel to another vector More...
T	getDistanceFrom (const vector2d< T > &other) const
	Gets distance from another point. More...
T	getDistanceFromSQ (const vector2d< T > &other) const
	Returns squared distance from another point. More...
vector2d< T > &	rotateBy (f64 degrees, const vector2d< T > &center=vector2d< T >())
	rotates the point anticlockwise around a center by an amount of degrees. More...
vector2d< T > &	normalize ()
	Normalize the vector. More...
f64	getAngleTrig () const
	Calculates the angle of this vector in degrees in the trigonometric sense. More...
f64	getAngle () const
	Calculates the angle of this vector in degrees in the counter trigonometric sense. More...
f64	getAngleWith (const vector2d< T > &b) const
	Calculates the angle between this vector and another one in degree. More...
bool	isBetweenPoints (const vector2d< T > &begin, const vector2d< T > &end) const
	Returns if this vector interpreted as a point is on a line between two other points. More...
vector2d< T >	getInterpolated (const vector2d< T > &other, f64 d) const
	Creates an interpolated vector between this vector and another vector. More...
vector2d< T >	getInterpolated_quadratic (const vector2d< T > &v2, const vector2d< T > &v3, f64 d) const
	Creates a quadratically interpolated vector between this and two other vectors. More...
s32	checkOrientation (const vector2d< T > &b, const vector2d< T > &c) const
bool	areClockwise (const vector2d< T > &b, const vector2d< T > &c) const
bool	areCounterClockwise (const vector2d< T > &b, const vector2d< T > &c) const
vector2d< T > &	interpolate (const vector2d< T > &a, const vector2d< T > &b, f64 d)
	Sets this vector to the linearly interpolated vector between a and b. More...

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

Detailed Description

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

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

As of Irrlicht 1.6, this class supersedes position2d, which should be considered deprecated.

Definition at line 16 of file dimension2d.h.

Constructor & Destructor Documentation

vector2d() [1/5]

template<class T>

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

inline

Default constructor (null vector)

Definition at line 25 of file vector2d.h.

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

vector2d() [2/5]

template<class T>

irr::core::vector2d< T >::vector2d ( T  nx, T  ny  )

inline

Constructor with two different values.

Definition at line 27 of file vector2d.h.

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

vector2d() [3/5]

template<class T>

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

inlineexplicit

Constructor with the same value for both members.

Definition at line 29 of file vector2d.h.

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

vector2d() [4/5]

template<class T>

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

inline

Copy constructor.

Definition at line 31 of file vector2d.h.

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

vector2d() [5/5]

template<class T>

irr::core::vector2d< T >::vector2d ( const dimension2d< T > &  other )

inline

Definition at line 33 of file vector2d.h.

: X(other.Width), Y(other.Height) {}

Member Function Documentation

areClockwise()

template<class T>

bool irr::core::vector2d< T >::areClockwise ( const vector2d< T > &  b, const vector2d< T > &  c  ) const

inline

Returns true if points (a,b,c) are clockwise on the X,Y plane

Definition at line 365 of file vector2d.h.

        {
                T val = (b.Y - Y) * (c.X - b.X) -
                        (b.X - X) * (c.Y - b.Y);

                return val > 0;
        }

areCounterClockwise()

template<class T>

bool irr::core::vector2d< T >::areCounterClockwise ( const vector2d< T > &  b, const vector2d< T > &  c  ) const

inline

Returns true if points (a,b,c) are counterclockwise on the X,Y plane

Definition at line 374 of file vector2d.h.

        {
                T val = (b.Y - Y) * (c.X - b.X) -
                        (b.X - X) * (c.Y - b.Y);

                return val < 0;
        }

checkOrientation()

template<class T>

s32 irr::core::vector2d< T >::checkOrientation ( const vector2d< T > &  b, const vector2d< T > &  c  ) const

inline

Test if this point and another 2 points taken as triplet are colinear, clockwise, anticlockwise. This can be used also to check winding order in triangles for 2D meshes.

Returns

0 if points are colinear, 1 if clockwise, 2 if anticlockwise

Definition at line 345 of file vector2d.h.

        {
                // Example of clockwise points
                //
                //   ^ Y
                //   |       A
                //   |      . .
                //   |     .   .
                //   |    C.....B
                //   +---------------> X

                T val = (b.Y - Y) * (c.X - b.X) -
                        (b.X - X) * (c.Y - b.Y);

                if (val == 0) return 0;  // colinear

                return (val > 0) ? 1 : 2; // clock or counterclock wise
        }

dotProduct()

template<class T>

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

inline

Get the dot product of this vector with another.

Parameters

other

Other vector to take dot product with.

Returns

The dot product of the two vectors.

Definition at line 139 of file vector2d.h.

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

equals()

template<class T>

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

inline

Checks if this vector equals the other one.

Takes floating point rounding errors into account.

Parameters

other	Vector to compare with.
tolerance	Epsilon value for both - comparing X and Y.

Returns

True if the two vector are (almost) equal, else false.

Definition at line 119 of file vector2d.h.

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

getAngle()

template<class T>

f64 irr::core::vector2d< T >::getAngle ( ) const

inline

Calculates the angle of this vector in degrees in the counter trigonometric sense.

0 is to the right (3 o'clock), values increase clockwise.

Returns

Returns a value between 0 and 360.

Definition at line 237 of file vector2d.h.

        {
                if (Y == 0) // corrected thanks to a suggestion by Jox
                        return X < 0 ? 180 : 0;
                else if (X == 0)
                        return Y < 0 ? 90 : 270;

                // don't use getLength here to avoid precision loss with s32 vectors
                // avoid floating-point trouble as sqrt(y*y) is occasionally larger than y, so clamp
                const f64 tmp = core::clamp(Y / sqrt((f64)(X*X + Y*Y)), -1.0, 1.0);
                const f64 angle = atan( core::squareroot(1 - tmp*tmp) / tmp) * RADTODEG64;

                if (X>0 && Y>0)
                        return angle + 270;
                else
                if (X>0 && Y<0)
                        return angle + 90;
                else
                if (X<0 && Y<0)
                        return 90 - angle;
                else
                if (X<0 && Y>0)
                        return 270 - angle;

                return angle;
        }

getAngleTrig()

template<class T>

f64 irr::core::vector2d< T >::getAngleTrig ( ) const

inline

Calculates the angle of this vector in degrees in the trigonometric sense.

0 is to the right (3 o'clock), values increase counter-clockwise. This method has been suggested by Pr3t3nd3r.

Returns

Returns a value between 0 and 360.

Definition at line 214 of file vector2d.h.

        {
                if (Y == 0)
                        return X < 0 ? 180 : 0;
                else
                if (X == 0)
                        return Y < 0 ? 270 : 90;

                if ( Y > 0)
                        if (X > 0)
                                return atan((irr::f64)Y/(irr::f64)X) * RADTODEG64;
                        else
                                return 180.0-atan((irr::f64)Y/-(irr::f64)X) * RADTODEG64;
                else
                        if (X > 0)
                                return 360.0-atan(-(irr::f64)Y/(irr::f64)X) * RADTODEG64;
                        else
                                return 180.0+atan(-(irr::f64)Y/-(irr::f64)X) * RADTODEG64;
        }

getAngleWith()

template<class T>

f64 irr::core::vector2d< T >::getAngleWith ( const vector2d< T > &  b ) const

inline

Calculates the angle between this vector and another one in degree.

Parameters

b	Other vector to test with.

Returns

Returns a value between 0 and 90.

Definition at line 267 of file vector2d.h.

        {
                f64 tmp = (f64)(X*b.X + Y*b.Y);

                if (tmp == 0.0)
                        return 90.0;

                tmp = tmp / core::squareroot((f64)((X*X + Y*Y) * (b.X*b.X + b.Y*b.Y)));
                if (tmp < 0.0)
                        tmp = -tmp;
                if ( tmp > 1.0 ) //   avoid floating-point trouble
                        tmp = 1.0;

                return atan(sqrt(1 - tmp*tmp) / tmp) * RADTODEG64;
        }

getDistanceFrom()

template<class T>

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

inline

Gets distance from another point.

Here, the vector is interpreted as a point in 2-dimensional space.

Parameters

other

Other vector to measure from.

Returns

Distance from other point.

Definition at line 162 of file vector2d.h.

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

getDistanceFromSQ()

template<class T>

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

inline

Returns squared distance from another point.

Here, the vector is interpreted as a point in 2-dimensional space.

Parameters

other

Other vector to measure from.

Returns

Squared distance from other point.

Definition at line 171 of file vector2d.h.

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

getInterpolated()

template<class T>

vector2d<T> irr::core::vector2d< T >::getInterpolated ( const vector2d< 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 316 of file vector2d.h.

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

getInterpolated_quadratic()

template<class T>

vector2d<T> irr::core::vector2d< T >::getInterpolated_quadratic ( const vector2d< T > &  v2, const vector2d< 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 328 of file vector2d.h.

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

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

getLength()

template<class T>

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

inline

Gets the length of the vector.

Returns

The length of the vector.

Definition at line 129 of file vector2d.h.

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

getLengthSQ()

template<class T>

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

inline

Get the squared length of this vector.

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

Returns

The squared length of the vector.

Definition at line 134 of file vector2d.h.

{ return X*X + Y*Y; }

interpolate()

template<class T>

vector2d<T>& irr::core::vector2d< T >::interpolate ( const vector2d< T > &  a, const vector2d< 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 388 of file vector2d.h.

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

isBetweenPoints()

template<class T>

bool irr::core::vector2d< T >::isBetweenPoints ( const vector2d< T > &  begin, const vector2d< 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 288 of file vector2d.h.

        {
                //             .  end
                //            /
                //           /
                //          /
                //         . begin
                //        -
                //       -
                //      . this point (am I inside or outside)?
                //
                if (begin.X != end.X)
                {
                        return ((begin.X <= X && X <= end.X) ||
                                        (begin.X >= X && X >= end.X));
                }
                else
                {
                        return ((begin.Y <= Y && Y <= end.Y) ||
                                        (begin.Y >= Y && Y >= end.Y));
                }
        }

nearlyParallel()

template<class T>

bool irr::core::vector2d< T >::nearlyParallel ( const vector2d< T > &  other, const T  factor = relativeErrorFactor<T>()  ) const

inline

check if this vector is parallel to another vector

Definition at line 145 of file vector2d.h.

        {
                // https://eagergames.wordpress.com/2017/04/01/fast-parallel-lines-and-vectors-test/
                // if a || b then  a.x/a.y = b.x/b.y (similiar triangles)
                // if a || b then either both x are 0 or both y are 0.

                return  equalsRelative( X*other.Y, other.X* Y, factor)
                && // a bit counterintuitive, but makes sure  that
                   // only y or only x are 0, and at same time deals
                   // with the case where one vector is zero vector.
                        (X*other.X + Y*other.Y) != 0;
        }

normalize()

template<class T>

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

inline

Normalize the vector.

The null vector is left untouched.

Returns

Reference to this vector, after normalization.

Definition at line 199 of file vector2d.h.

        {
                f32 length = (f32)(X*X + Y*Y);
                if ( length == 0 )
                        return *this;
                length = core::reciprocal_squareroot ( length );
                X = (T)(X * length);
                Y = (T)(Y * length);
                return *this;
        }

operator *() [1/2]

template<class T>

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

inline

Definition at line 57 of file vector2d.h.

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

operator *() [2/2]

template<class T>

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

inline

Definition at line 59 of file vector2d.h.

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

operator *=() [1/2]

template<class T>

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

inline

Definition at line 58 of file vector2d.h.

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

operator *=() [2/2]

template<class T>

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

inline

Definition at line 60 of file vector2d.h.

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

operator []() [1/2]

template<class T>

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

inline

Definition at line 67 of file vector2d.h.

        {
                _IRR_DEBUG_BREAK_IF(index>1) // access violation

                return *(&X+index);
        }

operator []() [2/2]

template<class T>

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

inline

Definition at line 74 of file vector2d.h.

        {
                _IRR_DEBUG_BREAK_IF(index>1) // access violation

                return *(&X+index);
        }

operator!=()

template<class T>

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

inline

Definition at line 110 of file vector2d.h.

{ return !equals(other); }

operator+() [1/3]

template<class T>

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

inline

Definition at line 43 of file vector2d.h.

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

operator+() [2/3]

template<class T>

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

inline

Definition at line 44 of file vector2d.h.

{ return vector2d<T>(X + other.Width, Y + other.Height); }

operator+() [3/3]

template<class T>

vector2d<T> irr::core::vector2d< T >::operator+ ( const T  v ) const

inline

Definition at line 46 of file vector2d.h.

{ return vector2d<T>(X + v, Y + v); }

operator+=() [1/3]

template<class T>

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

inline

Definition at line 45 of file vector2d.h.

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

operator+=() [2/3]

template<class T>

vector2d<T>& irr::core::vector2d< T >::operator+= ( const T  v )

inline

Definition at line 47 of file vector2d.h.

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

operator+=() [3/3]

template<class T>

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

inline

Definition at line 48 of file vector2d.h.

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

operator-() [1/4]

template<class T>

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

inline

Definition at line 37 of file vector2d.h.

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

operator-() [2/4]

template<class T>

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

inline

Definition at line 50 of file vector2d.h.

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

operator-() [3/4]

template<class T>

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

inline

Definition at line 51 of file vector2d.h.

{ return vector2d<T>(X - other.Width, Y - other.Height); }

operator-() [4/4]

template<class T>

vector2d<T> irr::core::vector2d< T >::operator- ( const T  v ) const

inline

Definition at line 53 of file vector2d.h.

{ return vector2d<T>(X - v, Y - v); }

operator-=() [1/3]

template<class T>

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

inline

Definition at line 52 of file vector2d.h.

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

operator-=() [2/3]

template<class T>

vector2d<T>& irr::core::vector2d< T >::operator-= ( const T  v )

inline

Definition at line 54 of file vector2d.h.

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

operator-=() [3/3]

template<class T>

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

inline

Definition at line 55 of file vector2d.h.

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

operator/() [1/2]

template<class T>

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

inline

Definition at line 62 of file vector2d.h.

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

operator/() [2/2]

template<class T>

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

inline

Definition at line 64 of file vector2d.h.

{ return vector2d<T>(X / v, Y / v); }

operator/=() [1/2]

template<class T>

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

inline

Definition at line 63 of file vector2d.h.

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

operator/=() [2/2]

template<class T>

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

inline

Definition at line 65 of file vector2d.h.

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

operator<()

template<class T>

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

inline

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

Definition at line 96 of file vector2d.h.

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

operator<=()

template<class T>

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

inline

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

Definition at line 82 of file vector2d.h.

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

operator=() [1/2]

template<class T>

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

inline

Definition at line 39 of file vector2d.h.

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

operator=() [2/2]

template<class T>

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

inline

Definition at line 41 of file vector2d.h.

{ X = other.Width; Y = other.Height; return *this; }

operator==()

template<class T>

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

inline

Definition at line 109 of file vector2d.h.

{ return equals(other); }

operator>()

template<class T>

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

inline

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

Definition at line 103 of file vector2d.h.

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

operator>=()

template<class T>

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

inline

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

Definition at line 89 of file vector2d.h.

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

rotateBy()

template<class T>

vector2d<T>& irr::core::vector2d< T >::rotateBy ( f64  degrees, const vector2d< T > &  center = vector2d<T>()  )

inline

rotates the point anticlockwise around a center by an amount of degrees.

Parameters

degrees	Amount of degrees to rotate by, anticlockwise.
center	Rotation center.

Returns

This vector after transformation.

Definition at line 180 of file vector2d.h.

        {
                degrees *= DEGTORAD64;
                const f64 cs = cos(degrees);
                const f64 sn = sin(degrees);

                X -= center.X;
                Y -= center.Y;

                set((T)(X*cs - Y*sn), (T)(X*sn + Y*cs));

                X += center.X;
                Y += center.Y;
                return *this;
        }

set() [1/2]

template<class T>

vector2d<T>& irr::core::vector2d< T >::set ( T  nx, T  ny  )

inline

Definition at line 124 of file vector2d.h.

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

set() [2/2]

template<class T>

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

inline

Definition at line 125 of file vector2d.h.

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

Member Data Documentation

X

template<class T>

T irr::core::vector2d< T >::X

X coordinate of vector.

Definition at line 396 of file vector2d.h.

Y

template<class T>

T irr::core::vector2d< T >::Y

Y coordinate of vector.

Definition at line 399 of file vector2d.h.

---

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

• include/irrlicht/dimension2d.h
• include/irrlicht/vector2d.h