reflexion 0.1.7 → 0.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (223) hide show
  1. checksums.yaml +4 -4
  2. data/.doc/ext/reflex/application.cpp +5 -5
  3. data/.doc/ext/reflex/body.cpp +167 -0
  4. data/.doc/ext/reflex/capture_event.cpp +4 -4
  5. data/.doc/ext/reflex/draw_event.cpp +4 -4
  6. data/.doc/ext/reflex/event.cpp +4 -4
  7. data/.doc/ext/reflex/fixture.cpp +101 -0
  8. data/.doc/ext/reflex/focus_event.cpp +4 -4
  9. data/.doc/ext/reflex/frame_event.cpp +4 -4
  10. data/.doc/ext/reflex/image_view.cpp +22 -5
  11. data/.doc/ext/reflex/key_event.cpp +4 -4
  12. data/.doc/ext/reflex/native.cpp +6 -0
  13. data/.doc/ext/reflex/pointer_event.cpp +4 -4
  14. data/.doc/ext/reflex/reflex.cpp +2 -3
  15. data/.doc/ext/reflex/scroll_event.cpp +4 -4
  16. data/.doc/ext/reflex/selector.cpp +4 -4
  17. data/.doc/ext/reflex/style.cpp +4 -4
  18. data/.doc/ext/reflex/style_length.cpp +4 -4
  19. data/.doc/ext/reflex/style_length2.cpp +4 -4
  20. data/.doc/ext/reflex/style_length4.cpp +4 -4
  21. data/.doc/ext/reflex/update_event.cpp +4 -4
  22. data/.doc/ext/reflex/view.cpp +110 -8
  23. data/.doc/ext/reflex/wheel_event.cpp +4 -4
  24. data/.doc/ext/reflex/window.cpp +36 -12
  25. data/README.md +2 -2
  26. data/Rakefile +2 -1
  27. data/VERSION +1 -1
  28. data/ext/reflex/application.cpp +8 -8
  29. data/ext/reflex/body.cpp +181 -0
  30. data/ext/reflex/capture_event.cpp +4 -4
  31. data/ext/reflex/draw_event.cpp +4 -4
  32. data/ext/reflex/event.cpp +4 -4
  33. data/ext/reflex/fixture.cpp +108 -0
  34. data/ext/reflex/focus_event.cpp +4 -4
  35. data/ext/reflex/frame_event.cpp +4 -4
  36. data/ext/reflex/image_view.cpp +24 -5
  37. data/ext/reflex/key_event.cpp +4 -4
  38. data/ext/reflex/native.cpp +6 -0
  39. data/ext/reflex/pointer_event.cpp +4 -4
  40. data/ext/reflex/reflex.cpp +2 -3
  41. data/ext/reflex/scroll_event.cpp +4 -4
  42. data/ext/reflex/selector.cpp +4 -4
  43. data/ext/reflex/style.cpp +4 -4
  44. data/ext/reflex/style_length.cpp +4 -4
  45. data/ext/reflex/style_length2.cpp +4 -4
  46. data/ext/reflex/style_length4.cpp +4 -4
  47. data/ext/reflex/update_event.cpp +4 -4
  48. data/ext/reflex/view.cpp +126 -12
  49. data/ext/reflex/wheel_event.cpp +4 -4
  50. data/ext/reflex/window.cpp +39 -12
  51. data/include/reflex/bitmap.h +20 -0
  52. data/include/reflex/body.h +82 -0
  53. data/include/reflex/bounds.h +20 -0
  54. data/include/reflex/color.h +20 -0
  55. data/include/reflex/color_space.h +20 -0
  56. data/include/reflex/defs.h +5 -1
  57. data/include/reflex/event.h +16 -25
  58. data/include/reflex/fixture.h +116 -0
  59. data/include/reflex/font.h +20 -0
  60. data/include/reflex/image.h +20 -0
  61. data/include/reflex/image_view.h +1 -1
  62. data/include/reflex/matrix.h +20 -0
  63. data/include/reflex/painter.h +20 -0
  64. data/include/reflex/point.h +24 -0
  65. data/include/reflex/ruby/application.h +6 -0
  66. data/include/reflex/ruby/body.h +41 -0
  67. data/include/reflex/ruby/event.h +68 -0
  68. data/include/reflex/ruby/fixture.h +41 -0
  69. data/include/reflex/ruby/image_view.h +14 -0
  70. data/include/reflex/ruby/selector.h +14 -0
  71. data/include/reflex/ruby/style.h +14 -0
  72. data/include/reflex/ruby/style_length.h +26 -0
  73. data/include/reflex/ruby/view.h +43 -39
  74. data/include/reflex/ruby/window.h +27 -21
  75. data/include/reflex/ruby.h +2 -0
  76. data/include/reflex/shader.h +20 -0
  77. data/include/reflex/style.h +2 -3
  78. data/include/reflex/texture.h +20 -0
  79. data/include/reflex/view.h +45 -24
  80. data/include/reflex/window.h +11 -14
  81. data/include/reflex.h +3 -0
  82. data/lib/reflex/application.rb +6 -2
  83. data/lib/reflex/body.rb +17 -0
  84. data/lib/reflex/fixture.rb +17 -0
  85. data/lib/reflex/view.rb +16 -1
  86. data/lib/reflex/window.rb +13 -1
  87. data/lib/reflex.rb +2 -0
  88. data/reflex.gemspec +1 -1
  89. data/samples/bats.rb +4 -3
  90. data/samples/checker.rb +4 -3
  91. data/samples/fans.rb +4 -3
  92. data/samples/fps.rb +5 -3
  93. data/samples/grid.rb +5 -4
  94. data/samples/hello.rb +1 -1
  95. data/samples/image.rb +3 -2
  96. data/samples/ios/hello/hello/main.cpp +12 -3
  97. data/samples/ios/hello/hello.xcodeproj/project.pbxproj +376 -123
  98. data/samples/key.rb +5 -4
  99. data/samples/layout.rb +3 -2
  100. data/samples/model.rb +3 -2
  101. data/samples/osx/hello/hello/main.cpp +12 -3
  102. data/samples/osx/hello/hello.xcodeproj/project.pbxproj +375 -120
  103. data/samples/physics.rb +37 -0
  104. data/samples/repl.rb +3 -2
  105. data/samples/shader.rb +4 -4
  106. data/samples/shapes.rb +4 -4
  107. data/samples/text.rb +6 -4
  108. data/samples/tree.rb +5 -4
  109. data/samples/views.rb +3 -2
  110. data/samples/visuals.rb +1 -2
  111. data/src/body.cpp +244 -0
  112. data/src/event.cpp +18 -18
  113. data/src/fixture.cpp +108 -0
  114. data/src/image_view.cpp +1 -1
  115. data/src/ios/native_window.h +2 -0
  116. data/src/ios/native_window.mm +18 -1
  117. data/src/ios/opengl_view.mm +8 -0
  118. data/src/ios/window.mm +24 -3
  119. data/src/ios/window_data.h +3 -3
  120. data/src/osx/native_window.mm +17 -1
  121. data/src/osx/window.mm +24 -3
  122. data/src/osx/window_data.h +3 -3
  123. data/src/physics/Box2D/Box2D.h +68 -0
  124. data/src/physics/Box2D/Collision/Shapes/b2ChainShape.cpp +193 -0
  125. data/src/physics/Box2D/Collision/Shapes/b2ChainShape.h +105 -0
  126. data/src/physics/Box2D/Collision/Shapes/b2CircleShape.cpp +99 -0
  127. data/src/physics/Box2D/Collision/Shapes/b2CircleShape.h +91 -0
  128. data/src/physics/Box2D/Collision/Shapes/b2EdgeShape.cpp +138 -0
  129. data/src/physics/Box2D/Collision/Shapes/b2EdgeShape.h +74 -0
  130. data/src/physics/Box2D/Collision/Shapes/b2PolygonShape.cpp +467 -0
  131. data/src/physics/Box2D/Collision/Shapes/b2PolygonShape.h +101 -0
  132. data/src/physics/Box2D/Collision/Shapes/b2Shape.h +101 -0
  133. data/src/physics/Box2D/Collision/b2BroadPhase.cpp +119 -0
  134. data/src/physics/Box2D/Collision/b2BroadPhase.h +257 -0
  135. data/src/physics/Box2D/Collision/b2CollideCircle.cpp +154 -0
  136. data/src/physics/Box2D/Collision/b2CollideEdge.cpp +698 -0
  137. data/src/physics/Box2D/Collision/b2CollidePolygon.cpp +239 -0
  138. data/src/physics/Box2D/Collision/b2Collision.cpp +252 -0
  139. data/src/physics/Box2D/Collision/b2Collision.h +277 -0
  140. data/src/physics/Box2D/Collision/b2Distance.cpp +603 -0
  141. data/src/physics/Box2D/Collision/b2Distance.h +141 -0
  142. data/src/physics/Box2D/Collision/b2DynamicTree.cpp +778 -0
  143. data/src/physics/Box2D/Collision/b2DynamicTree.h +289 -0
  144. data/src/physics/Box2D/Collision/b2TimeOfImpact.cpp +486 -0
  145. data/src/physics/Box2D/Collision/b2TimeOfImpact.h +58 -0
  146. data/src/physics/Box2D/Common/b2BlockAllocator.cpp +215 -0
  147. data/src/physics/Box2D/Common/b2BlockAllocator.h +62 -0
  148. data/src/physics/Box2D/Common/b2Draw.cpp +44 -0
  149. data/src/physics/Box2D/Common/b2Draw.h +86 -0
  150. data/src/physics/Box2D/Common/b2GrowableStack.h +85 -0
  151. data/src/physics/Box2D/Common/b2Math.cpp +94 -0
  152. data/src/physics/Box2D/Common/b2Math.h +720 -0
  153. data/src/physics/Box2D/Common/b2Settings.cpp +44 -0
  154. data/src/physics/Box2D/Common/b2Settings.h +151 -0
  155. data/src/physics/Box2D/Common/b2StackAllocator.cpp +83 -0
  156. data/src/physics/Box2D/Common/b2StackAllocator.h +60 -0
  157. data/src/physics/Box2D/Common/b2Timer.cpp +101 -0
  158. data/src/physics/Box2D/Common/b2Timer.h +50 -0
  159. data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp +53 -0
  160. data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.h +39 -0
  161. data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp +53 -0
  162. data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.h +39 -0
  163. data/src/physics/Box2D/Dynamics/Contacts/b2CircleContact.cpp +52 -0
  164. data/src/physics/Box2D/Dynamics/Contacts/b2CircleContact.h +39 -0
  165. data/src/physics/Box2D/Dynamics/Contacts/b2Contact.cpp +247 -0
  166. data/src/physics/Box2D/Dynamics/Contacts/b2Contact.h +349 -0
  167. data/src/physics/Box2D/Dynamics/Contacts/b2ContactSolver.cpp +838 -0
  168. data/src/physics/Box2D/Dynamics/Contacts/b2ContactSolver.h +95 -0
  169. data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp +49 -0
  170. data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.h +39 -0
  171. data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp +49 -0
  172. data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.h +39 -0
  173. data/src/physics/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp +49 -0
  174. data/src/physics/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h +38 -0
  175. data/src/physics/Box2D/Dynamics/Contacts/b2PolygonContact.cpp +52 -0
  176. data/src/physics/Box2D/Dynamics/Contacts/b2PolygonContact.h +39 -0
  177. data/src/physics/Box2D/Dynamics/Joints/b2DistanceJoint.cpp +260 -0
  178. data/src/physics/Box2D/Dynamics/Joints/b2DistanceJoint.h +169 -0
  179. data/src/physics/Box2D/Dynamics/Joints/b2FrictionJoint.cpp +251 -0
  180. data/src/physics/Box2D/Dynamics/Joints/b2FrictionJoint.h +119 -0
  181. data/src/physics/Box2D/Dynamics/Joints/b2GearJoint.cpp +419 -0
  182. data/src/physics/Box2D/Dynamics/Joints/b2GearJoint.h +125 -0
  183. data/src/physics/Box2D/Dynamics/Joints/b2Joint.cpp +211 -0
  184. data/src/physics/Box2D/Dynamics/Joints/b2Joint.h +226 -0
  185. data/src/physics/Box2D/Dynamics/Joints/b2MotorJoint.cpp +304 -0
  186. data/src/physics/Box2D/Dynamics/Joints/b2MotorJoint.h +133 -0
  187. data/src/physics/Box2D/Dynamics/Joints/b2MouseJoint.cpp +222 -0
  188. data/src/physics/Box2D/Dynamics/Joints/b2MouseJoint.h +129 -0
  189. data/src/physics/Box2D/Dynamics/Joints/b2PrismaticJoint.cpp +629 -0
  190. data/src/physics/Box2D/Dynamics/Joints/b2PrismaticJoint.h +196 -0
  191. data/src/physics/Box2D/Dynamics/Joints/b2PulleyJoint.cpp +348 -0
  192. data/src/physics/Box2D/Dynamics/Joints/b2PulleyJoint.h +152 -0
  193. data/src/physics/Box2D/Dynamics/Joints/b2RevoluteJoint.cpp +502 -0
  194. data/src/physics/Box2D/Dynamics/Joints/b2RevoluteJoint.h +204 -0
  195. data/src/physics/Box2D/Dynamics/Joints/b2RopeJoint.cpp +241 -0
  196. data/src/physics/Box2D/Dynamics/Joints/b2RopeJoint.h +114 -0
  197. data/src/physics/Box2D/Dynamics/Joints/b2WeldJoint.cpp +344 -0
  198. data/src/physics/Box2D/Dynamics/Joints/b2WeldJoint.h +126 -0
  199. data/src/physics/Box2D/Dynamics/Joints/b2WheelJoint.cpp +419 -0
  200. data/src/physics/Box2D/Dynamics/Joints/b2WheelJoint.h +210 -0
  201. data/src/physics/Box2D/Dynamics/b2Body.cpp +549 -0
  202. data/src/physics/Box2D/Dynamics/b2Body.h +860 -0
  203. data/src/physics/Box2D/Dynamics/b2ContactManager.cpp +296 -0
  204. data/src/physics/Box2D/Dynamics/b2ContactManager.h +52 -0
  205. data/src/physics/Box2D/Dynamics/b2Fixture.cpp +303 -0
  206. data/src/physics/Box2D/Dynamics/b2Fixture.h +345 -0
  207. data/src/physics/Box2D/Dynamics/b2Island.cpp +539 -0
  208. data/src/physics/Box2D/Dynamics/b2Island.h +93 -0
  209. data/src/physics/Box2D/Dynamics/b2TimeStep.h +70 -0
  210. data/src/physics/Box2D/Dynamics/b2World.cpp +1339 -0
  211. data/src/physics/Box2D/Dynamics/b2World.h +354 -0
  212. data/src/physics/Box2D/Dynamics/b2WorldCallbacks.cpp +36 -0
  213. data/src/physics/Box2D/Dynamics/b2WorldCallbacks.h +155 -0
  214. data/src/physics/Box2D/Rope/b2Rope.cpp +259 -0
  215. data/src/physics/Box2D/Rope/b2Rope.h +115 -0
  216. data/src/style.cpp +2 -2
  217. data/src/view.cpp +217 -17
  218. data/src/window.cpp +25 -15
  219. data/src/world.cpp +206 -0
  220. data/src/world.h +96 -0
  221. data/task/box2d.rake +25 -0
  222. data/test/test_view.rb +5 -5
  223. metadata +125 -3
