charcoal/archive/math/vec2.h

#pragma once

#include <cmath>

namespace egm
{

	template <typename T>
	struct tvec2
	{
		T x;
		T y;

		tvec2() : x(0), y(0) {}
		tvec2(const tvec2<T>& v) : x(v.x), y(v.y) {}
		template <typename U>
		tvec2(const tvec2<U>& v) : x((T)v.x), y((T)v.y) {}
		tvec2(const T& scalar) : x(scalar), y(scalar) {}
		tvec2(const T& scalar1, const T& scalar2) : x(scalar1), y(scalar2) {}

		T& operator[](const unsigned int& index)
		{
			switch (index)
			{
			case 0:
				return x;
			case 1:
				return y;
			default:
				throw "Index Out Of Bounds";
			}
		}

		bool operator==(const tvec2<T>& o)
		{
			return (o.x == x && o.y == y);
		}

		tvec2<T>& operator=(const tvec2<T>& o)
		{
			x = o.x;
			y = o.y;
			return *this;
		}

		tvec2<T> operator-() const
		{
			return {
				-x,
				-y,
			};
		}

		tvec2<T> operator+(const tvec2<T>& o) const
		{
			return {
				x + o.x,
				y + o.y
			};
		}

		tvec2<T>& operator+=(const tvec2<T>& o)
		{
			x += o.x;
			y += o.y;
			return *this;
		}

		tvec2<T> operator-(const tvec2<T>& o) const
		{
			return {
				x - o.x,
				y - o.y
			};
		}

		tvec2<T>& operator-=(const tvec2<T>& o)
		{
			x -= o.x;
			y -= o.y;
			return *this;
		}

		tvec2<T> operator*(const tvec2<T>& o) const
		{
			return {
				x * o.x,
				y * o.y
			};
		}

		tvec2<T>& operator*=(const tvec2<T>& o)
		{
			x *= o.x;
			y *= o.y;
			return *this;
		}

		tvec2<T> operator*(const T& scalar) const
		{
			return {
				x * scalar,
				y * scalar
			};
		}

		tvec2<T>& operator*=(const T& scalar)
		{
			x *= scalar;
			y *= scalar;
			return *this;
		}

		tvec2<T> operator/(const tvec2<T>& o) const
		{
			return {
				x / o.x,
				y / o.y
			};
		}

		tvec2<T>& operator/=(const tvec2<T>& o)
		{
			x /= o.x;
			y /= o.y;
			return *this;
		}

		tvec2<T> operator/(const T& scalar) const
		{
			return {
				x / scalar,
				y / scalar
			};
		}

		tvec2<T>& operator/=(const T& scalar)
		{
			x /= scalar;
			y /= scalar;
			return *this;
		}

		T length()
		{
			return sqrt(x * x + y * y);
		}

		T length_squared()
		{
			return x * x + y * y;
		}

		void normalize()
		{
			T l = length();
			x /= l;
			y /= l;
		}
	};

	typedef tvec2<float>	vec2;
	typedef tvec2<double>	dvec2;
	typedef tvec2<int>		ivec2;
}