Fixture.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_DYNAMICS_FIXTURE_HPP
#define PLAYRHO_DYNAMICS_FIXTURE_HPP
 
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Common/Span.hpp>
#include <PlayRho/Common/BoundedValue.hpp>
#include <PlayRho/Dynamics/Filter.hpp>
#include <PlayRho/Dynamics/FixtureConf.hpp>
#include <PlayRho/Dynamics/FixtureProxy.hpp>
#include <PlayRho/Collision/Shapes/Shape.hpp>
#include <limits>
#include <memory>
#include <vector>
#include <array>
 
namespace playrho {
namespace d2 {
 
class Body;
 
class Fixture
{
public:
    NonNull<Body*> GetBody() const noexcept;
    
    Shape GetShape() const noexcept;
    
    void SetSensor(bool sensor) noexcept;
 
    bool IsSensor() const noexcept;
 
    void SetFilterData(Filter filter);
 
    Filter GetFilterData() const noexcept;
 
    void Refilter();
 
    void* GetUserData() const noexcept;
 
    void SetUserData(void* data) noexcept;
 
    AreaDensity GetDensity() const noexcept;
 
    Real GetFriction() const noexcept;
 
    Real GetRestitution() const noexcept;
 
    ChildCounter GetProxyCount() const noexcept;
 
    FixtureProxy GetProxy(ChildCounter index) const noexcept;
    
    Span<const FixtureProxy> GetProxies() const noexcept;
 
private:
 
    friend class FixtureAtty;
    
    Fixture() = delete; // explicitly deleted
    
    Fixture(const Fixture& other) = delete;
    
    Fixture(NonNull<Body*> body, const FixtureConf& def, const Shape& shape):
        m_body{body},
        m_userData{def.userData},
        m_shape{shape},
        m_filter{def.filter},
        m_isSensor{def.isSensor}
    {
        // Intentionally empty.
    }
    
    ~Fixture()
    {
        // Intentionally empty.
    }
    
    union FixtureProxies {
        FixtureProxies() noexcept: asArray{} {}
        ~FixtureProxies() noexcept {}
 
        std::array<FixtureProxy, 2> asArray; 
        std::unique_ptr<FixtureProxy[]> asBuffer; 
    };
    
    void SetProxies(std::unique_ptr<FixtureProxy[]> value, std::size_t count) noexcept;
 
    void ResetProxies() noexcept;
 
    // Data ordered here for memory compaction.
    
    NonNull<Body*> const m_body; 
 
    void* m_userData = nullptr; 
 
    Shape m_shape;
    
    FixtureProxies m_proxies; 
    
    ChildCounter m_proxyCount = 0;
 
    Filter m_filter; 
    
    bool m_isSensor = false; 
};
 
inline Shape Fixture::GetShape() const noexcept
{
    return m_shape;
}
 
inline bool Fixture::IsSensor() const noexcept
{
    return m_isSensor;
}
 
inline Filter Fixture::GetFilterData() const noexcept
{
    return m_filter;
}
 
inline void* Fixture::GetUserData() const noexcept
{
    return m_userData;
}
 
inline void Fixture::SetUserData(void* data) noexcept
{
    m_userData = data;
}
 
inline NonNull<Body*> Fixture::GetBody() const noexcept
{
    return m_body;
}
 
inline ChildCounter Fixture::GetProxyCount() const noexcept
{
    return m_proxyCount;
}
 
inline void Fixture::SetFilterData(Filter filter)
{
    m_filter = filter;
    Refilter();
}
 
inline Span<const FixtureProxy> Fixture::GetProxies() const noexcept
{
    const auto ptr = (m_proxyCount <= 2)? &(m_proxies.asArray[0]): m_proxies.asBuffer.get();
    return Span<const FixtureProxy>(ptr, m_proxyCount);
}
 
inline void Fixture::SetProxies(std::unique_ptr<FixtureProxy[]> value, std::size_t count) noexcept
{
    assert(count < std::numeric_limits<ChildCounter>::max());
    switch (count)
    {
        case 2:
            m_proxies.asArray[1] = value[1];
            [[fallthrough]];
        case 1:
            m_proxies.asArray[0] = value[0];
            [[fallthrough]];
        case 0:
            break;
        default:
            m_proxies.asBuffer = std::move(value);
            break;
    }
    m_proxyCount = static_cast<decltype(m_proxyCount)>(count);
}
 
inline void Fixture::ResetProxies() noexcept
{
    if (m_proxyCount > 2)
    {
        m_proxies.asBuffer.reset();
    }
    m_proxyCount = 0;
}
 
inline Real Fixture::GetFriction() const noexcept
{
    return playrho::d2::GetFriction(m_shape);
}
 
inline Real Fixture::GetRestitution() const noexcept
{
    return playrho::d2::GetRestitution(m_shape);
}
 
inline AreaDensity Fixture::GetDensity() const noexcept
{
    return playrho::d2::GetDensity(m_shape);
}
 
// Free functions...
 
bool TestPoint(const Fixture& f, Length2 p) noexcept;
 
void SetAwake(const Fixture& f) noexcept;
 
Transformation GetTransformation(const Fixture& f) noexcept;
 
inline bool ShouldCollide(const Fixture& fixtureA, const Fixture& fixtureB) noexcept
{
    return ShouldCollide(fixtureA.GetFilterData(), fixtureB.GetFilterData());
}
    
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_DYNAMICS_FIXTURE_HPP