sf::Vector2< T > Class Template Reference

Class template for manipulating 2-dimensional vectors. More...

#include <Vector2.hpp>

Public Member Functions
constexpr	Vector2 ()=default
	Default constructor.
constexpr	Vector2 (T x, T y)
	Construct the vector from cartesian coordinates.
template<typename U>
constexpr	Vector2 (Vector2< U > vector)
	Construct the vector from another type of vector.
SFML_SYSTEM_API	Vector2 (T r, Angle phi)
	Construct the vector from polar coordinates (floating-point).
SFML_SYSTEM_API T	length () const
	Length of the vector (floating-point).
constexpr T	lengthSquared () const
	Square of vector's length.
SFML_SYSTEM_API Vector2	normalized () const
	Vector with same direction but length 1 (floating-point).
SFML_SYSTEM_API Angle	angleTo (Vector2 rhs) const
	Signed angle from *this to rhs (floating-point).
SFML_SYSTEM_API Angle	angle () const
	Signed angle from +X or (1,0) vector (floating-point).
SFML_SYSTEM_API Vector2	rotatedBy (Angle phi) const
	Rotate by angle phi (floating-point).
SFML_SYSTEM_API Vector2	projectedOnto (Vector2 axis) const
	Projection of this vector onto axis (floating-point).
constexpr Vector2	perpendicular () const
	Returns a perpendicular vector.
constexpr T	dot (Vector2 rhs) const
	Dot product of two 2D vectors.
constexpr T	cross (Vector2 rhs) const
	Z component of the cross product of two 2D vectors.
constexpr Vector2	componentWiseMul (Vector2 rhs) const
	Component-wise multiplication of *this and rhs.
constexpr Vector2	componentWiseDiv (Vector2 rhs) const
	Component-wise division of *this and rhs.

Public Attributes
T	x {}
	X coordinate of the vector.
T	y {}
	Y coordinate of the vector.

Static Public Attributes
static const Vector2	UnitX
	The X unit vector (1, 0), usually facing right.
static const Vector2	UnitY
	The Y unit vector (0, 1), usually facing down.

Related Symbols
(Note that these are not member symbols.)
template<typename T>
constexpr Vector2< T >	operator- (Vector2< T > right)
	Overload of unary operator -.
template<typename T>
constexpr Vector2< T > &	operator+= (Vector2< T > &left, Vector2< T > right)
	Overload of binary operator +=.
template<typename T>
constexpr Vector2< T > &	operator-= (Vector2< T > &left, Vector2< T > right)
	Overload of binary operator -=.
template<typename T>
constexpr Vector2< T >	operator+ (Vector2< T > left, Vector2< T > right)
	Overload of binary operator +.
template<typename T>
constexpr Vector2< T >	operator- (Vector2< T > left, Vector2< T > right)
	Overload of binary operator -.
template<typename T>
constexpr Vector2< T >	operator* (Vector2< T > left, T right)
	Overload of binary operator *.
template<typename T>
constexpr Vector2< T >	operator* (T left, Vector2< T > right)
	Overload of binary operator *.
template<typename T>
constexpr Vector2< T > &	operator*= (Vector2< T > &left, T right)
	Overload of binary operator *=.
template<typename T>
constexpr Vector2< T >	operator/ (Vector2< T > left, T right)
	Overload of binary operator /.
template<typename T>
constexpr Vector2< T > &	operator/= (Vector2< T > &left, T right)
	Overload of binary operator /=.
template<typename T>
constexpr bool	operator== (Vector2< T > left, Vector2< T > right)
	Overload of binary operator ==.
template<typename T>
constexpr bool	operator!= (Vector2< T > left, Vector2< T > right)
	Overload of binary operator !=.

Detailed Description

template<typename T>
class sf::Vector2< T >

Class template for manipulating 2-dimensional vectors.

sf::Vector2 is a simple class that defines a mathematical vector with two coordinates (x and y). It can be used to represent anything that has two dimensions: a size, a point, a velocity, a scale, etc.

The API provides basic arithmetic (addition, subtraction, scale), as well as more advanced geometric operations, such as dot/cross products, length and angle computations, projections, rotations, etc.

The template parameter T is the type of the coordinates. It can be any type that supports arithmetic operations (+, -, /, *) and comparisons (==, !=), for example int or float. Note that some operations are only meaningful for vectors where T is a floating point type (e.g. float or double), often because results cannot be represented accurately with integers. The method documentation mentions "(floating-point)" in those cases.

You generally don't have to care about the templated form (sf::Vector2<T>), the most common specializations have special type aliases:

