Shape.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_SHAPE_HPP
#define PLAYRHO_COLLISION_SHAPES_SHAPE_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Collision/DistanceProxy.hpp>
#include <PlayRho/Collision/MassData.hpp>
#include <PlayRho/Common/BoundedValue.hpp>
#include <memory>
#include <functional>
#include <utility>
#include <typeinfo>
 
namespace playrho {
namespace d2 {
 
class Shape;
 
// Forward declare functions.
// Note that these may be friend functions but that declaring these within the class that
// they're to be friends of, doesn't also insure that they're found within the namespace
// in terms of lookup.
 
ChildCounter GetChildCount(const Shape& shape) noexcept;
 
DistanceProxy GetChild(const Shape& shape, ChildCounter index);
 
MassData GetMassData(const Shape& shape) noexcept;
 
Real GetFriction(const Shape& shape) noexcept;
 
Real GetRestitution(const Shape& shape) noexcept;
 
NonNegative<AreaDensity> GetDensity(const Shape& shape) noexcept;
 
NonNegative<Length> GetVertexRadius(const Shape& shape, ChildCounter idx);
 
void Transform(Shape& shape, const Mat22& m);
 
bool Visit(const Shape& shape, void* userData);
 
const void* GetData(const Shape& shape) noexcept;
 
const std::type_info& GetUseTypeInfo(const Shape& shape);
 
using TypeInfoVisitor = std::function<void(const std::type_info& ti, const void* data)>;
 
void Accept(const Shape& shape, const TypeInfoVisitor& visitor);
 
bool operator== (const Shape& lhs, const Shape& rhs) noexcept;
 
bool operator!= (const Shape& lhs, const Shape& rhs) noexcept;
 
// Now define the shape class...
    
 
class Shape
{
public:
    Shape();
 
    template <typename T>
    explicit Shape(T arg): m_self{std::make_shared<Model<T>>(std::move(arg))}
    {
        // Intentionally empty.
    }
    
    Shape(const Shape& other) = default;
    
    Shape(Shape&& other) = default;
    
    Shape& operator= (const Shape& other) = default;
    
    Shape& operator= (Shape&& other) = default;
 
    friend ChildCounter GetChildCount(const Shape& shape) noexcept
    {
        return shape.m_self->GetChildCount_();
    }
 
    friend DistanceProxy GetChild(const Shape& shape, ChildCounter index)
    {
        return shape.m_self->GetChild_(index);
    }
    
    friend MassData GetMassData(const Shape& shape) noexcept
    {
        return shape.m_self->GetMassData_();
    }
    
    friend NonNegative<Length> GetVertexRadius(const Shape& shape, ChildCounter idx)
    {
        return shape.m_self->GetVertexRadius_(idx);
    }
    
    friend Real GetFriction(const Shape& shape) noexcept
    {
        return shape.m_self->GetFriction_();
    }
    
    friend Real GetRestitution(const Shape& shape) noexcept
    {
        return shape.m_self->GetRestitution_();
    }
 
    friend NonNegative<AreaDensity> GetDensity(const Shape& shape) noexcept
    {
        return shape.m_self->GetDensity_();
    }
    
    friend void Transform(Shape& shape, const Mat22& m)
    {
        auto copy = shape.m_self->Clone();
        copy->Transform_(m);
        shape.m_self = std::unique_ptr<const Shape::Concept>{std::move(copy)};
    }
    
    friend bool Visit(const Shape& shape, void* userData)
    {
        return shape.m_self->Visit_(userData);
    }
    
    friend const void* GetData(const Shape& shape) noexcept
    {
        return shape.m_self->GetData_();
    }
    
    friend const std::type_info& GetUseTypeInfo(const Shape& shape)
    {
        return shape.m_self->GetUseTypeInfo_();
    }
 
    friend void Accept(const Shape& shape, const TypeInfoVisitor& visitor)
    {
        const auto self = shape.m_self;
        visitor(self->GetUseTypeInfo_(), self->GetData_());
    }
    
