vector.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2025-08-05
// Version V2.1.0
//##################################################################################################
 
#pragma once
 
#include "tuple.h"
 
#include <cmath>
 
namespace cil
{
    class Vector2f;
    class Vector3f;
    class Vector4f;
    class Vector2i;
    class Vector3i;
    class Vector4i;
    class Matrix4f;
 
    template<typename T, typename S>
    class Vector : public Tuple<T>
    {
    public:
        Vector(int size)
            : Tuple<T>(size)
        {
        }
 
        const T& operator[](int index) const
        {
            return this->m_data[index];
        }
 
        T& operator[](int index)
        {
            return this->m_data[index];
        }
 
        const T& operator[](char key) const
        {
            if (key == 'x')
                return this->m_data[0];
            if (key == 'y')
                return this->m_data[1];
            if (key == 'z' && this->m_size >= 3)
                return this->m_data[2];
            if (key == 'w' && this->m_size >= 4)
                return this->m_data[3];
 
            return this->m_data[0];
        }
 
        T& operator[](char key)
        {
            if (key == 'x')
                return this->m_data[0];
            if (key == 'y')
                return this->m_data[1];
            if (key == 'z' && this->m_size >= 3)
                return this->m_data[2];
            if (key == 'w' && this->m_size >= 4)
                return this->m_data[3];
 
            return this->m_data[0];
        }
 
        Vector& operator+=(const Vector& other)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] += other.data()[i];
 
            return *this;
        }
        Vector<T, S>& operator-=(const Vector& other)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] -= other.data()[i];
 
            return *this;
        }
        Vector<T, S>& operator*=(float factor)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] *= factor;
 
            return *this;
        }
 
        Vector<T, S>& operator/=(float factor)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] /= factor;
 
            return *this;
        }
 
        S operator+(const S& other) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] + other.data()[i];
 
            return v;
        }
        S operator-(const S& other) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] - other.data()[i];
 
            return v;
        }
 
        S operator-() const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = -this->m_data[i];
 
            return v;
        }
 
        T operator*(const S& other) const
        {
            T v = 0;
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v += this->m_data[i] * other.data()[i];
 
            return v;
        }
        S operator*(float factor) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] * factor;
 
            return v;
        }
        S operator/(float factor) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] / factor;
 
            return v;
        }
        T squaredLength() const
        {
            T v = 0;
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v += this->m_data[i] * this->m_data[i];
 
            return v;
        }
        float length() const
        {
            return sqrt(this->squaredLength());
        }
        bool setLength(float len)
        {
            auto current = this->length();
            if (current > 0.0)
            {
                float factor = len / current;
                this->operator*=(factor);
 
                return true;
            }
 
            return false;
        }
 
        bool normalize()
        {
            return this->setLength(1.0f);
        }
    };
 
    template<typename T, typename S>
    class Vector2 : public Vector<T, S>
    {
    public:
 
        Vector2()
            : Vector<T, S>(2)
        {
        }
 
        void set(T x, T y)
        {
            this->m_data[0] = x;
            this->m_data[1] = y;
        }
    };
 
    class Vector2i final : public Vector2<int, Vector2i>
    {
    public:
        Vector2i(); 
        Vector2i(int x, int y); 
        Vector2i(const Vector2i& other); 
        Vector2i(const Vector3i& other); 
        Vector2i(const Vector4i& other); 
 
        int manhattanLength() const;
    };
 
    class Vector2f final : public Vector2<float, Vector2f>
    {
    public:
        Vector2f(); 
        Vector2f(float x, float y); 
        Vector2f(const Vector2f& other); 
        Vector2f(const Vector3f& other); 
        Vector2f(const Vector4f& other); 
    };
 
    template<typename T, typename S>
    class Vector3 : public Vector<T, S>
    {
    public:
 
        Vector3()
            : Vector<T, S>(3)
        {
        }
        void set(T x, T y, T z)
        {
            this->m_data[0] = x;
            this->m_data[1] = y;
            this->m_data[2] = z;
        }
 
        S operator^(const S& other) const
        {
            auto a = this->m_data;
            auto b = other.data();
 
            auto x = a[1] * b[2] - a[2] * b[1];
            auto y = a[2] * b[0] - a[0] * b[2];
            auto z = a[0] * b[1] - a[1] * b[0];
 
            return S(x, y, z);
        }
    };
 
    class Vector3i final : public Vector3<int, Vector3i>
    {
    public:
        Vector3i(); 
        Vector3i(int x, int y, int z); 
        Vector3i(const Vector2i& other, int z = 0); 
        Vector3i(const Vector3i& other); 
        Vector3i(const Vector4i& other); 
    };
    class Vector3f final : public Vector3<float, Vector3f>
    {
    public:
        Vector3f(); 
        Vector3f(float x, float y, float z); 
        Vector3f(const Vector2f& other, float z = 0); 
        Vector3f(const Vector3f& other); 
        Vector3f(const Vector4f& other); 
    };
 
    template<typename T, typename S>
    class Vector4 : public Vector<T, S>
    {
    public:
        Vector4()
            : Vector<T, S>(4)
        {
        }
        void set(T x, T y, T z, T w)
        {
            this->m_data[0] = x;
            this->m_data[1] = y;
            this->m_data[2] = z;
            this->m_data[3] = w;
        }
    };
 
 
    class Vector4i final : public Vector4<int, Vector4i>
    {
    public:
        Vector4i(); 
        Vector4i(int x, int y, int z, int w); 
        Vector4i(const Vector2i& other, int z = 0, int w = 0); 
        Vector4i(const Vector3i& other, int w = 0); 
        Vector4i(const Vector4i& other); 
    };
 
 
    class Vector4f final : public Vector4<float, Vector4f>
    {
    public:
        Vector4f(); 
        Vector4f(float x, float y, float z, float w); 
        Vector4f(const Vector2f& other, float z = 0, float w = 0); 
        Vector4f(const Vector3f& other, float w = 0); 
        Vector4f(const Vector4f& other); 
    };
 
    using vec2 = Vector2f;
    using ivec2 = Vector2i;
    using vec3 = Vector3f;
    using ivec3 = Vector3i;
    using vec4 = Vector4f;
    using ivec4 = Vector4i;
}