DiskShapeConf.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_DISKSHAPECONF_HPP
#define PLAYRHO_COLLISION_SHAPES_DISKSHAPECONF_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 {
 
struct DiskShapeConf: ShapeBuilder<DiskShapeConf>
{
    static PLAYRHO_CONSTEXPR inline NonNegative<Length> GetDefaultRadius() noexcept
    {
        return NonNegative<Length>{DefaultLinearSlop * 2};
    }
 
    PLAYRHO_CONSTEXPR DiskShapeConf() = default;
 
    PLAYRHO_CONSTEXPR inline DiskShapeConf(NonNegative<Length> r): vertexRadius{r}
    {
        // Intentionally empty.
    }
 
    PLAYRHO_CONSTEXPR inline DiskShapeConf& UseLocation(Length2 value) noexcept
    {
        location = value;
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline DiskShapeConf& UseRadius(NonNegative<Length> r) noexcept
    {
        vertexRadius = r;
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline DiskShapeConf& Transform(const Mat22& m) noexcept
    {
        location = m * location;
        return *this;
    }
    
    NonNegative<Length> GetRadius() const noexcept
    {
        return vertexRadius;
    }
    
    Length2 GetLocation() const noexcept
    {
        return location;
    }
    
    NonNegative<Length> vertexRadius = GetDefaultRadius();
 
    Length2 location = Length2{};
};
 
// Free functions...
 
inline bool operator== (const DiskShapeConf& lhs, const DiskShapeConf& rhs) noexcept
{
    return lhs.vertexRadius == rhs.vertexRadius && lhs.friction == rhs.friction
        && lhs.restitution == rhs.restitution && lhs.density == rhs.density
        && lhs.location == rhs.location;
}
 
inline bool operator!= (const DiskShapeConf& lhs, const DiskShapeConf& rhs) noexcept
{
    return !(lhs == rhs);
}
 
PLAYRHO_CONSTEXPR inline ChildCounter GetChildCount(const DiskShapeConf&) noexcept
{
    return 1;
}
 
inline DistanceProxy GetChild(const DiskShapeConf& arg, ChildCounter index)
{
    if (index != 0)
    {
        throw InvalidArgument("only index of 0 is supported");
    }
    return DistanceProxy{arg.vertexRadius, 1, &arg.location, nullptr};
}
 
PLAYRHO_CONSTEXPR inline NonNegative<Length> GetVertexRadius(const DiskShapeConf& arg) noexcept
{
    return arg.vertexRadius;
}
 
PLAYRHO_CONSTEXPR inline NonNegative<Length> GetVertexRadius(const DiskShapeConf& arg,
                                                             ChildCounter) noexcept
{
    return GetVertexRadius(arg);
}
 
inline MassData GetMassData(const DiskShapeConf& arg) noexcept
{
    return playrho::d2::GetMassData(arg.vertexRadius, arg.density, arg.location);
}
 
inline void Transform(DiskShapeConf& arg, const Mat22& m) noexcept
{
    arg.Transform(m);
}
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_DISKSHAPECONF_HPP