spk_vector2.hpp

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
 
#include "structure/math/spk_safe_comparand.hpp"
 
namespace spk
{
    template <typename TType>
    struct IVector2
    {
        using value_type = TType;

        TType x{};
        TType y{};

        constexpr IVector2() = default;

        template <typename TX, typename TY>
            requires(std::is_constructible_v<TType, TX> && std::is_constructible_v<TType, TY>)
        constexpr IVector2(const TX &p_x, const TY &p_y) :
            x(static_cast<TType>(p_x)),
            y(static_cast<TType>(p_y))
        {
        }

        template <typename TOther>
            requires std::is_constructible_v<TType, TOther>
        explicit constexpr IVector2(const IVector2<TOther> &p_other) :
            x(static_cast<TType>(p_other.x)),
            y(static_cast<TType>(p_other.y))
        {
        }

        template <typename TOther>
            requires std::is_constructible_v<TType, TOther>
        explicit constexpr IVector2(const TOther &p_value) :
            x(static_cast<TType>(p_value)),
            y(static_cast<TType>(p_value))
        {
        }

        static const IVector2 Zero;
        static const IVector2 One;

        std::string toString() const
        {
            std::ostringstream stream;
            stream << *this;
            return stream.str();
        }

        std::wstring toWstring() const
        {
            std::wostringstream stream;
            stream << *this;
            return stream.str();
        }

        friend std::ostream &operator<<(std::ostream &p_stream, const IVector2 &p_value)
        {
            p_stream << '(' << p_value.x << ", " << p_value.y << ')';
            return p_stream;
        }

        friend std::wostream &operator<<(std::wostream &p_stream, const IVector2 &p_value)
        {
            p_stream << L'(' << p_value.x << L", " << p_value.y << L')';
            return p_stream;
        }

        bool operator==(const IVector2 &p_other) const
        {
            return spk::SafeComparand(x) == p_other.x &&
                   spk::SafeComparand(y) == p_other.y;
        }

        bool operator!=(const IVector2 &p_other) const
        {
            return !(*this == p_other);
        }

        IVector2 operator+(const IVector2 &p_other) const
        {
            return IVector2(x + p_other.x, y + p_other.y);
        }

        IVector2 operator-(const IVector2 &p_other) const
        {
            return IVector2(x - p_other.x, y - p_other.y);
        }

        IVector2 operator*(const IVector2 &p_other) const
        {
            return IVector2(x * p_other.x, y * p_other.y);
        }

        IVector2 operator/(const IVector2 &p_other) const
        {
            if (spk::SafeComparand(p_other.x) == 0 ||
                spk::SafeComparand(p_other.y) == 0)
            {
                throw std::invalid_argument("Can't divide by 0");
            }
            return IVector2(x / p_other.x, y / p_other.y);
        }

        IVector2 operator+(const TType &p_scalar) const
        {
            return IVector2(x + p_scalar, y + p_scalar);
        }

        IVector2 operator-(const TType &p_scalar) const
        {
            return IVector2(x - p_scalar, y - p_scalar);
        }

        IVector2 operator*(const TType &p_scalar) const
        {
            return IVector2(x * p_scalar, y * p_scalar);
        }

        IVector2 operator/(const TType &p_scalar) const
        {
            if (spk::SafeComparand(p_scalar) == 0)
            {
                throw std::invalid_argument("Can't divide by 0");
            }
            return IVector2(x / p_scalar, y / p_scalar);
        }

        friend IVector2 operator+(const TType &p_scalar, const IVector2 &p_vector)
        {
            return p_vector + p_scalar;
        }

        friend IVector2 operator-(const TType &p_scalar, const IVector2 &p_vector)
        {
            return IVector2(p_scalar - p_vector.x, p_scalar - p_vector.y);
        }

        friend IVector2 operator*(const TType &p_scalar, const IVector2 &p_vector)
        {
            return p_vector * p_scalar;
        }

        friend IVector2 operator/(const TType &p_scalar, const IVector2 &p_vector)
        {
            if (spk::SafeComparand(p_vector.x) == 0 ||
                spk::SafeComparand(p_vector.y) == 0)
            {
                throw std::invalid_argument("Can't divide by 0");
            }
            return IVector2(p_scalar / p_vector.x, p_scalar / p_vector.y);
        }

        IVector2 inverse() const
        {
            return IVector2(-x, -y);
        }

        IVector2 operator-() const
        {
            return inverse();
        }

        IVector2 &operator+=(const IVector2 &p_other)
        {
            x += p_other.x;
            y += p_other.y;
            return *this;
        }

        IVector2 &operator-=(const IVector2 &p_other)
        {
            x -= p_other.x;
            y -= p_other.y;
            return *this;
        }

        IVector2 &operator*=(const IVector2 &p_other)
        {
            x *= p_other.x;
            y *= p_other.y;
            return *this;
        }

        IVector2 &operator/=(const IVector2 &p_other)
        {
            if (spk::SafeComparand(p_other.x) == 0 ||
                spk::SafeComparand(p_other.y) == 0)
            {
                throw std::invalid_argument("Can't divide by 0");
            }
            x /= p_other.x;
            y /= p_other.y;
            return *this;
        }

        IVector2 &operator+=(const TType &p_scalar)
        {
            x += p_scalar;
            y += p_scalar;
            return *this;
        }

        IVector2 &operator-=(const TType &p_scalar)
        {
            x -= p_scalar;
            y -= p_scalar;
            return *this;
        }

        IVector2 &operator*=(const TType &p_scalar)
        {
            x *= p_scalar;
            y *= p_scalar;
            return *this;
        }

