PhysicBody.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/Fixture.h>
#include <kiwano-physics/ContactEdge.h>
 
namespace kiwano
{
namespace physics
{
 
class PhysicWorld;
 
class KGE_API PhysicBody : public Component
{
    friend class PhysicWorld;
 
public:
    enum class Type
    {
        Static = 0,  
        Kinematic,   
        Dynamic,     
    };
 
    PhysicBody(PhysicWorld* world, Type type);
 
    PhysicBody(PhysicWorldPtr world, Type type);
 
    virtual ~PhysicBody();
 
    bool Init(PhysicWorld* world);
 
    void AddFixture(FixturePtr fixture);
 
    Fixture* AddCircleShape(float radius, float density, float friction = 0.2f);
 
    Fixture* AddRectShape(const Vec2& size, float density, float friction = 0.2f);
 
    Fixture* AddPolygonShape(const Vector<Point>& vertexs, float density, float friction = 0.2f);
 
    Fixture* AddEdgeShape(const Point& p1, const Point& p2, float density, float friction = 0.2f);
 
    Fixture* AddChainShape(const Vector<Point>& vertices, bool loop, float density, float friction = 0.2f);
 
    void RemoveFixture(FixturePtr fixture);
 
    void RemoveAllFixtures();
 
    FixtureList GetFixtureList() const;
 
    ContactEdgeList GetContactList() const;
 
    uint16_t GetCategoryBits() const;
 
    void SetCategoryBits(uint16_t category_bits);
 
    uint16_t GetMaskBits() const;
 
    void SetMaskBits(uint16_t mask_bits);
 
    int16_t GetGroupIndex() const;
 
    void SetGroupIndex(int16_t index);
 
    float GetRotation() const;
 
    void SetRotation(float angle);
 
    Point GetPosition() const;
 
    void SetPosition(const Point& pos);
 
    void SetTransform(const Point& pos, float angle);
 
    float GetMass() const;
 
    float GetInertia() const;
 
    void GetMassData(float* mass, Point* center, float* inertia) const;
 
    void SetMassData(float mass, const Point& center, float inertia);
 
    void ResetMassData();
 
    Point GetLocalPoint(const Point& world) const;
 
    Vec2 GetLocalVector(const Vec2& world) const;
 
    Point GetWorldPoint(const Point& local) const;
 
    Vec2 GetWorldVector(const Vec2& local) const;
 
    Point GetLocalCenter() const;
 
    Point GetWorldCenter() const;
 
    Type GetType() const;
 
    void SetType(Type type);
 
    float GetGravityScale() const;
 
    void SetGravityScale(float scale);
 
    float GetLinearDamping() const;
 
    void SetLinearDamping(float damping);
 
    float GetAngularDamping() const;
 
    void SetAngularDamping(float damping);
 
    void ApplyForce(const Vec2& force, const Point& point, bool wake = true);
 
    void ApplyForceToCenter(const Vec2& force, bool wake = true);
 
    void ApplyTorque(float torque, bool wake = false);
 
    bool IsIgnoreRotation() const;
 
    void SetIgnoreRotation(bool flag);
 
    bool IsBullet() const;
 
    void SetBullet(bool flag);
 
    bool IsAwake() const;
 
    void SetAwake(bool flag);
 
    bool IsSleepingAllowed() const;
 
    void SetSleepingAllowed(bool flag);
 
    bool IsActive() const;
 
    void SetActive(bool flag);
 
    PhysicWorld* GetWorld() const;
 
    void Destroy();
 
    b2Body* GetB2Body() const;
 
    void SetB2Body(b2Body* body);
 
protected:
    void InitComponent(Actor* actor) override;
 
    void DestroyComponent() override;
 
    void UpdateFromActor(Actor* actor);
 
    void UpdateFromActor(Actor* actor, const Matrix3x2& actor_to_world, float parent_rotation);
 
    void UpdateFixtureFilter(b2Fixture* fixture);
 
    void BeforeSimulation(Actor* actor, const Matrix3x2& parent_to_world, const Matrix3x2& actor_to_world,
                          float parent_rotation);
 
    void AfterSimulation(Actor* actorconst, const Matrix3x2& parent_to_world, float parent_rotation);
 
private:
    PhysicWorld* world_;
    b2Body*      body_;
    uint16_t     category_bits_;
    uint16_t     mask_bits_;
    int16_t      group_index_;
 
    PhysicBody::Type   type_;
    Vector<FixturePtr> fixtures_;
 
