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

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2007 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_REVOLUTE_JOINT_H
  19. #define B2_REVOLUTE_JOINT_H
  20. #include <Box2D/Dynamics/Joints/b2Joint.h>
  21. /// Revolute joint definition. This requires defining an
  22. /// anchor point where the bodies are joined. The definition
  23. /// uses local anchor points so that the initial configuration
  24. /// can violate the constraint slightly. You also need to
  25. /// specify the initial relative angle for joint limits. This
  26. /// helps when saving and loading a game.
  27. /// The local anchor points are measured from the body's origin
  28. /// rather than the center of mass because:
  29. /// 1. you might not know where the center of mass will be.
  30. /// 2. if you add/remove shapes from a body and recompute the mass,
  31. ///    the joints will be broken.
  32. struct b2RevoluteJointDef : public b2JointDef
  33. {
  34. b2RevoluteJointDef()
  35. {
  36. type = e_revoluteJoint;
  37. localAnchorA.Set(0.0f, 0.0f);
  38. localAnchorB.Set(0.0f, 0.0f);
  39. referenceAngle = 0.0f;
  40. lowerAngle = 0.0f;
  41. upperAngle = 0.0f;
  42. maxMotorTorque = 0.0f;
  43. motorSpeed = 0.0f;
  44. enableLimit = false;
  45. enableMotor = false;
  46. }
  47. /// Initialize the bodies, anchors, and reference angle using a world
  48. /// anchor point.
  49. void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
  50. /// The local anchor point relative to body1's origin.
  51. b2Vec2 localAnchorA;
  52. /// The local anchor point relative to body2's origin.
  53. b2Vec2 localAnchorB;
  54. /// The body2 angle minus body1 angle in the reference state (radians).
  55. float32 referenceAngle;
  56. /// A flag to enable joint limits.
  57. bool enableLimit;
  58. /// The lower angle for the joint limit (radians).
  59. float32 lowerAngle;
  60. /// The upper angle for the joint limit (radians).
  61. float32 upperAngle;
  62. /// A flag to enable the joint motor.
  63. bool enableMotor;
  64. /// The desired motor speed. Usually in radians per second.
  65. float32 motorSpeed;
  66. /// The maximum motor torque used to achieve the desired motor speed.
  67. /// Usually in N-m.
  68. float32 maxMotorTorque;
  69. };
  70. /// A revolute joint constrains two bodies to share a common point while they
  71. /// are free to rotate about the point. The relative rotation about the shared
  72. /// point is the joint angle. You can limit the relative rotation with
  73. /// a joint limit that specifies a lower and upper angle. You can use a motor
  74. /// to drive the relative rotation about the shared point. A maximum motor torque
  75. /// is provided so that infinite forces are not generated.
  76. class b2RevoluteJoint : public b2Joint
  77. {
  78. public:
  79. b2Vec2 GetAnchorA() const;
  80. b2Vec2 GetAnchorB() const;
  81. b2Vec2 GetReactionForce(float32 inv_dt) const;
  82. float32 GetReactionTorque(float32 inv_dt) const;
  83. /// Get the current joint angle in radians.
  84. float32 GetJointAngle() const;
  85. /// Get the current joint angle speed in radians per second.
  86. float32 GetJointSpeed() const;
  87. /// Is the joint limit enabled?
  88. bool IsLimitEnabled() const;
  89. /// Enable/disable the joint limit.
  90. void EnableLimit(bool flag);
  91. /// Get the lower joint limit in radians.
  92. float32 GetLowerLimit() const;
  93. /// Get the upper joint limit in radians.
  94. float32 GetUpperLimit() const;
  95. /// Set the joint limits in radians.
  96. void SetLimits(float32 lower, float32 upper);
  97. /// Is the joint motor enabled?
  98. bool IsMotorEnabled() const;
  99. /// Enable/disable the joint motor.
  100. void EnableMotor(bool flag);
  101. /// Set the motor speed in radians per second.
  102. void SetMotorSpeed(float32 speed);
  103. /// Get the motor speed in radians per second.
  104. float32 GetMotorSpeed() const;
  105. /// Set the maximum motor torque, usually in N-m.
  106. void SetMaxMotorTorque(float32 torque);
  107. /// Get the current motor torque, usually in N-m.
  108. float32 GetMotorTorque() const;
  109. protected:
  110. friend class b2Joint;
  111. friend class b2GearJoint;
  112. b2RevoluteJoint(const b2RevoluteJointDef* def);
  113. void InitVelocityConstraints(const b2TimeStep& step);
  114. void SolveVelocityConstraints(const b2TimeStep& step);
  115. bool SolvePositionConstraints(float32 baumgarte);
  116. b2Vec2 m_localAnchor1; // relative
  117. b2Vec2 m_localAnchor2;
  118. b2Vec3 m_impulse;
  119. float32 m_motorImpulse;
  120. b2Mat33 m_mass; // effective mass for point-to-point constraint.
  121. float32 m_motorMass; // effective mass for motor/limit angular constraint.
  122. bool m_enableMotor;
  123. float32 m_maxMotorTorque;
  124. float32 m_motorSpeed;
  125. bool m_enableLimit;
  126. float32 m_referenceAngle;
  127. float32 m_lowerAngle;
  128. float32 m_upperAngle;
  129. b2LimitState m_limitState;
  130. };
  131. inline float32 b2RevoluteJoint::GetMotorSpeed() const
  132. {
  133. return m_motorSpeed;
  134. }
  135. #endif