Magic_Game/src/kiwano-physics/Fixture.h

// Copyright (c) 2018-2019 Kiwano - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#pragma once
#include <kiwano-physics/helper.h>

namespace kiwano
{
namespace physics
{
class Body;

KGE_DECLARE_SMART_PTR(Fixture);

/**
 * \addtogroup Physics
 * @{
 */

/// \~chinese
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD>
class Fixture : public virtual ObjectBase
{
public:
    /// \~chinese
    /// @brief <20>о߲<D0BE><DFB2><EFBFBD>
    struct Param
    {
        float density     = 0.0f;   ///< <20>ܶ<EFBFBD>
        float friction    = 0.2f;   ///< Ħ<><C4A6><EFBFBD><EFBFBD>
        float restitution = 0.0f;   ///< <20><><EFBFBD>Իָ<D4BB>
        bool  is_sensor   = false;  ///< <20>Ƿ<EFBFBD><C7B7>ǽӴ<C7BD><D3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

        Param() {}

        Param(float density, float friction = 0.2f, float restitution = 0.f, bool is_sensor = false)
            : density(density)
            , friction(friction)
            , restitution(restitution)
            , is_sensor(is_sensor)
        {
        }
    };

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD>Բ<EFBFBD>μо<CEBC>
    /// @param body <20><><EFBFBD>Ӽоߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param param <20>о߲<D0BE><DFB2><EFBFBD>
    /// @param radius Բ<>ΰ뾶
    /// @param offset ƫ<><C6AB><EFBFBD><EFBFBD>
    static FixturePtr CreateCircle(Body* body, Param const& param, float radius, Point const& offset = Point());

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>μо<CEBC>
    /// @param body <20><><EFBFBD>Ӽоߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param param <20>о߲<D0BE><DFB2><EFBFBD>
    /// @param size <20><><EFBFBD>δ<EFBFBD>С
    /// @param offset ƫ<><C6AB><EFBFBD><EFBFBD>
    /// @param rotation <20><>ת<EFBFBD>Ƕ<EFBFBD>
    static FixturePtr CreateRect(Body* body, Param const& param, Size const& size, Point const& offset = Point(),
                                 float rotation = 0.f);

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>μо<CEBC>
    /// @param body <20><><EFBFBD>Ӽоߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param param <20>о߲<D0BE><DFB2><EFBFBD>
    /// @param vertexs <20><><EFBFBD><EFBFBD><EFBFBD>ζ<EFBFBD><CEB6><EFBFBD>
    static FixturePtr CreatePolygon(Body* body, Param const& param, Vector<Point> const& vertexs);

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD>߼о<DFBC>
    /// @param body <20><><EFBFBD>Ӽоߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param param <20>о߲<D0BE><DFB2><EFBFBD>
    /// @param p1 <20>ߵ<EFBFBD><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param p2 <20>ߵ<EFBFBD><DFB5>յ<EFBFBD>
    static FixturePtr CreateEdge(Body* body, Param const& param, Point const& p1, Point const& p2);

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD>
    /// @param body <20><><EFBFBD>Ӽоߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD>
    /// @param param <20>о߲<D0BE><DFB2><EFBFBD>
    /// @param vertexs <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// @param loop <20>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD>
    static FixturePtr CreateChain(Body* body, Param const& param, Vector<Point> const& vertexs, bool loop = false);

    Fixture();

    virtual ~Fixture();

    /// \~chinese
    /// @brief <20>Ƿ<EFBFBD><C7B7><EFBFBD>Ч
    bool IsValid() const;

    /// \~chinese
    /// @brief <20><>ȡ<EFBFBD>о<EFBFBD><D0BE><EFBFBD><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>
    Body* GetBody() const;

    /// \~chinese
    /// @brief <20>Ƿ<EFBFBD><C7B7>ǽӴ<C7BD><D3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    bool IsSensor() const;

    /// \~chinese
    /// @brief <20><><EFBFBD>üо<C3BC><D0BE>Ƿ<EFBFBD><C7B7>ǽӴ<C7BD><D3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// @details <20>Ӵ<EFBFBD><D3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӵ<EFBFBD><D3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӱ<EFBFBD><D3B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˶<EFBFBD>
    void SetSensor(bool sensor);

    /// \~chinese
    /// @brief <20><>ȡ<EFBFBD>оߵ<D0BE><DFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    void GetMassData(float* mass, Point* center, float* inertia) const;

    /// \~chinese
    /// @brief <20><>ȡ<EFBFBD>ܶ<EFBFBD>
    float GetDensity() const;

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD>ܶ<EFBFBD>
    void SetDensity(float density);