    Point offset_;
    Point position_cached_;
};
 
inline FixtureList PhysicBody::GetFixtureList() const
{
    KGE_ASSERT(body_);
 
    if (!body_->GetFixtureList())
        return FixtureList();
 
    Fixture* fixture = static_cast<Fixture*>(body_->GetFixtureList()->GetUserData());
    return FixtureList(fixture);
}
 
inline ContactEdgeList PhysicBody::GetContactList() const
{
    KGE_ASSERT(body_);
    ContactEdge edge;
    edge.SetB2ContactEdge(body_->GetContactList());
    return ContactEdgeList(edge);
}
 
inline uint16_t PhysicBody::GetCategoryBits() const
{
    return category_bits_;
}
 
inline uint16_t PhysicBody::GetMaskBits() const
{
    return mask_bits_;
}
 
inline int16_t PhysicBody::GetGroupIndex() const
{
    return group_index_;
}
 
inline float PhysicBody::GetRotation() const
{
    KGE_ASSERT(body_);
    return math::Radian2Degree(body_->GetAngle());
}
 
inline void PhysicBody::SetRotation(float angle)
{
    SetTransform(GetPosition(), angle);
}
 
inline void PhysicBody::SetPosition(const Point& pos)
{
    SetTransform(pos, GetRotation());
}
 
inline float PhysicBody::GetMass() const
{
    KGE_ASSERT(body_);
    return body_->GetMass();
}
 
inline float PhysicBody::GetInertia() const
{
    KGE_ASSERT(body_);
    return body_->GetInertia();
}
 
inline PhysicBody::Type PhysicBody::GetType() const
{
    return type_;
}
 
inline void PhysicBody::SetType(Type type)
{
    if (type_ != type)
    {
        type_ = type;
        if (body_)
        {
            body_->SetType(b2BodyType(type));
        }
    }
}
 
inline float PhysicBody::GetGravityScale() const
{
    KGE_ASSERT(body_);
    return body_->GetGravityScale();
}
 
inline void PhysicBody::SetGravityScale(float scale)
{
    KGE_ASSERT(body_);
    body_->SetGravityScale(scale);
}
 
inline float PhysicBody::GetLinearDamping() const
{
    KGE_ASSERT(body_);
    return body_->GetLinearDamping();
}
 
inline void PhysicBody::SetLinearDamping(float damping)
{
    KGE_ASSERT(body_);
    body_->SetLinearDamping(damping);
}
 
inline float PhysicBody::GetAngularDamping() const
{
    KGE_ASSERT(body_);
    return body_->GetAngularDamping();
}
 
inline void PhysicBody::SetAngularDamping(float damping)
{
    KGE_ASSERT(body_);
    body_->SetAngularDamping(damping);
}
 
inline bool PhysicBody::IsIgnoreRotation() const
{
    KGE_ASSERT(body_);
    return body_->IsFixedRotation();
}
 
inline void PhysicBody::SetIgnoreRotation(bool flag)
{
    KGE_ASSERT(body_);
    body_->SetFixedRotation(flag);
}
 
inline bool PhysicBody::IsBullet() const
{
    KGE_ASSERT(body_);
    return body_->IsBullet();
}
 
inline void PhysicBody::SetBullet(bool flag)
{
    KGE_ASSERT(body_);
    body_->SetBullet(flag);
}
 
inline bool PhysicBody::IsAwake() const
{
    KGE_ASSERT(body_);
    return body_->IsAwake();
}
 
inline void PhysicBody::SetAwake(bool flag)
{
    KGE_ASSERT(body_);
    body_->SetAwake(flag);
}
 
inline bool PhysicBody::IsSleepingAllowed() const
{
    KGE_ASSERT(body_);
    return body_->IsSleepingAllowed();
}
 
inline void PhysicBody::SetSleepingAllowed(bool flag)
{
    KGE_ASSERT(body_);
    body_->SetSleepingAllowed(flag);
}
 
inline bool PhysicBody::IsActive() const
{
    KGE_ASSERT(body_);
    return body_->IsActive();
}
 
inline void PhysicBody::SetActive(bool flag)
{
    KGE_ASSERT(body_);
    body_->SetActive(flag);
}
 
inline b2Body* PhysicBody::GetB2Body() const
{
    return body_;
}
 
inline PhysicWorld* PhysicBody::GetWorld() const
{
    return world_;
}
 
}  // namespace physics
}  // namespace kiwano