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.
- checksums.yaml +4 -4
- data/.doc/ext/reflex/application.cpp +5 -5
- data/.doc/ext/reflex/body.cpp +167 -0
- data/.doc/ext/reflex/capture_event.cpp +4 -4
- data/.doc/ext/reflex/draw_event.cpp +4 -4
- data/.doc/ext/reflex/event.cpp +4 -4
- data/.doc/ext/reflex/fixture.cpp +101 -0
- data/.doc/ext/reflex/focus_event.cpp +4 -4
- data/.doc/ext/reflex/frame_event.cpp +4 -4
- data/.doc/ext/reflex/image_view.cpp +22 -5
- data/.doc/ext/reflex/key_event.cpp +4 -4
- data/.doc/ext/reflex/native.cpp +6 -0
- data/.doc/ext/reflex/pointer_event.cpp +4 -4
- data/.doc/ext/reflex/reflex.cpp +2 -3
- data/.doc/ext/reflex/scroll_event.cpp +4 -4
- data/.doc/ext/reflex/selector.cpp +4 -4
- data/.doc/ext/reflex/style.cpp +4 -4
- data/.doc/ext/reflex/style_length.cpp +4 -4
- data/.doc/ext/reflex/style_length2.cpp +4 -4
- data/.doc/ext/reflex/style_length4.cpp +4 -4
- data/.doc/ext/reflex/update_event.cpp +4 -4
- data/.doc/ext/reflex/view.cpp +110 -8
- data/.doc/ext/reflex/wheel_event.cpp +4 -4
- data/.doc/ext/reflex/window.cpp +36 -12
- data/README.md +2 -2
- data/Rakefile +2 -1
- data/VERSION +1 -1
- data/ext/reflex/application.cpp +8 -8
- data/ext/reflex/body.cpp +181 -0
- data/ext/reflex/capture_event.cpp +4 -4
- data/ext/reflex/draw_event.cpp +4 -4
- data/ext/reflex/event.cpp +4 -4
- data/ext/reflex/fixture.cpp +108 -0
- data/ext/reflex/focus_event.cpp +4 -4
- data/ext/reflex/frame_event.cpp +4 -4
- data/ext/reflex/image_view.cpp +24 -5
- data/ext/reflex/key_event.cpp +4 -4
- data/ext/reflex/native.cpp +6 -0
- data/ext/reflex/pointer_event.cpp +4 -4
- data/ext/reflex/reflex.cpp +2 -3
- data/ext/reflex/scroll_event.cpp +4 -4
- data/ext/reflex/selector.cpp +4 -4
- data/ext/reflex/style.cpp +4 -4
- data/ext/reflex/style_length.cpp +4 -4
- data/ext/reflex/style_length2.cpp +4 -4
- data/ext/reflex/style_length4.cpp +4 -4
- data/ext/reflex/update_event.cpp +4 -4
- data/ext/reflex/view.cpp +126 -12
- data/ext/reflex/wheel_event.cpp +4 -4
- data/ext/reflex/window.cpp +39 -12
- data/include/reflex/bitmap.h +20 -0
- data/include/reflex/body.h +82 -0
- data/include/reflex/bounds.h +20 -0
- data/include/reflex/color.h +20 -0
- data/include/reflex/color_space.h +20 -0
- data/include/reflex/defs.h +5 -1
- data/include/reflex/event.h +16 -25
- data/include/reflex/fixture.h +116 -0
- data/include/reflex/font.h +20 -0
- data/include/reflex/image.h +20 -0
- data/include/reflex/image_view.h +1 -1
- data/include/reflex/matrix.h +20 -0
- data/include/reflex/painter.h +20 -0
- data/include/reflex/point.h +24 -0
- data/include/reflex/ruby/application.h +6 -0
- data/include/reflex/ruby/body.h +41 -0
- data/include/reflex/ruby/event.h +68 -0
- data/include/reflex/ruby/fixture.h +41 -0
- data/include/reflex/ruby/image_view.h +14 -0
- data/include/reflex/ruby/selector.h +14 -0
- data/include/reflex/ruby/style.h +14 -0
- data/include/reflex/ruby/style_length.h +26 -0
- data/include/reflex/ruby/view.h +43 -39
- data/include/reflex/ruby/window.h +27 -21
- data/include/reflex/ruby.h +2 -0
- data/include/reflex/shader.h +20 -0
- data/include/reflex/style.h +2 -3
- data/include/reflex/texture.h +20 -0
- data/include/reflex/view.h +45 -24
- data/include/reflex/window.h +11 -14
- data/include/reflex.h +3 -0
- data/lib/reflex/application.rb +6 -2
- data/lib/reflex/body.rb +17 -0
- data/lib/reflex/fixture.rb +17 -0
- data/lib/reflex/view.rb +16 -1
- data/lib/reflex/window.rb +13 -1
- data/lib/reflex.rb +2 -0
- data/reflex.gemspec +1 -1
- data/samples/bats.rb +4 -3
- data/samples/checker.rb +4 -3
- data/samples/fans.rb +4 -3
- data/samples/fps.rb +5 -3
- data/samples/grid.rb +5 -4
- data/samples/hello.rb +1 -1
- data/samples/image.rb +3 -2
- data/samples/ios/hello/hello/main.cpp +12 -3
- data/samples/ios/hello/hello.xcodeproj/project.pbxproj +376 -123
- data/samples/key.rb +5 -4
- data/samples/layout.rb +3 -2
- data/samples/model.rb +3 -2
- data/samples/osx/hello/hello/main.cpp +12 -3
- data/samples/osx/hello/hello.xcodeproj/project.pbxproj +375 -120
- data/samples/physics.rb +37 -0
- data/samples/repl.rb +3 -2
- data/samples/shader.rb +4 -4
- data/samples/shapes.rb +4 -4
- data/samples/text.rb +6 -4
- data/samples/tree.rb +5 -4
- data/samples/views.rb +3 -2
- data/samples/visuals.rb +1 -2
- data/src/body.cpp +244 -0
- data/src/event.cpp +18 -18
- data/src/fixture.cpp +108 -0
- data/src/image_view.cpp +1 -1
- data/src/ios/native_window.h +2 -0
- data/src/ios/native_window.mm +18 -1
- data/src/ios/opengl_view.mm +8 -0
- data/src/ios/window.mm +24 -3
- data/src/ios/window_data.h +3 -3
- data/src/osx/native_window.mm +17 -1
- data/src/osx/window.mm +24 -3
- data/src/osx/window_data.h +3 -3
- data/src/physics/Box2D/Box2D.h +68 -0
- data/src/physics/Box2D/Collision/Shapes/b2ChainShape.cpp +193 -0
- data/src/physics/Box2D/Collision/Shapes/b2ChainShape.h +105 -0
- data/src/physics/Box2D/Collision/Shapes/b2CircleShape.cpp +99 -0
- data/src/physics/Box2D/Collision/Shapes/b2CircleShape.h +91 -0
- data/src/physics/Box2D/Collision/Shapes/b2EdgeShape.cpp +138 -0
- data/src/physics/Box2D/Collision/Shapes/b2EdgeShape.h +74 -0
- data/src/physics/Box2D/Collision/Shapes/b2PolygonShape.cpp +467 -0
- data/src/physics/Box2D/Collision/Shapes/b2PolygonShape.h +101 -0
- data/src/physics/Box2D/Collision/Shapes/b2Shape.h +101 -0
- data/src/physics/Box2D/Collision/b2BroadPhase.cpp +119 -0
- data/src/physics/Box2D/Collision/b2BroadPhase.h +257 -0
- data/src/physics/Box2D/Collision/b2CollideCircle.cpp +154 -0
- data/src/physics/Box2D/Collision/b2CollideEdge.cpp +698 -0
- data/src/physics/Box2D/Collision/b2CollidePolygon.cpp +239 -0
- data/src/physics/Box2D/Collision/b2Collision.cpp +252 -0
- data/src/physics/Box2D/Collision/b2Collision.h +277 -0
- data/src/physics/Box2D/Collision/b2Distance.cpp +603 -0
- data/src/physics/Box2D/Collision/b2Distance.h +141 -0
- data/src/physics/Box2D/Collision/b2DynamicTree.cpp +778 -0
- data/src/physics/Box2D/Collision/b2DynamicTree.h +289 -0
- data/src/physics/Box2D/Collision/b2TimeOfImpact.cpp +486 -0
- data/src/physics/Box2D/Collision/b2TimeOfImpact.h +58 -0
- data/src/physics/Box2D/Common/b2BlockAllocator.cpp +215 -0
- data/src/physics/Box2D/Common/b2BlockAllocator.h +62 -0
- data/src/physics/Box2D/Common/b2Draw.cpp +44 -0
- data/src/physics/Box2D/Common/b2Draw.h +86 -0
- data/src/physics/Box2D/Common/b2GrowableStack.h +85 -0
- data/src/physics/Box2D/Common/b2Math.cpp +94 -0
- data/src/physics/Box2D/Common/b2Math.h +720 -0
- data/src/physics/Box2D/Common/b2Settings.cpp +44 -0
- data/src/physics/Box2D/Common/b2Settings.h +151 -0
- data/src/physics/Box2D/Common/b2StackAllocator.cpp +83 -0
- data/src/physics/Box2D/Common/b2StackAllocator.h +60 -0
- data/src/physics/Box2D/Common/b2Timer.cpp +101 -0
- data/src/physics/Box2D/Common/b2Timer.h +50 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp +53 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp +53 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2CircleContact.cpp +52 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2CircleContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2Contact.cpp +247 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2Contact.h +349 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ContactSolver.cpp +838 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2ContactSolver.h +95 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp +49 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp +49 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp +49 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h +38 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2PolygonContact.cpp +52 -0
- data/src/physics/Box2D/Dynamics/Contacts/b2PolygonContact.h +39 -0
- data/src/physics/Box2D/Dynamics/Joints/b2DistanceJoint.cpp +260 -0
- data/src/physics/Box2D/Dynamics/Joints/b2DistanceJoint.h +169 -0
- data/src/physics/Box2D/Dynamics/Joints/b2FrictionJoint.cpp +251 -0
- data/src/physics/Box2D/Dynamics/Joints/b2FrictionJoint.h +119 -0
- data/src/physics/Box2D/Dynamics/Joints/b2GearJoint.cpp +419 -0
- data/src/physics/Box2D/Dynamics/Joints/b2GearJoint.h +125 -0
- data/src/physics/Box2D/Dynamics/Joints/b2Joint.cpp +211 -0
- data/src/physics/Box2D/Dynamics/Joints/b2Joint.h +226 -0
- data/src/physics/Box2D/Dynamics/Joints/b2MotorJoint.cpp +304 -0
- data/src/physics/Box2D/Dynamics/Joints/b2MotorJoint.h +133 -0
- data/src/physics/Box2D/Dynamics/Joints/b2MouseJoint.cpp +222 -0
- data/src/physics/Box2D/Dynamics/Joints/b2MouseJoint.h +129 -0
- data/src/physics/Box2D/Dynamics/Joints/b2PrismaticJoint.cpp +629 -0
- data/src/physics/Box2D/Dynamics/Joints/b2PrismaticJoint.h +196 -0
- data/src/physics/Box2D/Dynamics/Joints/b2PulleyJoint.cpp +348 -0
- data/src/physics/Box2D/Dynamics/Joints/b2PulleyJoint.h +152 -0
- data/src/physics/Box2D/Dynamics/Joints/b2RevoluteJoint.cpp +502 -0
- data/src/physics/Box2D/Dynamics/Joints/b2RevoluteJoint.h +204 -0
- data/src/physics/Box2D/Dynamics/Joints/b2RopeJoint.cpp +241 -0
- data/src/physics/Box2D/Dynamics/Joints/b2RopeJoint.h +114 -0
- data/src/physics/Box2D/Dynamics/Joints/b2WeldJoint.cpp +344 -0
- data/src/physics/Box2D/Dynamics/Joints/b2WeldJoint.h +126 -0
- data/src/physics/Box2D/Dynamics/Joints/b2WheelJoint.cpp +419 -0
- data/src/physics/Box2D/Dynamics/Joints/b2WheelJoint.h +210 -0
- data/src/physics/Box2D/Dynamics/b2Body.cpp +549 -0
- data/src/physics/Box2D/Dynamics/b2Body.h +860 -0
- data/src/physics/Box2D/Dynamics/b2ContactManager.cpp +296 -0
- data/src/physics/Box2D/Dynamics/b2ContactManager.h +52 -0
- data/src/physics/Box2D/Dynamics/b2Fixture.cpp +303 -0
- data/src/physics/Box2D/Dynamics/b2Fixture.h +345 -0
- data/src/physics/Box2D/Dynamics/b2Island.cpp +539 -0
- data/src/physics/Box2D/Dynamics/b2Island.h +93 -0
- data/src/physics/Box2D/Dynamics/b2TimeStep.h +70 -0
- data/src/physics/Box2D/Dynamics/b2World.cpp +1339 -0
- data/src/physics/Box2D/Dynamics/b2World.h +354 -0
- data/src/physics/Box2D/Dynamics/b2WorldCallbacks.cpp +36 -0
- data/src/physics/Box2D/Dynamics/b2WorldCallbacks.h +155 -0
- data/src/physics/Box2D/Rope/b2Rope.cpp +259 -0
- data/src/physics/Box2D/Rope/b2Rope.h +115 -0
- data/src/style.cpp +2 -2
- data/src/view.cpp +217 -17
- data/src/window.cpp +25 -15
- data/src/world.cpp +206 -0
- data/src/world.h +96 -0
- data/task/box2d.rake +25 -0
- data/test/test_view.rb +5 -5
- 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
|