2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* physics_body_2d.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
2022-01-13 09:45:09 +01:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-05 00:50:27 +01:00
2014-02-10 02:10:30 +01:00
# include "physics_body_2d.h"
2017-08-19 01:02:56 +02:00
2017-10-24 18:10:30 +02:00
# include "core/core_string_names.h"
2018-09-11 18:13:45 +02:00
# include "core/engine.h"
2018-10-24 21:32:55 +02:00
# include "core/list.h"
2018-09-11 18:13:45 +02:00
# include "core/math/math_funcs.h"
2018-02-16 19:06:00 +01:00
# include "core/method_bind_ext.gen.inc"
2018-10-24 21:32:55 +02:00
# include "core/object.h"
# include "core/rid.h"
2014-02-10 02:10:30 +01:00
# include "scene/scene_string_names.h"
2018-08-23 21:49:24 +02:00
2018-08-29 17:03:48 +02:00
void PhysicsBody2D : : _notification ( int p_what ) {
2018-08-23 21:49:24 +02:00
}
2014-02-10 02:10:30 +01:00
2015-05-10 20:58:08 +02:00
void PhysicsBody2D : : _set_layers ( uint32_t p_mask ) {
2017-01-13 15:01:19 +01:00
set_collision_layer ( p_mask ) ;
2015-05-10 20:58:08 +02:00
set_collision_mask ( p_mask ) ;
}
2017-03-05 16:44:50 +01:00
uint32_t PhysicsBody2D : : _get_layers ( ) const {
2017-01-13 15:01:19 +01:00
return get_collision_layer ( ) ;
2015-05-10 20:58:08 +02:00
}
2014-05-14 06:22:15 +02:00
void PhysicsBody2D : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _set_layers " , " mask " ) , & PhysicsBody2D : : _set_layers ) ;
ClassDB : : bind_method ( D_METHOD ( " _get_layers " ) , & PhysicsBody2D : : _get_layers ) ;
2018-10-24 21:32:55 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_collision_exceptions " ) , & PhysicsBody2D : : get_collision_exceptions ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " add_collision_exception_with " , " body " ) , & PhysicsBody2D : : add_collision_exception_with ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_collision_exception_with " , " body " ) , & PhysicsBody2D : : remove_collision_exception_with ) ;
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " layers " , PROPERTY_HINT_LAYERS_2D_PHYSICS , " " , 0 ) , " _set_layers " , " _get_layers " ) ; //for backwards compat
2015-06-06 14:44:38 +02:00
}
2015-05-03 21:47:21 +02:00
2017-12-06 21:36:34 +01:00
PhysicsBody2D : : PhysicsBody2D ( Physics2DServer : : BodyMode p_mode ) :
2021-11-09 13:00:07 +01:00
CollisionObject2D ( RID_PRIME ( Physics2DServer : : get_singleton ( ) - > body_create ( ) ) , false ) {
2017-11-10 03:34:01 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , p_mode ) ;
2015-03-22 05:46:18 +01:00
set_pickable ( false ) ;
2014-02-10 02:10:30 +01:00
}
2018-10-24 21:32:55 +02:00
Array PhysicsBody2D : : get_collision_exceptions ( ) {
List < RID > exceptions ;
Physics2DServer : : get_singleton ( ) - > body_get_collision_exceptions ( get_rid ( ) , & exceptions ) ;
Array ret ;
for ( List < RID > : : Element * E = exceptions . front ( ) ; E ; E = E - > next ( ) ) {
RID body = E - > get ( ) ;
ObjectID instance_id = Physics2DServer : : get_singleton ( ) - > body_get_object_instance_id ( body ) ;
Object * obj = ObjectDB : : get_instance ( instance_id ) ;
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( obj ) ;
ret . append ( physics_body ) ;
}
return ret ;
}
2017-03-05 16:44:50 +01:00
void PhysicsBody2D : : add_collision_exception_with ( Node * p_node ) {
2014-09-22 05:50:48 +02:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 22:58:51 +02:00
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( p_node ) ;
2019-08-08 22:11:48 +02:00
ERR_FAIL_COND_MSG ( ! physics_body , " Collision exception only works between two objects of PhysicsBody type. " ) ;
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_add_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 05:50:48 +02:00
}
2017-03-05 16:44:50 +01:00
void PhysicsBody2D : : remove_collision_exception_with ( Node * p_node ) {
2014-09-22 05:50:48 +02:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 22:58:51 +02:00
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( p_node ) ;
2019-08-08 22:11:48 +02:00
ERR_FAIL_COND_MSG ( ! physics_body , " Collision exception only works between two objects of PhysicsBody type. " ) ;
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_remove_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 05:50:48 +02:00
}
2017-03-05 16:44:50 +01:00
void StaticBody2D : : set_constant_linear_velocity ( const Vector2 & p_vel ) {
constant_linear_velocity = p_vel ;
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_LINEAR_VELOCITY , constant_linear_velocity ) ;
2014-02-10 02:10:30 +01:00
}
void StaticBody2D : : set_constant_angular_velocity ( real_t p_vel ) {
2017-03-05 16:44:50 +01:00
constant_angular_velocity = p_vel ;
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_ANGULAR_VELOCITY , constant_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
}
Vector2 StaticBody2D : : get_constant_linear_velocity ( ) const {
return constant_linear_velocity ;
}
real_t StaticBody2D : : get_constant_angular_velocity ( ) const {
return constant_angular_velocity ;
}
2017-10-24 18:10:30 +02:00
# ifndef DISABLE_DEPRECATED
2017-03-05 16:44:50 +01:00
void StaticBody2D : : set_friction ( real_t p_friction ) {
2019-03-18 15:30:26 +01:00
if ( p_friction = = 1.0 & & physics_material_override . is_null ( ) ) { // default value, don't create an override for that
2018-09-02 15:05:40 +02:00
return ;
}
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method set_friction has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( p_friction < 0 | | p_friction > 1 , " Friction must be between 0 and 1. " ) ;
2014-02-10 02:10:30 +01:00
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
physics_material_override . instance ( ) ;
2018-07-23 16:37:07 +02:00
set_physics_material_override ( physics_material_override ) ;
2017-10-24 18:10:30 +02:00
}
physics_material_override - > set_friction ( p_friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-24 18:10:30 +02:00
2017-03-05 16:44:50 +01:00
real_t StaticBody2D : : get_friction ( ) const {
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method get_friction has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
return 1 ;
}
return physics_material_override - > get_friction ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void StaticBody2D : : set_bounce ( real_t p_bounce ) {
2019-03-18 15:30:26 +01:00
if ( p_bounce = = 0.0 & & physics_material_override . is_null ( ) ) { // default value, don't create an override for that
2018-09-02 15:05:40 +02:00
return ;
}
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method set_bounce has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( p_bounce < 0 | | p_bounce > 1 , " Bounce must be between 0 and 1. " ) ;
2014-02-10 02:10:30 +01:00
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
physics_material_override . instance ( ) ;
2018-07-23 16:37:07 +02:00
set_physics_material_override ( physics_material_override ) ;
2017-10-24 18:10:30 +02:00
}
physics_material_override - > set_bounce ( p_bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-24 18:10:30 +02:00
2017-03-05 16:44:50 +01:00
real_t StaticBody2D : : get_bounce ( ) const {
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method get_bounce has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
return 0 ;
}
return physics_material_override - > get_bounce ( ) ;
}
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2017-10-24 18:10:30 +02:00
void StaticBody2D : : set_physics_material_override ( const Ref < PhysicsMaterial > & p_physics_material_override ) {
if ( physics_material_override . is_valid ( ) ) {
2021-05-05 12:44:11 +02:00
if ( physics_material_override - > is_connected ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ) {
2018-07-23 16:37:07 +02:00
physics_material_override - > disconnect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ;
2021-05-05 12:44:11 +02:00
}
2017-10-24 18:10:30 +02:00
}
physics_material_override = p_physics_material_override ;
if ( physics_material_override . is_valid ( ) ) {
physics_material_override - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ;
}
_reload_physics_characteristics ( ) ;
}
Ref < PhysicsMaterial > StaticBody2D : : get_physics_material_override ( ) const {
return physics_material_override ;
2014-02-10 02:10:30 +01:00
}
void StaticBody2D : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_constant_linear_velocity " , " vel " ) , & StaticBody2D : : set_constant_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " set_constant_angular_velocity " , " vel " ) , & StaticBody2D : : set_constant_angular_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_constant_linear_velocity " ) , & StaticBody2D : : get_constant_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_constant_angular_velocity " ) , & StaticBody2D : : get_constant_angular_velocity ) ;
2018-07-27 15:34:58 +02:00
# ifndef DISABLE_DEPRECATED
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_friction " , " friction " ) , & StaticBody2D : : set_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " get_friction " ) , & StaticBody2D : : get_friction ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_bounce " , " bounce " ) , & StaticBody2D : : set_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " get_bounce " ) , & StaticBody2D : : get_bounce ) ;
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2014-02-10 02:10:30 +01:00
2017-10-24 18:10:30 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_physics_material_override " , " physics_material_override " ) , & StaticBody2D : : set_physics_material_override ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_material_override " ) , & StaticBody2D : : get_physics_material_override ) ;
ClassDB : : bind_method ( D_METHOD ( " _reload_physics_characteristics " ) , & StaticBody2D : : _reload_physics_characteristics ) ;
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " constant_linear_velocity " ) , " set_constant_linear_velocity " , " get_constant_linear_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " constant_angular_velocity " ) , " set_constant_angular_velocity " , " get_constant_angular_velocity " ) ;
2018-07-27 15:34:58 +02:00
# ifndef DISABLE_DEPRECATED
2018-11-08 15:30:02 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " , 0 ) , " set_friction " , " get_friction " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " , 0 ) , " set_bounce " , " get_bounce " ) ;
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2018-11-08 15:30:02 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " physics_material_override " , PROPERTY_HINT_RESOURCE_TYPE , " PhysicsMaterial " ) , " set_physics_material_override " , " get_physics_material_override " ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-06 21:36:34 +01:00
StaticBody2D : : StaticBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_STATIC ) {
2017-03-05 16:44:50 +01:00
constant_angular_velocity = 0 ;
2014-02-10 02:10:30 +01:00
}
StaticBody2D : : ~ StaticBody2D ( ) {
}
2017-10-24 18:10:30 +02:00
void StaticBody2D : : _reload_physics_characteristics ( ) {
if ( physics_material_override . is_null ( ) ) {
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , 0 ) ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , 1 ) ;
} else {
2018-07-23 16:37:07 +02:00
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , physics_material_override - > computed_bounce ( ) ) ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , physics_material_override - > computed_friction ( ) ) ;
2017-10-24 18:10:30 +02:00
}
}
2014-11-06 01:20:42 +01:00
void RigidBody2D : : _body_enter_tree ( ObjectID p_id ) {
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! E ) ;
ERR_FAIL_COND ( E - > get ( ) . in_scene ) ;
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_scene = true ;
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2020-10-12 16:37:36 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_entered , E - > get ( ) . rid , node , E - > get ( ) . shapes [ i ] . body_shape , E - > get ( ) . shapes [ i ] . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2014-11-06 01:20:42 +01:00
void RigidBody2D : : _body_exit_tree ( ObjectID p_id ) {
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! E ) ;
ERR_FAIL_COND ( ! E - > get ( ) . in_scene ) ;
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_scene = false ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , node ) ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2020-10-12 16:37:36 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_exited , E - > get ( ) . rid , node , E - > get ( ) . shapes [ i ] . body_shape , E - > get ( ) . shapes [ i ] . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2020-10-12 16:37:36 +02:00
void RigidBody2D : : _body_inout ( int p_status , const RID & p_body , ObjectID p_instance , int p_body_shape , int p_local_shape ) {
2017-03-05 16:44:50 +01:00
bool body_in = p_status = = 1 ;
ObjectID objid = p_instance ;
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( objid ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( objid ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! body_in & & ! E ) ;
if ( body_in ) {
if ( ! E ) {
2017-03-05 16:44:50 +01:00
E = contact_monitor - > body_map . insert ( objid , BodyState ( ) ) ;
2020-10-12 16:37:36 +02:00
E - > get ( ) . rid = p_body ;
2017-01-14 12:26:56 +01:00
//E->get().rc=0;
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_scene = node & & node - > is_inside_tree ( ) ;
2014-02-10 02:10:30 +01:00
if ( node ) {
2017-03-05 16:44:50 +01:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree , make_binds ( objid ) ) ;
2018-01-12 12:28:39 +01:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree , make_binds ( objid ) ) ;
2014-02-10 02:10:30 +01:00
if ( E - > get ( ) . in_scene ) {
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2014-02-10 02:10:30 +01:00
}
}
2014-10-03 13:58:41 +02:00
//E->get().rc++;
2014-02-10 02:10:30 +01:00
}
2014-10-03 13:58:41 +02:00
2021-05-05 12:44:11 +02:00
if ( node ) {
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes . insert ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
if ( E - > get ( ) . in_scene ) {
2020-10-12 16:37:36 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_entered , p_body , node , p_body_shape , p_local_shape ) ;
2014-02-10 02:10:30 +01:00
}
} else {
2014-10-03 13:58:41 +02:00
//E->get().rc--;
2014-02-10 02:10:30 +01:00
2021-05-05 12:44:11 +02:00
if ( node ) {
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes . erase ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
2014-10-03 13:58:41 +02:00
bool in_scene = E - > get ( ) . in_scene ;
if ( E - > get ( ) . shapes . empty ( ) ) {
2014-02-10 02:10:30 +01:00
if ( node ) {
2017-03-05 16:44:50 +01:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree ) ;
2018-01-12 12:28:39 +01:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree ) ;
2021-05-05 12:44:11 +02:00
if ( in_scene ) {
2018-09-01 12:05:51 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , node ) ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
}
contact_monitor - > body_map . erase ( E ) ;
}
2014-10-03 13:58:41 +02:00
if ( node & & in_scene ) {
2020-10-12 16:37:36 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_exited , p_body , node , p_body_shape , p_local_shape ) ;
2014-02-10 02:10:30 +01:00
}
}
}
struct _RigidBody2DInOut {
2020-10-12 16:37:36 +02:00
RID rid ;
2014-02-10 02:10:30 +01:00
ObjectID id ;
int shape ;
int local_shape ;
} ;
2018-02-16 19:06:00 +01:00
bool RigidBody2D : : _test_motion ( const Vector2 & p_motion , bool p_infinite_inertia , float p_margin , const Ref < Physics2DTestMotionResult > & p_result ) {
2021-05-04 16:00:45 +02:00
Physics2DServer : : MotionResult * r = nullptr ;
2021-11-10 01:03:25 +01:00
Physics2DServer : : MotionResult temp_result ;
2021-05-05 12:44:11 +02:00
if ( p_result . is_valid ( ) ) {
2017-03-05 16:44:50 +01:00
r = p_result - > get_result_ptr ( ) ;
2021-11-10 01:03:25 +01:00
} else {
r = & temp_result ;
}
bool colliding = Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , get_global_transform ( ) , p_motion , p_infinite_inertia , p_margin , r ) ;
if ( colliding ) {
// Don't report collision when the whole motion is done.
return ( r - > collision_safe_fraction < 1.0 ) ;
} else {
return false ;
2021-05-05 12:44:11 +02:00
}
2015-04-20 01:50:55 +02:00
}
2014-02-10 02:10:30 +01:00
void RigidBody2D : : _direct_state_changed ( Object * p_state ) {
2017-08-24 22:58:51 +02:00
state = Object : : cast_to < Physics2DDirectBodyState > ( p_state ) ;
2021-03-30 08:36:30 +02:00
ERR_FAIL_COND_MSG ( ! state , " Method '_direct_state_changed' must receive a valid Physics2DDirectBodyState object as argument " ) ;
2014-02-10 02:10:30 +01:00
2016-06-17 21:45:10 +02:00
set_block_transform_notify ( true ) ; // don't want notify (would feedback loop)
2021-05-05 12:44:11 +02:00
if ( mode ! = MODE_KINEMATIC ) {
2018-08-23 21:49:24 +02:00
set_global_transform ( state - > get_transform ( ) ) ;
2021-05-05 12:44:11 +02:00
}
2017-03-05 16:44:50 +01:00
linear_velocity = state - > get_linear_velocity ( ) ;
angular_velocity = state - > get_angular_velocity ( ) ;
if ( sleeping ! = state - > is_sleeping ( ) ) {
sleeping = state - > is_sleeping ( ) ;
2016-06-17 21:45:10 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > sleeping_state_changed ) ;
}
2021-05-05 12:44:11 +02:00
if ( get_script_instance ( ) ) {
2017-03-05 16:44:50 +01:00
get_script_instance ( ) - > call ( " _integrate_forces " , state ) ;
2021-05-05 12:44:11 +02:00
}
2016-06-17 21:45:10 +02:00
set_block_transform_notify ( false ) ; // want it back
2014-02-10 02:10:30 +01:00
if ( contact_monitor ) {
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2014-02-10 02:10:30 +01:00
//untag all
2017-03-05 16:44:50 +01:00
int rc = 0 ;
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
E - > get ( ) . shapes [ i ] . tagged = false ;
2014-02-10 02:10:30 +01:00
rc + + ;
}
}
2017-03-05 16:44:50 +01:00
_RigidBody2DInOut * toadd = ( _RigidBody2DInOut * ) alloca ( state - > get_contact_count ( ) * sizeof ( _RigidBody2DInOut ) ) ;
int toadd_count = 0 ; //state->get_contact_count();
RigidBody2D_RemoveAction * toremove = ( RigidBody2D_RemoveAction * ) alloca ( rc * sizeof ( RigidBody2D_RemoveAction ) ) ;
int toremove_count = 0 ;
2014-02-10 02:10:30 +01:00
//put the ones to add
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < state - > get_contact_count ( ) ; i + + ) {
2020-10-12 16:37:36 +02:00
RID rid = state - > get_contact_collider ( i ) ;
2014-02-10 02:10:30 +01:00
ObjectID obj = state - > get_contact_collider_id ( i ) ;
int local_shape = state - > get_contact_local_shape ( i ) ;
int shape = state - > get_contact_collider_shape ( i ) ;
2017-01-14 12:26:56 +01:00
//bool found=false;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( obj ) ;
2014-02-10 02:10:30 +01:00
if ( ! E ) {
2020-10-12 16:37:36 +02:00
toadd [ toadd_count ] . rid = rid ;
2017-03-05 16:44:50 +01:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 02:10:30 +01:00
toadd_count + + ;
continue ;
}
2017-03-05 16:44:50 +01:00
ShapePair sp ( shape , local_shape ) ;
2014-02-10 02:10:30 +01:00
int idx = E - > get ( ) . shapes . find ( sp ) ;
2017-03-05 16:44:50 +01:00
if ( idx = = - 1 ) {
2020-10-12 16:37:36 +02:00
toadd [ toadd_count ] . rid = rid ;
2017-03-05 16:44:50 +01:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 02:10:30 +01:00
toadd_count + + ;
continue ;
}
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes [ idx ] . tagged = true ;
2014-02-10 02:10:30 +01:00
}
//put the ones to remove
2017-03-05 16:44:50 +01:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
if ( ! E - > get ( ) . shapes [ i ] . tagged ) {
2020-10-12 16:37:36 +02:00
toremove [ toremove_count ] . rid = E - > get ( ) . rid ;
2017-03-05 16:44:50 +01:00
toremove [ toremove_count ] . body_id = E - > key ( ) ;
toremove [ toremove_count ] . pair = E - > get ( ) . shapes [ i ] ;
2014-02-10 02:10:30 +01:00
toremove_count + + ;
}
}
}
//process remotions
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < toremove_count ; i + + ) {
2020-10-12 16:37:36 +02:00
_body_inout ( 0 , toremove [ i ] . rid , toremove [ i ] . body_id , toremove [ i ] . pair . body_shape , toremove [ i ] . pair . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
//process aditions
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < toadd_count ; i + + ) {
2020-10-12 16:37:36 +02:00
_body_inout ( 1 , toadd [ i ] . rid , toadd [ i ] . id , toadd [ i ] . shape , toadd [ i ] . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2021-05-04 16:00:45 +02:00
state = nullptr ;
2014-02-10 02:10:30 +01:00
}
void RigidBody2D : : set_mode ( Mode p_mode ) {
2017-03-05 16:44:50 +01:00
mode = p_mode ;
switch ( p_mode ) {
2014-02-10 02:10:30 +01:00
case MODE_RIGID : {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , Physics2DServer : : BODY_MODE_RIGID ) ;
2014-02-10 02:10:30 +01:00
} break ;
case MODE_STATIC : {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , Physics2DServer : : BODY_MODE_STATIC ) ;
2014-02-10 02:10:30 +01:00
} break ;
2014-02-19 15:57:14 +01:00
case MODE_KINEMATIC : {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , Physics2DServer : : BODY_MODE_KINEMATIC ) ;
2014-02-10 02:10:30 +01:00
} break ;
case MODE_CHARACTER : {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , Physics2DServer : : BODY_MODE_CHARACTER ) ;
2014-02-10 02:10:30 +01:00
} break ;
}
}
2017-03-05 16:44:50 +01:00
RigidBody2D : : Mode RigidBody2D : : get_mode ( ) const {
2014-02-10 02:10:30 +01:00
return mode ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_mass ( real_t p_mass ) {
ERR_FAIL_COND ( p_mass < = 0 ) ;
mass = p_mass ;
2014-02-10 02:10:30 +01:00
_change_notify ( " mass " ) ;
_change_notify ( " weight " ) ;
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_MASS , mass ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_mass ( ) const {
2014-02-10 02:10:30 +01:00
return mass ;
}
2016-04-26 14:15:15 +02:00
void RigidBody2D : : set_inertia ( real_t p_inertia ) {
2019-08-15 13:34:47 +02:00
ERR_FAIL_COND ( p_inertia < 0 ) ;
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_INERTIA , p_inertia ) ;
2016-04-26 14:15:15 +02:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_inertia ( ) const {
return Physics2DServer : : get_singleton ( ) - > body_get_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_INERTIA ) ;
2016-04-21 02:49:37 +02:00
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_weight ( real_t p_weight ) {
2018-08-29 08:37:08 +02:00
set_mass ( p_weight / ( real_t ( GLOBAL_DEF ( " physics/2d/default_gravity " , 98 ) ) / 10 ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-07-04 14:57:15 +02:00
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_weight ( ) const {
2018-08-29 08:37:08 +02:00
return mass * ( real_t ( GLOBAL_DEF ( " physics/2d/default_gravity " , 98 ) ) / 10 ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-24 18:10:30 +02:00
# ifndef DISABLE_DEPRECATED
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_friction ( real_t p_friction ) {
2019-03-18 15:30:26 +01:00
if ( p_friction = = 1.0 & & physics_material_override . is_null ( ) ) { // default value, don't create an override for that
2018-09-02 15:05:40 +02:00
return ;
}
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method set_friction has been deprecated and will be removed in the future, use physics material instead. " ) ;
2018-09-02 15:05:40 +02:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( p_friction < 0 | | p_friction > 1 , " Friction must be between 0 and 1. " ) ;
2014-02-10 02:10:30 +01:00
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
physics_material_override . instance ( ) ;
2018-07-23 16:37:07 +02:00
set_physics_material_override ( physics_material_override ) ;
2017-10-24 18:10:30 +02:00
}
physics_material_override - > set_friction ( p_friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_friction ( ) const {
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method get_friction has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
return 1 ;
}
return physics_material_override - > get_friction ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_bounce ( real_t p_bounce ) {
2019-03-18 15:30:26 +01:00
if ( p_bounce = = 0.0 & & physics_material_override . is_null ( ) ) { // default value, don't create an override for that
2018-09-02 15:05:40 +02:00
return ;
}
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method set_bounce has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
physics_material_override . instance ( ) ;
2018-07-23 16:37:07 +02:00
set_physics_material_override ( physics_material_override ) ;
2017-10-24 18:10:30 +02:00
}
physics_material_override - > set_bounce ( p_bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_bounce ( ) const {
2019-08-08 22:11:48 +02:00
WARN_DEPRECATED_MSG ( " The method get_bounce has been deprecated and will be removed in the future, use physics material instead. " ) ;
2017-10-24 18:10:30 +02:00
if ( physics_material_override . is_null ( ) ) {
return 0 ;
}
return physics_material_override - > get_bounce ( ) ;
}
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2017-10-24 18:10:30 +02:00
void RigidBody2D : : set_physics_material_override ( const Ref < PhysicsMaterial > & p_physics_material_override ) {
if ( physics_material_override . is_valid ( ) ) {
2021-05-05 12:44:11 +02:00
if ( physics_material_override - > is_connected ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ) {
2018-07-23 16:37:07 +02:00
physics_material_override - > disconnect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ;
2021-05-05 12:44:11 +02:00
}
2017-10-24 18:10:30 +02:00
}
physics_material_override = p_physics_material_override ;
if ( physics_material_override . is_valid ( ) ) {
physics_material_override - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _reload_physics_characteristics " ) ;
}
_reload_physics_characteristics ( ) ;
}
Ref < PhysicsMaterial > RigidBody2D : : get_physics_material_override ( ) const {
return physics_material_override ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_gravity_scale ( real_t p_gravity_scale ) {
gravity_scale = p_gravity_scale ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_GRAVITY_SCALE , gravity_scale ) ;
2015-01-05 22:37:12 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_gravity_scale ( ) const {
2015-01-05 22:37:12 +01:00
return gravity_scale ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_linear_damp ( real_t p_linear_damp ) {
ERR_FAIL_COND ( p_linear_damp < - 1 ) ;
linear_damp = p_linear_damp ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_LINEAR_DAMP , linear_damp ) ;
2015-01-05 22:37:12 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_linear_damp ( ) const {
2015-01-05 22:37:12 +01:00
return linear_damp ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_angular_damp ( real_t p_angular_damp ) {
ERR_FAIL_COND ( p_angular_damp < - 1 ) ;
angular_damp = p_angular_damp ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_ANGULAR_DAMP , angular_damp ) ;
2015-01-05 22:37:12 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_angular_damp ( ) const {
2015-01-05 22:37:12 +01:00
return angular_damp ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_axis_velocity ( const Vector2 & p_axis ) {
Vector2 v = state ? state - > get_linear_velocity ( ) : linear_velocity ;
2014-02-10 02:10:30 +01:00
Vector2 axis = p_axis . normalized ( ) ;
2017-03-05 16:44:50 +01:00
v - = axis * axis . dot ( v ) ;
v + = p_axis ;
2014-02-10 02:10:30 +01:00
if ( state ) {
set_linear_velocity ( v ) ;
} else {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_axis_velocity ( get_rid ( ) , p_axis ) ;
linear_velocity = v ;
2014-02-10 02:10:30 +01:00
}
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_linear_velocity ( const Vector2 & p_velocity ) {
linear_velocity = p_velocity ;
2021-05-05 12:44:11 +02:00
if ( state ) {
2014-02-10 02:10:30 +01:00
state - > set_linear_velocity ( linear_velocity ) ;
2021-05-05 12:44:11 +02:00
} else {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_LINEAR_VELOCITY , linear_velocity ) ;
2014-02-10 02:10:30 +01:00
}
}
2017-03-05 16:44:50 +01:00
Vector2 RigidBody2D : : get_linear_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return linear_velocity ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_angular_velocity ( real_t p_velocity ) {
angular_velocity = p_velocity ;
2021-05-05 12:44:11 +02:00
if ( state ) {
2014-02-10 02:10:30 +01:00
state - > set_angular_velocity ( angular_velocity ) ;
2021-05-05 12:44:11 +02:00
} else {
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_ANGULAR_VELOCITY , angular_velocity ) ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody2D : : get_angular_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return angular_velocity ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_use_custom_integrator ( bool p_enable ) {
2021-05-05 12:44:11 +02:00
if ( custom_integrator = = p_enable ) {
2014-02-10 02:10:30 +01:00
return ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
custom_integrator = p_enable ;
Physics2DServer : : get_singleton ( ) - > body_set_omit_force_integration ( get_rid ( ) , p_enable ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
bool RigidBody2D : : is_using_custom_integrator ( ) {
2014-02-10 02:10:30 +01:00
return custom_integrator ;
}
2014-09-22 05:50:48 +02:00
void RigidBody2D : : set_sleeping ( bool p_sleeping ) {
2017-03-05 16:44:50 +01:00
sleeping = p_sleeping ;
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_SLEEPING , sleeping ) ;
2014-02-10 02:10:30 +01:00
}
void RigidBody2D : : set_can_sleep ( bool p_active ) {
2017-03-05 16:44:50 +01:00
can_sleep = p_active ;
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_CAN_SLEEP , p_active ) ;
2014-02-10 02:10:30 +01:00
}
bool RigidBody2D : : is_able_to_sleep ( ) const {
return can_sleep ;
}
2014-09-22 05:50:48 +02:00
bool RigidBody2D : : is_sleeping ( ) const {
return sleeping ;
2014-02-10 02:10:30 +01:00
}
void RigidBody2D : : set_max_contacts_reported ( int p_amount ) {
2017-03-05 16:44:50 +01:00
max_contacts_reported = p_amount ;
Physics2DServer : : get_singleton ( ) - > body_set_max_contacts_reported ( get_rid ( ) , p_amount ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
int RigidBody2D : : get_max_contacts_reported ( ) const {
2014-02-10 02:10:30 +01:00
return max_contacts_reported ;
}
2018-07-24 09:49:12 +02:00
void RigidBody2D : : apply_central_impulse ( const Vector2 & p_impulse ) {
Physics2DServer : : get_singleton ( ) - > body_apply_central_impulse ( get_rid ( ) , p_impulse ) ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : apply_impulse ( const Vector2 & p_offset , const Vector2 & p_impulse ) {
Physics2DServer : : get_singleton ( ) - > body_apply_impulse ( get_rid ( ) , p_offset , p_impulse ) ;
2014-02-10 02:10:30 +01:00
}
2018-07-24 09:49:12 +02:00
void RigidBody2D : : apply_torque_impulse ( float p_torque ) {
Physics2DServer : : get_singleton ( ) - > body_apply_torque_impulse ( get_rid ( ) , p_torque ) ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : set_applied_force ( const Vector2 & p_force ) {
2014-02-10 02:10:30 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_applied_force ( get_rid ( ) , p_force ) ;
} ;
Vector2 RigidBody2D : : get_applied_force ( ) const {
return Physics2DServer : : get_singleton ( ) - > body_get_applied_force ( get_rid ( ) ) ;
} ;
2016-04-21 01:49:35 +02:00
void RigidBody2D : : set_applied_torque ( const float p_torque ) {
Physics2DServer : : get_singleton ( ) - > body_set_applied_torque ( get_rid ( ) , p_torque ) ;
} ;
float RigidBody2D : : get_applied_torque ( ) const {
return Physics2DServer : : get_singleton ( ) - > body_get_applied_torque ( get_rid ( ) ) ;
} ;
2018-07-24 09:49:12 +02:00
void RigidBody2D : : add_central_force ( const Vector2 & p_force ) {
Physics2DServer : : get_singleton ( ) - > body_add_central_force ( get_rid ( ) , p_force ) ;
}
2017-03-05 16:44:50 +01:00
void RigidBody2D : : add_force ( const Vector2 & p_offset , const Vector2 & p_force ) {
Physics2DServer : : get_singleton ( ) - > body_add_force ( get_rid ( ) , p_offset , p_force ) ;
2016-04-26 14:15:15 +02:00
}
2014-02-10 02:10:30 +01:00
2018-07-24 09:49:12 +02:00
void RigidBody2D : : add_torque ( const float p_torque ) {
Physics2DServer : : get_singleton ( ) - > body_add_torque ( get_rid ( ) , p_torque ) ;
}
2014-02-19 15:57:14 +01:00
void RigidBody2D : : set_continuous_collision_detection_mode ( CCDMode p_mode ) {
2017-03-05 16:44:50 +01:00
ccd_mode = p_mode ;
Physics2DServer : : get_singleton ( ) - > body_set_continuous_collision_detection_mode ( get_rid ( ) , Physics2DServer : : CCDMode ( p_mode ) ) ;
2014-02-19 15:57:14 +01:00
}
2014-02-10 02:10:30 +01:00
2014-02-19 15:57:14 +01:00
RigidBody2D : : CCDMode RigidBody2D : : get_continuous_collision_detection_mode ( ) const {
return ccd_mode ;
2014-02-10 02:10:30 +01:00
}
2014-11-13 04:53:12 +01:00
Array RigidBody2D : : get_colliding_bodies ( ) const {
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V ( ! contact_monitor , Array ( ) ) ;
2014-11-13 04:53:12 +01:00
Array ret ;
ret . resize ( contact_monitor - > body_map . size ( ) ) ;
2017-03-05 16:44:50 +01:00
int idx = 0 ;
for ( const Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-11-13 04:53:12 +01:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
if ( ! obj ) {
2017-03-05 16:44:50 +01:00
ret . resize ( ret . size ( ) - 1 ) ; //ops
2014-11-13 04:53:12 +01:00
} else {
2017-03-05 16:44:50 +01:00
ret [ idx + + ] = obj ;
2014-11-13 04:53:12 +01:00
}
}
return ret ;
}
2014-02-10 02:10:30 +01:00
void RigidBody2D : : set_contact_monitor ( bool p_enabled ) {
2021-05-05 12:44:11 +02:00
if ( p_enabled = = is_contact_monitor_enabled ( ) ) {
2014-02-10 02:10:30 +01:00
return ;
2021-05-05 12:44:11 +02:00
}
2014-02-10 02:10:30 +01:00
if ( ! p_enabled ) {
2019-08-08 22:11:48 +02:00
ERR_FAIL_COND_MSG ( contact_monitor - > locked , " Can't disable contact monitoring during in/out callback. Use call_deferred( \" set_contact_monitor \" , false) instead. " ) ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
//clean up mess
2018-01-21 12:46:13 +01:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
Node * node = Object : : cast_to < Node > ( obj ) ;
if ( node ) {
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree ) ;
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree ) ;
}
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
memdelete ( contact_monitor ) ;
2021-05-04 16:00:45 +02:00
contact_monitor = nullptr ;
2014-02-10 02:10:30 +01:00
} else {
2017-03-05 16:44:50 +01:00
contact_monitor = memnew ( ContactMonitor ) ;
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
}
bool RigidBody2D : : is_contact_monitor_enabled ( ) const {
2021-05-04 16:00:45 +02:00
return contact_monitor ! = nullptr ;
2014-02-10 02:10:30 +01:00
}
2017-08-05 21:06:15 +02:00
void RigidBody2D : : _notification ( int p_what ) {
# ifdef TOOLS_ENABLED
if ( p_what = = NOTIFICATION_ENTER_TREE ) {
2017-08-19 01:02:56 +02:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 21:06:15 +02:00
set_notify_local_transform ( true ) ; //used for warnings and only in editor
}
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
2017-08-19 01:02:56 +02:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 21:06:15 +02:00
update_configuration_warning ( ) ;
}
}
# endif
}
String RigidBody2D : : get_configuration_warning ( ) const {
Transform2D t = get_transform ( ) ;
String warning = CollisionObject2D : : get_configuration_warning ( ) ;
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 ) ) {
if ( warning ! = String ( ) ) {
2019-07-09 00:17:04 +02:00
warning + = " \n \n " ;
2017-08-05 21:06:15 +02:00
}
2018-01-18 21:37:17 +01:00
warning + = TTR ( " Size changes to RigidBody2D (in character or rigid modes) will be overridden by the physics engine when running. \n Change the size in children collision shapes instead. " ) ;
2017-08-05 21:06:15 +02:00
}
return warning ;
}
2014-02-10 02:10:30 +01:00
void RigidBody2D : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_mode " , " mode " ) , & RigidBody2D : : set_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " get_mode " ) , & RigidBody2D : : get_mode ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_mass " , " mass " ) , & RigidBody2D : : set_mass ) ;
ClassDB : : bind_method ( D_METHOD ( " get_mass " ) , & RigidBody2D : : get_mass ) ;
2016-04-21 02:49:37 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_inertia " ) , & RigidBody2D : : get_inertia ) ;
ClassDB : : bind_method ( D_METHOD ( " set_inertia " , " inertia " ) , & RigidBody2D : : set_inertia ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_weight " , " weight " ) , & RigidBody2D : : set_weight ) ;
ClassDB : : bind_method ( D_METHOD ( " get_weight " ) , & RigidBody2D : : get_weight ) ;
2014-02-10 02:10:30 +01:00
2018-07-27 15:34:58 +02:00
# ifndef DISABLE_DEPRECATED
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_friction " , " friction " ) , & RigidBody2D : : set_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " get_friction " ) , & RigidBody2D : : get_friction ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_bounce " , " bounce " ) , & RigidBody2D : : set_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " get_bounce " ) , & RigidBody2D : : get_bounce ) ;
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2015-01-05 22:37:12 +01:00
2017-10-24 18:10:30 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_physics_material_override " , " physics_material_override " ) , & RigidBody2D : : set_physics_material_override ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_material_override " ) , & RigidBody2D : : get_physics_material_override ) ;
ClassDB : : bind_method ( D_METHOD ( " _reload_physics_characteristics " ) , & RigidBody2D : : _reload_physics_characteristics ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_gravity_scale " , " gravity_scale " ) , & RigidBody2D : : set_gravity_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_gravity_scale " ) , & RigidBody2D : : get_gravity_scale ) ;
2015-01-05 22:37:12 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_linear_damp " , " linear_damp " ) , & RigidBody2D : : set_linear_damp ) ;
ClassDB : : bind_method ( D_METHOD ( " get_linear_damp " ) , & RigidBody2D : : get_linear_damp ) ;
2015-01-05 22:37:12 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_angular_damp " , " angular_damp " ) , & RigidBody2D : : set_angular_damp ) ;
ClassDB : : bind_method ( D_METHOD ( " get_angular_damp " ) , & RigidBody2D : : get_angular_damp ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_linear_velocity " , " linear_velocity " ) , & RigidBody2D : : set_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_linear_velocity " ) , & RigidBody2D : : get_linear_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_angular_velocity " , " angular_velocity " ) , & RigidBody2D : : set_angular_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_angular_velocity " ) , & RigidBody2D : : get_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_max_contacts_reported " , " amount " ) , & RigidBody2D : : set_max_contacts_reported ) ;
ClassDB : : bind_method ( D_METHOD ( " get_max_contacts_reported " ) , & RigidBody2D : : get_max_contacts_reported ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_use_custom_integrator " , " enable " ) , & RigidBody2D : : set_use_custom_integrator ) ;
ClassDB : : bind_method ( D_METHOD ( " is_using_custom_integrator " ) , & RigidBody2D : : is_using_custom_integrator ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_contact_monitor " , " enabled " ) , & RigidBody2D : : set_contact_monitor ) ;
ClassDB : : bind_method ( D_METHOD ( " is_contact_monitor_enabled " ) , & RigidBody2D : : is_contact_monitor_enabled ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_continuous_collision_detection_mode " , " mode " ) , & RigidBody2D : : set_continuous_collision_detection_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " get_continuous_collision_detection_mode " ) , & RigidBody2D : : get_continuous_collision_detection_mode ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_axis_velocity " , " axis_velocity " ) , & RigidBody2D : : set_axis_velocity ) ;
2018-07-24 09:49:12 +02:00
ClassDB : : bind_method ( D_METHOD ( " apply_central_impulse " , " impulse " ) , & RigidBody2D : : apply_central_impulse ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " apply_impulse " , " offset " , " impulse " ) , & RigidBody2D : : apply_impulse ) ;
2018-07-24 09:49:12 +02:00
ClassDB : : bind_method ( D_METHOD ( " apply_torque_impulse " , " torque " ) , & RigidBody2D : : apply_torque_impulse ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_applied_force " , " force " ) , & RigidBody2D : : set_applied_force ) ;
ClassDB : : bind_method ( D_METHOD ( " get_applied_force " ) , & RigidBody2D : : get_applied_force ) ;
2016-04-21 01:49:35 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_applied_torque " , " torque " ) , & RigidBody2D : : set_applied_torque ) ;
ClassDB : : bind_method ( D_METHOD ( " get_applied_torque " ) , & RigidBody2D : : get_applied_torque ) ;
2016-04-26 14:15:15 +02:00
2018-07-24 09:49:12 +02:00
ClassDB : : bind_method ( D_METHOD ( " add_central_force " , " force " ) , & RigidBody2D : : add_central_force ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " add_force " , " offset " , " force " ) , & RigidBody2D : : add_force ) ;
2018-07-24 09:49:12 +02:00
ClassDB : : bind_method ( D_METHOD ( " add_torque " , " torque " ) , & RigidBody2D : : add_torque ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_sleeping " , " sleeping " ) , & RigidBody2D : : set_sleeping ) ;
ClassDB : : bind_method ( D_METHOD ( " is_sleeping " ) , & RigidBody2D : : is_sleeping ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_can_sleep " , " able_to_sleep " ) , & RigidBody2D : : set_can_sleep ) ;
ClassDB : : bind_method ( D_METHOD ( " is_able_to_sleep " ) , & RigidBody2D : : is_able_to_sleep ) ;
2015-04-20 01:50:55 +02:00
2018-02-21 08:42:36 +01:00
ClassDB : : bind_method ( D_METHOD ( " test_motion " , " motion " , " infinite_inertia " , " margin " , " result " ) , & RigidBody2D : : _test_motion , DEFVAL ( true ) , DEFVAL ( 0.08 ) , DEFVAL ( Variant ( ) ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _direct_state_changed " ) , & RigidBody2D : : _direct_state_changed ) ;
ClassDB : : bind_method ( D_METHOD ( " _body_enter_tree " ) , & RigidBody2D : : _body_enter_tree ) ;
ClassDB : : bind_method ( D_METHOD ( " _body_exit_tree " ) , & RigidBody2D : : _body_exit_tree ) ;
2014-11-13 04:53:12 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_colliding_bodies " ) , & RigidBody2D : : get_colliding_bodies ) ;
2014-02-10 02:10:30 +01:00
2017-08-29 07:15:46 +02:00
BIND_VMETHOD ( MethodInfo ( " _integrate_forces " , PropertyInfo ( Variant : : OBJECT , " state " , PROPERTY_HINT_RESOURCE_TYPE , " Physics2DDirectBodyState " ) ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " mode " , PROPERTY_HINT_ENUM , " Rigid,Static,Character,Kinematic " ) , " set_mode " , " get_mode " ) ;
2022-01-26 06:09:07 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " mass " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01,or_greater " ) , " set_mass " , " get_mass " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " inertia " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01,or_greater " , 0 ) , " set_inertia " , " get_inertia " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " weight " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01,or_greater " , PROPERTY_USAGE_EDITOR ) , " set_weight " , " get_weight " ) ;
2018-07-27 15:34:58 +02:00
# ifndef DISABLE_DEPRECATED
2018-11-08 15:30:02 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " , 0 ) , " set_friction " , " get_friction " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " , 0 ) , " set_bounce " , " get_bounce " ) ;
2018-07-27 15:34:58 +02:00
# endif // DISABLE_DEPRECATED
2018-11-08 15:30:02 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " physics_material_override " , PROPERTY_HINT_RESOURCE_TYPE , " PhysicsMaterial " ) , " set_physics_material_override " , " get_physics_material_override " ) ;
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " gravity_scale " , PROPERTY_HINT_RANGE , " -128,128,0.01 " ) , " set_gravity_scale " , " get_gravity_scale " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " custom_integrator " ) , " set_use_custom_integrator " , " is_using_custom_integrator " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " continuous_cd " , PROPERTY_HINT_ENUM , " Disabled,Cast Ray,Cast Shape " ) , " set_continuous_collision_detection_mode " , " get_continuous_collision_detection_mode " ) ;
2019-12-21 22:25:01 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " contacts_reported " , PROPERTY_HINT_RANGE , " 0,64,1,or_greater " ) , " set_max_contacts_reported " , " get_max_contacts_reported " ) ;
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " contact_monitor " ) , " set_contact_monitor " , " is_contact_monitor_enabled " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " sleeping " ) , " set_sleeping " , " is_sleeping " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " can_sleep " ) , " set_can_sleep " , " is_able_to_sleep " ) ;
ADD_GROUP ( " Linear " , " linear_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " linear_velocity " ) , " set_linear_velocity " , " get_linear_velocity " ) ;
2019-07-31 13:55:38 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " linear_damp " , PROPERTY_HINT_RANGE , " -1,100,0.001,or_greater " ) , " set_linear_damp " , " get_linear_damp " ) ;
2017-03-05 16:44:50 +01:00
ADD_GROUP ( " Angular " , " angular_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " angular_velocity " ) , " set_angular_velocity " , " get_angular_velocity " ) ;
2019-07-31 13:55:38 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " angular_damp " , PROPERTY_HINT_RANGE , " -1,100,0.001,or_greater " ) , " set_angular_damp " , " get_angular_damp " ) ;
2018-01-11 23:35:12 +01:00
ADD_GROUP ( " Applied Forces " , " applied_ " ) ;
2018-11-08 15:30:02 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " applied_force " ) , " set_applied_force " , " get_applied_force " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " applied_torque " ) , " set_applied_torque " , " get_applied_torque " ) ;
2014-02-10 02:10:30 +01:00
2021-10-15 17:28:11 +02:00
ADD_SIGNAL ( MethodInfo ( " body_shape_entered " , PropertyInfo ( Variant : : _RID , " body_rid " ) , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) , PropertyInfo ( Variant : : INT , " body_shape_index " ) , PropertyInfo ( Variant : : INT , " local_shape_index " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_shape_exited " , PropertyInfo ( Variant : : _RID , " body_rid " ) , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) , PropertyInfo ( Variant : : INT , " body_shape_index " ) , PropertyInfo ( Variant : : INT , " local_shape_index " ) ) ) ;
2018-09-01 12:05:51 +02:00
ADD_SIGNAL ( MethodInfo ( " body_entered " , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_exited " , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
2017-03-05 16:44:50 +01:00
ADD_SIGNAL ( MethodInfo ( " sleeping_state_changed " ) ) ;
2014-02-19 15:57:14 +01:00
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( MODE_RIGID ) ;
2017-10-21 20:58:02 +02:00
BIND_ENUM_CONSTANT ( MODE_STATIC ) ;
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( MODE_CHARACTER ) ;
2017-10-21 20:58:02 +02:00
BIND_ENUM_CONSTANT ( MODE_KINEMATIC ) ;
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( CCD_MODE_DISABLED ) ;
BIND_ENUM_CONSTANT ( CCD_MODE_CAST_RAY ) ;
BIND_ENUM_CONSTANT ( CCD_MODE_CAST_SHAPE ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-06 21:36:34 +01:00
RigidBody2D : : RigidBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_RIGID ) {
2017-03-05 16:44:50 +01:00
mode = MODE_RIGID ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
mass = 1 ;
2015-01-05 22:37:12 +01:00
2017-03-05 16:44:50 +01:00
gravity_scale = 1 ;
linear_damp = - 1 ;
angular_damp = - 1 ;
2015-01-05 22:37:12 +01:00
2017-03-05 16:44:50 +01:00
max_contacts_reported = 0 ;
2021-05-04 16:00:45 +02:00
state = nullptr ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
angular_velocity = 0 ;
sleeping = false ;
ccd_mode = CCD_MODE_DISABLED ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
custom_integrator = false ;
2021-05-04 16:00:45 +02:00
contact_monitor = nullptr ;
2017-03-05 16:44:50 +01:00
can_sleep = true ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
2014-02-10 02:10:30 +01:00
}
RigidBody2D : : ~ RigidBody2D ( ) {
2021-05-05 12:44:11 +02:00
if ( contact_monitor ) {
2017-03-05 16:44:50 +01:00
memdelete ( contact_monitor ) ;
2021-05-05 12:44:11 +02:00
}
2014-02-19 15:57:14 +01:00
}
2017-10-24 18:10:30 +02:00
void RigidBody2D : : _reload_physics_characteristics ( ) {
if ( physics_material_override . is_null ( ) ) {
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , 0 ) ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , 1 ) ;
} else {
2018-07-23 16:37:07 +02:00
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , physics_material_override - > computed_bounce ( ) ) ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , physics_material_override - > computed_friction ( ) ) ;
2017-10-24 18:10:30 +02:00
}
}
2014-02-19 15:57:14 +01:00
//////////////////////////
2018-07-17 13:57:23 +02:00
Ref < KinematicCollision2D > KinematicBody2D : : _move ( const Vector2 & p_motion , bool p_infinite_inertia , bool p_exclude_raycast_shapes , bool p_test_only ) {
2017-06-24 17:33:52 +02:00
Collision col ;
2014-02-19 15:57:14 +01:00
2018-07-17 13:57:23 +02:00
if ( move_and_collide ( p_motion , p_infinite_inertia , col , p_exclude_raycast_shapes , p_test_only ) ) {
2021-09-23 03:15:03 +02:00
// Create a new instance when the cached reference is invalid or still in use in script.
if ( motion_cache . is_null ( ) | | motion_cache - > reference_get_count ( ) > 1 ) {
2017-09-10 18:07:47 +02:00
motion_cache . instance ( ) ;
motion_cache - > owner = this ;
}
2014-02-19 15:57:14 +01:00
2017-09-10 18:07:47 +02:00
motion_cache - > collision = col ;
2015-05-04 03:37:10 +02:00
2017-09-10 18:07:47 +02:00
return motion_cache ;
2017-06-24 17:33:52 +02:00
}
2017-09-10 18:07:47 +02:00
return Ref < KinematicCollision2D > ( ) ;
2015-05-04 03:37:10 +02:00
}
2014-02-19 15:57:14 +01:00
2018-07-17 01:04:07 +02:00
bool KinematicBody2D : : separate_raycast_shapes ( bool p_infinite_inertia , Collision & r_collision ) {
Physics2DServer : : SeparationResult sep_res [ 8 ] ; //max 8 rays
2018-08-23 21:49:24 +02:00
Transform2D gt = get_global_transform ( ) ;
2018-07-17 01:04:07 +02:00
Vector2 recover ;
int hits = Physics2DServer : : get_singleton ( ) - > body_test_ray_separation ( get_rid ( ) , gt , p_infinite_inertia , recover , sep_res , 8 , margin ) ;
int deepest = - 1 ;
float deepest_depth ;
for ( int i = 0 ; i < hits ; i + + ) {
if ( deepest = = - 1 | | sep_res [ i ] . collision_depth > deepest_depth ) {
deepest = i ;
deepest_depth = sep_res [ i ] . collision_depth ;
}
}
gt . elements [ 2 ] + = recover ;
2018-08-23 21:49:24 +02:00
set_global_transform ( gt ) ;
2018-07-17 01:04:07 +02:00
if ( deepest ! = - 1 ) {
r_collision . collider = sep_res [ deepest ] . collider_id ;
2021-09-21 18:00:23 +02:00
r_collision . collider_rid = sep_res [ deepest ] . collider ;
2018-07-17 01:04:07 +02:00
r_collision . collider_metadata = sep_res [ deepest ] . collider_metadata ;
r_collision . collider_shape = sep_res [ deepest ] . collider_shape ;
r_collision . collider_vel = sep_res [ deepest ] . collider_velocity ;
r_collision . collision = sep_res [ deepest ] . collision_point ;
r_collision . normal = sep_res [ deepest ] . collision_normal ;
r_collision . local_shape = sep_res [ deepest ] . collision_local_shape ;
r_collision . travel = recover ;
r_collision . remainder = Vector2 ( ) ;
return true ;
} else {
return false ;
}
}
2021-07-01 03:59:40 +02:00
bool KinematicBody2D : : move_and_collide ( const Vector2 & p_motion , bool p_infinite_inertia , Collision & r_collision , bool p_exclude_raycast_shapes , bool p_test_only , bool p_cancel_sliding , const Set < RID > & p_exclude ) {
2019-03-04 13:42:00 +01:00
if ( sync_to_physics ) {
ERR_PRINT ( " Functions move_and_slide and move_and_collide do not work together with 'sync to physics' option. Please read the documentation. " ) ;
}
2018-08-23 21:49:24 +02:00
Transform2D gt = get_global_transform ( ) ;
2015-04-20 01:50:55 +02:00
Physics2DServer : : MotionResult result ;
2021-07-04 20:05:22 +02:00
bool colliding = Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , gt , p_motion , p_infinite_inertia , margin , & result , p_exclude_raycast_shapes , p_exclude ) ;
2017-06-24 17:33:52 +02:00
2021-07-01 03:59:40 +02:00
// Restore direction of motion to be along original motion,
// in order to avoid sliding due to recovery,
// but only if collision depth is low enough to avoid tunneling.
2021-07-01 04:00:31 +02:00
if ( p_cancel_sliding ) {
real_t motion_length = p_motion . length ( ) ;
2021-07-01 03:59:40 +02:00
real_t precision = 0.001 ;
2021-07-01 04:00:31 +02:00
if ( colliding ) {
2021-07-01 03:59:40 +02:00
// Can't just use margin as a threshold because collision depth is calculated on unsafe motion,
// so even in normal resting cases the depth can be a bit more than the margin.
precision + = motion_length * ( result . collision_unsafe_fraction - result . collision_safe_fraction ) ;
if ( result . collision_depth > ( real_t ) margin + precision ) {
p_cancel_sliding = false ;
}
}
if ( p_cancel_sliding ) {
2021-07-01 04:00:31 +02:00
// When motion is null, recovery is the resulting motion.
Vector2 motion_normal ;
if ( motion_length > CMP_EPSILON ) {
motion_normal = p_motion / motion_length ;
}
2021-07-01 03:59:40 +02:00
// Check depth of recovery.
2021-07-01 04:00:31 +02:00
real_t projected_length = result . motion . dot ( motion_normal ) ;
Vector2 recovery = result . motion - motion_normal * projected_length ;
2021-07-01 03:59:40 +02:00
real_t recovery_length = recovery . length ( ) ;
// Fixes cases where canceling slide causes the motion to go too deep into the ground,
2021-07-01 04:00:31 +02:00
// because we're only taking rest information into account and not general recovery.
2021-07-01 03:59:40 +02:00
if ( recovery_length < ( real_t ) margin + precision ) {
// Apply adjustment to motion.
2021-07-01 04:00:31 +02:00
result . motion = motion_normal * projected_length ;
2021-07-01 03:59:40 +02:00
result . remainder = p_motion - result . motion ;
}
}
}
2017-06-24 17:33:52 +02:00
if ( colliding ) {
r_collision . collider_metadata = result . collider_metadata ;
r_collision . collider_shape = result . collider_shape ;
r_collision . collider_vel = result . collider_velocity ;
r_collision . collision = result . collision_point ;
r_collision . normal = result . collision_normal ;
r_collision . collider = result . collider_id ;
2018-07-17 13:57:23 +02:00
r_collision . collider_rid = result . collider ;
2017-06-24 17:33:52 +02:00
r_collision . travel = result . motion ;
r_collision . remainder = result . remainder ;
r_collision . local_shape = result . collision_local_shape ;
2014-02-19 15:57:14 +01:00
}
2018-07-17 13:57:23 +02:00
if ( ! p_test_only ) {
gt . elements [ 2 ] + = result . motion ;
2018-08-23 21:49:24 +02:00
set_global_transform ( gt ) ;
2018-07-17 13:57:23 +02:00
}
2014-02-19 15:57:14 +01:00
2017-06-24 17:33:52 +02:00
return colliding ;
2014-02-19 15:57:14 +01:00
}
Fix misc. source comment typos
Found using `codespell -q 3 -S ./thirdparty,*.po -L ang,ba,cas,dof,doubleclick,fave,hist,leapyear,lod,nd,numer,ois,paket,seeked,sinc,switchs,te,uint -D ~/Projects/codespell/codespell_lib/data/dictionary.txt `
2019-09-19 20:36:39 +02:00
//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
2018-08-10 18:06:34 +02:00
# define FLOOR_ANGLE_THRESHOLD 0.01
2021-08-11 03:24:27 +02:00
Vector2 KinematicBody2D : : _move_and_slide_internal ( const Vector2 & p_linear_velocity , const Vector2 & p_snap , const Vector2 & p_up_direction , bool p_stop_on_slope , int p_max_slides , float p_floor_max_angle , bool p_infinite_inertia ) {
2019-11-25 00:10:36 +01:00
Vector2 body_velocity = p_linear_velocity ;
Vector2 body_velocity_normal = body_velocity . normalized ( ) ;
2020-06-16 11:11:54 +02:00
Vector2 up_direction = p_up_direction . normalized ( ) ;
2021-08-11 03:24:27 +02:00
bool was_on_floor = on_floor ;
2019-11-25 00:10:36 +01:00
2021-07-04 20:05:22 +02:00
// Hack in order to work with calling from _process as well as from _physics_process; calling from thread is risky
float delta = Engine : : get_singleton ( ) - > is_in_physics_frame ( ) ? get_physics_process_delta_time ( ) : get_process_delta_time ( ) ;
2019-11-25 00:10:36 +01:00
Vector2 current_floor_velocity = floor_velocity ;
2021-08-24 11:29:40 +02:00
if ( on_floor & & on_floor_body . is_valid ( ) ) {
2018-07-17 13:57:23 +02:00
//this approach makes sure there is less delay between the actual body velocity and the one we saved
Physics2DDirectBodyState * bs = Physics2DServer : : get_singleton ( ) - > body_get_direct_state ( on_floor_body ) ;
if ( bs ) {
2021-08-09 20:57:17 +02:00
Transform2D gt = get_global_transform ( ) ;
Vector2 local_position = gt . elements [ 2 ] - bs - > get_transform ( ) . elements [ 2 ] ;
current_floor_velocity = bs - > get_velocity_at_local_position ( local_position ) ;
2021-11-09 23:15:40 +01:00
} else {
// Body is removed or destroyed, invalidate floor.
current_floor_velocity = Vector2 ( ) ;
on_floor_body = RID ( ) ;
2018-07-17 13:57:23 +02:00
}
}
2021-07-04 20:05:22 +02:00
colliders . clear ( ) ;
2017-06-24 17:33:52 +02:00
on_floor = false ;
on_ceiling = false ;
on_wall = false ;
2020-01-15 08:04:02 +01:00
floor_normal = Vector2 ( ) ;
2017-06-24 17:33:52 +02:00
floor_velocity = Vector2 ( ) ;
2016-08-29 01:57:27 +02:00
2021-08-09 19:29:39 +02:00
if ( current_floor_velocity ! = Vector2 ( ) & & on_floor_body . is_valid ( ) ) {
2021-07-04 20:05:22 +02:00
Collision floor_collision ;
Set < RID > exclude ;
exclude . insert ( on_floor_body ) ;
2021-07-01 03:59:40 +02:00
if ( move_and_collide ( current_floor_velocity * delta , p_infinite_inertia , floor_collision , true , false , false , exclude ) ) {
2021-07-04 20:05:22 +02:00
colliders . push_back ( floor_collision ) ;
_set_collision_direction ( floor_collision , up_direction , p_floor_max_angle ) ;
}
}
on_floor_body = RID ( ) ;
Vector2 motion = body_velocity * delta ;
2021-07-01 04:00:31 +02:00
// No sliding on first attempt to keep floor motion stable when possible,
// when stop on slope is enabled.
bool sliding_enabled = ! p_stop_on_slope ;
2021-07-01 03:59:40 +02:00
for ( int iteration = 0 ; iteration < p_max_slides ; + + iteration ) {
2017-06-24 17:33:52 +02:00
Collision collision ;
2018-07-17 01:04:07 +02:00
bool found_collision = false ;
2019-11-25 00:10:36 +01:00
for ( int i = 0 ; i < 2 ; + + i ) {
2018-07-17 01:04:07 +02:00
bool collided ;
if ( i = = 0 ) { //collide
2021-07-01 03:59:40 +02:00
collided = move_and_collide ( motion , p_infinite_inertia , collision , true , false , ! sliding_enabled ) ;
2018-07-17 01:04:07 +02:00
if ( ! collided ) {
motion = Vector2 ( ) ; //clear because no collision happened and motion completed
}
} else { //separate raycasts (if any)
collided = separate_raycast_shapes ( p_infinite_inertia , collision ) ;
if ( collided ) {
collision . remainder = motion ; //keep
collision . travel = Vector2 ( ) ;
}
}
2016-08-29 01:57:27 +02:00
2018-07-17 01:04:07 +02:00
if ( collided ) {
found_collision = true ;
2016-08-31 22:58:51 +02:00
2018-08-14 19:20:48 +02:00
colliders . push_back ( collision ) ;
2017-11-20 01:42:44 +01:00
2021-07-04 20:05:22 +02:00
_set_collision_direction ( collision , up_direction , p_floor_max_angle ) ;
if ( on_floor & & p_stop_on_slope ) {
2021-07-01 03:59:40 +02:00
if ( ( body_velocity_normal + up_direction ) . length ( ) < 0.01 ) {
2021-07-04 20:05:22 +02:00
Transform2D gt = get_global_transform ( ) ;
2021-07-01 04:00:31 +02:00
if ( collision . travel . length ( ) > margin ) {
gt . elements [ 2 ] - = collision . travel . slide ( up_direction ) ;
} else {
gt . elements [ 2 ] - = collision . travel ;
}
2021-07-04 20:05:22 +02:00
set_global_transform ( gt ) ;
return Vector2 ( ) ;
2018-07-17 01:04:07 +02:00
}
2016-08-29 01:57:27 +02:00
}
2021-07-01 03:59:40 +02:00
if ( sliding_enabled | | ! on_floor ) {
motion = collision . remainder . slide ( collision . normal ) ;
body_velocity = body_velocity . slide ( collision . normal ) ;
} else {
motion = collision . remainder ;
}
2018-07-17 01:04:07 +02:00
}
2021-07-01 03:59:40 +02:00
sliding_enabled = true ;
2018-07-17 01:04:07 +02:00
}
2016-08-29 01:57:27 +02:00
2021-05-05 12:44:11 +02:00
if ( ! found_collision | | motion = = Vector2 ( ) ) {
2016-09-01 17:03:55 +02:00
break ;
2021-05-05 12:44:11 +02:00
}
2016-08-29 01:57:27 +02:00
}
2021-08-11 03:24:27 +02:00
if ( was_on_floor & & p_snap ! = Vector2 ( ) & & ! on_floor ) {
// Apply snap.
Collision col ;
Transform2D gt = get_global_transform ( ) ;
if ( move_and_collide ( p_snap , p_infinite_inertia , col , false , true , false ) ) {
bool apply = true ;
if ( up_direction ! = Vector2 ( ) ) {
if ( Math : : acos ( col . normal . dot ( up_direction ) ) < = p_floor_max_angle + FLOOR_ANGLE_THRESHOLD ) {
on_floor = true ;
floor_normal = col . normal ;
on_floor_body = col . collider_rid ;
floor_velocity = col . collider_vel ;
if ( p_stop_on_slope ) {
// move and collide may stray the object a bit because of pre un-stucking,
// so only ensure that motion happens on floor direction in this case.
if ( col . travel . length ( ) > margin ) {
col . travel = up_direction * up_direction . dot ( col . travel ) ;
} else {
col . travel = Vector2 ( ) ;
}
}
} else {
apply = false ;
}
}
if ( apply ) {
gt . elements [ 2 ] + = col . travel ;
set_global_transform ( gt ) ;
}
}
}
2022-01-06 20:23:23 +01:00
if ( moving_platform_apply_velocity_on_leave ! = PLATFORM_VEL_ON_LEAVE_NEVER ) {
2021-07-04 20:05:22 +02:00
// Add last platform velocity when just left a moving platform.
2022-01-06 20:23:23 +01:00
if ( ! on_floor ) {
if ( moving_platform_apply_velocity_on_leave = = PLATFORM_VEL_ON_LEAVE_UPWARD_ONLY & & current_floor_velocity . dot ( up_direction ) < 0 ) {
current_floor_velocity = current_floor_velocity . slide ( up_direction ) ;
}
return body_velocity + current_floor_velocity ;
}
2021-07-04 20:05:22 +02:00
}
2019-11-25 00:10:36 +01:00
return body_velocity ;
2018-07-17 02:30:44 +02:00
}
2018-07-17 01:04:07 +02:00
2021-08-11 03:24:27 +02:00
Vector2 KinematicBody2D : : move_and_slide ( const Vector2 & p_linear_velocity , const Vector2 & p_up_direction , bool p_stop_on_slope , int p_max_slides , float p_floor_max_angle , bool p_infinite_inertia ) {
return _move_and_slide_internal ( p_linear_velocity , Vector2 ( ) , p_up_direction , p_stop_on_slope , p_max_slides , p_floor_max_angle , p_infinite_inertia ) ;
}
2018-07-17 01:04:07 +02:00
2021-08-11 03:24:27 +02:00
Vector2 KinematicBody2D : : move_and_slide_with_snap ( const Vector2 & p_linear_velocity , const Vector2 & p_snap , const Vector2 & p_up_direction , bool p_stop_on_slope , int p_max_slides , float p_floor_max_angle , bool p_infinite_inertia ) {
return _move_and_slide_internal ( p_linear_velocity , p_snap , p_up_direction , p_stop_on_slope , p_max_slides , p_floor_max_angle , p_infinite_inertia ) ;
2016-08-29 01:57:27 +02:00
}
2021-07-04 20:05:22 +02:00
void KinematicBody2D : : _set_collision_direction ( const Collision & p_collision , const Vector2 & p_up_direction , float p_floor_max_angle ) {
if ( p_up_direction = = Vector2 ( ) ) {
//all is a wall
on_wall = true ;
} else {
if ( Math : : acos ( p_collision . normal . dot ( p_up_direction ) ) < = p_floor_max_angle + FLOOR_ANGLE_THRESHOLD ) { //floor
on_floor = true ;
floor_normal = p_collision . normal ;
on_floor_body = p_collision . collider_rid ;
floor_velocity = p_collision . collider_vel ;
} else if ( Math : : acos ( p_collision . normal . dot ( - p_up_direction ) ) < = p_floor_max_angle + FLOOR_ANGLE_THRESHOLD ) { //ceiling
on_ceiling = true ;
} else {
on_wall = true ;
}
}
}
2017-06-24 17:33:52 +02:00
bool KinematicBody2D : : is_on_floor ( ) const {
return on_floor ;
2016-08-29 01:57:27 +02:00
}
2017-06-24 17:33:52 +02:00
bool KinematicBody2D : : is_on_wall ( ) const {
return on_wall ;
2016-08-29 01:57:27 +02:00
}
2017-06-24 17:33:52 +02:00
bool KinematicBody2D : : is_on_ceiling ( ) const {
return on_ceiling ;
2016-08-29 01:57:27 +02:00
}
2020-01-10 14:58:19 +01:00
Vector2 KinematicBody2D : : get_floor_normal ( ) const {
return floor_normal ;
}
2021-08-26 06:16:40 +02:00
real_t KinematicBody2D : : get_floor_angle ( const Vector2 & p_up_direction ) const {
ERR_FAIL_COND_V ( p_up_direction = = Vector2 ( ) , 0 ) ;
return Math : : acos ( floor_normal . dot ( p_up_direction ) ) ;
}
2017-06-24 17:33:52 +02:00
Vector2 KinematicBody2D : : get_floor_velocity ( ) const {
return floor_velocity ;
2014-02-19 15:57:14 +01:00
}
2022-01-06 20:23:23 +01:00
void KinematicBody2D : : set_moving_platform_apply_velocity_on_leave ( MovingPlatformApplyVelocityOnLeave p_on_leave_apply_velocity ) {
moving_platform_apply_velocity_on_leave = p_on_leave_apply_velocity ;
}
KinematicBody2D : : MovingPlatformApplyVelocityOnLeave KinematicBody2D : : get_moving_platform_apply_velocity_on_leave ( ) const {
return moving_platform_apply_velocity_on_leave ;
}
2018-02-16 19:06:00 +01:00
bool KinematicBody2D : : test_move ( const Transform2D & p_from , const Vector2 & p_motion , bool p_infinite_inertia ) {
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , false ) ;
2014-02-19 15:57:14 +01:00
2021-11-10 01:03:25 +01:00
Physics2DServer : : MotionResult result ;
bool colliding = Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_from , p_motion , p_infinite_inertia , margin , & result ) ;
if ( colliding ) {
// Don't report collision when the whole motion is done.
return ( result . collision_safe_fraction < 1.0 ) ;
} else {
return false ;
}
2014-02-19 15:57:14 +01:00
}
2017-06-24 17:33:52 +02:00
void KinematicBody2D : : set_safe_margin ( float p_margin ) {
margin = p_margin ;
2014-02-19 15:57:14 +01:00
}
2015-04-20 01:50:55 +02:00
2017-06-24 17:33:52 +02:00
float KinematicBody2D : : get_safe_margin ( ) const {
return margin ;
2014-02-19 15:57:14 +01:00
}
2014-02-23 00:28:19 +01:00
2017-09-10 18:07:47 +02:00
int KinematicBody2D : : get_slide_count ( ) const {
2017-06-24 17:33:52 +02:00
return colliders . size ( ) ;
2014-02-23 00:28:19 +01:00
}
2014-02-19 15:57:14 +01:00
2017-09-10 18:07:47 +02:00
KinematicBody2D : : Collision KinematicBody2D : : get_slide_collision ( int p_bounce ) const {
ERR_FAIL_INDEX_V ( p_bounce , colliders . size ( ) , Collision ( ) ) ;
return colliders [ p_bounce ] ;
2014-10-14 06:01:25 +02:00
}
2014-10-16 05:06:34 +02:00
2017-09-10 18:07:47 +02:00
Ref < KinematicCollision2D > KinematicBody2D : : _get_slide_collision ( int p_bounce ) {
ERR_FAIL_INDEX_V ( p_bounce , colliders . size ( ) , Ref < KinematicCollision2D > ( ) ) ;
if ( p_bounce > = slide_colliders . size ( ) ) {
slide_colliders . resize ( p_bounce + 1 ) ;
2017-06-24 17:33:52 +02:00
}
2014-02-19 15:57:14 +01:00
2021-09-23 03:15:03 +02:00
// Create a new instance when the cached reference is invalid or still in use in script.
if ( slide_colliders [ p_bounce ] . is_null ( ) | | slide_colliders [ p_bounce ] - > reference_get_count ( ) > 1 ) {
2018-07-25 03:11:03 +02:00
slide_colliders . write [ p_bounce ] . instance ( ) ;
slide_colliders . write [ p_bounce ] - > owner = this ;
2017-06-24 17:33:52 +02:00
}
2014-02-19 15:57:14 +01:00
2018-07-25 03:11:03 +02:00
slide_colliders . write [ p_bounce ] - > collision = colliders [ p_bounce ] ;
2017-09-10 18:07:47 +02:00
return slide_colliders [ p_bounce ] ;
2014-02-19 15:57:14 +01:00
}
2021-08-26 06:16:40 +02:00
Ref < KinematicCollision2D > KinematicBody2D : : _get_last_slide_collision ( ) {
if ( colliders . size ( ) = = 0 ) {
return Ref < KinematicCollision2D > ( ) ;
}
return _get_slide_collision ( colliders . size ( ) - 1 ) ;
}
2018-07-17 13:57:23 +02:00
void KinematicBody2D : : set_sync_to_physics ( bool p_enable ) {
if ( sync_to_physics = = p_enable ) {
return ;
}
sync_to_physics = p_enable ;
2018-11-22 02:22:43 +01:00
2021-05-05 12:44:11 +02:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2018-11-22 02:22:43 +01:00
return ;
2021-05-05 12:44:11 +02:00
}
2018-11-22 02:22:43 +01:00
2018-07-17 13:57:23 +02:00
if ( p_enable ) {
Physics2DServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
set_only_update_transform_changes ( true ) ;
set_notify_local_transform ( true ) ;
} else {
2021-05-04 16:00:45 +02:00
Physics2DServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , nullptr , " " ) ;
2018-07-17 13:57:23 +02:00
set_only_update_transform_changes ( false ) ;
set_notify_local_transform ( false ) ;
}
}
bool KinematicBody2D : : is_sync_to_physics_enabled ( ) const {
return sync_to_physics ;
}
void KinematicBody2D : : _direct_state_changed ( Object * p_state ) {
2021-05-05 12:44:11 +02:00
if ( ! sync_to_physics ) {
2018-07-17 13:57:23 +02:00
return ;
2021-05-05 12:44:11 +02:00
}
2018-07-17 13:57:23 +02:00
Physics2DDirectBodyState * state = Object : : cast_to < Physics2DDirectBodyState > ( p_state ) ;
2021-03-30 08:36:30 +02:00
ERR_FAIL_COND_MSG ( ! state , " Method '_direct_state_changed' must receive a valid Physics2DDirectBodyState object as argument " ) ;
2018-07-17 13:57:23 +02:00
last_valid_transform = state - > get_transform ( ) ;
set_notify_local_transform ( false ) ;
2018-08-23 21:49:24 +02:00
set_global_transform ( last_valid_transform ) ;
2018-07-17 13:57:23 +02:00
set_notify_local_transform ( true ) ;
}
void KinematicBody2D : : _notification ( int p_what ) {
if ( p_what = = NOTIFICATION_ENTER_TREE ) {
2018-08-23 21:49:24 +02:00
last_valid_transform = get_global_transform ( ) ;
2019-08-19 11:11:14 +02:00
// Reset move_and_slide() data.
on_floor = false ;
on_floor_body = RID ( ) ;
on_ceiling = false ;
on_wall = false ;
colliders . clear ( ) ;
floor_velocity = Vector2 ( ) ;
2018-07-17 13:57:23 +02:00
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
//used by sync to physics, send the new transform to the physics
2018-08-23 21:49:24 +02:00
Transform2D new_transform = get_global_transform ( ) ;
2018-07-17 13:57:23 +02:00
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_TRANSFORM , new_transform ) ;
//but then revert changes
set_notify_local_transform ( false ) ;
2018-08-23 21:49:24 +02:00
set_global_transform ( last_valid_transform ) ;
2018-07-17 13:57:23 +02:00
set_notify_local_transform ( true ) ;
}
}
2014-02-19 15:57:14 +01:00
void KinematicBody2D : : _bind_methods ( ) {
2018-07-17 13:57:23 +02:00
ClassDB : : bind_method ( D_METHOD ( " move_and_collide " , " rel_vec " , " infinite_inertia " , " exclude_raycast_shapes " , " test_only " ) , & KinematicBody2D : : _move , DEFVAL ( true ) , DEFVAL ( true ) , DEFVAL ( false ) ) ;
2020-01-15 08:04:02 +01:00
ClassDB : : bind_method ( D_METHOD ( " move_and_slide " , " linear_velocity " , " up_direction " , " stop_on_slope " , " max_slides " , " floor_max_angle " , " infinite_inertia " ) , & KinematicBody2D : : move_and_slide , DEFVAL ( Vector2 ( 0 , 0 ) ) , DEFVAL ( false ) , DEFVAL ( 4 ) , DEFVAL ( Math : : deg2rad ( ( float ) 45 ) ) , DEFVAL ( true ) ) ;
ClassDB : : bind_method ( D_METHOD ( " move_and_slide_with_snap " , " linear_velocity " , " snap " , " up_direction " , " stop_on_slope " , " max_slides " , " floor_max_angle " , " infinite_inertia " ) , & KinematicBody2D : : move_and_slide_with_snap , DEFVAL ( Vector2 ( 0 , 0 ) ) , DEFVAL ( false ) , DEFVAL ( 4 ) , DEFVAL ( Math : : deg2rad ( ( float ) 45 ) ) , DEFVAL ( true ) ) ;
2014-02-19 15:57:14 +01:00
2018-10-17 10:22:48 +02:00
ClassDB : : bind_method ( D_METHOD ( " test_move " , " from " , " rel_vec " , " infinite_inertia " ) , & KinematicBody2D : : test_move , DEFVAL ( true ) ) ;
2014-02-19 15:57:14 +01:00
2017-06-24 17:33:52 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_on_floor " ) , & KinematicBody2D : : is_on_floor ) ;
ClassDB : : bind_method ( D_METHOD ( " is_on_ceiling " ) , & KinematicBody2D : : is_on_ceiling ) ;
ClassDB : : bind_method ( D_METHOD ( " is_on_wall " ) , & KinematicBody2D : : is_on_wall ) ;
2020-01-10 14:58:19 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_floor_normal " ) , & KinematicBody2D : : get_floor_normal ) ;
2021-08-26 06:16:40 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_floor_angle " , " up_direction " ) , & KinematicBody2D : : get_floor_angle , DEFVAL ( Vector2 ( 0.0 , - 1.0 ) ) ) ;
2017-06-24 17:33:52 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_floor_velocity " ) , & KinematicBody2D : : get_floor_velocity ) ;
2014-02-19 15:57:14 +01:00
2017-06-24 17:33:52 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_safe_margin " , " pixels " ) , & KinematicBody2D : : set_safe_margin ) ;
2017-08-09 13:54:55 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_safe_margin " ) , & KinematicBody2D : : get_safe_margin ) ;
2014-02-19 15:57:14 +01:00
2022-01-06 20:23:23 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_moving_platform_apply_velocity_on_leave " , " on_leave_apply_velocity " ) , & KinematicBody2D : : set_moving_platform_apply_velocity_on_leave ) ;
ClassDB : : bind_method ( D_METHOD ( " get_moving_platform_apply_velocity_on_leave " ) , & KinematicBody2D : : get_moving_platform_apply_velocity_on_leave ) ;
2017-09-10 18:07:47 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_slide_count " ) , & KinematicBody2D : : get_slide_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_slide_collision " , " slide_idx " ) , & KinematicBody2D : : _get_slide_collision ) ;
2021-08-26 06:16:40 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_last_slide_collision " ) , & KinematicBody2D : : _get_last_slide_collision ) ;
2014-02-19 15:57:14 +01:00
2018-07-17 13:57:23 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_sync_to_physics " , " enable " ) , & KinematicBody2D : : set_sync_to_physics ) ;
ClassDB : : bind_method ( D_METHOD ( " is_sync_to_physics_enabled " ) , & KinematicBody2D : : is_sync_to_physics_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " _direct_state_changed " ) , & KinematicBody2D : : _direct_state_changed ) ;
2017-06-24 17:33:52 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " collision/safe_margin " , PROPERTY_HINT_RANGE , " 0.001,256,0.001 " ) , " set_safe_margin " , " get_safe_margin " ) ;
2018-07-17 13:57:23 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " motion/sync_to_physics " ) , " set_sync_to_physics " , " is_sync_to_physics_enabled " ) ;
2022-01-06 20:23:23 +01:00
ADD_GROUP ( " Moving platform " , " moving_platform " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " moving_platform_apply_velocity_on_leave " , PROPERTY_HINT_ENUM , " Always,Upward Only,Never " , PROPERTY_USAGE_DEFAULT ) , " set_moving_platform_apply_velocity_on_leave " , " get_moving_platform_apply_velocity_on_leave " ) ;
BIND_ENUM_CONSTANT ( PLATFORM_VEL_ON_LEAVE_ALWAYS ) ;
BIND_ENUM_CONSTANT ( PLATFORM_VEL_ON_LEAVE_UPWARD_ONLY ) ;
BIND_ENUM_CONSTANT ( PLATFORM_VEL_ON_LEAVE_NEVER ) ;
2014-02-19 15:57:14 +01:00
}
2017-12-06 21:36:34 +01:00
KinematicBody2D : : KinematicBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_KINEMATIC ) {
2017-03-05 16:44:50 +01:00
margin = 0.08 ;
2016-08-29 01:57:27 +02:00
2017-06-24 17:33:52 +02:00
on_floor = false ;
on_ceiling = false ;
on_wall = false ;
2018-07-17 13:57:23 +02:00
sync_to_physics = false ;
2014-02-19 15:57:14 +01:00
}
2017-03-05 16:44:50 +01:00
KinematicBody2D : : ~ KinematicBody2D ( ) {
2017-09-10 18:07:47 +02:00
if ( motion_cache . is_valid ( ) ) {
2021-05-04 16:00:45 +02:00
motion_cache - > owner = nullptr ;
2017-09-10 18:07:47 +02:00
}
for ( int i = 0 ; i < slide_colliders . size ( ) ; i + + ) {
if ( slide_colliders [ i ] . is_valid ( ) ) {
2021-05-04 16:00:45 +02:00
slide_colliders . write [ i ] - > owner = nullptr ;
2017-09-10 18:07:47 +02:00
}
}
}
////////////////////////
Vector2 KinematicCollision2D : : get_position ( ) const {
return collision . collision ;
}
Vector2 KinematicCollision2D : : get_normal ( ) const {
return collision . normal ;
}
Vector2 KinematicCollision2D : : get_travel ( ) const {
return collision . travel ;
}
Vector2 KinematicCollision2D : : get_remainder ( ) const {
return collision . remainder ;
}
2021-08-26 06:16:40 +02:00
real_t KinematicCollision2D : : get_angle ( const Vector2 & p_up_direction ) const {
ERR_FAIL_COND_V ( p_up_direction = = Vector2 ( ) , 0 ) ;
return collision . get_angle ( p_up_direction ) ;
}
2017-09-10 18:07:47 +02:00
Object * KinematicCollision2D : : get_local_shape ( ) const {
2021-05-05 12:44:11 +02:00
if ( ! owner ) {
2021-05-04 16:00:45 +02:00
return nullptr ;
2021-05-05 12:44:11 +02:00
}
2017-09-10 18:07:47 +02:00
uint32_t ownerid = owner - > shape_find_owner ( collision . local_shape ) ;
return owner - > shape_owner_get_owner ( ownerid ) ;
}
Object * KinematicCollision2D : : get_collider ( ) const {
if ( collision . collider ) {
return ObjectDB : : get_instance ( collision . collider ) ;
}
2021-05-04 16:00:45 +02:00
return nullptr ;
2017-09-10 18:07:47 +02:00
}
ObjectID KinematicCollision2D : : get_collider_id ( ) const {
return collision . collider ;
}
2021-06-10 03:24:15 +02:00
RID KinematicCollision2D : : get_collider_rid ( ) const {
return collision . collider_rid ;
}
2017-09-10 18:07:47 +02:00
Object * KinematicCollision2D : : get_collider_shape ( ) const {
Object * collider = get_collider ( ) ;
if ( collider ) {
CollisionObject2D * obj2d = Object : : cast_to < CollisionObject2D > ( collider ) ;
if ( obj2d ) {
uint32_t ownerid = obj2d - > shape_find_owner ( collision . collider_shape ) ;
return obj2d - > shape_owner_get_owner ( ownerid ) ;
}
}
2021-05-04 16:00:45 +02:00
return nullptr ;
2017-09-10 18:07:47 +02:00
}
int KinematicCollision2D : : get_collider_shape_index ( ) const {
return collision . collider_shape ;
}
Vector2 KinematicCollision2D : : get_collider_velocity ( ) const {
return collision . collider_vel ;
}
Variant KinematicCollision2D : : get_collider_metadata ( ) const {
return Variant ( ) ;
}
void KinematicCollision2D : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " get_position " ) , & KinematicCollision2D : : get_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_normal " ) , & KinematicCollision2D : : get_normal ) ;
ClassDB : : bind_method ( D_METHOD ( " get_travel " ) , & KinematicCollision2D : : get_travel ) ;
ClassDB : : bind_method ( D_METHOD ( " get_remainder " ) , & KinematicCollision2D : : get_remainder ) ;
2021-08-26 06:16:40 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_angle " , " up_direction " ) , & KinematicCollision2D : : get_angle , DEFVAL ( Vector2 ( 0.0 , - 1.0 ) ) ) ;
2017-09-10 18:07:47 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_local_shape " ) , & KinematicCollision2D : : get_local_shape ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider " ) , & KinematicCollision2D : : get_collider ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_id " ) , & KinematicCollision2D : : get_collider_id ) ;
2021-06-10 03:24:15 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_collider_rid " ) , & KinematicCollision2D : : get_collider_rid ) ;
2017-09-10 18:07:47 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_collider_shape " ) , & KinematicCollision2D : : get_collider_shape ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_shape_index " ) , & KinematicCollision2D : : get_collider_shape_index ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_velocity " ) , & KinematicCollision2D : : get_collider_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_metadata " ) , & KinematicCollision2D : : get_collider_metadata ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " position " ) , " " , " get_position " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " normal " ) , " " , " get_normal " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " travel " ) , " " , " get_travel " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " remainder " ) , " " , " get_remainder " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " local_shape " ) , " " , " get_local_shape " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " collider " ) , " " , " get_collider " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collider_id " ) , " " , " get_collider_id " ) ;
2021-06-10 03:24:15 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : _RID , " collider_rid " ) , " " , " get_collider_rid " ) ;
2017-09-10 18:07:47 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " collider_shape " ) , " " , " get_collider_shape " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collider_shape_index " ) , " " , " get_collider_shape_index " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " collider_velocity " ) , " " , " get_collider_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : NIL , " collider_metadata " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NIL_IS_VARIANT ) , " " , " get_collider_metadata " ) ;
}
KinematicCollision2D : : KinematicCollision2D ( ) {
collision . collider = 0 ;
collision . collider_shape = 0 ;
collision . local_shape = 0 ;
2021-05-04 16:00:45 +02:00
owner = nullptr ;
2014-02-10 02:10:30 +01:00
}