    /// \~chinese
    /// @brief <20><>ȡĦ<C8A1><C4A6><EFBFBD><EFBFBD> [N]
    float GetFriction() const;

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD>Ħ<EFBFBD><C4A6><EFBFBD><EFBFBD> [N]
    void SetFriction(float friction);

    /// \~chinese
    /// @brief <20><>ȡ<EFBFBD><C8A1><EFBFBD>Իָ<D4BB>
    float GetRestitution() const;

    /// \~chinese
    /// @brief <20><><EFBFBD>õ<EFBFBD><C3B5>Իָ<D4BB>
    void SetRestitution(float restitution);

    /// \~chinese
    /// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    bool TestPoint(const Point& p) const;

    b2Fixture* GetB2Fixture() const;

    void SetB2Fixture(b2Fixture* fixture);

    bool operator==(const Fixture& rhs) const;
    bool operator!=(const Fixture& rhs) const;

private:
    b2Fixture* fixture_;
};

/// \~chinese
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD><D0BE>б<EFBFBD>
class FixtureList
{
    template <typename _Ty>
    class IteratorImpl : public std::iterator<std::forward_iterator_tag, _Ty>
    {
        using herit = std::iterator<std::forward_iterator_tag, _Ty>;

    public:
        using reference = typename herit::reference;
        using pointer   = typename herit::pointer;

        IteratorImpl(pointer elem)
            : elem_(elem)
        {
        }

        inline reference operator*() const
        {
            return const_cast<typename herit::reference>(*elem_);
        }

        inline pointer operator->() const
        {
            return std::pointer_traits<typename herit::pointer>::pointer_to(**this);
        }

        inline IteratorImpl& operator++()
        {
            b2Fixture* next = elem_->GetB2Fixture()->GetNext();

            elem_ = static_cast<Fixture*>(next->GetUserData());
            return *this;
        }

        inline IteratorImpl operator++(int)
        {
            IteratorImpl old = *this;

            operator++();
            return old;
        }

        inline bool operator==(const IteratorImpl& rhs) const
        {
            return elem_ == rhs.elem_;
        }

        inline bool operator!=(const IteratorImpl& rhs) const
        {
            return !operator==(rhs);
        }

    private:
        pointer elem_;
    };

public:
    using value_type     = Fixture;
    using iterator       = IteratorImpl<value_type>;
    using const_iterator = IteratorImpl<const value_type>;

    inline FixtureList()
        : first_(nullptr)
    {
    }

    inline FixtureList(value_type* first)
        : first_(first)
    {
    }

    inline const value_type& front() const
    {
        return *first_;
    }

    inline value_type& front()
    {
        return *first_;
    }

    inline iterator begin()
    {
        return iterator(first_);
    }

    inline const_iterator begin() const
    {
        return cbegin();
    }

    inline const_iterator cbegin() const
    {
        return const_iterator(first_);
    }

    inline iterator end()
    {
        return iterator(nullptr);
    }

    inline const_iterator end() const
    {
        return cend();
    }

    inline const_iterator cend() const
    {
        return const_iterator(nullptr);
    }

private:
    value_type* first_;
};

/** @} */

inline bool Fixture::IsSensor() const
{
    KGE_ASSERT(fixture_);
    return fixture_->IsSensor();
}

inline void Fixture::SetSensor(bool sensor)
{
    KGE_ASSERT(fixture_);
    fixture_->SetSensor(sensor);
}

inline float Fixture::GetDensity() const
{
    KGE_ASSERT(fixture_);
    return fixture_->GetDensity();
}

inline void Fixture::SetDensity(float density)
{
    KGE_ASSERT(fixture_);
    fixture_->SetDensity(density);
}

inline float Fixture::GetFriction() const
{
    KGE_ASSERT(fixture_);
    return fixture_->GetFriction();
}

inline void Fixture::SetFriction(float friction)
{
    KGE_ASSERT(fixture_);
    fixture_->SetFriction(friction);
}

inline float Fixture::GetRestitution() const
{
    KGE_ASSERT(fixture_);
    return fixture_->GetRestitution();
}

inline void Fixture::SetRestitution(float restitution)
{
    KGE_ASSERT(fixture_);
    fixture_->SetRestitution(restitution);
}

inline bool Fixture::IsValid() const
{
    return fixture_ != nullptr;
}

inline b2Fixture* Fixture::GetB2Fixture() const
{
    return fixture_;
}

inline void Fixture::SetB2Fixture(b2Fixture* fixture)
{
    fixture_ = fixture;
}

inline bool Fixture::operator==(const Fixture& rhs) const
{
    return fixture_ == rhs.fixture_;
}

inline bool Fixture::operator!=(const Fixture& rhs) const
{
    return fixture_ != rhs.fixture_;
}

}  // namespace physics
}  // namespace kiwano