MultiShapeConf.hpp

Go to the documentation of this file.

/*
 * 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_MULTISHAPECONF_HPP
#define PLAYRHO_COLLISION_SHAPES_MULTISHAPECONF_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/Shapes/ShapeConf.hpp>
#include <PlayRho/Collision/DistanceProxy.hpp>
#include <PlayRho/Collision/MassData.hpp>
#include <vector>
 
namespace playrho {
namespace d2 {
 
class VertexSet;
 
class ConvexHull
{
public:
    
    static ConvexHull Get(const VertexSet& pointSet, NonNegative<Length> vertexRadius =
                          NonNegative<Length>{DefaultLinearSlop * Real{2}});
    
    DistanceProxy GetDistanceProxy() const
    {
        return DistanceProxy{
            vertexRadius, static_cast<VertexCounter>(size(vertices)),
            data(vertices), data(normals)
        };
    }
    
    NonNegative<Length> GetVertexRadius() const noexcept
    {
        return vertexRadius;
    }
    
    ConvexHull& Transform(const Mat22& m) noexcept;
 
    friend bool operator== (const ConvexHull& lhs, const ConvexHull& rhs) noexcept
    {
        // No need to check normals - they're based on vertices.
        return lhs.vertexRadius == rhs.vertexRadius && lhs.vertices == rhs.vertices;
    }
    
    friend bool operator!= (const ConvexHull& lhs, const ConvexHull& rhs) noexcept
    {
        return !(lhs == rhs);
    }
    
private:
    ConvexHull(std::vector<Length2> verts, std::vector<UnitVec> norms,
               NonNegative<Length> vr):
        vertices{verts}, normals{norms}, vertexRadius{vr}
    {}
    
    std::vector<Length2> vertices;
    
    std::vector<UnitVec> normals;
 
    NonNegative<Length> vertexRadius;
};
 
struct MultiShapeConf: public ShapeBuilder<MultiShapeConf>
{
    static PLAYRHO_CONSTEXPR inline NonNegative<Length> GetDefaultVertexRadius() noexcept
    {
        return NonNegative<Length>{DefaultLinearSlop * 2};
    }
    
    static inline MultiShapeConf GetDefaultConf() noexcept
    {
        return MultiShapeConf{};
    }
    
    inline MultiShapeConf():
        ShapeBuilder{ShapeConf{}}
    {
        // Intentionally empty.
    }
    
    MultiShapeConf& AddConvexHull(const VertexSet& pointSet, NonNegative<Length> vertexRadius =
                                  GetDefaultVertexRadius()) noexcept;
    
    MultiShapeConf& Transform(const Mat22& m) noexcept;
 
    std::vector<ConvexHull> children; 
};
 
// Free functions...
 
inline bool operator== (const MultiShapeConf& lhs, const MultiShapeConf& rhs) noexcept
{
    return lhs.friction == rhs.friction && lhs.restitution == rhs.restitution
        && lhs.density == rhs.density && lhs.children == rhs.children;
}
 
inline bool operator!= (const MultiShapeConf& lhs, const MultiShapeConf& rhs) noexcept
{
    return !(lhs == rhs);
}
 
inline ChildCounter GetChildCount(const MultiShapeConf& arg) noexcept
{
    return static_cast<ChildCounter>(size(arg.children));
}
 
inline DistanceProxy GetChild(const MultiShapeConf& arg, ChildCounter index)
{
    if (index >= GetChildCount(arg))
    {
        throw InvalidArgument("index out of range");
    }
    return arg.children[index].GetDistanceProxy();
}
 
MassData GetMassData(const MultiShapeConf& arg) noexcept;
 
inline NonNegative<Length> GetVertexRadius(const MultiShapeConf& arg, ChildCounter index)
{
    if (index >= GetChildCount(arg))
    {
        throw InvalidArgument("index out of range");
    }
    return arg.children[index].GetVertexRadius();
}
 
inline void Transform(MultiShapeConf& arg, const Mat22& m) noexcept
{
    arg.Transform(m);
}
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_MULTISHAPECONF_HPP