• sf::Vector2<float> is sf::Vector2f
• sf::Vector2<int> is sf::Vector2i
• sf::Vector2<unsigned int> is sf::Vector2u

The sf::Vector2 class has a simple interface, its x and y members can be accessed directly (there are no accessors like setX(), getX()).

Usage example:

sf::Vector2f v(16.5f, 24.f);
v.x = 18.2f;
float y = v.y;
 
sf::Vector2f w = v * 5.f;
sf::Vector2f u;
u = v + w;
 
float s = v.dot(w);
 
bool different = (v != u);

Note: for 3-dimensional vectors, see sf::Vector3.

Constructor & Destructor Documentation

Vector2() [1/4]

template<typename T>

sf::Vector2< T >::Vector2 ( )

constexprdefault

Default constructor.

Creates a Vector2(0, 0).

Vector2() [2/4]

template<typename T>

sf::Vector2< T >::Vector2 ( T x, T y )

constexpr

Construct the vector from cartesian coordinates.

Parameters

x	X coordinate
y	Y coordinate

Vector2() [3/4]

template<typename T>

template<typename U>

sf::Vector2< T >::Vector2 ( Vector2< U > vector )

explicitconstexpr

Construct the vector from another type of vector.

This constructor doesn't replace the copy constructor, it's called only when U != T. A call to this constructor will fail to compile if U is not convertible to T.

Parameters

vector

Vector to convert

Vector2() [4/4]

template<typename T>

SFML_SYSTEM_API sf::Vector2< T >::Vector2	(	T	r,
		Angle	phi )

Construct the vector from polar coordinates (floating-point).

Parameters

r	Length of vector (can be negative)
phi	Angle from X axis

Note that this constructor is lossy: calling length() and angle() may return values different to those provided in this constructor.

In particular, these transforms can be applied:

• Vector2(r, phi) == Vector2(-r, phi + 180_deg)
• Vector2(r, phi) == Vector2(r, phi + n * 360_deg)

Member Function Documentation

angle()

template<typename T>

SFML_SYSTEM_API Angle sf::Vector2< T >::angle ( ) const

nodiscard

Signed angle from +X or (1,0) vector (floating-point).

For example, the vector (1,0) corresponds to 0 degrees, (0,1) corresponds to 90 degrees.

Returns

Angle in the range [-180, 180) degrees.

Precondition

This vector is no zero vector.

angleTo()

template<typename T>

SFML_SYSTEM_API Angle sf::Vector2< T >::angleTo ( Vector2< T > rhs ) const

nodiscard

Signed angle from *this to rhs (floating-point).

Returns

The smallest angle which rotates *this in positive or negative direction, until it has the same direction as rhs. The result has a sign and lies in the range [-180, 180) degrees.

Precondition

Neither *this nor rhs is a zero vector.

componentWiseDiv()

template<typename T>

Vector2 sf::Vector2< T >::componentWiseDiv ( Vector2< T > rhs ) const

nodiscardconstexpr

Component-wise division of *this and rhs.

Computes (lhs.x/rhs.x, lhs.y/rhs.y).

Scaling is the most common use case for component-wise multiplication/division.

Precondition

Neither component of rhs is zero.

componentWiseMul()

template<typename T>

Vector2 sf::Vector2< T >::componentWiseMul ( Vector2< T > rhs ) const

nodiscardconstexpr

Component-wise multiplication of *this and rhs.

Computes (lhs.x*rhs.x, lhs.y*rhs.y).

Scaling is the most common use case for component-wise multiplication/division. This operation is also known as the Hadamard or Schur product.

cross()

template<typename T>

T sf::Vector2< T >::cross ( Vector2< T > rhs ) const

nodiscardconstexpr

Z component of the cross product of two 2D vectors.

Treats the operands as 3D vectors, computes their cross product and returns the result's Z component (X and Y components are always zero).

dot()

template<typename T>

T sf::Vector2< T >::dot ( Vector2< T > rhs ) const

nodiscardconstexpr

Dot product of two 2D vectors.

length()

template<typename T>

SFML_SYSTEM_API T sf::Vector2< T >::length ( ) const

nodiscard

Length of the vector (floating-point).

If you are not interested in the actual length, but only in comparisons, consider using lengthSquared().

lengthSquared()

template<typename T>

T sf::Vector2< T >::lengthSquared ( ) const

nodiscardconstexpr

Square of vector's length.

Suitable for comparisons, more efficient than length().

normalized()

template<typename T>

SFML_SYSTEM_API Vector2 sf::Vector2< T >::normalized ( ) const

nodiscard

Vector with same direction but length 1 (floating-point).

