3D vector More...

#include <Vector3.h>

Public Types
enum	Component { X = 0, Y = 1, Z = 2 }
	Vector component. More...
Public Member Functions
	Vector3 ()
	Default constructor setting all components to 0.
	Vector3 (float fX, float fY, float fZ=0.0f)
	Vector3 (const float fV[])
PLMATH_API	Vector3 (const Vector2 &vV, float fZ=0.0f)
	Vector3 (const Vector3 &vV)
PLMATH_API	Vector3 (const Vector4 &vV)
	Vector3 (const PLCore::String &sString)
	~Vector3 ()
Vector3 &	operator= (const float fV[])
PLMATH_API Vector3 &	operator= (const Vector2 &vV)
Vector3 &	operator= (const Vector3 &vV)
PLMATH_API Vector3 &	operator= (const Vector4 &vV)
bool	operator== (const Vector3 &vV) const
	Compares two vectors.
bool	operator!= (const Vector3 &vV) const
	Compares two vectors.
bool	operator< (const Vector3 &vV) const
	Compares two vectors lexicographically.
bool	operator> (const Vector3 &vV) const
	Compares two vectors lexicographically.
bool	operator<= (const Vector3 &vV) const
	Compares two vectors lexicographically.
bool	operator>= (const Vector3 &vV) const
	Compares two vectors lexicographically.
Vector3	operator+ (const Vector3 &vV) const
Vector3	operator+ (float fN) const
Vector3 &	operator+= (const Vector3 &vV)
Vector3 &	operator+= (float fN)
Vector3	operator- () const
Vector3	operator- (const Vector3 &vV) const
Vector3	operator- (float fN) const
Vector3 &	operator-= (const Vector3 &vV)
Vector3 &	operator-= (float fN)
Vector3	operator* (const Vector3 &vV) const
	Per component multiplication.
Vector3	operator* (float fS) const
Vector3 &	operator*= (const Vector3 &vV)
	Per component multiplication.
Vector3 &	operator*= (float fS)
PLMATH_API Vector3 &	operator*= (const Matrix3x3 &mRot)
	Rotates the vector.
PLMATH_API Vector3 &	operator*= (const Matrix3x4 &mTrans)
	Transforms the vector.
PLMATH_API Vector3 &	operator*= (const Matrix4x4 &mTrans)
	Transforms the vector.
PLMATH_API Vector3 &	operator*= (const Quaternion &qQ)
	Rotates the vector.
Vector3	operator/ (const Vector3 &vV) const
	Per component division.
Vector3	operator/ (float fS) const
Vector3 &	operator/= (const Vector3 &vV)
	Per component division.
Vector3 &	operator/= (float fS)
	operator float * ()
	operator const float * () const
float &	operator[] (int nIndex)
const float &	operator[] (int nIndex) const
void	GetXYZ (float &fX, float &fY, float &fZ) const
float	GetX () const
float	GetY () const
float	GetZ () const
void	SetXYZ (float fX=0.0f, float fY=0.0f, float fZ=0.0f)
void	SetXYZ (const float fV[])
void	SetX (float fX=0.0f)
void	SetY (float fY=0.0f)
void	SetZ (float fZ=0.0f)
void	IncXYZ (float fX=0.0f, float fY=0.0f, float fZ=0.0f)
void	IncXYZ (const float fV[])
void	IncX (float fX)
void	IncY (float fY)
void	IncZ (float fZ)
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.
Vector3	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.
Vector3	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.
Vector3	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.
Vector3 &	Normalize ()
	Normalizes the vector.
Vector3	GetNormalized () const
	Returns the normalized vector.
float	GetDistance (const Vector3 &vV) const
	Returns the distance to another vector.
float	GetSquaredDistance (const Vector3 &vV) const
	Returns the squared distance to another vector.
float	DotProduct (const Vector3 &vV) const
	Returns the dot product of two vectors.
Vector3	ProjectVector (const Vector3 &vA, const Vector3 &vB) const
	Project vector a onto another vector b.
float	GetAngle (const Vector3 &vV) const
	Calculates the angle between two vectors.
Vector3	CrossProduct (const Vector3 &vV) const
	Returns the cross product of this vector with another.
Vector3 &	CrossProduct (const Vector3 &vV1, const Vector3 &vV2)
	Calculates the cross product of two vectors.
