PolygonShapeConf.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_SHAPES_POLYGONSHAPECONF_HPP
#define PLAYRHO_COLLISION_SHAPES_POLYGONSHAPECONF_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/Shapes/ShapeConf.hpp>
#include <PlayRho/Collision/DistanceProxy.hpp>
#include <PlayRho/Collision/MassData.hpp>
#include <PlayRho/Common/VertexSet.hpp>
#include <type_traits>
#include <vector>
 
namespace playrho {
namespace d2 {
 
class PolygonShapeConf: public ShapeBuilder<PolygonShapeConf>
{
public:
    static PLAYRHO_CONSTEXPR inline NonNegative<Length> GetDefaultVertexRadius() noexcept
    {
        return NonNegative<Length>{DefaultLinearSlop * 2};
    }
    
    static inline PolygonShapeConf GetDefaultConf() noexcept
    {
        return PolygonShapeConf{};
    }
    
    PolygonShapeConf();
    
    PolygonShapeConf(Length hx, Length hy,
                     const PolygonShapeConf& conf = GetDefaultConf()) noexcept;
    
    explicit PolygonShapeConf(Span<const Length2> points,
                              const PolygonShapeConf& conf = GetDefaultConf()) noexcept;
    
    PolygonShapeConf& UseVertexRadius(NonNegative<Length> value) noexcept;
 
    PolygonShapeConf& UseVertices(const std::vector<Length2>& verts) noexcept;
    
    PolygonShapeConf& SetAsBox(Length hx, Length hy) noexcept;
    
    PolygonShapeConf& SetAsBox(Length hx, Length hy, Length2 center, Angle angle) noexcept;
    
    PolygonShapeConf& Set(Span<const Length2> verts) noexcept;
    
    PolygonShapeConf& Set(const VertexSet& points) noexcept;
    
    PolygonShapeConf& Transform(Transformation xfm) noexcept;
    
    PolygonShapeConf& Transform(const Mat22& m) noexcept;
 
    friend bool operator== (const PolygonShapeConf& lhs, const PolygonShapeConf& rhs) noexcept
    {
        // Don't need to check normals nor centroid since they 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 PolygonShapeConf& lhs, const PolygonShapeConf& rhs) noexcept
    {
        return !(lhs == rhs);
    }
    
    VertexCounter GetVertexCount() const noexcept
    {
        return static_cast<VertexCounter>(size(m_vertices));
    }
    
    Length2 GetVertex(VertexCounter index) const
    {
        assert(0 <= index && index < GetVertexCount());
        return m_vertices[index];
    }
    
    UnitVec GetNormal(VertexCounter index) const
    {
        assert(0 <= index && index < GetVertexCount());
        return m_normals[index];
    }
    
    Span<const Length2> GetVertices() const noexcept
    {
        return Span<const Length2>(&m_vertices[0], GetVertexCount());
    }
    
    Span<const UnitVec> GetNormals() const noexcept
    {
        return Span<const UnitVec>(&m_normals[0], GetVertexCount());
    }
    
    Length2 GetCentroid() const noexcept { return m_centroid; }
    
    NonNegative<Length> vertexRadius = GetDefaultVertexRadius();
    
private:
    std::vector<Length2> m_vertices;
    
    std::vector<UnitVec> m_normals;
    
    Length2 m_centroid = GetInvalid<Length2>();
};
 
inline PolygonShapeConf& PolygonShapeConf::UseVertexRadius(NonNegative<Length> value) noexcept
{
    vertexRadius = value;
    return *this;
}
 
// Free functions...
 
PLAYRHO_CONSTEXPR inline ChildCounter GetChildCount(const PolygonShapeConf&) noexcept
{
    return 1;
}
 
inline DistanceProxy GetChild(const PolygonShapeConf& arg, ChildCounter index)
{
    if (index != 0)
    {
        throw InvalidArgument("only index of 0 is supported");
    }
    return DistanceProxy{arg.vertexRadius, arg.GetVertexCount(),
        data(arg.GetVertices()), data(arg.GetNormals())};
}
 
inline NonNegative<Length> GetVertexRadius(const PolygonShapeConf& arg) noexcept
{
    return arg.vertexRadius;
}
 
inline NonNegative<Length> GetVertexRadius(const PolygonShapeConf& arg, ChildCounter) noexcept
{
    return GetVertexRadius(arg);
}
 
inline MassData GetMassData(const PolygonShapeConf& arg) noexcept
{
    return playrho::d2::GetMassData(arg.vertexRadius, arg.density, arg.GetVertices());
}
 
Length2 GetEdge(const PolygonShapeConf& shape, VertexCounter index);
 
inline void Transform(PolygonShapeConf& arg, const Mat22& m) noexcept
{
    arg.Transform(m);
}
 
bool Validate(const Span<const Length2> verts);
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_POLYGONSHAPECONF_HPP