AVector3.hpp

#pragma once
 
#include <atomic>
#include <cmath>
#include <iostream>
 
namespace PixelBullet
{
    template <typename T>
    class AVector3
    {
    public:
        AVector3() noexcept
            : m_X(0)
            , m_Y(0)
            , m_Z(0)
        {
        }
 
        AVector3(T x, T y, T z) noexcept
            : m_X(x)
            , m_Y(y)
            , m_Z(z)
        {
        }
 
        AVector3(const AVector3& other) noexcept
            : m_X(other.m_X.load(std::memory_order_relaxed))
            , m_Y(other.m_Y.load(std::memory_order_relaxed))
            , m_Z(other.m_Z.load(std::memory_order_relaxed))
        {
        }
 
        AVector3(AVector3&& other) noexcept
            : m_X(other.m_X.load(std::memory_order_relaxed))
            , m_Y(other.m_Y.load(std::memory_order_relaxed))
            , m_Z(other.m_Z.load(std::memory_order_relaxed))
        {
            other.m_X.store(0, std::memory_order_relaxed);
            other.m_Y.store(0, std::memory_order_relaxed);
            other.m_Z.store(0, std::memory_order_relaxed);
        }
 
        AVector3& operator=(const AVector3& other) noexcept
        {
            if (this != &other)
            {
                m_X.store(other.m_X.load(std::memory_order_relaxed), std::memory_order_relaxed);
                m_Y.store(other.m_Y.load(std::memory_order_relaxed), std::memory_order_relaxed);
                m_Z.store(other.m_Z.load(std::memory_order_relaxed), std::memory_order_relaxed);
            }
            return *this;
        }
 
        AVector3& operator=(AVector3&& other) noexcept
        {
            if (this != &other)
            {
                m_X.store(other.m_X.load(std::memory_order_relaxed), std::memory_order_relaxed);
                m_Y.store(other.m_Y.load(std::memory_order_relaxed), std::memory_order_relaxed);
                m_Z.store(other.m_Z.load(std::memory_order_relaxed), std::memory_order_relaxed);
                other.m_X.store(0, std::memory_order_relaxed);
                other.m_Y.store(0, std::memory_order_relaxed);
                other.m_Z.store(0, std::memory_order_relaxed);
            }
            return *this;
        }
 
        AVector3 operator+(const AVector3& other) const noexcept
        {
            return AVector3(GetX() + other.GetX(), GetY() + other.GetY(), GetZ() + other.GetZ());
        }
 
        AVector3& operator+=(const AVector3& other) noexcept
        {
            SetX(GetX() + other.GetX());
            SetY(GetY() + other.GetY());
            SetZ(GetZ() + other.GetZ());
            return *this;
        }
 
        AVector3 operator-(const AVector3& other) const noexcept
        {
            return AVector3(GetX() - other.GetX(), GetY() - other.GetY(), GetZ() - other.GetZ());
        }
 
        AVector3& operator-=(const AVector3& other) noexcept
        {
            SetX(GetX() - other.GetX());
            SetY(GetY() - other.GetY());
            SetZ(GetZ() - other.GetZ());
            return *this;
        }
 
        AVector3 operator-() const noexcept
        {
            return AVector3(-GetX(), -GetY(), -GetZ());
        }
 
        AVector3 operator*(T scalar) const noexcept
        {
            return AVector3(GetX() * scalar, GetY() * scalar, GetZ() * scalar);
        }
 
        AVector3& operator*=(T scalar) noexcept
        {
            SetX(GetX() * scalar);
            SetY(GetY() * scalar);
            SetZ(GetZ() * scalar);
            return *this;
        }
 
        AVector3 operator/(T scalar) const noexcept
        {
            return AVector3(GetX() / scalar, GetY() / scalar, GetZ() / scalar);
        }
 
        AVector3& operator/=(T scalar) noexcept
        {
            SetX(GetX() / scalar);
            SetY(GetY() / scalar);
            SetZ(GetZ() / scalar);
            return *this;
        }
 
        bool operator==(const AVector3& other) const noexcept
        {
            return GetX() == other.GetX() && GetY() == other.GetY() && GetZ() == other.GetZ();
        }
        bool operator!=(const AVector3& other) const noexcept
        {
            return !(*this == other);
        }
 
        T GetX() const noexcept
        {
            return m_X.load(std::memory_order_relaxed);
        }
        T GetY() const noexcept
        {
            return m_Y.load(std::memory_order_relaxed);
        }
        T GetZ() const noexcept
        {
            return m_Z.load(std::memory_order_relaxed);
        }
 
        void SetX(T x) noexcept
        {
            m_X.store(x, std::memory_order_relaxed);
        }
        void SetY(T y) noexcept
        {
            m_Y.store(y, std::memory_order_relaxed);
        }
        void SetZ(T z) noexcept
        {
            m_Z.store(z, std::memory_order_relaxed);
        }
 
 
        T Dot(const AVector3& other) const noexcept
        {
            return GetX() * other.GetX() + GetY() * other.GetY() + GetZ() * other.GetZ();
        }
 
        AVector3 Cross(const AVector3& other) const noexcept
        {
            return AVector3(GetY() * other.GetZ() - GetZ() * other.GetY(),
                            GetZ() * other.GetX() - GetX() * other.GetZ(),
                            GetX() * other.GetY() - GetY() * other.GetX());
        }
 
        T Length() const noexcept
        {
            return static_cast<T>(std::sqrt(GetX() * GetX() + GetY() * GetY() + GetZ() * GetZ()));
        }
 
        AVector3 Normalized() const noexcept
        {
            T len = Length();
            if (len != 0)
            {
                return *this / len;
            }
            return AVector3(); 
        }
 
    private:
        std::atomic<T> m_X;
        std::atomic<T> m_Y;
        std::atomic<T> m_Z;
    };
 
    template <typename T>
    AVector3<T> operator*(T scalar, const AVector3<T>& vec) noexcept
    {
        return vec * scalar;
    }
 
    template <typename T>
    std::ostream& operator<<(std::ostream& os, const AVector3<T>& vec)
    {
        os << "(" << vec.GetX() << ", " << vec.GetY() << ", " << vec.GetZ() << ")";
        return os;
    }
} // namespace PixelBullet