| TGX 1.0.4 A tiny 2D/3D graphics library optimized for 32 bits microcontrollers.

Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | List of all members
tgx::Vec2< T > Struct Template Reference

Generic 2D vector [specializations iVec2, fVec2, dVec2]. More...

`#include <Vec2.h>`

Inheritance diagram for tgx::Vec2< T >:

## Public Member Functions
| Vec2 ()
| default constructor: the vector content is undefined.
constexpr | Vec2 (T X, T Y)
| Constructor with explicit initialization.
| Vec2 (const Vec2 &v)=default
| Default copy constructor.
Vec2 & | operator= (const Vec2 &V)=default
| Default assignment operator.
template<typename U>
| operator Vec2< U > ()
| Explicit conversion to another vector with different integral type.
| operator Vec2< typename DefaultFPType< T >::fptype > ()
| Implicit conversion to floating-point type vector.
bool | operator== (const Vec2 V) const
| Equality comparator.
bool | operator!= (const Vec2 V) const
| Inequality operator.
bool | operator< (const Vec2 V) const
| Less-than comparison operator.
bool | operator<= (const Vec2 V) const
| Less-than-or-equal comparison operator.
bool | operator> (const Vec2 V) const
| Greater-than comparison operator.
bool | operator>= (const Vec2 V) const
| Greater-than-or-equal comparison operator.
void | operator+= (const Vec2 V)
| Add another vector to this one.
void | operator-= (const Vec2 V)
| Substract another vector from this one.
void | operator*= (const Vec2 V)
| Multiply this vector by another one (coordinate by coordinate multiplication).
void | operator/= (const Vec2 V)
| Divide this vector by another one (coordinate by coordinate division).
void | operator+= (const T &v)
| scalar addition.
void | operator-= (const T &v)
| scalar substraction.
void | operator*= (const T &v)
| scalar multiplication.
void | operator/= (const T &v)
| scalar division.
Vec2 | operator- () const
| unary negation operator
T | norm2 () const
| Compute the squared euclidian norm of the vector.
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Tfloat | norm () const
| Compute the euclidian norm of the vector.
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Tfloat | norm_fast () const
| Compute the euclidian norm of the vector.
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Tfloat | invnorm () const
| Compute the inverse of the euclidian norm of the vector.
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Tfloat | invnorm_fast () const
| Compute the inverse of the euclidian norm of the vector.
template<typename Tfloat = typename DefaultFPType<T>::fptype>
void | normalize ()
| Normalise the vector so that its norm is 1 (do nothing if the vector is 0).
template<typename Tfloat = typename DefaultFPType<T>::fptype>
void | normalize_fast ()
| Normalise the vector so that its norm is 1 (do nothing if the vector is 0).
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Vec2< T > | getNormalize () const
| Return the vector normalized to have unit norm (do nothing if the vector is 0).
template<typename Tfloat = typename DefaultFPType<T>::fptype>
Vec2< T > | getNormalize_fast () const
| Return the vector normalized to have unit norm (do nothing if the vector is 0).
void | rotate90 ()
| Rotate this vector by +90 degree (anti-clockise).
Vec2< T > | getRotate90 () const
| Return the vector obtained after rotation by +90 degree (anti-clockise).
int | leftOf (Vec2< T > LA, Vec2< T > LB) const
| Determine which half-space delimited by the line (LA,LB) the point represented by this vector belongs.
bool | setAsIntersection (Vec2< T > LA1, Vec2< T > LA2, Vec2< T > LB1, Vec2< T > LB2)
| Set this vector as the intersection of the two lines (LA1,LA2) and (LB1,LB2).
void | print (Stream &outputStream=Serial) const
| Print a representation of the vector using a given stream object.

## Public Attributes
T | x
| 'x' coordinate (first dimension)
T | y
| 'y' coordinate (second dimension)

## Detailed Description

template<typename T>
struct tgx::Vec2< T >

Generic 2D vector [specializations iVec2, fVec2, dVec2].

The class contains two public member variables `x` and `y` which define the 2D vector `(x,y)`.

Template Parameters

  `T` | arithmetic type of the vector (`int`, `float`...)

See also
  `Vec3`,`Vec4`

## Member Function Documentation

## ◆ operator Vec2< U >()

template<typename T>
template<typename U>

tgx::Vec2< T >::operator Vec2< U > | ( |  | ) |
| inline explicit

Explicit conversion to another vector with different integral type.

Warning
  the conversion of the vectors components values from type `T` to type `U` is performed with a simple C-style cast.

## ◆ operator==()

template<typename T>

bool tgx::Vec2< T >::operator== | ( | const Vec2< T > | V | ) | const
| inline

Equality comparator.

Return true if all components compare equal.

## ◆ operator<()

template<typename T>

bool tgx::Vec2< T >::operator< | ( | const Vec2< T > | V | ) | const
| inline

Less-than comparison operator.

Use lexicographical order.

## ◆ operator<=()

template<typename T>

bool tgx::Vec2< T >::operator<= | ( | const Vec2< T > | V | ) | const
| inline

Less-than-or-equal comparison operator.

Use lexicographical order.

## ◆ operator>()

template<typename T>

bool tgx::Vec2< T >::operator> | ( | const Vec2< T > | V | ) | const
| inline

