spk_vector3.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_vector2.hpp"
 
namespace spk
{
    template <typename TType>
    struct IVector3
    {
        using value_type = TType;

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

        constexpr IVector3() = default;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        IVector3 &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;
            return *this;
        }

        bool isZero() const
        {
            return spk::SafeComparand(x) == 0 &&
                   spk::SafeComparand(y) == 0 &&
                   spk::SafeComparand(z) == 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);
            return (px * px) + (py * py) + (pz * pz);
        }

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

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

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

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

        IVector3 cross(const IVector3 &p_other) const
        {
            const auto ax = static_cast<float>(x);
            const auto ay = static_cast<float>(y);
            const auto az = static_cast<float>(z);
            const auto bx = static_cast<float>(p_other.x);
            const auto by = static_cast<float>(p_other.y);
            const auto bz = static_cast<float>(p_other.z);
 
            return IVector3(
                static_cast<TType>((ay * bz) - (az * by)),
                static_cast<TType>((az * bx) - (ax * bz)),
                static_cast<TType>((ax * by) - (ay * bx)));
        }

        IVector2<TType> xy() const
        {
            return IVector2<TType>(x, y);
        }

        IVector2<TType> yz() const
        {
            return IVector2<TType>(y, z);
        }

        template <typename TAlpha>
            requires std::is_arithmetic_v<TAlpha>
        static IVector3 lerp(const IVector3 &p_from, const IVector3 &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 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;
            return IVector3(
                static_cast<TType>(startX + (deltaX * alpha)),
                static_cast<TType>(startY + (deltaY * alpha)),
                static_cast<TType>(startZ + (deltaZ * alpha)));
        }

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

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

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

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

        static IVector3 max(std::initializer_list<IVector3> p_values)
        {
            if (p_values.size() == 0)
            {
                throw std::invalid_argument("IVector3::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 IVector3 clamp(const IVector3 &p_value, const IVector3 &p_boundA, const IVector3 &p_boundB)
        {
            const IVector3 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));
            const IVector3 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));
 
            return IVector3(
                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));
        }

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

        static bool isBetween(const IVector3 &p_value, const IVector3 &p_boundA, const IVector3 &p_boundB)
        {
            const IVector3 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));
            const IVector3 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));
 
            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);
        }

        template <typename TOther>
            requires std::is_constructible_v<TOther, TType>
        explicit constexpr operator IVector3<TOther>() const
        {
            return IVector3<TOther>(
                static_cast<TOther>(x),
                static_cast<TOther>(y),
                static_cast<TOther>(z));
        }
    };
 
    template <typename TType>
    inline const IVector3<TType> IVector3<TType>::Zero{};
 
    template <typename TType>
    inline const IVector3<TType> IVector3<TType>::One{
        static_cast<TType>(1),
        static_cast<TType>(1),
        static_cast<TType>(1)};
 
    using Vector3 = IVector3<float_t>;
    using Vector3Int = IVector3<int32_t>;
    using Vector3UInt = IVector3<uint32_t>;
}