Crafter.Math/interfaces/Crafter.Math-Vector.cppm

/*
Crafter®.Math
Copyright (C) 2026 Catcrafts®
catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

export module Crafter.Math:Vector;
import std;

namespace Crafter {
	template <typename T, std::uint32_t Len, std::uint32_t Aligment>
	struct __attribute__((packed)) VectorBase {
		T v[Aligment];
	};
	
	template <typename T, std::uint32_t Aligment>
	struct __attribute__((packed)) VectorBase<T, 1, Aligment> {
		union {
			T v[Aligment];
			T x, r;
		};
	};
	
	template <typename T, std::uint32_t Aligment>
	struct __attribute__((packed)) VectorBase<T, 2, Aligment> {
		union {
			T v[Aligment];
			struct __attribute__((packed)) {
				T x, y;
			};
            struct __attribute__((packed)) {
				T r, g;
			};
		};
		constexpr VectorBase<T, 2, Aligment>(float x, float y): x(x), y(y) {
			
		}
		constexpr VectorBase<T, 2, Aligment>() = default;
	};

	template <typename T, std::uint32_t Aligment>
	struct __attribute__((packed)) VectorBase<T, 3, Aligment> {
		union {
			T v[Aligment];
			struct __attribute__((packed)) {
				T x, y, z;
			};
            struct __attribute__((packed)) {
				T r, g, b;
			};
		};
		constexpr VectorBase<T, 3, Aligment>(float x, float y, float z): x(x), y(y), z(z) {
			
		}
		constexpr VectorBase<T, 3, Aligment>() = default;
	};

	template <typename T, std::uint32_t Aligment>
	struct __attribute__((packed)) VectorBase<T, 4, Aligment> {
		union {
			T v[Aligment];
			struct __attribute__((packed)) {
				T x, y, z, w;
			};
            struct __attribute__((packed)) {
				T r, g, b, a;
			};
		};
		constexpr VectorBase<T, 4, Aligment>(float x, float y, float z, float w): x(x), y(y), z(z), w(w) {
			
		}
		constexpr VectorBase<T, 4, Aligment>() = default;
	};

    template <typename T, std::uint32_t Len>
	struct VectorBase<T, Len, 0> {
		T v[Len];
	};
	
	template <typename T>
	struct VectorBase<T, 1, 0> {
		union {
			T v[1];
			T x, r;
		};
	};
	
	template <typename T>
	struct VectorBase<T, 2, 0> {
		union {
			T v[2];
			struct {
				T x, y;
			};
            struct {
				T r, g;
			};
		};
		constexpr VectorBase<T, 2, 0>(float x, float y): x(x), y(y) {
			
		}
		constexpr VectorBase<T, 2, 0>() = default;
	};

	template <typename T>
	struct VectorBase<T, 3, 0> {
		union {
			T v[3];
			struct {
				T x, y, z;
			};
            struct {
				T r, g, b;
			};
		};
		constexpr VectorBase<T, 3, 0>(float x, float y, float z): x(x), y(y), z(z) {
			
		}
		constexpr VectorBase<T, 3, 0>() = default;
	};

	template <typename T>
	struct VectorBase<T, 4, 0> {
		union {
			T v[4];
			struct {
				T x, y, z, w;
			};
            struct {
				T r, g, b, a;
			};
		};
		constexpr VectorBase<T, 4, 0>(float x, float y, float z, float w): x(x), y(y), z(z), w(w) {
			
		}
		constexpr VectorBase<T, 4, 0>() = default;
	};

	export template <typename T, std::uint32_t Len, std::uint32_t Aligment>
	class Vector : public VectorBase<T, Len, Aligment> {
		public:
		constexpr Vector(float x, float y, float z, float w ) requires(std::same_as<T, float> && Len == 4) : VectorBase<T, Len, Aligment>(x, y, z, w) {

		}
		constexpr Vector(float x, float y, float z) requires(std::same_as<T, float> && Len == 3) : VectorBase<T, Len, Aligment>(x, y, z) {

		}
		constexpr Vector(float x, float y) requires(std::same_as<T, float> && Len == 2) : VectorBase<T, Len, Aligment>(x, y) {

		}

		constexpr Vector() = default;

        template <std::uint32_t BAlignment>
        constexpr operator Vector<T, Len, BAlignment>() const {
            Vector<T, Len, BAlignment> returnVector;
            for(std::uint32_t i = 0; i < Len; i++) {
                returnVector.v[i] = this->v[i];
            }
            return returnVector;
        }

		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr Vector<T, Len, Aligment> operator+(Vector<T, Blen, BAlignment> b) const {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				resultVector.v[i] = this->v[i]+b.v[i];
			}
			return resultVector;
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr Vector<T, Len, Aligment> operator-(Vector<T, Blen, BAlignment> b) const {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				resultVector.v[i] = this->v[i]-b.v[i];
			}
			return resultVector;
		}
		constexpr Vector<T, Len, Aligment> operator-(){
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < Len; i++) {
				resultVector.v[i] = -this->v[i];
			}
			return resultVector;
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr Vector<T, Len, Aligment> operator*(Vector<T, Blen, BAlignment> b) const {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				resultVector.v[i] = this->v[i]*b.v[i];
			}
			return resultVector;
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr Vector<T, Len, Aligment> operator/(Vector<T, Blen, BAlignment> b) const {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				resultVector.v[i] = this->v[i]/b.v[i];
			}
			return resultVector;
		}
        template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr void operator+=(Vector<T, Blen, BAlignment> b){
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				this->v[i]+=b.v[i];
			}
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr void operator-=(Vector<T, Blen, BAlignment> b){
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				this->v[i]-=b.v[i];
			}
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr void operator*=(Vector<T, Blen, BAlignment> b){
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				this->v[i]*=b.v[i];
			}
		}
		template <std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr void operator/=(Vector<T, Blen, BAlignment> b){
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				this->v[i]/=b.v[i];
			}
		}

		template <typename BT>
		constexpr Vector<T, Len, Aligment> operator+(BT b) const requires std::is_arithmetic_v<BT> {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < Len; i++) {
				resultVector.v[i] = this->v[i] + b;
			}
			return resultVector;
		}
		template <typename BT>
		constexpr Vector<T, Len, Aligment> operator-(BT b) const requires std::is_arithmetic_v<BT> {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < Len; i++) {
				resultVector.v[i] = this->v[i] - b;
			}
			return resultVector;
		}
		template <typename BT>
		constexpr Vector<T, Len, Aligment> operator*(BT b) const requires std::is_arithmetic_v<BT> {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < Len; i++) {
				resultVector.v[i] = this->v[i] * b;
			}
			return resultVector;
		}
		template <typename BT>
		constexpr Vector<T, Len, Aligment> operator/(BT b) const requires std::is_arithmetic_v<BT> {
			Vector<T, Len, Aligment> resultVector;
			for(std::uint32_t i = 0; i < Len; i++) {
				resultVector.v[i] = this->v[i] / b;
			}
			return resultVector;
		}
		template <typename BT>
		constexpr void operator+=(BT b) requires std::is_arithmetic_v<BT>{
			for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] += b;
			}
		}
		template <typename BT>
		constexpr void operator-=(BT b) requires std::is_arithmetic_v<BT>{
			for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] -= b;
			}
		}
		template <typename BT>
		constexpr void operator*=(BT b) requires std::is_arithmetic_v<BT>{
			for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] *= b;
			}
		}
		template <typename BT>
		constexpr void operator/=(BT b) requires std::is_arithmetic_v<BT>{
			for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] /= b;
			}
		}

		template <typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr bool operator==(Vector<BT, Blen, BAlignment> b) const {
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				if(this->v[i] != b.v[i]) {
                    return false;
                }
			}
			return true;
		}

        template <typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
		constexpr bool operator!=(Vector<BT, Blen, BAlignment> b) const {
			for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
				if(this->v[i] != b.v[i]) {
                    return true;
                }
			}
			return false;
		}

		constexpr void Normalize() {
			float fLength = Length();
		
			if (fLength > 0) {
				fLength = 1.0f / fLength;
			}

            for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] *= fLength;
			}
		}

        constexpr void Invert() {
            for(std::uint32_t i = 0; i < Len; i++) {
				this->v[i] = -this->v[i];
			}
		}

		constexpr float Length() const {
			float Result = LengthSq();
			return std::sqrtf(Result);
		}

		constexpr float LengthSq() const {
    		return Dot(*this, *this);
		}

        template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment, typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
        constexpr static Vector<T, Len, Aligment> Cross(Vector<AT, Alen, AAlignment> a, Vector<BT, Blen, BAlignment> b) requires(Len == 3 && Alen >= 3 && Blen >= 3) {
            return Vector<T, Len, Aligment>(
            	(a.v[1] * b.v[2]) - (a.v[2] * b.v[1]),
            	(a.v[2] * b.v[0]) - (a.v[0] * b.v[2]),
            	(a.v[0] * b.v[1]) - (a.v[1] * b.v[0])
			);
        }

        template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment>
        constexpr static Vector<T, Len, Aligment> Normalize(Vector<AT, Alen, AAlignment> a) requires(Len == Alen) {
            Vector<T, 3, 0> returned;
            float fLength = a.Length();
		
			if (fLength > 0) {
				fLength = 1.0f / fLength;
			}

            for(std::uint32_t i = 0; i < Len; i++) {
				returned.v[i] = a.v[i] * fLength;
			}
            return returned;
        }

        template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment, typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
        constexpr static float Dot(Vector<AT, Alen, AAlignment> a, Vector<BT, Blen, BAlignment> b) requires(Alen >= Len && Blen >= Len) {
            float accumulate = a.v[0] * b.v[0];
            for(std::uint32_t i = 1; i < Len; i++) {
                accumulate += a.v[i] * b.v[i];
			}
			return accumulate;
		}

        template <typename AT, std::uint32_t AAlignment, typename BT, std::uint32_t BAlignment>
        constexpr static Vector<T, 3, Aligment> Rotate(Vector<AT, 3, AAlignment> v, Vector<BT, 4, BAlignment> q) requires(Len == 3) {
            Vector<T, 3, 0> qv(q.x, q.y, q.z);
            Vector<T, 3, 0> t = Vector<T, 3, Aligment>::Cross(qv, v) * T(2);
            return v + t * q.w + Vector<T, 3, Aligment>::Cross(qv, t);
		}

        template <typename AT, std::uint32_t AAlignment, typename BT, std::uint32_t BAlignment, typename PT, std::uint32_t PAlignment>
        constexpr static Vector<T, 3, Aligment> RotatePivot(Vector<AT, 3, AAlignment> v, Vector<BT, 4, BAlignment> q, Vector<PT, 3, PAlignment> pivot) requires(Len == 3) {
            Vector<T, 3, 0> translated = v - pivot;
            Vector<T, 3, 0> qv(q.x, q.y, q.z);
            Vector<T, 3, 0> t = Cross(qv, translated) * T(2);
            Vector<T, 3, 0> rotated = translated + t * q.w +Cross(qv, t);
            return rotated + pivot;
        }

        template <typename AT, std::uint32_t AAlignment, typename BT, std::uint32_t BAlignment, typename CT, std::uint32_t CAlignment>
        constexpr static Vector<T, 4, Aligment> QuanternionFromBasis(Vector<AT, 3, AAlignment> right, Vector<BT, 3, BAlignment> up, Vector<CT, 3, CAlignment> forward) requires(Len == 4) {
            T m00 = right.x;
            T m01 = up.x;
            T m02 = forward.x;

            T m10 = right.y;
            T m11 = up.y;
            T m12 = forward.y;

            T m20 = right.z;
            T m21 = up.z;
            T m22 = forward.z;

            T trace = m00 + m11 + m22;

            Vector<T, 4, Aligment> q;

            if (trace > std::numeric_limits<T>::epsilon()) {
                T s = std::sqrt(trace + T(1)) * T(2);
                q.w = T(0.25) * s;
                q.x = (m21 - m12) / s;
                q.y = (m02 - m20) / s;
                q.z = (m10 - m01) / s;
            }
            else if ((m00 > m11) && (m00 > m22)) {
                T s = std::sqrt(T(1) + m00 - m11 - m22) * T(2);
                q.w = (m21 - m12) / s;
                q.x = T(0.25) * s;
                q.y = (m01 + m10) / s;
                q.z = (m02 + m20) / s;
            }
            else if (m11 > m22) {
                T s = std::sqrt(T(1) + m11 - m00 - m22) * T(2);
                q.w = (m02 - m20) / s;
                q.x = (m01 + m10) / s;
                q.y = T(0.25) * s;
                q.z = (m12 + m21) / s;
            }
            else {
                T s = std::sqrt(T(1) + m22 - m00 - m11) * T(2);
                q.w = (m10 - m01) / s;
                q.x = (m02 + m20) / s;
                q.y = (m12 + m21) / s;
                q.z = T(0.25) * s;
            }

            q.Normalize();
            return q;
		}

        constexpr static Vector<T, 4, Aligment> QuanternionFromEuler(T roll, T pitch, T yaw) {
            T cr = std::cos(roll * 0.5);
            T sr = std::sin(roll * 0.5);
            T cp = std::cos(pitch * 0.5);
            T sp = std::sin(pitch * 0.5);
            T cy = std::cos(yaw * 0.5);
            T sy = std::sin(yaw * 0.5);

            return Vector<T, 4, Aligment>(
                sr * cp * cy - cr * sp * sy, 
                cr * sp * cy + sr * cp * sy, 
                cr * cp * sy - sr * sp * cy,
                cr * cp * cy + sr * sp * sy
            );
        }
	};
}


template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 2, Aligment>> : std::formatter<std::string> {
    auto format(const Crafter::Vector<T, 2, Aligment>& obj, format_context& ctx) const {
        return std::formatter<std::string>::format(std::format("{{{}, {}}}", 
			obj.x, obj.y
		), ctx);
    }
};

template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 3, Aligment>> : std::formatter<std::string> {
    auto format(const Crafter::Vector<T, 3, Aligment>& obj, format_context& ctx) const {
        return std::formatter<std::string>::format(std::format("{{{}, {}, {}}}", 
			obj.x, obj.y, obj.z
		), ctx);
    }
};

template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 4, Aligment>> : std::formatter<std::string> {
    auto format(const Crafter::Vector<T, 4, Aligment>& obj, format_context& ctx) const {
        return std::formatter<std::string>::format(std::format("{{{}, {}, {}, {}}}", 
			obj.x, obj.y, obj.z, obj.w
		), ctx);
    }
};


template <typename T, std::uint32_t Len, std::uint32_t Aligment, typename BT>
constexpr Crafter::Vector<T, Len, Aligment> operator*(BT b, const Crafter::Vector<T, Len, Aligment>& v) requires std::is_arithmetic_v<BT> {
    return v * b;
}