Vector2.h

Go to the documentation of this file.

#pragma once
#include <cstdlib>
#include <sstream>
 
namespace Eule
{
    template <typename T> class Vector3;
    template <typename T> class Vector4;
 
    template <typename T>
    class Vector2
    {
    public:
        Vector2() : x{ 0 }, y{ 0 } {}
        Vector2(T _x, T _y) : x{ _x }, y{ _y } {}
        Vector2(const Vector2<T>& other) = default;
        Vector2(Vector2<T>&& other) noexcept = default;
 
        double DotProduct(const Vector2<T>& other) const;
 
        double CrossProduct(const Vector2<T>& other) const;
 
        double SqrMagnitude() const;
 
        double Magnitude() const;
 
        [[nodiscard]] Vector2<double> Normalize() const;
 
        void NormalizeSelf();
 
        Vector2<T> VectorScale(const Vector2<T>& scalar) const;
 
        void LerpSelf(const Vector2<T>& other, double t);
 
        [[nodiscard]] Vector2<double> Lerp(const Vector2<T>& other, double t) const;
 
        [[nodiscard]] bool Similar(const Vector2<T>& other, double epsilon = 0.00001) const;
 
        [[nodiscard]] Vector2<int> ToInt() const;
 
        [[nodiscard]] Vector2<double> ToDouble() const;
 
        T& operator[](std::size_t idx);
        const T& operator[](std::size_t idx) const;
 
        Vector2<T> operator+(const Vector2<T>& other) const;
        void operator+=(const Vector2<T>& other);
        Vector2<T> operator-(const Vector2<T>& other) const;
        void operator-=(const Vector2<T>& other);
        Vector2<T> operator*(const T scale) const;
        void operator*=(const T scale);
        Vector2<T> operator/(const T scale) const;
        void operator/=(const T scale);
        Vector2<T> operator-() const;
 
        operator Vector3<T>() const; 
        operator Vector4<T>() const; 
 
        void operator=(const Vector2<T>& other);
        void operator=(Vector2<T>&& other) noexcept;
 
        bool operator==(const Vector2<T>& other) const;
        bool operator!=(const Vector2<T>& other) const;
 
        friend std::ostream& operator<< (std::ostream& os, const Vector2<T>& v)
        {
            return os << "[x: " << v.x << "  y: " << v.y << "]";
        }
        friend std::wostream& operator<< (std::wostream& os, const Vector2<T>& v)
        {
            return os << L"[x: " << v.x << L"  y: " << v.y << L"]";
        }
 
        T x;
        T y;
 
        // Some handy predefines
        static const Vector2<double> up;
        static const Vector2<double> down;
        static const Vector2<double> right;
        static const Vector2<double> left;
        static const Vector2<double> one;
        static const Vector2<double> zero;
    };
 
    typedef Vector2<int> Vector2i;
    typedef Vector2<double> Vector2d;
}