1 /*************************************************************************/
2 /* physics_body.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30 #include "physics_body.h"
31 #include "scene/scene_string_names.h"
32
_notification(int p_what)33 void PhysicsBody::_notification(int p_what) {
34
35 /*
36 switch(p_what) {
37
38 case NOTIFICATION_TRANSFORM_CHANGED: {
39
40 PhysicsServer::get_singleton()->body_set_state(get_rid(),PhysicsServer::BODY_STATE_TRANSFORM,get_global_transform());
41
42 } break;
43 }
44 */
45 }
46
get_linear_velocity() const47 Vector3 PhysicsBody::get_linear_velocity() const {
48
49 return Vector3();
50 }
get_angular_velocity() const51 Vector3 PhysicsBody::get_angular_velocity() const {
52
53 return Vector3();
54 }
55
get_inverse_mass() const56 float PhysicsBody::get_inverse_mass() const {
57
58 return 0;
59 }
60
set_layer_mask(uint32_t p_mask)61 void PhysicsBody::set_layer_mask(uint32_t p_mask) {
62
63 layer_mask = p_mask;
64 PhysicsServer::get_singleton()->body_set_layer_mask(get_rid(), p_mask);
65 }
66
get_layer_mask() const67 uint32_t PhysicsBody::get_layer_mask() const {
68
69 return layer_mask;
70 }
71
set_collision_mask(uint32_t p_mask)72 void PhysicsBody::set_collision_mask(uint32_t p_mask) {
73
74 collision_mask = p_mask;
75 PhysicsServer::get_singleton()->body_set_collision_mask(get_rid(), p_mask);
76 }
77
get_collision_mask() const78 uint32_t PhysicsBody::get_collision_mask() const {
79
80 return collision_mask;
81 }
82
set_collision_mask_bit(int p_bit,bool p_value)83 void PhysicsBody::set_collision_mask_bit(int p_bit, bool p_value) {
84
85 uint32_t mask = get_collision_mask();
86 if (p_value)
87 mask |= 1 << p_bit;
88 else
89 mask &= ~(1 << p_bit);
90 set_collision_mask(mask);
91 }
92
get_collision_mask_bit(int p_bit) const93 bool PhysicsBody::get_collision_mask_bit(int p_bit) const {
94
95 return get_collision_mask() & (1 << p_bit);
96 }
97
set_layer_mask_bit(int p_bit,bool p_value)98 void PhysicsBody::set_layer_mask_bit(int p_bit, bool p_value) {
99
100 uint32_t mask = get_layer_mask();
101 if (p_value)
102 mask |= 1 << p_bit;
103 else
104 mask &= ~(1 << p_bit);
105 set_layer_mask(mask);
106 }
107
get_layer_mask_bit(int p_bit) const108 bool PhysicsBody::get_layer_mask_bit(int p_bit) const {
109
110 return get_layer_mask() & (1 << p_bit);
111 }
112
add_collision_exception_with(Node * p_node)113 void PhysicsBody::add_collision_exception_with(Node *p_node) {
114
115 ERR_FAIL_NULL(p_node);
116 PhysicsBody *physics_body = p_node->cast_to<PhysicsBody>();
117 if (!physics_body) {
118 ERR_EXPLAIN("Collision exception only works between two objects of PhysicsBody type");
119 }
120 ERR_FAIL_COND(!physics_body);
121 PhysicsServer::get_singleton()->body_add_collision_exception(get_rid(), physics_body->get_rid());
122 }
123
remove_collision_exception_with(Node * p_node)124 void PhysicsBody::remove_collision_exception_with(Node *p_node) {
125
126 ERR_FAIL_NULL(p_node);
127 PhysicsBody *physics_body = p_node->cast_to<PhysicsBody>();
128 if (!physics_body) {
129 ERR_EXPLAIN("Collision exception only works between two objects of PhysicsBody type");
130 }
131 ERR_FAIL_COND(!physics_body);
132 PhysicsServer::get_singleton()->body_remove_collision_exception(get_rid(), physics_body->get_rid());
133 }
134
_set_layers(uint32_t p_mask)135 void PhysicsBody::_set_layers(uint32_t p_mask) {
136 set_layer_mask(p_mask);
137 set_collision_mask(p_mask);
138 }
139
_get_layers() const140 uint32_t PhysicsBody::_get_layers() const {
141
142 return get_layer_mask();
143 }
144
_bind_methods()145 void PhysicsBody::_bind_methods() {
146 ObjectTypeDB::bind_method(_MD("set_layer_mask", "mask"), &PhysicsBody::set_layer_mask);
147 ObjectTypeDB::bind_method(_MD("get_layer_mask"), &PhysicsBody::get_layer_mask);
148
149 ObjectTypeDB::bind_method(_MD("set_collision_mask", "mask"), &PhysicsBody::set_collision_mask);
150 ObjectTypeDB::bind_method(_MD("get_collision_mask"), &PhysicsBody::get_collision_mask);
151
152 ObjectTypeDB::bind_method(_MD("set_collision_mask_bit", "bit", "value"), &PhysicsBody::set_collision_mask_bit);
153 ObjectTypeDB::bind_method(_MD("get_collision_mask_bit", "bit"), &PhysicsBody::get_collision_mask_bit);
154
155 ObjectTypeDB::bind_method(_MD("set_layer_mask_bit", "bit", "value"), &PhysicsBody::set_layer_mask_bit);
156 ObjectTypeDB::bind_method(_MD("get_layer_mask_bit", "bit"), &PhysicsBody::get_layer_mask_bit);
157
158 ObjectTypeDB::bind_method(_MD("_set_layers", "mask"), &PhysicsBody::_set_layers);
159 ObjectTypeDB::bind_method(_MD("_get_layers"), &PhysicsBody::_get_layers);
160
161 ADD_PROPERTY(PropertyInfo(Variant::INT, "layers", PROPERTY_HINT_ALL_FLAGS, "", 0), _SCS("_set_layers"), _SCS("_get_layers")); //for backwards compat
162 ADD_PROPERTY(PropertyInfo(Variant::INT, "collision/layers", PROPERTY_HINT_ALL_FLAGS), _SCS("set_layer_mask"), _SCS("get_layer_mask"));
163 ADD_PROPERTY(PropertyInfo(Variant::INT, "collision/mask", PROPERTY_HINT_ALL_FLAGS), _SCS("set_collision_mask"), _SCS("get_collision_mask"));
164 }
165
PhysicsBody(PhysicsServer::BodyMode p_mode)166 PhysicsBody::PhysicsBody(PhysicsServer::BodyMode p_mode) :
167 CollisionObject(PhysicsServer::get_singleton()->body_create(p_mode), false) {
168
169 layer_mask = 1;
170 collision_mask = 1;
171 }
172
set_friction(real_t p_friction)173 void StaticBody::set_friction(real_t p_friction) {
174
175 ERR_FAIL_COND(p_friction < 0 || p_friction > 1);
176
177 friction = p_friction;
178 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, friction);
179 }
get_friction() const180 real_t StaticBody::get_friction() const {
181
182 return friction;
183 }
184
set_bounce(real_t p_bounce)185 void StaticBody::set_bounce(real_t p_bounce) {
186
187 ERR_FAIL_COND(p_bounce < 0 || p_bounce > 1);
188
189 bounce = p_bounce;
190 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, bounce);
191 }
get_bounce() const192 real_t StaticBody::get_bounce() const {
193
194 return bounce;
195 }
196
set_constant_linear_velocity(const Vector3 & p_vel)197 void StaticBody::set_constant_linear_velocity(const Vector3 &p_vel) {
198
199 constant_linear_velocity = p_vel;
200 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_LINEAR_VELOCITY, constant_linear_velocity);
201 }
202
set_constant_angular_velocity(const Vector3 & p_vel)203 void StaticBody::set_constant_angular_velocity(const Vector3 &p_vel) {
204
205 constant_angular_velocity = p_vel;
206 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_ANGULAR_VELOCITY, constant_angular_velocity);
207 }
208
get_constant_linear_velocity() const209 Vector3 StaticBody::get_constant_linear_velocity() const {
210
211 return constant_linear_velocity;
212 }
get_constant_angular_velocity() const213 Vector3 StaticBody::get_constant_angular_velocity() const {
214
215 return constant_angular_velocity;
216 }
217
_bind_methods()218 void StaticBody::_bind_methods() {
219
220 ObjectTypeDB::bind_method(_MD("set_constant_linear_velocity", "vel"), &StaticBody::set_constant_linear_velocity);
221 ObjectTypeDB::bind_method(_MD("set_constant_angular_velocity", "vel"), &StaticBody::set_constant_angular_velocity);
222 ObjectTypeDB::bind_method(_MD("get_constant_linear_velocity"), &StaticBody::get_constant_linear_velocity);
223 ObjectTypeDB::bind_method(_MD("get_constant_angular_velocity"), &StaticBody::get_constant_angular_velocity);
224
225 ObjectTypeDB::bind_method(_MD("set_friction", "friction"), &StaticBody::set_friction);
226 ObjectTypeDB::bind_method(_MD("get_friction"), &StaticBody::get_friction);
227
228 ObjectTypeDB::bind_method(_MD("set_bounce", "bounce"), &StaticBody::set_bounce);
229 ObjectTypeDB::bind_method(_MD("get_bounce"), &StaticBody::get_bounce);
230
231 ObjectTypeDB::bind_method(_MD("add_collision_exception_with", "body:PhysicsBody"), &PhysicsBody::add_collision_exception_with);
232 ObjectTypeDB::bind_method(_MD("remove_collision_exception_with", "body:PhysicsBody"), &PhysicsBody::remove_collision_exception_with);
233
234 ADD_PROPERTY(PropertyInfo(Variant::REAL, "friction", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_friction"), _SCS("get_friction"));
235 ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_bounce"), _SCS("get_bounce"));
236
237 ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_linear_velocity"), _SCS("set_constant_linear_velocity"), _SCS("get_constant_linear_velocity"));
238 ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_angular_velocity"), _SCS("set_constant_angular_velocity"), _SCS("get_constant_angular_velocity"));
239 }
240
StaticBody()241 StaticBody::StaticBody() :
242 PhysicsBody(PhysicsServer::BODY_MODE_STATIC) {
243
244 bounce = 0;
245 friction = 1;
246 }
247
~StaticBody()248 StaticBody::~StaticBody() {
249 }
250
_body_enter_tree(ObjectID p_id)251 void RigidBody::_body_enter_tree(ObjectID p_id) {
252
253 Object *obj = ObjectDB::get_instance(p_id);
254 Node *node = obj ? obj->cast_to<Node>() : NULL;
255 ERR_FAIL_COND(!node);
256
257 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
258 ERR_FAIL_COND(!E);
259 ERR_FAIL_COND(E->get().in_tree);
260
261 E->get().in_tree = true;
262
263 contact_monitor->locked = true;
264
265 emit_signal(SceneStringNames::get_singleton()->body_enter, node);
266
267 for (int i = 0; i < E->get().shapes.size(); i++) {
268
269 emit_signal(SceneStringNames::get_singleton()->body_enter_shape, p_id, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
270 }
271
272 contact_monitor->locked = false;
273 }
274
_body_exit_tree(ObjectID p_id)275 void RigidBody::_body_exit_tree(ObjectID p_id) {
276
277 Object *obj = ObjectDB::get_instance(p_id);
278 Node *node = obj ? obj->cast_to<Node>() : NULL;
279 ERR_FAIL_COND(!node);
280 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
281 ERR_FAIL_COND(!E);
282 ERR_FAIL_COND(!E->get().in_tree);
283 E->get().in_tree = false;
284
285 contact_monitor->locked = true;
286
287 emit_signal(SceneStringNames::get_singleton()->body_exit, node);
288
289 for (int i = 0; i < E->get().shapes.size(); i++) {
290
291 emit_signal(SceneStringNames::get_singleton()->body_exit_shape, p_id, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
292 }
293
294 contact_monitor->locked = false;
295 }
296
_body_inout(int p_status,ObjectID p_instance,int p_body_shape,int p_local_shape)297 void RigidBody::_body_inout(int p_status, ObjectID p_instance, int p_body_shape, int p_local_shape) {
298
299 bool body_in = p_status == 1;
300 ObjectID objid = p_instance;
301
302 Object *obj = ObjectDB::get_instance(objid);
303 Node *node = obj ? obj->cast_to<Node>() : NULL;
304
305 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(objid);
306
307 ERR_FAIL_COND(!body_in && !E);
308
309 if (body_in) {
310 if (!E) {
311
312 E = contact_monitor->body_map.insert(objid, BodyState());
313 //E->get().rc=0;
314 E->get().in_tree = node && node->is_inside_tree();
315 if (node) {
316 node->connect(SceneStringNames::get_singleton()->enter_tree, this, SceneStringNames::get_singleton()->_body_enter_tree, make_binds(objid));
317 node->connect(SceneStringNames::get_singleton()->exit_tree, this, SceneStringNames::get_singleton()->_body_exit_tree, make_binds(objid));
318 if (E->get().in_tree) {
319 emit_signal(SceneStringNames::get_singleton()->body_enter, node);
320 }
321 }
322 }
323 //E->get().rc++;
324 if (node)
325 E->get().shapes.insert(ShapePair(p_body_shape, p_local_shape));
326
327 if (E->get().in_tree) {
328 emit_signal(SceneStringNames::get_singleton()->body_enter_shape, objid, node, p_body_shape, p_local_shape);
329 }
330
331 } else {
332
333 //E->get().rc--;
334
335 if (node)
336 E->get().shapes.erase(ShapePair(p_body_shape, p_local_shape));
337
338 bool in_tree = E->get().in_tree;
339
340 if (E->get().shapes.empty()) {
341
342 if (node) {
343 node->disconnect(SceneStringNames::get_singleton()->enter_tree, this, SceneStringNames::get_singleton()->_body_enter_tree);
344 node->disconnect(SceneStringNames::get_singleton()->exit_tree, this, SceneStringNames::get_singleton()->_body_exit_tree);
345 if (in_tree)
346 emit_signal(SceneStringNames::get_singleton()->body_exit, obj);
347 }
348
349 contact_monitor->body_map.erase(E);
350 }
351 if (node && in_tree) {
352 emit_signal(SceneStringNames::get_singleton()->body_exit_shape, objid, obj, p_body_shape, p_local_shape);
353 }
354 }
355 }
356
357 struct _RigidBodyInOut {
358
359 ObjectID id;
360 int shape;
361 int local_shape;
362 };
363
_direct_state_changed(Object * p_state)364 void RigidBody::_direct_state_changed(Object *p_state) {
365
366 //eh.. fuck
367 #ifdef DEBUG_ENABLED
368
369 state = p_state->cast_to<PhysicsDirectBodyState>();
370 #else
371 state = (PhysicsDirectBodyState *)p_state; //trust it
372 #endif
373
374 set_ignore_transform_notification(true);
375 set_global_transform(state->get_transform());
376 linear_velocity = state->get_linear_velocity();
377 angular_velocity = state->get_angular_velocity();
378 if (sleeping != state->is_sleeping()) {
379 sleeping = state->is_sleeping();
380 emit_signal(SceneStringNames::get_singleton()->sleeping_state_changed);
381 }
382 if (get_script_instance())
383 get_script_instance()->call("_integrate_forces", state);
384 set_ignore_transform_notification(false);
385
386 if (contact_monitor) {
387
388 contact_monitor->locked = true;
389
390 //untag all
391 int rc = 0;
392 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
393
394 for (int i = 0; i < E->get().shapes.size(); i++) {
395
396 E->get().shapes[i].tagged = false;
397 rc++;
398 }
399 }
400
401 _RigidBodyInOut *toadd = (_RigidBodyInOut *)alloca(state->get_contact_count() * sizeof(_RigidBodyInOut));
402 int toadd_count = 0; //state->get_contact_count();
403 RigidBody_RemoveAction *toremove = (RigidBody_RemoveAction *)alloca(rc * sizeof(RigidBody_RemoveAction));
404 int toremove_count = 0;
405
406 //put the ones to add
407
408 for (int i = 0; i < state->get_contact_count(); i++) {
409
410 ObjectID obj = state->get_contact_collider_id(i);
411 int local_shape = state->get_contact_local_shape(i);
412 int shape = state->get_contact_collider_shape(i);
413
414 // bool found=false;
415
416 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(obj);
417 if (!E) {
418 toadd[toadd_count].local_shape = local_shape;
419 toadd[toadd_count].id = obj;
420 toadd[toadd_count].shape = shape;
421 toadd_count++;
422 continue;
423 }
424
425 ShapePair sp(shape, local_shape);
426 int idx = E->get().shapes.find(sp);
427 if (idx == -1) {
428
429 toadd[toadd_count].local_shape = local_shape;
430 toadd[toadd_count].id = obj;
431 toadd[toadd_count].shape = shape;
432 toadd_count++;
433 continue;
434 }
435
436 E->get().shapes[idx].tagged = true;
437 }
438
439 //put the ones to remove
440
441 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
442
443 for (int i = 0; i < E->get().shapes.size(); i++) {
444
445 if (!E->get().shapes[i].tagged) {
446
447 toremove[toremove_count].body_id = E->key();
448 toremove[toremove_count].pair = E->get().shapes[i];
449 toremove_count++;
450 }
451 }
452 }
453
454 //process remotions
455
456 for (int i = 0; i < toremove_count; i++) {
457
458 _body_inout(0, toremove[i].body_id, toremove[i].pair.body_shape, toremove[i].pair.local_shape);
459 }
460
461 //process aditions
462
463 for (int i = 0; i < toadd_count; i++) {
464
465 _body_inout(1, toadd[i].id, toadd[i].shape, toadd[i].local_shape);
466 }
467
468 contact_monitor->locked = false;
469 }
470
471 state = NULL;
472 }
473
_notification(int p_what)474 void RigidBody::_notification(int p_what) {
475
476 #ifdef TOOLS_ENABLED
477 if (p_what == NOTIFICATION_ENTER_TREE) {
478 if (get_tree()->is_editor_hint()) {
479 set_notify_local_transform(true); //used for warnings and only in editor
480 }
481 }
482
483 if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {
484 if (get_tree()->is_editor_hint()) {
485 update_configuration_warning();
486 }
487 }
488
489 #endif
490 }
491
set_mode(Mode p_mode)492 void RigidBody::set_mode(Mode p_mode) {
493
494 mode = p_mode;
495 switch (p_mode) {
496
497 case MODE_RIGID: {
498
499 PhysicsServer::get_singleton()->body_set_mode(get_rid(), PhysicsServer::BODY_MODE_RIGID);
500 } break;
501 case MODE_STATIC: {
502
503 PhysicsServer::get_singleton()->body_set_mode(get_rid(), PhysicsServer::BODY_MODE_STATIC);
504
505 } break;
506 case MODE_CHARACTER: {
507 PhysicsServer::get_singleton()->body_set_mode(get_rid(), PhysicsServer::BODY_MODE_CHARACTER);
508
509 } break;
510 case MODE_KINEMATIC: {
511
512 PhysicsServer::get_singleton()->body_set_mode(get_rid(), PhysicsServer::BODY_MODE_KINEMATIC);
513 } break;
514 }
515 }
516
get_mode() const517 RigidBody::Mode RigidBody::get_mode() const {
518
519 return mode;
520 }
521
set_mass(real_t p_mass)522 void RigidBody::set_mass(real_t p_mass) {
523
524 ERR_FAIL_COND(p_mass <= 0);
525 mass = p_mass;
526 _change_notify("mass");
527 _change_notify("weight");
528 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_MASS, mass);
529 }
get_mass() const530 real_t RigidBody::get_mass() const {
531
532 return mass;
533 }
534
set_weight(real_t p_weight)535 void RigidBody::set_weight(real_t p_weight) {
536
537 set_mass(p_weight / 9.8);
538 }
get_weight() const539 real_t RigidBody::get_weight() const {
540
541 return mass * 9.8;
542 }
543
set_friction(real_t p_friction)544 void RigidBody::set_friction(real_t p_friction) {
545
546 ERR_FAIL_COND(p_friction < 0 || p_friction > 1);
547
548 friction = p_friction;
549 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, friction);
550 }
get_friction() const551 real_t RigidBody::get_friction() const {
552
553 return friction;
554 }
555
set_bounce(real_t p_bounce)556 void RigidBody::set_bounce(real_t p_bounce) {
557
558 ERR_FAIL_COND(p_bounce < 0 || p_bounce > 1);
559
560 bounce = p_bounce;
561 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, bounce);
562 }
get_bounce() const563 real_t RigidBody::get_bounce() const {
564
565 return bounce;
566 }
567
set_gravity_scale(real_t p_gravity_scale)568 void RigidBody::set_gravity_scale(real_t p_gravity_scale) {
569
570 gravity_scale = p_gravity_scale;
571 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
572 }
get_gravity_scale() const573 real_t RigidBody::get_gravity_scale() const {
574
575 return gravity_scale;
576 }
577
set_linear_damp(real_t p_linear_damp)578 void RigidBody::set_linear_damp(real_t p_linear_damp) {
579
580 ERR_FAIL_COND(p_linear_damp < -1);
581 linear_damp = p_linear_damp;
582 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_LINEAR_DAMP, linear_damp);
583 }
get_linear_damp() const584 real_t RigidBody::get_linear_damp() const {
585
586 return linear_damp;
587 }
588
set_angular_damp(real_t p_angular_damp)589 void RigidBody::set_angular_damp(real_t p_angular_damp) {
590
591 ERR_FAIL_COND(p_angular_damp < -1);
592 angular_damp = p_angular_damp;
593 PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_ANGULAR_DAMP, angular_damp);
594 }
get_angular_damp() const595 real_t RigidBody::get_angular_damp() const {
596
597 return angular_damp;
598 }
599
set_axis_velocity(const Vector3 & p_axis)600 void RigidBody::set_axis_velocity(const Vector3 &p_axis) {
601
602 Vector3 v = state ? state->get_linear_velocity() : linear_velocity;
603 Vector3 axis = p_axis.normalized();
604 v -= axis * axis.dot(v);
605 v += p_axis;
606 if (state) {
607 set_linear_velocity(v);
608 } else {
609 PhysicsServer::get_singleton()->body_set_axis_velocity(get_rid(), p_axis);
610 linear_velocity = v;
611 }
612 }
613
set_linear_velocity(const Vector3 & p_velocity)614 void RigidBody::set_linear_velocity(const Vector3 &p_velocity) {
615
616 linear_velocity = p_velocity;
617 if (state)
618 state->set_linear_velocity(linear_velocity);
619 else
620 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
621 }
622
get_linear_velocity() const623 Vector3 RigidBody::get_linear_velocity() const {
624
625 return linear_velocity;
626 }
627
set_angular_velocity(const Vector3 & p_velocity)628 void RigidBody::set_angular_velocity(const Vector3 &p_velocity) {
629
630 angular_velocity = p_velocity;
631 if (state)
632 state->set_angular_velocity(angular_velocity);
633 else
634 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
635 }
get_angular_velocity() const636 Vector3 RigidBody::get_angular_velocity() const {
637
638 return angular_velocity;
639 }
640
set_use_custom_integrator(bool p_enable)641 void RigidBody::set_use_custom_integrator(bool p_enable) {
642
643 if (custom_integrator == p_enable)
644 return;
645
646 custom_integrator = p_enable;
647 PhysicsServer::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
648 }
is_using_custom_integrator()649 bool RigidBody::is_using_custom_integrator() {
650
651 return custom_integrator;
652 }
653
set_sleeping(bool p_sleeping)654 void RigidBody::set_sleeping(bool p_sleeping) {
655
656 sleeping = p_sleeping;
657 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_SLEEPING, sleeping);
658 }
659
set_can_sleep(bool p_active)660 void RigidBody::set_can_sleep(bool p_active) {
661
662 can_sleep = p_active;
663 PhysicsServer::get_singleton()->body_set_state(get_rid(), PhysicsServer::BODY_STATE_CAN_SLEEP, p_active);
664 }
665
is_able_to_sleep() const666 bool RigidBody::is_able_to_sleep() const {
667
668 return can_sleep;
669 }
670
is_sleeping() const671 bool RigidBody::is_sleeping() const {
672
673 return sleeping;
674 }
675
set_max_contacts_reported(int p_amount)676 void RigidBody::set_max_contacts_reported(int p_amount) {
677
678 max_contacts_reported = p_amount;
679 PhysicsServer::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
680 }
681
get_max_contacts_reported() const682 int RigidBody::get_max_contacts_reported() const {
683
684 return max_contacts_reported;
685 }
686
apply_impulse(const Vector3 & p_pos,const Vector3 & p_impulse)687 void RigidBody::apply_impulse(const Vector3 &p_pos, const Vector3 &p_impulse) {
688
689 PhysicsServer::get_singleton()->body_apply_impulse(get_rid(), p_pos, p_impulse);
690 }
691
set_use_continuous_collision_detection(bool p_enable)692 void RigidBody::set_use_continuous_collision_detection(bool p_enable) {
693
694 ccd = p_enable;
695 PhysicsServer::get_singleton()->body_set_enable_continuous_collision_detection(get_rid(), p_enable);
696 }
697
is_using_continuous_collision_detection() const698 bool RigidBody::is_using_continuous_collision_detection() const {
699
700 return ccd;
701 }
702
set_contact_monitor(bool p_enabled)703 void RigidBody::set_contact_monitor(bool p_enabled) {
704
705 if (p_enabled == is_contact_monitor_enabled())
706 return;
707
708 if (!p_enabled) {
709
710 if (contact_monitor->locked) {
711 ERR_EXPLAIN("Can't disable contact monitoring during in/out callback. Use call_deferred(\"set_contact_monitor\",false) instead");
712 }
713 ERR_FAIL_COND(contact_monitor->locked);
714
715 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
716
717 //clean up mess
718 }
719
720 memdelete(contact_monitor);
721 contact_monitor = NULL;
722 } else {
723
724 contact_monitor = memnew(ContactMonitor);
725 contact_monitor->locked = false;
726 }
727 }
728
is_contact_monitor_enabled() const729 bool RigidBody::is_contact_monitor_enabled() const {
730
731 return contact_monitor != NULL;
732 }
733
set_axis_lock(AxisLock p_lock)734 void RigidBody::set_axis_lock(AxisLock p_lock) {
735
736 axis_lock = p_lock;
737 PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), PhysicsServer::BodyAxisLock(axis_lock));
738 }
739
get_axis_lock() const740 RigidBody::AxisLock RigidBody::get_axis_lock() const {
741
742 return axis_lock;
743 }
744
get_colliding_bodies() const745 Array RigidBody::get_colliding_bodies() const {
746
747 ERR_FAIL_COND_V(!contact_monitor, Array());
748
749 Array ret;
750 ret.resize(contact_monitor->body_map.size());
751 int idx = 0;
752 for (const Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
753 Object *obj = ObjectDB::get_instance(E->key());
754 if (!obj) {
755 ret.resize(ret.size() - 1); //ops
756 } else {
757 ret[idx++] = obj;
758 }
759 }
760
761 return ret;
762 }
763
get_configuration_warning() const764 String RigidBody::get_configuration_warning() const {
765
766 Transform t = get_transform();
767
768 String warning = CollisionObject::get_configuration_warning();
769
770 if ((get_mode() == MODE_RIGID || get_mode() == MODE_CHARACTER) && (ABS(t.basis.get_axis(0).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(1).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(0).length() - 1.0) > 0.05)) {
771 if (warning != String()) {
772 warning += "\n";
773 }
774 warning += TTR("Size changes to RigidBody (in character or rigid modes) will be overriden by the physics engine when running.\nChange the size in children collision shapes instead.");
775 }
776
777 return warning;
778 }
779
_bind_methods()780 void RigidBody::_bind_methods() {
781
782 ObjectTypeDB::bind_method(_MD("set_mode", "mode"), &RigidBody::set_mode);
783 ObjectTypeDB::bind_method(_MD("get_mode"), &RigidBody::get_mode);
784
785 ObjectTypeDB::bind_method(_MD("set_mass", "mass"), &RigidBody::set_mass);
786 ObjectTypeDB::bind_method(_MD("get_mass"), &RigidBody::get_mass);
787
788 ObjectTypeDB::bind_method(_MD("set_weight", "weight"), &RigidBody::set_weight);
789 ObjectTypeDB::bind_method(_MD("get_weight"), &RigidBody::get_weight);
790
791 ObjectTypeDB::bind_method(_MD("set_friction", "friction"), &RigidBody::set_friction);
792 ObjectTypeDB::bind_method(_MD("get_friction"), &RigidBody::get_friction);
793
794 ObjectTypeDB::bind_method(_MD("set_bounce", "bounce"), &RigidBody::set_bounce);
795 ObjectTypeDB::bind_method(_MD("get_bounce"), &RigidBody::get_bounce);
796
797 ObjectTypeDB::bind_method(_MD("set_linear_velocity", "linear_velocity"), &RigidBody::set_linear_velocity);
798 ObjectTypeDB::bind_method(_MD("get_linear_velocity"), &RigidBody::get_linear_velocity);
799
800 ObjectTypeDB::bind_method(_MD("set_angular_velocity", "angular_velocity"), &RigidBody::set_angular_velocity);
801 ObjectTypeDB::bind_method(_MD("get_angular_velocity"), &RigidBody::get_angular_velocity);
802
803 ObjectTypeDB::bind_method(_MD("set_gravity_scale", "gravity_scale"), &RigidBody::set_gravity_scale);
804 ObjectTypeDB::bind_method(_MD("get_gravity_scale"), &RigidBody::get_gravity_scale);
805
806 ObjectTypeDB::bind_method(_MD("set_linear_damp", "linear_damp"), &RigidBody::set_linear_damp);
807 ObjectTypeDB::bind_method(_MD("get_linear_damp"), &RigidBody::get_linear_damp);
808
809 ObjectTypeDB::bind_method(_MD("set_angular_damp", "angular_damp"), &RigidBody::set_angular_damp);
810 ObjectTypeDB::bind_method(_MD("get_angular_damp"), &RigidBody::get_angular_damp);
811
812 ObjectTypeDB::bind_method(_MD("set_max_contacts_reported", "amount"), &RigidBody::set_max_contacts_reported);
813 ObjectTypeDB::bind_method(_MD("get_max_contacts_reported"), &RigidBody::get_max_contacts_reported);
814
815 ObjectTypeDB::bind_method(_MD("set_use_custom_integrator", "enable"), &RigidBody::set_use_custom_integrator);
816 ObjectTypeDB::bind_method(_MD("is_using_custom_integrator"), &RigidBody::is_using_custom_integrator);
817
818 ObjectTypeDB::bind_method(_MD("set_contact_monitor", "enabled"), &RigidBody::set_contact_monitor);
819 ObjectTypeDB::bind_method(_MD("is_contact_monitor_enabled"), &RigidBody::is_contact_monitor_enabled);
820
821 ObjectTypeDB::bind_method(_MD("set_use_continuous_collision_detection", "enable"), &RigidBody::set_use_continuous_collision_detection);
822 ObjectTypeDB::bind_method(_MD("is_using_continuous_collision_detection"), &RigidBody::is_using_continuous_collision_detection);
823
824 ObjectTypeDB::bind_method(_MD("set_axis_velocity", "axis_velocity"), &RigidBody::set_axis_velocity);
825 ObjectTypeDB::bind_method(_MD("apply_impulse", "pos", "impulse"), &RigidBody::apply_impulse);
826
827 ObjectTypeDB::bind_method(_MD("set_sleeping", "sleeping"), &RigidBody::set_sleeping);
828 ObjectTypeDB::bind_method(_MD("is_sleeping"), &RigidBody::is_sleeping);
829
830 ObjectTypeDB::bind_method(_MD("set_can_sleep", "able_to_sleep"), &RigidBody::set_can_sleep);
831 ObjectTypeDB::bind_method(_MD("is_able_to_sleep"), &RigidBody::is_able_to_sleep);
832
833 ObjectTypeDB::bind_method(_MD("_direct_state_changed"), &RigidBody::_direct_state_changed);
834 ObjectTypeDB::bind_method(_MD("_body_enter_tree"), &RigidBody::_body_enter_tree);
835 ObjectTypeDB::bind_method(_MD("_body_exit_tree"), &RigidBody::_body_exit_tree);
836
837 ObjectTypeDB::bind_method(_MD("set_axis_lock", "axis_lock"), &RigidBody::set_axis_lock);
838 ObjectTypeDB::bind_method(_MD("get_axis_lock"), &RigidBody::get_axis_lock);
839
840 ObjectTypeDB::bind_method(_MD("get_colliding_bodies"), &RigidBody::get_colliding_bodies);
841
842 BIND_VMETHOD(MethodInfo("_integrate_forces", PropertyInfo(Variant::OBJECT, "state:PhysicsDirectBodyState")));
843
844 ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Rigid,Static,Character,Kinematic"), _SCS("set_mode"), _SCS("get_mode"));
845 ADD_PROPERTY(PropertyInfo(Variant::REAL, "mass", PROPERTY_HINT_EXP_RANGE, "0.01,65535,0.01"), _SCS("set_mass"), _SCS("get_mass"));
846 ADD_PROPERTY(PropertyInfo(Variant::REAL, "weight", PROPERTY_HINT_EXP_RANGE, "0.01,65535,0.01", PROPERTY_USAGE_EDITOR), _SCS("set_weight"), _SCS("get_weight"));
847 ADD_PROPERTY(PropertyInfo(Variant::REAL, "friction", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_friction"), _SCS("get_friction"));
848 ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_bounce"), _SCS("get_bounce"));
849 ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity_scale", PROPERTY_HINT_RANGE, "-128,128,0.01"), _SCS("set_gravity_scale"), _SCS("get_gravity_scale"));
850 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "custom_integrator"), _SCS("set_use_custom_integrator"), _SCS("is_using_custom_integrator"));
851 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "continuous_cd"), _SCS("set_use_continuous_collision_detection"), _SCS("is_using_continuous_collision_detection"));
852 ADD_PROPERTY(PropertyInfo(Variant::INT, "contacts_reported"), _SCS("set_max_contacts_reported"), _SCS("get_max_contacts_reported"));
853 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "contact_monitor"), _SCS("set_contact_monitor"), _SCS("is_contact_monitor_enabled"));
854 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sleeping"), _SCS("set_sleeping"), _SCS("is_sleeping"));
855 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "can_sleep"), _SCS("set_can_sleep"), _SCS("is_able_to_sleep"));
856 ADD_PROPERTY(PropertyInfo(Variant::INT, "axis_lock", PROPERTY_HINT_ENUM, "Disabled,Lock X,Lock Y,Lock Z"), _SCS("set_axis_lock"), _SCS("get_axis_lock"));
857 ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "velocity/linear"), _SCS("set_linear_velocity"), _SCS("get_linear_velocity"));
858 ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "velocity/angular"), _SCS("set_angular_velocity"), _SCS("get_angular_velocity"));
859 ADD_PROPERTY(PropertyInfo(Variant::REAL, "damp_override/linear", PROPERTY_HINT_RANGE, "-1,128,0.01"), _SCS("set_linear_damp"), _SCS("get_linear_damp"));
860 ADD_PROPERTY(PropertyInfo(Variant::REAL, "damp_override/angular", PROPERTY_HINT_RANGE, "-1,128,0.01"), _SCS("set_angular_damp"), _SCS("get_angular_damp"));
861
862 ADD_SIGNAL(MethodInfo("body_enter_shape", PropertyInfo(Variant::INT, "body_id"), PropertyInfo(Variant::OBJECT, "body"), PropertyInfo(Variant::INT, "body_shape"), PropertyInfo(Variant::INT, "local_shape")));
863 ADD_SIGNAL(MethodInfo("body_exit_shape", PropertyInfo(Variant::INT, "body_id"), PropertyInfo(Variant::OBJECT, "body"), PropertyInfo(Variant::INT, "body_shape"), PropertyInfo(Variant::INT, "local_shape")));
864 ADD_SIGNAL(MethodInfo("body_enter", PropertyInfo(Variant::OBJECT, "body")));
865 ADD_SIGNAL(MethodInfo("body_exit", PropertyInfo(Variant::OBJECT, "body")));
866 ADD_SIGNAL(MethodInfo("sleeping_state_changed"));
867
868 BIND_CONSTANT(MODE_STATIC);
869 BIND_CONSTANT(MODE_KINEMATIC);
870 BIND_CONSTANT(MODE_RIGID);
871 BIND_CONSTANT(MODE_CHARACTER);
872 }
873
RigidBody()874 RigidBody::RigidBody() :
875 PhysicsBody(PhysicsServer::BODY_MODE_RIGID) {
876
877 mode = MODE_RIGID;
878
879 bounce = 0;
880 mass = 1;
881 friction = 1;
882 max_contacts_reported = 0;
883 state = NULL;
884
885 gravity_scale = 1;
886 linear_damp = -1;
887 angular_damp = -1;
888
889 //angular_velocity=0;
890 sleeping = false;
891 ccd = false;
892
893 custom_integrator = false;
894 contact_monitor = NULL;
895 can_sleep = true;
896
897 axis_lock = AXIS_LOCK_DISABLED;
898
899 PhysicsServer::get_singleton()->body_set_force_integration_callback(get_rid(), this, "_direct_state_changed");
900 }
901
~RigidBody()902 RigidBody::~RigidBody() {
903
904 if (contact_monitor)
905 memdelete(contact_monitor);
906 }
907 //////////////////////////////////////////////////////
908 //////////////////////////
909
_get_collider() const910 Variant KinematicBody::_get_collider() const {
911
912 ObjectID oid = get_collider();
913 if (oid == 0)
914 return Variant();
915 Object *obj = ObjectDB::get_instance(oid);
916 if (!obj)
917 return Variant();
918
919 Reference *ref = obj->cast_to<Reference>();
920 if (ref) {
921 return Ref<Reference>(ref);
922 }
923
924 return obj;
925 }
926
_ignores_mode(PhysicsServer::BodyMode p_mode) const927 bool KinematicBody::_ignores_mode(PhysicsServer::BodyMode p_mode) const {
928
929 switch (p_mode) {
930 case PhysicsServer::BODY_MODE_STATIC: return !collide_static;
931 case PhysicsServer::BODY_MODE_KINEMATIC: return !collide_kinematic;
932 case PhysicsServer::BODY_MODE_RIGID: return !collide_rigid;
933 case PhysicsServer::BODY_MODE_CHARACTER: return !collide_character;
934 }
935
936 return true;
937 }
938
move(const Vector3 & p_motion)939 Vector3 KinematicBody::move(const Vector3 &p_motion) {
940
941 //give me back regular physics engine logic
942 //this is madness
943 //and most people using this function will think
944 //what it does is simpler than using physics
945 //this took about a week to get right..
946 //but is it right? who knows at this point..
947
948 colliding = false;
949 ERR_FAIL_COND_V(!is_inside_tree(), Vector3());
950 PhysicsDirectSpaceState *dss = PhysicsServer::get_singleton()->space_get_direct_state(get_world()->get_space());
951 ERR_FAIL_COND_V(!dss, Vector3());
952 const int max_shapes = 32;
953 Vector3 sr[max_shapes * 2];
954 int res_shapes;
955
956 Set<RID> exclude;
957 exclude.insert(get_rid());
958
959 //recover first
960 int recover_attempts = 4;
961
962 bool collided = false;
963 uint32_t mask = 0;
964 if (collide_static)
965 mask |= PhysicsDirectSpaceState::TYPE_MASK_STATIC_BODY;
966 if (collide_kinematic)
967 mask |= PhysicsDirectSpaceState::TYPE_MASK_KINEMATIC_BODY;
968 if (collide_rigid)
969 mask |= PhysicsDirectSpaceState::TYPE_MASK_RIGID_BODY;
970 if (collide_character)
971 mask |= PhysicsDirectSpaceState::TYPE_MASK_CHARACTER_BODY;
972
973 // print_line("motion: "+p_motion+" margin: "+rtos(margin));
974
975 //print_line("margin: "+rtos(margin));
976
977 float m = margin;
978 //m=0.001;
979
980 do {
981
982 //motion recover
983 for (int i = 0; i < get_shape_count(); i++) {
984
985 if (is_shape_set_as_trigger(i))
986 continue;
987
988 if (dss->collide_shape(get_shape(i)->get_rid(), get_global_transform() * get_shape_transform(i), m, sr, max_shapes, res_shapes, exclude, get_layer_mask(), mask)) {
989 collided = true;
990 }
991 }
992
993 if (!collided)
994 break;
995
996 //print_line("have to recover");
997 Vector3 recover_motion;
998 bool all_outside = true;
999 for (int j = 0; j < 8; j++) {
1000 for (int i = 0; i < res_shapes; i++) {
1001
1002 Vector3 a = sr[i * 2 + 0];
1003 Vector3 b = sr[i * 2 + 1];
1004 //print_line(String()+a+" -> "+b);
1005 #if 0
1006 float d = a.distance_to(b);
1007
1008 //if (d<margin)
1009 /// continue;
1010 ///
1011 ///
1012 recover_motion+=(b-a)*0.2;
1013 #else
1014 float dist = a.distance_to(b);
1015 if (dist > CMP_EPSILON) {
1016 Vector3 norm = (b - a).normalized();
1017 if (dist > margin * 0.5)
1018 all_outside = false;
1019 float adv = norm.dot(recover_motion);
1020 //print_line(itos(i)+" dist: "+rtos(dist)+" adv: "+rtos(adv));
1021 recover_motion += norm * MAX(dist - adv, 0) * 0.4;
1022 }
1023 #endif
1024 }
1025 }
1026
1027 if (recover_motion == Vector3()) {
1028 collided = false;
1029 break;
1030 }
1031
1032 //print_line("**** RECOVER: "+recover_motion);
1033
1034 Transform gt = get_global_transform();
1035 gt.origin += recover_motion;
1036 set_global_transform(gt);
1037
1038 recover_attempts--;
1039
1040 if (all_outside)
1041 break;
1042
1043 } while (recover_attempts);
1044
1045 //move second
1046 float safe = 1.0;
1047 float unsafe = 1.0;
1048 int best_shape = -1;
1049
1050 PhysicsDirectSpaceState::ShapeRestInfo rest;
1051
1052 //print_line("pos: "+get_global_transform().origin);
1053 //print_line("motion: "+p_motion);
1054
1055 for (int i = 0; i < get_shape_count(); i++) {
1056
1057 if (is_shape_set_as_trigger(i))
1058 continue;
1059
1060 float lsafe, lunsafe;
1061 PhysicsDirectSpaceState::ShapeRestInfo lrest;
1062 bool valid = dss->cast_motion(get_shape(i)->get_rid(), get_global_transform() * get_shape_transform(i), p_motion, 0, lsafe, lunsafe, exclude, get_layer_mask(), mask, &lrest);
1063 //print_line("shape: "+itos(i)+" travel:"+rtos(ltravel));
1064 if (!valid) {
1065 safe = 0;
1066 unsafe = 0;
1067 best_shape = i; //sadly it's the best
1068 //print_line("initial stuck");
1069
1070 break;
1071 }
1072 if (lsafe == 1.0) {
1073 //print_line("initial free");
1074 continue;
1075 }
1076 if (lsafe < safe) {
1077
1078 //print_line("initial at "+rtos(lsafe));
1079 safe = lsafe;
1080 safe = MAX(0, lsafe - 0.01);
1081 unsafe = lunsafe;
1082 best_shape = i;
1083 rest = lrest;
1084 }
1085 }
1086
1087 //print_line("best shape: "+itos(best_shape)+" motion "+p_motion);
1088
1089 if (safe >= 1) {
1090 //not collided
1091 colliding = false;
1092 } else {
1093
1094 colliding = true;
1095
1096 if (true || (safe == 0 && unsafe == 0)) { //use it always because it's more precise than GJK
1097 //no advance, use rest info from collision
1098 Transform ugt = get_global_transform();
1099 ugt.origin += p_motion * unsafe;
1100
1101 PhysicsDirectSpaceState::ShapeRestInfo rest_info;
1102 bool c2 = dss->rest_info(get_shape(best_shape)->get_rid(), ugt * get_shape_transform(best_shape), m, &rest, exclude, get_layer_mask(), mask);
1103 if (!c2) {
1104 //should not happen, but floating point precision is so weird..
1105 colliding = false;
1106 }
1107
1108 // print_line("Rest Travel: "+rest.normal);
1109 }
1110
1111 if (colliding) {
1112
1113 collision = rest.point;
1114 normal = rest.normal;
1115 collider = rest.collider_id;
1116 collider_vel = rest.linear_velocity;
1117 collider_shape = rest.shape;
1118 }
1119 }
1120
1121 Vector3 motion = p_motion * safe;
1122 //if (colliding)
1123 // motion+=normal*0.001;
1124 Transform gt = get_global_transform();
1125 gt.origin += motion;
1126 set_global_transform(gt);
1127
1128 return p_motion - motion;
1129 }
1130
move_to(const Vector3 & p_position)1131 Vector3 KinematicBody::move_to(const Vector3 &p_position) {
1132
1133 return move(p_position - get_global_transform().origin);
1134 }
1135
can_teleport_to(const Vector3 & p_position)1136 bool KinematicBody::can_teleport_to(const Vector3 &p_position) {
1137
1138 ERR_FAIL_COND_V(!is_inside_tree(), false);
1139 PhysicsDirectSpaceState *dss = PhysicsServer::get_singleton()->space_get_direct_state(get_world()->get_space());
1140 ERR_FAIL_COND_V(!dss, false);
1141
1142 uint32_t mask = 0;
1143 if (collide_static)
1144 mask |= PhysicsDirectSpaceState::TYPE_MASK_STATIC_BODY;
1145 if (collide_kinematic)
1146 mask |= PhysicsDirectSpaceState::TYPE_MASK_KINEMATIC_BODY;
1147 if (collide_rigid)
1148 mask |= PhysicsDirectSpaceState::TYPE_MASK_RIGID_BODY;
1149 if (collide_character)
1150 mask |= PhysicsDirectSpaceState::TYPE_MASK_CHARACTER_BODY;
1151
1152 Transform xform = get_global_transform();
1153 xform.origin = p_position;
1154
1155 Set<RID> exclude;
1156 exclude.insert(get_rid());
1157
1158 for (int i = 0; i < get_shape_count(); i++) {
1159
1160 if (is_shape_set_as_trigger(i))
1161 continue;
1162
1163 bool col = dss->intersect_shape(get_shape(i)->get_rid(), xform * get_shape_transform(i), 0, NULL, 1, exclude, get_layer_mask(), mask);
1164 if (col)
1165 return false;
1166 }
1167
1168 return true;
1169 }
1170
is_colliding() const1171 bool KinematicBody::is_colliding() const {
1172
1173 ERR_FAIL_COND_V(!is_inside_tree(), false);
1174
1175 return colliding;
1176 }
get_collision_pos() const1177 Vector3 KinematicBody::get_collision_pos() const {
1178
1179 ERR_FAIL_COND_V(!colliding, Vector3());
1180 return collision;
1181 }
get_collision_normal() const1182 Vector3 KinematicBody::get_collision_normal() const {
1183
1184 ERR_FAIL_COND_V(!colliding, Vector3());
1185 return normal;
1186 }
1187
get_collider_velocity() const1188 Vector3 KinematicBody::get_collider_velocity() const {
1189
1190 return collider_vel;
1191 }
1192
get_collider() const1193 ObjectID KinematicBody::get_collider() const {
1194
1195 ERR_FAIL_COND_V(!colliding, 0);
1196 return collider;
1197 }
get_collider_shape() const1198 int KinematicBody::get_collider_shape() const {
1199
1200 ERR_FAIL_COND_V(!colliding, -1);
1201 return collider_shape;
1202 }
set_collide_with_static_bodies(bool p_enable)1203 void KinematicBody::set_collide_with_static_bodies(bool p_enable) {
1204
1205 collide_static = p_enable;
1206 }
can_collide_with_static_bodies() const1207 bool KinematicBody::can_collide_with_static_bodies() const {
1208
1209 return collide_static;
1210 }
1211
set_collide_with_rigid_bodies(bool p_enable)1212 void KinematicBody::set_collide_with_rigid_bodies(bool p_enable) {
1213
1214 collide_rigid = p_enable;
1215 }
can_collide_with_rigid_bodies() const1216 bool KinematicBody::can_collide_with_rigid_bodies() const {
1217
1218 return collide_rigid;
1219 }
1220
set_collide_with_kinematic_bodies(bool p_enable)1221 void KinematicBody::set_collide_with_kinematic_bodies(bool p_enable) {
1222
1223 collide_kinematic = p_enable;
1224 }
can_collide_with_kinematic_bodies() const1225 bool KinematicBody::can_collide_with_kinematic_bodies() const {
1226
1227 return collide_kinematic;
1228 }
1229
set_collide_with_character_bodies(bool p_enable)1230 void KinematicBody::set_collide_with_character_bodies(bool p_enable) {
1231
1232 collide_character = p_enable;
1233 }
can_collide_with_character_bodies() const1234 bool KinematicBody::can_collide_with_character_bodies() const {
1235
1236 return collide_character;
1237 }
1238
set_collision_margin(float p_margin)1239 void KinematicBody::set_collision_margin(float p_margin) {
1240
1241 margin = p_margin;
1242 }
1243
get_collision_margin() const1244 float KinematicBody::get_collision_margin() const {
1245
1246 return margin;
1247 }
1248
_bind_methods()1249 void KinematicBody::_bind_methods() {
1250
1251 ObjectTypeDB::bind_method(_MD("move", "rel_vec"), &KinematicBody::move);
1252 ObjectTypeDB::bind_method(_MD("move_to", "position"), &KinematicBody::move_to);
1253
1254 ObjectTypeDB::bind_method(_MD("can_teleport_to", "position"), &KinematicBody::can_teleport_to);
1255
1256 ObjectTypeDB::bind_method(_MD("is_colliding"), &KinematicBody::is_colliding);
1257
1258 ObjectTypeDB::bind_method(_MD("get_collision_pos"), &KinematicBody::get_collision_pos);
1259 ObjectTypeDB::bind_method(_MD("get_collision_normal"), &KinematicBody::get_collision_normal);
1260 ObjectTypeDB::bind_method(_MD("get_collider_velocity"), &KinematicBody::get_collider_velocity);
1261 ObjectTypeDB::bind_method(_MD("get_collider:Variant"), &KinematicBody::_get_collider);
1262 ObjectTypeDB::bind_method(_MD("get_collider_shape"), &KinematicBody::get_collider_shape);
1263
1264 ObjectTypeDB::bind_method(_MD("set_collide_with_static_bodies", "enable"), &KinematicBody::set_collide_with_static_bodies);
1265 ObjectTypeDB::bind_method(_MD("can_collide_with_static_bodies"), &KinematicBody::can_collide_with_static_bodies);
1266
1267 ObjectTypeDB::bind_method(_MD("set_collide_with_kinematic_bodies", "enable"), &KinematicBody::set_collide_with_kinematic_bodies);
1268 ObjectTypeDB::bind_method(_MD("can_collide_with_kinematic_bodies"), &KinematicBody::can_collide_with_kinematic_bodies);
1269
1270 ObjectTypeDB::bind_method(_MD("set_collide_with_rigid_bodies", "enable"), &KinematicBody::set_collide_with_rigid_bodies);
1271 ObjectTypeDB::bind_method(_MD("can_collide_with_rigid_bodies"), &KinematicBody::can_collide_with_rigid_bodies);
1272
1273 ObjectTypeDB::bind_method(_MD("set_collide_with_character_bodies", "enable"), &KinematicBody::set_collide_with_character_bodies);
1274 ObjectTypeDB::bind_method(_MD("can_collide_with_character_bodies"), &KinematicBody::can_collide_with_character_bodies);
1275
1276 ObjectTypeDB::bind_method(_MD("set_collision_margin", "pixels"), &KinematicBody::set_collision_margin);
1277 ObjectTypeDB::bind_method(_MD("get_collision_margin", "pixels"), &KinematicBody::get_collision_margin);
1278
1279 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with/static"), _SCS("set_collide_with_static_bodies"), _SCS("can_collide_with_static_bodies"));
1280 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with/kinematic"), _SCS("set_collide_with_kinematic_bodies"), _SCS("can_collide_with_kinematic_bodies"));
1281 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with/rigid"), _SCS("set_collide_with_rigid_bodies"), _SCS("can_collide_with_rigid_bodies"));
1282 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with/character"), _SCS("set_collide_with_character_bodies"), _SCS("can_collide_with_character_bodies"));
1283 ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision/margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), _SCS("set_collision_margin"), _SCS("get_collision_margin"));
1284 }
1285
KinematicBody()1286 KinematicBody::KinematicBody() :
1287 PhysicsBody(PhysicsServer::BODY_MODE_KINEMATIC) {
1288
1289 collide_static = true;
1290 collide_rigid = true;
1291 collide_kinematic = true;
1292 collide_character = true;
1293
1294 colliding = false;
1295 collider = 0;
1296 margin = 0.001;
1297 collider_shape = 0;
1298 }
~KinematicBody()1299 KinematicBody::~KinematicBody() {
1300 }
1301