better rage::vector3 class (#165)

rage/vector.hpp

@@ -2,81 +2,231 @@
 
 namespace rage
 {
-	template<typename T>
+	template <typename T>
 	union vector2
 	{
 		T data[2];
-		struct { T x, y; };
+		struct
+		{
+			T x, y;
+		};
 
-		vector2(T x, T y) :
+		vector2(T x, T y) : x(x),
-			x(x),
+							y(y)
-			y(y)
 		{
 		}
 
-		vector2() :
+		vector2() : x(),
-			x(),
+					y()
-			y()
 		{
 		}
 	};
 
-	template<typename T>
+	template <typename T>
 	union vector3
 	{
 		T data[3];
-		struct { T x, y, z; };
+		struct
+		{
+			T x, y, z;
+		};
 
-		vector3(T x, T y, T z) :
+		vector3(T x, T y, T z) noexcept : x(x),
-			x(x),
+										  y(y),
-			y(y),
+										  z(z)
-			z(z)
 		{
 		}
 
-		vector3() :
+		vector3() noexcept : x(),
-			x(),
+							 y(),
-			y(),
+							 z()
-			z()
 		{
 		}
+
+		vector3 operator+(const vector3 &rhs) const
+		{
+			return vector3(x + rhs.x, y + rhs.y, z + rhs.z);
+		}
+
+		vector3 operator-(const vector3 &rhs) const
+		{
+			return vector3(x - rhs.x, y - rhs.y, z - rhs.z);
+		}
+
+		vector3 operator*(const vector3 &rhs) const
+		{
+			return vector3(x * rhs.x, y * rhs.y, z * rhs.z);
+		}
+
+		vector3 operator/(const vector3 &rhs) const
+		{
+			return vector3(x / rhs.x, y / rhs.y, z / rhs.z);
+		}
+
+		vector3 operator+(const float &rhs) const
+		{
+			return vector3(x + rhs, y + rhs, z + rhs);
+		}
+
+		vector3 operator-(const float &rhs) const
+		{
+			return vector3(x - rhs, y - rhs, z - rhs);
+		}
+
+		vector3 operator*(const float &rhs) const
+		{
+			return vector3(x * rhs, y * rhs, z * rhs);
+		}
+
+		vector3 operator/(const float &rhs) const
+		{
+			return vector3(x / rhs, y / rhs, z / rhs);
+		}
+
+		bool operator==(const vector3 &rhs) const
+		{
+			return x == rhs.x && y == rhs.y && z == rhs.z;
+		}
+
+		vector3 &operator+=(const vector3 &rhs)
+		{
+			return *this = *this + rhs;
+		}
+
+		vector3 &operator-=(const vector3 &rhs)
+		{
+			return *this = *this - rhs;
+		}
+
+		vector3 &operator*=(const vector3 &rhs)
+		{
+			return *this = *this * rhs;
+		}
+
+		vector3 &operator/=(const vector3 &rhs)
+		{
+			return *this = *this / rhs;
+		}
+
+		vector3 &operator+=(const float &rhs)
+		{
+			return *this = *this + rhs;
+		}
+
+		vector3 &operator-=(const float &rhs)
+		{
+			return *this = *this - rhs;
+		}
+
+		vector3 &operator*=(const float &rhs)
+		{
+			return *this = *this * rhs;
+		}
+
+		vector3 &operator/=(const float &rhs)
+		{
+			return *this = *this / rhs;
+		}
+
+		T length() const
+		{
+			return sqrt(x * x + y * y + z * z);
+		}
+
+		T magnitude() const
+		{
+			return length();
+		}
+
+		// This doesn't modify the vector inline.
+		vector3 normalize() const
+		{
+			T len = length();
+			if (len)
+			{
+				return *this * (1 / len);
+			}
+
+			return *this;
+		}
+
+		// This doesn't modify the vector inline.
+		vector3 multiply(const vector3 rhs) const
+		{
+			return vector3(x * rhs.x, y * rhs.y, z * rhs.z);
+		}
+
+		// This doesn't modify the vector inline.
+		vector3 invert() const
+		{
+			return *this * -1;
+		}
+
+		// This doesn't modify the vector inline.
+		vector3 cross_product(const vector3 &rhs) const
+		{
+			return vector3(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x);
+		}
+
+		float dot_product(const vector3 &rhs) const
+		{
+			return x * rhs.x + y * rhs.y + z * rhs.z;
+		}
+
+		float distance(const vector3 &rhs) const
+		{
+			return (*this - rhs).length();
+		}
 	};
 
-	template<typename T>
+	template <typename T>
 	union vector4
 	{
 		T data[4];
-		struct { T x, y, z, w; };
+		struct
+		{
+			T x, y, z, w;
+		};
 
-		vector4(T x, T y, T z, T w) :
+		vector4(T x, T y, T z, T w) : x(x),
-			x(x),
+									  y(y),
-			y(y),
+									  z(z),
-			z(z),
+									  w(w)
-			w(w)
 		{
 		}
 
-		vector4() :
+		vector4() : x(),
-			x(),
+					y(),
-			y(),
+					z(),
-			z(),
+					w()
-			w()
 		{
 		}
 	};
 
-	template<typename T>
+	template <typename T>
 	union matrix34
 	{
 		T data[3][4];
-		struct { struct { T x, y, z, w; } rows[3]; };
+		struct
+		{
+			struct
+			{
+				T x, y, z, w;
+			} rows[3];
+		};
 	};
 
-	template<typename T>
+	template <typename T>
 	union matrix44
 	{
 		T data[4][4];
-		struct { struct { T x, y, z, w; } rows[4]; };
+		struct
+		{
+			struct
+			{
+				T x, y, z, w;
+			} rows[4];
+		};
 	};
 
 	typedef vector2<float> fvector2;