@@ -0,0 +1,502 @@
1
+ /*
2
+ * Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
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
+
19
+ #include <Box2D/Dynamics/Joints/b2RevoluteJoint.h>
20
+ #include <Box2D/Dynamics/b2Body.h>
21
+ #include <Box2D/Dynamics/b2TimeStep.h>
22
+
23
+ // Point-to-point constraint
24
+ // C = p2 - p1
25
+ // Cdot = v2 - v1
26
+ // = v2 + cross(w2, r2) - v1 - cross(w1, r1)
27
+ // J = [-I -r1_skew I r2_skew ]
28
+ // Identity used:
29
+ // w k % (rx i + ry j) = w * (-ry i + rx j)
30
+
31
+ // Motor constraint
32
+ // Cdot = w2 - w1
33
+ // J = [0 0 -1 0 0 1]
34
+ // K = invI1 + invI2
35
+
36
+ void b2RevoluteJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
37
+ {
38
+ bodyA = bA;
39
+ bodyB = bB;
40
+ localAnchorA = bodyA->GetLocalPoint(anchor);
41
+ localAnchorB = bodyB->GetLocalPoint(anchor);
42
+ referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
43
+ }
44
+
45
+ b2RevoluteJoint::b2RevoluteJoint(const b2RevoluteJointDef* def)
46
+ : b2Joint(def)
47
+ {
48
+ m_localAnchorA = def->localAnchorA;
49
+ m_localAnchorB = def->localAnchorB;
50
+ m_referenceAngle = def->referenceAngle;
51
+
52
+ m_impulse.SetZero();
53
+ m_motorImpulse = 0.0f;
54
+
55
+ m_lowerAngle = def->lowerAngle;
56
+ m_upperAngle = def->upperAngle;
57
+ m_maxMotorTorque = def->maxMotorTorque;
58
+ m_motorSpeed = def->motorSpeed;
59
+ m_enableLimit = def->enableLimit;
60
+ m_enableMotor = def->enableMotor;
61
+ m_limitState = e_inactiveLimit;
62
+ }
63
+
64
+ void b2RevoluteJoint::InitVelocityConstraints(const b2SolverData& data)
65
+ {
66
+ m_indexA = m_bodyA->m_islandIndex;
67
+ m_indexB = m_bodyB->m_islandIndex;
68
+ m_localCenterA = m_bodyA->m_sweep.localCenter;
69
+ m_localCenterB = m_bodyB->m_sweep.localCenter;
70
+ m_invMassA = m_bodyA->m_invMass;
71
+ m_invMassB = m_bodyB->m_invMass;
72
+ m_invIA = m_bodyA->m_invI;
73
+ m_invIB = m_bodyB->m_invI;
74
+
75
+ float32 aA = data.positions[m_indexA].a;
76
+ b2Vec2 vA = data.velocities[m_indexA].v;
77
+ float32 wA = data.velocities[m_indexA].w;
78
+
79
+ float32 aB = data.positions[m_indexB].a;
80
+ b2Vec2 vB = data.velocities[m_indexB].v;
81
+ float32 wB = data.velocities[m_indexB].w;
82
+
83
+ b2Rot qA(aA), qB(aB);
84
+
85
+ m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
86
+ m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
87
+
88
+ // J = [-I -r1_skew I r2_skew]
89
+ // [ 0 -1 0 1]
90
+ // r_skew = [-ry; rx]
91
+
92
+ // Matlab
93
+ // K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]
94
+ // [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]
95
+ // [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]
96
+
97
+ float32 mA = m_invMassA, mB = m_invMassB;
98
+ float32 iA = m_invIA, iB = m_invIB;
99
+
100
+ bool fixedRotation = (iA + iB == 0.0f);
101
+
102
+ m_mass.ex.x = mA + mB + m_rA.y * m_rA.y * iA + m_rB.y * m_rB.y * iB;
103
+ m_mass.ey.x = -m_rA.y * m_rA.x * iA - m_rB.y * m_rB.x * iB;
104
+ m_mass.ez.x = -m_rA.y * iA - m_rB.y * iB;
105
+ m_mass.ex.y = m_mass.ey.x;
106
+ m_mass.ey.y = mA + mB + m_rA.x * m_rA.x * iA + m_rB.x * m_rB.x * iB;
107
+ m_mass.ez.y = m_rA.x * iA + m_rB.x * iB;
108
+ m_mass.ex.z = m_mass.ez.x;
109
+ m_mass.ey.z = m_mass.ez.y;
110
+ m_mass.ez.z = iA + iB;
111
+
112
+ m_motorMass = iA + iB;
113
+ if (m_motorMass > 0.0f)
114
+ {
115
+ m_motorMass = 1.0f / m_motorMass;
116
+ }
117
+
118
+ if (m_enableMotor == false || fixedRotation)
119
+ {
120
+ m_motorImpulse = 0.0f;
121
+ }
122
+
123
+ if (m_enableLimit && fixedRotation == false)
124
+ {
125
+ float32 jointAngle = aB - aA - m_referenceAngle;
126
+ if (b2Abs(m_upperAngle - m_lowerAngle) < 2.0f * b2_angularSlop)
127
+ {
128
+ m_limitState = e_equalLimits;
129
+ }
130
+ else if (jointAngle <= m_lowerAngle)
131
+ {
132
+ if (m_limitState != e_atLowerLimit)
133
+ {
134
+ m_impulse.z = 0.0f;
135
+ }
136
+ m_limitState = e_atLowerLimit;
137
+ }
138
+ else if (jointAngle >= m_upperAngle)
139
+ {
140
+ if (m_limitState != e_atUpperLimit)
141
+ {
142
+ m_impulse.z = 0.0f;
143
+ }
144
+ m_limitState = e_atUpperLimit;
145
+ }
146
+ else
147
+ {
148
+ m_limitState = e_inactiveLimit;
149
+ m_impulse.z = 0.0f;
150
+ }
151
+ }
152
+ else
153
+ {
154
+ m_limitState = e_inactiveLimit;
155
+ }
156
+
157
+ if (data.step.warmStarting)
158
+ {
159
+ // Scale impulses to support a variable time step.
160
+ m_impulse *= data.step.dtRatio;
161
+ m_motorImpulse *= data.step.dtRatio;
162
+
163
+ b2Vec2 P(m_impulse.x, m_impulse.y);
164
+
165
+ vA -= mA * P;
166
+ wA -= iA * (b2Cross(m_rA, P) + m_motorImpulse + m_impulse.z);
167
+
168
+ vB += mB * P;
169
+ wB += iB * (b2Cross(m_rB, P) + m_motorImpulse + m_impulse.z);
170
+ }
171
+ else
172
+ {
173
+ m_impulse.SetZero();
174
+ m_motorImpulse = 0.0f;
175
+ }
176
+
177
+ data.velocities[m_indexA].v = vA;
178
+ data.velocities[m_indexA].w = wA;
179
+ data.velocities[m_indexB].v = vB;
180
+ data.velocities[m_indexB].w = wB;
181
+ }
182
+
183
+ void b2RevoluteJoint::SolveVelocityConstraints(const b2SolverData& data)
184
+ {
185
+ b2Vec2 vA = data.velocities[m_indexA].v;
186
+ float32 wA = data.velocities[m_indexA].w;
187
+ b2Vec2 vB = data.velocities[m_indexB].v;
188
+ float32 wB = data.velocities[m_indexB].w;
189
+
190
+ float32 mA = m_invMassA, mB = m_invMassB;
191
+ float32 iA = m_invIA, iB = m_invIB;
192
+
193
+ bool fixedRotation = (iA + iB == 0.0f);
194
+
195
+ // Solve motor constraint.
196
+ if (m_enableMotor && m_limitState != e_equalLimits && fixedRotation == false)
197
+ {
198
+ float32 Cdot = wB - wA - m_motorSpeed;
199
+ float32 impulse = -m_motorMass * Cdot;
200
+ float32 oldImpulse = m_motorImpulse;
201
+ float32 maxImpulse = data.step.dt * m_maxMotorTorque;
202
+ m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
203
+ impulse = m_motorImpulse - oldImpulse;
204
+
205
+ wA -= iA * impulse;
206
+ wB += iB * impulse;
207
+ }
208
+
209
+ // Solve limit constraint.
210
+ if (m_enableLimit && m_limitState != e_inactiveLimit && fixedRotation == false)
211
+ {
212
+ b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
213
+ float32 Cdot2 = wB - wA;
214
+ b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
215
+
216
+ b2Vec3 impulse = -m_mass.Solve33(Cdot);
217
+
218
+ if (m_limitState == e_equalLimits)
219
+ {
220
+ m_impulse += impulse;
221
+ }
222
+ else if (m_limitState == e_atLowerLimit)
223
+ {
224
+ float32 newImpulse = m_impulse.z + impulse.z;
225
+ if (newImpulse < 0.0f)
226
+ {
227
+ b2Vec2 rhs = -Cdot1 + m_impulse.z * b2Vec2(m_mass.ez.x, m_mass.ez.y);
228
+ b2Vec2 reduced = m_mass.Solve22(rhs);
229
+ impulse.x = reduced.x;
230
+ impulse.y = reduced.y;
231
+ impulse.z = -m_impulse.z;
232
+ m_impulse.x += reduced.x;
233
+ m_impulse.y += reduced.y;
234
+ m_impulse.z = 0.0f;
235
+ }
236
+ else
237
+ {
238
+ m_impulse += impulse;
239
+ }
240
+ }
241
+ else if (m_limitState == e_atUpperLimit)
242
+ {
243
+ float32 newImpulse = m_impulse.z + impulse.z;
244
+ if (newImpulse > 0.0f)
245
+ {
246
+ b2Vec2 rhs = -Cdot1 + m_impulse.z * b2Vec2(m_mass.ez.x, m_mass.ez.y);
247
+ b2Vec2 reduced = m_mass.Solve22(rhs);
248
+ impulse.x = reduced.x;
249
+ impulse.y = reduced.y;
250
+ impulse.z = -m_impulse.z;
251
+ m_impulse.x += reduced.x;
252
+ m_impulse.y += reduced.y;
253
+ m_impulse.z = 0.0f;
254
+ }
255
+ else
256
+ {
257
+ m_impulse += impulse;
258
+ }
259
+ }
260
+
261
+ b2Vec2 P(impulse.x, impulse.y);
262
+
263
+ vA -= mA * P;
264
+ wA -= iA * (b2Cross(m_rA, P) + impulse.z);
265
+
266
+ vB += mB * P;
267
+ wB += iB * (b2Cross(m_rB, P) + impulse.z);
268
+ }
269
+ else
270
+ {
271
+ // Solve point-to-point constraint
272
+ b2Vec2 Cdot = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
273
+ b2Vec2 impulse = m_mass.Solve22(-Cdot);
274
+
275
+ m_impulse.x += impulse.x;
276
+ m_impulse.y += impulse.y;
277
+
278
+ vA -= mA * impulse;
279
+ wA -= iA * b2Cross(m_rA, impulse);
280
+
281
+ vB += mB * impulse;
282
+ wB += iB * b2Cross(m_rB, impulse);
283
+ }
284
+
285
+ data.velocities[m_indexA].v = vA;
286
+ data.velocities[m_indexA].w = wA;
287
+ data.velocities[m_indexB].v = vB;
288
+ data.velocities[m_indexB].w = wB;
289
+ }
290
+
291
+ bool b2RevoluteJoint::SolvePositionConstraints(const b2SolverData& data)
292
+ {
293
+ b2Vec2 cA = data.positions[m_indexA].c;
294
+ float32 aA = data.positions[m_indexA].a;
295
+ b2Vec2 cB = data.positions[m_indexB].c;
296
+ float32 aB = data.positions[m_indexB].a;
297
+
298
+ b2Rot qA(aA), qB(aB);
299
+
300
+ float32 angularError = 0.0f;
301
+ float32 positionError = 0.0f;
302
+
303
+ bool fixedRotation = (m_invIA + m_invIB == 0.0f);
304
+
305
+ // Solve angular limit constraint.
306
+ if (m_enableLimit && m_limitState != e_inactiveLimit && fixedRotation == false)
307
+ {
308
+ float32 angle = aB - aA - m_referenceAngle;
309
+ float32 limitImpulse = 0.0f;
310
+
311
+ if (m_limitState == e_equalLimits)
312
+ {
313
+ // Prevent large angular corrections
314
+ float32 C = b2Clamp(angle - m_lowerAngle, -b2_maxAngularCorrection, b2_maxAngularCorrection);
315
+ limitImpulse = -m_motorMass * C;
316
+ angularError = b2Abs(C);
317
+ }
318
+ else if (m_limitState == e_atLowerLimit)
319
+ {
320
+ float32 C = angle - m_lowerAngle;
321
+ angularError = -C;
322
+
323
+ // Prevent large angular corrections and allow some slop.
324
+ C = b2Clamp(C + b2_angularSlop, -b2_maxAngularCorrection, 0.0f);
325
+ limitImpulse = -m_motorMass * C;
326
+ }
327
+ else if (m_limitState == e_atUpperLimit)
328
+ {
329
+ float32 C = angle - m_upperAngle;
330
+ angularError = C;
331
+
332
+ // Prevent large angular corrections and allow some slop.
333
+ C = b2Clamp(C - b2_angularSlop, 0.0f, b2_maxAngularCorrection);
334
+ limitImpulse = -m_motorMass * C;
335
+ }
336
+
337
+ aA -= m_invIA * limitImpulse;
338
+ aB += m_invIB * limitImpulse;
339
+ }
340
+
341
+ // Solve point-to-point constraint.
342
+ {
343
+ qA.Set(aA);
344
+ qB.Set(aB);
345
+ b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
346
+ b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
347
+
348
+ b2Vec2 C = cB + rB - cA - rA;
349
+ positionError = C.Length();
350
+
351
+ float32 mA = m_invMassA, mB = m_invMassB;
352
+ float32 iA = m_invIA, iB = m_invIB;
353
+
354
+ b2Mat22 K;
355
+ K.ex.x = mA + mB + iA * rA.y * rA.y + iB * rB.y * rB.y;
356
+ K.ex.y = -iA * rA.x * rA.y - iB * rB.x * rB.y;
357
+ K.ey.x = K.ex.y;
358
+ K.ey.y = mA + mB + iA * rA.x * rA.x + iB * rB.x * rB.x;
359
+
360
+ b2Vec2 impulse = -K.Solve(C);
361
+
362
+ cA -= mA * impulse;
363
+ aA -= iA * b2Cross(rA, impulse);
364
+
365
+ cB += mB * impulse;
366
+ aB += iB * b2Cross(rB, impulse);
367
+ }
368
+
369
+ data.positions[m_indexA].c = cA;
370
+ data.positions[m_indexA].a = aA;
371
+ data.positions[m_indexB].c = cB;
372
+ data.positions[m_indexB].a = aB;
373
+
374
+ return positionError <= b2_linearSlop && angularError <= b2_angularSlop;
375
+ }
376
+
377
+ b2Vec2 b2RevoluteJoint::GetAnchorA() const
378
+ {
379
+ return m_bodyA->GetWorldPoint(m_localAnchorA);
380
+ }
381
+
382
+ b2Vec2 b2RevoluteJoint::GetAnchorB() const
383
+ {
384
+ return m_bodyB->GetWorldPoint(m_localAnchorB);
385
+ }
386
+
387
+ b2Vec2 b2RevoluteJoint::GetReactionForce(float32 inv_dt) const
388
+ {
389
+ b2Vec2 P(m_impulse.x, m_impulse.y);
390
+ return inv_dt * P;
391
+ }
392
+
393
+ float32 b2RevoluteJoint::GetReactionTorque(float32 inv_dt) const
394
+ {
395
+ return inv_dt * m_impulse.z;
396
+ }
397
+
398
+ float32 b2RevoluteJoint::GetJointAngle() const
399
+ {
400
+ b2Body* bA = m_bodyA;
401
+ b2Body* bB = m_bodyB;
402
+ return bB->m_sweep.a - bA->m_sweep.a - m_referenceAngle;
403
+ }
404
+
405
+ float32 b2RevoluteJoint::GetJointSpeed() const
406
+ {
407
+ b2Body* bA = m_bodyA;
408
+ b2Body* bB = m_bodyB;
409
+ return bB->m_angularVelocity - bA->m_angularVelocity;
410
+ }
411
+
412
+ bool b2RevoluteJoint::IsMotorEnabled() const
413
+ {
414
+ return m_enableMotor;
415
+ }
416
+
417
+ void b2RevoluteJoint::EnableMotor(bool flag)
418
+ {
419
+ m_bodyA->SetAwake(true);
420
+ m_bodyB->SetAwake(true);
421
+ m_enableMotor = flag;
422
+ }
423
+
424
+ float32 b2RevoluteJoint::GetMotorTorque(float32 inv_dt) const
425
+ {
426
+ return inv_dt * m_motorImpulse;
427
+ }
428
+
429
+ void b2RevoluteJoint::SetMotorSpeed(float32 speed)
430
+ {
431
+ m_bodyA->SetAwake(true);
432
+ m_bodyB->SetAwake(true);
433
+ m_motorSpeed = speed;
434
+ }
435
+
436
+ void b2RevoluteJoint::SetMaxMotorTorque(float32 torque)
437
+ {
438
+ m_bodyA->SetAwake(true);
439
+ m_bodyB->SetAwake(true);
440
+ m_maxMotorTorque = torque;
441
+ }
442
+
443
+ bool b2RevoluteJoint::IsLimitEnabled() const
444
+ {
445
+ return m_enableLimit;
446
+ }
447
+
448
+ void b2RevoluteJoint::EnableLimit(bool flag)
449
+ {
450
+ if (flag != m_enableLimit)
451
+ {
452
+ m_bodyA->SetAwake(true);
453
+ m_bodyB->SetAwake(true);
454
+ m_enableLimit = flag;
455
+ m_impulse.z = 0.0f;
456
+ }
457
+ }
458
+
459
+ float32 b2RevoluteJoint::GetLowerLimit() const
460
+ {
461
+ return m_lowerAngle;
462
+ }
463
+
464
+ float32 b2RevoluteJoint::GetUpperLimit() const
465
+ {
466
+ return m_upperAngle;
467
+ }
468
+
469
+ void b2RevoluteJoint::SetLimits(float32 lower, float32 upper)
470
+ {
471
+ b2Assert(lower <= upper);
472
+
473
+ if (lower != m_lowerAngle || upper != m_upperAngle)
474
+ {
475
+ m_bodyA->SetAwake(true);
476
+ m_bodyB->SetAwake(true);
477
+ m_impulse.z = 0.0f;
478
+ m_lowerAngle = lower;
479
+ m_upperAngle = upper;
480
+ }
481
+ }
482
+
483
+ void b2RevoluteJoint::Dump()
484
+ {
485
+ int32 indexA = m_bodyA->m_islandIndex;
486
+ int32 indexB = m_bodyB->m_islandIndex;
487
+
488
+ b2Log(" b2RevoluteJointDef jd;\n");
489
+ b2Log(" jd.bodyA = bodies[%d];\n", indexA);
490
+ b2Log(" jd.bodyB = bodies[%d];\n", indexB);
491
+ b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
492
+ b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
493
+ b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
494
+ b2Log(" jd.referenceAngle = %.15lef;\n", m_referenceAngle);
495
+ b2Log(" jd.enableLimit = bool(%d);\n", m_enableLimit);
496
+ b2Log(" jd.lowerAngle = %.15lef;\n", m_lowerAngle);
497
+ b2Log(" jd.upperAngle = %.15lef;\n", m_upperAngle);
498
+ b2Log(" jd.enableMotor = bool(%d);\n", m_enableMotor);
499
+ b2Log(" jd.motorSpeed = %.15lef;\n", m_motorSpeed);
500
+ b2Log(" jd.maxMotorTorque = %.15lef;\n", m_maxMotorTorque);
501
+ b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
502
+ }
@@ -0,0 +1,204 @@
1
+ /*
2
+ * Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
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
+
19
+ #ifndef B2_REVOLUTE_JOINT_H
20
+ #define B2_REVOLUTE_JOINT_H
21
+
22
+ #include <Box2D/Dynamics/Joints/b2Joint.h>
23
+
24
+ /// Revolute joint definition. This requires defining an
25
+ /// anchor point where the bodies are joined. The definition
26
+ /// uses local anchor points so that the initial configuration
27
+ /// can violate the constraint slightly. You also need to
28
+ /// specify the initial relative angle for joint limits. This
29
+ /// helps when saving and loading a game.
30
+ /// The local anchor points are measured from the body's origin
31
+ /// rather than the center of mass because:
32
+ /// 1. you might not know where the center of mass will be.
33
+ /// 2. if you add/remove shapes from a body and recompute the mass,
34
+ /// the joints will be broken.
35
+ struct b2RevoluteJointDef : public b2JointDef
36
+ {
37
+ b2RevoluteJointDef()
38
+ {
39
+ type = e_revoluteJoint;
40
+ localAnchorA.Set(0.0f, 0.0f);
41
+ localAnchorB.Set(0.0f, 0.0f);
42
+ referenceAngle = 0.0f;
43
+ lowerAngle = 0.0f;
44
+ upperAngle = 0.0f;
45
+ maxMotorTorque = 0.0f;
46
+ motorSpeed = 0.0f;
47
+ enableLimit = false;
48
+ enableMotor = false;
49
+ }
50
+
51
+ /// Initialize the bodies, anchors, and reference angle using a world
52
+ /// anchor point.
53
+ void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
54
+
55
+ /// The local anchor point relative to bodyA's origin.
56
+ b2Vec2 localAnchorA;
57
+
58
+ /// The local anchor point relative to bodyB's origin.
59
+ b2Vec2 localAnchorB;
60
+
61
+ /// The bodyB angle minus bodyA angle in the reference state (radians).
62
+ float32 referenceAngle;
63
+
64
+ /// A flag to enable joint limits.
65
+ bool enableLimit;
66
+
67
+ /// The lower angle for the joint limit (radians).
68
+ float32 lowerAngle;
69
+
70
+ /// The upper angle for the joint limit (radians).
71
+ float32 upperAngle;
72
+
73
+ /// A flag to enable the joint motor.
74
+ bool enableMotor;
75
+
76
+ /// The desired motor speed. Usually in radians per second.
77
+ float32 motorSpeed;
78
+
79
+ /// The maximum motor torque used to achieve the desired motor speed.
80
+ /// Usually in N-m.
81
+ float32 maxMotorTorque;
82
+ };
83
+
84
+ /// A revolute joint constrains two bodies to share a common point while they
85
+ /// are free to rotate about the point. The relative rotation about the shared
86
+ /// point is the joint angle. You can limit the relative rotation with
87
+ /// a joint limit that specifies a lower and upper angle. You can use a motor
88
+ /// to drive the relative rotation about the shared point. A maximum motor torque
89
+ /// is provided so that infinite forces are not generated.
90
+ class b2RevoluteJoint : public b2Joint
91
+ {
92
+ public:
93
+ b2Vec2 GetAnchorA() const;
94
+ b2Vec2 GetAnchorB() const;
95
+
96
+ /// The local anchor point relative to bodyA's origin.
97
+ const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
98
+
99
+ /// The local anchor point relative to bodyB's origin.
100
+ const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
101
+
102
+ /// Get the reference angle.
103
+ float32 GetReferenceAngle() const { return m_referenceAngle; }
104
+
105
+ /// Get the current joint angle in radians.
106
+ float32 GetJointAngle() const;
107
+
108
+ /// Get the current joint angle speed in radians per second.
109
+ float32 GetJointSpeed() const;
110
+
111
+ /// Is the joint limit enabled?
112
+ bool IsLimitEnabled() const;
113
+
114
+ /// Enable/disable the joint limit.
115
+ void EnableLimit(bool flag);
116
+
117
+ /// Get the lower joint limit in radians.
118
+ float32 GetLowerLimit() const;
119
+
120
+ /// Get the upper joint limit in radians.
121
+ float32 GetUpperLimit() const;
122
+
123
+ /// Set the joint limits in radians.
124
+ void SetLimits(float32 lower, float32 upper);
125
+
126
+ /// Is the joint motor enabled?
127
+ bool IsMotorEnabled() const;
128
+
129
+ /// Enable/disable the joint motor.
130
+ void EnableMotor(bool flag);
131
+
132
+ /// Set the motor speed in radians per second.
133
+ void SetMotorSpeed(float32 speed);
134
+
135
+ /// Get the motor speed in radians per second.
136
+ float32 GetMotorSpeed() const;
137
+
138
+ /// Set the maximum motor torque, usually in N-m.
139
+ void SetMaxMotorTorque(float32 torque);
140
+ float32 GetMaxMotorTorque() const { return m_maxMotorTorque; }
141
+
142
+ /// Get the reaction force given the inverse time step.
143
+ /// Unit is N.
144
+ b2Vec2 GetReactionForce(float32 inv_dt) const;
145
+
146
+ /// Get the reaction torque due to the joint limit given the inverse time step.
147
+ /// Unit is N*m.
148
+ float32 GetReactionTorque(float32 inv_dt) const;
149
+
150
+ /// Get the current motor torque given the inverse time step.
151
+ /// Unit is N*m.
152
+ float32 GetMotorTorque(float32 inv_dt) const;
153
+
154
+ /// Dump to b2Log.
155
+ void Dump();
156
+
157
+ protected:
158
+
159
+ friend class b2Joint;
160
+ friend class b2GearJoint;
161
+
162
+ b2RevoluteJoint(const b2RevoluteJointDef* def);
163
+
164
+ void InitVelocityConstraints(const b2SolverData& data);
165
+ void SolveVelocityConstraints(const b2SolverData& data);
166
+ bool SolvePositionConstraints(const b2SolverData& data);
167
+
168
+ // Solver shared
169
+ b2Vec2 m_localAnchorA;
170
+ b2Vec2 m_localAnchorB;
171
+ b2Vec3 m_impulse;
172
+ float32 m_motorImpulse;
173
+
174
+ bool m_enableMotor;
175
+ float32 m_maxMotorTorque;
176
+ float32 m_motorSpeed;
177
+
178
+ bool m_enableLimit;
179
+ float32 m_referenceAngle;
180
+ float32 m_lowerAngle;
181
+ float32 m_upperAngle;
182
+
183
+ // Solver temp
184
+ int32 m_indexA;
185
+ int32 m_indexB;
186
+ b2Vec2 m_rA;
187
+ b2Vec2 m_rB;
188
+ b2Vec2 m_localCenterA;
189
+ b2Vec2 m_localCenterB;
190
+ float32 m_invMassA;
191
+ float32 m_invMassB;
192
+ float32 m_invIA;
193
+ float32 m_invIB;
194
+ b2Mat33 m_mass; // effective mass for point-to-point constraint.
195
+ float32 m_motorMass; // effective mass for motor/limit angular constraint.
196
+ b2LimitState m_limitState;
197
+ };
198
+
199
+ inline float32 b2RevoluteJoint::GetMotorSpeed() const
200
+ {
201
+ return m_motorSpeed;
202
+ }
203
+
204
+ #endif