Contact.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_DYNAMICS_CONTACTS_CONTACT_HPP
#define PLAYRHO_DYNAMICS_CONTACTS_CONTACT_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/Manifold.hpp>
#include <PlayRho/Collision/Distance.hpp>
#include <PlayRho/Collision/TimeOfImpact.hpp>
#include <PlayRho/Collision/Shapes/Shape.hpp>
 
namespace playrho {
 
inline Real MixFriction(Real friction1, Real friction2)
{
    assert(friction1 >= 0 && friction2 >= 0);
    return sqrt(friction1 * friction2);
}
 
inline Real MixRestitution(Real restitution1, Real restitution2) noexcept
{
    return (restitution1 > restitution2) ? restitution1 : restitution2;
}
 
struct ToiConf;
class StepConf;
 
namespace d2 {
 
class Body;
class Fixture;
class ContactListener;
 
class Contact
{
public:
    
    using substep_type = TimestepIters;
 
    struct UpdateConf
    {
        DistanceConf distance; 
        Manifold::Conf manifold; 
    };
    
    static UpdateConf GetUpdateConf(const StepConf& conf) noexcept;
    
    Contact(Fixture* fA, ChildCounter iA, Fixture* fB, ChildCounter iB);
    
    Contact() = delete;
    
    Contact(const Contact& copy) = default;
 
    const Manifold& GetManifold() const noexcept;
    
    bool IsTouching() const noexcept;
 
    [[deprecated]] void SetEnabled(bool flag) noexcept;
 
    void SetEnabled() noexcept;
 
    void UnsetEnabled() noexcept;
 
    bool IsEnabled() const noexcept;
 
    Fixture* GetFixtureA() const noexcept;
 
    ChildCounter GetChildIndexA() const noexcept;
 
    Fixture* GetFixtureB() const noexcept;
 
    ChildCounter GetChildIndexB() const noexcept;
 
    void SetFriction(Real friction) noexcept;
 
    Real GetFriction() const noexcept;
 
    void SetRestitution(Real restitution) noexcept;
 
    Real GetRestitution() const noexcept;
 
    void SetTangentSpeed(LinearVelocity speed) noexcept;
 
    LinearVelocity GetTangentSpeed() const noexcept;
 
    substep_type GetToiCount() const noexcept;
 
    bool HasValidToi() const noexcept;
 
    Real GetToi() const;
 
    void FlagForFiltering() noexcept;
 
    bool NeedsFiltering() const noexcept;
 
    void FlagForUpdating() noexcept;
 
    bool NeedsUpdating() const noexcept;
 
private:
 
    friend class ContactAtty;
 
    using FlagsType = std::uint8_t;
 
    enum: FlagsType
    {
        // Used when crawling contact graph when forming islands.
        e_islandFlag = 0x01,
        
        // Set when the shapes are touching.
        e_touchingFlag = 0x02,
 
        // This contact can be disabled (by user)
        e_enabledFlag = 0x04,
 
        // This contact needs filtering because a fixture filter was changed.
        e_filterFlag = 0x08,
 
        // This contact has a valid TOI in m_toi
        e_toiFlag = 0x10,
        
        // This contacts needs its touching state updated.
        e_dirtyFlag = 0x20
    };
    
    void UnflagForFiltering() noexcept;
 
    void UnflagForUpdating() noexcept;
 
    void Update(const UpdateConf& conf, ContactListener* listener = nullptr);
 
    void SetToi(Real toi) noexcept;
 
    void UnsetToi() noexcept;
 
    void SetToiCount(substep_type value) noexcept;
 
    void SetTouching() noexcept;
 
    void UnsetTouching() noexcept;
 
    Manifold& GetMutableManifold() noexcept;
    
    bool IsIslanded() const noexcept;
    
    void SetIslanded() noexcept;
    
    void UnsetIslanded() noexcept;
 
    // Member variables...
 
    Manifold mutable m_manifold; 
 
    // Need to be able to identify two different fixtures, the child shape per fixture,
    // and the two different bodies that each fixture is associated with. This could be
    // done by storing whatever information is needed to lookup this information. For
    // instance, if the dynamic tree's two leaf nodes for this contact contained this
    // info then minimally only those two indexes are needed. That may be sub-optimal
    // however depending the speed of cache and memory access.
 
    Fixture* const m_fixtureA; 
    Fixture* const m_fixtureB; 
    ChildCounter const m_indexA; 
    ChildCounter const m_indexB; 
    
    // initialized on construction (construction-time depedent)
    Real m_friction; 
    Real m_restitution; 
 
    LinearVelocity m_tangentSpeed = 0; 
    
    Real m_toi;
    
    substep_type m_toiCount = 0; 
    
