b2PrismaticJoint.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_PRISMATIC_JOINT_H
  19. #define B2_PRISMATIC_JOINT_H
  20. #include <Box2D/Dynamics/Joints/b2Joint.h>
  21. /// Prismatic joint definition. This requires defining a line of
  22. /// motion using an axis and an anchor point. The definition uses local
  23. /// anchor points and a local axis so that the initial configuration
  24. /// can violate the constraint slightly. The joint translation is zero
  25. /// when the local anchor points coincide in world space. Using local
  26. /// anchors and a local axis helps when saving and loading a game.
  27. /// @warning at least one body should by dynamic with a non-fixed rotation.
  28. struct b2PrismaticJointDef : public b2JointDef
  29. {
  30. b2PrismaticJointDef()
  31. {
  32. type = e_prismaticJoint;
  33. localAnchorA.SetZero();
  34. localAnchorB.SetZero();
  35. localAxis1.Set(1.0f, 0.0f);
  36. referenceAngle = 0.0f;
  37. enableLimit = false;
  38. lowerTranslation = 0.0f;
  39. upperTranslation = 0.0f;
  40. enableMotor = false;
  41. maxMotorForce = 0.0f;
  42. motorSpeed = 0.0f;
  43. }
  44. /// Initialize the bodies, anchors, axis, and reference angle using the world
  45. /// anchor and world axis.
  46. void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
  47. /// The local anchor point relative to body1's origin.
  48. b2Vec2 localAnchorA;
  49. /// The local anchor point relative to body2's origin.
  50. b2Vec2 localAnchorB;
  51. /// The local translation axis in body1.
  52. b2Vec2 localAxis1;
  53. /// The constrained angle between the bodies: body2_angle - body1_angle.
  54. float32 referenceAngle;
  55. /// Enable/disable the joint limit.
  56. bool enableLimit;
  57. /// The lower translation limit, usually in meters.
  58. float32 lowerTranslation;
  59. /// The upper translation limit, usually in meters.
  60. float32 upperTranslation;
  61. /// Enable/disable the joint motor.
  62. bool enableMotor;
  63. /// The maximum motor torque, usually in N-m.
  64. float32 maxMotorForce;
  65. /// The desired motor speed in radians per second.
  66. float32 motorSpeed;
  67. };
  68. /// A prismatic joint. This joint provides one degree of freedom: translation
  69. /// along an axis fixed in body1. Relative rotation is prevented. You can
  70. /// use a joint limit to restrict the range of motion and a joint motor to
  71. /// drive the motion or to model joint friction.
  72. class b2PrismaticJoint : public b2Joint
  73. {
  74. public:
  75. b2Vec2 GetAnchorA() const;
  76. b2Vec2 GetAnchorB() const;
  77. b2Vec2 GetReactionForce(float32 inv_dt) const;
  78. float32 GetReactionTorque(float32 inv_dt) const;
  79. /// Get the current joint translation, usually in meters.
  80. float32 GetJointTranslation() const;
  81. /// Get the current joint translation speed, usually in meters per second.
  82. float32 GetJointSpeed() const;
  83. /// Is the joint limit enabled?
  84. bool IsLimitEnabled() const;
  85. /// Enable/disable the joint limit.
  86. void EnableLimit(bool flag);
  87. /// Get the lower joint limit, usually in meters.
  88. float32 GetLowerLimit() const;
  89. /// Get the upper joint limit, usually in meters.
  90. float32 GetUpperLimit() const;
  91. /// Set the joint limits, usually in meters.
  92. void SetLimits(float32 lower, float32 upper);
  93. /// Is the joint motor enabled?
  94. bool IsMotorEnabled() const;
  95. /// Enable/disable the joint motor.
  96. void EnableMotor(bool flag);
  97. /// Set the motor speed, usually in meters per second.
  98. void SetMotorSpeed(float32 speed);
  99. /// Get the motor speed, usually in meters per second.
  100. float32 GetMotorSpeed() const;
  101. /// Set the maximum motor force, usually in N.
  102. void SetMaxMotorForce(float32 force);
  103. /// Get the current motor force, usually in N.
  104. float32 GetMotorForce() const;
  105. protected:
  106. friend class b2Joint;
  107. friend class b2GearJoint;
  108. b2PrismaticJoint(const b2PrismaticJointDef* def);
  109. void InitVelocityConstraints(const b2TimeStep& step);
  110. void SolveVelocityConstraints(const b2TimeStep& step);
  111. bool SolvePositionConstraints(float32 baumgarte);
  112. b2Vec2 m_localAnchor1;
  113. b2Vec2 m_localAnchor2;
  114. b2Vec2 m_localXAxis1;
  115. b2Vec2 m_localYAxis1;
  116. float32 m_refAngle;
  117. b2Vec2 m_axis, m_perp;
  118. float32 m_s1, m_s2;
  119. float32 m_a1, m_a2;
  120. b2Mat33 m_K;
  121. b2Vec3 m_impulse;
  122. float32 m_motorMass; // effective mass for motor/limit translational constraint.
  123. float32 m_motorImpulse;
  124. float32 m_lowerTranslation;
  125. float32 m_upperTranslation;
  126. float32 m_maxMotorForce;
  127. float32 m_motorSpeed;
  128. bool m_enableLimit;
  129. bool m_enableMotor;
  130. b2LimitState m_limitState;
  131. };
  132. inline float32 b2PrismaticJoint::GetMotorSpeed() const
  133. {
  134. return m_motorSpeed;
  135. }
  136. #endif