2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* physics_body_2d.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 14:11:45 +02:00
/* https://godotengine.org */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
2019-06-04 11:41:49 +02:00
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2019 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. */
/*************************************************************************/
# include "physics_body_2d.h"
# include "scene/scene_string_names.h"
2017-03-19 00:36:26 +01:00
bool PhysicsBody2D : : motion_fix_enabled = false ;
2017-03-06 05:08:12 +01:00
2014-02-10 02:10:30 +01:00
void PhysicsBody2D : : _notification ( int p_what ) {
2017-03-19 00:36:26 +01:00
/*
2014-02-10 02:10:30 +01:00
switch ( p_what ) {
case NOTIFICATION_TRANSFORM_CHANGED : {
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_TRANSFORM , get_global_transform ( ) ) ;
} break ;
}
*/
}
2017-03-19 00:36:26 +01:00
void PhysicsBody2D : : set_one_way_collision_direction ( const Vector2 & p_dir ) {
2015-01-13 14:49:26 +01:00
2017-03-19 00:36:26 +01:00
one_way_collision_direction = p_dir ;
Physics2DServer : : get_singleton ( ) - > body_set_one_way_collision_direction ( get_rid ( ) , p_dir ) ;
2015-01-13 14:49:26 +01:00
}
2017-03-19 00:36:26 +01:00
Vector2 PhysicsBody2D : : get_one_way_collision_direction ( ) const {
2015-01-13 14:49:26 +01:00
return one_way_collision_direction ;
}
2015-01-14 01:19:11 +01:00
void PhysicsBody2D : : set_one_way_collision_max_depth ( float p_depth ) {
2017-03-19 00:36:26 +01:00
one_way_collision_max_depth = p_depth ;
Physics2DServer : : get_singleton ( ) - > body_set_one_way_collision_max_depth ( get_rid ( ) , p_depth ) ;
2015-01-14 01:19:11 +01:00
}
2017-03-19 00:36:26 +01:00
float PhysicsBody2D : : get_one_way_collision_max_depth ( ) const {
2015-01-14 01:19:11 +01:00
return one_way_collision_max_depth ;
}
2015-05-10 20:58:08 +02:00
void PhysicsBody2D : : _set_layers ( uint32_t p_mask ) {
set_layer_mask ( p_mask ) ;
set_collision_mask ( p_mask ) ;
}
2017-03-19 00:36:26 +01:00
uint32_t PhysicsBody2D : : _get_layers ( ) const {
2015-05-10 20:58:08 +02:00
return get_layer_mask ( ) ;
}
2014-05-14 06:22:15 +02:00
void PhysicsBody2D : : _bind_methods ( ) {
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_layer_mask " , " mask " ) , & PhysicsBody2D : : set_layer_mask ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_layer_mask " ) , & PhysicsBody2D : : get_layer_mask ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_collision_mask " , " mask " ) , & PhysicsBody2D : : set_collision_mask ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collision_mask " ) , & PhysicsBody2D : : get_collision_mask ) ;
2015-06-06 14:44:38 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_collision_mask_bit " , " bit " , " value " ) , & PhysicsBody2D : : set_collision_mask_bit ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collision_mask_bit " , " bit " ) , & PhysicsBody2D : : get_collision_mask_bit ) ;
2015-06-06 14:44:38 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_layer_mask_bit " , " bit " , " value " ) , & PhysicsBody2D : : set_layer_mask_bit ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_layer_mask_bit " , " bit " ) , & PhysicsBody2D : : get_layer_mask_bit ) ;
2015-06-06 14:44:38 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " _set_layers " , " mask " ) , & PhysicsBody2D : : _set_layers ) ;
ObjectTypeDB : : bind_method ( _MD ( " _get_layers " ) , & PhysicsBody2D : : _get_layers ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_one_way_collision_direction " , " dir " ) , & PhysicsBody2D : : set_one_way_collision_direction ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_one_way_collision_direction " ) , & PhysicsBody2D : : get_one_way_collision_direction ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_one_way_collision_max_depth " , " depth " ) , & PhysicsBody2D : : set_one_way_collision_max_depth ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_one_way_collision_max_depth " ) , & PhysicsBody2D : : get_one_way_collision_max_depth ) ;
ObjectTypeDB : : bind_method ( _MD ( " add_collision_exception_with " , " body:PhysicsBody2D " ) , & PhysicsBody2D : : add_collision_exception_with ) ;
ObjectTypeDB : : bind_method ( _MD ( " remove_collision_exception_with " , " body:PhysicsBody2D " ) , & PhysicsBody2D : : remove_collision_exception_with ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " layers " , PROPERTY_HINT_ALL_FLAGS , " " , 0 ) , _SCS ( " _set_layers " ) , _SCS ( " _get_layers " ) ) ; //for backwards compat
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision/layers " , PROPERTY_HINT_ALL_FLAGS ) , _SCS ( " set_layer_mask " ) , _SCS ( " get_layer_mask " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision/mask " , PROPERTY_HINT_ALL_FLAGS ) , _SCS ( " set_collision_mask " ) , _SCS ( " get_collision_mask " ) ) ;
ADD_PROPERTYNZ ( PropertyInfo ( Variant : : VECTOR2 , " one_way_collision/direction " ) , _SCS ( " set_one_way_collision_direction " ) , _SCS ( " get_one_way_collision_direction " ) ) ;
ADD_PROPERTYNZ ( PropertyInfo ( Variant : : REAL , " one_way_collision/max_depth " ) , _SCS ( " set_one_way_collision_max_depth " ) , _SCS ( " get_one_way_collision_max_depth " ) ) ;
2014-05-14 06:22:15 +02:00
}
void PhysicsBody2D : : set_layer_mask ( uint32_t p_mask ) {
2017-03-19 00:36:26 +01:00
mask = p_mask ;
Physics2DServer : : get_singleton ( ) - > body_set_layer_mask ( get_rid ( ) , p_mask ) ;
2014-05-14 06:22:15 +02:00
}
uint32_t PhysicsBody2D : : get_layer_mask ( ) const {
2014-02-10 02:10:30 +01:00
2014-05-14 06:22:15 +02:00
return mask ;
}
2015-05-03 21:47:21 +02:00
void PhysicsBody2D : : set_collision_mask ( uint32_t p_mask ) {
2017-03-19 00:36:26 +01:00
collision_mask = p_mask ;
Physics2DServer : : get_singleton ( ) - > body_set_collision_mask ( get_rid ( ) , p_mask ) ;
2015-05-03 21:47:21 +02:00
}
uint32_t PhysicsBody2D : : get_collision_mask ( ) const {
return collision_mask ;
}
2015-06-06 14:44:38 +02:00
void PhysicsBody2D : : set_collision_mask_bit ( int p_bit , bool p_value ) {
uint32_t mask = get_collision_mask ( ) ;
if ( p_value )
2017-03-19 00:36:26 +01:00
mask | = 1 < < p_bit ;
2015-06-06 14:44:38 +02:00
else
2017-03-19 00:36:26 +01:00
mask & = ~ ( 1 < < p_bit ) ;
2015-06-06 14:44:38 +02:00
set_collision_mask ( mask ) ;
}
2017-03-19 00:36:26 +01:00
bool PhysicsBody2D : : get_collision_mask_bit ( int p_bit ) const {
2015-06-06 14:44:38 +02:00
2017-03-19 00:36:26 +01:00
return get_collision_mask ( ) & ( 1 < < p_bit ) ;
2015-06-06 14:44:38 +02:00
}
void PhysicsBody2D : : set_layer_mask_bit ( int p_bit , bool p_value ) {
uint32_t mask = get_layer_mask ( ) ;
if ( p_value )
2017-03-19 00:36:26 +01:00
mask | = 1 < < p_bit ;
2015-06-06 14:44:38 +02:00
else
2017-03-19 00:36:26 +01:00
mask & = ~ ( 1 < < p_bit ) ;
2015-06-06 14:44:38 +02:00
set_layer_mask ( mask ) ;
}
2017-03-19 00:36:26 +01:00
bool PhysicsBody2D : : get_layer_mask_bit ( int p_bit ) const {
2015-06-06 14:44:38 +02:00
2017-03-19 00:36:26 +01:00
return get_layer_mask ( ) & ( 1 < < p_bit ) ;
2015-06-06 14:44:38 +02:00
}
2015-05-03 21:47:21 +02:00
2017-12-11 15:31:49 +01:00
PhysicsBody2D : : PhysicsBody2D ( Physics2DServer : : BodyMode p_mode ) :
CollisionObject2D ( Physics2DServer : : get_singleton ( ) - > body_create ( p_mode ) , false ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
mask = 1 ;
collision_mask = 1 ;
2015-01-14 01:19:11 +01:00
set_one_way_collision_max_depth ( 0 ) ;
2015-03-22 05:46:18 +01:00
set_pickable ( false ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
void PhysicsBody2D : : add_collision_exception_with ( Node * p_node ) {
2014-09-22 05:50:48 +02:00
ERR_FAIL_NULL ( p_node ) ;
PhysicsBody2D * physics_body = p_node - > cast_to < PhysicsBody2D > ( ) ;
if ( ! physics_body ) {
ERR_EXPLAIN ( " Collision exception only works between two objects of PhysicsBody type " ) ;
}
ERR_FAIL_COND ( ! physics_body ) ;
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
void PhysicsBody2D : : remove_collision_exception_with ( Node * p_node ) {
2014-09-22 05:50:48 +02:00
ERR_FAIL_NULL ( p_node ) ;
PhysicsBody2D * physics_body = p_node - > cast_to < PhysicsBody2D > ( ) ;
if ( ! physics_body ) {
ERR_EXPLAIN ( " Collision exception only works between two objects of PhysicsBody type " ) ;
}
ERR_FAIL_COND ( ! physics_body ) ;
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
void StaticBody2D : : set_constant_linear_velocity ( const Vector2 & p_vel ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
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-19 00:36:26 +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 ;
}
2014-02-19 15:57:14 +01:00
#if 0
2014-02-10 02:10:30 +01:00
void StaticBody2D : : _update_xform ( ) {
if ( ! pre_xform | | ! pending )
return ;
setting = true ;
Matrix32 new_xform = get_global_transform ( ) ; //obtain the new one
set_block_transform_notify ( true ) ;
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_TRANSFORM , * pre_xform ) ; //then simulate motion!
set_global_transform ( * pre_xform ) ; //but restore state to previous one in both visual and physics
set_block_transform_notify ( false ) ;
Physics2DServer : : get_singleton ( ) - > body_static_simulate_motion ( get_rid ( ) , new_xform ) ; //then simulate motion!
setting = false ;
pending = false ;
}
2014-02-19 15:57:14 +01:00
# endif
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
void StaticBody2D : : set_friction ( real_t p_friction ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND ( p_friction < 0 | | p_friction > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
friction = p_friction ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t StaticBody2D : : get_friction ( ) const {
2014-02-10 02:10:30 +01:00
return friction ;
}
2017-03-19 00:36:26 +01:00
void StaticBody2D : : set_bounce ( real_t p_bounce ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
bounce = p_bounce ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t StaticBody2D : : get_bounce ( ) const {
2014-02-10 02:10:30 +01:00
return bounce ;
}
void StaticBody2D : : _bind_methods ( ) {
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_constant_linear_velocity " , " vel " ) , & StaticBody2D : : set_constant_linear_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_constant_angular_velocity " , " vel " ) , & StaticBody2D : : set_constant_angular_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_constant_linear_velocity " ) , & StaticBody2D : : get_constant_linear_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_constant_angular_velocity " ) , & StaticBody2D : : get_constant_angular_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_friction " , " friction " ) , & StaticBody2D : : set_friction ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_friction " ) , & StaticBody2D : : get_friction ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_bounce " , " bounce " ) , & StaticBody2D : : set_bounce ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_bounce " ) , & StaticBody2D : : get_bounce ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " constant_linear_velocity " ) , _SCS ( " set_constant_linear_velocity " ) , _SCS ( " get_constant_linear_velocity " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " constant_angular_velocity " ) , _SCS ( " set_constant_angular_velocity " ) , _SCS ( " get_constant_angular_velocity " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , _SCS ( " set_friction " ) , _SCS ( " get_friction " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , _SCS ( " set_bounce " ) , _SCS ( " get_bounce " ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-11 15:31:49 +01:00
StaticBody2D : : StaticBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_STATIC ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
constant_angular_velocity = 0 ;
bounce = 0 ;
friction = 1 ;
2014-02-10 02:10:30 +01:00
}
StaticBody2D : : ~ StaticBody2D ( ) {
}
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 ) ;
Node * node = obj ? obj - > cast_to < Node > ( ) : NULL ;
ERR_FAIL_COND ( ! node ) ;
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2017-03-19 00:36:26 +01:00
E - > get ( ) . in_scene = true ;
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_enter , node ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2016-01-12 10:14:15 +01:00
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_enter_shape , p_id , node , E - > get ( ) . shapes [ i ] . body_shape , E - > get ( ) . shapes [ i ] . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +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 ) ;
Node * node = obj ? obj - > cast_to < Node > ( ) : NULL ;
ERR_FAIL_COND ( ! node ) ;
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
E - > get ( ) . in_scene = false ;
2016-01-12 10:14:15 +01:00
2017-03-19 00:36:26 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exit , node ) ;
2016-01-12 10:14:15 +01:00
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exit_shape , p_id , 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-19 00:36:26 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : _body_inout ( int p_status , ObjectID p_instance , int p_body_shape , int p_local_shape ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +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 ) ;
Node * node = obj ? obj - > cast_to < Node > ( ) : NULL ;
2017-03-19 00:36:26 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( objid ) ;
2014-02-10 02:10:30 +01:00
2015-04-26 22:46:20 +02:00
/*if (obj) {
if ( body_in )
print_line ( " in: " + String ( obj - > call ( " get_name " ) ) ) ;
else
print_line ( " out: " + String ( obj - > call ( " get_name " ) ) ) ;
} */
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! body_in & & ! E ) ;
if ( body_in ) {
if ( ! E ) {
2017-03-19 00:36:26 +01:00
E = contact_monitor - > body_map . insert ( objid , BodyState ( ) ) ;
// E->get().rc=0;
E - > get ( ) . in_scene = node & & node - > is_inside_tree ( ) ;
2014-02-10 02:10:30 +01:00
if ( node ) {
2017-03-19 00:36:26 +01:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > enter_tree , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree , make_binds ( objid ) ) ;
node - > connect ( SceneStringNames : : get_singleton ( ) - > exit_tree , 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-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_enter , 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
2014-02-10 02:10:30 +01:00
if ( node )
2017-03-19 00:36:26 +01:00
E - > get ( ) . shapes . insert ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2014-02-10 02:10:30 +01:00
if ( E - > get ( ) . in_scene ) {
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_enter_shape , objid , 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
if ( node )
2017-03-19 00:36:26 +01:00
E - > get ( ) . shapes . erase ( ShapePair ( p_body_shape , p_local_shape ) ) ;
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-19 00:36:26 +01:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > enter_tree , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree ) ;
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > exit_tree , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree ) ;
2014-10-03 13:58:41 +02:00
if ( in_scene )
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exit , obj ) ;
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 ) {
2017-03-19 00:36:26 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exit_shape , objid , obj , p_body_shape , p_local_shape ) ;
2014-02-10 02:10:30 +01:00
}
}
}
struct _RigidBody2DInOut {
ObjectID id ;
int shape ;
int local_shape ;
} ;
2017-03-19 00:36:26 +01:00
bool RigidBody2D : : _test_motion ( const Vector2 & p_motion , float p_margin , const Ref < Physics2DTestMotionResult > & p_result ) {
2015-04-20 01:50:55 +02:00
2017-03-19 00:36:26 +01:00
Physics2DServer : : MotionResult * r = NULL ;
2015-04-20 01:50:55 +02:00
if ( p_result . is_valid ( ) )
2017-03-19 00:36:26 +01:00
r = p_result - > get_result_ptr ( ) ;
2017-03-06 05:08:12 +01:00
if ( motion_fix_enabled ) {
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_test_motion_from ( get_rid ( ) , get_global_transform ( ) , p_motion , p_margin , r ) ;
2017-03-06 05:08:12 +01:00
} else {
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_motion , p_margin , r ) ;
2017-03-06 05:08:12 +01: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-03-19 00:36:26 +01:00
//eh.. fuck
2014-02-10 02:10:30 +01:00
# ifdef DEBUG_ENABLED
2017-03-19 00:36:26 +01:00
state = p_state - > cast_to < Physics2DDirectBodyState > ( ) ;
2014-02-10 02:10:30 +01:00
# else
2017-03-19 00:36:26 +01:00
state = ( Physics2DDirectBodyState * ) p_state ; //trust it
2014-02-10 02:10:30 +01:00
# endif
2016-06-17 21:45:10 +02:00
set_block_transform_notify ( true ) ; // don't want notify (would feedback loop)
2017-03-19 00:36:26 +01:00
if ( mode ! = MODE_KINEMATIC )
2016-06-17 21:45:10 +02:00
set_global_transform ( state - > get_transform ( ) ) ;
2017-03-19 00:36:26 +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 ) ;
}
if ( get_script_instance ( ) )
2017-03-19 00:36:26 +01:00
get_script_instance ( ) - > call ( " _integrate_forces " , state ) ;
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-19 00:36:26 +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-19 00:36:26 +01:00
int rc = 0 ;
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
E - > get ( ) . shapes [ i ] . tagged = false ;
2014-02-10 02:10:30 +01:00
rc + + ;
}
}
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
for ( int i = 0 ; i < state - > get_contact_count ( ) ; 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-03-19 00:36:26 +01:00
// bool found=false;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( obj ) ;
2014-02-10 02:10:30 +01:00
if ( ! E ) {
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
ShapePair sp ( shape , local_shape ) ;
2014-02-10 02:10:30 +01:00
int idx = E - > get ( ) . shapes . find ( sp ) ;
2017-03-19 00:36:26 +01:00
if ( idx = = - 1 ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
E - > get ( ) . shapes [ idx ] . tagged = true ;
2014-02-10 02:10:30 +01:00
}
//put the ones to remove
2017-03-19 00:36:26 +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
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
if ( ! E - > get ( ) . shapes [ i ] . tagged ) {
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
for ( int i = 0 ; i < toremove_count ; i + + ) {
2014-10-03 13:58:41 +02:00
2017-03-19 00:36:26 +01:00
_body_inout ( 0 , 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-19 00:36:26 +01:00
for ( int i = 0 ; i < toadd_count ; i + + ) {
2014-10-03 13:58:41 +02:00
2017-03-19 00:36:26 +01:00
_body_inout ( 1 , toadd [ i ] . id , toadd [ i ] . shape , toadd [ i ] . local_shape ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
state = NULL ;
2014-02-10 02:10:30 +01:00
}
void RigidBody2D : : set_mode ( Mode p_mode ) {
2017-03-19 00:36:26 +01:00
mode = p_mode ;
switch ( p_mode ) {
2014-02-10 02:10:30 +01:00
case MODE_RIGID : {
2017-03-19 00:36:26 +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-19 00:36:26 +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 : {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +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-19 00:36:26 +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-19 00:36:26 +01:00
RigidBody2D : : Mode RigidBody2D : : get_mode ( ) const {
2014-02-10 02:10:30 +01:00
return mode ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_mass ( real_t p_mass ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
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-19 00:36:26 +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-19 00:36:26 +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 ) {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND ( p_inertia < = 0 ) ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_INERTIA , p_inertia ) ;
2016-04-26 14:15:15 +02:00
}
2017-03-19 00:36:26 +01:00
real_t RigidBody2D : : get_inertia ( ) const {
2016-04-21 02:49:37 +02:00
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_get_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_INERTIA ) ;
2016-04-21 02:49:37 +02:00
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_weight ( real_t p_weight ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
set_mass ( p_weight / 9.8 ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t RigidBody2D : : get_weight ( ) const {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
return mass * 9.8 ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_friction ( real_t p_friction ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND ( p_friction < 0 | | p_friction > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
friction = p_friction ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_FRICTION , friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t RigidBody2D : : get_friction ( ) const {
2014-02-10 02:10:30 +01:00
return friction ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_bounce ( real_t p_bounce ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
bounce = p_bounce ;
Physics2DServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , Physics2DServer : : BODY_PARAM_BOUNCE , bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t RigidBody2D : : get_bounce ( ) const {
2014-02-10 02:10:30 +01:00
return bounce ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_gravity_scale ( real_t p_gravity_scale ) {
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
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-19 00:36:26 +01:00
real_t RigidBody2D : : get_gravity_scale ( ) const {
2015-01-05 22:37:12 +01:00
return gravity_scale ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_linear_damp ( real_t p_linear_damp ) {
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
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-19 00:36:26 +01:00
real_t RigidBody2D : : get_linear_damp ( ) const {
2015-01-05 22:37:12 +01:00
return linear_damp ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_angular_damp ( real_t p_angular_damp ) {
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
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-19 00:36:26 +01:00
real_t RigidBody2D : : get_angular_damp ( ) const {
2015-01-05 22:37:12 +01:00
return angular_damp ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_axis_velocity ( const Vector2 & p_axis ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
Vector2 v = state ? state - > get_linear_velocity ( ) : linear_velocity ;
2014-02-10 02:10:30 +01:00
Vector2 axis = p_axis . normalized ( ) ;
2017-03-19 00:36:26 +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-19 00:36:26 +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-19 00:36:26 +01:00
void RigidBody2D : : set_linear_velocity ( const Vector2 & p_velocity ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
linear_velocity = p_velocity ;
2014-02-10 02:10:30 +01:00
if ( state )
state - > set_linear_velocity ( linear_velocity ) ;
else {
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
Vector2 RigidBody2D : : get_linear_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return linear_velocity ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_angular_velocity ( real_t p_velocity ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
angular_velocity = p_velocity ;
2014-02-10 02:10:30 +01:00
if ( state )
state - > set_angular_velocity ( angular_velocity ) ;
else
2017-03-19 00:36:26 +01:00
Physics2DServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , Physics2DServer : : BODY_STATE_ANGULAR_VELOCITY , angular_velocity ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +01:00
real_t RigidBody2D : : get_angular_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return angular_velocity ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : set_use_custom_integrator ( bool p_enable ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
if ( custom_integrator = = p_enable )
2014-02-10 02:10:30 +01:00
return ;
2017-03-19 00:36:26 +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-19 00:36:26 +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 ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +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-19 00:36:26 +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 {
2014-02-10 02:10:30 +01:00
2014-09-22 05:50:48 +02:00
return sleeping ;
2014-02-10 02:10:30 +01:00
}
void RigidBody2D : : set_max_contacts_reported ( int p_amount ) {
2017-03-19 00:36:26 +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-19 00:36:26 +01:00
int RigidBody2D : : get_max_contacts_reported ( ) const {
2014-02-10 02:10:30 +01:00
return max_contacts_reported ;
}
2017-03-19 00:36:26 +01:00
void RigidBody2D : : apply_impulse ( const Vector2 & p_offset , const Vector2 & p_impulse ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
Physics2DServer : : get_singleton ( ) - > body_apply_impulse ( get_rid ( ) , p_offset , p_impulse ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-19 00:36:26 +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 ( ) ) ;
} ;
2017-03-19 00:36:26 +01:00
void RigidBody2D : : add_force ( const Vector2 & p_offset , const Vector2 & p_force ) {
2016-04-26 14:15:15 +02:00
2017-03-19 00:36:26 +01:00
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
2014-02-19 15:57:14 +01:00
void RigidBody2D : : set_continuous_collision_detection_mode ( CCDMode p_mode ) {
2017-03-19 00:36:26 +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 {
2014-02-10 02:10:30 +01:00
2014-02-19 15:57:14 +01:00
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-19 00:36:26 +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-19 00:36:26 +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-19 00:36:26 +01:00
ret . resize ( ret . size ( ) - 1 ) ; //ops
2014-11-13 04:53:12 +01:00
} else {
2017-03-19 00:36:26 +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 ) {
2017-03-19 00:36:26 +01:00
if ( p_enabled = = is_contact_monitor_enabled ( ) )
2014-02-10 02:10:30 +01:00
return ;
if ( ! p_enabled ) {
2016-01-12 10:14:15 +01:00
if ( contact_monitor - > locked ) {
ERR_EXPLAIN ( " Can't disable contact monitoring during in/out callback. Use call_deferred( \" set_contact_monitor \" ,false) instead " ) ;
}
ERR_FAIL_COND ( contact_monitor - > locked ) ;
2017-03-19 00:36:26 +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
}
2017-03-19 00:36:26 +01:00
memdelete ( contact_monitor ) ;
contact_monitor = NULL ;
2014-02-10 02:10:30 +01:00
} else {
2017-03-19 00:36:26 +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 {
2017-03-19 00:36:26 +01:00
return contact_monitor ! = NULL ;
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 ) {
if ( get_tree ( ) - > is_editor_hint ( ) ) {
set_notify_local_transform ( true ) ; //used for warnings and only in editor
}
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
if ( get_tree ( ) - > is_editor_hint ( ) ) {
update_configuration_warning ( ) ;
}
}
# endif
}
String RigidBody2D : : get_configuration_warning ( ) const {
Matrix32 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 ( ) ) {
warning + = " \n " ;
}
warning + = TTR ( " Size changes to RigidBody2D (in character or rigid modes) will be overriden by the physics engine when running. \n Change the size in children collision shapes instead. " ) ;
}
return warning ;
}
2014-02-10 02:10:30 +01:00
void RigidBody2D : : _bind_methods ( ) {
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_mode " , " mode " ) , & RigidBody2D : : set_mode ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_mode " ) , & RigidBody2D : : get_mode ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_mass " , " mass " ) , & RigidBody2D : : set_mass ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_mass " ) , & RigidBody2D : : get_mass ) ;
2016-04-21 02:49:37 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_inertia " ) , & RigidBody2D : : get_inertia ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_inertia " , " inertia " ) , & RigidBody2D : : set_inertia ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_weight " , " weight " ) , & RigidBody2D : : set_weight ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_weight " ) , & RigidBody2D : : get_weight ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_friction " , " friction " ) , & RigidBody2D : : set_friction ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_friction " ) , & RigidBody2D : : get_friction ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_bounce " , " bounce " ) , & RigidBody2D : : set_bounce ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_bounce " ) , & RigidBody2D : : get_bounce ) ;
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_gravity_scale " , " gravity_scale " ) , & RigidBody2D : : set_gravity_scale ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_gravity_scale " ) , & RigidBody2D : : get_gravity_scale ) ;
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_linear_damp " , " linear_damp " ) , & RigidBody2D : : set_linear_damp ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_linear_damp " ) , & RigidBody2D : : get_linear_damp ) ;
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_angular_damp " , " angular_damp " ) , & RigidBody2D : : set_angular_damp ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_angular_damp " ) , & RigidBody2D : : get_angular_damp ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_linear_velocity " , " linear_velocity " ) , & RigidBody2D : : set_linear_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_linear_velocity " ) , & RigidBody2D : : get_linear_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_angular_velocity " , " angular_velocity " ) , & RigidBody2D : : set_angular_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_angular_velocity " ) , & RigidBody2D : : get_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_max_contacts_reported " , " amount " ) , & RigidBody2D : : set_max_contacts_reported ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_max_contacts_reported " ) , & RigidBody2D : : get_max_contacts_reported ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_use_custom_integrator " , " enable " ) , & RigidBody2D : : set_use_custom_integrator ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_using_custom_integrator " ) , & RigidBody2D : : is_using_custom_integrator ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_contact_monitor " , " enabled " ) , & RigidBody2D : : set_contact_monitor ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_contact_monitor_enabled " ) , & RigidBody2D : : is_contact_monitor_enabled ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_continuous_collision_detection_mode " , " mode " ) , & RigidBody2D : : set_continuous_collision_detection_mode ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_continuous_collision_detection_mode " ) , & RigidBody2D : : get_continuous_collision_detection_mode ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_axis_velocity " , " axis_velocity " ) , & RigidBody2D : : set_axis_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " apply_impulse " , " offset " , " impulse " ) , & RigidBody2D : : apply_impulse ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_applied_force " , " force " ) , & RigidBody2D : : set_applied_force ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_applied_force " ) , & RigidBody2D : : get_applied_force ) ;
2016-04-21 01:49:35 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_applied_torque " , " torque " ) , & RigidBody2D : : set_applied_torque ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_applied_torque " ) , & RigidBody2D : : get_applied_torque ) ;
2016-04-26 14:15:15 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " add_force " , " offset " , " force " ) , & RigidBody2D : : add_force ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_sleeping " , " sleeping " ) , & RigidBody2D : : set_sleeping ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_sleeping " ) , & RigidBody2D : : is_sleeping ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_can_sleep " , " able_to_sleep " ) , & RigidBody2D : : set_can_sleep ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_able_to_sleep " ) , & RigidBody2D : : is_able_to_sleep ) ;
2015-04-20 01:50:55 +02:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " test_motion " , " motion " , " margin " , " result:Physics2DTestMotionResult " ) , & RigidBody2D : : _test_motion , DEFVAL ( 0.08 ) , DEFVAL ( Variant ( ) ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " _direct_state_changed " ) , & RigidBody2D : : _direct_state_changed ) ;
ObjectTypeDB : : bind_method ( _MD ( " _body_enter_tree " ) , & RigidBody2D : : _body_enter_tree ) ;
ObjectTypeDB : : bind_method ( _MD ( " _body_exit_tree " ) , & RigidBody2D : : _body_exit_tree ) ;
2014-11-13 04:53:12 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_colliding_bodies " ) , & RigidBody2D : : get_colliding_bodies ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
BIND_VMETHOD ( MethodInfo ( " _integrate_forces " , PropertyInfo ( Variant : : OBJECT , " state:Physics2DDirectBodyState " ) ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " mode " , PROPERTY_HINT_ENUM , " Rigid,Static,Character,Kinematic " ) , _SCS ( " set_mode " ) , _SCS ( " get_mode " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " mass " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " ) , _SCS ( " set_mass " ) , _SCS ( " get_mass " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " weight " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " , PROPERTY_USAGE_EDITOR ) , _SCS ( " set_weight " ) , _SCS ( " get_weight " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , _SCS ( " set_friction " ) , _SCS ( " get_friction " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , _SCS ( " set_bounce " ) , _SCS ( " get_bounce " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " gravity_scale " , PROPERTY_HINT_RANGE , " -128,128,0.01 " ) , _SCS ( " set_gravity_scale " ) , _SCS ( " get_gravity_scale " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " custom_integrator " ) , _SCS ( " set_use_custom_integrator " ) , _SCS ( " is_using_custom_integrator " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " continuous_cd " , PROPERTY_HINT_ENUM , " Disabled,Cast Ray,Cast Shape " ) , _SCS ( " set_continuous_collision_detection_mode " ) , _SCS ( " get_continuous_collision_detection_mode " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " contacts_reported " ) , _SCS ( " set_max_contacts_reported " ) , _SCS ( " get_max_contacts_reported " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " contact_monitor " ) , _SCS ( " set_contact_monitor " ) , _SCS ( " is_contact_monitor_enabled " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " sleeping " ) , _SCS ( " set_sleeping " ) , _SCS ( " is_sleeping " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " can_sleep " ) , _SCS ( " set_can_sleep " ) , _SCS ( " is_able_to_sleep " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " velocity/linear " ) , _SCS ( " set_linear_velocity " ) , _SCS ( " get_linear_velocity " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " velocity/angular " ) , _SCS ( " set_angular_velocity " ) , _SCS ( " get_angular_velocity " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " damp_override/linear " , PROPERTY_HINT_RANGE , " -1,128,0.01 " ) , _SCS ( " set_linear_damp " ) , _SCS ( " get_linear_damp " ) ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " damp_override/angular " , PROPERTY_HINT_RANGE , " -1,128,0.01 " ) , _SCS ( " set_angular_damp " ) , _SCS ( " get_angular_damp " ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
ADD_SIGNAL ( MethodInfo ( " body_enter_shape " , PropertyInfo ( Variant : : INT , " body_id " ) , PropertyInfo ( Variant : : OBJECT , " body " ) , PropertyInfo ( Variant : : INT , " body_shape " ) , PropertyInfo ( Variant : : INT , " local_shape " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_exit_shape " , PropertyInfo ( Variant : : INT , " body_id " ) , PropertyInfo ( Variant : : OBJECT , " body " ) , PropertyInfo ( Variant : : INT , " body_shape " ) , PropertyInfo ( Variant : : INT , " local_shape " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_enter " , PropertyInfo ( Variant : : OBJECT , " body " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_exit " , PropertyInfo ( Variant : : OBJECT , " body " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " sleeping_state_changed " ) ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
BIND_CONSTANT ( MODE_STATIC ) ;
BIND_CONSTANT ( MODE_KINEMATIC ) ;
BIND_CONSTANT ( MODE_RIGID ) ;
BIND_CONSTANT ( MODE_CHARACTER ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
BIND_CONSTANT ( CCD_MODE_DISABLED ) ;
BIND_CONSTANT ( CCD_MODE_CAST_RAY ) ;
BIND_CONSTANT ( CCD_MODE_CAST_SHAPE ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-11 15:31:49 +01:00
RigidBody2D : : RigidBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_RIGID ) {
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
mode = MODE_RIGID ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
bounce = 0 ;
mass = 1 ;
friction = 1 ;
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
gravity_scale = 1 ;
linear_damp = - 1 ;
angular_damp = - 1 ;
2015-01-05 22:37:12 +01:00
2017-03-19 00:36:26 +01:00
max_contacts_reported = 0 ;
state = NULL ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
angular_velocity = 0 ;
sleeping = false ;
ccd_mode = CCD_MODE_DISABLED ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +01:00
custom_integrator = false ;
contact_monitor = NULL ;
can_sleep = true ;
2014-02-10 02:10:30 +01:00
2017-03-19 00:36:26 +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 ( ) {
if ( contact_monitor )
2017-03-19 00:36:26 +01:00
memdelete ( contact_monitor ) ;
2014-02-19 15:57:14 +01:00
}
//////////////////////////
Variant KinematicBody2D : : _get_collider ( ) const {
2017-03-19 00:36:26 +01:00
ObjectID oid = get_collider ( ) ;
if ( oid = = 0 )
2014-02-19 15:57:14 +01:00
return Variant ( ) ;
Object * obj = ObjectDB : : get_instance ( oid ) ;
if ( ! obj )
return Variant ( ) ;
Reference * ref = obj - > cast_to < Reference > ( ) ;
if ( ref ) {
return Ref < Reference > ( ref ) ;
}
return obj ;
}
2015-05-04 03:37:10 +02:00
void KinematicBody2D : : revert_motion ( ) {
Matrix32 gt = get_global_transform ( ) ;
2017-03-19 00:36:26 +01:00
gt . elements [ 2 ] - = travel ;
2015-05-04 03:37:10 +02:00
set_global_transform ( gt ) ;
2017-03-19 00:36:26 +01:00
travel = Vector2 ( ) ;
2015-05-04 03:37:10 +02:00
}
Vector2 KinematicBody2D : : get_travel ( ) const {
return travel ;
}
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
Vector2 KinematicBody2D : : move ( const Vector2 & p_motion ) {
2014-02-19 15:57:14 +01:00
2015-04-20 01:50:55 +02:00
# if 1
2017-03-06 05:08:12 +01:00
Matrix32 gt = get_global_transform ( ) ;
2015-04-20 01:50:55 +02:00
Physics2DServer : : MotionResult result ;
2017-03-06 05:08:12 +01:00
if ( motion_fix_enabled ) {
2017-03-19 00:36:26 +01:00
colliding = Physics2DServer : : get_singleton ( ) - > body_test_motion_from ( get_rid ( ) , gt , p_motion , margin , & result ) ;
2017-03-06 05:08:12 +01:00
} else {
2017-03-19 00:36:26 +01:00
colliding = Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_motion , margin , & result ) ;
2017-03-06 05:08:12 +01:00
}
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
collider_metadata = result . collider_metadata ;
collider_shape = result . collider_shape ;
collider_vel = result . collider_velocity ;
collision = result . collision_point ;
normal = result . collision_normal ;
collider = result . collider_id ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
gt . elements [ 2 ] + = result . motion ;
2015-04-20 01:50:55 +02:00
set_global_transform ( gt ) ;
2017-03-19 00:36:26 +01:00
travel = result . motion ;
2017-03-06 05:08:12 +01:00
2015-04-20 01:50:55 +02:00
return result . remainder ;
2014-02-19 15:57:14 +01:00
2015-04-20 01:50:55 +02:00
# else
2014-02-23 00:28:19 +01:00
//give me back regular physics engine logic
//this is madness
//and most people using this function will think
//what it does is simpler than using physics
//this took about a week to get right..
//but is it right? who knows at this point..
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
colliding = false ;
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , Vector2 ( ) ) ;
2014-02-19 15:57:14 +01:00
Physics2DDirectSpaceState * dss = Physics2DServer : : get_singleton ( ) - > space_get_direct_state ( get_world_2d ( ) - > get_space ( ) ) ;
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! dss , Vector2 ( ) ) ;
const int max_shapes = 32 ;
Vector2 sr [ max_shapes * 2 ] ;
2014-02-23 00:28:19 +01:00
int res_shapes ;
2014-02-19 15:57:14 +01:00
Set < RID > exclude ;
exclude . insert ( get_rid ( ) ) ;
2014-02-23 00:28:19 +01:00
//recover first
2017-03-19 00:36:26 +01:00
int recover_attempts = 4 ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
bool collided = false ;
uint32_t mask = 0 ;
2017-03-06 05:08:12 +01:00
if ( true )
2017-03-19 00:36:26 +01:00
mask | = Physics2DDirectSpaceState : : TYPE_MASK_STATIC_BODY ;
2017-03-06 05:08:12 +01:00
if ( true )
2017-03-19 00:36:26 +01:00
mask | = Physics2DDirectSpaceState : : TYPE_MASK_KINEMATIC_BODY ;
2017-03-06 05:08:12 +01:00
if ( true )
2017-03-19 00:36:26 +01:00
mask | = Physics2DDirectSpaceState : : TYPE_MASK_RIGID_BODY ;
2017-03-06 05:08:12 +01:00
if ( true )
2017-03-19 00:36:26 +01:00
mask | = Physics2DDirectSpaceState : : TYPE_MASK_CHARACTER_BODY ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
//print_line("margin: "+rtos(margin));
do {
2014-02-19 15:57:14 +01:00
2014-09-03 04:13:40 +02:00
//motion recover
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < get_shape_count ( ) ; i + + ) {
2014-02-19 15:57:14 +01:00
2014-12-20 19:30:06 +01:00
if ( is_shape_set_as_trigger ( i ) )
continue ;
2017-03-19 00:36:26 +01:00
if ( dss - > collide_shape ( get_shape ( i ) - > get_rid ( ) , get_global_transform ( ) * get_shape_transform ( i ) , Vector2 ( ) , margin , sr , max_shapes , res_shapes , exclude , get_layer_mask ( ) , mask ) )
collided = true ;
2014-02-19 15:57:14 +01:00
}
2014-02-23 00:28:19 +01:00
if ( ! collided )
break ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
Vector2 recover_motion ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < res_shapes ; i + + ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
Vector2 a = sr [ i * 2 + 0 ] ;
Vector2 b = sr [ i * 2 + 1 ] ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
float d = a . distance_to ( b ) ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
//if (d<margin)
/// continue;
2017-03-19 00:36:26 +01:00
recover_motion + = ( b - a ) * 0.4 ;
2014-02-23 00:28:19 +01:00
}
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
if ( recover_motion = = Vector2 ( ) ) {
collided = false ;
2014-02-23 00:28:19 +01:00
break ;
}
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
Matrix32 gt = get_global_transform ( ) ;
2017-03-19 00:36:26 +01:00
gt . elements [ 2 ] + = recover_motion ;
2014-02-23 00:28:19 +01:00
set_global_transform ( gt ) ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
recover_attempts - - ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
} while ( recover_attempts ) ;
2014-02-19 15:57:14 +01:00
2014-02-23 00:28:19 +01:00
//move second
float safe = 1.0 ;
float unsafe = 1.0 ;
2017-03-19 00:36:26 +01:00
int best_shape = - 1 ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
for ( int i = 0 ; i < get_shape_count ( ) ; i + + ) {
2014-02-19 15:57:14 +01:00
2014-12-20 19:30:06 +01:00
if ( is_shape_set_as_trigger ( i ) )
continue ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
float lsafe , lunsafe ;
bool valid = dss - > cast_motion ( get_shape ( i ) - > get_rid ( ) , get_global_transform ( ) * get_shape_transform ( i ) , p_motion , 0 , lsafe , lunsafe , exclude , get_layer_mask ( ) , mask ) ;
2014-02-23 00:28:19 +01:00
//print_line("shape: "+itos(i)+" travel:"+rtos(ltravel));
if ( ! valid ) {
2015-01-14 01:19:11 +01:00
2017-03-19 00:36:26 +01:00
safe = 0 ;
unsafe = 0 ;
best_shape = i ; //sadly it's the best
2014-02-23 00:28:19 +01:00
break ;
}
2017-03-19 00:36:26 +01:00
if ( lsafe = = 1.0 ) {
2014-02-19 15:57:14 +01:00
continue ;
}
2014-02-23 00:28:19 +01:00
if ( lsafe < safe ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
safe = lsafe ;
unsafe = lunsafe ;
best_shape = i ;
2014-02-19 15:57:14 +01:00
}
}
2014-02-23 00:28:19 +01:00
//print_line("best shape: "+itos(best_shape)+" motion "+p_motion);
2017-03-19 00:36:26 +01:00
if ( safe > = 1 ) {
2014-02-19 15:57:14 +01:00
//not collided
2017-03-19 00:36:26 +01:00
colliding = false ;
2017-03-06 05:08:12 +01:00
2014-02-19 15:57:14 +01:00
} else {
2014-02-23 00:28:19 +01:00
//it collided, let's get the rest info in unsafe advance
Matrix32 ugt = get_global_transform ( ) ;
2017-03-19 00:36:26 +01:00
ugt . elements [ 2 ] + = p_motion * unsafe ;
2014-02-23 00:28:19 +01:00
Physics2DDirectSpaceState : : ShapeRestInfo rest_info ;
2017-03-19 00:36:26 +01:00
bool c2 = dss - > rest_info ( get_shape ( best_shape ) - > get_rid ( ) , ugt * get_shape_transform ( best_shape ) , Vector2 ( ) , margin , & rest_info , exclude , get_layer_mask ( ) , mask ) ;
2014-02-23 00:28:19 +01:00
if ( ! c2 ) {
//should not happen, but floating point precision is so weird..
2015-01-14 01:19:11 +01:00
2017-03-19 00:36:26 +01:00
colliding = false ;
2014-02-19 15:57:14 +01:00
} else {
2014-02-23 00:28:19 +01:00
//print_line("Travel: "+rtos(travel));
2017-03-19 00:36:26 +01:00
colliding = true ;
collision = rest_info . point ;
normal = rest_info . normal ;
collider = rest_info . collider_id ;
collider_vel = rest_info . linear_velocity ;
collider_shape = rest_info . shape ;
collider_metadata = rest_info . metadata ;
2014-02-19 15:57:14 +01:00
}
}
2017-03-19 00:36:26 +01:00
Vector2 motion = p_motion * safe ;
2014-02-19 15:57:14 +01:00
Matrix32 gt = get_global_transform ( ) ;
2017-03-19 00:36:26 +01:00
gt . elements [ 2 ] + = motion ;
2014-02-19 15:57:14 +01:00
set_global_transform ( gt ) ;
2017-03-19 00:36:26 +01:00
return p_motion - motion ;
2015-04-20 01:50:55 +02:00
# endif
2014-02-19 15:57:14 +01:00
}
2017-03-19 00:36:26 +01:00
Vector2 KinematicBody2D : : move_to ( const Vector2 & p_position ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
return move ( p_position - get_global_pos ( ) ) ;
2014-02-19 15:57:14 +01:00
}
2017-08-29 03:35:44 +02:00
Vector2 KinematicBody2D : : move_and_slide ( const Vector2 & p_linear_velocity , const Vector2 & p_floor_direction , float p_slope_stop_min_velocity , int p_max_bounces , float p_floor_max_angle ) {
2017-07-31 00:39:14 +02:00
Vector2 motion = ( move_and_slide_floor_velocity + p_linear_velocity ) * get_fixed_process_delta_time ( ) ;
Vector2 lv = p_linear_velocity ;
move_and_slide_on_floor = false ;
move_and_slide_on_ceiling = false ;
move_and_slide_on_wall = false ;
move_and_slide_colliders . clear ( ) ;
move_and_slide_floor_velocity = Vector2 ( ) ;
while ( p_max_bounces ) {
motion = move ( motion ) ;
if ( is_colliding ( ) ) {
if ( p_floor_direction = = Vector2 ( ) ) {
//all is a wall
move_and_slide_on_wall = true ;
} else {
2017-08-29 03:35:44 +02:00
if ( get_collision_normal ( ) . dot ( p_floor_direction ) > = Math : : cos ( p_floor_max_angle ) ) { //floor
2017-07-31 00:39:14 +02:00
move_and_slide_on_floor = true ;
move_and_slide_floor_velocity = get_collider_velocity ( ) ;
if ( get_travel ( ) . length ( ) < 1 & & ABS ( ( lv . x - move_and_slide_floor_velocity . x ) ) < p_slope_stop_min_velocity ) {
revert_motion ( ) ;
return Vector2 ( ) ;
}
2017-08-29 03:35:44 +02:00
} else if ( get_collision_normal ( ) . dot ( - p_floor_direction ) > = Math : : cos ( p_floor_max_angle ) ) { //ceiling
2017-07-31 00:39:14 +02:00
move_and_slide_on_ceiling = true ;
} else {
move_and_slide_on_wall = true ;
}
}
motion = get_collision_normal ( ) . slide ( motion ) ;
lv = get_collision_normal ( ) . slide ( lv ) ;
Variant collider = _get_collider ( ) ;
if ( collider . get_type ( ) ! = Variant : : NIL ) {
move_and_slide_colliders . push_back ( collider ) ;
}
} else {
break ;
}
p_max_bounces - - ;
if ( motion = = Vector2 ( ) )
break ;
}
return lv ;
}
bool KinematicBody2D : : is_move_and_slide_on_floor ( ) const {
return move_and_slide_on_floor ;
}
bool KinematicBody2D : : is_move_and_slide_on_wall ( ) const {
return move_and_slide_on_wall ;
}
bool KinematicBody2D : : is_move_and_slide_on_ceiling ( ) const {
return move_and_slide_on_ceiling ;
}
Array KinematicBody2D : : get_move_and_slide_colliders ( ) const {
return move_and_slide_colliders ;
}
2017-03-19 00:36:26 +01:00
bool KinematicBody2D : : test_move ( const Vector2 & p_motion ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , false ) ;
2014-02-19 15:57:14 +01:00
2017-03-06 05:08:12 +01:00
if ( motion_fix_enabled ) {
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_test_motion_from ( get_rid ( ) , get_global_transform ( ) , p_motion , margin ) ;
2017-03-06 05:08:12 +01:00
} else {
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_motion , margin ) ;
2017-03-06 05:08:12 +01:00
}
}
2017-03-19 00:36:26 +01:00
bool KinematicBody2D : : test_move_from ( const Matrix32 & p_from , const Vector2 & p_motion ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , false ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
return Physics2DServer : : get_singleton ( ) - > body_test_motion_from ( get_rid ( ) , p_from , p_motion , margin ) ;
2014-02-19 15:57:14 +01:00
}
Vector2 KinematicBody2D : : get_collision_pos ( ) const {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! colliding , Vector2 ( ) ) ;
2014-02-19 15:57:14 +01:00
return collision ;
}
2015-04-20 01:50:55 +02:00
2014-02-19 15:57:14 +01:00
Vector2 KinematicBody2D : : get_collision_normal ( ) const {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! colliding , Vector2 ( ) ) ;
2014-02-19 15:57:14 +01:00
return normal ;
}
2014-02-23 00:28:19 +01:00
Vector2 KinematicBody2D : : get_collider_velocity ( ) const {
return collider_vel ;
}
2014-02-19 15:57:14 +01:00
ObjectID KinematicBody2D : : get_collider ( ) const {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! colliding , 0 ) ;
2014-02-19 15:57:14 +01:00
return collider ;
}
2014-10-14 06:01:25 +02:00
int KinematicBody2D : : get_collider_shape ( ) const {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! colliding , 0 ) ;
2014-10-14 06:01:25 +02:00
return collider_shape ;
}
2014-10-16 05:06:34 +02:00
Variant KinematicBody2D : : get_collider_metadata ( ) const {
2017-03-19 00:36:26 +01:00
ERR_FAIL_COND_V ( ! colliding , 0 ) ;
2014-10-16 05:06:34 +02:00
return collider_metadata ;
}
2017-03-19 00:36:26 +01:00
bool KinematicBody2D : : is_colliding ( ) const {
2014-02-19 15:57:14 +01:00
2015-04-20 01:50:55 +02:00
return colliding ;
2014-02-19 15:57:14 +01:00
}
void KinematicBody2D : : set_collision_margin ( float p_margin ) {
2017-03-19 00:36:26 +01:00
margin = p_margin ;
2014-02-19 15:57:14 +01:00
}
2017-03-19 00:36:26 +01:00
float KinematicBody2D : : get_collision_margin ( ) const {
2014-02-19 15:57:14 +01:00
return margin ;
}
void KinematicBody2D : : _bind_methods ( ) {
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " move " , " rel_vec " ) , & KinematicBody2D : : move ) ;
ObjectTypeDB : : bind_method ( _MD ( " move_to " , " position " ) , & KinematicBody2D : : move_to ) ;
2017-08-29 03:35:44 +02:00
ObjectTypeDB : : bind_method ( _MD ( " move_and_slide " , " linear_velocity " , " floor_normal " , " slope_stop_min_velocity " , " max_bounces " , " floor_max_angle " ) , & KinematicBody2D : : move_and_slide , DEFVAL ( Vector2 ( 0 , 0 ) ) , DEFVAL ( 5 ) , DEFVAL ( 4 ) , DEFVAL ( Math : : deg2rad ( ( float ) 45 ) ) ) ;
2017-07-31 00:39:14 +02:00
ObjectTypeDB : : bind_method ( _MD ( " get_move_and_slide_colliders " ) , & KinematicBody2D : : get_move_and_slide_colliders ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_move_and_slide_on_floor " ) , & KinematicBody2D : : is_move_and_slide_on_floor ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_move_and_slide_on_ceiling " ) , & KinematicBody2D : : is_move_and_slide_on_ceiling ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_move_and_slide_on_wall " ) , & KinematicBody2D : : is_move_and_slide_on_wall ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " test_move " , " rel_vec " ) , & KinematicBody2D : : test_move ) ;
ObjectTypeDB : : bind_method ( _MD ( " test_move_from " , " from " , " rel_vec " ) , & KinematicBody2D : : test_move_from ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_travel " ) , & KinematicBody2D : : get_travel ) ;
ObjectTypeDB : : bind_method ( _MD ( " revert_motion " ) , & KinematicBody2D : : revert_motion ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " is_colliding " ) , & KinematicBody2D : : is_colliding ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_collision_pos " ) , & KinematicBody2D : : get_collision_pos ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collision_normal " ) , & KinematicBody2D : : get_collision_normal ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collider_velocity " ) , & KinematicBody2D : : get_collider_velocity ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collider:Variant " ) , & KinematicBody2D : : _get_collider ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collider_shape " ) , & KinematicBody2D : : get_collider_shape ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collider_metadata:Variant " ) , & KinematicBody2D : : get_collider_metadata ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_collision_margin " , " pixels " ) , & KinematicBody2D : : set_collision_margin ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_collision_margin " , " pixels " ) , & KinematicBody2D : : get_collision_margin ) ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " collision/margin " , PROPERTY_HINT_RANGE , " 0.001,256,0.001 " ) , _SCS ( " set_collision_margin " ) , _SCS ( " get_collision_margin " ) ) ;
2014-02-19 15:57:14 +01:00
}
2017-12-11 15:31:49 +01:00
KinematicBody2D : : KinematicBody2D ( ) :
PhysicsBody2D ( Physics2DServer : : BODY_MODE_KINEMATIC ) {
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
colliding = false ;
collider = 0 ;
2014-02-19 15:57:14 +01:00
2017-03-19 00:36:26 +01:00
collider_shape = 0 ;
2014-10-14 06:01:25 +02:00
2017-03-19 00:36:26 +01:00
margin = 0.08 ;
2017-07-31 00:39:14 +02:00
move_and_slide_on_floor = false ;
move_and_slide_on_ceiling = false ;
move_and_slide_on_wall = false ;
2014-02-19 15:57:14 +01:00
}
2017-03-19 00:36:26 +01:00
KinematicBody2D : : ~ KinematicBody2D ( ) {
2014-02-10 02:10:30 +01:00
}