AABB.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
 * Modified work 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_COLLISION_AABB_HPP
#define PLAYRHO_COLLISION_AABB_HPP
 
 
#include <PlayRho/Common/Intervals.hpp>
#include <PlayRho/Common/Vector2.hpp>
#include <PlayRho/Common/Templates.hpp>
#include <array>
#include <algorithm>
#include <functional>
 
namespace playrho {
 
namespace detail {
 
template <std::size_t N> struct RayCastInput;
 
template <std::size_t N>
struct AABB
{
    using Location = Vector<Length, N>;
 
    PLAYRHO_CONSTEXPR inline AABB() = default;
    
    template<typename... Tail>
    PLAYRHO_CONSTEXPR inline AABB(std::enable_if_t<sizeof...(Tail)+1 == N, LengthInterval> head,
                                  Tail... tail) noexcept:
        ranges{head, LengthInterval(tail)...}
    {
        // Intentionally empty.
    }
 
    PLAYRHO_CONSTEXPR inline explicit AABB(const Location p) noexcept
    {
        for (auto i = decltype(N){0}; i < N; ++i)
        {
            ranges[i] = LengthInterval{p[i]};
        }
    }
 
    PLAYRHO_CONSTEXPR inline AABB(const Location a, const Location b) noexcept
    {
        for (auto i = decltype(N){0}; i < N; ++i)
        {
            ranges[i] = LengthInterval{a[i], b[i]};
        }
    }
 
    LengthInterval ranges[N];
};
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline bool operator== (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        if (lhs.ranges[i] != rhs.ranges[i])
        {
            return false;
        }
    }
    return true;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline bool operator!= (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
template <std::size_t N>
inline bool operator< (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    return std::lexicographical_compare(cbegin(lhs.ranges), cend(lhs.ranges),
                                        cbegin(rhs.ranges), cend(rhs.ranges),
                                        std::less<LengthInterval>{});
}
 
template <std::size_t N>
inline bool operator<= (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    const auto lhsEnd = cend(lhs.ranges);
    const auto rhsEnd = cend(rhs.ranges);
    const auto diff = std::mismatch(cbegin(lhs.ranges), lhsEnd,
                                    cbegin(rhs.ranges), rhsEnd);
    return (std::get<0>(diff) == lhsEnd) || (*std::get<0>(diff) < *std::get<1>(diff));
}
 
template <std::size_t N>
inline bool operator> (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    return std::lexicographical_compare(cbegin(lhs.ranges), cend(lhs.ranges),
                                        cbegin(rhs.ranges), cend(rhs.ranges),
                                        std::greater<LengthInterval>{});
}
 
template <std::size_t N>
inline bool operator>= (const AABB<N>& lhs, const AABB<N>& rhs) noexcept
{
    const auto lhsEnd = cend(lhs.ranges);
    const auto rhsEnd = cend(rhs.ranges);
    const auto diff = std::mismatch(cbegin(lhs.ranges), lhsEnd,
                                    cbegin(rhs.ranges), rhsEnd);
    return (std::get<0>(diff) == lhsEnd) || (*std::get<0>(diff) > *std::get<1>(diff));
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline bool TestOverlap(const AABB<N>& a, const AABB<N>& b) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        if (!IsIntersecting(a.ranges[i], b.ranges[i]))
        {
            return false;
        }
    }
    return true;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N> GetIntersectingAABB(const AABB<N>& a, const AABB<N>& b) noexcept
{
    auto result = AABB<N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result.ranges[i] = GetIntersection(a.ranges[i], b.ranges[i]);
    }
    return result;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline Vector<Length, N> GetCenter(const AABB<N>& aabb) noexcept
{
    auto result = Vector<Length, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = GetCenter(aabb.ranges[i]);
    }
    return result;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline Vector<Length, N> GetDimensions(const AABB<N>& aabb) noexcept
{
    auto result = Vector<Length, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = GetSize(aabb.ranges[i]);
    }
    return result;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline Vector<Length, N> GetExtents(const AABB<N>& aabb) noexcept
{
    PLAYRHO_CONSTEXPR const auto RealInverseOfTwo = Real{1} / Real{2};
    return GetDimensions(aabb) * RealInverseOfTwo;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline bool Contains(const AABB<N>& a, const AABB<N>& b) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        if (!IsEntirelyEnclosing(a.ranges[i], b.ranges[i]))
        {
            return false;
        }
    }
    return true;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N>& Include(AABB<N>& var, const Vector<Length, N>& value) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        var.ranges[i].Include(value[i]);
    }
    return var;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N>& Include(AABB<N>& var, const AABB<N>& val) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        var.ranges[i].Include(val.ranges[i]);
    }
    return var;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N>& Move(AABB<N>& var, const Vector<Length, N> value) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        var.ranges[i].Move(value[i]);
    }
    return var;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N>& Fatten(AABB<N>& var, const NonNegative<Length> amount) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        var.ranges[i].ExpandEqually(amount);
    }
    return var;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N> GetDisplacedAABB(AABB<N> aabb, const Vector<Length, N> displacement)
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        aabb.ranges[i].Expand(displacement[i]);
    }
    return aabb;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N> GetFattenedAABB(AABB<N> aabb, const Length amount)
{
    return Fatten(aabb, amount);
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N> GetMovedAABB(AABB<N> aabb, const Vector<Length, N> value) noexcept
{
    return Move(aabb, value);
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline AABB<N> GetEnclosingAABB(AABB<N> a, const AABB<N>& b)
{
    return Include(a, b);
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline Vector<Length, N> GetLowerBound(const AABB<N>& aabb) noexcept
{
    auto result = Vector<Length, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = aabb.ranges[i].GetMin();
    }
    return result;
}
 
template <std::size_t N>
PLAYRHO_CONSTEXPR inline Vector<Length, N> GetUpperBound(const AABB<N>& aabb) noexcept
{
    auto result = Vector<Length, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = aabb.ranges[i].GetMax();
    }
    return result;
}
 
template <std::size_t N>
inline ::std::ostream& operator<< (::std::ostream& os, const AABB<N>& value)
{
    os << "{";
    auto multiple = false;
    for (const auto& range: value.ranges)
    {
        if (multiple)
        {
            os << ',';
        }
        else
        {
            multiple = true;
        }
        os << range;
    }
    os << "}";
    return os;
}
 
} // namespace detail
 
