2D vector More...

#include <Vector2.h>

Public Types
enum	Component { X = 0, Y = 1 }
	Vector component. More...
Public Member Functions
	Vector2 ()
	Default constructor setting all components to 0.
	Vector2 (float fX, float fY)
	Vector2 (const float fV[])
	Vector2 (const Vector2 &vV)
PLMATH_API	Vector2 (const Vector3 &vV)
PLMATH_API	Vector2 (const Vector4 &vV)
	Vector2 (const PLCore::String &sString)
	~Vector2 ()
Vector2 &	operator= (const float fV[])
Vector2 &	operator= (const Vector2 &vV)
PLMATH_API Vector2 &	operator= (const Vector3 &vV)
PLMATH_API Vector2 &	operator= (const Vector4 &vV)
bool	operator== (const Vector2 &vV) const
	Compares two vectors.
bool	operator!= (const Vector2 &vV) const
	Compares two vectors.
bool	operator< (const Vector2 &vV) const
	Compares two vectors lexicographically.
bool	operator> (const Vector2 &vV) const
	Compares two vectors lexicographically.
bool	operator<= (const Vector2 &vV) const
	Compares two vectors lexicographically.
bool	operator>= (const Vector2 &vV) const
	Compares two vectors lexicographically.
Vector2	operator+ (const Vector2 &vV) const
Vector2	operator+ (float fN) const
Vector2 &	operator+= (const Vector2 &vV)
Vector2 &	operator+= (float fN)
Vector2	operator- () const
Vector2	operator- (float fN) const
Vector2	operator- (const Vector2 &vV) const
Vector2 &	operator-= (const Vector2 &vV)
Vector2 &	operator-= (float fN)
Vector2	operator* (const Vector2 &vV) const
	Per component multiplication.
Vector2	operator* (float fS) const
Vector2 &	operator*= (const Vector2 &vV)
	Per component multiplication.
Vector2 &	operator*= (float fS)
PLMATH_API Vector2 &	operator*= (const Matrix3x3 &mRot)
	Rotates the vector.
PLMATH_API Vector2 &	operator*= (const Matrix3x4 &mRot)
	Rotates the vector.
PLMATH_API Vector2 &	operator*= (const Matrix4x4 &mTrans)
	Transforms the vector.
Vector2	operator/ (const Vector2 &vV) const
	Per component division.
Vector2	operator/ (float fS) const
Vector2 &	operator/= (const Vector2 &vV)
	Per component division.
Vector2 &	operator/= (float fS)
	operator float * ()
	operator const float * () const
float &	operator[] (int nIndex)
const float &	operator[] (int nIndex) const
void	GetXY (float &fX, float &fY) const
float	GetX () const
float	GetY () const
void	SetXY (float fX=0.0f, float fY=0.0f)
void	SetXY (const float fV[])
void	SetX (float fX=0.0f)
void	SetY (float fY=0.0f)
void	IncXY (float fX=0.0f, float fY=0.0f)
void	IncXY (const float fV[])
void	IncX (float fX)
void	IncY (float fY)
bool	IsNull () const
	Returns whether the vector is null or not.
bool	IsPacked () const
	Returns whether the vector is packed (within range of 0-1) or not.
void	PackTo01 ()
	Packs/clamps the vector into a range of 0-1.
Vector2	GetPackedTo01 () const
	Returns a vector which is packed/clamped into the range of 0-1.
void	UnpackFrom01 ()
	Unpacks the packed vector into a range of -1 to 1.
Vector2	GetUnpackedFrom01 () const
	Returns a unpacked vector of the range of -1 to 1.
Component	GetSmallestComponent () const
	Returns the smallest component.
float	GetSmallestValue () const
	Returns the value of the smallest component.
Component	GetGreatestComponent () const
	Returns the greatest component.
float	GetGreatestValue () const
	Returns the value of the greatest component.
void	Invert ()
	Inverts the vector.
Vector2	GetInverted () const
	Returns the inverted vector.
