Vector2.hpp

Go to the documentation of this file.

// Copyright (c) 2023 Sapphire Development Team. All Rights Reserved.
 
#pragma once
 
#ifndef SAPPHIRE_MATHS_VECTOR2_GUARD
#define SAPPHIRE_MATHS_VECTOR2_GUARD
 
#include <cstdint>
 
#include <SA/Maths/Debug.hpp>
 
#include <SA/Maths/Angle/Degree.hpp>
#include <SA/Maths/Algorithms/Cos.hpp>
#include <SA/Maths/Algorithms/Tan.hpp>
#include <SA/Maths/Algorithms/Sqrt.hpp>
#include <SA/Maths/Algorithms/Lerp.hpp>
#include <SA/Maths/Algorithms/Equals.hpp>
 
namespace SA
{
    template <typename T>
    struct Vec3;
 
    template <typename T>
    struct Vec2
    {
        using Type = T;
 
 
        T x = T();
 
        T y = T();
 
//{ Constants
 
        static const Vec2 Zero;
 
        static const Vec2 One;
 
        static const Vec2 Right;
 
        static const Vec2 Left;
 
        static const Vec2 Up;
 
        static const Vec2 Down;
 
//}
 
//{ Constructors
 
        Vec2() = default;
 
 
        constexpr Vec2(T _x, T _y) noexcept;
 
        constexpr Vec2(T _scale) noexcept;
 
 
        Vec2(Vec2&&) = default;
 
        Vec2(const Vec2&) = default;
 
        template <typename TIn>
        constexpr Vec2(const Vec2<TIn>& _other) noexcept;
 
        template <typename TIn>
        constexpr Vec2(const Vec3<TIn>& _other) noexcept;
 
//}
 
//{ Equals
 
        constexpr bool IsZero() const noexcept;
 
        constexpr bool Equals(const Vec2& _other, T _epsilon = std::numeric_limits<T>::epsilon()) const noexcept;
 
 
        constexpr bool operator==(const Vec2 & _rhs) const noexcept;
 
        constexpr bool operator!=(const Vec2 & _rhs) const noexcept;
 
//}
 
//{ Accessors
 
        T* Data() noexcept;
 
        const T* Data() const noexcept;
 
 
        T& operator[](uint32_t _index);
 
        const T& operator[](uint32_t _index) const;
 
//}
 
//{ Length
 
        constexpr T Length() const;
 
        constexpr T SqrLength() const noexcept;
 
 
        Vec2& Normalize();
 
        Vec2 GetNormalized() const;
 
        constexpr bool IsNormalized() const noexcept;
 
//}
 
//{ Project
 
        Vec2 Reflect(const Vec2& _normal, float _elasticity = 1.0f) const noexcept;
 
        Vec2 ProjectOnTo(const Vec2& _other) const noexcept;
 
        Vec2 ProjectOnToNormal(const Vec2& _normal) const noexcept;
 
        Vec2 Perpendicular() const noexcept;
 
//}
 
//{ Dot/Cross
 
        static constexpr T Dot(const Vec2& _lhs, const Vec2& _rhs) noexcept;
 
        static constexpr T Cross(const Vec2& _lhs, const Vec2& _rhs) noexcept;
 
//}
 
//{ Angle
 
        static Deg<T> Angle(const Vec2& _start, const Vec2& _end) noexcept;
 
        static Deg<T> AngleUnsigned(const Vec2& _start, const Vec2& _end) noexcept;
 
//}
 
//{ Dist/Dir
 
        static constexpr T Dist(const Vec2& _start, const Vec2& _end);
 
        static constexpr T SqrDist(const Vec2& _start, const Vec2& _end) noexcept;
 
        static constexpr Vec2 Dir(const Vec2& _start, const Vec2& _end) noexcept;
 
        static constexpr Vec2 DirN(const Vec2& _start, const Vec2& _end);
 
//}
 
//{ Lerp
        static Vec2 Lerp(const Vec2& _start, const Vec2& _end, float _alpha) noexcept;
 
        static Vec2 LerpUnclamped(const Vec2& _start, const Vec2& _end, float _alpha) noexcept;
 
        static Vec2 SLerp(const Vec2& _start, const Vec2& _end, float _alpha) noexcept;
 
        static Vec2 SLerpUnclamped(const Vec2& _start, const Vec2& _end, float _alpha) noexcept;
 
//}
 
//{ Operators
 
        Vec2& operator=(Vec2&&) = default;
 
        Vec2& operator=(const Vec2&) = default;
 
 
        constexpr Vec2 operator-() const noexcept;
 
        constexpr Vec2 operator*(T _scale) const noexcept;
 
        Vec2 operator/(T _scale) const;
 
        constexpr Vec2 operator+(const Vec2& _rhs) const noexcept;
 
        constexpr Vec2 operator-(const Vec2& _rhs) const noexcept;
 
        constexpr Vec2 operator*(const Vec2& _rhs) const noexcept;
 
        Vec2 operator/(const Vec2& _rhs) const;
 
        constexpr T operator|(const Vec2& _rhs) const noexcept;
 
        constexpr T operator^(const Vec2& _rhs) const noexcept;
 
 
        Vec2& operator*=(T _scale) noexcept;
 
        Vec2& operator/=(T _scale);
 
        Vec2& operator+=(const Vec2& _rhs) noexcept;
 
        Vec2& operator-=(const Vec2& _rhs) noexcept;
 
        Vec2 operator*=(const Vec2& _rhs) noexcept;
 
        Vec2 operator/=(const Vec2& _rhs);
 
//}
    };
 
 
    template <typename T>
    constexpr Vec2<T> operator*(typename std::remove_cv<T>::type _lhs, const Vec2<T>& _rhs) noexcept;
 
    template <typename T>
    Vec2<T> operator/(typename std::remove_cv<T>::type _lhs, const Vec2<T>& _rhs);
 
 
#if SA_LOGGER_IMPL
 
    template <typename T>
    std::string ToString(const Vec2<T>& _v);
 
#endif
 
 
//{ Aliases
 
    using Vec2i = Vec2<int32_t>;
 
    using Vec2ui = Vec2<uint32_t>;
 
    using Vec2f = Vec2<float>;
 
    using Vec2d = Vec2<double>;
 
 
    template <typename T>
    using Vector2 = Vec2<T>;
 
    using Vector2i = Vector2<int32_t>;
 
    using Vector2ui = Vector2<uint32_t>;
 
    using Vector2f = Vector2<float>;
 
    using Vector2d = Vector2<double>;
 
//}
}
 
#include <SA/Maths/Space/Vector2.inl>
 
#endif // GUARD