DistanceProxy.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_DISTANCEPROXY_HPP
#define PLAYRHO_COLLISION_DISTANCEPROXY_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Common/Range.hpp>
#include <vector>
#include <algorithm>
 
// Define IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS to implement the DistanceProxy class
// using buffers instead of pointers. Note that timing tests suggest implementing with
// buffers is significantly slower. Using buffers could make defining new shapes
// easier though so a buffering code alternative is kept in the source code for now.
// #define IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
 
namespace playrho {
namespace d2 {
 
    class Shape;
 
    class DistanceProxy
    {
    public:
        using ConstVertexPointer = const Length2*;
        
        using ConstVertexIterator = ConstVertexPointer;
        
        using ConstNormalPointer = const UnitVec*;
        
        using ConstNormalIterator = ConstNormalPointer;
 
        DistanceProxy() = default;
        
        DistanceProxy(const DistanceProxy& copy) noexcept:
#ifndef IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
            m_vertices{copy.m_vertices},
            m_normals{copy.m_normals},
#endif
            m_count{copy.m_count},
            m_vertexRadius{copy.m_vertexRadius}
        {
#ifdef IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
            const auto count = copy.m_count;
            std::copy(copy.m_vertices, copy.m_vertices + count, m_vertices);
            std::copy(copy.m_normals, copy.m_normals + count, m_normals);
#else
            // Intentionall empty.
#endif
       }
 
        DistanceProxy(const NonNegative<Length> vertexRadius, const VertexCounter count,
                      const Length2* vertices, const UnitVec* normals) noexcept:
#ifndef IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
            m_vertices{vertices},
            m_normals{normals},
#endif
            m_count{count},
            m_vertexRadius{vertexRadius}
        {
            assert(vertexRadius >= 0_m);
            assert(count >= 0);
            assert(count < 1 || vertices);
            assert(count < 2 || normals);
#ifdef IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
            if (vertices)
            {
                std::copy(vertices, vertices + count, m_vertices);
            }
            if (normals)
            {
                std::copy(normals, normals + count, m_normals);
            }
#endif
        }
        
        auto GetVertexRadius() const noexcept { return m_vertexRadius; }
        
        Range<ConstVertexIterator> GetVertices() const noexcept
        {
            return {m_vertices, m_vertices + m_count};
        }
        
        Range<ConstNormalIterator> GetNormals() const noexcept
        {
            return {m_normals, m_normals + m_count};
        }
 
        auto GetVertexCount() const noexcept { return m_count; }
        
        auto GetVertex(VertexCounter index) const noexcept
        {
            assert(index != InvalidVertex);
            assert(index < m_count);
            return *(m_vertices + index);
        }
        
        auto GetNormal(VertexCounter index) const noexcept
        {
            assert(index != InvalidVertex);
            assert(index < m_count);
            return *(m_normals + index);
        }
 
    private:
#ifdef IMPLEMENT_DISTANCEPROXY_WITH_BUFFERS
        Length2 m_vertices[MaxShapeVertices]; 
        UnitVec m_normals[MaxShapeVertices]; 
#else
        const Length2* m_vertices = nullptr; 
        const UnitVec* m_normals = nullptr; 
#endif
        VertexCounter m_count = 0; 
        NonNegative<Length> m_vertexRadius = 0_m; 
    };
    
    // Free functions...
    
    bool operator== (const DistanceProxy& lhs, const DistanceProxy& rhs) noexcept;
    
    inline bool operator!= (const DistanceProxy& lhs, const DistanceProxy& rhs) noexcept
    {
        return !(lhs == rhs);
    }
    
    inline NonNegative<Length> GetVertexRadius(const DistanceProxy& arg) noexcept
    {
        return arg.GetVertexRadius();
    }
    
    template <class T>
    inline VertexCounter GetSupportIndex(const DistanceProxy& proxy, T dir) noexcept
    {
        using VT = typename T::value_type;
        using OT = decltype(VT{} * 0_m);
 
        auto index = InvalidVertex; // Index of vertex that when dotted with dir has the max value.
        auto maxValue = -std::numeric_limits<OT>::infinity(); // Max dot value.
        auto i = VertexCounter{0};
        for (const auto& vertex: proxy.GetVertices())
        {
            const auto value = Dot(vertex, dir);
            if (maxValue < value)
            {
                maxValue = value;
                index = i;
            }
            ++i;
        }
        return index;
    }
 
    std::size_t FindLowestRightMostVertex(Span<const Length2> vertices);
    
    std::vector<Length2> GetConvexHullAsVector(Span<const Length2> vertices);
 
    bool TestPoint(const DistanceProxy& proxy, Length2 point) noexcept;
    
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_DISTANCEPROXY_HPP