Vector3.hpp

Go to the documentation of this file.

#ifndef PHYTH_VECTOR3_HPP
#define PHYTH_VECTOR3_HPP
 
#include "Phyth/Core/Quantity.hpp"
#include "Vector.hpp"
#include "QuantityFuncs.hpp"
 
#include <ostream>
 
namespace Phyth {
    template<typename T>
    using Vector3 = Vector<3, T>;
    template<typename T>
    struct Vector<3, T> {
        static_assert(is_quantity_v<T>, "Vector only supports Quantity types");
 
        T x;
        T y;
        T z;
 
        constexpr Vector() : x(0), y(0), z(0) {
        }
 
        constexpr Vector(T x_, T y_, T z_) : x(x_), y(y_), z(z_) {
        }
 
        static constexpr Vector FromPolar(T r, const Scalar theta_rad) {
            return Vector(
                r * Utils::cos(theta_rad),
                r * Utils::sin(theta_rad),
                T(0)
            );
        }
 
        static constexpr Vector FromSpherical(T r, const Scalar theta_rad, const Scalar phi_rad) {
            return Vector(
                r * Utils::sin(theta_rad) * Utils::cos(phi_rad),
                r * Utils::sin(theta_rad) * Utils::sin(phi_rad),
                r * Utils::cos(theta_rad)
            );
        }
 
        [[nodiscard]] auto ToPolar() const {
            Vector r = Length();
            auto theta = Utils::atan2(y / r, x / r);
            return std::pair<decltype(r), Scalar>{r, theta};
        }
 
        [[nodiscard]] auto ToSpherical() const {
            auto r = Length();
            auto theta = Utils::acos(z / r);
            auto phi = Utils::atan2(y / r, x / r);
            return std::tuple<decltype(r), Scalar, Scalar>{r, theta, phi};
        }
 
        constexpr T &operator[](const size_t i) {
            switch (i) {
                case 0: return x;
                case 1: return y;
                default: return z;
            }
        }
 
        constexpr const T &operator[](const size_t i) const {
            switch (i) {
                case 0: return x;
                case 1: return y;
                default: return z;
            }
        }
 
        template<typename U>
        constexpr auto operator+(const Vector3<U> &other) const {
            return Vector3<decltype(x + other.x)>(
                x + other.x,
                y + other.y,
                z + other.z
            );
        }
 
        template<typename U>
        constexpr auto operator-(const Vector3<U> &other) const {
            return Vector3<decltype(x - other.x)>(
                x - other.x,
                y - other.y,
                z - other.z
            );
        }
 
        constexpr auto operator-() const {
            return Vector(-x, -y, -z);
        }
 
        template<typename U, typename = std::enable_if_t<!std::is_same_v<std::decay_t<U>, Vector>> >
        constexpr auto operator*(U scalar) const {
            return Vector3<decltype(x * scalar)>(
                x * scalar,
                y * scalar,
                z * scalar
            );
        }
 
        template<typename U>
        constexpr auto operator/(U scalar) const {
            return Vector3<decltype(x / scalar)>(
                x / scalar,
                y / scalar,
                z / scalar
            );
        }
 
        template<typename U>
        constexpr Vector &operator+=(const Vector3<U> &other) {
            x += other.x;
            y += other.y;
            z += other.z;
            return *this;
        }
 
        template<typename U>
        constexpr Vector &operator-=(const Vector3<U> &other) {
            x -= other.x;
            y -= other.y;
            z -= other.z;
            return *this;
        }
 
        template<typename U>
        constexpr Vector &operator*=(U scalar) {
            x *= scalar;
            y *= scalar;
            z *= scalar;
            return *this;
        }
 
        template<typename U>
        constexpr Vector &operator/=(U scalar) {
            x /= scalar;
            y /= scalar;
            z /= scalar;
            return *this;
        }
 
        template<typename U>
        constexpr bool operator==(const Vector3<U> &other) const {
            return x == other.x && y == other.y && z == other.z;
        }
 
        template<typename U>
        constexpr bool operator!=(const Vector3<U> &other) const {
            return !(*this == other);
        }
 
        template<typename U>
        constexpr auto Dot(const Vector3<U> &other) const -> decltype(x * other.x) {
            return x * other.x + y * other.y + z * other.z;
        }
 
        template<typename U>
        constexpr auto Cross(const Vector3<U> &other) const {
            return Vector3<decltype(x * other.x)>(
                y * other.z - z * other.y,
                z * other.x - x * other.z,
                x * other.y - y * other.x
            );
        }
 
        [[nodiscard]] auto Length() const {
            return Utils::sqrt(x * x + y * y + z * z);
        }
 
        [[nodiscard]] auto LengthSquared() const {
            return x * x + y * y + z * z;
        }
 
        [[nodiscard]] Vector3<Scalar> Normalized() const {
            auto len = Length();
            return Vector3<decltype(x / len)>(
                x / len,
                y / len,
                z / len
            );
        }
 
        template<typename U>
        [[nodiscard]] auto Project(const Vector3<U> &other) const {
            return Dot(other) / other.LengthSquared() * other;
        }
 
        template<typename UnitT>
        [[nodiscard]] Vector3<Quantity<UnitT> > As() const {
            return {x.template As<UnitT>(), y.template As<UnitT>(), z.template As<UnitT>()};
        }
 
        friend std::ostream &operator<<(std::ostream &os, const Vector &v) {
            os << "(" << v.x << ", " << v.y << ", " << v.z << ")";
            return os;
        }
    };
 
    template<typename T>
    inline constexpr auto is_vector3_v = is_vector_of_n_v<3, T>;;
 
    template<typename T, typename U,
        typename = std::enable_if_t<!is_vector3_v<T>> >
    constexpr auto operator*(T scalar, const Vector3<U> &v) {
        return Vector3<decltype(scalar * v.x)>(
            scalar * v.x,
            scalar * v.y,
            scalar * v.z
        );
    }
}
 
#endif // PHYTH_VECTOR3_HPP