1 /*************************************************************************/
2 /* physics_body_2d.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_2d.h"
31 #include "scene/scene_string_names.h"
32
33 bool PhysicsBody2D::motion_fix_enabled = false;
34
_notification(int p_what)35 void PhysicsBody2D::_notification(int p_what) {
36
37 /*
38 switch(p_what) {
39
40 case NOTIFICATION_TRANSFORM_CHANGED: {
41
42 Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_TRANSFORM,get_global_transform());
43
44 } break;
45 }
46 */
47 }
48
set_one_way_collision_direction(const Vector2 & p_dir)49 void PhysicsBody2D::set_one_way_collision_direction(const Vector2 &p_dir) {
50
51 one_way_collision_direction = p_dir;
52 Physics2DServer::get_singleton()->body_set_one_way_collision_direction(get_rid(), p_dir);
53 }
54
get_one_way_collision_direction() const55 Vector2 PhysicsBody2D::get_one_way_collision_direction() const {
56
57 return one_way_collision_direction;
58 }
59
set_one_way_collision_max_depth(float p_depth)60 void PhysicsBody2D::set_one_way_collision_max_depth(float p_depth) {
61
62 one_way_collision_max_depth = p_depth;
63 Physics2DServer::get_singleton()->body_set_one_way_collision_max_depth(get_rid(), p_depth);
64 }
65
get_one_way_collision_max_depth() const66 float PhysicsBody2D::get_one_way_collision_max_depth() const {
67
68 return one_way_collision_max_depth;
69 }
70
_set_layers(uint32_t p_mask)71 void PhysicsBody2D::_set_layers(uint32_t p_mask) {
72
73 set_layer_mask(p_mask);
74 set_collision_mask(p_mask);
75 }
76
_get_layers() const77 uint32_t PhysicsBody2D::_get_layers() const {
78
79 return get_layer_mask();
80 }
81
_bind_methods()82 void PhysicsBody2D::_bind_methods() {
83
84 ObjectTypeDB::bind_method(_MD("set_layer_mask", "mask"), &PhysicsBody2D::set_layer_mask);
85 ObjectTypeDB::bind_method(_MD("get_layer_mask"), &PhysicsBody2D::get_layer_mask);
86 ObjectTypeDB::bind_method(_MD("set_collision_mask", "mask"), &PhysicsBody2D::set_collision_mask);
87 ObjectTypeDB::bind_method(_MD("get_collision_mask"), &PhysicsBody2D::get_collision_mask);
88
89 ObjectTypeDB::bind_method(_MD("set_collision_mask_bit", "bit", "value"), &PhysicsBody2D::set_collision_mask_bit);
90 ObjectTypeDB::bind_method(_MD("get_collision_mask_bit", "bit"), &PhysicsBody2D::get_collision_mask_bit);
91
92 ObjectTypeDB::bind_method(_MD("set_layer_mask_bit", "bit", "value"), &PhysicsBody2D::set_layer_mask_bit);
93 ObjectTypeDB::bind_method(_MD("get_layer_mask_bit", "bit"), &PhysicsBody2D::get_layer_mask_bit);
94
95 ObjectTypeDB::bind_method(_MD("_set_layers", "mask"), &PhysicsBody2D::_set_layers);
96 ObjectTypeDB::bind_method(_MD("_get_layers"), &PhysicsBody2D::_get_layers);
97 ObjectTypeDB::bind_method(_MD("set_one_way_collision_direction", "dir"), &PhysicsBody2D::set_one_way_collision_direction);
98 ObjectTypeDB::bind_method(_MD("get_one_way_collision_direction"), &PhysicsBody2D::get_one_way_collision_direction);
99 ObjectTypeDB::bind_method(_MD("set_one_way_collision_max_depth", "depth"), &PhysicsBody2D::set_one_way_collision_max_depth);
100 ObjectTypeDB::bind_method(_MD("get_one_way_collision_max_depth"), &PhysicsBody2D::get_one_way_collision_max_depth);
101 ObjectTypeDB::bind_method(_MD("add_collision_exception_with", "body:PhysicsBody2D"), &PhysicsBody2D::add_collision_exception_with);
102 ObjectTypeDB::bind_method(_MD("remove_collision_exception_with", "body:PhysicsBody2D"), &PhysicsBody2D::remove_collision_exception_with);
103 ADD_PROPERTY(PropertyInfo(Variant::INT, "layers", PROPERTY_HINT_ALL_FLAGS, "", 0), _SCS("_set_layers"), _SCS("_get_layers")); //for backwards compat
104 ADD_PROPERTY(PropertyInfo(Variant::INT, "collision/layers", PROPERTY_HINT_ALL_FLAGS), _SCS("set_layer_mask"), _SCS("get_layer_mask"));
105 ADD_PROPERTY(PropertyInfo(Variant::INT, "collision/mask", PROPERTY_HINT_ALL_FLAGS), _SCS("set_collision_mask"), _SCS("get_collision_mask"));
106 ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2, "one_way_collision/direction"), _SCS("set_one_way_collision_direction"), _SCS("get_one_way_collision_direction"));
107 ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "one_way_collision/max_depth"), _SCS("set_one_way_collision_max_depth"), _SCS("get_one_way_collision_max_depth"));
108 }
109
set_layer_mask(uint32_t p_mask)110 void PhysicsBody2D::set_layer_mask(uint32_t p_mask) {
111
112 mask = p_mask;
113 Physics2DServer::get_singleton()->body_set_layer_mask(get_rid(), p_mask);
114 }
115
get_layer_mask() const116 uint32_t PhysicsBody2D::get_layer_mask() const {
117
118 return mask;
119 }
120
set_collision_mask(uint32_t p_mask)121 void PhysicsBody2D::set_collision_mask(uint32_t p_mask) {
122
123 collision_mask = p_mask;
124 Physics2DServer::get_singleton()->body_set_collision_mask(get_rid(), p_mask);
125 }
126
get_collision_mask() const127 uint32_t PhysicsBody2D::get_collision_mask() const {
128
129 return collision_mask;
130 }
131
set_collision_mask_bit(int p_bit,bool p_value)132 void PhysicsBody2D::set_collision_mask_bit(int p_bit, bool p_value) {
133
134 uint32_t mask = get_collision_mask();
135 if (p_value)
136 mask |= 1 << p_bit;
137 else
138 mask &= ~(1 << p_bit);
139 set_collision_mask(mask);
140 }
get_collision_mask_bit(int p_bit) const141 bool PhysicsBody2D::get_collision_mask_bit(int p_bit) const {
142
143 return get_collision_mask() & (1 << p_bit);
144 }
145
set_layer_mask_bit(int p_bit,bool p_value)146 void PhysicsBody2D::set_layer_mask_bit(int p_bit, bool p_value) {
147
148 uint32_t mask = get_layer_mask();
149 if (p_value)
150 mask |= 1 << p_bit;
151 else
152 mask &= ~(1 << p_bit);
153 set_layer_mask(mask);
154 }
155
get_layer_mask_bit(int p_bit) const156 bool PhysicsBody2D::get_layer_mask_bit(int p_bit) const {
157
158 return get_layer_mask() & (1 << p_bit);
159 }
160
PhysicsBody2D(Physics2DServer::BodyMode p_mode)161 PhysicsBody2D::PhysicsBody2D(Physics2DServer::BodyMode p_mode) :
162 CollisionObject2D(Physics2DServer::get_singleton()->body_create(p_mode), false) {
163
164 mask = 1;
165 collision_mask = 1;
166 set_one_way_collision_max_depth(0);
167 set_pickable(false);
168 }
169
add_collision_exception_with(Node * p_node)170 void PhysicsBody2D::add_collision_exception_with(Node *p_node) {
171
172 ERR_FAIL_NULL(p_node);
173 PhysicsBody2D *physics_body = p_node->cast_to<PhysicsBody2D>();
174 if (!physics_body) {
175 ERR_EXPLAIN("Collision exception only works between two objects of PhysicsBody type");
176 }
177 ERR_FAIL_COND(!physics_body);
178 Physics2DServer::get_singleton()->body_add_collision_exception(get_rid(), physics_body->get_rid());
179 }
180
remove_collision_exception_with(Node * p_node)181 void PhysicsBody2D::remove_collision_exception_with(Node *p_node) {
182
183 ERR_FAIL_NULL(p_node);
184 PhysicsBody2D *physics_body = p_node->cast_to<PhysicsBody2D>();
185 if (!physics_body) {
186 ERR_EXPLAIN("Collision exception only works between two objects of PhysicsBody type");
187 }
188 ERR_FAIL_COND(!physics_body);
189 Physics2DServer::get_singleton()->body_remove_collision_exception(get_rid(), physics_body->get_rid());
190 }
191
set_constant_linear_velocity(const Vector2 & p_vel)192 void StaticBody2D::set_constant_linear_velocity(const Vector2 &p_vel) {
193
194 constant_linear_velocity = p_vel;
195 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_LINEAR_VELOCITY, constant_linear_velocity);
196 }
197
set_constant_angular_velocity(real_t p_vel)198 void StaticBody2D::set_constant_angular_velocity(real_t p_vel) {
199
200 constant_angular_velocity = p_vel;
201 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_ANGULAR_VELOCITY, constant_angular_velocity);
202 }
203
get_constant_linear_velocity() const204 Vector2 StaticBody2D::get_constant_linear_velocity() const {
205
206 return constant_linear_velocity;
207 }
get_constant_angular_velocity() const208 real_t StaticBody2D::get_constant_angular_velocity() const {
209
210 return constant_angular_velocity;
211 }
212 #if 0
213 void StaticBody2D::_update_xform() {
214
215 if (!pre_xform || !pending)
216 return;
217
218 setting=true;
219
220
221 Matrix32 new_xform = get_global_transform(); //obtain the new one
222
223 set_block_transform_notify(true);
224 Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_TRANSFORM,*pre_xform); //then simulate motion!
225 set_global_transform(*pre_xform); //but restore state to previous one in both visual and physics
226 set_block_transform_notify(false);
227
228 Physics2DServer::get_singleton()->body_static_simulate_motion(get_rid(),new_xform); //then simulate motion!
229
230 setting=false;
231 pending=false;
232
233 }
234 #endif
235
set_friction(real_t p_friction)236 void StaticBody2D::set_friction(real_t p_friction) {
237
238 ERR_FAIL_COND(p_friction < 0 || p_friction > 1);
239
240 friction = p_friction;
241 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, friction);
242 }
get_friction() const243 real_t StaticBody2D::get_friction() const {
244
245 return friction;
246 }
247
set_bounce(real_t p_bounce)248 void StaticBody2D::set_bounce(real_t p_bounce) {
249
250 ERR_FAIL_COND(p_bounce < 0 || p_bounce > 1);
251
252 bounce = p_bounce;
253 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, bounce);
254 }
get_bounce() const255 real_t StaticBody2D::get_bounce() const {
256
257 return bounce;
258 }
259
_bind_methods()260 void StaticBody2D::_bind_methods() {
261
262 ObjectTypeDB::bind_method(_MD("set_constant_linear_velocity", "vel"), &StaticBody2D::set_constant_linear_velocity);
263 ObjectTypeDB::bind_method(_MD("set_constant_angular_velocity", "vel"), &StaticBody2D::set_constant_angular_velocity);
264 ObjectTypeDB::bind_method(_MD("get_constant_linear_velocity"), &StaticBody2D::get_constant_linear_velocity);
265 ObjectTypeDB::bind_method(_MD("get_constant_angular_velocity"), &StaticBody2D::get_constant_angular_velocity);
266 ObjectTypeDB::bind_method(_MD("set_friction", "friction"), &StaticBody2D::set_friction);
267 ObjectTypeDB::bind_method(_MD("get_friction"), &StaticBody2D::get_friction);
268
269 ObjectTypeDB::bind_method(_MD("set_bounce", "bounce"), &StaticBody2D::set_bounce);
270 ObjectTypeDB::bind_method(_MD("get_bounce"), &StaticBody2D::get_bounce);
271
272 ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "constant_linear_velocity"), _SCS("set_constant_linear_velocity"), _SCS("get_constant_linear_velocity"));
273 ADD_PROPERTY(PropertyInfo(Variant::REAL, "constant_angular_velocity"), _SCS("set_constant_angular_velocity"), _SCS("get_constant_angular_velocity"));
274 ADD_PROPERTY(PropertyInfo(Variant::REAL, "friction", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_friction"), _SCS("get_friction"));
275 ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_bounce"), _SCS("get_bounce"));
276 }
277
StaticBody2D()278 StaticBody2D::StaticBody2D() :
279 PhysicsBody2D(Physics2DServer::BODY_MODE_STATIC) {
280
281 constant_angular_velocity = 0;
282 bounce = 0;
283 friction = 1;
284 }
285
~StaticBody2D()286 StaticBody2D::~StaticBody2D() {
287 }
288
_body_enter_tree(ObjectID p_id)289 void RigidBody2D::_body_enter_tree(ObjectID p_id) {
290
291 Object *obj = ObjectDB::get_instance(p_id);
292 Node *node = obj ? obj->cast_to<Node>() : NULL;
293 ERR_FAIL_COND(!node);
294
295 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
296 ERR_FAIL_COND(!E);
297 ERR_FAIL_COND(E->get().in_scene);
298
299 contact_monitor->locked = true;
300
301 E->get().in_scene = true;
302 emit_signal(SceneStringNames::get_singleton()->body_enter, node);
303
304 for (int i = 0; i < E->get().shapes.size(); i++) {
305
306 emit_signal(SceneStringNames::get_singleton()->body_enter_shape, p_id, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
307 }
308
309 contact_monitor->locked = false;
310 }
311
_body_exit_tree(ObjectID p_id)312 void RigidBody2D::_body_exit_tree(ObjectID p_id) {
313
314 Object *obj = ObjectDB::get_instance(p_id);
315 Node *node = obj ? obj->cast_to<Node>() : NULL;
316 ERR_FAIL_COND(!node);
317 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
318 ERR_FAIL_COND(!E);
319 ERR_FAIL_COND(!E->get().in_scene);
320 E->get().in_scene = false;
321
322 contact_monitor->locked = true;
323
324 emit_signal(SceneStringNames::get_singleton()->body_exit, node);
325
326 for (int i = 0; i < E->get().shapes.size(); i++) {
327
328 emit_signal(SceneStringNames::get_singleton()->body_exit_shape, p_id, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
329 }
330
331 contact_monitor->locked = false;
332 }
333
_body_inout(int p_status,ObjectID p_instance,int p_body_shape,int p_local_shape)334 void RigidBody2D::_body_inout(int p_status, ObjectID p_instance, int p_body_shape, int p_local_shape) {
335
336 bool body_in = p_status == 1;
337 ObjectID objid = p_instance;
338
339 Object *obj = ObjectDB::get_instance(objid);
340 Node *node = obj ? obj->cast_to<Node>() : NULL;
341
342 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(objid);
343
344 /*if (obj) {
345 if (body_in)
346 print_line("in: "+String(obj->call("get_name")));
347 else
348 print_line("out: "+String(obj->call("get_name")));
349 }*/
350
351 ERR_FAIL_COND(!body_in && !E);
352
353 if (body_in) {
354 if (!E) {
355
356 E = contact_monitor->body_map.insert(objid, BodyState());
357 // E->get().rc=0;
358 E->get().in_scene = node && node->is_inside_tree();
359 if (node) {
360 node->connect(SceneStringNames::get_singleton()->enter_tree, this, SceneStringNames::get_singleton()->_body_enter_tree, make_binds(objid));
361 node->connect(SceneStringNames::get_singleton()->exit_tree, this, SceneStringNames::get_singleton()->_body_exit_tree, make_binds(objid));
362 if (E->get().in_scene) {
363 emit_signal(SceneStringNames::get_singleton()->body_enter, node);
364 }
365 }
366
367 //E->get().rc++;
368 }
369
370 if (node)
371 E->get().shapes.insert(ShapePair(p_body_shape, p_local_shape));
372
373 if (E->get().in_scene) {
374 emit_signal(SceneStringNames::get_singleton()->body_enter_shape, objid, node, p_body_shape, p_local_shape);
375 }
376
377 } else {
378
379 //E->get().rc--;
380
381 if (node)
382 E->get().shapes.erase(ShapePair(p_body_shape, p_local_shape));
383
384 bool in_scene = E->get().in_scene;
385
386 if (E->get().shapes.empty()) {
387
388 if (node) {
389 node->disconnect(SceneStringNames::get_singleton()->enter_tree, this, SceneStringNames::get_singleton()->_body_enter_tree);
390 node->disconnect(SceneStringNames::get_singleton()->exit_tree, this, SceneStringNames::get_singleton()->_body_exit_tree);
391 if (in_scene)
392 emit_signal(SceneStringNames::get_singleton()->body_exit, obj);
393 }
394
395 contact_monitor->body_map.erase(E);
396 }
397 if (node && in_scene) {
398 emit_signal(SceneStringNames::get_singleton()->body_exit_shape, objid, obj, p_body_shape, p_local_shape);
399 }
400 }
401 }
402
403 struct _RigidBody2DInOut {
404
405 ObjectID id;
406 int shape;
407 int local_shape;
408 };
409
_test_motion(const Vector2 & p_motion,float p_margin,const Ref<Physics2DTestMotionResult> & p_result)410 bool RigidBody2D::_test_motion(const Vector2 &p_motion, float p_margin, const Ref<Physics2DTestMotionResult> &p_result) {
411
412 Physics2DServer::MotionResult *r = NULL;
413 if (p_result.is_valid())
414 r = p_result->get_result_ptr();
415 if (motion_fix_enabled) {
416 return Physics2DServer::get_singleton()->body_test_motion_from(get_rid(), get_global_transform(), p_motion, p_margin, r);
417 } else {
418 return Physics2DServer::get_singleton()->body_test_motion(get_rid(), p_motion, p_margin, r);
419 }
420 }
421
_direct_state_changed(Object * p_state)422 void RigidBody2D::_direct_state_changed(Object *p_state) {
423
424 //eh.. fuck
425 #ifdef DEBUG_ENABLED
426
427 state = p_state->cast_to<Physics2DDirectBodyState>();
428 #else
429 state = (Physics2DDirectBodyState *)p_state; //trust it
430 #endif
431
432 set_block_transform_notify(true); // don't want notify (would feedback loop)
433 if (mode != MODE_KINEMATIC)
434 set_global_transform(state->get_transform());
435 linear_velocity = state->get_linear_velocity();
436 angular_velocity = state->get_angular_velocity();
437 if (sleeping != state->is_sleeping()) {
438 sleeping = state->is_sleeping();
439 emit_signal(SceneStringNames::get_singleton()->sleeping_state_changed);
440 }
441 if (get_script_instance())
442 get_script_instance()->call("_integrate_forces", state);
443 set_block_transform_notify(false); // want it back
444
445 if (contact_monitor) {
446
447 contact_monitor->locked = true;
448
449 //untag all
450 int rc = 0;
451 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
452
453 for (int i = 0; i < E->get().shapes.size(); i++) {
454
455 E->get().shapes[i].tagged = false;
456 rc++;
457 }
458 }
459
460 _RigidBody2DInOut *toadd = (_RigidBody2DInOut *)alloca(state->get_contact_count() * sizeof(_RigidBody2DInOut));
461 int toadd_count = 0; //state->get_contact_count();
462 RigidBody2D_RemoveAction *toremove = (RigidBody2D_RemoveAction *)alloca(rc * sizeof(RigidBody2D_RemoveAction));
463 int toremove_count = 0;
464
465 //put the ones to add
466
467 for (int i = 0; i < state->get_contact_count(); i++) {
468
469 ObjectID obj = state->get_contact_collider_id(i);
470 int local_shape = state->get_contact_local_shape(i);
471 int shape = state->get_contact_collider_shape(i);
472
473 // bool found=false;
474
475 Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(obj);
476 if (!E) {
477 toadd[toadd_count].local_shape = local_shape;
478 toadd[toadd_count].id = obj;
479 toadd[toadd_count].shape = shape;
480 toadd_count++;
481 continue;
482 }
483
484 ShapePair sp(shape, local_shape);
485 int idx = E->get().shapes.find(sp);
486 if (idx == -1) {
487
488 toadd[toadd_count].local_shape = local_shape;
489 toadd[toadd_count].id = obj;
490 toadd[toadd_count].shape = shape;
491 toadd_count++;
492 continue;
493 }
494
495 E->get().shapes[idx].tagged = true;
496 }
497
498 //put the ones to remove
499
500 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
501
502 for (int i = 0; i < E->get().shapes.size(); i++) {
503
504 if (!E->get().shapes[i].tagged) {
505
506 toremove[toremove_count].body_id = E->key();
507 toremove[toremove_count].pair = E->get().shapes[i];
508 toremove_count++;
509 }
510 }
511 }
512
513 //process remotions
514
515 for (int i = 0; i < toremove_count; i++) {
516
517 _body_inout(0, toremove[i].body_id, toremove[i].pair.body_shape, toremove[i].pair.local_shape);
518 }
519
520 //process aditions
521
522 for (int i = 0; i < toadd_count; i++) {
523
524 _body_inout(1, toadd[i].id, toadd[i].shape, toadd[i].local_shape);
525 }
526
527 contact_monitor->locked = false;
528 }
529
530 state = NULL;
531 }
532
set_mode(Mode p_mode)533 void RigidBody2D::set_mode(Mode p_mode) {
534
535 mode = p_mode;
536 switch (p_mode) {
537
538 case MODE_RIGID: {
539
540 Physics2DServer::get_singleton()->body_set_mode(get_rid(), Physics2DServer::BODY_MODE_RIGID);
541 } break;
542 case MODE_STATIC: {
543
544 Physics2DServer::get_singleton()->body_set_mode(get_rid(), Physics2DServer::BODY_MODE_STATIC);
545
546 } break;
547 case MODE_KINEMATIC: {
548
549 Physics2DServer::get_singleton()->body_set_mode(get_rid(), Physics2DServer::BODY_MODE_KINEMATIC);
550
551 } break;
552 case MODE_CHARACTER: {
553 Physics2DServer::get_singleton()->body_set_mode(get_rid(), Physics2DServer::BODY_MODE_CHARACTER);
554
555 } break;
556 }
557 }
558
get_mode() const559 RigidBody2D::Mode RigidBody2D::get_mode() const {
560
561 return mode;
562 }
563
set_mass(real_t p_mass)564 void RigidBody2D::set_mass(real_t p_mass) {
565
566 ERR_FAIL_COND(p_mass <= 0);
567 mass = p_mass;
568 _change_notify("mass");
569 _change_notify("weight");
570 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_MASS, mass);
571 }
get_mass() const572 real_t RigidBody2D::get_mass() const {
573
574 return mass;
575 }
576
set_inertia(real_t p_inertia)577 void RigidBody2D::set_inertia(real_t p_inertia) {
578
579 ERR_FAIL_COND(p_inertia <= 0);
580 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_INERTIA, p_inertia);
581 }
582
get_inertia() const583 real_t RigidBody2D::get_inertia() const {
584
585 return Physics2DServer::get_singleton()->body_get_param(get_rid(), Physics2DServer::BODY_PARAM_INERTIA);
586 }
587
set_weight(real_t p_weight)588 void RigidBody2D::set_weight(real_t p_weight) {
589
590 set_mass(p_weight / 9.8);
591 }
get_weight() const592 real_t RigidBody2D::get_weight() const {
593
594 return mass * 9.8;
595 }
596
set_friction(real_t p_friction)597 void RigidBody2D::set_friction(real_t p_friction) {
598
599 ERR_FAIL_COND(p_friction < 0 || p_friction > 1);
600
601 friction = p_friction;
602 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, friction);
603 }
get_friction() const604 real_t RigidBody2D::get_friction() const {
605
606 return friction;
607 }
608
set_bounce(real_t p_bounce)609 void RigidBody2D::set_bounce(real_t p_bounce) {
610
611 ERR_FAIL_COND(p_bounce < 0 || p_bounce > 1);
612
613 bounce = p_bounce;
614 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, bounce);
615 }
get_bounce() const616 real_t RigidBody2D::get_bounce() const {
617
618 return bounce;
619 }
620
set_gravity_scale(real_t p_gravity_scale)621 void RigidBody2D::set_gravity_scale(real_t p_gravity_scale) {
622
623 gravity_scale = p_gravity_scale;
624 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
625 }
get_gravity_scale() const626 real_t RigidBody2D::get_gravity_scale() const {
627
628 return gravity_scale;
629 }
630
set_linear_damp(real_t p_linear_damp)631 void RigidBody2D::set_linear_damp(real_t p_linear_damp) {
632
633 ERR_FAIL_COND(p_linear_damp < -1);
634 linear_damp = p_linear_damp;
635 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_LINEAR_DAMP, linear_damp);
636 }
get_linear_damp() const637 real_t RigidBody2D::get_linear_damp() const {
638
639 return linear_damp;
640 }
641
set_angular_damp(real_t p_angular_damp)642 void RigidBody2D::set_angular_damp(real_t p_angular_damp) {
643
644 ERR_FAIL_COND(p_angular_damp < -1);
645 angular_damp = p_angular_damp;
646 Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_ANGULAR_DAMP, angular_damp);
647 }
get_angular_damp() const648 real_t RigidBody2D::get_angular_damp() const {
649
650 return angular_damp;
651 }
652
set_axis_velocity(const Vector2 & p_axis)653 void RigidBody2D::set_axis_velocity(const Vector2 &p_axis) {
654
655 Vector2 v = state ? state->get_linear_velocity() : linear_velocity;
656 Vector2 axis = p_axis.normalized();
657 v -= axis * axis.dot(v);
658 v += p_axis;
659 if (state) {
660 set_linear_velocity(v);
661 } else {
662 Physics2DServer::get_singleton()->body_set_axis_velocity(get_rid(), p_axis);
663 linear_velocity = v;
664 }
665 }
666
set_linear_velocity(const Vector2 & p_velocity)667 void RigidBody2D::set_linear_velocity(const Vector2 &p_velocity) {
668
669 linear_velocity = p_velocity;
670 if (state)
671 state->set_linear_velocity(linear_velocity);
672 else {
673
674 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
675 }
676 }
677
get_linear_velocity() const678 Vector2 RigidBody2D::get_linear_velocity() const {
679
680 return linear_velocity;
681 }
682
set_angular_velocity(real_t p_velocity)683 void RigidBody2D::set_angular_velocity(real_t p_velocity) {
684
685 angular_velocity = p_velocity;
686 if (state)
687 state->set_angular_velocity(angular_velocity);
688 else
689 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
690 }
get_angular_velocity() const691 real_t RigidBody2D::get_angular_velocity() const {
692
693 return angular_velocity;
694 }
695
set_use_custom_integrator(bool p_enable)696 void RigidBody2D::set_use_custom_integrator(bool p_enable) {
697
698 if (custom_integrator == p_enable)
699 return;
700
701 custom_integrator = p_enable;
702 Physics2DServer::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
703 }
is_using_custom_integrator()704 bool RigidBody2D::is_using_custom_integrator() {
705
706 return custom_integrator;
707 }
708
set_sleeping(bool p_sleeping)709 void RigidBody2D::set_sleeping(bool p_sleeping) {
710
711 sleeping = p_sleeping;
712 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_SLEEPING, sleeping);
713 }
714
set_can_sleep(bool p_active)715 void RigidBody2D::set_can_sleep(bool p_active) {
716
717 can_sleep = p_active;
718 Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_CAN_SLEEP, p_active);
719 }
720
is_able_to_sleep() const721 bool RigidBody2D::is_able_to_sleep() const {
722
723 return can_sleep;
724 }
725
is_sleeping() const726 bool RigidBody2D::is_sleeping() const {
727
728 return sleeping;
729 }
730
set_max_contacts_reported(int p_amount)731 void RigidBody2D::set_max_contacts_reported(int p_amount) {
732
733 max_contacts_reported = p_amount;
734 Physics2DServer::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
735 }
736
get_max_contacts_reported() const737 int RigidBody2D::get_max_contacts_reported() const {
738
739 return max_contacts_reported;
740 }
741
apply_impulse(const Vector2 & p_offset,const Vector2 & p_impulse)742 void RigidBody2D::apply_impulse(const Vector2 &p_offset, const Vector2 &p_impulse) {
743
744 Physics2DServer::get_singleton()->body_apply_impulse(get_rid(), p_offset, p_impulse);
745 }
746
set_applied_force(const Vector2 & p_force)747 void RigidBody2D::set_applied_force(const Vector2 &p_force) {
748
749 Physics2DServer::get_singleton()->body_set_applied_force(get_rid(), p_force);
750 };
751
get_applied_force() const752 Vector2 RigidBody2D::get_applied_force() const {
753
754 return Physics2DServer::get_singleton()->body_get_applied_force(get_rid());
755 };
756
set_applied_torque(const float p_torque)757 void RigidBody2D::set_applied_torque(const float p_torque) {
758
759 Physics2DServer::get_singleton()->body_set_applied_torque(get_rid(), p_torque);
760 };
761
get_applied_torque() const762 float RigidBody2D::get_applied_torque() const {
763
764 return Physics2DServer::get_singleton()->body_get_applied_torque(get_rid());
765 };
766
add_force(const Vector2 & p_offset,const Vector2 & p_force)767 void RigidBody2D::add_force(const Vector2 &p_offset, const Vector2 &p_force) {
768
769 Physics2DServer::get_singleton()->body_add_force(get_rid(), p_offset, p_force);
770 }
771
set_continuous_collision_detection_mode(CCDMode p_mode)772 void RigidBody2D::set_continuous_collision_detection_mode(CCDMode p_mode) {
773
774 ccd_mode = p_mode;
775 Physics2DServer::get_singleton()->body_set_continuous_collision_detection_mode(get_rid(), Physics2DServer::CCDMode(p_mode));
776 }
777
get_continuous_collision_detection_mode() const778 RigidBody2D::CCDMode RigidBody2D::get_continuous_collision_detection_mode() const {
779
780 return ccd_mode;
781 }
782
get_colliding_bodies() const783 Array RigidBody2D::get_colliding_bodies() const {
784
785 ERR_FAIL_COND_V(!contact_monitor, Array());
786
787 Array ret;
788 ret.resize(contact_monitor->body_map.size());
789 int idx = 0;
790 for (const Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
791 Object *obj = ObjectDB::get_instance(E->key());
792 if (!obj) {
793 ret.resize(ret.size() - 1); //ops
794 } else {
795 ret[idx++] = obj;
796 }
797 }
798
799 return ret;
800 }
801
set_contact_monitor(bool p_enabled)802 void RigidBody2D::set_contact_monitor(bool p_enabled) {
803
804 if (p_enabled == is_contact_monitor_enabled())
805 return;
806
807 if (!p_enabled) {
808
809 if (contact_monitor->locked) {
810 ERR_EXPLAIN("Can't disable contact monitoring during in/out callback. Use call_deferred(\"set_contact_monitor\",false) instead");
811 }
812 ERR_FAIL_COND(contact_monitor->locked);
813
814 for (Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.front(); E; E = E->next()) {
815
816 //clean up mess
817 }
818
819 memdelete(contact_monitor);
820 contact_monitor = NULL;
821 } else {
822
823 contact_monitor = memnew(ContactMonitor);
824 contact_monitor->locked = false;
825 }
826 }
827
is_contact_monitor_enabled() const828 bool RigidBody2D::is_contact_monitor_enabled() const {
829
830 return contact_monitor != NULL;
831 }
832
_notification(int p_what)833 void RigidBody2D::_notification(int p_what) {
834
835 #ifdef TOOLS_ENABLED
836 if (p_what == NOTIFICATION_ENTER_TREE) {
837 if (get_tree()->is_editor_hint()) {
838 set_notify_local_transform(true); //used for warnings and only in editor
839 }
840 }
841
842 if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {
843 if (get_tree()->is_editor_hint()) {
844 update_configuration_warning();
845 }
846 }
847
848 #endif
849 }
850
get_configuration_warning() const851 String RigidBody2D::get_configuration_warning() const {
852
853 Matrix32 t = get_transform();
854
855 String warning = CollisionObject2D::get_configuration_warning();
856
857 if ((get_mode() == MODE_RIGID || get_mode() == MODE_CHARACTER) && (ABS(t.elements[0].length() - 1.0) > 0.05 || ABS(t.elements[1].length() - 1.0) > 0.05)) {
858 if (warning != String()) {
859 warning += "\n";
860 }
861 warning += TTR("Size changes to RigidBody2D (in character or rigid modes) will be overriden by the physics engine when running.\nChange the size in children collision shapes instead.");
862 }
863
864 return warning;
865 }
866
_bind_methods()867 void RigidBody2D::_bind_methods() {
868
869 ObjectTypeDB::bind_method(_MD("set_mode", "mode"), &RigidBody2D::set_mode);
870 ObjectTypeDB::bind_method(_MD("get_mode"), &RigidBody2D::get_mode);
871
872 ObjectTypeDB::bind_method(_MD("set_mass", "mass"), &RigidBody2D::set_mass);
873 ObjectTypeDB::bind_method(_MD("get_mass"), &RigidBody2D::get_mass);
874
875 ObjectTypeDB::bind_method(_MD("get_inertia"), &RigidBody2D::get_inertia);
876 ObjectTypeDB::bind_method(_MD("set_inertia", "inertia"), &RigidBody2D::set_inertia);
877
878 ObjectTypeDB::bind_method(_MD("set_weight", "weight"), &RigidBody2D::set_weight);
879 ObjectTypeDB::bind_method(_MD("get_weight"), &RigidBody2D::get_weight);
880
881 ObjectTypeDB::bind_method(_MD("set_friction", "friction"), &RigidBody2D::set_friction);
882 ObjectTypeDB::bind_method(_MD("get_friction"), &RigidBody2D::get_friction);
883
884 ObjectTypeDB::bind_method(_MD("set_bounce", "bounce"), &RigidBody2D::set_bounce);
885 ObjectTypeDB::bind_method(_MD("get_bounce"), &RigidBody2D::get_bounce);
886
887 ObjectTypeDB::bind_method(_MD("set_gravity_scale", "gravity_scale"), &RigidBody2D::set_gravity_scale);
888 ObjectTypeDB::bind_method(_MD("get_gravity_scale"), &RigidBody2D::get_gravity_scale);
889
890 ObjectTypeDB::bind_method(_MD("set_linear_damp", "linear_damp"), &RigidBody2D::set_linear_damp);
891 ObjectTypeDB::bind_method(_MD("get_linear_damp"), &RigidBody2D::get_linear_damp);
892
893 ObjectTypeDB::bind_method(_MD("set_angular_damp", "angular_damp"), &RigidBody2D::set_angular_damp);
894 ObjectTypeDB::bind_method(_MD("get_angular_damp"), &RigidBody2D::get_angular_damp);
895
896 ObjectTypeDB::bind_method(_MD("set_linear_velocity", "linear_velocity"), &RigidBody2D::set_linear_velocity);
897 ObjectTypeDB::bind_method(_MD("get_linear_velocity"), &RigidBody2D::get_linear_velocity);
898
899 ObjectTypeDB::bind_method(_MD("set_angular_velocity", "angular_velocity"), &RigidBody2D::set_angular_velocity);
900 ObjectTypeDB::bind_method(_MD("get_angular_velocity"), &RigidBody2D::get_angular_velocity);
901
902 ObjectTypeDB::bind_method(_MD("set_max_contacts_reported", "amount"), &RigidBody2D::set_max_contacts_reported);
903 ObjectTypeDB::bind_method(_MD("get_max_contacts_reported"), &RigidBody2D::get_max_contacts_reported);
904
905 ObjectTypeDB::bind_method(_MD("set_use_custom_integrator", "enable"), &RigidBody2D::set_use_custom_integrator);
906 ObjectTypeDB::bind_method(_MD("is_using_custom_integrator"), &RigidBody2D::is_using_custom_integrator);
907
908 ObjectTypeDB::bind_method(_MD("set_contact_monitor", "enabled"), &RigidBody2D::set_contact_monitor);
909 ObjectTypeDB::bind_method(_MD("is_contact_monitor_enabled"), &RigidBody2D::is_contact_monitor_enabled);
910
911 ObjectTypeDB::bind_method(_MD("set_continuous_collision_detection_mode", "mode"), &RigidBody2D::set_continuous_collision_detection_mode);
912 ObjectTypeDB::bind_method(_MD("get_continuous_collision_detection_mode"), &RigidBody2D::get_continuous_collision_detection_mode);
913
914 ObjectTypeDB::bind_method(_MD("set_axis_velocity", "axis_velocity"), &RigidBody2D::set_axis_velocity);
915 ObjectTypeDB::bind_method(_MD("apply_impulse", "offset", "impulse"), &RigidBody2D::apply_impulse);
916
917 ObjectTypeDB::bind_method(_MD("set_applied_force", "force"), &RigidBody2D::set_applied_force);
918 ObjectTypeDB::bind_method(_MD("get_applied_force"), &RigidBody2D::get_applied_force);
919
920 ObjectTypeDB::bind_method(_MD("set_applied_torque", "torque"), &RigidBody2D::set_applied_torque);
921 ObjectTypeDB::bind_method(_MD("get_applied_torque"), &RigidBody2D::get_applied_torque);
922
923 ObjectTypeDB::bind_method(_MD("add_force", "offset", "force"), &RigidBody2D::add_force);
924
925 ObjectTypeDB::bind_method(_MD("set_sleeping", "sleeping"), &RigidBody2D::set_sleeping);
926 ObjectTypeDB::bind_method(_MD("is_sleeping"), &RigidBody2D::is_sleeping);
927
928 ObjectTypeDB::bind_method(_MD("set_can_sleep", "able_to_sleep"), &RigidBody2D::set_can_sleep);
929 ObjectTypeDB::bind_method(_MD("is_able_to_sleep"), &RigidBody2D::is_able_to_sleep);
930
931 ObjectTypeDB::bind_method(_MD("test_motion", "motion", "margin", "result:Physics2DTestMotionResult"), &RigidBody2D::_test_motion, DEFVAL(0.08), DEFVAL(Variant()));
932
933 ObjectTypeDB::bind_method(_MD("_direct_state_changed"), &RigidBody2D::_direct_state_changed);
934 ObjectTypeDB::bind_method(_MD("_body_enter_tree"), &RigidBody2D::_body_enter_tree);
935 ObjectTypeDB::bind_method(_MD("_body_exit_tree"), &RigidBody2D::_body_exit_tree);
936
937 ObjectTypeDB::bind_method(_MD("get_colliding_bodies"), &RigidBody2D::get_colliding_bodies);
938
939 BIND_VMETHOD(MethodInfo("_integrate_forces", PropertyInfo(Variant::OBJECT, "state:Physics2DDirectBodyState")));
940
941 ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Rigid,Static,Character,Kinematic"), _SCS("set_mode"), _SCS("get_mode"));
942 ADD_PROPERTY(PropertyInfo(Variant::REAL, "mass", PROPERTY_HINT_EXP_RANGE, "0.01,65535,0.01"), _SCS("set_mass"), _SCS("get_mass"));
943 ADD_PROPERTY(PropertyInfo(Variant::REAL, "weight", PROPERTY_HINT_EXP_RANGE, "0.01,65535,0.01", PROPERTY_USAGE_EDITOR), _SCS("set_weight"), _SCS("get_weight"));
944 ADD_PROPERTY(PropertyInfo(Variant::REAL, "friction", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_friction"), _SCS("get_friction"));
945 ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_bounce"), _SCS("get_bounce"));
946 ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity_scale", PROPERTY_HINT_RANGE, "-128,128,0.01"), _SCS("set_gravity_scale"), _SCS("get_gravity_scale"));
947 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "custom_integrator"), _SCS("set_use_custom_integrator"), _SCS("is_using_custom_integrator"));
948 ADD_PROPERTY(PropertyInfo(Variant::INT, "continuous_cd", PROPERTY_HINT_ENUM, "Disabled,Cast Ray,Cast Shape"), _SCS("set_continuous_collision_detection_mode"), _SCS("get_continuous_collision_detection_mode"));
949 ADD_PROPERTY(PropertyInfo(Variant::INT, "contacts_reported"), _SCS("set_max_contacts_reported"), _SCS("get_max_contacts_reported"));
950 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "contact_monitor"), _SCS("set_contact_monitor"), _SCS("is_contact_monitor_enabled"));
951 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sleeping"), _SCS("set_sleeping"), _SCS("is_sleeping"));
952 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "can_sleep"), _SCS("set_can_sleep"), _SCS("is_able_to_sleep"));
953 ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "velocity/linear"), _SCS("set_linear_velocity"), _SCS("get_linear_velocity"));
954 ADD_PROPERTY(PropertyInfo(Variant::REAL, "velocity/angular"), _SCS("set_angular_velocity"), _SCS("get_angular_velocity"));
955 ADD_PROPERTY(PropertyInfo(Variant::REAL, "damp_override/linear", PROPERTY_HINT_RANGE, "-1,128,0.01"), _SCS("set_linear_damp"), _SCS("get_linear_damp"));
956 ADD_PROPERTY(PropertyInfo(Variant::REAL, "damp_override/angular", PROPERTY_HINT_RANGE, "-1,128,0.01"), _SCS("set_angular_damp"), _SCS("get_angular_damp"));
957
958 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")));
959 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")));
960 ADD_SIGNAL(MethodInfo("body_enter", PropertyInfo(Variant::OBJECT, "body")));
961 ADD_SIGNAL(MethodInfo("body_exit", PropertyInfo(Variant::OBJECT, "body")));
962 ADD_SIGNAL(MethodInfo("sleeping_state_changed"));
963
964 BIND_CONSTANT(MODE_STATIC);
965 BIND_CONSTANT(MODE_KINEMATIC);
966 BIND_CONSTANT(MODE_RIGID);
967 BIND_CONSTANT(MODE_CHARACTER);
968
969 BIND_CONSTANT(CCD_MODE_DISABLED);
970 BIND_CONSTANT(CCD_MODE_CAST_RAY);
971 BIND_CONSTANT(CCD_MODE_CAST_SHAPE);
972 }
973
RigidBody2D()974 RigidBody2D::RigidBody2D() :
975 PhysicsBody2D(Physics2DServer::BODY_MODE_RIGID) {
976
977 mode = MODE_RIGID;
978
979 bounce = 0;
980 mass = 1;
981 friction = 1;
982
983 gravity_scale = 1;
984 linear_damp = -1;
985 angular_damp = -1;
986
987 max_contacts_reported = 0;
988 state = NULL;
989
990 angular_velocity = 0;
991 sleeping = false;
992 ccd_mode = CCD_MODE_DISABLED;
993
994 custom_integrator = false;
995 contact_monitor = NULL;
996 can_sleep = true;
997
998 Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(), this, "_direct_state_changed");
999 }
1000
~RigidBody2D()1001 RigidBody2D::~RigidBody2D() {
1002
1003 if (contact_monitor)
1004 memdelete(contact_monitor);
1005 }
1006
1007 //////////////////////////
1008
_get_collider() const1009 Variant KinematicBody2D::_get_collider() const {
1010
1011 ObjectID oid = get_collider();
1012 if (oid == 0)
1013 return Variant();
1014 Object *obj = ObjectDB::get_instance(oid);
1015 if (!obj)
1016 return Variant();
1017
1018 Reference *ref = obj->cast_to<Reference>();
1019 if (ref) {
1020 return Ref<Reference>(ref);
1021 }
1022
1023 return obj;
1024 }
1025
revert_motion()1026 void KinematicBody2D::revert_motion() {
1027
1028 Matrix32 gt = get_global_transform();
1029 gt.elements[2] -= travel;
1030 set_global_transform(gt);
1031 travel = Vector2();
1032 }
1033
get_travel() const1034 Vector2 KinematicBody2D::get_travel() const {
1035
1036 return travel;
1037 }
1038
move(const Vector2 & p_motion)1039 Vector2 KinematicBody2D::move(const Vector2 &p_motion) {
1040
1041 #if 1
1042
1043 Matrix32 gt = get_global_transform();
1044 Physics2DServer::MotionResult result;
1045 if (motion_fix_enabled) {
1046 colliding = Physics2DServer::get_singleton()->body_test_motion_from(get_rid(), gt, p_motion, margin, &result);
1047 } else {
1048 colliding = Physics2DServer::get_singleton()->body_test_motion(get_rid(), p_motion, margin, &result);
1049 }
1050
1051 collider_metadata = result.collider_metadata;
1052 collider_shape = result.collider_shape;
1053 collider_vel = result.collider_velocity;
1054 collision = result.collision_point;
1055 normal = result.collision_normal;
1056 collider = result.collider_id;
1057
1058 gt.elements[2] += result.motion;
1059 set_global_transform(gt);
1060 travel = result.motion;
1061
1062 return result.remainder;
1063
1064 #else
1065 //give me back regular physics engine logic
1066 //this is madness
1067 //and most people using this function will think
1068 //what it does is simpler than using physics
1069 //this took about a week to get right..
1070 //but is it right? who knows at this point..
1071
1072 colliding = false;
1073 ERR_FAIL_COND_V(!is_inside_tree(), Vector2());
1074 Physics2DDirectSpaceState *dss = Physics2DServer::get_singleton()->space_get_direct_state(get_world_2d()->get_space());
1075 ERR_FAIL_COND_V(!dss, Vector2());
1076 const int max_shapes = 32;
1077 Vector2 sr[max_shapes * 2];
1078 int res_shapes;
1079
1080 Set<RID> exclude;
1081 exclude.insert(get_rid());
1082
1083 //recover first
1084 int recover_attempts = 4;
1085
1086 bool collided = false;
1087 uint32_t mask = 0;
1088 if (true)
1089 mask |= Physics2DDirectSpaceState::TYPE_MASK_STATIC_BODY;
1090 if (true)
1091 mask |= Physics2DDirectSpaceState::TYPE_MASK_KINEMATIC_BODY;
1092 if (true)
1093 mask |= Physics2DDirectSpaceState::TYPE_MASK_RIGID_BODY;
1094 if (true)
1095 mask |= Physics2DDirectSpaceState::TYPE_MASK_CHARACTER_BODY;
1096
1097 //print_line("margin: "+rtos(margin));
1098 do {
1099
1100 //motion recover
1101 for (int i = 0; i < get_shape_count(); i++) {
1102
1103 if (is_shape_set_as_trigger(i))
1104 continue;
1105 if (dss->collide_shape(get_shape(i)->get_rid(), get_global_transform() * get_shape_transform(i), Vector2(), margin, sr, max_shapes, res_shapes, exclude, get_layer_mask(), mask))
1106 collided = true;
1107 }
1108
1109 if (!collided)
1110 break;
1111
1112 Vector2 recover_motion;
1113
1114 for (int i = 0; i < res_shapes; i++) {
1115
1116 Vector2 a = sr[i * 2 + 0];
1117 Vector2 b = sr[i * 2 + 1];
1118
1119 float d = a.distance_to(b);
1120
1121 //if (d<margin)
1122 /// continue;
1123 recover_motion += (b - a) * 0.4;
1124 }
1125
1126 if (recover_motion == Vector2()) {
1127 collided = false;
1128 break;
1129 }
1130
1131 Matrix32 gt = get_global_transform();
1132 gt.elements[2] += recover_motion;
1133 set_global_transform(gt);
1134
1135 recover_attempts--;
1136
1137 } while (recover_attempts);
1138
1139 //move second
1140 float safe = 1.0;
1141 float unsafe = 1.0;
1142 int best_shape = -1;
1143
1144 for (int i = 0; i < get_shape_count(); i++) {
1145
1146 if (is_shape_set_as_trigger(i))
1147 continue;
1148
1149 float lsafe, lunsafe;
1150 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);
1151 //print_line("shape: "+itos(i)+" travel:"+rtos(ltravel));
1152 if (!valid) {
1153
1154 safe = 0;
1155 unsafe = 0;
1156 best_shape = i; //sadly it's the best
1157 break;
1158 }
1159 if (lsafe == 1.0) {
1160 continue;
1161 }
1162 if (lsafe < safe) {
1163
1164 safe = lsafe;
1165 unsafe = lunsafe;
1166 best_shape = i;
1167 }
1168 }
1169
1170 //print_line("best shape: "+itos(best_shape)+" motion "+p_motion);
1171
1172 if (safe >= 1) {
1173 //not collided
1174 colliding = false;
1175
1176 } else {
1177
1178 //it collided, let's get the rest info in unsafe advance
1179 Matrix32 ugt = get_global_transform();
1180 ugt.elements[2] += p_motion * unsafe;
1181 Physics2DDirectSpaceState::ShapeRestInfo rest_info;
1182 bool c2 = dss->rest_info(get_shape(best_shape)->get_rid(), ugt * get_shape_transform(best_shape), Vector2(), margin, &rest_info, exclude, get_layer_mask(), mask);
1183 if (!c2) {
1184 //should not happen, but floating point precision is so weird..
1185
1186 colliding = false;
1187 } else {
1188
1189 //print_line("Travel: "+rtos(travel));
1190 colliding = true;
1191 collision = rest_info.point;
1192 normal = rest_info.normal;
1193 collider = rest_info.collider_id;
1194 collider_vel = rest_info.linear_velocity;
1195 collider_shape = rest_info.shape;
1196 collider_metadata = rest_info.metadata;
1197 }
1198 }
1199
1200 Vector2 motion = p_motion * safe;
1201 Matrix32 gt = get_global_transform();
1202 gt.elements[2] += motion;
1203 set_global_transform(gt);
1204
1205 return p_motion - motion;
1206 #endif
1207 }
1208
move_to(const Vector2 & p_position)1209 Vector2 KinematicBody2D::move_to(const Vector2 &p_position) {
1210
1211 return move(p_position - get_global_pos());
1212 }
1213
move_and_slide(const Vector2 & p_linear_velocity,const Vector2 & p_floor_direction,float p_slope_stop_min_velocity,int p_max_bounces,float p_floor_max_angle)1214 Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction, float p_slope_stop_min_velocity, int p_max_bounces, float p_floor_max_angle) {
1215
1216 Vector2 motion = (move_and_slide_floor_velocity + p_linear_velocity) * get_fixed_process_delta_time();
1217 Vector2 lv = p_linear_velocity;
1218
1219 move_and_slide_on_floor = false;
1220 move_and_slide_on_ceiling = false;
1221 move_and_slide_on_wall = false;
1222 move_and_slide_colliders.clear();
1223 move_and_slide_floor_velocity = Vector2();
1224
1225 while (p_max_bounces) {
1226
1227 motion = move(motion);
1228
1229 if (is_colliding()) {
1230
1231 if (p_floor_direction == Vector2()) {
1232 //all is a wall
1233 move_and_slide_on_wall = true;
1234 } else {
1235 if (get_collision_normal().dot(p_floor_direction) >= Math::cos(p_floor_max_angle)) { //floor
1236 move_and_slide_on_floor = true;
1237 move_and_slide_floor_velocity = get_collider_velocity();
1238
1239 if (get_travel().length() < 1 && ABS((lv.x - move_and_slide_floor_velocity.x)) < p_slope_stop_min_velocity) {
1240 revert_motion();
1241 return Vector2();
1242 }
1243 } else if (get_collision_normal().dot(-p_floor_direction) >= Math::cos(p_floor_max_angle)) { //ceiling
1244 move_and_slide_on_ceiling = true;
1245 } else {
1246 move_and_slide_on_wall = true;
1247 }
1248 }
1249
1250 motion = get_collision_normal().slide(motion);
1251 lv = get_collision_normal().slide(lv);
1252 Variant collider = _get_collider();
1253 if (collider.get_type() != Variant::NIL) {
1254 move_and_slide_colliders.push_back(collider);
1255 }
1256
1257 } else {
1258 break;
1259 }
1260
1261 p_max_bounces--;
1262 if (motion == Vector2())
1263 break;
1264 }
1265
1266 return lv;
1267 }
1268
is_move_and_slide_on_floor() const1269 bool KinematicBody2D::is_move_and_slide_on_floor() const {
1270
1271 return move_and_slide_on_floor;
1272 }
1273
is_move_and_slide_on_wall() const1274 bool KinematicBody2D::is_move_and_slide_on_wall() const {
1275
1276 return move_and_slide_on_wall;
1277 }
1278
is_move_and_slide_on_ceiling() const1279 bool KinematicBody2D::is_move_and_slide_on_ceiling() const {
1280
1281 return move_and_slide_on_ceiling;
1282 }
1283
get_move_and_slide_colliders() const1284 Array KinematicBody2D::get_move_and_slide_colliders() const {
1285
1286 return move_and_slide_colliders;
1287 }
1288
test_move(const Vector2 & p_motion)1289 bool KinematicBody2D::test_move(const Vector2 &p_motion) {
1290
1291 ERR_FAIL_COND_V(!is_inside_tree(), false);
1292
1293 if (motion_fix_enabled) {
1294 return Physics2DServer::get_singleton()->body_test_motion_from(get_rid(), get_global_transform(), p_motion, margin);
1295 } else {
1296 return Physics2DServer::get_singleton()->body_test_motion(get_rid(), p_motion, margin);
1297 }
1298 }
1299
test_move_from(const Matrix32 & p_from,const Vector2 & p_motion)1300 bool KinematicBody2D::test_move_from(const Matrix32 &p_from, const Vector2 &p_motion) {
1301
1302 ERR_FAIL_COND_V(!is_inside_tree(), false);
1303
1304 return Physics2DServer::get_singleton()->body_test_motion_from(get_rid(), p_from, p_motion, margin);
1305 }
1306
get_collision_pos() const1307 Vector2 KinematicBody2D::get_collision_pos() const {
1308
1309 ERR_FAIL_COND_V(!colliding, Vector2());
1310 return collision;
1311 }
1312
get_collision_normal() const1313 Vector2 KinematicBody2D::get_collision_normal() const {
1314
1315 ERR_FAIL_COND_V(!colliding, Vector2());
1316 return normal;
1317 }
1318
get_collider_velocity() const1319 Vector2 KinematicBody2D::get_collider_velocity() const {
1320
1321 return collider_vel;
1322 }
1323
get_collider() const1324 ObjectID KinematicBody2D::get_collider() const {
1325
1326 ERR_FAIL_COND_V(!colliding, 0);
1327 return collider;
1328 }
1329
get_collider_shape() const1330 int KinematicBody2D::get_collider_shape() const {
1331
1332 ERR_FAIL_COND_V(!colliding, 0);
1333 return collider_shape;
1334 }
1335
get_collider_metadata() const1336 Variant KinematicBody2D::get_collider_metadata() const {
1337
1338 ERR_FAIL_COND_V(!colliding, 0);
1339 return collider_metadata;
1340 }
1341
is_colliding() const1342 bool KinematicBody2D::is_colliding() const {
1343
1344 return colliding;
1345 }
1346
set_collision_margin(float p_margin)1347 void KinematicBody2D::set_collision_margin(float p_margin) {
1348
1349 margin = p_margin;
1350 }
1351
get_collision_margin() const1352 float KinematicBody2D::get_collision_margin() const {
1353
1354 return margin;
1355 }
1356
_bind_methods()1357 void KinematicBody2D::_bind_methods() {
1358
1359 ObjectTypeDB::bind_method(_MD("move", "rel_vec"), &KinematicBody2D::move);
1360 ObjectTypeDB::bind_method(_MD("move_to", "position"), &KinematicBody2D::move_to);
1361 ObjectTypeDB::bind_method(_MD("move_and_slide", "linear_velocity", "floor_normal", "slope_stop_min_velocity", "max_bounces", "floor_max_angle"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(5), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)));
1362
1363 ObjectTypeDB::bind_method(_MD("get_move_and_slide_colliders"), &KinematicBody2D::get_move_and_slide_colliders);
1364 ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_floor"), &KinematicBody2D::is_move_and_slide_on_floor);
1365 ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_ceiling"), &KinematicBody2D::is_move_and_slide_on_ceiling);
1366 ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_wall"), &KinematicBody2D::is_move_and_slide_on_wall);
1367
1368 ObjectTypeDB::bind_method(_MD("test_move", "rel_vec"), &KinematicBody2D::test_move);
1369 ObjectTypeDB::bind_method(_MD("test_move_from", "from", "rel_vec"), &KinematicBody2D::test_move_from);
1370 ObjectTypeDB::bind_method(_MD("get_travel"), &KinematicBody2D::get_travel);
1371 ObjectTypeDB::bind_method(_MD("revert_motion"), &KinematicBody2D::revert_motion);
1372
1373 ObjectTypeDB::bind_method(_MD("is_colliding"), &KinematicBody2D::is_colliding);
1374
1375 ObjectTypeDB::bind_method(_MD("get_collision_pos"), &KinematicBody2D::get_collision_pos);
1376 ObjectTypeDB::bind_method(_MD("get_collision_normal"), &KinematicBody2D::get_collision_normal);
1377 ObjectTypeDB::bind_method(_MD("get_collider_velocity"), &KinematicBody2D::get_collider_velocity);
1378 ObjectTypeDB::bind_method(_MD("get_collider:Variant"), &KinematicBody2D::_get_collider);
1379 ObjectTypeDB::bind_method(_MD("get_collider_shape"), &KinematicBody2D::get_collider_shape);
1380 ObjectTypeDB::bind_method(_MD("get_collider_metadata:Variant"), &KinematicBody2D::get_collider_metadata);
1381
1382 ObjectTypeDB::bind_method(_MD("set_collision_margin", "pixels"), &KinematicBody2D::set_collision_margin);
1383 ObjectTypeDB::bind_method(_MD("get_collision_margin", "pixels"), &KinematicBody2D::get_collision_margin);
1384
1385 ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision/margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), _SCS("set_collision_margin"), _SCS("get_collision_margin"));
1386 }
1387
KinematicBody2D()1388 KinematicBody2D::KinematicBody2D() :
1389 PhysicsBody2D(Physics2DServer::BODY_MODE_KINEMATIC) {
1390
1391 colliding = false;
1392 collider = 0;
1393
1394 collider_shape = 0;
1395
1396 margin = 0.08;
1397
1398 move_and_slide_on_floor = false;
1399 move_and_slide_on_ceiling = false;
1400 move_and_slide_on_wall = false;
1401 }
~KinematicBody2D()1402 KinematicBody2D::~KinematicBody2D() {
1403 }
1404