Vector3.hpp

Go to the documentation of this file.

// Copyright (c) 2023 Sapphire development team. All Rights Reserved.
 
#pragma once
 
#ifndef SAPPHIRE_MATHS_VECTOR3_GUARD
#define SAPPHIRE_MATHS_VECTOR3_GUARD
 
#include <cstdint>
 
#include <SA/Maths/Debug.hpp>
 
#include <SA/Maths/Angle/Degree.hpp>
#include <SA/Maths/Algorithms/Cos.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 Vec2;
 
    template <typename T>
    struct Vec4;
 
    template <typename T>
    struct Vec3
    {
        using Type = T;
 
        T x = T();
 
        T y = T();
 
        T z = T();
 
//{ Constants
 
        static const Vec3 Zero;
 
        static const Vec3 One;
 
        static const Vec3 Right;
 
        static const Vec3 Left;
 
        static const Vec3 Up;
 
        static const Vec3 Down;
 
        static const Vec3 Forward;
 
        static const Vec3 Backward;
 
//}
 
//{ Constructors
 
        Vec3() = default;
 
 
        constexpr Vec3(T _x, T _y, T _z) noexcept;
 
        constexpr Vec3(T _scale) noexcept;
 
 
        Vec3(Vec3&&) = default;
 
        Vec3(const Vec3&) = default;
 
        template <typename TIn>
        constexpr Vec3(const Vec3<TIn>& _other) noexcept;
 
        template <typename TIn>
        constexpr Vec3(const Vec2<TIn>& _other, T _z = T(0)) noexcept;
 
        template <typename TIn>
        constexpr Vec3(const Vec4<TIn>& _other) noexcept;
 
//}
 
//{ Equals
 
        constexpr bool IsZero() const noexcept;
 
        constexpr bool Equals(const Vec3& _other, T _epsilon = std::numeric_limits<T>::epsilon()) const noexcept;
 
 
        constexpr bool operator==(const Vec3 & _rhs) const noexcept;
 
        constexpr bool operator!=(const Vec3 & _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;
 
        Vec3& Normalize();
 
        Vec3 GetNormalized() const;
 
        constexpr bool IsNormalized() const noexcept;
 
//}
 
//{ Project
 
        Vec3 Reflect(const Vec3& _normal, float _elasticity = 1.0f) const noexcept;
 
        Vec3 ProjectOnTo(const Vec3& _other) const noexcept;
 
        Vec3 ProjectOnToNormal(const Vec3& _normal) const noexcept;
 
//}
 
//{ Dot/Cross
 
        static constexpr T Dot(const Vec3& _lhs, const Vec3& _rhs) noexcept;
 
        static constexpr Vec3<T> Cross(const Vec3& _lhs, const Vec3& _rhs) noexcept;
 
//}
 
//{ Angle
 
        static Deg<T> Angle(const Vec3& _start, const Vec3& _end, const Vec3& _normal = Vec3::Up) noexcept;
 
        static Deg<T> AngleUnsigned(const Vec3& _start, const Vec3& _end) noexcept;
 
//}
 
//{ Dist/Dir
 
        static constexpr T Dist(const Vec3& _start, const Vec3& _end);
 
        static constexpr T SqrDist(const Vec3& _start, const Vec3& _end) noexcept;
 
        static constexpr Vec3 Dir(const Vec3& _start, const Vec3& _end) noexcept;
 
        static constexpr Vec3 DirN(const Vec3& _start, const Vec3& _end);
 
//}
 
//{ Lerp
 
        static Vec3 Lerp(const Vec3& _start, const Vec3& _end, float _alpha) noexcept;
 
        static Vec3 LerpUnclamped(const Vec3& _start, const Vec3& _end, float _alpha) noexcept;
 
        static Vec3 SLerp(const Vec3& _start, const Vec3& _end, float _alpha) noexcept;
 
        static Vec3 SLerpUnclamped(const Vec3& _start, const Vec3& _end, float _alpha) noexcept;
 
//}
 
//{ Operators
 
        Vec3& operator=(Vec3&&) = default;
 
        Vec3& operator=(const Vec3&) = default;
 
 
        constexpr Vec3 operator-() const noexcept;
 
        Vec3 operator*(T _scale) const noexcept;
 
        Vec3 operator/(T _scale) const;
 
        constexpr Vec3 operator+(const Vec3& _rhs) const noexcept;
 
        constexpr Vec3 operator-(const Vec3& _rhs) const noexcept;
 
        constexpr Vec3 operator*(const Vec3& _rhs) const noexcept;
 
        Vec3 operator/(const Vec3& _rhs) const;
 
        constexpr T operator|(const Vec3& _rhs) const noexcept;
 
        constexpr Vec3 operator^(const Vec3& _rhs) const noexcept;
 
 
        Vec3& operator*=(T _scale) noexcept;
 
        Vec3& operator/=(T _scale);
 
        Vec3& operator+=(const Vec3& _rhs) noexcept;
 
        Vec3& operator-=(const Vec3& _rhs) noexcept;
 
        Vec3 operator*=(const Vec3& _rhs) noexcept;
 
        Vec3 operator/=(const Vec3& _rhs);
 
//}
    };
 
 
    template <typename T>
    constexpr Vec3<T> operator*(typename std::remove_cv<T>::type _lhs, const Vec3<T>& _rhs) noexcept;
 
    template <typename T>
    Vec3<T> operator/(typename std::remove_cv<T>::type _lhs, const Vec3<T>& _rhs);
 
 
#if SA_LOGGER_IMPL
 
    template <typename T>
    std::string ToString(const Vec3<T>& _v);
 
#endif
 
 
//{ Aliases
 
    using Vec3i = Vec3<int32_t>;
 
    using Vec3ui = Vec3<uint32_t>;
 
    using Vec3f = Vec3<float>;
 
    using Vec3d = Vec3<double>;
 
 
    template <typename T>
    using Vector3 = Vec3<T>;
 
    using Vector3i = Vector3<int32_t>;
 
    using Vector3ui = Vector3<uint32_t>;
 
    using Vector3f = Vector3<float>;
 
    using Vector3d = Vector3<double>;
 
//}
}
 
#include <SA/Maths/Space/Vector3.inl>
 
#endif // GUARD