spk_vector4.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"
 
#include "structure/math/spk_vector3.hpp"
 
namespace spk
{
    template <typename TType>
    struct IVector4
    {
        using value_type = TType;

        TType x{};
        TType y{};
        TType z{};
        TType w{};

        constexpr IVector4() = default;

        template <typename TX, typename TY, typename TZ, typename TW>
            requires(std::is_constructible_v<TType, TX> && std::is_constructible_v<TType, TY> &&
                     std::is_constructible_v<TType, TZ> && std::is_constructible_v<TType, TW>)
        constexpr IVector4(const TX &p_x, const TY &p_y, const TZ &p_z, const TW &p_w) :
            x(static_cast<TType>(p_x)),
            y(static_cast<TType>(p_y)),
            z(static_cast<TType>(p_z)),
            w(static_cast<TType>(p_w))
        {
        }

        template <typename TOtherVector, typename TZ, typename TW>
            requires(std::is_constructible_v<TType, TOtherVector> &&
                     std::is_constructible_v<TType, TZ> && std::is_constructible_v<TType, TW>)
        constexpr IVector4(const IVector2<TOtherVector> &p_other, const TZ &p_z, const TW &p_w) :
            x(static_cast<TType>(p_other.x)),
            y(static_cast<TType>(p_other.y)),
            z(static_cast<TType>(p_z)),
            w(static_cast<TType>(p_w))
        {
        }

        template <typename TOtherVector, typename TW>
            requires(std::is_constructible_v<TType, TOtherVector> && std::is_constructible_v<TType, TW>)
        constexpr IVector4(const IVector3<TOtherVector> &p_other, const TW &p_w) :
            x(static_cast<TType>(p_other.x)),
            y(static_cast<TType>(p_other.y)),
            z(static_cast<TType>(p_other.z)),
            w(static_cast<TType>(p_w))
        {
        }

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

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

        static const IVector4 Zero;
        static const IVector4 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 IVector4 &p_value)
        {
            p_stream << '(' << p_value.x << ", " << p_value.y << ", " << p_value.z << ", " << p_value.w << ')';
            return p_stream;
        }

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

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

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

        IVector4 operator+(const IVector4 &p_other) const
        {
            return IVector4(x + p_other.x, y + p_other.y, z + p_other.z, w + p_other.w);
        }

        IVector4 operator-(const IVector4 &p_other) const
        {
            return IVector4(x - p_other.x, y - p_other.y, z - p_other.z, w - p_other.w);
        }

        IVector4 operator*(const IVector4 &p_other) const
        {
            return IVector4(x * p_other.x, y * p_other.y, z * p_other.z, w * p_other.w);
        }

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

        IVector4 operator+(const TType &p_scalar) const
        {
            return IVector4(x + p_scalar, y + p_scalar, z + p_scalar, w + p_scalar);
        }

        IVector4 operator-(const TType &p_scalar) const
        {
            return IVector4(x - p_scalar, y - p_scalar, z - p_scalar, w - p_scalar);
        }

        IVector4 operator*(const TType &p_scalar) const
        {
            return IVector4(x * p_scalar, y * p_scalar, z * p_scalar, w * p_scalar);
        }

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

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

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

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

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

        IVector4 inverse() const
        {
            return IVector4(-x, -y, -z, -w);
        }

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

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

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

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

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

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

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

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