Precondition

*this is no zero vector.

perpendicular()

template<typename T>

Vector2 sf::Vector2< T >::perpendicular ( ) const

nodiscardconstexpr

Returns a perpendicular vector.

Returns *this rotated by +90 degrees; (x,y) becomes (-y,x). For example, the vector (1,0) is transformed to (0,1).

In SFML's default coordinate system with +X right and +Y down, this amounts to a clockwise rotation.

projectedOnto()

template<typename T>

SFML_SYSTEM_API Vector2 sf::Vector2< T >::projectedOnto ( Vector2< T > axis ) const

nodiscard

Projection of this vector onto axis (floating-point).

Parameters

axis	Vector being projected onto. Need not be normalized.

Precondition

axis must not have length zero.

rotatedBy()

template<typename T>

SFML_SYSTEM_API Vector2 sf::Vector2< T >::rotatedBy ( Angle phi ) const

nodiscard

Rotate by angle phi (floating-point).

Returns a vector with same length but different direction.

In SFML's default coordinate system with +X right and +Y down, this amounts to a clockwise rotation by phi.

Friends And Related Symbol Documentation

operator!=()

template<typename T>

bool operator!= ( Vector2< T > left, Vector2< T > right )

related

Overload of binary operator !=.

This operator compares strict difference between two vectors.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

True if left is not equal to right

operator*() [1/2]

template<typename T>

Vector2< T > operator* ( T left, Vector2< T > right )

related

Overload of binary operator *.

Parameters

left	Left operand (a scalar value)
right	Right operand (a vector)

Returns

Memberwise multiplication by left

operator*() [2/2]

template<typename T>

Vector2< T > operator* ( Vector2< T > left, T right )

related

Overload of binary operator *.

Parameters

left	Left operand (a vector)
right	Right operand (a scalar value)

Returns

Memberwise multiplication by right

operator*=()

template<typename T>

Vector2< T > & operator*= ( Vector2< T > & left, T right )

related

Overload of binary operator *=.

This operator performs a memberwise multiplication by right, and assigns the result to left.

Parameters

left	Left operand (a vector)
right	Right operand (a scalar value)

Returns

Reference to left

operator+()

template<typename T>

Vector2< T > operator+ ( Vector2< T > left, Vector2< T > right )

related

Overload of binary operator +.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

Memberwise addition of both vectors

operator+=()

template<typename T>

Vector2< T > & operator+= ( Vector2< T > & left, Vector2< T > right )

related

Overload of binary operator +=.

This operator performs a memberwise addition of both vectors, and assigns the result to left.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

Reference to left

operator-() [1/2]

template<typename T>

Vector2< T > operator- ( Vector2< T > left, Vector2< T > right )

related

Overload of binary operator -.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

Memberwise subtraction of both vectors

operator-() [2/2]

template<typename T>

Vector2< T > operator- ( Vector2< T > right )

related

Overload of unary operator -.

Parameters

right

Vector to negate

Returns

Memberwise opposite of the vector

operator-=()

template<typename T>

Vector2< T > & operator-= ( Vector2< T > & left, Vector2< T > right )

related

Overload of binary operator -=.

This operator performs a memberwise subtraction of both vectors, and assigns the result to left.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

Reference to left

operator/()

template<typename T>

Vector2< T > operator/ ( Vector2< T > left, T right )

related

Overload of binary operator /.

Parameters

left	Left operand (a vector)
right	Right operand (a scalar value)

Returns

Memberwise division by right

operator/=()

template<typename T>

Vector2< T > & operator/= ( Vector2< T > & left, T right )

related

Overload of binary operator /=.

This operator performs a memberwise division by right, and assigns the result to left.

Parameters

left	Left operand (a vector)
right	Right operand (a scalar value)

Returns

Reference to left

operator==()

template<typename T>

bool operator== ( Vector2< T > left, Vector2< T > right )

related

Overload of binary operator ==.

This operator compares strict equality between two vectors.

Parameters

left	Left operand (a vector)
right	Right operand (a vector)

Returns

True if left is equal to right

Member Data Documentation

UnitX

template<typename T>

const Vector2 sf::Vector2< T >::UnitX

static

The X unit vector (1, 0), usually facing right.

UnitY

template<typename T>

const Vector2 sf::Vector2< T >::UnitY

static

The Y unit vector (0, 1), usually facing down.

x

template<typename T>

T sf::Vector2< T >::x {}

X coordinate of the vector.

y

template<typename T>

T sf::Vector2< T >::y {}

Y coordinate of the vector.

---

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

• SFML/System/Vector2.hpp