core/include/core/math/Vector.hpp

#ifndef CORE_VECTOR_HPP
#define CORE_VECTOR_HPP

#include "core/math/Math.hpp"
#include "core/utils/ArrayString.hpp"

namespace Core {
    template<int N, typename T>
    class alignas(sizeof(T) * (Math::isPowerOf2(N) ? N : 1)) Vector final {
        static_assert(N > 0, "Vector size must be positive");
        T values[static_cast<unsigned int>(N)];

    public:
        Vector() {
            for(int i = 0; i < N; i++) {
                values[i] = static_cast<T>(0);
            }
        }

        template<typename OT, typename... Args>
        Vector(OT a, Args&&... args)
            : values(static_cast<T>(a), static_cast<T>(args)...) {
            static_assert(sizeof...(args) + 1 == N,
                          "vector parameters do not match its size");
        }

    public:
        Vector& setAngles(float, float) = delete;
        Vector cross(const Vector&) const = delete;

        Vector& operator+=(const Vector& other) {
            for(int i = 0; i < N; i++) {
                values[i] += other.values[i];
            }
            return *this;
        }

        Vector operator+(const Vector& other) const {
            Vector v = *this;
            v += other;
            return v;
        }

        Vector& operator-=(const Vector& other) {
            for(int i = 0; i < N; i++) {
                values[i] -= other.values[i];
            }
            return *this;
        }

        Vector operator-() const {
            Vector v = *this;
            for(int i = 0; i < N; i++) {
                v.values[i] = -v.values[i];
            }
            return v;
        }

        Vector operator-(const Vector& other) const {
            Vector v = *this;
            v -= other;
            return v;
        }

        Vector& operator*=(T factor) {
            for(int i = 0; i < N; i++) {
                values[i] *= factor;
            }
            return *this;
        }

        Vector& operator*=(const Vector& other) {
            for(int i = 0; i < N; i++) {
                values[i] *= other.values[i];
            }
            return *this;
        }

        Vector operator*(T factor) const {
            Vector v = *this;
            v *= factor;
            return v;
        }

        Vector operator*(const Vector& other) const {
            Vector v = *this;
            v *= other;
            return v;
        }

        Vector& operator/=(T factor) {
            for(int i = 0; i < N; i++) {
                values[i] /= factor;
            }
            return *this;
        }

        Vector& operator/=(const Vector& other) {
            for(int i = 0; i < N; i++) {
                values[i] /= other.values[i];
            }
            return *this;
        }

        Vector operator/(T factor) const {
            Vector v = *this;
            v /= factor;
            return v;
        }

        Vector operator/(const Vector& other) const {
            Vector v = *this;
            v /= other;
            return v;
        }

        T dot(const Vector& v) const {
            T length = 0.0f;
            for(int i = 0; i < N; i++) {
                length += values[i] * v.values[i];
            }
            return length;
        }

        T squareLength() const {
            return dot(*this);
        }

        float length() const {
            return Math::squareRoot(static_cast<float>(squareLength()));
        }

        Vector& normalize() {
            if constexpr(Core::IsSame<float, T> || Core::IsSame<double, T>) {
                *this *= 1.0f / length();
            } else {
                *this /= static_cast<T>(length());
            }
            return *this;
        }

        T& operator[](int index) {
            return values[index];
        }

        const T& operator[](int index) const {
            return values[index];
        }

        Vector<N, int> toInt() const {
            Vector<N, int> cast;
            for(int i = 0; i < N; i++) {
                cast[i] = static_cast<int>(values[i]);
            }
            return cast;
        }

        Vector<N, float> toFloat() const {
            Vector<N, float> cast;
            for(int i = 0; i < N; i++) {
                cast[i] = static_cast<float>(values[i]);
            }
            return cast;
        }

        template<typename String>
        check_return Error toString(String& s) const {
            CORE_RETURN_ERROR(s.append("["));
            for(int i = 0; i < N - 1; i++) {
                CORE_RETURN_ERROR(s.append(values[i]));
                CORE_RETURN_ERROR(s.append(", "));
            }
            if(N > 0) {
                CORE_RETURN_ERROR(s.append(values[N - 1]));
            }
            return s.append("]");
        }
    };

    using Vector4 = Vector<4, float>;
    using Vector3 = Vector<3, float>;
    using Vector2 = Vector<2, float>;

    static_assert(alignof(Vector4) == sizeof(float) * 4,
                  "invalid Vector4 alignment");
    static_assert(alignof(Vector3) == sizeof(float),
                  "invalid Vector3 alignment");
    static_assert(alignof(Vector2) == sizeof(float) * 2,
                  "invalid Vector2 alignment");

    using IntVector4 = Vector<4, int>;
    using IntVector3 = Vector<3, int>;
    using IntVector2 = Vector<2, int>;

    static_assert(alignof(IntVector4) == sizeof(int) * 4,
                  "invalid IntVector4 alignment");
    static_assert(alignof(IntVector3) == sizeof(int),
                  "invalid IntVector3 alignment");
    static_assert(alignof(IntVector2) == sizeof(int) * 2,
                  "invalid IntVector2 alignment");

    template<>
    Vector3& Vector3::setAngles(float lengthAngle, float widthAngle);

    template<>
    Vector3 Vector3::cross(const Vector3& other) const;
}

template<int N, typename T>
Core::Vector<N, T> operator*(T factor, const Core::Vector<N, T>& v) {
    return v * factor;
}

#endif