        IVector4 &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;
            z /= p_scalar;
            w /= p_scalar;
            return *this;
        }

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

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

        IVector3<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 IVector4 &p_other) const
        {
            return (*this - p_other).squaredLength();
        }

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

        float dot(const IVector4 &p_other) const
        {
            const auto px = static_cast<float>(x);
            const auto py = static_cast<float>(y);
            const auto pz = static_cast<float>(z);
            const auto pw = static_cast<float>(w);
            return (px * static_cast<float>(p_other.x)) +
                   (py * static_cast<float>(p_other.y)) +
                   (pz * static_cast<float>(p_other.z)) +
                   (pw * static_cast<float>(p_other.w));
        }

        IVector3<TType> xyz() const
        {
            return IVector3<TType>(x, y, z);
        }

        template <typename TAlpha>
            requires std::is_arithmetic_v<TAlpha>
        static IVector4 lerp(const IVector4 &p_from, const IVector4 &p_to, const TAlpha &p_alpha)
        {
            const auto alpha = static_cast<float>(p_alpha);
            const auto startX = static_cast<float>(p_from.x);
            const auto startY = static_cast<float>(p_from.y);
            const auto startZ = static_cast<float>(p_from.z);
            const auto startW = static_cast<float>(p_from.w);
            const auto deltaX = static_cast<float>(p_to.x) - startX;
            const auto deltaY = static_cast<float>(p_to.y) - startY;
            const auto deltaZ = static_cast<float>(p_to.z) - startZ;
            const auto deltaW = static_cast<float>(p_to.w) - startW;
            return IVector4(
                static_cast<TType>(startX + (deltaX * alpha)),
                static_cast<TType>(startY + (deltaY * alpha)),
                static_cast<TType>(startZ + (deltaZ * alpha)),
                static_cast<TType>(startW + (deltaW * alpha)));
        }

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

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

        static IVector4 min(std::initializer_list<IVector4> p_values)
        {
            if (p_values.size() == 0)
            {
                throw std::invalid_argument("IVector4::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 IVector4 max(const IVector4 &p_a, const IVector4 &p_b)
        {
            return IVector4(
                std::max(p_a.x, p_b.x),
                std::max(p_a.y, p_b.y),
                std::max(p_a.z, p_b.z),
                std::max(p_a.w, p_b.w));
        }

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

        static IVector4 max(std::initializer_list<IVector4> p_values)
        {
            if (p_values.size() == 0)
            {
                throw std::invalid_argument("IVector4::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 IVector4 clamp(const IVector4 &p_value, const IVector4 &p_boundA, const IVector4 &p_boundB)
        {
            const IVector4 low(
                std::min(p_boundA.x, p_boundB.x),
                std::min(p_boundA.y, p_boundB.y),
                std::min(p_boundA.z, p_boundB.z),
                std::min(p_boundA.w, p_boundB.w));
            const IVector4 high(
                std::max(p_boundA.x, p_boundB.x),
                std::max(p_boundA.y, p_boundB.y),
                std::max(p_boundA.z, p_boundB.z),
                std::max(p_boundA.w, p_boundB.w));
 
            return IVector4(
                std::clamp(p_value.x, low.x, high.x),
                std::clamp(p_value.y, low.y, high.y),
                std::clamp(p_value.z, low.z, high.z),
                std::clamp(p_value.w, low.w, high.w));
        }

        IVector4 clamped(const IVector4 &p_boundA, const IVector4 &p_boundB) const
        {
            return clamp(*this, p_boundA, p_boundB);
        }

        static bool isBetween(const IVector4 &p_value, const IVector4 &p_boundA, const IVector4 &p_boundB)
        {
            const IVector4 low(
                std::min(p_boundA.x, p_boundB.x),
                std::min(p_boundA.y, p_boundB.y),
                std::min(p_boundA.z, p_boundB.z),
                std::min(p_boundA.w, p_boundB.w));
            const IVector4 high(
                std::max(p_boundA.x, p_boundB.x),
                std::max(p_boundA.y, p_boundB.y),
                std::max(p_boundA.z, p_boundB.z),
                std::max(p_boundA.w, p_boundB.w));
 
            return (p_value.x >= low.x && p_value.x <= high.x) &&
                   (p_value.y >= low.y && p_value.y <= high.y) &&
                   (p_value.z >= low.z && p_value.z <= high.z) &&
                   (p_value.w >= low.w && p_value.w <= high.w);
        }

        template <typename TOther>
            requires std::is_constructible_v<TOther, TType>
        explicit constexpr operator IVector4<TOther>() const
        {
            return IVector4<TOther>(
                static_cast<TOther>(x),
                static_cast<TOther>(y),
                static_cast<TOther>(z),
                static_cast<TOther>(w));
        }
    };
 
    template <typename TType>
    inline const IVector4<TType> IVector4<TType>::Zero{};
 
    template <typename TType>
    inline const IVector4<TType> IVector4<TType>::One{
        static_cast<TType>(1),
        static_cast<TType>(1),
        static_cast<TType>(1),
        static_cast<TType>(1)};
 
    using Vector4 = IVector4<float_t>;
    using Vector4Int = IVector4<int32_t>;
    using Vector4UInt = IVector4<uint32_t>;
}