core/modules/Vector.cppm

module;

export module Core.Vector;

export import Core.Types;

import Core.Math;
import Core.Meta;
import Core.ToString;
import Core.Std;

export namespace Core {
    template<size_t N, typename T>
    class alignas(sizeof(T) * (Core::isPowerOf2(N) ? N : 1)) Vector final {
        T values[N];

    public:
        Vector() {
            for(size_t 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");
        }

        Vector& operator+=(const Vector& other) {
            for(size_t 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(size_t i = 0; i < N; i++) {
                values[i] -= other.values[i];
            }
            return *this;
        }

        Vector operator-() const {
            Vector v = *this;
            for(size_t 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(size_t i = 0; i < N; i++) {
                values[i] *= factor;
            }
            return *this;
        }

        Vector& operator*=(const Vector& other) {
            for(size_t 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(size_t i = 0; i < N; i++) {
                values[i] /= factor;
            }
            return *this;
        }

        Vector& operator/=(const Vector& other) {
            for(size_t 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(size_t i = 0; i < N; i++) {
                length += values[i] * v.values[i];
            }
            return length;
        }

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

        float length() const {
            return sqrtf(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[](size_t index) {
            return values[index];
        }

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

        template<typename C>
        Vector<N, C> to() const {
            Vector<N, C> cast;
            for(size_t i = 0; i < N; i++) {
                cast[i] = static_cast<C>(values[i]);
            }
            return cast;
        }

        Vector<N, int> toInt() const {
            return to<int>();
        }

        Vector<N, float> toFloat() const {
            return to<float>();
        }

        size_t toString(char* s, size_t n) const {
            size_t total = 0;
            addString("[", s, n, total);
            for(size_t i = 0; i < N - 1; i++) {
                addString(values[i], s, n, total);
                addString(", ", s, n, total);
            }
            if constexpr(N > 0) {
                addString(values[N - 1], s, n, total);
            }
            addString("]", s, n, total);
            return total;
        }

        bool operator==(const Vector& other) const {
            for(size_t i = 0; i < N; i++) {
                if(notEqual(values[i], other.values[i])) {
                    return false;
                }
            }
            return true;
        }

        template<Core::If<N >= 3, int, void*> = 0>
        auto& xyz() {
            return *reinterpret_cast<Vector<3, T>*>(this);
        }

        template<Core::If<N >= 3, int, void*> = 0>
        const auto& xyz() const {
            return *reinterpret_cast<const Vector<3, T>*>(this);
        }

    private:
        template<typename O>
        static bool notEqual(const O& a, const O& b) {
            return a != b;
        }

        static bool notEqual(float a, float b) {
            constexpr float e = 0.00001f;
            float diff = a - b;
            return diff < -e || diff > e;
        }
    };

    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");

    void setAngles(Vector3& v, float lengthAngle, float widthAngle);
    Vector3 cross(const Vector3& a, const Vector3& b);
}

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