b2_distance.h

// MIT License
 
// Copyright (c) 2019 Erin Catto
 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#ifndef B2_DISTANCE_H
#define B2_DISTANCE_H
 
#include "b2_api.h"
#include "b2_math.h"
 
class b2Shape;
 
struct B2_API b2DistanceProxy
{
    b2DistanceProxy() : m_vertices(nullptr), m_count(0), m_radius(0.0f) {}
 
    void Set(const b2Shape* shape, int32 index);
 
    void Set(const b2Vec2* vertices, int32 count, float radius);
 
    int32 GetSupport(const b2Vec2& d) const;
 
    const b2Vec2& GetSupportVertex(const b2Vec2& d) const;
 
    int32 GetVertexCount() const;
 
    const b2Vec2& GetVertex(int32 index) const;
 
    b2Vec2 m_buffer[2];
    const b2Vec2* m_vertices;
    int32 m_count;
    float m_radius;
};
 
struct B2_API b2SimplexCache
{
    float metric;       
    uint16 count;
    uint8 indexA[3];    
    uint8 indexB[3];    
};
 
struct B2_API b2DistanceInput
{
    b2DistanceProxy proxyA;
    b2DistanceProxy proxyB;
    b2Transform transformA;
    b2Transform transformB;
    bool useRadii;
};
 
struct B2_API b2DistanceOutput
{
    b2Vec2 pointA;      
    b2Vec2 pointB;      
    float distance;
    int32 iterations;   
};
 
B2_API void b2Distance(b2DistanceOutput* output,
                b2SimplexCache* cache,
                const b2DistanceInput* input);
 
struct B2_API b2ShapeCastInput
{
    b2DistanceProxy proxyA;
    b2DistanceProxy proxyB;
    b2Transform transformA;
    b2Transform transformB;
    b2Vec2 translationB;
};
 
struct B2_API b2ShapeCastOutput
{
    b2Vec2 point;
    b2Vec2 normal;
    float lambda;
    int32 iterations;
};
 
B2_API bool b2ShapeCast(b2ShapeCastOutput* output, const b2ShapeCastInput* input);
 
 
inline int32 b2DistanceProxy::GetVertexCount() const
{
    return m_count;
}
 
inline const b2Vec2& b2DistanceProxy::GetVertex(int32 index) const
{
    b2Assert(0 <= index && index < m_count);
    return m_vertices[index];
}
 
inline int32 b2DistanceProxy::GetSupport(const b2Vec2& d) const
{
    int32 bestIndex = 0;
    float bestValue = b2Dot(m_vertices[0], d);
    for (int32 i = 1; i < m_count; ++i)
    {
        float value = b2Dot(m_vertices[i], d);
        if (value > bestValue)
        {
            bestIndex = i;
            bestValue = value;
        }
    }
 
    return bestIndex;
}
 
inline const b2Vec2& b2DistanceProxy::GetSupportVertex(const b2Vec2& d) const
{
    int32 bestIndex = 0;
    float bestValue = b2Dot(m_vertices[0], d);
    for (int32 i = 1; i < m_count; ++i)
    {
        float value = b2Dot(m_vertices[i], d);
        if (value > bestValue)
        {
            bestIndex = i;
            bestValue = value;
        }
    }
 
    return m_vertices[bestIndex];
}
 
#endif