PLMATH_API void	GetRightUp (Vector3 &vRight, Vector3 &vUp) const
	Calculates the right/up vectors of the vector.
PLMATH_API void	GetRightUp (float fRight[], float fUp[]) const
void	GetFaceNormal (const Vector3 &vV1, const Vector3 &vV2, const Vector3 &vV3)
	Calculates a face/plane normal.
PLMATH_API Vector3 &	RotateAxis (Vector3 &vV, float fAngle)
	Rotates two vectors around it's axis.
PLMATH_API Quaternion	GetRotationTo (const Vector3 &vDest) const
	Returns a rotation quaternion to the destination vector.
PLMATH_API Vector3 &	GetProjection (const Vector3 &vX, const Vector3 &vN)
	Calculates a normalized projection vector.
PLMATH_API Vector3 &	ProjectPlane (const Vector3 &vV1, const Vector3 &vV2)
	Project the vector on to the plane created by two direction vectors.
PLMATH_API Vector3 &	Reflect (const Vector3 &vIncidentNormal, const Vector3 &vNormal)
	Calculates a reflection vector.
PLMATH_API Vector3 &	Refract (const Vector3 &vIncidentNormal, const Vector3 &vNormal, float fEtaRatio)
	Calculates a refraction vector.
PLMATH_API Vector3	ClosestPointOnLine (const Vector3 &vV1, const Vector3 &vV2) const
	Finds the closest point on a line to this point.
PLMATH_API bool	IsPointInTriangle (const Vector3 &vV1, const Vector3 &vV2, const Vector3 &vV3) const
	Check if a point is in a triangle.
PLMATH_API Vector3	ClosestPointOnTriangle (const Vector3 &vV1, const Vector3 &vV2, const Vector3 &vV3) const
	Find the closest point on a triangle to this point.
PLMATH_API bool	ClosestPointOnTriangle (const Vector3 &vV1, const Vector3 &vV2, const Vector3 &vV3, float fRadius, Vector3 &vClosest) const
	Find the closest point on a triangle to this point.
PLMATH_API Vector3	To2DCoordinate (const Matrix4x4 &mWorldViewProjection, const Rectangle &cViewportRectangle, float fDepthRangeMin=0.0f, float fDepthRangeMax=1.0f, float *pfHomogeneousDivide=nullptr) const
	Returns the 2D screen coordinate corresponding to this 3D coordinate.
PLMATH_API Vector3	To3DCoordinate (const Matrix4x4 &mProj, const Matrix4x4 &mView, const Matrix4x4 &mWorld, const Rectangle &cViewportRectangle) const
	Returns the 3D coordinate corresponding to this 2D screen coordinate.
PLMATH_API PLCore::String	ToString () const
	To string.
PLMATH_API bool	FromString (const PLCore::String &sString)
	From string.
Public Attributes
union {
float fV [3]
	Vertex element array access.
struct {
float x
float y
float z
}
	Known vertex element names when dealing with positions or directions.
struct {
float u
float v
float w
}
	Known vertex element names when dealing with texture coordinates.
struct {
float fPitch
float fYaw
float fRoll
}
	Known vertex element names when dealing with rotations.
};
	Some direct vertex element accesses.
Static Public Attributes
static PLMATH_API const Vector3	Zero
static PLMATH_API const Vector3	One
static PLMATH_API const Vector3	NegativeOne
static PLMATH_API const Vector3	UnitX
static PLMATH_API const Vector3	UnitY
static PLMATH_API const Vector3	UnitZ
static PLMATH_API const Vector3	NegativeUnitX
static PLMATH_API const Vector3	NegativeUnitY
static PLMATH_API const Vector3	NegativeUnitZ

Detailed Description

3D vector

Member Enumeration Documentation

enum PLMath::Vector3::Component

Vector component.

Enumerator:

X	X component
Y	Y component
Z	Z component

Constructor & Destructor Documentation

PLMath::Vector3::Vector3 ( ) [inline]

Default constructor setting all components to 0.

PLMath::Vector3::Vector3	(	float	fX,
		float	fY,
		float	fZ = `0.0f`
	)		`[inline]`

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

PLMATH_API PLMath::Vector3::Vector3	(	const Vector2 &	vV,
		float	fZ = `0.0f`
	)

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

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

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

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

Member Function Documentation

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

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

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

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

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

Compares two vectors.

Parameters:

[in] vV Vector to compare with

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

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

