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

游戏引擎

开发平台:

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_CALLBACKS_H
  19. #define B2_WORLD_CALLBACKS_H
  20. #include <Box2D/Common/b2Settings.h>
  21. struct b2Vec2;
  22. struct b2Transform;
  23. class b2Fixture;
  24. class b2Body;
  25. class b2Joint;
  26. class b2Contact;
  27. struct b2ContactPoint;
  28. struct b2ContactResult;
  29. struct b2Manifold;
  30. /// Joints and fixtures are destroyed when their associated
  31. /// body is destroyed. Implement this listener so that you
  32. /// may nullify references to these joints and shapes.
  33. class b2DestructionListener
  34. {
  35. public:
  36. virtual ~b2DestructionListener() {}
  37. /// Called when any joint is about to be destroyed due
  38. /// to the destruction of one of its attached bodies.
  39. virtual void SayGoodbye(b2Joint* joint) = 0;
  40. /// Called when any fixture is about to be destroyed due
  41. /// to the destruction of its parent body.
  42. virtual void SayGoodbye(b2Fixture* fixture) = 0;
  43. };
  44. /// Implement this class to provide collision filtering. In other words, you can implement
  45. /// this class if you want finer control over contact creation.
  46. class b2ContactFilter
  47. {
  48. public:
  49. virtual ~b2ContactFilter() {}
  50. /// Return true if contact calculations should be performed between these two shapes.
  51. /// @warning for performance reasons this is only called when the AABBs begin to overlap.
  52. virtual bool ShouldCollide(b2Fixture* fixtureA, b2Fixture* fixtureB);
  53. };
  54. /// Contact impulses for reporting. Impulses are used instead of forces because
  55. /// sub-step forces may approach infinity for rigid body collisions. These
  56. /// match up one-to-one with the contact points in b2Manifold.
  57. struct b2ContactImpulse
  58. {
  59. float32 normalImpulses[b2_maxManifoldPoints];
  60. float32 tangentImpulses[b2_maxManifoldPoints];
  61. };
  62. /// Implement this class to get contact information. You can use these results for
  63. /// things like sounds and game logic. You can also get contact results by
  64. /// traversing the contact lists after the time step. However, you might miss
  65. /// some contacts because continuous physics leads to sub-stepping.
  66. /// Additionally you may receive multiple callbacks for the same contact in a
  67. /// single time step.
  68. /// You should strive to make your callbacks efficient because there may be
  69. /// many callbacks per time step.
  70. /// @warning You cannot create/destroy Box2D entities inside these callbacks.
  71. class b2ContactListener
  72. {
  73. public:
  74. virtual ~b2ContactListener() {}
  75. /// Called when two fixtures begin to touch.
  76. virtual void BeginContact(b2Contact* contact) { B2_NOT_USED(contact); }
  77. /// Called when two fixtures cease to touch.
  78. virtual void EndContact(b2Contact* contact) { B2_NOT_USED(contact); }
  79. /// This is called after a contact is updated. This allows you to inspect a
  80. /// contact before it goes to the solver. If you are careful, you can modify the
  81. /// contact manifold (e.g. disable contact).
  82. /// A copy of the old manifold is provided so that you can detect changes.
  83. /// Note: this is called only for awake bodies.
  84. /// Note: this is called even when the number of contact points is zero.
  85. /// Note: this is not called for sensors.
  86. /// Note: if you set the number of contact points to zero, you will not
  87. /// get an EndContact callback. However, you may get a BeginContact callback
  88. /// the next step.
  89. virtual void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
  90. {
  91. B2_NOT_USED(contact);
  92. B2_NOT_USED(oldManifold);
  93. }
  94. /// This lets you inspect a contact after the solver is finished. This is useful
  95. /// for inspecting impulses.
  96. /// Note: the contact manifold does not include time of impact impulses, which can be
  97. /// arbitrarily large if the sub-step is small. Hence the impulse is provided explicitly
  98. /// in a separate data structure.
  99. /// Note: this is only called for contacts that are touching, solid, and awake.
  100. virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
  101. {
  102. B2_NOT_USED(contact);
  103. B2_NOT_USED(impulse);
  104. }
  105. };
  106. /// Callback class for AABB queries.
  107. /// See b2World::Query
  108. class b2QueryCallback
  109. {
  110. public:
  111. virtual ~b2QueryCallback() {}
  112. /// Called for each fixture found in the query AABB.
  113. /// @return false to terminate the query.
  114. virtual bool ReportFixture(b2Fixture* fixture) = 0;
  115. };
  116. /// Callback class for ray casts.
  117. /// See b2World::RayCast
  118. class b2RayCastCallback
  119. {
  120. public:
  121. virtual ~b2RayCastCallback() {}
  122. /// Called for each fixture found in the query. You control how the ray cast
  123. /// proceeds by returning a float:
  124. /// return -1: ignore this fixture and continue
  125. /// return 0: terminate the ray cast
  126. /// return fraction: clip the ray to this point
  127. /// return 1: don't clip the ray and continue
  128. /// @param fixture the fixture hit by the ray
  129. /// @param point the point of initial intersection
  130. /// @param normal the normal vector at the point of intersection
  131. /// @return -1 to filter, 0 to terminate, fraction to clip the ray for
  132. /// closest hit, 1 to continue
  133. virtual float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
  134. const b2Vec2& normal, float32 fraction) = 0;
  135. };
  136. /// Color for debug drawing. Each value has the range [0,1].
  137. struct b2Color
  138. {
  139. b2Color() {}
  140. b2Color(float32 r, float32 g, float32 b) : r(r), g(g), b(b) {}
  141. void Set(float32 ri, float32 gi, float32 bi) { r = ri; g = gi; b = bi; }
  142. float32 r, g, b;
  143. };
  144. /// Implement and register this class with a b2World to provide debug drawing of physics
  145. /// entities in your game.
  146. class b2DebugDraw
  147. {
  148. public:
  149. b2DebugDraw();
  150. virtual ~b2DebugDraw() {}
  151. enum
  152. {
  153. e_shapeBit = 0x0001, ///< draw shapes
  154. e_jointBit = 0x0002, ///< draw joint connections
  155. e_aabbBit = 0x0004, ///< draw axis aligned bounding boxes
  156. e_pairBit = 0x0008, ///< draw broad-phase pairs
  157. e_centerOfMassBit = 0x0010, ///< draw center of mass frame
  158. };
  159. /// Set the drawing flags.
  160. void SetFlags(uint32 flags);
  161. /// Get the drawing flags.
  162. uint32 GetFlags() const;
  163. /// Append flags to the current flags.
  164. void AppendFlags(uint32 flags);
  165. /// Clear flags from the current flags.
  166. void ClearFlags(uint32 flags);
  167. /// Draw a closed polygon provided in CCW order.
  168. virtual void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
  169. /// Draw a solid closed polygon provided in CCW order.
  170. virtual void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
  171. /// Draw a circle.
  172. virtual void DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color) = 0;
  173. /// Draw a solid circle.
  174. virtual void DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) = 0;
  175. /// Draw a line segment.
  176. virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) = 0;
  177. /// Draw a transform. Choose your own length scale.
  178. /// @param xf a transform.
  179. virtual void DrawTransform(const b2Transform& xf) = 0;
  180. protected:
  181. uint32 m_drawFlags;
  182. };
  183. #endif