    FlagsType m_flags = e_enabledFlag|e_dirtyFlag; 
};
 
 
inline const Manifold& Contact::GetManifold() const noexcept
{
    // XXX: What to do if needs-updating?
    //assert(!NeedsUpdating());
    return m_manifold;
}
 
inline Manifold& Contact::GetMutableManifold() noexcept
{
    return m_manifold;
}
 
inline void Contact::SetEnabled(bool flag) noexcept
{
    if (flag)
    {
        SetEnabled();
    }
    else
    {
        UnsetEnabled();
    }
}
 
inline void Contact::SetEnabled() noexcept
{
    m_flags |= Contact::e_enabledFlag;
}
 
inline void Contact::UnsetEnabled() noexcept
{
    m_flags &= ~Contact::e_enabledFlag;
}
 
inline bool Contact::IsEnabled() const noexcept
{
    return (m_flags & e_enabledFlag) != 0;
}
 
inline bool Contact::IsTouching() const noexcept
{
    // XXX: What to do if needs-updating?
    // assert(!NeedsUpdating());
    return (m_flags & e_touchingFlag) != 0;
}
 
inline void Contact::SetTouching() noexcept
{
    m_flags |= e_touchingFlag;
}
 
inline void Contact::UnsetTouching() noexcept
{
    m_flags &= ~e_touchingFlag;
}
 
inline Fixture* Contact::GetFixtureA() const noexcept
{
    return m_fixtureA;
}
 
inline Fixture* Contact::GetFixtureB() const noexcept
{
    return m_fixtureB;
}
 
inline void Contact::FlagForFiltering() noexcept
{
    m_flags |= e_filterFlag;
}
 
inline void Contact::UnflagForFiltering() noexcept
{
    m_flags &= ~Contact::e_filterFlag;
}
 
inline bool Contact::NeedsFiltering() const noexcept
{
    return (m_flags & Contact::e_filterFlag) != 0;
}
 
inline void Contact::FlagForUpdating() noexcept
{
    m_flags |= e_dirtyFlag;
}
 
inline void Contact::UnflagForUpdating() noexcept
{
    m_flags &= ~Contact::e_dirtyFlag;
}
 
inline bool Contact::NeedsUpdating() const noexcept
{
    return (m_flags & Contact::e_dirtyFlag) != 0;
}
 
inline void Contact::SetFriction(Real friction) noexcept
{
    assert(friction >= 0);
    m_friction = friction;
}
 
inline Real Contact::GetFriction() const noexcept
{
    return m_friction;
}
 
inline void Contact::SetRestitution(Real restitution) noexcept
{
    m_restitution = restitution;
}
 
inline Real Contact::GetRestitution() const noexcept
{
    return m_restitution;
}
 
inline void Contact::SetTangentSpeed(LinearVelocity speed) noexcept
{
    m_tangentSpeed = speed;
}
 
inline LinearVelocity Contact::GetTangentSpeed() const noexcept
{
    return m_tangentSpeed;
}
 
inline bool Contact::HasValidToi() const noexcept
{
    return (m_flags & Contact::e_toiFlag) != 0;
}
 
inline Real Contact::GetToi() const
{
    assert(HasValidToi());
    return m_toi;
}
 
inline void Contact::SetToi(Real toi) noexcept
{
    assert(toi >= 0 && toi <= 1);
    m_toi = toi;
    m_flags |= Contact::e_toiFlag;
}
 
inline void Contact::UnsetToi() noexcept
{
    m_flags &= ~Contact::e_toiFlag;
}
 
inline void Contact::SetToiCount(substep_type value) noexcept
{
    m_toiCount = value;
}
 
inline Contact::substep_type Contact::GetToiCount() const noexcept
{
    return m_toiCount;
}
 
inline bool Contact::IsIslanded() const noexcept
{
    return (m_flags & e_islandFlag) != 0;
}
 
inline void Contact::SetIslanded() noexcept
{
    m_flags |= e_islandFlag;
}
 
inline void Contact::UnsetIslanded() noexcept
{
    m_flags &= ~e_islandFlag;
}
 
inline ChildCounter Contact::GetChildIndexA() const noexcept
{
    return m_indexA;
}
 
inline ChildCounter Contact::GetChildIndexB() const noexcept
{
    return m_indexB;
}
 
// Free functions...
 
using ContactPtr = Contact*;
 
Body* GetBodyA(const Contact& contact) noexcept;
 
Body* GetBodyB(const Contact& contact) noexcept;
 
inline Fixture* GetFixtureA(const Contact& contact) noexcept
{
    return contact.GetFixtureA();
}
 
inline Fixture* GetFixtureB(const Contact& contact) noexcept
{
    return contact.GetFixtureB();
}
 
inline ChildCounter GetChildIndexA(const Contact& contact) noexcept
{
    return contact.GetChildIndexA();
}
 
inline ChildCounter GetChildIndexB(const Contact& contact) noexcept
{
    return contact.GetChildIndexB();
}
 
bool HasSensor(const Contact& contact) noexcept;
 
bool IsImpenetrable(const Contact& contact) noexcept;
 
bool IsActive(const Contact& contact) noexcept;
 
void SetAwake(const Contact& c) noexcept;
 
void ResetFriction(Contact& contact);
 
void ResetRestitution(Contact& contact) noexcept;
 
TOIOutput CalcToi(const Contact& contact, ToiConf conf);
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_DYNAMICS_CONTACTS_CONTACT_HPP