UnitVec.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_UNITVEC2_HPP
#define PLAYRHO_COMMON_UNITVEC2_HPP
 
 
#include <PlayRho/Common/Settings.hpp>
#include <PlayRho/Common/Units.hpp>
#include <PlayRho/Common/InvalidArgument.hpp>
 
#include <cstdlib>
#include <iostream>
#include <utility>
#include <type_traits>
 
namespace playrho {
 
// Explicitly import needed functions into this namespace to avoid including the math
//  header which itself expects UnitVec to already be defined.
using std::isnormal;
using std::sqrt;
using std::hypot;
using std::abs;
 
namespace d2 {
 
class UnitVec
{
public:
    using value_type = Real;
    
    using size_type = std::size_t;
    
    using const_reference = const value_type&;
    
    using const_pointer = const value_type*;
    
    using const_iterator = const value_type*;
    
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    
    static PLAYRHO_CONSTEXPR inline UnitVec GetRight() noexcept { return UnitVec{1, 0}; }
 
    static PLAYRHO_CONSTEXPR inline UnitVec GetTop() noexcept { return UnitVec{0, 1}; }
 
    static PLAYRHO_CONSTEXPR inline UnitVec GetLeft() noexcept { return UnitVec{-1, 0}; }
 
    static PLAYRHO_CONSTEXPR inline UnitVec GetBottom() noexcept { return UnitVec{0, -1}; }
 
    static PLAYRHO_CONSTEXPR inline UnitVec GetZero() noexcept { return UnitVec{0, 0}; }
 
    static PLAYRHO_CONSTEXPR inline UnitVec GetTopRight() noexcept
    {
        // Note that 1/sqrt(2) == sqrt(2)/(sqrt(2)*sqrt(2)) == sqrt(2)/2
        return UnitVec{+SquareRootTwo/Real(2), +SquareRootTwo/Real(2)};
    }
    
    static PLAYRHO_CONSTEXPR inline UnitVec GetBottomRight() noexcept
    {
        // Note that 1/sqrt(2) == sqrt(2)/(sqrt(2)*sqrt(2)) == sqrt(2)/2
        return UnitVec{+SquareRootTwo/Real(2), -SquareRootTwo/Real(2)};
    }
    
    static PLAYRHO_CONSTEXPR inline UnitVec GetDefaultFallback() noexcept { return UnitVec{}; }
 
    template <typename T>
    using PolarCoord = std::enable_if_t<IsArithmetic<T>::value, std::pair<UnitVec, T>>;
 
    template <typename T>
    static PolarCoord<T> Get(const T x, const T y,
                             const UnitVec fallback = GetDefaultFallback()) noexcept
    {
        // Try the faster way first...
        const auto magnitudeSquared = x * x + y * y;
        if (isnormal(magnitudeSquared))
        {
            const auto magnitude = sqrt(magnitudeSquared);
            assert(isnormal(magnitude));
            const auto invMagnitude = Real{1} / magnitude;
            return {UnitVec{value_type{x * invMagnitude}, value_type{y * invMagnitude}}, magnitude};
        }
        
        // Failed the faster way, try the more accurate and robust way...
        const auto magnitude = hypot(x, y);
        if (isnormal(magnitude))
        {
            return std::make_pair(UnitVec{x / magnitude, y / magnitude}, magnitude);
        }
        
        // Give up and return the fallback value.
        return std::make_pair(fallback, T{0});
    }
 
    static UnitVec Get(const Angle angle) noexcept;
 
    PLAYRHO_CONSTEXPR inline UnitVec() noexcept = default;
    
    PLAYRHO_CONSTEXPR inline size_type max_size() const noexcept { return size_type{2}; }
    
    PLAYRHO_CONSTEXPR inline size_type size() const noexcept { return size_type{2}; }
    
    PLAYRHO_CONSTEXPR inline bool empty() const noexcept { return false; }
    
    const_iterator begin() const noexcept { return const_iterator(m_elems); }
    
    const_iterator end() const noexcept { return const_iterator(m_elems + 2); }
    
    const_iterator cbegin() const noexcept { return begin(); }
    
    const_iterator cend() const noexcept { return end(); }
    
    const_reverse_iterator crbegin() const noexcept
    {
        return const_reverse_iterator{m_elems + 2};
    }
    
    const_reverse_iterator crend() const noexcept
    {
        return const_reverse_iterator{m_elems};
    }
    
    const_reverse_iterator rbegin() const noexcept
    {
        return crbegin();
    }
    
    const_reverse_iterator rend() const noexcept
    {
        return crend();
    }
    
    PLAYRHO_CONSTEXPR inline const_reference operator[](size_type pos) const noexcept
    {
        assert(pos < size());
        return m_elems[pos];
    }
    
    PLAYRHO_CONSTEXPR inline const_reference at(size_type pos) const
    {
        if (pos >= size())
        {
            throw InvalidArgument("Vector::at: position >= size()");
        }
        return m_elems[pos];
    }
    
    PLAYRHO_CONSTEXPR inline const_pointer data() const noexcept
    {
        return m_elems;
    }
    
    PLAYRHO_CONSTEXPR inline auto GetX() const noexcept { return m_elems[0]; }
 
