File indexing completed on 2025-08-03 03:50:01

 /*
 * Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
 *
 * 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 B2_WORLD_H
 #define B2_WORLD_H
 
 #include <Box2D/Common/b2Math.h>
 #include <Box2D/Common/b2BlockAllocator.h>
 #include <Box2D/Common/b2StackAllocator.h>
 #include <Box2D/Dynamics/b2ContactManager.h>
 #include <Box2D/Dynamics/b2WorldCallbacks.h>
 
 struct b2AABB;
 struct b2BodyDef;
 struct b2JointDef;
 struct b2TimeStep;
 class b2Body;
 class b2Fixture;
 class b2Joint;
 
 /// The world class manages all physics entities, dynamic simulation,
 /// and asynchronous queries. The world also contains efficient memory
 /// management facilities.
 class b2World
 {
 public:
     /// Construct a world object.
     /// @param gravity the world gravity vector.
     /// @param doSleep improve performance by not simulating inactive bodies.
     b2World(const b2Vec2& gravity, bool doSleep);
 
     /// Destruct the world. All physics entities are destroyed and all heap memory is released.
     ~b2World();
 
     /// Register a destruction listener. The listener is owned by you and must
     /// remain in scope.
     void SetDestructionListener(b2DestructionListener* listener);
 
     /// Register a contact filter to provide specific control over collision.
     /// Otherwise the default filter is used (b2_defaultFilter). The listener is
     /// owned by you and must remain in scope. 
     void SetContactFilter(b2ContactFilter* filter);
 
     /// Register a contact event listener. The listener is owned by you and must
     /// remain in scope.
     void SetContactListener(b2ContactListener* listener);
 
     /// Register a routine for debug drawing. The debug draw functions are called
     /// inside with b2World::DrawDebugData method. The debug draw object is owned
     /// by you and must remain in scope.
     void SetDebugDraw(b2DebugDraw* debugDraw);
 
     /// Create a rigid body given a definition. No reference to the definition
     /// is retained.
     /// @warning This function is locked during callbacks.
     b2Body* CreateBody(const b2BodyDef* def);
 
     /// Destroy a rigid body given a definition. No reference to the definition
     /// is retained. This function is locked during callbacks.
     /// @warning This automatically deletes all associated shapes and joints.
     /// @warning This function is locked during callbacks.
     void DestroyBody(b2Body* body);
 
     /// Create a joint to constrain bodies together. No reference to the definition
     /// is retained. This may cause the connected bodies to cease colliding.
     /// @warning This function is locked during callbacks.
     b2Joint* CreateJoint(const b2JointDef* def);
 
     /// Destroy a joint. This may cause the connected bodies to begin colliding.
     /// @warning This function is locked during callbacks.
     void DestroyJoint(b2Joint* joint);
 
     /// Take a time step. This performs collision detection, integration,
     /// and constraint solution.
     /// @param timeStep the amount of time to simulate, this should not vary.
     /// @param velocityIterations for the velocity constraint solver.
     /// @param positionIterations for the position constraint solver.
     void Step(  qreal timeStep,
                 int32 velocityIterations,
                 int32 positionIterations);
 
     /// Manually clear the force buffer on all bodies. By default, forces are cleared automatically
     /// after each call to Step. The default behavior is modified by calling SetAutoClearForces.
     /// The purpose of this function is to support sub-stepping. Sub-stepping is often used to maintain
     /// a fixed sized time step under a variable frame-rate.
     /// When you perform sub-stepping you will disable auto clearing of forces and instead call
     /// ClearForces after all sub-steps are complete in one pass of your game loop.
     /// @see SetAutoClearForces
     void ClearForces();
 
     /// Call this to draw shapes and other debug draw data.
     void DrawDebugData();
 
     /// Query the world for all fixtures that potentially overlap the
     /// provided AABB.
     /// @param callback a user implemented callback class.
     /// @param aabb the query box.
     void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
 
     /// Ray-cast the world for all fixtures in the path of the ray. Your callback
     /// controls whether you get the closest point, any point, or n-points.
     /// The ray-cast ignores shapes that contain the starting point.
     /// @param callback a user implemented callback class.
     /// @param point1 the ray starting point
     /// @param point2 the ray ending point
     void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;
 
     /// Get the world body list. With the returned body, use b2Body::GetNext to get
     /// the next body in the world list. A NULL body indicates the end of the list.
     /// @return the head of the world body list.
     b2Body* GetBodyList();
     const b2Body* GetBodyList() const;
 
     /// Get the world joint list. With the returned joint, use b2Joint::GetNext to get
     /// the next joint in the world list. A NULL joint indicates the end of the list.
     /// @return the head of the world joint list.
     b2Joint* GetJointList();
     const b2Joint* GetJointList() const;
 
     /// Get the world contact list. With the returned contact, use b2Contact::GetNext to get
     /// the next contact in the world list. A NULL contact indicates the end of the list.
     /// @return the head of the world contact list.
     /// @warning contacts are 
     b2Contact* GetContactList();
     const b2Contact* GetContactList() const;
 
     /// Enable/disable warm starting. For testing.
     void SetWarmStarting(bool flag) { m_warmStarting = flag; }
 
     /// Enable/disable continuous physics. For testing.
     void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }
 
     /// Enable/disable single stepped continuous physics. For testing.
     void SetSubStepping(bool flag) { m_subStepping = flag; }
 
     /// Get the number of broad-phase proxies.
     int32 GetProxyCount() const;
 
     /// Get the number of bodies.
     int32 GetBodyCount() const;
 
     /// Get the number of joints.
     int32 GetJointCount() const;
 
     /// Get the number of contacts (each may have 0 or more contact points).
     int32 GetContactCount() const;
 
     /// Change the global gravity vector.
     void SetGravity(const b2Vec2& gravity);
     
     /// Get the global gravity vector.
     b2Vec2 GetGravity() const;
 
     /// Is the world locked (in the middle of a time step).
     bool IsLocked() const;
 
     /// Set flag to control automatic clearing of forces after each time step.
     void SetAutoClearForces(bool flag);
 
     /// Get the flag that controls automatic clearing of forces after each time step.
     bool GetAutoClearForces() const;
 
     /// Get the contact manager for testing.
     const b2ContactManager& GetContactManager() const;
 
 private:
 
     // m_flags
     enum
     {
         e_newFixture    = 0x0001,
         e_locked        = 0x0002,
         e_clearForces   = 0x0004
     };
 
     friend class b2Body;
     friend class b2ContactManager;
     friend class b2Controller;
 
     void Solve(const b2TimeStep& step);
     void SolveTOI(const b2TimeStep& step);
 
     void DrawJoint(b2Joint* joint);
     void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
 
     b2BlockAllocator m_blockAllocator;
     b2StackAllocator m_stackAllocator;
 
     int32 m_flags;
 
     b2ContactManager m_contactManager;
 
     b2Body* m_bodyList;
     b2Joint* m_jointList;
 
     int32 m_bodyCount;
     int32 m_jointCount;
 
     b2Vec2 m_gravity;
     bool m_allowSleep;
 
     b2DestructionListener* m_destructionListener;
     b2DebugDraw* m_debugDraw;
 
     // This is used to compute the time step ratio to
     // support a variable time step.
     qreal m_inv_dt0;
 
     // These are for debugging the solver.
     bool m_warmStarting;
     bool m_continuousPhysics;
     bool m_subStepping;
 
     bool m_stepComplete;
 };
 
 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_flags & e_locked) == e_locked;
 }
 
 inline void b2World::SetAutoClearForces(bool flag)
 {
     if (flag)
     {
         m_flags |= e_clearForces;
     }
     else
     {
         m_flags &= ~e_clearForces;
     }
 }
 
 /// Get the flag that controls automatic clearing of forces after each time step.
 inline bool b2World::GetAutoClearForces() const
 {
     return (m_flags & e_clearForces) == e_clearForces;
 }
 
 inline const b2ContactManager& b2World::GetContactManager() const
 {
     return m_contactManager;
 }
 
 #endif