float	GetLength () const
	Returns the length of the vector (also called magnitude)
float	GetSquaredLength () const
	Returns the squared length of the vector (also called norm)
void	SetLength (float fLength=1.0f)
	Sets the vector to the given length.
Vector2 &	Normalize ()
	Normalizes the vector.
Vector2	GetNormalized () const
	Returns the normalized vector.
float	GetDistance (const Vector2 &vV) const
	Returns the distance to another vector.
float	GetSquaredDistance (const Vector2 &vV) const
	Returns the squared distance to another vector.
float	DotProduct (const Vector2 &vV) const
	Returns the dot product of two vectors.
Vector2	ProjectVector (const Vector2 &vA, const Vector2 &vB) const
	Project vector a onto another vector b.
float	GetAngle (const Vector2 &vV) const
	Calculates the angle between two vectors.
PLMATH_API PLCore::String	ToString () const
	To string.
PLMATH_API bool	FromString (const PLCore::String &sString)
	From string.
Public Attributes
union {
float fV [2]
	Vertex element array access.
struct {
float x
float y
}
	Known vertex element names when dealing with positions or directions.
struct {
float u
float v
}
	Known vertex element names when dealing with texture coordinates.
};
	Some direct vertex element accesses.
Static Public Attributes
static PLMATH_API const Vector2	Zero
static PLMATH_API const Vector2	One
static PLMATH_API const Vector2	NegativeOne
static PLMATH_API const Vector2	UnitX
static PLMATH_API const Vector2	UnitY
static PLMATH_API const Vector2	NegativeUnitX
static PLMATH_API const Vector2	NegativeUnitY

Detailed Description

2D vector

Member Enumeration Documentation

enum PLMath::Vector2::Component

Vector component.

Enumerator:

X	X component
Y	Y component

Constructor & Destructor Documentation

PLMath::Vector2::Vector2 ( ) [inline]

Default constructor setting all components to 0.

PLMath::Vector2::Vector2	(	float	fX,
		float	fY
	)		`[inline]`

PLMath::Vector2::Vector2 ( const float fV[] ) [inline]

PLMath::Vector2::Vector2 ( const Vector2 & vV ) [inline]

PLMATH_API PLMath::Vector2::Vector2 ( const Vector3 & vV )

PLMATH_API PLMath::Vector2::Vector2 ( const Vector4 & vV )

PLMath::Vector2::Vector2 ( const PLCore::String & sString ) [inline]

PLMath::Vector2::~Vector2 ( ) [inline]

Member Function Documentation

Vector2 & PLMath::Vector2::operator= ( const float fV[] ) [inline]

Vector2 & PLMath::Vector2::operator= ( const Vector2 & vV ) [inline]

PLMATH_API Vector2& PLMath::Vector2::operator= ( const Vector3 & vV )

PLMATH_API Vector2& PLMath::Vector2::operator= ( const Vector4 & vV )

bool PLMath::Vector2::operator== ( const Vector2 & vV ) const [inline]

Compares two vectors.

Parameters:

[in] vV Vector to compare with

Returns:: 'true' if all components are equal, else 'false'

bool PLMath::Vector2::operator!= ( const Vector2 & vV ) const [inline]

Compares two vectors.

Parameters:

[in] vV Vector to compare with

Returns:: 'false' if all components are equal, else 'true'

bool PLMath::Vector2::operator< ( const Vector2 & vV ) const [inline]

Compares two vectors lexicographically.

Parameters:

[in] vV Vector to compare with

Returns:: 'true' if ALL components of this vector are less, else 'false'

Note:

