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

游戏引擎

开发平台:

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_DISTANCE_H
  19. #define B2_DISTANCE_H
  20. #include <Box2D/Common/b2Math.h>
  21. #include <climits>
  22. class b2Shape;
  23. /// A distance proxy is used by the GJK algorithm.
  24. /// It encapsulates any shape.
  25. struct b2DistanceProxy
  26. {
  27. b2DistanceProxy() : m_vertices(NULL), m_count(0), m_radius(0.0f) {}
  28. /// Initialize the proxy using the given shape. The shape
  29. /// must remain in scope while the proxy is in use.
  30. void Set(const b2Shape* shape);
  31. /// Get the supporting vertex index in the given direction.
  32. int32 GetSupport(const b2Vec2& d) const;
  33. /// Get the supporting vertex in the given direction.
  34. const b2Vec2& GetSupportVertex(const b2Vec2& d) const;
  35. /// Get the vertex count.
  36. int32 GetVertexCount() const;
  37. /// Get a vertex by index. Used by b2Distance.
  38. const b2Vec2& GetVertex(int32 index) const;
  39. const b2Vec2* m_vertices;
  40. int32 m_count;
  41. float32 m_radius;
  42. };
  43. /// Used to warm start b2Distance.
  44. /// Set count to zero on first call.
  45. struct b2SimplexCache
  46. {
  47. float32 metric; ///< length or area
  48. uint16 count;
  49. uint8 indexA[3]; ///< vertices on shape A
  50. uint8 indexB[3]; ///< vertices on shape B
  51. };
  52. /// Input for b2Distance.
  53. /// You have to option to use the shape radii
  54. /// in the computation. Even 
  55. struct b2DistanceInput
  56. {
  57. b2DistanceProxy proxyA;
  58. b2DistanceProxy proxyB;
  59. b2Transform transformA;
  60. b2Transform transformB;
  61. bool useRadii;
  62. };
  63. /// Output for b2Distance.
  64. struct b2DistanceOutput
  65. {
  66. b2Vec2 pointA; ///< closest point on shapeA
  67. b2Vec2 pointB; ///< closest point on shapeB
  68. float32 distance;
  69. int32 iterations; ///< number of GJK iterations used
  70. };
  71. /// Compute the closest points between two shapes. Supports any combination of:
  72. /// b2CircleShape, b2PolygonShape, b2EdgeShape. The simplex cache is input/output.
  73. /// On the first call set b2SimplexCache.count to zero.
  74. void b2Distance(b2DistanceOutput* output,
  75. b2SimplexCache* cache, 
  76. const b2DistanceInput* input);
  77. //////////////////////////////////////////////////////////////////////////
  78. inline int32 b2DistanceProxy::GetVertexCount() const
  79. {
  80. return m_count;
  81. }
  82. inline const b2Vec2& b2DistanceProxy::GetVertex(int32 index) const
  83. {
  84. b2Assert(0 <= index && index < m_count);
  85. return m_vertices[index];
  86. }
  87. inline int32 b2DistanceProxy::GetSupport(const b2Vec2& d) const
  88. {
  89. int32 bestIndex = 0;
  90. float32 bestValue = b2Dot(m_vertices[0], d);
  91. for (int32 i = 1; i < m_count; ++i)
  92. {
  93. float32 value = b2Dot(m_vertices[i], d);
  94. if (value > bestValue)
  95. {
  96. bestIndex = i;
  97. bestValue = value;
  98. }
  99. }
  100. return bestIndex;
  101. }
  102. inline const b2Vec2& b2DistanceProxy::GetSupportVertex(const b2Vec2& d) const
  103. {
  104. int32 bestIndex = 0;
  105. float32 bestValue = b2Dot(m_vertices[0], d);
  106. for (int32 i = 1; i < m_count; ++i)
  107. {
  108. float32 value = b2Dot(m_vertices[i], d);
  109. if (value > bestValue)
  110. {
  111. bestIndex = i;
  112. bestValue = value;
  113. }
  114. }
  115. return m_vertices[bestIndex];
  116. }
  117. #endif