Panda3D

Loading...
Searching...
No Matches
bulletHingeConstraint.cxx
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file bulletHingeConstraint.cxx
10 * @author enn0x
11 * @date 2010-03-01
12 */
13
14#include "bulletHingeConstraint.h"
15
16#include "bulletRigidBodyNode.h"
17#include "bulletWorld.h"
18
19#include "deg_2_rad.h"
20
21 TypeHandle BulletHingeConstraint::_type_handle;
22
23/**
24 * Creates a hinge constraint which connects one rigid body with some fixe
25 * dpoint in the world.
26 */
27 BulletHingeConstraint::
28 BulletHingeConstraint(const BulletRigidBodyNode *node_a,
29 const TransformState *ts_a,
30 bool use_frame_a) {
31
32 btRigidBody *ptr_a = btRigidBody::upcast(node_a->get_object());
33 btTransform frame_a = TransformState_to_btTrans(ts_a);
34
35 _constraint = new btHingeConstraint(*ptr_a, frame_a, use_frame_a);
36}
37
38/**
39 * Constructs a hinge constraint which connects two rigid bodies.
40 */
41 BulletHingeConstraint::
42 BulletHingeConstraint(const BulletRigidBodyNode *node_a,
43 const BulletRigidBodyNode *node_b,
44 const TransformState *ts_a,
45 const TransformState *ts_b,
46 bool use_frame_a) {
47
48 btRigidBody *ptr_a = btRigidBody::upcast(node_a->get_object());
49 btTransform frame_a = TransformState_to_btTrans(ts_a);
50
51 btRigidBody *ptr_b = btRigidBody::upcast(node_b->get_object());
52 btTransform frame_b = TransformState_to_btTrans(ts_b);
53
54 _constraint = new btHingeConstraint(*ptr_a, *ptr_b, frame_a, frame_b, use_frame_a);
55}
56
57/**
58 * Creates a hinge constraint in the same way as the other constructor, but
59 * uses the world as second body so that node_a is fixed to some point in mid-
60 * air for example.
61 */
62 BulletHingeConstraint::
63 BulletHingeConstraint(const BulletRigidBodyNode *node_a,
64 const LPoint3 &pivot_a,
65 const LVector3 &axis_a,
66 bool use_frame_a) {
67
68 btRigidBody *ptr_a = btRigidBody::upcast(node_a->get_object());
69 btVector3 pos_a = LVecBase3_to_btVector3(pivot_a);
70 btVector3 vec_a = LVecBase3_to_btVector3(axis_a);
71
72 _constraint = new btHingeConstraint(*ptr_a, pos_a, vec_a, use_frame_a);
73}
74
75/**
76 * Creates a hinge connecting node_a to node_b. The pivot point is the point
77 * at which the body is fixed to the constraint. In other words: It specifies
78 * where on each body the rotation axis should be. This axis is specified
79 * using axis_a and axis_b. Remember, everything is specified in the bodies
80 * own coordinate system!
81 */
82 BulletHingeConstraint::
83 BulletHingeConstraint(const BulletRigidBodyNode *node_a,
84 const BulletRigidBodyNode *node_b,
85 const LPoint3 &pivot_a,
86 const LPoint3 &pivot_b,
87 const LVector3 &axis_a,
88 const LVector3 &axis_b,
89 bool use_frame_a) {
90
91 btRigidBody *ptr_a = btRigidBody::upcast(node_a->get_object());
92 btVector3 pos_a = LVecBase3_to_btVector3(pivot_a);
93 btVector3 vec_a = LVecBase3_to_btVector3(axis_a);
94
95 btRigidBody *ptr_b = btRigidBody::upcast(node_b->get_object());
96 btVector3 pos_b = LVecBase3_to_btVector3(pivot_b);
97 btVector3 vec_b = LVecBase3_to_btVector3(axis_b);
98
99 _constraint = new btHingeConstraint(*ptr_a, *ptr_b, pos_a, pos_b, vec_a, vec_b, use_frame_a);
100}
101
102/**
103 *
104 */
105btTypedConstraint *BulletHingeConstraint::
106ptr() const {
107
108 return _constraint;
109}
110
111/**
112 *
113 */
114 void BulletHingeConstraint::
115set_angular_only(bool value) {
116 LightMutexHolder holder(BulletWorld::get_global_lock());
117
118 return _constraint->setAngularOnly(value);
119}
120
121/**
122 *
123 */
124 bool BulletHingeConstraint::
125get_angular_only() const {
126 LightMutexHolder holder(BulletWorld::get_global_lock());
127
128 return _constraint->getAngularOnly();
129}
130
131/**
132 * Sets the lower and upper rotational limits in degrees.
133 */
134 void BulletHingeConstraint::
135 set_limit(PN_stdfloat low, PN_stdfloat high, PN_stdfloat softness, PN_stdfloat bias, PN_stdfloat relaxation) {
136 LightMutexHolder holder(BulletWorld::get_global_lock());
137
138 low = deg_2_rad(low);
139 high = deg_2_rad(high);
140
141 _constraint->setLimit(low, high, softness, bias, relaxation);
142}
143
144/**
145 * Sets the hinge's rotation axis in world coordinates.
146 */
147 void BulletHingeConstraint::
148 set_axis(const LVector3 &axis) {
149 LightMutexHolder holder(BulletWorld::get_global_lock());
150
151 nassertv(!axis.is_nan());
152
153 btVector3 v = LVecBase3_to_btVector3(axis);
154 _constraint->setAxis(v);
155}
156
157/**
158 * Returns the lower angular limit in degrees.
159 */
160PN_stdfloat BulletHingeConstraint::
161 get_lower_limit() const {
162 LightMutexHolder holder(BulletWorld::get_global_lock());
163
164 return rad_2_deg(_constraint->getLowerLimit());
165}
166
167/**
168 * Returns the upper angular limit in degrees.
169 */
170PN_stdfloat BulletHingeConstraint::
171 get_upper_limit() const {
172 LightMutexHolder holder(BulletWorld::get_global_lock());
173
174 return rad_2_deg(_constraint->getUpperLimit());
175}
176
177/**
178 * Returns the angle between node_a and node_b in degrees.
179 */
180PN_stdfloat BulletHingeConstraint::
181 get_hinge_angle() {
182 LightMutexHolder holder(BulletWorld::get_global_lock());
183
184 return rad_2_deg(_constraint->getHingeAngle());
185}
186
187/**
188 * Applies an impulse to the constraint so that the angle changes at
189 * target_velocity where max_impulse is the maximum impulse that is used for
190 * achieving the specified velocity.
191 *
192 * Note that the target_velocity is in radians/second, not degrees.
193 */
194 void BulletHingeConstraint::
195 enable_angular_motor(bool enable, PN_stdfloat target_velocity, PN_stdfloat max_impulse) {
196 LightMutexHolder holder(BulletWorld::get_global_lock());
197
198 _constraint->enableAngularMotor(enable, target_velocity, max_impulse);
199}
200
201/**
202 *
203 */
204 void BulletHingeConstraint::
205enable_motor(bool enable) {
206 LightMutexHolder holder(BulletWorld::get_global_lock());
207
208 _constraint->enableMotor(enable);
209}
210
211/**
212 * Sets the maximum impulse used to achieve the velocity set in
213 * enable_angular_motor.
214 */
215 void BulletHingeConstraint::
216 set_max_motor_impulse(PN_stdfloat max_impulse) {
217 LightMutexHolder holder(BulletWorld::get_global_lock());
218
219 _constraint->setMaxMotorImpulse(max_impulse);
220}
221
222/**
223 *
224 */
225 void BulletHingeConstraint::
226set_motor_target(const LQuaternion &quat, PN_stdfloat dt) {
227 LightMutexHolder holder(BulletWorld::get_global_lock());
228
229 _constraint->setMotorTarget(LQuaternion_to_btQuat(quat), dt);
230}
231
232/**
233 *
234 */
235 void BulletHingeConstraint::
236set_motor_target(PN_stdfloat target_angle, PN_stdfloat dt) {
237 LightMutexHolder holder(BulletWorld::get_global_lock());
238
239 _constraint->setMotorTarget(target_angle, dt);
240}
241
242/**
243 *
244 */
245 void BulletHingeConstraint::
246set_frames(const TransformState *ts_a, const TransformState *ts_b) {
247 LightMutexHolder holder(BulletWorld::get_global_lock());
248
249 btTransform frame_a = TransformState_to_btTrans(ts_a);
250 btTransform frame_b = TransformState_to_btTrans(ts_b);
251
252 _constraint->setFrames(frame_a, frame_b);
253}
254
255/**
256 *
257 */
258CPT(TransformState) BulletHingeConstraint::
259get_frame_a() const {
260 LightMutexHolder holder(BulletWorld::get_global_lock());
261
262 return btTrans_to_TransformState(_constraint->getAFrame());
263}
264
265/**
266 *
267 */
268CPT(TransformState) BulletHingeConstraint::
269get_frame_b() const {
270 LightMutexHolder holder(BulletWorld::get_global_lock());
271
272 return btTrans_to_TransformState(_constraint->getBFrame());
273}
bulletHingeConstraint.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
bulletRigidBodyNode.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
bulletWorld.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
BulletHingeConstraint::get_hinge_angle
get_hinge_angle
Returns the angle between node_a and node_b in degrees.
Definition bulletHingeConstraint.h:75
BulletHingeConstraint::get_lower_limit
get_lower_limit
Returns the lower angular limit in degrees.
Definition bulletHingeConstraint.h:76
BulletHingeConstraint::enable_angular_motor
void enable_angular_motor(bool enable, PN_stdfloat target_velocity, PN_stdfloat max_impulse)
Applies an impulse to the constraint so that the angle changes at target_velocity where max_impulse i...
Definition bulletHingeConstraint.cxx:195
BulletHingeConstraint::get_upper_limit
get_upper_limit
Returns the upper angular limit in degrees.
Definition bulletHingeConstraint.h:77
BulletHingeConstraint::set_axis
void set_axis(const LVector3 &axis)
Sets the hinge's rotation axis in world coordinates.
Definition bulletHingeConstraint.cxx:148
BulletHingeConstraint::set_limit
void set_limit(PN_stdfloat low, PN_stdfloat high, PN_stdfloat softness=0.9f, PN_stdfloat bias=0.3f, PN_stdfloat relaxation=1.0f)
Sets the lower and upper rotational limits in degrees.
Definition bulletHingeConstraint.cxx:135
BulletHingeConstraint::set_max_motor_impulse
void set_max_motor_impulse(PN_stdfloat max_impulse)
Sets the maximum impulse used to achieve the velocity set in enable_angular_motor.
Definition bulletHingeConstraint.cxx:216
BulletHingeConstraint::BulletHingeConstraint
BulletHingeConstraint(const BulletRigidBodyNode *node_a, const LPoint3 &pivot_a, const LVector3 &axis_a, bool use_frame_a=false)
Creates a hinge constraint in the same way as the other constructor, but uses the world as second bod...
Definition bulletHingeConstraint.cxx:63
BulletRigidBodyNode
Definition bulletRigidBodyNode.h:31
LightMutexHolder
Similar to MutexHolder, but for a light mutex.
Definition lightMutexHolder.h:25
TransformState
Indicates a coordinate-system transform on vertices.
Definition transformState.h:54
TypeHandle
TypeHandle is the identifier used to differentiate C++ class types.
Definition typeHandle.h:81
deg_2_rad.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.