Compares two vectors.

Parameters:

[in] vV Vector to compare with

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

bool PLMath::Vector3::operator< ( const Vector3 & 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 3-dimensional vectors is used (see http://en.wikipedia.org/wiki/Ordered_vector_space)

bool PLMath::Vector3::operator> ( const Vector3 & 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::Vector3::operator<= ( const Vector3 & 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::Vector3::operator>= ( const Vector3 & 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 <"

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

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

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

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

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

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

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

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

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

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

Per component multiplication.

Parameters:

[in] vV Vector to multiplicate with

Returns:: The resulting vector

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

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

Per component multiplication.

Parameters:

[in] vV Vector to multiplicate with

Returns:: This vector which is now the resulting vector

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

PLMATH_API Vector3& PLMath::Vector3::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 Vector3& PLMath::Vector3::operator*= ( const Matrix3x4 & mTrans )

Transforms the vector.

Parameters:

[in] mTrans Matrix which transforms the vector

Returns:: This vector which is now the resulting vector

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

Transforms the vector.

Parameters:

[in] mTrans Matrix which transforms the vector

Returns:: This vector which is now the resulting vector

PLMATH_API Vector3& PLMath::Vector3::operator*= ( const Quaternion & qQ )

Rotates the vector.

Parameters:

[in] qQ Quaternion which rotates the vector

Returns:: This vector which is now the resulting vector

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

Per component division.

Parameters:

[in] vV Vector to divide through

Returns:: The resulting vector

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

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

Per component division.

Parameters:

[in] vV Vector to divide through

Returns:: This vector which is now the resulting vector

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

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

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

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

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

void PLMath::Vector3::GetXYZ	(	float &	fX,
		float &	fY,
		float &	fZ
	)		const `[inline]`

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

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

float PLMath::Vector3::GetZ ( ) const [inline]

void PLMath::Vector3::SetXYZ	(	float	fX = `0.0f`,
		float	fY = `0.0f`,
		float	fZ = `0.0f`
	)		`[inline]`

void PLMath::Vector3::SetXYZ ( const float fV[] ) [inline]

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

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

void PLMath::Vector3::SetZ ( float fZ = 0.0f ) [inline]

void PLMath::Vector3::IncXYZ	(	float	fX = `0.0f`,
		float	fY = `0.0f`,
		float	fZ = `0.0f`
	)		`[inline]`

void PLMath::Vector3::IncXYZ ( const float fV[] ) [inline]

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

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

void PLMath::Vector3::IncZ ( float fZ ) [inline]

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

Returns whether the vector is null or not.

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

bool PLMath::Vector3::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::Vector3::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.

Vector3 PLMath::Vector3::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::Vector3::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

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

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

Returns:: The unpacked vector

See also:

UnpackFrom01()

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

Returns the smallest component.

Returns:: The smallest component

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

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

Returns the value of the smallest component.

Returns:: The value of the smallest component

See also:

GetSmallestComponent() above

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

Returns the greatest component.

Returns:: The greatest component

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

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

Returns the value of the greatest component.

Returns:: The value of the greatest component

See also:

GetGreatestComponent() above

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

Inverts the vector.

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

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

Returns the inverted vector.

Returns:: Inverted vector

See also:

Invert()

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

Returns the length of the vector (also called magnitude)

Returns:: Vector length

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

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

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

Returns:: Squared vector length

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

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::Vector3::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 + z*z)

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

Normalizes the vector.

Returns:: This instance

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

Note:

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

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

Returns the normalized vector.

Returns:: Normalized vector

See also:

Normalize()

float PLMath::Vector3::GetDistance ( const Vector3 & 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
dz = v2.z-v1.z
d = sqrt(dx*dx + dy*dy + dz*dz)

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

Returns the squared 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
dz = v2.z-v1.z
d = dx*dx + dy*dy + dz*dz

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::Vector3::DotProduct ( const Vector3 & 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 + this->z*vV.z

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()

Vector3 PLMath::Vector3::ProjectVector	(	const Vector3 &	vA,
		const Vector3 &	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::Vector3::GetAngle ( const Vector3 & 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

Vector3 PLMath::Vector3::CrossProduct ( const Vector3 & vV ) const [inline]

Returns the cross product of this vector with another.

Parameters:

[in] vV Vector to calculate the cross product with

Remarks:

      c               (a = this, b = vV)
      ^     a
      |    ^                      | ax |   | bx |   | ay*bz - az*by |
      |   /           c = a x b = | ay | x | by | = | az*bx - ax*bz |
      |  /                        | az |   | bz |   | ax*by - ay*bx |
      | /
      |/--------> b

Returns:: The calculated vector which is perpendicular to the given two vectors

Remarks:: The length of the cross product is the lengths of the individual vectors, multiplied together with the sine of the angle between them. This means you can use the cross product to tell when two vectors are parallel, because if they are parallel their cross product will be zero.

Note:

The cross product is also known as the 'vector product' or 'outer product'
Unlike the dot product, the cross product is only defined for 3-dimensional vectors (and not for 2-dimensional, 4-dimensional and so on)
The cross product is anti commutative (a x b = -(b x a) ... means that the order is important)

Vector3 & PLMath::Vector3::CrossProduct	(	const Vector3 &	vV1,
		const Vector3 &	vV2
	)		`[inline]`

Calculates the cross product of two vectors.

Parameters:

[in]	vV1	First of the two vectors to calculate the cross product from
[in]	vV2	Second of the two vectors to calculate the cross product from

Returns:: Reference to the vector itself which is now perpendicular (and not normalized) to the two vectors

See also:

CrossProduct() above

PLMATH_API void PLMath::Vector3::GetRightUp	(	Vector3 &	vRight,
		Vector3 &	vUp
	)		const

Calculates the right/up vectors of the vector.

Parameters:

[out]	vRight	The resulting right vectors which are perpendicular to the source vector
[out]	vUp	The resulting up vectors which are perpendicular to the source vector

PLMATH_API void PLMath::Vector3::GetRightUp	(	float	fRight[],
		float	fUp[]
	)		const

void PLMath::Vector3::GetFaceNormal	(	const Vector3 &	vV1,
		const Vector3 &	vV2,
		const Vector3 &	vV3
	)		`[inline]`

Calculates a face/plane normal.

Parameters:

[in]	vV1	First of the three vectors which describes the face/plane
[in]	vV2	Second of the three vectors which describes the face/plane
[in]	vV3	Third of the three vectors which describes the face/plane

Remarks:: GetNormalized(CrossProduct(vV1-vV2, vV1-vV3))

PLMATH_API Vector3& PLMath::Vector3::RotateAxis	(	Vector3 &	vV,
		float	fAngle
	)

Rotates two vectors around it's axis.

Parameters:

[in]	vV	Other vector to rotate
[in]	fAngle	Angle the two vectors should be rotated

Returns:: Reference to this vector

PLMATH_API Quaternion PLMath::Vector3::GetRotationTo ( const Vector3 & vDest ) const

Returns a rotation quaternion to the destination vector.

Parameters:

[in] vDest Destination vector

Returns:: Rotation quaternion

PLMATH_API Vector3& PLMath::Vector3::GetProjection	(	const Vector3 &	vX,
		const Vector3 &	vN
	)

Calculates a normalized projection vector.

Parameters:

[in]	vX	The first vector to calculate the projection from
[in]	vN	The second vector to calculate the projection from

Returns:: Reference to the vector itself which is now the resulting projection

PLMATH_API Vector3& PLMath::Vector3::ProjectPlane	(	const Vector3 &	vV1,
		const Vector3 &	vV2
	)

Project the vector on to the plane created by two direction vectors.

Parameters:

[in]	vV1	First of the two direction vectors creating the plane
[in]	vV2	Second of the two direction vectors creating the plane

Returns:: Reference to the vector itself which is now the resulting projection vector

Note:

vV1 and vV2 MUST be perpendicular to each other

PLMATH_API Vector3& PLMath::Vector3::Reflect	(	const Vector3 &	vIncidentNormal,
		const Vector3 &	vNormal
	)

Calculates a reflection vector.

Parameters:

[in]	vIncidentNormal	Incident normal
[in]	vNormal	Plane normal which reflects the incident vector (must be normalized)

Returns:: Reference to the vector itself which is now the resulting reflection vector

Remarks:

If I is the incident vector and N a normalized normal vector, then the reflection vector R is computed as: R = I - 2*N*(N*I) (N*I results in a scalar...)

                Plane normal N
                     |
    Incident ray I   |   Reflected ray R
                  \  |  /
                   \ | /
    ________________\|/________________ Plane

Note:

The reflection vector has the same length as the incident vector

PLMATH_API Vector3& PLMath::Vector3::Refract	(	const Vector3 &	vIncidentNormal,
		const Vector3 &	vNormal,
		float	fEtaRatio
	)

Calculates a refraction vector.

Parameters:

[in]	vIncidentNormal	Incident normal
[in]	vNormal	Plane normal which refracts the incident vector (must be normalized)
[in]	fEtaRatio	Index of refraction ratio

Returns:: Reference to the vector itself which is now the resulting refraction vector

Remarks:

Calculates a refraction vector using Snell's Law.

                Plane normal N
                     |
    Incident ray I   |
                  \  |
                   \ |
    ________________\|_________________ Plane
                     \
                        \
                           \
                            Refracted ray R

Here are some indices of refraction: Vacuum = 1.0, Air = 1.003, Water = 1.3333, Glass = 1.5, Plastic = 1.5, Diamond = 2.417

Note:

The refraction vector has the same length as the incident vector

PLMATH_API Vector3 PLMath::Vector3::ClosestPointOnLine	(	const Vector3 &	vV1,
		const Vector3 &	vV2
	)		const

Finds the closest point on a line to this point.

Parameters:

[in]	vV1	Line start position
[in]	vV2	Line end position

Returns:: The closest point on line

PLMATH_API bool PLMath::Vector3::IsPointInTriangle	(	const Vector3 &	vV1,
		const Vector3 &	vV2,
		const Vector3 &	vV3
	)		const

Check if a point is in a triangle.

Parameters:

[in]	vV1	First triangle point
[in]	vV2	Second triangle point
[in]	vV3	Third triangle point

Returns:: 'true' if the point is in the triangle, else 'false'

PLMATH_API Vector3 PLMath::Vector3::ClosestPointOnTriangle	(	const Vector3 &	vV1,
		const Vector3 &	vV2,
		const Vector3 &	vV3
	)		const

Find the closest point on a triangle to this point.

Parameters:

[in]	vV1	First triangle point
[in]	vV2	Second triangle point
[in]	vV3	Third triangle point

Returns:: The closest point on triangle

PLMATH_API bool PLMath::Vector3::ClosestPointOnTriangle	(	const Vector3 &	vV1,
		const Vector3 &	vV2,
		const Vector3 &	vV3,
		float	fRadius,
		Vector3 &	vClosest
	)		const

Find the closest point on a triangle to this point.

Parameters:

[in]	vV1	First triangle point
[in]	vV2	Second triangle point
[in]	vV3	Third triangle point
[in]	fRadius	Point test radius
[out]	vClosest	Will receive the closest point

Returns:: 'true' if closest point is valid, else 'false'

PLMATH_API Vector3 PLMath::Vector3::To2DCoordinate	(	const Matrix4x4 &	mWorldViewProjection,
		const Rectangle &	cViewportRectangle,
		float	fDepthRangeMin = `0.0f`,
		float	fDepthRangeMax = `1.0f`,
		float *	pfHomogeneousDivide = `nullptr`
	)		const

Returns the 2D screen coordinate corresponding to this 3D coordinate.

Parameters:

[in]	mWorldViewProjection	World view projection matrix to use
[in]	cViewportRectangle	Viewport rectangle to use
[in]	fDepthRangeMin	Depth range minimum
[in]	fDepthRangeMax	Depth range maximum
[in]	pfHomogeneousDivide	If not a null pointer, this receives the homogeneous divide

Returns:: The corresponding 2D screen coordinate (x, y, z depth)

PLMATH_API Vector3 PLMath::Vector3::To3DCoordinate	(	const Matrix4x4 &	mProj,
		const Matrix4x4 &	mView,
		const Matrix4x4 &	mWorld,
		const Rectangle &	cViewportRectangle
	)		const

Returns the 3D coordinate corresponding to this 2D screen coordinate.

Parameters:

[in]	mProj	Projection matrix to use
[in]	mView	View matrix to use
[in]	mWorld	World matrix to use
[in]	cViewportRectangle	Viewport rectangle to use

Returns:: The corresponding 3D coordinate

Remarks:: The depth value stored within the z component of this vector should be between 0.0-1.0. Try to avoid using 0.0 & 1.0, instead add a small value like 0.0001 - else wrong results may be returned, especially if an infinite projection matrix is used.

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

To string.