b2_collision.h

Go to the documentation of this file.

// 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_COLLISION_H
#define B2_COLLISION_H
 
#include <limits.h>
 
#include "b2_api.h"
#include "b2_math.h"
 
 
class b2Shape;
class b2CircleShape;
class b2EdgeShape;
class b2PolygonShape;
 
const uint8 b2_nullFeature = UCHAR_MAX;
 
struct B2_API b2ContactFeature
{
    enum Type
    {
        e_vertex = 0,
        e_face = 1
    };
 
    uint8 indexA;       
    uint8 indexB;       
    uint8 typeA;        
    uint8 typeB;        
};
 
union B2_API b2ContactID
{
    b2ContactFeature cf;
    uint32 key;                 
};
 
struct B2_API b2ManifoldPoint
{
    b2Vec2 localPoint;      
    float normalImpulse;    
    float tangentImpulse;   
    b2ContactID id;         
};
 
struct B2_API b2Manifold
{
    enum Type
    {
        e_circles,
        e_faceA,
        e_faceB
    };
 
    b2ManifoldPoint points[b2_maxManifoldPoints];   
    b2Vec2 localNormal;                             
    b2Vec2 localPoint;                              
    Type type;
    int32 pointCount;                               
};
 
struct B2_API b2WorldManifold
{
    void Initialize(const b2Manifold* manifold,
                    const b2Transform& xfA, float radiusA,
                    const b2Transform& xfB, float radiusB);
 
    b2Vec2 normal;                              
    b2Vec2 points[b2_maxManifoldPoints];        
    float separations[b2_maxManifoldPoints];    
};
 
enum b2PointState
{
    b2_nullState,       
    b2_addState,        
    b2_persistState,    
    b2_removeState      
};
 
B2_API void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
                      const b2Manifold* manifold1, const b2Manifold* manifold2);
 
struct B2_API b2ClipVertex
{
    b2Vec2 v;
    b2ContactID id;
};
 
struct B2_API b2RayCastInput
{
    b2Vec2 p1, p2;
    float maxFraction;
};
 
struct B2_API b2RayCastOutput
{
    b2Vec2 normal;
    float fraction;
};
 
struct B2_API b2AABB
{
    bool IsValid() const;
 
    b2Vec2 GetCenter() const
    {
        return 0.5f * (lowerBound + upperBound);
    }
 
    b2Vec2 GetExtents() const
    {
        return 0.5f * (upperBound - lowerBound);
    }
 
    float GetPerimeter() const
    {
        float wx = upperBound.x - lowerBound.x;
        float wy = upperBound.y - lowerBound.y;
        return 2.0f * (wx + wy);
    }
 
    void Combine(const b2AABB& aabb)
    {
        lowerBound = b2Min(lowerBound, aabb.lowerBound);
        upperBound = b2Max(upperBound, aabb.upperBound);
    }
 
    void Combine(const b2AABB& aabb1, const b2AABB& aabb2)
    {
        lowerBound = b2Min(aabb1.lowerBound, aabb2.lowerBound);
        upperBound = b2Max(aabb1.upperBound, aabb2.upperBound);
    }
 
    bool Contains(const b2AABB& aabb) const
    {
        bool result = true;
        result = result && lowerBound.x <= aabb.lowerBound.x;
        result = result && lowerBound.y <= aabb.lowerBound.y;
        result = result && aabb.upperBound.x <= upperBound.x;
        result = result && aabb.upperBound.y <= upperBound.y;
        return result;
    }
 
    bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input) const;
 
    b2Vec2 lowerBound;  
    b2Vec2 upperBound;  
};
 
B2_API void b2CollideCircles(b2Manifold* manifold,
                      const b2CircleShape* circleA, const b2Transform& xfA,
                      const b2CircleShape* circleB, const b2Transform& xfB);
 
B2_API void b2CollidePolygonAndCircle(b2Manifold* manifold,
                               const b2PolygonShape* polygonA, const b2Transform& xfA,
                               const b2CircleShape* circleB, const b2Transform& xfB);
 
B2_API void b2CollidePolygons(b2Manifold* manifold,
                       const b2PolygonShape* polygonA, const b2Transform& xfA,
                       const b2PolygonShape* polygonB, const b2Transform& xfB);
 
B2_API void b2CollideEdgeAndCircle(b2Manifold* manifold,
                               const b2EdgeShape* polygonA, const b2Transform& xfA,
                               const b2CircleShape* circleB, const b2Transform& xfB);
 
B2_API void b2CollideEdgeAndPolygon(b2Manifold* manifold,
                               const b2EdgeShape* edgeA, const b2Transform& xfA,
                               const b2PolygonShape* polygonB, const b2Transform& xfB);
 
B2_API int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
                            const b2Vec2& normal, float offset, int32 vertexIndexA);
 
B2_API bool b2TestOverlap(  const b2Shape* shapeA, int32 indexA,
                    const b2Shape* shapeB, int32 indexB,
                    const b2Transform& xfA, const b2Transform& xfB);
 
struct b2Hull
{
    b2Vec2 points[b2_maxPolygonVertices];
    int32 count;
};
 
b2Hull b2ComputeHull(const b2Vec2* points, int32 count);
 
bool b2ValidateHull(const b2Hull& hull);
 
 
// ---------------- Inline Functions ------------------------------------------
 
inline bool b2AABB::IsValid() const
{
    b2Vec2 d = upperBound - lowerBound;
    bool valid = d.x >= 0.0f && d.y >= 0.0f;
    valid = valid && lowerBound.IsValid() && upperBound.IsValid();
    return valid;
}
 
inline bool b2TestOverlap(const b2AABB& a, const b2AABB& b)
{
    b2Vec2 d1, d2;
    d1 = b.lowerBound - a.upperBound;
    d2 = a.lowerBound - b.upperBound;
 
    if (d1.x > 0.0f || d1.y > 0.0f)
        return false;
 
    if (d2.x > 0.0f || d2.y > 0.0f)
        return false;
 
    return true;
}
 
#endif