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

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2007 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_CONTROLLER_H
  19. #define B2_CONTROLLER_H
  20. #include "../../Dynamics/b2World.h"
  21. #include "../../Dynamics/b2Body.h"
  22. class b2Body;
  23. class b2World;
  24. class b2Controller;
  25. /// A controller edge is used to connect bodies and controllers together
  26. /// in a bipartite graph.
  27. struct b2ControllerEdge
  28. {
  29. b2Controller* controller; ///< provides quick access to other end of this edge.
  30. b2Body* body; ///< the body
  31. b2ControllerEdge* prevBody; ///< the previous controller edge in the controllers's joint list
  32. b2ControllerEdge* nextBody; ///< the next controller edge in the controllers's joint list
  33. b2ControllerEdge* prevController; ///< the previous controller edge in the body's joint list
  34. b2ControllerEdge* nextController; ///< the next controller edge in the body's joint list
  35. };
  36. class b2ControllerDef;
  37. /// Base class for controllers. Controllers are a convience for encapsulating common
  38. /// per-step functionality.
  39. class b2Controller
  40. {
  41. public:
  42. virtual ~b2Controller();
  43. /// Controllers override this to implement per-step functionality.
  44. virtual void Step(const b2TimeStep& step) = 0;
  45. /// Controllers override this to provide debug drawing.
  46. virtual void Draw(b2DebugDraw *debugDraw) {B2_NOT_USED(debugDraw);};
  47. /// Adds a body to the controller list.
  48. void AddBody(b2Body* body);
  49. /// Removes a body from the controller list.
  50. void RemoveBody(b2Body* body);
  51. /// Removes all bodies from the controller list.
  52. void Clear();
  53. /// Get the next controller in the world's body list.
  54. b2Controller* GetNext();
  55. const b2Controller* GetNext() const;
  56. /// Get the parent world of this body.
  57. b2World* GetWorld();
  58. const b2World* GetWorld() const;
  59. /// Get the attached body list
  60. b2ControllerEdge* GetBodyList();
  61. const b2ControllerEdge* GetBodyList() const;
  62. protected:
  63. friend class b2World;
  64. b2World* m_world;
  65. b2ControllerEdge* m_bodyList;
  66. int32 m_bodyCount;
  67. b2Controller(const b2ControllerDef* def):
  68. m_world(NULL),
  69. m_bodyList(NULL),
  70. m_bodyCount(0),
  71. m_prev(NULL),
  72. m_next(NULL)
  73. {
  74. B2_NOT_USED(def);
  75. }
  76. virtual void Destroy(b2BlockAllocator* allocator) = 0;
  77. private:
  78. b2Controller* m_prev;
  79. b2Controller* m_next;
  80. static void Destroy(b2Controller* controller, b2BlockAllocator* allocator);
  81. };
  82. class b2ControllerDef
  83. {
  84. public:
  85. virtual ~b2ControllerDef() {};
  86. private:
  87. friend class b2World;
  88. virtual b2Controller* Create(b2BlockAllocator* allocator) const = 0;
  89. };
  90. inline b2Controller* b2Controller::GetNext()
  91. {
  92. return m_next;
  93. }
  94. inline const b2Controller* b2Controller::GetNext() const
  95. {
  96. return m_next;
  97. }
  98. inline b2World* b2Controller::GetWorld()
  99. {
  100. return m_world;
  101. }
  102. inline const b2World* b2Controller::GetWorld() const
  103. {
  104. return m_world;
  105. }
  106. inline b2ControllerEdge* b2Controller::GetBodyList()
  107. {
  108. return m_bodyList;
  109. }
  110. inline const b2ControllerEdge* b2Controller::GetBodyList() const
  111. {
  112. return m_bodyList;
  113. }
  114. inline void b2Controller::Destroy(b2Controller* controller, b2BlockAllocator* allocator)
  115. {
  116. controller->Destroy(allocator);
  117. }
  118. #endif