d2Body.h

Go to the documentation of this file.

#ifndef BODY_H
#define BODY_H
 
#include "d2api.h"
 
#include "d2Shape.h"
#include "d2Math.h"
#include "d2Types.h"
 
// Forward declarations
class d2World;
struct d2AABB;
 
// enums
enum d2BodyType
{
    d2_staticBody = 0,      //< A static body does not move or rotate.
    d2_dynamicBody      //< A dynamic body is fully simulated.
};
 
class D2_API d2Body
{
public:
    d2Body(const d2Shape &shape, real x, real y, real mass, d2World* world);
 
    ~d2Body();
 
    void ComputeAABB();
 
    void AddForce(const d2Vec2 &force);
 
    void AddTorque(real torque);
 
    void ClearForces();
 
    void ClearTorque();
 
    d2Vec2 LocalSpaceToWorldSpace(const d2Vec2 &point) const;
 
    d2Vec2 WorldSpaceToLocalSpace(const d2Vec2 &point) const;
 
    void ApplyImpulseLinear(const d2Vec2 &j);
 
    void ApplyImpulseAngular(const real j);
 
    void ApplyImpulseAtPoint(const d2Vec2 &j, const d2Vec2 &r);
 
    void IntegrateLinear(real dt);
 
    void IntegrateAngular(real dt);
 
    void IntegrateForces(const real dt);
 
    void IntegrateVelocities(const real dt);
 
    inline const d2Vec2& GetPosition() const;
 
    inline void SetPosition(const d2Vec2& position);
 
    inline const d2Vec2& GetVelocity() const;
 
    inline void SetAcceleration(const d2Vec2& acceleration);
 
    inline void SetAngularVelocity(real angularVelocity);
 
    inline real GetAngularVelocity() const;
 
    inline real GetRotation() const;
 
    inline real GetMass() const;
 
    inline real GetInvMass() const;
 
    inline real GetI() const;
 
    inline real GetInvI() const;
 
    inline void SetFriction(real friction);
 
    inline real GetFriction() const;
 
    inline void SetRestitution(real restitution);
 
    inline real GetRestitution() const;
 
    inline d2Shape* GetShape() const;
 
    inline d2AABB* GetAABB() const;
 
    inline d2Body* GetNext();
    inline const d2Body* GetNext() const;
 
    inline d2Body* GetPrev();
    inline const d2Body* GetPrev() const;
 
    inline real GetSleepTime() const;
 
    inline bool IsAwake() const;
 
    inline void SetAwake(bool awake);
 
    inline real GetGravityScale() const;
 
    inline void SetGravityScale(real gravityScale);
 
private:
    friend class d2World;
 
    enum
    {
        e_awakeFlag = 0x0001
    };
 
    uint16 m_flags{};
    d2BodyType m_type{};
 
    d2Transform m_transform; 
 
    d2Vec2 velocity {}; 
    d2Vec2 acceleration {}; 
 
    real m_gravityScale{ 1.0f }; 
 
    real angularVelocity {}; 
    real angularAcceleration {}; 
 
    d2Vec2 sumForces {}; 
    real sumTorque {}; 
 
    real mass {}; 
    real invMass {}; 
    real I {}; 
    real invI {}; 
 
    real restitution {}; 
 
    real friction {}; 
 
    d2AABB *aabb { nullptr }; 
 
    d2Shape *shape { nullptr }; 
 
    d2World* world { nullptr }; 
    d2Body* prev { nullptr }; 
    d2Body* next { nullptr }; 
 
    real m_sleepTime{}; 
};
 
inline const d2Vec2& d2Body::GetPosition() const
{
    return m_transform.p;
}
 
inline void d2Body::SetPosition(const d2Vec2& position)
{
    m_transform.p = position;
}
 
inline const d2Vec2& d2Body::GetVelocity() const
{
    return velocity;
}
 
inline void d2Body::SetAcceleration(const d2Vec2& acceleration)
{
    this->acceleration = acceleration;
}
 
inline void d2Body::SetAngularVelocity(real angularVelocity)
{
    this->angularVelocity = angularVelocity;
}
 
inline real d2Body::GetAngularVelocity() const
{
    return angularVelocity;
}
 
inline real d2Body::GetRotation() const
{
    return m_transform.q.GetAngle();
}
 
inline real d2Body::GetMass() const
{
    return mass;
}
 
inline real d2Body::GetInvMass() const
{
    return invMass;
}
 
inline real d2Body::GetI() const
{
    return I;
}
 
inline real d2Body::GetInvI() const
{
    return invI;
}
 
inline void d2Body::SetFriction(real friction)
{
    this->friction = friction;
}
 
inline real d2Body::GetFriction() const
{
    return friction;
}
 
inline void d2Body::SetRestitution(real restitution)
{
    this->restitution = restitution;
}
 
inline real d2Body::GetRestitution() const
{
    return restitution;
}
 
inline d2Shape* d2Body::GetShape() const
{
    return shape;
}
 
inline d2AABB* d2Body::GetAABB() const
{
    return aabb;
}
 
inline d2Body* d2Body::GetNext()
{
    return next;
}
 
inline const d2Body* d2Body::GetNext() const
{
    return next;
}
 
inline d2Body* d2Body::GetPrev()
{
    return prev;
}
 
inline const d2Body* d2Body::GetPrev() const
{
    return prev;
}
 
inline real d2Body::GetSleepTime() const
{
    return m_sleepTime;
}
 
inline real d2Body::GetGravityScale() const
{
    return m_gravityScale;
}
 
inline void d2Body::SetGravityScale(real gravityScale)
{
    m_gravityScale = gravityScale;
}
 
inline bool d2Body::IsAwake() const
{
    return (m_flags & e_awakeFlag) == e_awakeFlag;
}
 
inline void d2Body::SetAwake(bool awake)
{
    if (awake)
    {
        m_flags |= e_awakeFlag;
        m_sleepTime = 0.0f;
    }
    else
    {
        m_flags &= ~e_awakeFlag;
        m_sleepTime = 0.0f;
        velocity = d2Vec2(0, 0);
        angularVelocity = 0.0f;
        sumForces = d2Vec2(0, 0);
        sumTorque = 0.0f;
    }
}
 
#endif