    friend bool operator== (const Shape& lhs, const Shape& rhs) noexcept
    {
        return lhs.m_self == rhs.m_self || *lhs.m_self == *rhs.m_self;
    }
 
    friend bool operator!= (const Shape& lhs, const Shape& rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
private:
 
    struct Concept
    {
        virtual ~Concept() = default;
 
        virtual std::unique_ptr<Concept> Clone() const = 0;
        
        virtual ChildCounter GetChildCount_() const noexcept = 0;
        
        virtual DistanceProxy GetChild_(ChildCounter index) const = 0;
        
        virtual MassData GetMassData_() const noexcept = 0;
        
        virtual NonNegative<Length> GetVertexRadius_(ChildCounter idx) const = 0;
 
        virtual NonNegative<AreaDensity> GetDensity_() const noexcept = 0;
        
        virtual Real GetFriction_() const noexcept = 0;
        
        virtual Real GetRestitution_() const noexcept = 0;
        
        virtual void Transform_(const Mat22& m) = 0;
        
        virtual bool Visit_(void* userData) const = 0;
        
        virtual bool IsEqual_(const Concept& other) const noexcept = 0;
        
        virtual const std::type_info& GetUseTypeInfo_() const = 0;
        
        virtual const void* GetData_() const noexcept = 0;
        
        friend bool operator== (const Concept& lhs, const Concept &rhs) noexcept
        {
            return &lhs == &rhs || lhs.IsEqual_(rhs);
        }
        
        friend bool operator!= (const Concept& lhs, const Concept &rhs) noexcept
        {
            return !(lhs == rhs);
        }
    };
 
    template <typename T>
    struct Model final: Concept
    {
        using data_type = T;
 
        Model(T arg): data{std::move(arg)} {}
        
        std::unique_ptr<Concept> Clone() const override
        {
            return std::make_unique<Model>(data);
        }
 
        ChildCounter GetChildCount_() const noexcept override
        {
            return GetChildCount(data);
        }
 
        DistanceProxy GetChild_(ChildCounter index) const override
        {
            return GetChild(data, index);
        }
 
        MassData GetMassData_() const noexcept override
        {
            return GetMassData(data);
        }
        
        NonNegative<Length> GetVertexRadius_(ChildCounter idx) const override
        {
            return GetVertexRadius(data, idx);
        }
        
        NonNegative<AreaDensity> GetDensity_() const noexcept override
        {
            return GetDensity(data);
        }
        
        Real GetFriction_() const noexcept override
        {
            return GetFriction(data);
        }
        
        Real GetRestitution_() const noexcept override
        {
            return GetRestitution(data);
        }
        
        void Transform_(const Mat22& m) override
        {
            Transform(data, m);
        }
 
        bool Visit_(void* userData) const override
        {
            return ::playrho::Visit(data, userData);
        }
        
        bool IsEqual_(const Concept& other) const noexcept override
        {
            // Would be preferable to do this without using any kind of RTTI system.
            // But how would that be done?
            return (GetUseTypeInfo_() == other.GetUseTypeInfo_()) &&
                (data == *static_cast<const T*>(other.GetData_()));
        }
        
        const std::type_info& GetUseTypeInfo_() const override
        {
            return typeid(data_type);
        }
        
        const void* GetData_() const noexcept override
        {
            // Note address of "data" not necessarily same as address of "this" since
            // base class is virtual.
            return &data;
        }
 
        T data; 
    };
 
    std::shared_ptr<const Concept> m_self; 
};
 
// Related free functions...
 
bool TestPoint(const Shape& shape, Length2 point) noexcept;
 
} // namespace d2
 
template <>
inline bool Visit<d2::Shape>(const d2::Shape& shape, void* userData)
{
    return d2::Visit(shape, userData);
}
 
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_SHAPES_SHAPE_HPP