Greater-than comparison operator.

Use lexicographical order.

## ◆ operator>=()

template<typename T>

bool tgx::Vec2< T >::operator>= | ( | const Vec2< T > | V | ) | const
| inline

Greater-than-or-equal comparison operator.

Use lexicographical order.

## ◆ operator+=()

template<typename T>

void tgx::Vec2< T >::operator+= | ( | const T & | v | ) |
| inline

scalar addition.

Add v to each of the vector components.

## ◆ operator-=()

template<typename T>

void tgx::Vec2< T >::operator-= | ( | const T & | v | ) |
| inline

scalar substraction.

Add v to each of the vector components.

## ◆ operator*=()

template<typename T>

void tgx::Vec2< T >::operator*= | ( | const T & | v | ) |
| inline

scalar multiplication.

Multiply each of the vector components by v.

## ◆ operator/=()

template<typename T>

void tgx::Vec2< T >::operator/= | ( | const T & | v | ) |
| inline

scalar division.

Divde each of the vector components by v.

## ◆ norm2()

template<typename T>

T tgx::Vec2< T >::norm2 | ( |  | ) | const
| inline

Compute the squared euclidian norm of the vector.

See also
  norm(), norm_fast()

## ◆ norm()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Tfloat tgx::Vec2< T >::norm | ( |  | ) | const
| inline

Compute the euclidian norm of the vector.

Template Parameters

  Tfloat | Return type also used by computation. If left unspecified, the default floating type is used.

See also
  norm_fast()

## ◆ norm_fast()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Tfloat tgx::Vec2< T >::norm_fast | ( |  | ) | const
| inline

Compute the euclidian norm of the vector.

Use the tgx::fast_sqrt() approximation to speedup computations.

Template Parameters

  Tfloat | Return type also used by computation. If left unspecified, the default floating type is used.

See also
  norm()

## ◆ invnorm()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Tfloat tgx::Vec2< T >::invnorm | ( |  | ) | const
| inline

Compute the inverse of the euclidian norm of the vector.

Template Parameters

  Tfloat | Return type also used by computation. If left unspecified, the default floating type is used.

See also
  invnorm_fast()

## ◆ invnorm_fast()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Tfloat tgx::Vec2< T >::invnorm_fast | ( |  | ) | const
| inline

Compute the inverse of the euclidian norm of the vector.

Use the tgx::fast_invsqrt() approximation to speedup computations.

Template Parameters

  Tfloat | Return type also used by computation. If left unspecified, the default floating type is used.

See also
  invnorm()

## ◆ normalize()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

void tgx::Vec2< T >::normalize | ( |  | ) |
| inline

Normalise the vector so that its norm is 1 (do nothing if the vector is 0).

Template Parameters

  Tfloat | Floating point type used for computation (use default floating point type if unspecified).

See also
  normalize_fast()

## ◆ normalize_fast()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

void tgx::Vec2< T >::normalize_fast | ( |  | ) |
| inline

Normalise the vector so that its norm is 1 (do nothing if the vector is 0).

Use fast_invsqrt() approxiamtion to speedup computations.

Template Parameters

  Tfloat | Floating point type used for computation (use default floating point type if unspecified).

See also
  normalize()

## ◆ getNormalize()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Vec2< T > tgx::Vec2< T >::getNormalize | ( |  | ) | const
| inline

Return the vector normalized to have unit norm (do nothing if the vector is 0).

Template Parameters

  Tfloat | Floating point type used for computation (use default floating point type if unspecified).

See also
  getNormalize_fast()

## ◆ getNormalize_fast()

template<typename T>
template<typename Tfloat = typename DefaultFPType<T>::fptype>

Vec2< T > tgx::Vec2< T >::getNormalize_fast | ( |  | ) | const
| inline

Return the vector normalized to have unit norm (do nothing if the vector is 0).

Use fast_invsqrt() approxiamtion to speedup computations.

Template Parameters

  Tfloat | Floating point type used for computation (use default floating point type if unspecified).

See also
  getNormalize()

## ◆ leftOf()

template<typename T>

int tgx::Vec2< T >::leftOf | ( | Vec2< T > | LA,
|  | Vec2< T > | LB ) const
| inline

Determine which half-space delimited by the line (LA,LB) the point represented by this vector belongs.

- Returns 1 if this point is on the left of the oriented line (LA -> LB).
- Returns -1 if this point is on the right of the oriented line (LA -> LB).
- Returns 0 if this point is located on oriented the line (LA , LB).

## ◆ setAsIntersection()

template<typename T>

bool tgx::Vec2< T >::setAsIntersection | ( | Vec2< T > | LA1,
|  | Vec2< T > | LA2,
|  | Vec2< T > | LB1,
|  | Vec2< T > | LB2 )
| inline

Set this vector as the intersection of the two lines (LA1,LA2) and (LB1,LB2).

If the lines are parallel, the vector is left unchanged.

Returns
  true if the intersection point was correctly computed and false if the lines are parallel.

## ◆ print()

template<typename T>

void tgx::Vec2< T >::print | ( | Stream & | outputStream = Serial | ) | const
| inline

Print a representation of the vector using a given stream object.

Attention
  Defined only in the Arduino environment.

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

- src/Mat4.h
- src/Vec2.h