ChainShapeConf.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_CHAINSHAPECONF_HPP
#define PLAYRHO_COLLISION_SHAPES_CHAINSHAPECONF_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/Shapes/ShapeConf.hpp>
#include <PlayRho/Collision/DistanceProxy.hpp>
#include <PlayRho/Collision/MassData.hpp>
#include <PlayRho/Collision/AABB.hpp>
#include <vector>
 
namespace playrho {
namespace d2 {
 
class ChainShapeConf: public ShapeBuilder<ChainShapeConf>
{
public:
    static PLAYRHO_CONSTEXPR inline NonNegative<Length> GetDefaultVertexRadius() noexcept
    {
        return NonNegative<Length>{DefaultLinearSlop * Real{2}};
    }
 
    ChainShapeConf();
    
    ChainShapeConf& Set(std::vector<Length2> arg);
    
    ChainShapeConf& Add(Length2 vertex);
    
    ChainShapeConf& Transform(const Mat22& m) noexcept;
 
    ChildCounter GetChildCount() const noexcept
    {
        // edge count = vertex count - 1
        const auto count = GetVertexCount();
        return (count > 1)? count - 1: count;
    }
 
    DistanceProxy GetChild(ChildCounter index) const;
    
    MassData GetMassData() const noexcept;
    
    ChainShapeConf& UseVertexRadius(NonNegative<Length> value) noexcept;
 
    ChildCounter GetVertexCount() const noexcept
    {
        return static_cast<ChildCounter>(size(m_vertices));
    }
    
    Length2 GetVertex(ChildCounter index) const
    {
        assert((0 <= index) && (index < GetVertexCount()));
        return m_vertices[index];
    }
    
    UnitVec GetNormal(ChildCounter index) const
    {
        assert((0 <= index) && (index < GetVertexCount()));
        return m_normals[index];
    }
    
    friend bool operator== (const ChainShapeConf& lhs, const ChainShapeConf& rhs) noexcept
    {
        // Don't need to check normals since normals based on vertices.
        return lhs.vertexRadius == rhs.vertexRadius && lhs.friction == rhs.friction
            && lhs.restitution == rhs.restitution && lhs.density == rhs.density
            && lhs.m_vertices == rhs.m_vertices;
    }
    
    friend bool operator!= (const ChainShapeConf& lhs, const ChainShapeConf& rhs) noexcept
    {
        return !(lhs == rhs);
    }
    
    NonNegative<Length> vertexRadius = GetDefaultVertexRadius();
 
private:
    void ResetNormals();
 
    std::vector<Length2> m_vertices; 
    std::vector<UnitVec> m_normals; 
};
 
inline ChainShapeConf& ChainShapeConf::UseVertexRadius(NonNegative<Length> value) noexcept
{
    vertexRadius = value;
    return *this;
}
 
// Free functions...
 
inline ChildCounter GetChildCount(const ChainShapeConf& arg) noexcept
{
    return arg.GetChildCount();
}
 
inline DistanceProxy GetChild(const ChainShapeConf& arg, ChildCounter index)
{
    return arg.GetChild(index);
}
 
inline MassData GetMassData(const ChainShapeConf& arg) noexcept
{
    return arg.GetMassData();
}
 
inline bool IsLooped(const ChainShapeConf& shape) noexcept
{
    const auto count = shape.GetVertexCount();
    return (count > 1)? (shape.GetVertex(count - 1) == shape.GetVertex(0)): false;
}
 
inline ChildCounter GetNextIndex(const ChainShapeConf& shape, ChildCounter index) noexcept
{
    return GetModuloNext(index, shape.GetVertexCount());
}
 
inline NonNegative<Length> GetVertexRadius(const ChainShapeConf& arg)
{
    return arg.vertexRadius;
}
 
inline NonNegative<Length> GetVertexRadius(const ChainShapeConf& arg, ChildCounter)
{
    return GetVertexRadius(arg);
}
 
inline void Transform(ChainShapeConf& arg, const Mat22& m) noexcept
{
    arg.Transform(m);
}
 
ChainShapeConf GetChainShapeConf(Length2 dimensions);
 
inline ChainShapeConf GetChainShapeConf(Length dimension)
{
    return GetChainShapeConf(Length2{dimension, dimension});
}
 
ChainShapeConf GetChainShapeConf(const AABB& arg);
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_CHAINSHAPECONF_HPP