2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* physics_body_2d.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 01:10:30 +00: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-04 23:50:27 +00:00
2014-02-10 01:10:30 +00:00
# include "physics_body_2d.h"
2017-08-18 23:02:56 +00:00
2017-10-24 16:10:30 +00:00
# include "core/core_string_names.h"
2018-09-11 16:13:45 +00:00
# include "core/engine.h"
2018-10-24 19:32:55 +00:00
# include "core/list.h"
2018-09-11 16:13:45 +00:00
# include "core/math/math_funcs.h"
2018-02-16 18:06:00 +00:00
# include "core/method_bind_ext.gen.inc"
2018-10-24 19:32:55 +00:00
# include "core/object.h"
# include "core/rid.h"
2014-02-10 01:10:30 +00:00
# include "scene/scene_string_names.h"
2018-08-23 19:49:24 +00:00
2018-08-29 15:03:48 +00:00
void PhysicsBody2D : : _notification ( int p_what ) {
2018-08-23 19:49:24 +00:00
}
2014-02-10 01:10:30 +00:00
2015-05-10 18:58:08 +00:00
void PhysicsBody2D : : _set_layers ( uint32_t p_mask ) {
2017-01-13 14:01:19 +00:00
set_collision_layer ( p_mask ) ;
2015-05-10 18:58:08 +00:00
set_collision_mask ( p_mask ) ;
}
2017-03-05 15:44:50 +00:00
uint32_t PhysicsBody2D : : _get_layers ( ) const {
2015-05-10 18:58:08 +00:00
2017-01-13 14:01:19 +00:00
return get_collision_layer ( ) ;
2015-05-10 18:58:08 +00:00
}
2014-05-14 04:22:15 +00:00
void PhysicsBody2D : : _bind_methods ( ) {
2017-06-13 15:45:01 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_layer " , " layer " ) , & PhysicsBody2D : : set_collision_layer ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_collision_layer " ) , & PhysicsBody2D : : get_collision_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " set_collision_mask " , " mask " ) , & PhysicsBody2D : : set_collision_mask ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_mask " ) , & PhysicsBody2D : : get_collision_mask ) ;
2017-02-13 11:47:24 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_mask_bit " , " bit " , " value " ) , & PhysicsBody2D : : set_collision_mask_bit ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_mask_bit " , " bit " ) , & PhysicsBody2D : : get_collision_mask_bit ) ;
2017-02-13 11:47:24 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_layer_bit " , " bit " , " value " ) , & PhysicsBody2D : : set_collision_layer_bit ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_layer_bit " , " bit " ) , & PhysicsBody2D : : get_collision_layer_bit ) ;
2017-02-13 11:47:24 +00:00
2017-03-05 15:44:50 +00: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 19:32:55 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_collision_exceptions " ) , & PhysicsBody2D : : get_collision_exceptions ) ;
2017-08-09 11:19:41 +00: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 15:44:50 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " layers " , PROPERTY_HINT_LAYERS_2D_PHYSICS , " " , 0 ) , " _set_layers " , " _get_layers " ) ; //for backwards compat
2017-02-13 11:47:24 +00:00
2017-03-05 15:44:50 +00:00
ADD_GROUP ( " Collision " , " collision_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision_layer " , PROPERTY_HINT_LAYERS_2D_PHYSICS ) , " set_collision_layer " , " get_collision_layer " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision_mask " , PROPERTY_HINT_LAYERS_2D_PHYSICS ) , " set_collision_mask " , " get_collision_mask " ) ;
2014-05-14 04:22:15 +00:00
}
2017-06-13 15:45:01 +00:00
void PhysicsBody2D : : set_collision_layer ( uint32_t p_layer ) {
2014-05-14 04:22:15 +00:00
2017-06-13 15:45:01 +00:00
collision_layer = p_layer ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_collision_layer ( get_rid ( ) , p_layer ) ;
2014-05-14 04:22:15 +00:00
}
2017-01-13 14:01:19 +00:00
uint32_t PhysicsBody2D : : get_collision_layer ( ) const {
2014-02-10 01:10:30 +00:00
2017-06-13 15:45:01 +00:00
return collision_layer ;
2014-05-14 04:22:15 +00:00
}
2015-05-03 19:47:21 +00:00
void PhysicsBody2D : : set_collision_mask ( uint32_t p_mask ) {
2017-03-05 15:44:50 +00:00
collision_mask = p_mask ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_collision_mask ( get_rid ( ) , p_mask ) ;
2015-05-03 19:47:21 +00:00
}
uint32_t PhysicsBody2D : : get_collision_mask ( ) const {
return collision_mask ;
}
2015-06-06 12:44:38 +00:00
void PhysicsBody2D : : set_collision_mask_bit ( int p_bit , bool p_value ) {
uint32_t mask = get_collision_mask ( ) ;
if ( p_value )
2017-03-05 15:44:50 +00:00
mask | = 1 < < p_bit ;
2015-06-06 12:44:38 +00:00
else
2017-03-05 15:44:50 +00:00
mask & = ~ ( 1 < < p_bit ) ;
2015-06-06 12:44:38 +00:00
set_collision_mask ( mask ) ;
}
2017-03-05 15:44:50 +00:00
bool PhysicsBody2D : : get_collision_mask_bit ( int p_bit ) const {
2015-06-06 12:44:38 +00:00
2017-03-05 15:44:50 +00:00
return get_collision_mask ( ) & ( 1 < < p_bit ) ;
2015-06-06 12:44:38 +00:00
}
2017-01-13 14:01:19 +00:00
void PhysicsBody2D : : set_collision_layer_bit ( int p_bit , bool p_value ) {
2015-06-06 12:44:38 +00:00
2017-06-13 15:45:01 +00:00
uint32_t collision_layer = get_collision_layer ( ) ;
2015-06-06 12:44:38 +00:00
if ( p_value )
2017-06-13 15:45:01 +00:00
collision_layer | = 1 < < p_bit ;
2015-06-06 12:44:38 +00:00
else
2017-06-13 15:45:01 +00:00
collision_layer & = ~ ( 1 < < p_bit ) ;
set_collision_layer ( collision_layer ) ;
2015-06-06 12:44:38 +00:00
}
2017-03-05 15:44:50 +00:00
bool PhysicsBody2D : : get_collision_layer_bit ( int p_bit ) const {
2015-06-06 12:44:38 +00:00
2017-03-05 15:44:50 +00:00
return get_collision_layer ( ) & ( 1 < < p_bit ) ;
2015-06-06 12:44:38 +00:00
}
2015-05-03 19:47:21 +00:00
2020-03-27 18:21:27 +00:00
PhysicsBody2D : : PhysicsBody2D ( PhysicsServer2D : : BodyMode p_mode ) :
CollisionObject2D ( PhysicsServer2D : : get_singleton ( ) - > body_create ( ) , false ) {
2014-02-10 01:10:30 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , p_mode ) ;
2017-06-13 15:45:01 +00:00
collision_layer = 1 ;
2017-03-05 15:44:50 +00:00
collision_mask = 1 ;
2015-03-22 04:46:18 +00:00
set_pickable ( false ) ;
2014-02-10 01:10:30 +00:00
}
2018-10-24 19:32:55 +00:00
Array PhysicsBody2D : : get_collision_exceptions ( ) {
List < RID > exceptions ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_get_collision_exceptions ( get_rid ( ) , & exceptions ) ;
2018-10-24 19:32:55 +00:00
Array ret ;
for ( List < RID > : : Element * E = exceptions . front ( ) ; E ; E = E - > next ( ) ) {
RID body = E - > get ( ) ;
2020-03-27 18:21:27 +00:00
ObjectID instance_id = PhysicsServer2D : : get_singleton ( ) - > body_get_object_instance_id ( body ) ;
2018-10-24 19:32:55 +00:00
Object * obj = ObjectDB : : get_instance ( instance_id ) ;
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( obj ) ;
ret . append ( physics_body ) ;
}
return ret ;
}
2017-03-05 15:44:50 +00:00
void PhysicsBody2D : : add_collision_exception_with ( Node * p_node ) {
2014-09-22 03:50:48 +00:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 20:58:51 +00:00
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( p_node ) ;
2019-08-08 20:11:48 +00:00
ERR_FAIL_COND_MSG ( ! physics_body , " Collision exception only works between two objects of PhysicsBody type. " ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_add_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 03:50:48 +00:00
}
2017-03-05 15:44:50 +00:00
void PhysicsBody2D : : remove_collision_exception_with ( Node * p_node ) {
2014-09-22 03:50:48 +00:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 20:58:51 +00:00
PhysicsBody2D * physics_body = Object : : cast_to < PhysicsBody2D > ( p_node ) ;
2019-08-08 20:11:48 +00:00
ERR_FAIL_COND_MSG ( ! physics_body , " Collision exception only works between two objects of PhysicsBody type. " ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_remove_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 03:50:48 +00:00
}
2017-03-05 15:44:50 +00:00
void StaticBody2D : : set_constant_linear_velocity ( const Vector2 & p_vel ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
constant_linear_velocity = p_vel ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_LINEAR_VELOCITY , constant_linear_velocity ) ;
2014-02-10 01:10:30 +00:00
}
void StaticBody2D : : set_constant_angular_velocity ( real_t p_vel ) {
2017-03-05 15:44:50 +00:00
constant_angular_velocity = p_vel ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_ANGULAR_VELOCITY , constant_angular_velocity ) ;
2014-02-10 01:10:30 +00: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 16:10:30 +00:00
void StaticBody2D : : set_physics_material_override ( const Ref < PhysicsMaterial > & p_physics_material_override ) {
if ( physics_material_override . is_valid ( ) ) {
2020-02-21 22:26:13 +00:00
if ( physics_material_override - > is_connected ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & StaticBody2D : : _reload_physics_characteristics ) ) ) {
physics_material_override - > disconnect ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & StaticBody2D : : _reload_physics_characteristics ) ) ;
}
2017-10-24 16:10:30 +00:00
}
physics_material_override = p_physics_material_override ;
if ( physics_material_override . is_valid ( ) ) {
2020-02-21 22:26:13 +00:00
physics_material_override - > connect ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & StaticBody2D : : _reload_physics_characteristics ) ) ;
2017-10-24 16:10:30 +00:00
}
_reload_physics_characteristics ( ) ;
}
Ref < PhysicsMaterial > StaticBody2D : : get_physics_material_override ( ) const {
return physics_material_override ;
2014-02-10 01:10:30 +00:00
}
void StaticBody2D : : _bind_methods ( ) {
2017-03-05 15:44:50 +00: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 13:34:58 +00:00
2017-10-24 16:10:30 +00: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 ) ;
2017-03-05 15:44:50 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " constant_linear_velocity " ) , " set_constant_linear_velocity " , " get_constant_linear_velocity " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " constant_angular_velocity " ) , " set_constant_angular_velocity " , " get_constant_angular_velocity " ) ;
2018-11-08 14:30:02 +00: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 01:10:30 +00:00
}
2017-12-06 20:36:34 +00:00
StaticBody2D : : StaticBody2D ( ) :
2020-03-27 18:21:27 +00:00
PhysicsBody2D ( PhysicsServer2D : : BODY_MODE_STATIC ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
constant_angular_velocity = 0 ;
2014-02-10 01:10:30 +00:00
}
StaticBody2D : : ~ StaticBody2D ( ) {
}
2017-10-24 16:10:30 +00:00
void StaticBody2D : : _reload_physics_characteristics ( ) {
if ( physics_material_override . is_null ( ) ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_BOUNCE , 0 ) ;
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_FRICTION , 1 ) ;
2017-10-24 16:10:30 +00:00
} else {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_BOUNCE , physics_material_override - > computed_bounce ( ) ) ;
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_FRICTION , physics_material_override - > computed_friction ( ) ) ;
2017-10-24 16:10:30 +00:00
}
}
2014-11-06 00:20:42 +00:00
void RigidBody2D : : _body_enter_tree ( ObjectID p_id ) {
2014-02-10 01:10:30 +00:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 20:58:51 +00:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 11:46:13 +00:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 15:44:50 +00:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! E ) ;
ERR_FAIL_COND ( E - > get ( ) . in_scene ) ;
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = true ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
E - > get ( ) . in_scene = true ;
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2016-01-12 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_entered , p_id , node , E - > get ( ) . shapes [ i ] . body_shape , E - > get ( ) . shapes [ i ] . local_shape ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = false ;
2014-02-10 01:10:30 +00:00
}
2014-11-06 00:20:42 +00:00
void RigidBody2D : : _body_exit_tree ( ObjectID p_id ) {
2014-02-10 01:10:30 +00:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 20:58:51 +00:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 11:46:13 +00:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 15:44:50 +00:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! E ) ;
ERR_FAIL_COND ( ! E - > get ( ) . in_scene ) ;
2017-03-05 15:44:50 +00:00
E - > get ( ) . in_scene = false ;
2016-01-12 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = true ;
2016-01-12 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , node ) ;
2016-01-12 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_exited , p_id , node , E - > get ( ) . shapes [ i ] . body_shape , E - > get ( ) . shapes [ i ] . local_shape ) ;
2014-02-10 01:10:30 +00:00
}
2016-01-12 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = false ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : _body_inout ( int p_status , ObjectID p_instance , int p_body_shape , int p_local_shape ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
bool body_in = p_status = = 1 ;
ObjectID objid = p_instance ;
2014-02-10 01:10:30 +00:00
Object * obj = ObjectDB : : get_instance ( objid ) ;
2017-08-24 20:58:51 +00:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 01:10:30 +00:00
2018-01-21 11:46:13 +00:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 15:44:50 +00:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( objid ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! body_in & & ! E ) ;
if ( body_in ) {
if ( ! E ) {
2017-03-05 15:44:50 +00:00
E = contact_monitor - > body_map . insert ( objid , BodyState ( ) ) ;
2017-01-14 11:26:56 +00:00
//E->get().rc=0;
2017-03-05 15:44:50 +00:00
E - > get ( ) . in_scene = node & & node - > is_inside_tree ( ) ;
2014-02-10 01:10:30 +00:00
if ( node ) {
2020-02-21 22:26:13 +00:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_entered , callable_mp ( this , & RigidBody2D : : _body_enter_tree ) , make_binds ( objid ) ) ;
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , callable_mp ( this , & RigidBody2D : : _body_exit_tree ) , make_binds ( objid ) ) ;
2014-02-10 01:10:30 +00:00
if ( E - > get ( ) . in_scene ) {
2017-03-05 15:44:50 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2014-02-10 01:10:30 +00:00
}
}
2014-10-03 11:58:41 +00:00
//E->get().rc++;
2014-02-10 01:10:30 +00:00
}
2014-10-03 11:58:41 +00:00
2014-02-10 01:10:30 +00:00
if ( node )
2017-03-05 15:44:50 +00:00
E - > get ( ) . shapes . insert ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2014-02-10 01:10:30 +00:00
if ( E - > get ( ) . in_scene ) {
2017-03-05 15:44:50 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_entered , objid , node , p_body_shape , p_local_shape ) ;
2014-02-10 01:10:30 +00:00
}
} else {
2014-10-03 11:58:41 +00:00
//E->get().rc--;
2014-02-10 01:10:30 +00:00
if ( node )
2017-03-05 15:44:50 +00:00
E - > get ( ) . shapes . erase ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2014-02-10 01:10:30 +00:00
2014-10-03 11:58:41 +00:00
bool in_scene = E - > get ( ) . in_scene ;
if ( E - > get ( ) . shapes . empty ( ) ) {
2014-02-10 01:10:30 +00:00
if ( node ) {
2020-02-21 22:26:13 +00:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , callable_mp ( this , & RigidBody2D : : _body_enter_tree ) ) ;
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , callable_mp ( this , & RigidBody2D : : _body_exit_tree ) ) ;
2014-10-03 11:58:41 +00:00
if ( in_scene )
2018-09-01 10:05:51 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , node ) ;
2014-02-10 01:10:30 +00:00
}
contact_monitor - > body_map . erase ( E ) ;
}
2014-10-03 11:58:41 +00:00
if ( node & & in_scene ) {
2018-09-01 10:05:51 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_exited , objid , node , p_body_shape , p_local_shape ) ;
2014-02-10 01:10:30 +00:00
}
}
}
struct _RigidBody2DInOut {
ObjectID id ;
int shape ;
int local_shape ;
} ;
2018-02-16 18:06:00 +00:00
bool RigidBody2D : : _test_motion ( const Vector2 & p_motion , bool p_infinite_inertia , float p_margin , const Ref < Physics2DTestMotionResult > & p_result ) {
2015-04-19 23:50:55 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : MotionResult * r = NULL ;
2015-04-19 23:50:55 +00:00
if ( p_result . is_valid ( ) )
2017-03-05 15:44:50 +00:00
r = p_result - > get_result_ptr ( ) ;
2020-03-27 18:21:27 +00:00
return PhysicsServer2D : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , get_global_transform ( ) , p_motion , p_infinite_inertia , p_margin , r ) ;
2015-04-19 23:50:55 +00:00
}
2014-02-10 01:10:30 +00:00
void RigidBody2D : : _direct_state_changed ( Object * p_state ) {
# ifdef DEBUG_ENABLED
2020-03-27 18:21:27 +00:00
state = Object : : cast_to < PhysicsDirectBodyState2D > ( p_state ) ;
2014-02-10 01:10:30 +00:00
# else
2017-03-05 15:44:50 +00:00
state = ( Physics2DDirectBodyState * ) p_state ; //trust it
2014-02-10 01:10:30 +00:00
# endif
2016-06-17 19:45:10 +00:00
set_block_transform_notify ( true ) ; // don't want notify (would feedback loop)
2017-03-05 15:44:50 +00:00
if ( mode ! = MODE_KINEMATIC )
2018-08-23 19:49:24 +00:00
set_global_transform ( state - > get_transform ( ) ) ;
2017-03-05 15:44:50 +00: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 19:45:10 +00:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > sleeping_state_changed ) ;
}
if ( get_script_instance ( ) )
2017-03-05 15:44:50 +00:00
get_script_instance ( ) - > call ( " _integrate_forces " , state ) ;
2016-06-17 19:45:10 +00:00
set_block_transform_notify ( false ) ; // want it back
2014-02-10 01:10:30 +00:00
if ( contact_monitor ) {
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = true ;
2016-01-12 09:14:15 +00:00
2014-02-10 01:10:30 +00:00
//untag all
2017-03-05 15:44:50 +00:00
int rc = 0 ;
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
E - > get ( ) . shapes [ i ] . tagged = false ;
2014-02-10 01:10:30 +00:00
rc + + ;
}
}
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
//put the ones to add
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < state - > get_contact_count ( ) ; i + + ) {
2014-02-10 01:10:30 +00: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 11:26:56 +00:00
//bool found=false;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( obj ) ;
2014-02-10 01:10:30 +00:00
if ( ! E ) {
2017-03-05 15:44:50 +00:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 01:10:30 +00:00
toadd_count + + ;
continue ;
}
2017-03-05 15:44:50 +00:00
ShapePair sp ( shape , local_shape ) ;
2014-02-10 01:10:30 +00:00
int idx = E - > get ( ) . shapes . find ( sp ) ;
2017-03-05 15:44:50 +00:00
if ( idx = = - 1 ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 01:10:30 +00:00
toadd_count + + ;
continue ;
}
2017-03-05 15:44:50 +00:00
E - > get ( ) . shapes [ idx ] . tagged = true ;
2014-02-10 01:10:30 +00:00
}
//put the ones to remove
2017-03-05 15:44:50 +00:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 01:10:30 +00:00
if ( ! E - > get ( ) . shapes [ i ] . tagged ) {
2017-03-05 15:44:50 +00:00
toremove [ toremove_count ] . body_id = E - > key ( ) ;
toremove [ toremove_count ] . pair = E - > get ( ) . shapes [ i ] ;
2014-02-10 01:10:30 +00:00
toremove_count + + ;
}
}
}
//process remotions
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < toremove_count ; i + + ) {
2014-10-03 11:58:41 +00:00
2017-03-05 15:44:50 +00:00
_body_inout ( 0 , toremove [ i ] . body_id , toremove [ i ] . pair . body_shape , toremove [ i ] . pair . local_shape ) ;
2014-02-10 01:10:30 +00:00
}
//process aditions
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < toadd_count ; i + + ) {
2014-10-03 11:58:41 +00:00
2017-03-05 15:44:50 +00:00
_body_inout ( 1 , toadd [ i ] . id , toadd [ i ] . shape , toadd [ i ] . local_shape ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
contact_monitor - > locked = false ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
state = NULL ;
2014-02-10 01:10:30 +00:00
}
void RigidBody2D : : set_mode ( Mode p_mode ) {
2017-03-05 15:44:50 +00:00
mode = p_mode ;
switch ( p_mode ) {
2014-02-10 01:10:30 +00:00
case MODE_RIGID : {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer2D : : BODY_MODE_RIGID ) ;
2014-02-10 01:10:30 +00:00
} break ;
case MODE_STATIC : {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer2D : : BODY_MODE_STATIC ) ;
2014-02-10 01:10:30 +00:00
} break ;
2014-02-19 14:57:14 +00:00
case MODE_KINEMATIC : {
2014-02-10 01:10:30 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer2D : : BODY_MODE_KINEMATIC ) ;
2014-02-10 01:10:30 +00:00
} break ;
case MODE_CHARACTER : {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer2D : : BODY_MODE_CHARACTER ) ;
2014-02-10 01:10:30 +00:00
} break ;
}
}
2017-03-05 15:44:50 +00:00
RigidBody2D : : Mode RigidBody2D : : get_mode ( ) const {
2014-02-10 01:10:30 +00:00
return mode ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_mass ( real_t p_mass ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( p_mass < = 0 ) ;
mass = p_mass ;
2014-02-10 01:10:30 +00:00
_change_notify ( " mass " ) ;
_change_notify ( " weight " ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_MASS , mass ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_mass ( ) const {
2014-02-10 01:10:30 +00:00
return mass ;
}
2016-04-26 12:15:15 +00:00
void RigidBody2D : : set_inertia ( real_t p_inertia ) {
2019-08-15 11:34:47 +00:00
ERR_FAIL_COND ( p_inertia < 0 ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_INERTIA , p_inertia ) ;
2016-04-26 12:15:15 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_inertia ( ) const {
2016-04-21 00:49:37 +00:00
2020-03-27 18:21:27 +00:00
return PhysicsServer2D : : get_singleton ( ) - > body_get_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_INERTIA ) ;
2016-04-21 00:49:37 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_weight ( real_t p_weight ) {
2014-02-10 01:10:30 +00:00
2018-08-29 06:37:08 +00:00
set_mass ( p_weight / ( real_t ( GLOBAL_DEF ( " physics/2d/default_gravity " , 98 ) ) / 10 ) ) ;
2014-02-10 01:10:30 +00:00
}
2017-07-04 12:57:15 +00:00
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_weight ( ) const {
2014-02-10 01:10:30 +00:00
2018-08-29 06:37:08 +00:00
return mass * ( real_t ( GLOBAL_DEF ( " physics/2d/default_gravity " , 98 ) ) / 10 ) ;
2014-02-10 01:10:30 +00:00
}
2017-10-24 16:10:30 +00:00
void RigidBody2D : : set_physics_material_override ( const Ref < PhysicsMaterial > & p_physics_material_override ) {
if ( physics_material_override . is_valid ( ) ) {
2020-02-21 22:26:13 +00:00
if ( physics_material_override - > is_connected ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & RigidBody2D : : _reload_physics_characteristics ) ) ) {
physics_material_override - > disconnect ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & RigidBody2D : : _reload_physics_characteristics ) ) ;
}
2017-10-24 16:10:30 +00:00
}
physics_material_override = p_physics_material_override ;
if ( physics_material_override . is_valid ( ) ) {
2020-02-21 22:26:13 +00:00
physics_material_override - > connect ( CoreStringNames : : get_singleton ( ) - > changed , callable_mp ( this , & RigidBody2D : : _reload_physics_characteristics ) ) ;
2017-10-24 16:10:30 +00:00
}
_reload_physics_characteristics ( ) ;
}
Ref < PhysicsMaterial > RigidBody2D : : get_physics_material_override ( ) const {
return physics_material_override ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_gravity_scale ( real_t p_gravity_scale ) {
2015-01-05 21:37:12 +00:00
2017-03-05 15:44:50 +00:00
gravity_scale = p_gravity_scale ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_GRAVITY_SCALE , gravity_scale ) ;
2015-01-05 21:37:12 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_gravity_scale ( ) const {
2015-01-05 21:37:12 +00:00
return gravity_scale ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_linear_damp ( real_t p_linear_damp ) {
2015-01-05 21:37:12 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( p_linear_damp < - 1 ) ;
linear_damp = p_linear_damp ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_LINEAR_DAMP , linear_damp ) ;
2015-01-05 21:37:12 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_linear_damp ( ) const {
2015-01-05 21:37:12 +00:00
return linear_damp ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_angular_damp ( real_t p_angular_damp ) {
2015-01-05 21:37:12 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( p_angular_damp < - 1 ) ;
angular_damp = p_angular_damp ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_ANGULAR_DAMP , angular_damp ) ;
2015-01-05 21:37:12 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_angular_damp ( ) const {
2015-01-05 21:37:12 +00:00
return angular_damp ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_axis_velocity ( const Vector2 & p_axis ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Vector2 v = state ? state - > get_linear_velocity ( ) : linear_velocity ;
2014-02-10 01:10:30 +00:00
Vector2 axis = p_axis . normalized ( ) ;
2017-03-05 15:44:50 +00:00
v - = axis * axis . dot ( v ) ;
v + = p_axis ;
2014-02-10 01:10:30 +00:00
if ( state ) {
set_linear_velocity ( v ) ;
} else {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_axis_velocity ( get_rid ( ) , p_axis ) ;
2017-03-05 15:44:50 +00:00
linear_velocity = v ;
2014-02-10 01:10:30 +00:00
}
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_linear_velocity ( const Vector2 & p_velocity ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
linear_velocity = p_velocity ;
2014-02-10 01:10:30 +00:00
if ( state )
state - > set_linear_velocity ( linear_velocity ) ;
else {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_LINEAR_VELOCITY , linear_velocity ) ;
2014-02-10 01:10:30 +00:00
}
}
2017-03-05 15:44:50 +00:00
Vector2 RigidBody2D : : get_linear_velocity ( ) const {
2014-02-10 01:10:30 +00:00
return linear_velocity ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_angular_velocity ( real_t p_velocity ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
angular_velocity = p_velocity ;
2014-02-10 01:10:30 +00:00
if ( state )
state - > set_angular_velocity ( angular_velocity ) ;
else
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_ANGULAR_VELOCITY , angular_velocity ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
real_t RigidBody2D : : get_angular_velocity ( ) const {
2014-02-10 01:10:30 +00:00
return angular_velocity ;
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_use_custom_integrator ( bool p_enable ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
if ( custom_integrator = = p_enable )
2014-02-10 01:10:30 +00:00
return ;
2017-03-05 15:44:50 +00:00
custom_integrator = p_enable ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_omit_force_integration ( get_rid ( ) , p_enable ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
bool RigidBody2D : : is_using_custom_integrator ( ) {
2014-02-10 01:10:30 +00:00
return custom_integrator ;
}
2014-09-22 03:50:48 +00:00
void RigidBody2D : : set_sleeping ( bool p_sleeping ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
sleeping = p_sleeping ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_SLEEPING , sleeping ) ;
2014-02-10 01:10:30 +00:00
}
void RigidBody2D : : set_can_sleep ( bool p_active ) {
2017-03-05 15:44:50 +00:00
can_sleep = p_active ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_CAN_SLEEP , p_active ) ;
2014-02-10 01:10:30 +00:00
}
bool RigidBody2D : : is_able_to_sleep ( ) const {
return can_sleep ;
}
2014-09-22 03:50:48 +00:00
bool RigidBody2D : : is_sleeping ( ) const {
2014-02-10 01:10:30 +00:00
2014-09-22 03:50:48 +00:00
return sleeping ;
2014-02-10 01:10:30 +00:00
}
void RigidBody2D : : set_max_contacts_reported ( int p_amount ) {
2017-03-05 15:44:50 +00:00
max_contacts_reported = p_amount ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_max_contacts_reported ( get_rid ( ) , p_amount ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
int RigidBody2D : : get_max_contacts_reported ( ) const {
2014-02-10 01:10:30 +00:00
return max_contacts_reported ;
}
2018-07-24 07:49:12 +00:00
void RigidBody2D : : apply_central_impulse ( const Vector2 & p_impulse ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_apply_central_impulse ( get_rid ( ) , p_impulse ) ;
2018-07-24 07:49:12 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : apply_impulse ( const Vector2 & p_offset , const Vector2 & p_impulse ) {
2014-02-10 01:10:30 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_apply_impulse ( get_rid ( ) , p_offset , p_impulse ) ;
2014-02-10 01:10:30 +00:00
}
2018-07-24 07:49:12 +00:00
void RigidBody2D : : apply_torque_impulse ( float p_torque ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_apply_torque_impulse ( get_rid ( ) , p_torque ) ;
2018-07-24 07:49:12 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : set_applied_force ( const Vector2 & p_force ) {
2014-02-10 01:10:30 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_applied_force ( get_rid ( ) , p_force ) ;
2014-02-10 01:10:30 +00:00
} ;
Vector2 RigidBody2D : : get_applied_force ( ) const {
2020-03-27 18:21:27 +00:00
return PhysicsServer2D : : get_singleton ( ) - > body_get_applied_force ( get_rid ( ) ) ;
2014-02-10 01:10:30 +00:00
} ;
2016-04-20 23:49:35 +00:00
void RigidBody2D : : set_applied_torque ( const float p_torque ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_applied_torque ( get_rid ( ) , p_torque ) ;
2016-04-20 23:49:35 +00:00
} ;
float RigidBody2D : : get_applied_torque ( ) const {
2020-03-27 18:21:27 +00:00
return PhysicsServer2D : : get_singleton ( ) - > body_get_applied_torque ( get_rid ( ) ) ;
2016-04-20 23:49:35 +00:00
} ;
2018-07-24 07:49:12 +00:00
void RigidBody2D : : add_central_force ( const Vector2 & p_force ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_add_central_force ( get_rid ( ) , p_force ) ;
2018-07-24 07:49:12 +00:00
}
2017-03-05 15:44:50 +00:00
void RigidBody2D : : add_force ( const Vector2 & p_offset , const Vector2 & p_force ) {
2016-04-26 12:15:15 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_add_force ( get_rid ( ) , p_offset , p_force ) ;
2016-04-26 12:15:15 +00:00
}
2014-02-10 01:10:30 +00:00
2018-07-24 07:49:12 +00:00
void RigidBody2D : : add_torque ( const float p_torque ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_add_torque ( get_rid ( ) , p_torque ) ;
2018-07-24 07:49:12 +00:00
}
2014-02-19 14:57:14 +00:00
void RigidBody2D : : set_continuous_collision_detection_mode ( CCDMode p_mode ) {
2017-03-05 15:44:50 +00:00
ccd_mode = p_mode ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_continuous_collision_detection_mode ( get_rid ( ) , PhysicsServer2D : : CCDMode ( p_mode ) ) ;
2014-02-19 14:57:14 +00:00
}
2014-02-10 01:10:30 +00:00
2014-02-19 14:57:14 +00:00
RigidBody2D : : CCDMode RigidBody2D : : get_continuous_collision_detection_mode ( ) const {
2014-02-10 01:10:30 +00:00
2014-02-19 14:57:14 +00:00
return ccd_mode ;
2014-02-10 01:10:30 +00:00
}
2014-11-13 03:53:12 +00:00
Array RigidBody2D : : get_colliding_bodies ( ) const {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! contact_monitor , Array ( ) ) ;
2014-11-13 03:53:12 +00:00
Array ret ;
ret . resize ( contact_monitor - > body_map . size ( ) ) ;
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( const Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-11-13 03:53:12 +00:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
if ( ! obj ) {
2017-03-05 15:44:50 +00:00
ret . resize ( ret . size ( ) - 1 ) ; //ops
2014-11-13 03:53:12 +00:00
} else {
2017-03-05 15:44:50 +00:00
ret [ idx + + ] = obj ;
2014-11-13 03:53:12 +00:00
}
}
return ret ;
}
2014-02-10 01:10:30 +00:00
void RigidBody2D : : set_contact_monitor ( bool p_enabled ) {
2017-03-05 15:44:50 +00:00
if ( p_enabled = = is_contact_monitor_enabled ( ) )
2014-02-10 01:10:30 +00:00
return ;
if ( ! p_enabled ) {
2019-08-08 20:11:48 +00: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 09:14:15 +00:00
2017-03-05 15:44:50 +00:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 01:10:30 +00:00
//clean up mess
2018-01-21 11:46:13 +00:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
Node * node = Object : : cast_to < Node > ( obj ) ;
if ( node ) {
2020-02-21 22:26:13 +00:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , callable_mp ( this , & RigidBody2D : : _body_enter_tree ) ) ;
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , callable_mp ( this , & RigidBody2D : : _body_exit_tree ) ) ;
2018-01-21 11:46:13 +00:00
}
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
memdelete ( contact_monitor ) ;
contact_monitor = NULL ;
2014-02-10 01:10:30 +00:00
} else {
2017-03-05 15:44:50 +00:00
contact_monitor = memnew ( ContactMonitor ) ;
contact_monitor - > locked = false ;
2014-02-10 01:10:30 +00:00
}
}
bool RigidBody2D : : is_contact_monitor_enabled ( ) const {
2017-03-05 15:44:50 +00:00
return contact_monitor ! = NULL ;
2014-02-10 01:10:30 +00:00
}
2017-08-05 19:06:15 +00:00
void RigidBody2D : : _notification ( int p_what ) {
# ifdef TOOLS_ENABLED
if ( p_what = = NOTIFICATION_ENTER_TREE ) {
2017-08-18 23:02:56 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 19:06:15 +00:00
set_notify_local_transform ( true ) ; //used for warnings and only in editor
}
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
2017-08-18 23:02:56 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 19:06:15 +00: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-08 22:17:04 +00:00
warning + = " \n \n " ;
2017-08-05 19:06:15 +00:00
}
2018-01-18 20:37:17 +00: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 19:06:15 +00:00
}
return warning ;
}
2014-02-10 01:10:30 +00:00
void RigidBody2D : : _bind_methods ( ) {
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 00:49:37 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-10-24 16:10:30 +00: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 ) ;
2017-03-05 15:44:50 +00: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 21:37:12 +00:00
2017-03-05 15:44:50 +00: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 21:37:12 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_axis_velocity " , " axis_velocity " ) , & RigidBody2D : : set_axis_velocity ) ;
2018-07-24 07:49:12 +00:00
ClassDB : : bind_method ( D_METHOD ( " apply_central_impulse " , " impulse " ) , & RigidBody2D : : apply_central_impulse ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " apply_impulse " , " offset " , " impulse " ) , & RigidBody2D : : apply_impulse ) ;
2018-07-24 07:49:12 +00:00
ClassDB : : bind_method ( D_METHOD ( " apply_torque_impulse " , " torque " ) , & RigidBody2D : : apply_torque_impulse ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00: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-20 23:49:35 +00:00
2017-03-05 15:44:50 +00: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 12:15:15 +00:00
2018-07-24 07:49:12 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_central_force " , " force " ) , & RigidBody2D : : add_central_force ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_force " , " offset " , " force " ) , & RigidBody2D : : add_force ) ;
2018-07-24 07:49:12 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_torque " , " torque " ) , & RigidBody2D : : add_torque ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00: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-19 23:50:55 +00:00
2018-02-21 07:42:36 +00: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 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " _direct_state_changed " ) , & RigidBody2D : : _direct_state_changed ) ;
2014-11-13 03:53:12 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_colliding_bodies " ) , & RigidBody2D : : get_colliding_bodies ) ;
2014-02-10 01:10:30 +00:00
2017-08-29 05:15:46 +00:00
BIND_VMETHOD ( MethodInfo ( " _integrate_forces " , PropertyInfo ( Variant : : OBJECT , " state " , PROPERTY_HINT_RESOURCE_TYPE , " Physics2DDirectBodyState " ) ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " mode " , PROPERTY_HINT_ENUM , " Rigid,Static,Character,Kinematic " ) , " set_mode " , " get_mode " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " mass " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " ) , " set_mass " , " get_mass " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " inertia " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " , 0 ) , " set_inertia " , " get_inertia " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " weight " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " , PROPERTY_USAGE_EDITOR ) , " set_weight " , " get_weight " ) ;
2018-11-08 14:30:02 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " physics_material_override " , PROPERTY_HINT_RESOURCE_TYPE , " PhysicsMaterial " ) , " set_physics_material_override " , " get_physics_material_override " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " gravity_scale " , PROPERTY_HINT_RANGE , " -128,128,0.01 " ) , " set_gravity_scale " , " get_gravity_scale " ) ;
2017-03-05 15:44:50 +00:00
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 21:25:01 +00: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 15:44:50 +00: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 " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " linear_damp " , PROPERTY_HINT_RANGE , " -1,100,0.001,or_greater " ) , " set_linear_damp " , " get_linear_damp " ) ;
2017-03-05 15:44:50 +00:00
ADD_GROUP ( " Angular " , " angular_ " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " angular_velocity " ) , " set_angular_velocity " , " get_angular_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " angular_damp " , PROPERTY_HINT_RANGE , " -1,100,0.001,or_greater " ) , " set_angular_damp " , " get_angular_damp " ) ;
2018-01-11 22:35:12 +00:00
ADD_GROUP ( " Applied Forces " , " applied_ " ) ;
2018-11-08 14:30:02 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " applied_force " ) , " set_applied_force " , " get_applied_force " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " applied_torque " ) , " set_applied_torque " , " get_applied_torque " ) ;
2014-02-10 01:10:30 +00:00
2018-09-01 10:05:51 +00:00
ADD_SIGNAL ( MethodInfo ( " body_shape_entered " , PropertyInfo ( Variant : : INT , " body_id " ) , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) , PropertyInfo ( Variant : : INT , " body_shape " ) , PropertyInfo ( Variant : : INT , " local_shape " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_shape_exited " , PropertyInfo ( Variant : : INT , " body_id " ) , PropertyInfo ( Variant : : OBJECT , " body " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) , PropertyInfo ( Variant : : INT , " body_shape " ) , PropertyInfo ( Variant : : INT , " local_shape " ) ) ) ;
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 15:44:50 +00:00
ADD_SIGNAL ( MethodInfo ( " sleeping_state_changed " ) ) ;
2014-02-19 14:57:14 +00:00
2017-08-20 15:45:01 +00:00
BIND_ENUM_CONSTANT ( MODE_RIGID ) ;
2017-10-21 18:58:02 +00:00
BIND_ENUM_CONSTANT ( MODE_STATIC ) ;
2017-08-20 15:45:01 +00:00
BIND_ENUM_CONSTANT ( MODE_CHARACTER ) ;
2017-10-21 18:58:02 +00:00
BIND_ENUM_CONSTANT ( MODE_KINEMATIC ) ;
2017-08-20 15:45:01 +00:00
BIND_ENUM_CONSTANT ( CCD_MODE_DISABLED ) ;
BIND_ENUM_CONSTANT ( CCD_MODE_CAST_RAY ) ;
BIND_ENUM_CONSTANT ( CCD_MODE_CAST_SHAPE ) ;
2014-02-10 01:10:30 +00:00
}
2017-12-06 20:36:34 +00:00
RigidBody2D : : RigidBody2D ( ) :
2020-03-27 18:21:27 +00:00
PhysicsBody2D ( PhysicsServer2D : : BODY_MODE_RIGID ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
mode = MODE_RIGID ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
mass = 1 ;
2015-01-05 21:37:12 +00:00
2017-03-05 15:44:50 +00:00
gravity_scale = 1 ;
linear_damp = - 1 ;
angular_damp = - 1 ;
2015-01-05 21:37:12 +00:00
2017-03-05 15:44:50 +00:00
max_contacts_reported = 0 ;
state = NULL ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
angular_velocity = 0 ;
sleeping = false ;
ccd_mode = CCD_MODE_DISABLED ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
custom_integrator = false ;
contact_monitor = NULL ;
can_sleep = true ;
2014-02-10 01:10:30 +00:00
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
2014-02-10 01:10:30 +00:00
}
RigidBody2D : : ~ RigidBody2D ( ) {
if ( contact_monitor )
2017-03-05 15:44:50 +00:00
memdelete ( contact_monitor ) ;
2014-02-19 14:57:14 +00:00
}
2017-10-24 16:10:30 +00:00
void RigidBody2D : : _reload_physics_characteristics ( ) {
if ( physics_material_override . is_null ( ) ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_BOUNCE , 0 ) ;
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_FRICTION , 1 ) ;
2017-10-24 16:10:30 +00:00
} else {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_BOUNCE , physics_material_override - > computed_bounce ( ) ) ;
PhysicsServer2D : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer2D : : BODY_PARAM_FRICTION , physics_material_override - > computed_friction ( ) ) ;
2017-10-24 16:10:30 +00:00
}
}
2014-02-19 14:57:14 +00:00
//////////////////////////
2018-07-17 11:57:23 +00: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 15:33:52 +00:00
Collision col ;
2014-02-19 14:57:14 +00:00
2018-07-17 11:57:23 +00:00
if ( move_and_collide ( p_motion , p_infinite_inertia , col , p_exclude_raycast_shapes , p_test_only ) ) {
2017-09-10 16:07:47 +00:00
if ( motion_cache . is_null ( ) ) {
motion_cache . instance ( ) ;
motion_cache - > owner = this ;
}
2014-02-19 14:57:14 +00:00
2017-09-10 16:07:47 +00:00
motion_cache - > collision = col ;
2015-05-04 01:37:10 +00:00
2017-09-10 16:07:47 +00:00
return motion_cache ;
2017-06-24 15:33:52 +00:00
}
2017-09-10 16:07:47 +00:00
return Ref < KinematicCollision2D > ( ) ;
2015-05-04 01:37:10 +00:00
}
2014-02-19 14:57:14 +00:00
2018-07-16 23:04:07 +00:00
bool KinematicBody2D : : separate_raycast_shapes ( bool p_infinite_inertia , Collision & r_collision ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : SeparationResult sep_res [ 8 ] ; //max 8 rays
2018-07-16 23:04:07 +00:00
2018-08-23 19:49:24 +00:00
Transform2D gt = get_global_transform ( ) ;
2018-07-16 23:04:07 +00:00
Vector2 recover ;
2020-03-27 18:21:27 +00:00
int hits = PhysicsServer2D : : get_singleton ( ) - > body_test_ray_separation ( get_rid ( ) , gt , p_infinite_inertia , recover , sep_res , 8 , margin ) ;
2018-07-16 23:04:07 +00:00
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 19:49:24 +00:00
set_global_transform ( gt ) ;
2018-07-16 23:04:07 +00:00
if ( deepest ! = - 1 ) {
r_collision . collider = sep_res [ deepest ] . collider_id ;
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 ;
}
}
2018-07-17 11:57:23 +00: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 ) {
2016-09-01 15:03:55 +00:00
2019-03-04 12:42:00 +00: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 19:49:24 +00:00
Transform2D gt = get_global_transform ( ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : MotionResult result ;
bool colliding = PhysicsServer2D : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , gt , p_motion , p_infinite_inertia , margin , & result , p_exclude_raycast_shapes ) ;
2017-06-24 15:33:52 +00: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 11:57:23 +00:00
r_collision . collider_rid = result . collider ;
2017-06-24 15:33:52 +00:00
r_collision . travel = result . motion ;
r_collision . remainder = result . remainder ;
r_collision . local_shape = result . collision_local_shape ;
2014-02-19 14:57:14 +00:00
}
2018-07-17 11:57:23 +00:00
if ( ! p_test_only ) {
gt . elements [ 2 ] + = result . motion ;
2018-08-23 19:49:24 +00:00
set_global_transform ( gt ) ;
2018-07-17 11:57:23 +00:00
}
2014-02-19 14:57:14 +00:00
2017-06-24 15:33:52 +00:00
return colliding ;
2014-02-19 14:57:14 +00: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 18:36:39 +00:00
//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
2018-08-10 16:06:34 +00:00
# define FLOOR_ANGLE_THRESHOLD 0.01
2020-01-10 13:58:19 +00: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 ) {
2016-08-28 23:57:27 +00:00
2019-11-24 23:10:36 +00:00
Vector2 body_velocity = p_linear_velocity ;
Vector2 body_velocity_normal = body_velocity . normalized ( ) ;
Vector2 current_floor_velocity = floor_velocity ;
2018-07-17 11:57:23 +00:00
if ( on_floor & & on_floor_body . is_valid ( ) ) {
//this approach makes sure there is less delay between the actual body velocity and the one we saved
2020-03-27 18:21:27 +00:00
PhysicsDirectBodyState2D * bs = PhysicsServer2D : : get_singleton ( ) - > body_get_direct_state ( on_floor_body ) ;
2018-07-17 11:57:23 +00:00
if ( bs ) {
2019-11-24 23:10:36 +00:00
current_floor_velocity = bs - > get_linear_velocity ( ) ;
2018-07-17 11:57:23 +00:00
}
}
2018-03-15 12:29:22 +00:00
// Hack in order to work with calling from _process as well as from _physics_process; calling from thread is risky
2019-11-24 23:10:36 +00:00
Vector2 motion = ( current_floor_velocity + body_velocity ) * ( Engine : : get_singleton ( ) - > is_in_physics_frame ( ) ? get_physics_process_delta_time ( ) : get_process_delta_time ( ) ) ;
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
on_floor = false ;
2018-07-17 11:57:23 +00:00
on_floor_body = RID ( ) ;
2017-06-24 15:33:52 +00:00
on_ceiling = false ;
on_wall = false ;
colliders . clear ( ) ;
2020-01-15 07:04:02 +00:00
floor_normal = Vector2 ( ) ;
2017-06-24 15:33:52 +00:00
floor_velocity = Vector2 ( ) ;
2016-08-28 23:57:27 +00:00
2017-09-10 16:07:47 +00:00
while ( p_max_slides ) {
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
Collision collision ;
2018-07-16 23:04:07 +00:00
bool found_collision = false ;
2019-11-24 23:10:36 +00:00
for ( int i = 0 ; i < 2 ; + + i ) {
2018-07-16 23:04:07 +00:00
bool collided ;
if ( i = = 0 ) { //collide
collided = move_and_collide ( motion , p_infinite_inertia , collision ) ;
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-28 23:57:27 +00:00
2018-07-16 23:04:07 +00:00
if ( collided ) {
found_collision = true ;
2016-08-31 20:58:51 +00:00
2018-08-14 17:20:48 +00:00
colliders . push_back ( collision ) ;
2018-07-16 23:04:07 +00:00
motion = collision . remainder ;
2017-11-20 00:42:44 +00:00
2020-01-10 13:58:19 +00:00
if ( p_up_direction = = Vector2 ( ) ) {
2018-07-16 23:04:07 +00:00
//all is a wall
2017-06-24 15:33:52 +00:00
on_wall = true ;
2018-07-16 23:04:07 +00:00
} else {
2020-01-10 13:58:19 +00:00
if ( Math : : acos ( collision . normal . dot ( p_up_direction ) ) < = p_floor_max_angle + FLOOR_ANGLE_THRESHOLD ) { //floor
2018-07-16 23:04:07 +00:00
on_floor = true ;
2020-01-10 13:58:19 +00:00
floor_normal = collision . normal ;
2018-07-17 11:57:23 +00:00
on_floor_body = collision . collider_rid ;
2018-07-16 23:04:07 +00:00
floor_velocity = collision . collider_vel ;
2018-08-14 17:20:48 +00:00
if ( p_stop_on_slope ) {
2020-01-10 13:58:19 +00:00
if ( ( body_velocity_normal + p_up_direction ) . length ( ) < 0.01 & & collision . travel . length ( ) < 1 ) {
2018-08-23 19:49:24 +00:00
Transform2D gt = get_global_transform ( ) ;
2020-01-10 13:58:19 +00:00
gt . elements [ 2 ] - = collision . travel . slide ( p_up_direction ) ;
2018-08-23 19:49:24 +00:00
set_global_transform ( gt ) ;
2018-08-14 17:20:48 +00:00
return Vector2 ( ) ;
}
2018-07-16 23:04:07 +00:00
}
2020-01-10 13:58:19 +00:00
} else if ( Math : : acos ( collision . normal . dot ( - p_up_direction ) ) < = p_floor_max_angle + FLOOR_ANGLE_THRESHOLD ) { //ceiling
2018-07-16 23:04:07 +00:00
on_ceiling = true ;
} else {
on_wall = true ;
}
2016-08-28 23:57:27 +00:00
}
2019-11-24 23:10:36 +00:00
motion = motion . slide ( collision . normal ) ;
body_velocity = body_velocity . slide ( collision . normal ) ;
2018-07-16 23:04:07 +00:00
}
}
2016-08-28 23:57:27 +00:00
2019-11-24 23:10:36 +00:00
if ( ! found_collision | | motion = = Vector2 ( ) )
2016-09-01 15:03:55 +00:00
break ;
2019-11-24 23:10:36 +00:00
- - p_max_slides ;
2016-08-28 23:57:27 +00:00
}
2019-11-24 23:10:36 +00:00
return body_velocity ;
2018-07-17 00:30:44 +00:00
}
2018-07-16 23:04:07 +00:00
2020-01-10 13:58:19 +00: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 ) {
2018-07-17 11:57:23 +00:00
bool was_on_floor = on_floor ;
2020-01-10 13:58:19 +00:00
Vector2 ret = move_and_slide ( p_linear_velocity , p_up_direction , p_stop_on_slope , p_max_slides , p_floor_max_angle , p_infinite_inertia ) ;
2018-07-17 11:57:23 +00:00
if ( ! was_on_floor | | p_snap = = Vector2 ( ) ) {
return ret ;
}
2018-07-16 23:04:07 +00:00
2018-07-17 11:57:23 +00:00
Collision col ;
2018-08-23 19:49:24 +00:00
Transform2D gt = get_global_transform ( ) ;
2018-07-17 11:57:23 +00:00
if ( move_and_collide ( p_snap , p_infinite_inertia , col , false , true ) ) {
2019-02-16 18:49:55 +00:00
bool apply = true ;
2020-01-10 13:58:19 +00:00
if ( p_up_direction ! = Vector2 ( ) ) {
if ( Math : : acos ( p_up_direction . normalized ( ) . dot ( col . normal ) ) < p_floor_max_angle ) {
2019-02-16 18:49:55 +00:00
on_floor = true ;
2020-01-10 13:58:19 +00:00
floor_normal = col . normal ;
2019-02-16 18:49:55 +00:00
on_floor_body = col . collider_rid ;
floor_velocity = col . collider_vel ;
2019-02-23 13:23:38 +00:00
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.
2020-01-10 13:58:19 +00:00
col . travel = p_up_direction * p_up_direction . dot ( col . travel ) ;
2019-02-23 13:23:38 +00:00
}
2019-02-16 18:49:55 +00:00
} else {
apply = false ;
}
}
if ( apply ) {
gt . elements [ 2 ] + = col . travel ;
set_global_transform ( gt ) ;
2018-07-17 00:30:44 +00:00
}
2018-07-16 23:04:07 +00:00
}
2018-07-17 11:57:23 +00:00
return ret ;
2016-08-28 23:57:27 +00:00
}
2017-06-24 15:33:52 +00:00
bool KinematicBody2D : : is_on_floor ( ) const {
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
return on_floor ;
2016-08-28 23:57:27 +00:00
}
2017-06-24 15:33:52 +00:00
bool KinematicBody2D : : is_on_wall ( ) const {
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
return on_wall ;
2016-08-28 23:57:27 +00:00
}
2017-06-24 15:33:52 +00:00
bool KinematicBody2D : : is_on_ceiling ( ) const {
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
return on_ceiling ;
2016-08-28 23:57:27 +00:00
}
2020-01-10 13:58:19 +00:00
Vector2 KinematicBody2D : : get_floor_normal ( ) const {
return floor_normal ;
}
2017-06-24 15:33:52 +00:00
Vector2 KinematicBody2D : : get_floor_velocity ( ) const {
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
return floor_velocity ;
2014-02-19 14:57:14 +00:00
}
2018-02-16 18:06:00 +00:00
bool KinematicBody2D : : test_move ( const Transform2D & p_from , const Vector2 & p_motion , bool p_infinite_inertia ) {
2014-02-19 14:57:14 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , false ) ;
2014-02-19 14:57:14 +00:00
2020-03-27 18:21:27 +00:00
return PhysicsServer2D : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_from , p_motion , p_infinite_inertia , margin ) ;
2014-02-19 14:57:14 +00:00
}
2017-06-24 15:33:52 +00:00
void KinematicBody2D : : set_safe_margin ( float p_margin ) {
2014-02-19 14:57:14 +00:00
2017-06-24 15:33:52 +00:00
margin = p_margin ;
2014-02-19 14:57:14 +00:00
}
2015-04-19 23:50:55 +00:00
2017-06-24 15:33:52 +00:00
float KinematicBody2D : : get_safe_margin ( ) const {
2014-02-19 14:57:14 +00:00
2017-06-24 15:33:52 +00:00
return margin ;
2014-02-19 14:57:14 +00:00
}
2014-02-22 23:28:19 +00:00
2017-09-10 16:07:47 +00:00
int KinematicBody2D : : get_slide_count ( ) const {
2014-02-22 23:28:19 +00:00
2017-06-24 15:33:52 +00:00
return colliders . size ( ) ;
2014-02-22 23:28:19 +00:00
}
2014-02-19 14:57:14 +00:00
2017-09-10 16:07:47 +00: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 04:01:25 +00:00
}
2014-10-16 03:06:34 +00:00
2017-09-10 16:07:47 +00:00
Ref < KinematicCollision2D > KinematicBody2D : : _get_slide_collision ( int p_bounce ) {
2014-02-19 14:57:14 +00:00
2017-09-10 16:07:47 +00:00
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 15:33:52 +00:00
}
2014-02-19 14:57:14 +00:00
2017-09-10 16:07:47 +00:00
if ( slide_colliders [ p_bounce ] . is_null ( ) ) {
2018-07-25 01:11:03 +00:00
slide_colliders . write [ p_bounce ] . instance ( ) ;
slide_colliders . write [ p_bounce ] - > owner = this ;
2017-06-24 15:33:52 +00:00
}
2014-02-19 14:57:14 +00:00
2018-07-25 01:11:03 +00:00
slide_colliders . write [ p_bounce ] - > collision = colliders [ p_bounce ] ;
2017-09-10 16:07:47 +00:00
return slide_colliders [ p_bounce ] ;
2014-02-19 14:57:14 +00:00
}
2018-07-17 11:57:23 +00: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 01:22:43 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) )
return ;
2018-07-17 11:57:23 +00:00
if ( p_enable ) {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
2018-07-17 11:57:23 +00:00
set_only_update_transform_changes ( true ) ;
set_notify_local_transform ( true ) ;
} else {
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , NULL , " " ) ;
2018-07-17 11:57:23 +00: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 ) {
if ( ! sync_to_physics )
return ;
2020-03-27 18:21:27 +00:00
PhysicsDirectBodyState2D * state = Object : : cast_to < PhysicsDirectBodyState2D > ( p_state ) ;
2018-07-17 11:57:23 +00:00
last_valid_transform = state - > get_transform ( ) ;
set_notify_local_transform ( false ) ;
2018-08-23 19:49:24 +00:00
set_global_transform ( last_valid_transform ) ;
2018-07-17 11:57:23 +00:00
set_notify_local_transform ( true ) ;
}
void KinematicBody2D : : _notification ( int p_what ) {
if ( p_what = = NOTIFICATION_ENTER_TREE ) {
2018-08-23 19:49:24 +00:00
last_valid_transform = get_global_transform ( ) ;
2019-08-19 09:11:14 +00: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 11:57:23 +00:00
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
//used by sync to physics, send the new transform to the physics
2018-08-23 19:49:24 +00:00
Transform2D new_transform = get_global_transform ( ) ;
2020-03-27 18:21:27 +00:00
PhysicsServer2D : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer2D : : BODY_STATE_TRANSFORM , new_transform ) ;
2018-07-17 11:57:23 +00:00
//but then revert changes
set_notify_local_transform ( false ) ;
2018-08-23 19:49:24 +00:00
set_global_transform ( last_valid_transform ) ;
2018-07-17 11:57:23 +00:00
set_notify_local_transform ( true ) ;
}
}
2014-02-19 14:57:14 +00:00
void KinematicBody2D : : _bind_methods ( ) {
2018-07-17 11:57:23 +00: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 07:04:02 +00: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 14:57:14 +00:00
2018-10-17 08:22:48 +00:00
ClassDB : : bind_method ( D_METHOD ( " test_move " , " from " , " rel_vec " , " infinite_inertia " ) , & KinematicBody2D : : test_move , DEFVAL ( true ) ) ;
2014-02-19 14:57:14 +00:00
2017-06-24 15:33:52 +00: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 13:58:19 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_floor_normal " ) , & KinematicBody2D : : get_floor_normal ) ;
2017-06-24 15:33:52 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_floor_velocity " ) , & KinematicBody2D : : get_floor_velocity ) ;
2014-02-19 14:57:14 +00:00
2017-06-24 15:33:52 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_safe_margin " , " pixels " ) , & KinematicBody2D : : set_safe_margin ) ;
2017-08-09 11:54:55 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_safe_margin " ) , & KinematicBody2D : : get_safe_margin ) ;
2014-02-19 14:57:14 +00:00
2017-09-10 16:07:47 +00: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 ) ;
2014-02-19 14:57:14 +00:00
2018-07-17 11:57:23 +00: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 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " collision/safe_margin " , PROPERTY_HINT_RANGE , " 0.001,256,0.001 " ) , " set_safe_margin " , " get_safe_margin " ) ;
2018-07-17 11:57:23 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " motion/sync_to_physics " ) , " set_sync_to_physics " , " is_sync_to_physics_enabled " ) ;
2014-02-19 14:57:14 +00:00
}
2017-12-06 20:36:34 +00:00
KinematicBody2D : : KinematicBody2D ( ) :
2020-03-27 18:21:27 +00:00
PhysicsBody2D ( PhysicsServer2D : : BODY_MODE_KINEMATIC ) {
2014-02-19 14:57:14 +00:00
2017-03-05 15:44:50 +00:00
margin = 0.08 ;
2016-08-28 23:57:27 +00:00
2017-06-24 15:33:52 +00:00
on_floor = false ;
on_ceiling = false ;
on_wall = false ;
2018-07-17 11:57:23 +00:00
sync_to_physics = false ;
2014-02-19 14:57:14 +00:00
}
2017-03-05 15:44:50 +00:00
KinematicBody2D : : ~ KinematicBody2D ( ) {
2017-09-10 16:07:47 +00:00
if ( motion_cache . is_valid ( ) ) {
motion_cache - > owner = NULL ;
}
for ( int i = 0 ; i < slide_colliders . size ( ) ; i + + ) {
if ( slide_colliders [ i ] . is_valid ( ) ) {
2018-07-25 01:11:03 +00:00
slide_colliders . write [ i ] - > owner = NULL ;
2017-09-10 16:07:47 +00: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 ;
}
Object * KinematicCollision2D : : get_local_shape ( ) const {
2019-06-01 13:42:22 +00:00
if ( ! owner ) return NULL ;
2017-09-10 16:07:47 +00:00
uint32_t ownerid = owner - > shape_find_owner ( collision . local_shape ) ;
return owner - > shape_owner_get_owner ( ownerid ) ;
}
Object * KinematicCollision2D : : get_collider ( ) const {
2020-02-12 17:24:06 +00:00
if ( collision . collider . is_valid ( ) ) {
2017-09-10 16:07:47 +00:00
return ObjectDB : : get_instance ( collision . collider ) ;
}
return NULL ;
}
ObjectID KinematicCollision2D : : get_collider_id ( ) const {
return collision . collider ;
}
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 ) ;
}
}
return NULL ;
}
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 ) ;
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 ) ;
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 " ) ;
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 ( ) {
2020-02-12 17:24:06 +00:00
2017-09-10 16:07:47 +00:00
collision . collider_shape = 0 ;
collision . local_shape = 0 ;
owner = NULL ;
2014-02-10 01:10:30 +00:00
}