b2Fixture.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_FIXTURE_H
  19. #define B2_FIXTURE_H
  20. #include <Box2D/Dynamics/b2Body.h>
  21. #include <Box2D/Collision/b2Collision.h>
  22. #include <Box2D/Collision/Shapes/b2Shape.h>
  23. class b2BlockAllocator;
  24. class b2Body;
  25. class b2BroadPhase;
  26. /// This holds contact filtering data.
  27. struct b2Filter
  28. {
  29. /// The collision category bits. Normally you would just set one bit.
  30. uint16 categoryBits;
  31. /// The collision mask bits. This states the categories that this
  32. /// shape would accept for collision.
  33. uint16 maskBits;
  34. /// Collision groups allow a certain group of objects to never collide (negative)
  35. /// or always collide (positive). Zero means no collision group. Non-zero group
  36. /// filtering always wins against the mask bits.
  37. int16 groupIndex;
  38. };
  39. /// A fixture definition is used to create a fixture. This class defines an
  40. /// abstract fixture definition. You can reuse fixture definitions safely.
  41. struct b2FixtureDef
  42. {
  43. /// The constructor sets the default fixture definition values.
  44. b2FixtureDef()
  45. {
  46. shape = NULL;
  47. userData = NULL;
  48. friction = 0.2f;
  49. restitution = 0.0f;
  50. density = 0.0f;
  51. filter.categoryBits = 0x0001;
  52. filter.maskBits = 0xFFFF;
  53. filter.groupIndex = 0;
  54. isSensor = false;
  55. }
  56. virtual ~b2FixtureDef() {}
  57. /// The shape, this must be set. The shape will be cloned, so you
  58. /// can create the shape on the stack.
  59. const b2Shape* shape;
  60. /// Use this to store application specific fixture data.
  61. void* userData;
  62. /// The friction coefficient, usually in the range [0,1].
  63. float32 friction;
  64. /// The restitution (elasticity) usually in the range [0,1].
  65. float32 restitution;
  66. /// The density, usually in kg/m^2.
  67. float32 density;
  68. /// A sensor shape collects contact information but never generates a collision
  69. /// response.
  70. bool isSensor;
  71. /// Contact filtering data.
  72. b2Filter filter;
  73. };
  74. /// A fixture is used to attach a shape to a body for collision detection. A fixture
  75. /// inherits its transform from its parent. Fixtures hold additional non-geometric data
  76. /// such as friction, collision filters, etc.
  77. /// Fixtures are created via b2Body::CreateFixture.
  78. /// @warning you cannot reuse fixtures.
  79. class b2Fixture
  80. {
  81. public:
  82. /// Get the type of the child shape. You can use this to down cast to the concrete shape.
  83. /// @return the shape type.
  84. b2Shape::Type GetType() const;
  85. /// Get the child shape. You can modify the child shape, however you should not change the
  86. /// number of vertices because this will crash some collision caching mechanisms.
  87. /// Manipulating the shape may lead to non-physical behavior.
  88. b2Shape* GetShape();
  89. const b2Shape* GetShape() const;
  90. /// Set if this fixture is a sensor.
  91. void SetSensor(bool sensor);
  92. /// Is this fixture a sensor (non-solid)?
  93. /// @return the true if the shape is a sensor.
  94. bool IsSensor() const;
  95. /// Set the contact filtering data. This will not update contacts until the next time
  96. /// step when either parent body is active and awake.
  97. void SetFilterData(const b2Filter& filter);
  98. /// Get the contact filtering data.
  99. const b2Filter& GetFilterData() const;
  100. /// Get the parent body of this fixture. This is NULL if the fixture is not attached.
  101. /// @return the parent body.
  102. b2Body* GetBody();
  103. const b2Body* GetBody() const;
  104. /// Get the next fixture in the parent body's fixture list.
  105. /// @return the next shape.
  106. b2Fixture* GetNext();
  107. const b2Fixture* GetNext() const;
  108. /// Get the user data that was assigned in the fixture definition. Use this to
  109. /// store your application specific data.
  110. void* GetUserData() const;
  111. /// Set the user data. Use this to store your application specific data.
  112. void SetUserData(void* data);
  113. /// Test a point for containment in this fixture.
  114. /// @param xf the shape world transform.
  115. /// @param p a point in world coordinates.
  116. bool TestPoint(const b2Vec2& p) const;
  117. /// Cast a ray against this shape.
  118. /// @param output the ray-cast results.
  119. /// @param input the ray-cast input parameters.
  120. bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input) const;
  121. /// Get the mass data for this fixture. The mass data is based on the density and
  122. /// the shape. The rotational inertia is about the shape's origin. This operation
  123. /// may be expensive.
  124. void GetMassData(b2MassData* massData) const;
  125. /// Set the density of this fixture. This will _not_ automatically adjust the mass
  126. /// of the body. You must call b2Body::ResetMassData to update the body's mass.
  127. void SetDensity(float32 density);
  128. /// Get the density of this fixture.
  129. float32 GetDensity() const;
  130. /// Get the coefficient of friction.
  131. float32 GetFriction() const;
  132. /// Set the coefficient of friction.
  133. void SetFriction(float32 friction);
  134. /// Get the coefficient of restitution.
  135. float32 GetRestitution() const;
  136. /// Set the coefficient of restitution.
  137. void SetRestitution(float32 restitution);
  138. /// Get the fixture's AABB. This AABB may be enlarge and/or stale.
  139. /// If you need a more accurate AABB, compute it using the shape and
  140. /// the body transform.
  141. const b2AABB& GetAABB() const;
  142. protected:
  143. friend class b2Body;
  144. friend class b2World;
  145. friend class b2Contact;
  146. friend class b2ContactManager;
  147. b2Fixture();
  148. ~b2Fixture();
  149. // We need separation create/destroy functions from the constructor/destructor because
  150. // the destructor cannot access the allocator (no destructor arguments allowed by C++).
  151. void Create(b2BlockAllocator* allocator, b2Body* body, const b2FixtureDef* def);
  152. void Destroy(b2BlockAllocator* allocator);
  153. // These support body activation/deactivation.
  154. void CreateProxy(b2BroadPhase* broadPhase, const b2Transform& xf);
  155. void DestroyProxy(b2BroadPhase* broadPhase);
  156. void Synchronize(b2BroadPhase* broadPhase, const b2Transform& xf1, const b2Transform& xf2);
  157. b2AABB m_aabb;
  158. float32 m_density;
  159. b2Fixture* m_next;
  160. b2Body* m_body;
  161. b2Shape* m_shape;
  162. float32 m_friction;
  163. float32 m_restitution;
  164. int32 m_proxyId;
  165. b2Filter m_filter;
  166. bool m_isSensor;
  167. void* m_userData;
  168. };
  169. inline b2Shape::Type b2Fixture::GetType() const
  170. {
  171. return m_shape->GetType();
  172. }
  173. inline b2Shape* b2Fixture::GetShape()
  174. {
  175. return m_shape;
  176. }
  177. inline const b2Shape* b2Fixture::GetShape() const
  178. {
  179. return m_shape;
  180. }
  181. inline bool b2Fixture::IsSensor() const
  182. {
  183. return m_isSensor;
  184. }
  185. inline const b2Filter& b2Fixture::GetFilterData() const
  186. {
  187. return m_filter;
  188. }
  189. inline void* b2Fixture::GetUserData() const
  190. {
  191. return m_userData;
  192. }
  193. inline void b2Fixture::SetUserData(void* data)
  194. {
  195. m_userData = data;
  196. }
  197. inline b2Body* b2Fixture::GetBody()
  198. {
  199. return m_body;
  200. }
  201. inline const b2Body* b2Fixture::GetBody() const
  202. {
  203. return m_body;
  204. }
  205. inline b2Fixture* b2Fixture::GetNext()
  206. {
  207. return m_next;
  208. }
  209. inline const b2Fixture* b2Fixture::GetNext() const
  210. {
  211. return m_next;
  212. }
  213. inline void b2Fixture::SetDensity(float32 density)
  214. {
  215. b2Assert(b2IsValid(density) && density >= 0.0f);
  216. m_density = density;
  217. }
  218. inline float32 b2Fixture::GetDensity() const
  219. {
  220. return m_density;
  221. }
  222. inline float32 b2Fixture::GetFriction() const
  223. {
  224. return m_friction;
  225. }
  226. inline void b2Fixture::SetFriction(float32 friction)
  227. {
  228. m_friction = friction;
  229. }
  230. inline float32 b2Fixture::GetRestitution() const
  231. {
  232. return m_restitution;
  233. }
  234. inline void b2Fixture::SetRestitution(float32 restitution)
  235. {
  236. m_restitution = restitution;
  237. }
  238. inline bool b2Fixture::TestPoint(const b2Vec2& p) const
  239. {
  240. return m_shape->TestPoint(m_body->GetTransform(), p);
  241. }
  242. inline bool b2Fixture::RayCast(b2RayCastOutput* output, const b2RayCastInput& input) const
  243. {
  244. return m_shape->RayCast(output, input, m_body->GetTransform());
  245. }
  246. inline void b2Fixture::GetMassData(b2MassData* massData) const
  247. {
  248. m_shape->ComputeMass(massData, m_density);
  249. }
  250. inline const b2AABB& b2Fixture::GetAABB() const
  251. {
  252. return m_aabb;
  253. }
  254. #endif