b2PolygonShape.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_POLYGON_SHAPE_H
  19. #define B2_POLYGON_SHAPE_H
  20. #include <Box2D/Collision/Shapes/b2Shape.h>
  21. /// A convex polygon. It is assumed that the interior of the polygon is to
  22. /// the left of each edge.
  23. class b2PolygonShape : public b2Shape
  24. {
  25. public:
  26. b2PolygonShape();
  27. /// Implement b2Shape.
  28. b2Shape* Clone(b2BlockAllocator* allocator) const;
  29. /// Copy vertices. This assumes the vertices define a convex polygon.
  30. /// It is assumed that the exterior is the the right of each edge.
  31. void Set(const b2Vec2* vertices, int32 vertexCount);
  32. /// Build vertices to represent an axis-aligned box.
  33. /// @param hx the half-width.
  34. /// @param hy the half-height.
  35. void SetAsBox(float32 hx, float32 hy);
  36. /// Build vertices to represent an oriented box.
  37. /// @param hx the half-width.
  38. /// @param hy the half-height.
  39. /// @param center the center of the box in local coordinates.
  40. /// @param angle the rotation of the box in local coordinates.
  41. void SetAsBox(float32 hx, float32 hy, const b2Vec2& center, float32 angle);
  42. /// Set this as a single edge.
  43. void SetAsEdge(const b2Vec2& v1, const b2Vec2& v2);
  44. /// @see b2Shape::TestPoint
  45. bool TestPoint(const b2Transform& transform, const b2Vec2& p) const;
  46. /// Implement b2Shape.
  47. bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input, const b2Transform& transform) const;
  48. /// @see b2Shape::ComputeAABB
  49. void ComputeAABB(b2AABB* aabb, const b2Transform& transform) const;
  50. /// @see b2Shape::ComputeMass
  51. void ComputeMass(b2MassData* massData, float32 density) const;
  52. /// Get the supporting vertex index in the given direction.
  53. int32 GetSupport(const b2Vec2& d) const;
  54. /// Get the supporting vertex in the given direction.
  55. const b2Vec2& GetSupportVertex(const b2Vec2& d) const;
  56. /// Get the vertex count.
  57. int32 GetVertexCount() const { return m_vertexCount; }
  58. /// Get a vertex by index.
  59. const b2Vec2& GetVertex(int32 index) const;
  60. b2Vec2 m_centroid;
  61. b2Vec2 m_vertices[b2_maxPolygonVertices];
  62. b2Vec2 m_normals[b2_maxPolygonVertices];
  63. int32 m_vertexCount;
  64. };
  65. inline b2PolygonShape::b2PolygonShape()
  66. {
  67. m_type = e_polygon;
  68. m_radius = b2_polygonRadius;
  69. m_vertexCount = 0;
  70. m_centroid.SetZero();
  71. }
  72. inline int32 b2PolygonShape::GetSupport(const b2Vec2& d) const
  73. {
  74. int32 bestIndex = 0;
  75. float32 bestValue = b2Dot(m_vertices[0], d);
  76. for (int32 i = 1; i < m_vertexCount; ++i)
  77. {
  78. float32 value = b2Dot(m_vertices[i], d);
  79. if (value > bestValue)
  80. {
  81. bestIndex = i;
  82. bestValue = value;
  83. }
  84. }
  85. return bestIndex;
  86. }
  87. inline const b2Vec2& b2PolygonShape::GetSupportVertex(const b2Vec2& d) const
  88. {
  89. int32 bestIndex = 0;
  90. float32 bestValue = b2Dot(m_vertices[0], d);
  91. for (int32 i = 1; i < m_vertexCount; ++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 m_vertices[bestIndex];
  101. }
  102. inline const b2Vec2& b2PolygonShape::GetVertex(int32 index) const
  103. {
  104. b2Assert(0 <= index && index < m_vertexCount);
  105. return m_vertices[index];
  106. }
  107. #endif