A lexicographical order for 2-dimensional vectors is used (see http://en.wikipedia.org/wiki/Ordered_vector_space)

bool PLMath::Vector2::operator> ( const Vector2 & vV ) const [inline]

Compares two vectors lexicographically.

Parameters:

[in] vV Vector to compare with

Returns:: 'true' if ALL components of this vector are greater, else 'false'

See also:

"operator <"

bool PLMath::Vector2::operator<= ( const Vector2 & vV ) const [inline]

Compares two vectors lexicographically.

Parameters:

[in] vV Vector to compare with

Returns:: 'true' if ALL components of this vector are less or equal, else 'false'

See also:

"operator <"

bool PLMath::Vector2::operator>= ( const Vector2 & vV ) const [inline]

Compares two vectors lexicographically.

Parameters:

[in] vV Vector to compare with

Returns:: 'true' if ALL components of this vector are greater or equal, else 'false'

See also:

"operator <"

Vector2 PLMath::Vector2::operator+ ( const Vector2 & vV ) const [inline]

Vector2 PLMath::Vector2::operator+ ( float fN ) const [inline]

Vector2 & PLMath::Vector2::operator+= ( const Vector2 & vV ) [inline]

Vector2 & PLMath::Vector2::operator+= ( float fN ) [inline]

Vector2 PLMath::Vector2::operator- ( ) const [inline]

Vector2 PLMath::Vector2::operator- ( float fN ) const [inline]

Vector2 PLMath::Vector2::operator- ( const Vector2 & vV ) const [inline]

Vector2 & PLMath::Vector2::operator-= ( const Vector2 & vV ) [inline]

Vector2 & PLMath::Vector2::operator-= ( float fN ) [inline]

Vector2 PLMath::Vector2::operator* ( const Vector2 & vV ) const [inline]

Per component multiplication.

Parameters:

[in] vV Vector to multiplicate with

Returns:: The resulting vector

Vector2 PLMath::Vector2::operator* ( float fS ) const [inline]

Vector2 & PLMath::Vector2::operator*= ( const Vector2 & vV ) [inline]

Per component multiplication.

Parameters:

[in] vV Vector to multiplicate with

Returns:: This vector which is now the resulting vector

Vector2 & PLMath::Vector2::operator*= ( float fS ) [inline]

PLMATH_API Vector2& PLMath::Vector2::operator*= ( const Matrix3x3 & mRot )

Rotates the vector.

Parameters:

[in] mRot Matrix which rotates the vector

Returns:: This vector which is now the resulting vector

PLMATH_API Vector2& PLMath::Vector2::operator*= ( const Matrix3x4 & mRot )

Rotates the vector.

Parameters:

[in] mRot Matrix which rotates the vector

Returns:: This vector which is now the resulting vector

PLMATH_API Vector2& PLMath::Vector2::operator*= ( const Matrix4x4 & mTrans )

Transforms the vector.

Parameters:

[in] mTrans Matrix which transforms the vector

Returns:: This vector which is now the resulting vector

Vector2 PLMath::Vector2::operator/ ( const Vector2 & vV ) const [inline]

Per component division.

Parameters:

[in] vV Vector to divide through

Returns:: The resulting vector

Vector2 PLMath::Vector2::operator/ ( float fS ) const [inline]

Vector2 & PLMath::Vector2::operator/= ( const Vector2 & vV ) [inline]

Per component division.

Parameters:

[in] vV Vector to divide through

Returns:: This vector which is now the resulting vector

Vector2 & PLMath::Vector2::operator/= ( float fS ) [inline]

PLMath::Vector2::operator float * ( ) [inline]

PLMath::Vector2::operator const float * ( ) const [inline]

float & PLMath::Vector2::operator[] ( int nIndex ) [inline]

const float & PLMath::Vector2::operator[] ( int nIndex ) const [inline]

void PLMath::Vector2::GetXY	(	float &	fX,
		float &	fY
	)		const `[inline]`

float PLMath::Vector2::GetX ( ) const [inline]

float PLMath::Vector2::GetY ( ) const [inline]

void PLMath::Vector2::SetXY	(	float	fX = `0.0f`,
		float	fY = `0.0f`
	)		`[inline]`

void PLMath::Vector2::SetXY ( const float fV[] ) [inline]

void PLMath::Vector2::SetX ( float fX = 0.0f ) [inline]

void PLMath::Vector2::SetY ( float fY = 0.0f ) [inline]

void PLMath::Vector2::IncXY	(	float	fX = `0.0f`,
		float	fY = `0.0f`
	)		`[inline]`

void PLMath::Vector2::IncXY ( const float fV[] ) [inline]

void PLMath::Vector2::IncX ( float fX ) [inline]

void PLMath::Vector2::IncY ( float fY ) [inline]

bool PLMath::Vector2::IsNull ( ) const [inline]

Returns whether the vector is null or not.

Returns:: 'true' if the vector is null, else 'false'

bool PLMath::Vector2::IsPacked ( ) const [inline]

Returns whether the vector is packed (within range of 0-1) or not.

Returns:: 'true' if the vector is packed, else 'false'

void PLMath::Vector2::PackTo01 ( ) [inline]

Packs/clamps the vector into a range of 0-1.

Remarks:: First, the vector is normalized - now each component is between -1 and 1. This normalized vector is scaled by 0.5 and 0.5 is added.

Vector2 PLMath::Vector2::GetPackedTo01 ( ) const [inline]

Returns a vector which is packed/clamped into the range of 0-1.

Returns:: The packed vector

See also:

PackTo01()

void PLMath::Vector2::UnpackFrom01 ( ) [inline]

Unpacks the packed vector into a range of -1 to 1.

Remarks:: The vector is scaled by 2 and 1 is subtracted.

Note:

There's no internal check whether the vector is packed or not, you can do this by yourself using the IsPacked() function

Vector2 PLMath::Vector2::GetUnpackedFrom01 ( ) const [inline]

Returns a unpacked vector of the range of -1 to 1.

Returns:: The unpacked vector

See also:

UnpackFrom01()

Vector2::Component PLMath::Vector2::GetSmallestComponent ( ) const [inline]

Returns the smallest component.

Returns:: The smallest component

Remarks:: If x is 1 and y is 2, this function will return the x component.

float PLMath::Vector2::GetSmallestValue ( ) const [inline]

Returns the value of the smallest component.

Returns:: The value of the smallest component

See also:

GetSmallestComponent() above

Vector2::Component PLMath::Vector2::GetGreatestComponent ( ) const [inline]

Returns the greatest component.

Returns:: The greatest component

Remarks:: If x is 1 and y is 2, this function will return the y component.

float PLMath::Vector2::GetGreatestValue ( ) const [inline]

Returns the value of the greatest component.

Returns:: The value of the greatest component

See also:

GetGreatestValue() above

void PLMath::Vector2::Invert ( ) [inline]

Inverts the vector.

Remarks:: v'.x = -v.x
v'.y = -v.y

Vector2 PLMath::Vector2::GetInverted ( ) const [inline]

Returns the inverted vector.

Returns:: Inverted vector

See also:

Invert()

float PLMath::Vector2::GetLength ( ) const [inline]

Returns the length of the vector (also called magnitude)

Returns:: Vector length

Remarks:: l = sqrt(x*x + y*y)

float PLMath::Vector2::GetSquaredLength ( ) const [inline]

Returns the squared length of the vector (also called norm)

Returns:: Squared vector length

Remarks:: l = x*x + y*y

Note:

For better performance, use this function instead of GetLength() whenever possible. You can often work with squared lengths instead of the 'real' ones.

void PLMath::Vector2::SetLength ( float fLength = 1.0f ) [inline]

Sets the vector to the given length.

Parameters:

[in] fLength Length to set

Remarks:: v' = v*l/sqrt(x*x + y*y)

Vector2 & PLMath::Vector2::Normalize ( ) [inline]

Normalizes the vector.

Returns:: This instance

Remarks:: v' = v*1/sqrt(x*x + y*y)

Note:

This will set the vector to a length of 1 (same as SetLength(1.0f) :)
A normalized vector is called 'unit vector'

Vector2 PLMath::Vector2::GetNormalized ( ) const [inline]

Returns the normalized vector.

Returns:: Normalized vector

See also:

Normalize()

float PLMath::Vector2::GetDistance ( const Vector2 & vV ) const [inline]

Returns the distance to another vector.

Parameters:

[in] vV The other vector

Returns:: Distance to the other vector

Remarks:: dx = v2.x-v1.x
dy = v2.y-v1.y
d = sqrt(dx*dx + dy*dy)

float PLMath::Vector2::GetSquaredDistance ( const Vector2 & vV ) const [inline]

Returns the squared distance to another vector.

Parameters:

[in] vV The other vector

Returns:: Squared distance to the other vector

Remarks:: dx = v2.x-v1.x
dy = v2.y-v1.y
d = dx*dx + dy*dy

Note:

For better performance, use this function instead of GetDistance() whenever possible. You can often work with squared distances instead of the 'real' ones.

float PLMath::Vector2::DotProduct ( const Vector2 & vV ) const [inline]

Returns the dot product of two vectors.

Parameters:

[in] vV Second vector

Returns:: Dot product of the vectors

Remarks:: d = this->x*vV.x + this->y*vV.y

Note:

The dot product is also known as 'scalar product' or 'inner product'
The dot product of a vector with itself is equal to it's squared length, so it's possible to use GetSquaredLength() instead of v.DotProduct(v)
The dot product is commutative
If the two vectors are perpendicular, their dot product equals zero
If the angle between the two vectors is acute (< 90 degrees) the dot product will be positive, if the angle is obtuse (> 90 degrees) the dot product will be negative
Geometric definition: a.DotProduct(b) = a.GetLength() * b.GetLength() * cos(r)

See also:

GetAngle()

Vector2 PLMath::Vector2::ProjectVector	(	const Vector2 &	vA,
		const Vector2 &	vB
	)		const `[inline]`

Project vector a onto another vector b.

Project the vector onto another vector.

Parameters:

[in]	vA	Vector to project
[in]	vB	Vector to project onto

Remarks:

            ^.
           / .
          /  .
       a /   .
        /    .                                  a.DotProduct(b)
       /     .                  projb(a) = b * -----------------
      /      .                                  b.DotProduct(b)
     /       .
     --->____.
      b      ^= projb(a)

Returns:: The resulting projection vector

float PLMath::Vector2::GetAngle ( const Vector2 & vV ) const [inline]

Calculates the angle between two vectors.

Calculates the angle between two vectos.

Parameters:

[in] vV Second vector

Returns:: The angle between the two vectors (in radians)

Remarks:

                    v1.DotProduct(v2)
     cos A = --------------------------------
              v1.GetLength() * v2.GetLength()

Note:

If the two vectors are normalized, you can also use acos(DotProduct()) which is in this case more performant

PLMATH_API PLCore::String PLMath::Vector2::ToString ( ) const

To string.

Returns:: String with the data

PLMATH_API bool PLMath::Vector2::FromString ( const PLCore::String & sString )

From string.

Parameters:

[in] sString String with the data

Member Data Documentation

PLMATH_API const Vector2 PLMath::Vector2::Zero [static]

0.0, 0.0

PLMATH_API const Vector2 PLMath::Vector2::One [static]

1.0, 1.0

PLMATH_API const Vector2 PLMath::Vector2::NegativeOne [static]

-1.0, -1.0

PLMATH_API const Vector2 PLMath::Vector2::UnitX [static]

1.0, 0.0

PLMATH_API const Vector2 PLMath::Vector2::UnitY [static]

0.0, 1.0

PLMATH_API const Vector2 PLMath::Vector2::NegativeUnitX [static]

-1.0, 0.0

PLMATH_API const Vector2 PLMath::Vector2::NegativeUnitY [static]

0.0, -1.0

float PLMath::Vector2::fV[2]

Vertex element array access.

float PLMath::Vector2::x

float PLMath::Vector2::y

float PLMath::Vector2::u

float PLMath::Vector2::v

union { ... }

Some direct vertex element accesses.

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

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation