b2_world.h

// MIT License
 
// Copyright (c) 2019 Erin Catto
 
// 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.
 
#ifndef B2_WORLD_H
#define B2_WORLD_H
 
#include "b2_api.h"
#include "b2_block_allocator.h"
#include "b2_contact_manager.h"
#include "b2_math.h"
#include "b2_stack_allocator.h"
#include "b2_time_step.h"
#include "b2_world_callbacks.h"
 
struct b2AABB;
struct b2BodyDef;
struct b2Color;
struct b2JointDef;
class b2Body;
class b2Draw;
class b2Fixture;
class b2Joint;
 
class B2_API b2World
{
public:
    b2World(const b2Vec2& gravity);
 
    ~b2World();
 
    void SetDestructionListener(b2DestructionListener* listener);
 
    void SetContactFilter(b2ContactFilter* filter);
 
    void SetContactListener(b2ContactListener* listener);
 
    void SetDebugDraw(b2Draw* debugDraw);
 
    b2Body* CreateBody(const b2BodyDef* def);
 
    void DestroyBody(b2Body* body);
 
    b2Joint* CreateJoint(const b2JointDef* def);
 
    void DestroyJoint(b2Joint* joint);
 
    void Step(  float timeStep,
                int32 velocityIterations,
                int32 positionIterations);
 
    void ClearForces();
 
    void DebugDraw();
 
    void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
 
    void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;
 
    b2Body* GetBodyList();
    const b2Body* GetBodyList() const;
 
    b2Joint* GetJointList();
    const b2Joint* GetJointList() const;
 
    b2Contact* GetContactList();
    const b2Contact* GetContactList() const;
 
    void SetAllowSleeping(bool flag);
    bool GetAllowSleeping() const { return m_allowSleep; }
 
    void SetWarmStarting(bool flag) { m_warmStarting = flag; }
    bool GetWarmStarting() const { return m_warmStarting; }
 
    void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }
    bool GetContinuousPhysics() const { return m_continuousPhysics; }
 
    void SetSubStepping(bool flag) { m_subStepping = flag; }
    bool GetSubStepping() const { return m_subStepping; }
 
    int32 GetProxyCount() const;
 
    int32 GetBodyCount() const;
 
    int32 GetJointCount() const;
 
    int32 GetContactCount() const;
 
    int32 GetTreeHeight() const;
 
    int32 GetTreeBalance() const;
 
    float GetTreeQuality() const;
 
    void SetGravity(const b2Vec2& gravity);
 
    b2Vec2 GetGravity() const;
 
    bool IsLocked() const;
 
    void SetAutoClearForces(bool flag);
 
    bool GetAutoClearForces() const;
 
    void ShiftOrigin(const b2Vec2& newOrigin);
 
    const b2ContactManager& GetContactManager() const;
 
    const b2Profile& GetProfile() const;
 
    void Dump();
 
private:
 
    friend class b2Body;
    friend class b2Fixture;
    friend class b2ContactManager;
    friend class b2Controller;
 
    b2World(const b2World&) = delete;
    void operator=(const b2World&) = delete;
 
    void Solve(const b2TimeStep& step);
    void SolveTOI(const b2TimeStep& step);
 
    void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
 
    b2BlockAllocator m_blockAllocator;
    b2StackAllocator m_stackAllocator;
 
    b2ContactManager m_contactManager;
 
    b2Body* m_bodyList;
    b2Joint* m_jointList;
 
    int32 m_bodyCount;
    int32 m_jointCount;
 
    b2Vec2 m_gravity;
    bool m_allowSleep;
 
    b2DestructionListener* m_destructionListener;
    b2Draw* m_debugDraw;
 
    // This is used to compute the time step ratio to
    // support a variable time step.
    float m_inv_dt0;
 
    bool m_newContacts;
    bool m_locked;
    bool m_clearForces;
 
    // These are for debugging the solver.
    bool m_warmStarting;
    bool m_continuousPhysics;
    bool m_subStepping;
 
    bool m_stepComplete;
 
    b2Profile m_profile;
};
 
inline b2Body* b2World::GetBodyList()
{
    return m_bodyList;
}
 
inline const b2Body* b2World::GetBodyList() const
{
    return m_bodyList;
}
 
inline b2Joint* b2World::GetJointList()
{
    return m_jointList;
}
 
inline const b2Joint* b2World::GetJointList() const
{
    return m_jointList;
}
 
inline b2Contact* b2World::GetContactList()
{
    return m_contactManager.m_contactList;
}
 
inline const b2Contact* b2World::GetContactList() const
{
    return m_contactManager.m_contactList;
}
 
inline int32 b2World::GetBodyCount() const
{
    return m_bodyCount;
}
 
inline int32 b2World::GetJointCount() const
{
    return m_jointCount;
}
 
inline int32 b2World::GetContactCount() const
{
    return m_contactManager.m_contactCount;
}
 
inline void b2World::SetGravity(const b2Vec2& gravity)
{
    m_gravity = gravity;
}
 
inline b2Vec2 b2World::GetGravity() const
{
    return m_gravity;
}
 
inline bool b2World::IsLocked() const
{
    return m_locked;
}
 
inline void b2World::SetAutoClearForces(bool flag)
{
    m_clearForces = flag;
}
 
inline bool b2World::GetAutoClearForces() const
{
    return m_clearForces;
}
 
inline const b2ContactManager& b2World::GetContactManager() const
{
    return m_contactManager;
}
 
inline const b2Profile& b2World::GetProfile() const
{
    return m_profile;
}
 
#endif