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

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2008-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 BREAKABLE_TEST_H
  19. #define BREAKABLE_TEST_H
  20. // This is used to test sensor shapes.
  21. class Breakable : public Test
  22. {
  23. public:
  24. enum
  25. {
  26. e_count = 7
  27. };
  28. Breakable()
  29. {
  30. // Ground body
  31. {
  32. b2BodyDef bd;
  33. b2Body* ground = m_world->CreateBody(&bd);
  34. b2PolygonShape shape;
  35. shape.SetAsEdge(b2Vec2(-40.0f, 0.0f), b2Vec2(40.0f, 0.0f));
  36. ground->CreateFixture(&shape, 0.0f);
  37. }
  38. // Breakable dynamic body
  39. {
  40. b2BodyDef bd;
  41. bd.type = b2_dynamicBody;
  42. bd.position.Set(0.0f, 40.0f);
  43. bd.angle = 0.25f * b2_pi;
  44. m_body1 = m_world->CreateBody(&bd);
  45. m_shape1.SetAsBox(0.5f, 0.5f, b2Vec2(-0.5f, 0.0f), 0.0f);
  46. m_piece1 = m_body1->CreateFixture(&m_shape1, 1.0f);
  47. m_shape2.SetAsBox(0.5f, 0.5f, b2Vec2(0.5f, 0.0f), 0.0f);
  48. m_piece2 = m_body1->CreateFixture(&m_shape2, 1.0f);
  49. }
  50. m_break = false;
  51. m_broke = false;
  52. }
  53. void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
  54. {
  55. if (m_broke)
  56. {
  57. // The body already broke.
  58. return;
  59. }
  60. // Should the body break?
  61. int32 count = contact->GetManifold()->pointCount;
  62. float32 maxImpulse = 0.0f;
  63. for (int32 i = 0; i < count; ++i)
  64. {
  65. maxImpulse = b2Max(maxImpulse, impulse->normalImpulses[i]);
  66. }
  67. if (maxImpulse > 40.0f)
  68. {
  69. // Flag the body for breaking.
  70. m_break = true;
  71. }
  72. }
  73. void Break()
  74. {
  75. // Create two bodies from one.
  76. b2Body* body1 = m_piece1->GetBody();
  77. b2Vec2 center = body1->GetWorldCenter();
  78. body1->DestroyFixture(m_piece2);
  79. m_piece2 = NULL;
  80. b2BodyDef bd;
  81. bd.type = b2_dynamicBody;
  82. bd.position = body1->GetPosition();
  83. bd.angle = body1->GetAngle();
  84. b2Body* body2 = m_world->CreateBody(&bd);
  85. m_piece2 = body2->CreateFixture(&m_shape2, 1.0f);
  86. // Compute consistent velocities for new bodies based on
  87. // cached velocity.
  88. b2Vec2 center1 = body1->GetWorldCenter();
  89. b2Vec2 center2 = body2->GetWorldCenter();
  90. b2Vec2 velocity1 = m_velocity + b2Cross(m_angularVelocity, center1 - center);
  91. b2Vec2 velocity2 = m_velocity + b2Cross(m_angularVelocity, center2 - center);
  92. body1->SetAngularVelocity(m_angularVelocity);
  93. body1->SetLinearVelocity(velocity1);
  94. body2->SetAngularVelocity(m_angularVelocity);
  95. body2->SetLinearVelocity(velocity2);
  96. }
  97. void Step(Settings* settings)
  98. {
  99. if (m_break)
  100. {
  101. Break();
  102. m_broke = true;
  103. m_break = false;
  104. }
  105. // Cache velocities to improve movement on breakage.
  106. if (m_broke == false)
  107. {
  108. m_velocity = m_body1->GetLinearVelocity();
  109. m_angularVelocity = m_body1->GetAngularVelocity();
  110. }
  111. Test::Step(settings);
  112. }
  113. static Test* Create()
  114. {
  115. return new Breakable;
  116. }
  117. b2Body* m_body1;
  118. b2Vec2 m_velocity;
  119. float32 m_angularVelocity;
  120. b2PolygonShape m_shape1;
  121. b2PolygonShape m_shape2;
  122. b2Fixture* m_piece1;
  123. b2Fixture* m_piece2;
  124. bool m_broke;
  125. bool m_break;
  126. };
  127. #endif