gaming-core/math/Vector.h

#ifndef VECTOR_H
#define VECTOR_H

#include "math/Math.h"
#include "utils/StringBuffer.h"

template<int N, typename T>
class Vector final {
    T values[N];

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

    template<typename... Args>
    Vector(T a, Args&&... args) {
        init<0>(a, args...);
    }

private:
    template<int I>
    void init() {
        static_assert(I == N, "vector parameters do not match its size");
    }

    template<int I, typename... Args>
    void init(T a, Args&&... args) {
        values[I] = a;
        init<I + 1>(args...);
    }

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/(T factor) const {
        Vector v = *this;
        v /= factor;
        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 sqrtf(squareLength());
    }

    Vector& normalize() {
        *this *= 1.0f / 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] = values[i];
        }
        return cast;
    }

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

    template<int L>
    void toString(StringBuffer<L>& s) const {
        s.append("[");
        for(int i = 0; i < N - 1; i++) {
            s.append(values[i]);
            s.append(", ");
        }
        if(N > 0) {
            s.append(values[N - 1]);
        }
        s.append("]");
    }
};

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

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

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

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

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

#endif