[Edit: Checkout the improved Vector2 class here: improved Vector2 blog post.]

Hey, it's been a while since I've posted anything, and I've been wanting to share this Vector2 class that I have written. It started being developed less than a year ago, and has undergone some minor changes since then to try to improve efficiency and add functionality. I haven't touched it in a while since then, as I'm now working on a 3D game engine, but here is what I've got.

```/*  __      __   ___     _____    ____
*  \ \    / /  / _ \   |  __ \  |    |
*   \ \/\/ /  / / \ \  | | / /  |  __|
*    \_/\_/  /_/   \_\ |_| \_\  |_|
*      Take it to the next Level
*
*  Copyright (c) 2009 Brian Ernst.
*/

#ifndef w_Vector2
#define w_Vector2

#include <math.h>

namespace _Warp
{
typedef float Scalar;
typedef int Bool;

class Vector2
{
public:
Scalar X;
Scalar Y;

Vector2(const Scalar x = 0,const Scalar y = 0);
~Vector2();

Vector2 operator+(const Vector2& pVector) const;
Vector2 operator-(const Vector2& pVector) const;
Vector2 operator*(const Scalar& num) const;
Vector2 operator/(const Scalar& num) const;
Vector2 operator*(const Vector2& vector) const;
Vector2 operator/(const Vector2& vector) const;
void operator+=(const Vector2& pVector);
void operator-=(const Vector2& pVector);
void operator*=(const Scalar& num);
void operator/=(const Scalar& num);
void operator=(const Vector2& pVector);
Bool operator==(const Vector2& vector) const;
Bool operator!=(const Vector2& vector) const;

void Clamp(const Scalar& value);
void Normalize(const Scalar& value = 1.0f);
void Invert();

Scalar Length() const;

Vector2 Copy() const;

static Vector2 Cartesian(const Scalar& x,const Scalar& y);
static Vector2 Polar(const Scalar& radius,const Scalar& angle);
static Scalar Dot(const Vector2& pVec1,const Vector2& pVec2);
static Vector2 Rotate(const Vector2& pVec,const Scalar& angle);
static const Vector2 Zero;
};

inline Vector2 Vector2::Copy() const
{
return Vector2(X,Y);
}

inline Bool Vector2::operator==(const Vector2& vector) const
{
return X == vector.X && Y == vector.Y;
}

inline Bool Vector2::operator!=(const Vector2& vector) const
{
return X != vector.X || Y != vector.Y;
}

inline Vector2 Vector2::operator+(const Vector2& pVector) const
{
return Vector2(X + pVector.X,Y + pVector.Y);
}

inline Vector2 Vector2::operator-(const Vector2& pVector) const
{
return Vector2(X - pVector.X,Y - pVector.Y);
}

inline Vector2 Vector2::operator*(const Scalar& num) const
{
return Vector2(X * num,Y * num);
}

inline Vector2 Vector2::operator/(const Scalar& num) const
{
return Vector2(X / num,Y / num);
}

inline Vector2 Vector2::operator*(const Vector2& vector) const
{
return Vector2(X * vector.X,Y * vector.Y);
}

inline Vector2 Vector2::operator/(const Vector2& vector) const
{
return Vector2(X / vector.X,Y / vector.Y);
}
}

#endif```

And yes, I realize I need to comment this class, and I will. I might include the source files, but you can just as easily click on the "Source" button on the top right corner of the code box. And here's the cpp definitions file for the Vector2 functions:

```#include "Vector2.h"

namespace _Warp
{
const Vector2 Vector2::Zero = Vector2();

Vector2::Vector2(const Scalar x,const Scalar y)
{
X = x;
Y = y;
}

Vector2::~Vector2()
{
}

void Vector2::operator+=(const Vector2& pVector)
{
X += pVector.X;
Y += pVector.Y;
}

void Vector2::operator-=(const Vector2& pVector)
{
X -= pVector.X;
Y -= pVector.Y;
}

void Vector2::operator*=(const Scalar& num)
{
X *= num;
Y *= num;
}

void Vector2::operator/=(const Scalar& num)
{
X /= num;
Y /= num;
}

void Vector2::operator=(const Vector2& pVector)
{
X = pVector.X;
Y = pVector.Y;
}

Scalar Vector2::Length() const
{
return sqrt(pow(X,2.0f) + pow(Y,2.0f));
}

void Vector2::Clamp(const Scalar& value)
{
if(Length() <= value)
return;
Normalize();
*this *= value;
}

void Vector2::Normalize(const Scalar& value)
{
Scalar vecLength = Length();

if(vecLength == 0)
return;

X = X/vecLength * value;
Y = Y/vecLength * value;
}

void Vector2::Invert()
{
X *= -1;
Y *= -1;
}

Vector2 Vector2::Polar(const Scalar& x,const Scalar& y)
{
Vector2 pVector = Vector2();
pVector.X = atan2(y,x);
pVector.Y = sqrt(x * x + y * y);
return pVector;
}

Vector2 Vector2::Cartesian(const Scalar& radius,const Scalar& angle)
{
Vector2 pVector = Vector2();
pVector.X = radius * cos(angle);
pVector.Y = radius * sin(angle);
return pVector;
}

Scalar Vector2::Dot(const Vector2& pVec1,const Vector2& pVec2)
{
return pVec1.X * pVec2.X + pVec1.Y * pVec2.Y;
}

Vector2 Vector2::Rotate(const Vector2& pVec,const Scalar& angle)
{
Scalar cosResult = cos(angle);
Scalar sinResult = sin(angle);

//Essentially, apply a 2x2 rotation matrix to the vector
Scalar newX = pVec.X * cosResult - pVec.Y * sinResult;
Scalar newY = pVec.X * sinResult + pVec.Y * cosResult;

return Vector2(newX,newY);
}
}```

It's pretty simple, but quite useful and powerful I think. I put it up here for other people to use for quick reference; let me know what you think or just drop me a line telling me you're using it for something, that'd make my day. (:

So here's a zip file you can download: Vector2