    PLAYRHO_CONSTEXPR inline auto GetY() const noexcept { return m_elems[1]; }
    
    PLAYRHO_CONSTEXPR inline UnitVec FlipXY() const noexcept { return UnitVec{-GetX(), -GetY()}; }
 
    PLAYRHO_CONSTEXPR inline UnitVec FlipX() const noexcept { return UnitVec{-GetX(), GetY()}; }
 
    PLAYRHO_CONSTEXPR inline UnitVec FlipY() const noexcept { return UnitVec{GetX(), -GetY()}; }
 
    PLAYRHO_CONSTEXPR inline UnitVec Rotate(UnitVec amount) const noexcept
    {
        return UnitVec{GetX() * amount.GetX() - GetY() * amount.GetY(),
                        GetY() * amount.GetX() + GetX() * amount.GetY()};
    }
 
    PLAYRHO_CONSTEXPR inline UnitVec GetRevPerpendicular() const noexcept
    {
        // See http://mathworld.wolfram.com/PerpendicularVector.html
        return UnitVec{-GetY(), GetX()};
    }
 
    PLAYRHO_CONSTEXPR inline UnitVec GetFwdPerpendicular() const noexcept
    {
        // See http://mathworld.wolfram.com/PerpendicularVector.html
        return UnitVec{GetY(), -GetX()};
    }
 
    PLAYRHO_CONSTEXPR inline UnitVec operator-() const noexcept { return UnitVec{-GetX(), -GetY()}; }
 
    PLAYRHO_CONSTEXPR inline UnitVec operator+() const noexcept { return UnitVec{+GetX(), +GetY()}; }
 
    PLAYRHO_CONSTEXPR inline UnitVec Absolute() const noexcept
    {
        return UnitVec{abs(GetX()), abs(GetY())};
    }
 
private:
    
    PLAYRHO_CONSTEXPR inline UnitVec(value_type x, value_type y) noexcept : m_elems{x, y}
    {
        // Intentionally empty.
    }
 
    value_type m_elems[2] = { value_type{0}, value_type{0} }; 
};
 
// Free functions...
 
PLAYRHO_CONSTEXPR inline UnitVec GetXAxis(UnitVec rot) noexcept { return rot; }
 
PLAYRHO_CONSTEXPR inline UnitVec GetYAxis(UnitVec rot) noexcept { return rot.GetRevPerpendicular(); }
 
PLAYRHO_CONSTEXPR inline bool operator==(const UnitVec a, const UnitVec b) noexcept
{
    return (a.GetX() == b.GetX()) && (a.GetY() == b.GetY());
}
 
PLAYRHO_CONSTEXPR inline bool operator!=(const UnitVec a, const UnitVec b) noexcept
{
    return (a.GetX() != b.GetX()) || (a.GetY() != b.GetY());
}
 
PLAYRHO_CONSTEXPR inline UnitVec GetRevPerpendicular(const UnitVec vector) noexcept
{
    return vector.GetRevPerpendicular();
}
 
PLAYRHO_CONSTEXPR inline UnitVec GetFwdPerpendicular(const UnitVec vector) noexcept
{
    return vector.GetFwdPerpendicular();
}
 
PLAYRHO_CONSTEXPR inline UnitVec Rotate(const UnitVec vector, const UnitVec& angle) noexcept
{
    return vector.Rotate(angle);
}
 
PLAYRHO_CONSTEXPR inline UnitVec InverseRotate(const UnitVec vector, const UnitVec& angle) noexcept
{
    return vector.Rotate(angle.FlipY());
}
 
template <std::size_t I>
PLAYRHO_CONSTEXPR inline UnitVec::value_type get(UnitVec v) noexcept
{
    static_assert(I < 2, "Index out of bounds in playrho::get<> (playrho::UnitVec)");
    switch (I)
    {
        case 0: return v.GetX();
        case 1: return v.GetY();
    }
}
 
template <>
PLAYRHO_CONSTEXPR inline UnitVec::value_type get<0>(UnitVec v) noexcept
{
    return v.GetX();
}
 
template <>
PLAYRHO_CONSTEXPR inline UnitVec::value_type get<1>(UnitVec v) noexcept
{
    return v.GetY();
}
 
inline ::std::ostream& operator<<(::std::ostream& os, const UnitVec& value)
{
    return os << "UnitVec(" << get<0>(value) << "," << get<1>(value) << ")";
}
 
} // namespace d2
 
template <> PLAYRHO_CONSTEXPR inline d2::UnitVec GetInvalid() noexcept { return d2::UnitVec{}; }
 
template <> PLAYRHO_CONSTEXPR inline bool IsValid(const d2::UnitVec& value) noexcept
{
    return IsValid(value.GetX()) && IsValid(value.GetY()) && (value != d2::UnitVec::GetZero());
}
 
} // namespace playrho
 
namespace std {
 
template<>
class tuple_size< playrho::d2::UnitVec >: public std::integral_constant<std::size_t, 2> {};
 
template<std::size_t I>
class tuple_element<I, playrho::d2::UnitVec>
{
public:
    using type = playrho::Real;
};
 
} // namespace std
 
#endif // PLAYRHO_COMMON_UNITVEC2_HPP