b2World.h
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:9k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
  3. *
  4. * This software is provided 'as-is', without any express or implied
  5. * warranty.  In no event will the authors be held liable for any damages
  6. * arising from the use of this software.
  7. * Permission is granted to anyone to use this software for any purpose,
  8. * including commercial applications, and to alter it and redistribute it
  9. * freely, subject to the following restrictions:
  10. * 1. The origin of this software must not be misrepresented; you must not
  11. * claim that you wrote the original software. If you use this software
  12. * in a product, an acknowledgment in the product documentation would be
  13. * appreciated but is not required.
  14. * 2. Altered source versions must be plainly marked as such, and must not be
  15. * misrepresented as being the original software.
  16. * 3. This notice may not be removed or altered from any source distribution.
  17. */
  18. #ifndef B2_WORLD_H
  19. #define B2_WORLD_H
  20. #include <Box2D/Common/b2Math.h>
  21. #include <Box2D/Common/b2BlockAllocator.h>
  22. #include <Box2D/Common/b2StackAllocator.h>
  23. #include <Box2D/Dynamics/b2ContactManager.h>
  24. #include <Box2D/Dynamics/b2WorldCallbacks.h>
  25. struct b2AABB;
  26. struct b2BodyDef;
  27. struct b2JointDef;
  28. struct b2TimeStep;
  29. class b2Body;
  30. class b2Fixture;
  31. class b2Joint;
  32. /// The world class manages all physics entities, dynamic simulation,
  33. /// and asynchronous queries. The world also contains efficient memory
  34. /// management facilities.
  35. class b2World
  36. {
  37. public:
  38. /// Construct a world object.
  39. /// @param gravity the world gravity vector.
  40. /// @param doSleep improve performance by not simulating inactive bodies.
  41. b2World(const b2Vec2& gravity, bool doSleep);
  42. /// Destruct the world. All physics entities are destroyed and all heap memory is released.
  43. ~b2World();
  44. /// Register a destruction listener. The listener is owned by you and must
  45. /// remain in scope.
  46. void SetDestructionListener(b2DestructionListener* listener);
  47. /// Register a contact filter to provide specific control over collision.
  48. /// Otherwise the default filter is used (b2_defaultFilter). The listener is
  49. /// owned by you and must remain in scope. 
  50. void SetContactFilter(b2ContactFilter* filter);
  51. /// Register a contact event listener. The listener is owned by you and must
  52. /// remain in scope.
  53. void SetContactListener(b2ContactListener* listener);
  54. /// Register a routine for debug drawing. The debug draw functions are called
  55. /// inside with b2World::DrawDebugData method. The debug draw object is owned
  56. /// by you and must remain in scope.
  57. void SetDebugDraw(b2DebugDraw* debugDraw);
  58. /// Create a rigid body given a definition. No reference to the definition
  59. /// is retained.
  60. /// @warning This function is locked during callbacks.
  61. b2Body* CreateBody(const b2BodyDef* def);
  62. /// Destroy a rigid body given a definition. No reference to the definition
  63. /// is retained. This function is locked during callbacks.
  64. /// @warning This automatically deletes all associated shapes and joints.
  65. /// @warning This function is locked during callbacks.
  66. void DestroyBody(b2Body* body);
  67. /// Create a joint to constrain bodies together. No reference to the definition
  68. /// is retained. This may cause the connected bodies to cease colliding.
  69. /// @warning This function is locked during callbacks.
  70. b2Joint* CreateJoint(const b2JointDef* def);
  71. /// Destroy a joint. This may cause the connected bodies to begin colliding.
  72. /// @warning This function is locked during callbacks.
  73. void DestroyJoint(b2Joint* joint);
  74. /// Take a time step. This performs collision detection, integration,
  75. /// and constraint solution.
  76. /// @param timeStep the amount of time to simulate, this should not vary.
  77. /// @param velocityIterations for the velocity constraint solver.
  78. /// @param positionIterations for the position constraint solver.
  79. void Step( float32 timeStep,
  80. int32 velocityIterations,
  81. int32 positionIterations);
  82. /// Call this after you are done with time steps to clear the forces. You normally
  83. /// call this after each call to Step, unless you are performing sub-steps. By default,
  84. /// forces will be automatically cleared, so you don't need to call this function.
  85. /// @see SetAutoClearForces
  86. void ClearForces();
  87. /// Call this to draw shapes and other debug draw data.
  88. void DrawDebugData();
  89. /// Query the world for all fixtures that potentially overlap the
  90. /// provided AABB.
  91. /// @param callback a user implemented callback class.
  92. /// @param aabb the query box.
  93. void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
  94. /// Ray-cast the world for all fixtures in the path of the ray. Your callback
  95. /// controls whether you get the closest point, any point, or n-points.
  96. /// The ray-cast ignores shapes that contain the starting point.
  97. /// @param callback a user implemented callback class.
  98. /// @param point1 the ray starting point
  99. /// @param point2 the ray ending point
  100. void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;
  101. /// Get the world body list. With the returned body, use b2Body::GetNext to get
  102. /// the next body in the world list. A NULL body indicates the end of the list.
  103. /// @return the head of the world body list.
  104. b2Body* GetBodyList();
  105. /// Get the world joint list. With the returned joint, use b2Joint::GetNext to get
  106. /// the next joint in the world list. A NULL joint indicates the end of the list.
  107. /// @return the head of the world joint list.
  108. b2Joint* GetJointList();
  109. /// Get the world contact list. With the returned contact, use b2Contact::GetNext to get
  110. /// the next contact in the world list. A NULL contact indicates the end of the list.
  111. /// @return the head of the world contact list.
  112. /// @warning contacts are 
  113. b2Contact* GetContactList();
  114. /// Enable/disable warm starting. For testing.
  115. void SetWarmStarting(bool flag) { m_warmStarting = flag; }
  116. /// Enable/disable continuous physics. For testing.
  117. void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }
  118. /// Get the number of broad-phase proxies.
  119. int32 GetProxyCount() const;
  120. /// Get the number of bodies.
  121. int32 GetBodyCount() const;
  122. /// Get the number of joints.
  123. int32 GetJointCount() const;
  124. /// Get the number of contacts (each may have 0 or more contact points).
  125. int32 GetContactCount() const;
  126. /// Change the global gravity vector.
  127. void SetGravity(const b2Vec2& gravity);
  128. /// Get the global gravity vector.
  129. b2Vec2 GetGravity() const;
  130. /// Is the world locked (in the middle of a time step).
  131. bool IsLocked() const;
  132. /// Set flag to control automatic clearing of forces after each time step.
  133. void SetAutoClearForces(bool flag);
  134. /// Get the flag that controls automatic clearing of forces after each time step.
  135. bool GetAutoClearForces() const;
  136. private:
  137. // m_flags
  138. enum
  139. {
  140. e_newFixture = 0x0001,
  141. e_locked = 0x0002,
  142. e_clearForces = 0x0004,
  143. };
  144. friend class b2Body;
  145. friend class b2ContactManager;
  146. friend class b2Controller;
  147. void Solve(const b2TimeStep& step);
  148. void SolveTOI();
  149. void SolveTOI(b2Body* body);
  150. void DrawJoint(b2Joint* joint);
  151. void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
  152. b2BlockAllocator m_blockAllocator;
  153. b2StackAllocator m_stackAllocator;
  154. int32 m_flags;
  155. b2ContactManager m_contactManager;
  156. b2Body* m_bodyList;
  157. b2Joint* m_jointList;
  158. int32 m_bodyCount;
  159. int32 m_jointCount;
  160. b2Vec2 m_gravity;
  161. bool m_allowSleep;
  162. b2Body* m_groundBody;
  163. b2DestructionListener* m_destructionListener;
  164. b2DebugDraw* m_debugDraw;
  165. // This is used to compute the time step ratio to
  166. // support a variable time step.
  167. float32 m_inv_dt0;
  168. // This is for debugging the solver.
  169. bool m_warmStarting;
  170. // This is for debugging the solver.
  171. bool m_continuousPhysics;
  172. };
  173. inline b2Body* b2World::GetBodyList()
  174. {
  175. return m_bodyList;
  176. }
  177. inline b2Joint* b2World::GetJointList()
  178. {
  179. return m_jointList;
  180. }
  181. inline b2Contact* b2World::GetContactList()
  182. {
  183. return m_contactManager.m_contactList;
  184. }
  185. inline int32 b2World::GetBodyCount() const
  186. {
  187. return m_bodyCount;
  188. }
  189. inline int32 b2World::GetJointCount() const
  190. {
  191. return m_jointCount;
  192. }
  193. inline int32 b2World::GetContactCount() const
  194. {
  195. return m_contactManager.m_contactCount;
  196. }
  197. inline void b2World::SetGravity(const b2Vec2& gravity)
  198. {
  199. m_gravity = gravity;
  200. }
  201. inline b2Vec2 b2World::GetGravity() const
  202. {
  203. return m_gravity;
  204. }
  205. inline bool b2World::IsLocked() const
  206. {
  207. return (m_flags & e_locked) == e_locked;
  208. }
  209. inline void b2World::SetAutoClearForces(bool flag)
  210. {
  211. if (flag)
  212. {
  213. m_flags |= e_clearForces;
  214. }
  215. else
  216. {
  217. m_flags &= ~e_clearForces;
  218. }
  219. }
  220. /// Get the flag that controls automatic clearing of forces after each time step.
  221. inline bool b2World::GetAutoClearForces() const
  222. {
  223. return (m_flags & e_clearForces) == e_clearForces;
  224. }
  225. #endif