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

游戏引擎

开发平台:

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. #include <Box2D/Dynamics/Contacts/b2Contact.h>
  19. #include <Box2D/Dynamics/Contacts/b2CircleContact.h>
  20. #include <Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h>
  21. #include <Box2D/Dynamics/Contacts/b2PolygonContact.h>
  22. #include <Box2D/Dynamics/Contacts/b2ContactSolver.h>
  23. #include <Box2D/Collision/b2Collision.h>
  24. #include <Box2D/Collision/b2TimeOfImpact.h>
  25. #include <Box2D/Collision/Shapes/b2Shape.h>
  26. #include <Box2D/Common/b2BlockAllocator.h>
  27. #include <Box2D/Dynamics/b2Body.h>
  28. #include <Box2D/Dynamics/b2Fixture.h>
  29. #include <Box2D/Dynamics/b2World.h>
  30. b2ContactRegister b2Contact::s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
  31. bool b2Contact::s_initialized = false;
  32. void b2Contact::InitializeRegisters()
  33. {
  34. AddType(b2CircleContact::Create, b2CircleContact::Destroy, b2Shape::e_circle, b2Shape::e_circle);
  35. AddType(b2PolygonAndCircleContact::Create, b2PolygonAndCircleContact::Destroy, b2Shape::e_polygon, b2Shape::e_circle);
  36. AddType(b2PolygonContact::Create, b2PolygonContact::Destroy, b2Shape::e_polygon, b2Shape::e_polygon);
  37. }
  38. void b2Contact::AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destoryFcn,
  39. b2Shape::Type type1, b2Shape::Type type2)
  40. {
  41. b2Assert(b2Shape::e_unknown < type1 && type1 < b2Shape::e_typeCount);
  42. b2Assert(b2Shape::e_unknown < type2 && type2 < b2Shape::e_typeCount);
  43. s_registers[type1][type2].createFcn = createFcn;
  44. s_registers[type1][type2].destroyFcn = destoryFcn;
  45. s_registers[type1][type2].primary = true;
  46. if (type1 != type2)
  47. {
  48. s_registers[type2][type1].createFcn = createFcn;
  49. s_registers[type2][type1].destroyFcn = destoryFcn;
  50. s_registers[type2][type1].primary = false;
  51. }
  52. }
  53. b2Contact* b2Contact::Create(b2Fixture* fixtureA, b2Fixture* fixtureB, b2BlockAllocator* allocator)
  54. {
  55. if (s_initialized == false)
  56. {
  57. InitializeRegisters();
  58. s_initialized = true;
  59. }
  60. b2Shape::Type type1 = fixtureA->GetType();
  61. b2Shape::Type type2 = fixtureB->GetType();
  62. b2Assert(b2Shape::e_unknown < type1 && type1 < b2Shape::e_typeCount);
  63. b2Assert(b2Shape::e_unknown < type2 && type2 < b2Shape::e_typeCount);
  64. b2ContactCreateFcn* createFcn = s_registers[type1][type2].createFcn;
  65. if (createFcn)
  66. {
  67. if (s_registers[type1][type2].primary)
  68. {
  69. return createFcn(fixtureA, fixtureB, allocator);
  70. }
  71. else
  72. {
  73. return createFcn(fixtureB, fixtureA, allocator);
  74. }
  75. }
  76. else
  77. {
  78. return NULL;
  79. }
  80. }
  81. void b2Contact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
  82. {
  83. b2Assert(s_initialized == true);
  84. if (contact->m_manifold.pointCount > 0)
  85. {
  86. contact->GetFixtureA()->GetBody()->SetAwake(true);
  87. contact->GetFixtureB()->GetBody()->SetAwake(true);
  88. }
  89. b2Shape::Type typeA = contact->GetFixtureA()->GetType();
  90. b2Shape::Type typeB = contact->GetFixtureB()->GetType();
  91. b2Assert(b2Shape::e_unknown < typeA && typeB < b2Shape::e_typeCount);
  92. b2Assert(b2Shape::e_unknown < typeA && typeB < b2Shape::e_typeCount);
  93. b2ContactDestroyFcn* destroyFcn = s_registers[typeA][typeB].destroyFcn;
  94. destroyFcn(contact, allocator);
  95. }
  96. b2Contact::b2Contact(b2Fixture* fA, b2Fixture* fB)
  97. {
  98. m_flags = e_enabledFlag;
  99. m_fixtureA = fA;
  100. m_fixtureB = fB;
  101. m_manifold.pointCount = 0;
  102. m_prev = NULL;
  103. m_next = NULL;
  104. m_nodeA.contact = NULL;
  105. m_nodeA.prev = NULL;
  106. m_nodeA.next = NULL;
  107. m_nodeA.other = NULL;
  108. m_nodeB.contact = NULL;
  109. m_nodeB.prev = NULL;
  110. m_nodeB.next = NULL;
  111. m_nodeB.other = NULL;
  112. m_toiCount = 0;
  113. }
  114. // Update the contact manifold and touching status.
  115. // Note: do not assume the fixture AABBs are overlapping or are valid.
  116. void b2Contact::Update(b2ContactListener* listener)
  117. {
  118. b2Manifold oldManifold = m_manifold;
  119. // Re-enable this contact.
  120. m_flags |= e_enabledFlag;
  121. bool touching = false;
  122. bool wasTouching = (m_flags & e_touchingFlag) == e_touchingFlag;
  123. bool sensorA = m_fixtureA->IsSensor();
  124. bool sensorB = m_fixtureB->IsSensor();
  125. bool sensor = sensorA || sensorB;
  126. b2Body* bodyA = m_fixtureA->GetBody();
  127. b2Body* bodyB = m_fixtureB->GetBody();
  128. const b2Transform& xfA = bodyA->GetTransform();
  129. const b2Transform& xfB = bodyB->GetTransform();
  130. // Is this contact a sensor?
  131. if (sensor)
  132. {
  133. const b2Shape* shapeA = m_fixtureA->GetShape();
  134. const b2Shape* shapeB = m_fixtureB->GetShape();
  135. touching = b2TestOverlap(shapeA, shapeB, xfA, xfB);
  136. // Sensors don't generate manifolds.
  137. m_manifold.pointCount = 0;
  138. }
  139. else
  140. {
  141. Evaluate(&m_manifold, xfA, xfB);
  142. touching = m_manifold.pointCount > 0;
  143. // Match old contact ids to new contact ids and copy the
  144. // stored impulses to warm start the solver.
  145. for (int32 i = 0; i < m_manifold.pointCount; ++i)
  146. {
  147. b2ManifoldPoint* mp2 = m_manifold.points + i;
  148. mp2->normalImpulse = 0.0f;
  149. mp2->tangentImpulse = 0.0f;
  150. b2ContactID id2 = mp2->id;
  151. for (int32 j = 0; j < oldManifold.pointCount; ++j)
  152. {
  153. b2ManifoldPoint* mp1 = oldManifold.points + j;
  154. if (mp1->id.key == id2.key)
  155. {
  156. mp2->normalImpulse = mp1->normalImpulse;
  157. mp2->tangentImpulse = mp1->tangentImpulse;
  158. break;
  159. }
  160. }
  161. }
  162. if (touching != wasTouching)
  163. {
  164. bodyA->SetAwake(true);
  165. bodyB->SetAwake(true);
  166. }
  167. }
  168. if (touching)
  169. {
  170. m_flags |= e_touchingFlag;
  171. }
  172. else
  173. {
  174. m_flags &= ~e_touchingFlag;
  175. }
  176. if (wasTouching == false && touching == true && listener)
  177. {
  178. listener->BeginContact(this);
  179. }
  180. if (wasTouching == true && touching == false && listener)
  181. {
  182. listener->EndContact(this);
  183. }
  184. if (sensor == false && touching && listener)
  185. {
  186. listener->PreSolve(this, &oldManifold);
  187. }
  188. }