        IVector2 &operator/=(const TType &p_scalar)
        {
            if (spk::SafeComparand(p_scalar) == 0)
            {
                throw std::invalid_argument("Can't divide by 0");
            }
            x /= p_scalar;
            y /= p_scalar;
            return *this;
        }

        bool isZero() const
        {
            return spk::SafeComparand(x) == 0 &&
                   spk::SafeComparand(y) == 0;
        }

        float squaredLength() const
        {
            const auto px = static_cast<float>(x);
            const auto py = static_cast<float>(y);
            return (px * px) + (py * py);
        }

        IVector2<float> normalize() const
        {
            float baseSquareLenght = squaredLength();
 
            if (spk::SafeComparand(baseSquareLenght) == 0)
            {
                throw std::runtime_error("Can't normilize a vector of norm == 0");
            }
            return (this->operator/(std::sqrt(baseSquareLenght)));
        }

        float length() const
        {
            return static_cast<float>(std::sqrt(static_cast<double>(squaredLength())));
        }

        float squaredDistance(const IVector2 &p_other) const
        {
            return (*this - p_other).squaredLength();
        }

        float distance(const IVector2 &p_other) const
        {
            return (*this - p_other).length();
        }

        float dot(const IVector2 &p_other) const
        {
            const auto px = static_cast<float>(x);
            const auto py = static_cast<float>(y);
            return (px * static_cast<float>(p_other.x)) +
                   (py * static_cast<float>(p_other.y));
        }

        float cross(const IVector2 &p_other) const
        {
            return (static_cast<float>(x) * static_cast<float>(p_other.y)) -
                   (static_cast<float>(y) * static_cast<float>(p_other.x));
        }

        IVector2 perpendicular() const
        {
            return IVector2(-y, x);
        }

        static IVector2 lerp(const IVector2 &p_from, const IVector2 &p_to, const float &p_alpha)
        {
            const auto startX = static_cast<float>(p_from.x);
            const auto startY = static_cast<float>(p_from.y);
            const auto deltaX = static_cast<float>(p_to.x) - startX;
            const auto deltaY = static_cast<float>(p_to.y) - startY;
            return IVector2(
                static_cast<TType>(startX + (deltaX * p_alpha)),
                static_cast<TType>(startY + (deltaY * p_alpha)));
        }

        static IVector2 min(const IVector2 &p_a, const IVector2 &p_b)
        {
            return IVector2(
                std::min(p_a.x, p_b.x),
                std::min(p_a.y, p_b.y));
        }

        template <typename... TOthers>
            requires(sizeof...(TOthers) > 0 && (std::is_same_v<TOthers, IVector2> && ...))
        static IVector2 min(const IVector2 &p_a, const IVector2 &p_b, const TOthers &...p_rest)
        {
            return min(min(p_a, p_b), p_rest...);
        }

        static IVector2 min(std::initializer_list<IVector2> p_values)
        {
            if (p_values.size() == 0)
            {
                throw std::invalid_argument("IVector2::min requires at least one operand");
            }
 
            auto result = *p_values.begin();
            for (auto it = std::next(p_values.begin()); it != p_values.end(); ++it)
            {
                result = min(result, *it);
            }
            return result;
        }

        static IVector2 max(const IVector2 &p_a, const IVector2 &p_b)
        {
            return IVector2(
                std::max(p_a.x, p_b.x),
                std::max(p_a.y, p_b.y));
        }

        template <typename... TOthers>
            requires(sizeof...(TOthers) > 0 && (std::is_same_v<TOthers, IVector2> && ...))
        static IVector2 max(const IVector2 &p_a, const IVector2 &p_b, const TOthers &...p_rest)
        {
            return max(max(p_a, p_b), p_rest...);
        }

        static IVector2 max(std::initializer_list<IVector2> p_values)
        {
            if (p_values.size() == 0)
            {
                throw std::invalid_argument("IVector2::max requires at least one operand");
            }
 
            auto result = *p_values.begin();
            for (auto it = std::next(p_values.begin()); it != p_values.end(); ++it)
            {
                result = max(result, *it);
            }
            return result;
        }

        static IVector2 clamp(const IVector2 &p_value, const IVector2 &p_boundMinimum, const IVector2 &p_boundMaximum)
        {
            const IVector2 low(
                std::min(p_boundMinimum.x, p_boundMaximum.x),
                std::min(p_boundMinimum.y, p_boundMaximum.y));
            const IVector2 high(
                std::max(p_boundMinimum.x, p_boundMaximum.x),
                std::max(p_boundMinimum.y, p_boundMaximum.y));
 
            return IVector2(
                std::clamp(p_value.x, low.x, high.x),
                std::clamp(p_value.y, low.y, high.y));
        }

        IVector2 clamped(const IVector2 &p_boundMinimum, const IVector2 &p_boundMaximum) const
        {
            return clamp(*this, p_boundMinimum, p_boundMaximum);
        }

        static bool isBetween(const IVector2 &p_value, const IVector2 &p_valueA, const IVector2 &p_valueB)
        {
            return (p_value.x >= p_valueA.x && p_value.x <= p_valueB.x) &&
                   (p_value.y >= p_valueA.y && p_value.y <= p_valueB.y);
        }

        template <typename TOther>
            requires std::is_constructible_v<TOther, TType>
        explicit constexpr operator IVector2<TOther>() const
        {
            return IVector2<TOther>(
                static_cast<TOther>(x),
                static_cast<TOther>(y));
        }
    };
 
    template <typename TType>
    inline const IVector2<TType> IVector2<TType>::Zero{};
 
    template <typename TType>
    inline const IVector2<TType> IVector2<TType>::One{static_cast<TType>(1), static_cast<TType>(1)};
 
    using Vector2 = IVector2<float_t>;
    using Vector2Int = IVector2<int32_t>;
    using Vector2UInt = IVector2<uint32_t>;
}