EdgeShapeConf.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2010 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_SHAPES_EDGESHAPECONF_HPP
#define PLAYRHO_COLLISION_SHAPES_EDGESHAPECONF_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/Shapes/ShapeConf.hpp>
#include <PlayRho/Collision/DistanceProxy.hpp>
#include <PlayRho/Collision/MassData.hpp>
 
namespace playrho {
namespace d2 {
 
class EdgeShapeConf: public ShapeBuilder<EdgeShapeConf>
{
public:
    static PLAYRHO_CONSTEXPR inline NonNegative<Length> GetDefaultVertexRadius() noexcept
    {
        return NonNegative<Length>{DefaultLinearSlop * Real{2}};
    }
    
    static inline EdgeShapeConf GetDefaultConf() noexcept
    {
        return EdgeShapeConf{};
    }
 
    EdgeShapeConf() = default;
    
    EdgeShapeConf(Length2 vA, Length2 vB, const EdgeShapeConf& conf = GetDefaultConf()) noexcept;
    
    EdgeShapeConf& Set(Length2 vA, Length2 vB) noexcept;
    
    EdgeShapeConf& UseVertexRadius(NonNegative<Length> value) noexcept;
    
    EdgeShapeConf& Transform(const Mat22& m) noexcept;
 
    Length2 GetVertexA() const noexcept
    {
        return m_vertices[0];
    }
    
    Length2 GetVertexB() const noexcept
    {
        return m_vertices[1];
    }
    
    DistanceProxy GetChild() const noexcept
    {
        return DistanceProxy{vertexRadius, 2, m_vertices, m_normals};
    }
    
    NonNegative<Length> vertexRadius = GetDefaultVertexRadius();
 
private:
    Length2 m_vertices[2] = {Length2{}, Length2{}}; 
    UnitVec m_normals[2] = {UnitVec{}, UnitVec{}}; 
};
 
inline EdgeShapeConf& EdgeShapeConf::UseVertexRadius(NonNegative<Length> value) noexcept
{
    vertexRadius = value;
    return *this;
}
 
// Free functions...
 
inline bool operator== (const EdgeShapeConf& lhs, const EdgeShapeConf& rhs) noexcept
{
    return lhs.vertexRadius == rhs.vertexRadius && lhs.friction == rhs.friction
        && lhs.restitution == rhs.restitution && lhs.density == rhs.density
        && lhs.GetVertexA() == rhs.GetVertexA() && lhs.GetVertexB() == rhs.GetVertexB();
}
 
inline bool operator!= (const EdgeShapeConf& lhs, const EdgeShapeConf& rhs) noexcept
{
    return !(lhs == rhs);
}
 
PLAYRHO_CONSTEXPR inline ChildCounter GetChildCount(const EdgeShapeConf&) noexcept
{
    return 1;
}
 
inline DistanceProxy GetChild(const EdgeShapeConf& arg, ChildCounter index)
{
    if (index != 0)
    {
        throw InvalidArgument("only index of 0 is supported");
    }
    return arg.GetChild();
}
 
inline NonNegative<Length> GetVertexRadius(const EdgeShapeConf& arg) noexcept
{
    return arg.vertexRadius;
}
 
inline NonNegative<Length> GetVertexRadius(const EdgeShapeConf& arg, ChildCounter) noexcept
{
    return GetVertexRadius(arg);
}
 
inline MassData GetMassData(const EdgeShapeConf& arg) noexcept
{
    return playrho::d2::GetMassData(arg.vertexRadius, arg.density,
                                    arg.GetVertexA(), arg.GetVertexB());
}
 
inline void Transform(EdgeShapeConf& arg, const Mat22& m) noexcept
{
    arg.Transform(m);
}
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_EDGESHAPECONF_HPP