namespace d2 {
 
class Shape;
class Fixture;
class Body;
class Contact;
class DistanceProxy;
struct Transformation;
 
using detail::TestOverlap;
using detail::Contains;
 
using AABB = detail::AABB<2>;
 
PLAYRHO_CONSTEXPR inline Length GetPerimeter(const AABB& aabb) noexcept
{
    return (GetSize(aabb.ranges[0]) + GetSize(aabb.ranges[1])) * 2;
}
 
AABB ComputeAABB(const DistanceProxy& proxy, const Transformation& xf) noexcept;
 
AABB ComputeAABB(const DistanceProxy& proxy,
                 const Transformation& xfm0, const Transformation& xfm1) noexcept;
 
AABB ComputeAABB(const Shape& shape, const Transformation& xf) noexcept;
 
AABB ComputeAABB(const Fixture& fixture) noexcept;
 
AABB ComputeAABB(const Body& body);
 
AABB ComputeIntersectingAABB(const Fixture& fA, ChildCounter iA,
                             const Fixture& fB, ChildCounter iB) noexcept;
 
AABB ComputeIntersectingAABB(const Contact& contact);
    
AABB GetAABB(const playrho::detail::RayCastInput<2>& input) noexcept;
 
} // namespace d2
 
template <>
PLAYRHO_CONSTEXPR inline d2::AABB GetInvalid() noexcept
{
    return d2::AABB{LengthInterval{GetInvalid<Length>()}, LengthInterval{GetInvalid<Length>()}};
}
 
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_AABB_HPP