WorldManifold.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_WORLDMANIFOLD_HPP
#define PLAYRHO_COLLISION_WORLDMANIFOLD_HPP
 
#include <PlayRho/Common/Math.hpp>
 
namespace playrho {
namespace d2 {
 
class Manifold;
class Contact;
 
class WorldManifold
{
private:
    UnitVec m_normal = GetInvalid<UnitVec>(); 
    
    Length2 m_points[MaxManifoldPoints] = {GetInvalid<Length2>(), GetInvalid<Length2>()};
 
    Momentum2 m_impulses[MaxManifoldPoints] = {Momentum2{}, Momentum2{}};
    
    Length m_separations[MaxManifoldPoints] = {GetInvalid<Length>(), GetInvalid<Length>()};
    
public:
    
    using size_type = std::remove_const<decltype(MaxManifoldPoints)>::type;
 
    struct PointData
    {
        Length2 location; 
        Momentum2 impulse; 
        Length separation; 
    };
    
    WorldManifold() = default;
    
    PLAYRHO_CONSTEXPR inline explicit WorldManifold(UnitVec normal) noexcept:
        m_normal{normal}
    {
        assert(IsValid(normal));
        // Intentionally empty.
    }
    
    PLAYRHO_CONSTEXPR inline explicit WorldManifold(UnitVec normal, PointData ps0) noexcept:
        m_normal{normal},
        m_points{ps0.location, GetInvalid<Length2>()},
        m_impulses{ps0.impulse, Momentum2{}},
        m_separations{ps0.separation, GetInvalid<Length>()}
    {
        assert(IsValid(normal));
        // Intentionally empty.
    }
    
    PLAYRHO_CONSTEXPR inline explicit WorldManifold(UnitVec normal, PointData ps0, PointData ps1) noexcept:
        m_normal{normal},
        m_points{ps0.location, ps1.location},
        m_impulses{ps0.impulse, ps1.impulse},
        m_separations{ps0.separation, ps1.separation}
    {
        assert(IsValid(normal));
        // Intentionally empty.
    }
    
    size_type GetPointCount() const noexcept
    {
        return (IsValid(m_separations[0])? 1: 0) + (IsValid(m_separations[1])? 1: 0);
    }
    
    UnitVec GetNormal() const noexcept { return m_normal; }
    
    Length2 GetPoint(size_type index) const noexcept
    {
        assert(index < MaxManifoldPoints);
        return m_points[index];
    }
    
    Length GetSeparation(size_type index) const noexcept
    {
        assert(index < MaxManifoldPoints);
        return m_separations[index];
    }
    
    Momentum2 GetImpulses(size_type index) const noexcept
    {
        assert(index < MaxManifoldPoints);
        return m_impulses[index];
    }
};
 
WorldManifold GetWorldManifold(const Manifold& manifold,
                               Transformation xfA, Length radiusA,
                               Transformation xfB, Length radiusB);
 
WorldManifold GetWorldManifold(const Contact& contact);
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_WORLDMANIFOLD_HPP