2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* physics_body.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
2018-01-01 14:40:08 +01:00
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-05 00:50:27 +01:00
2014-02-10 02:10:30 +01:00
# include "physics_body.h"
2017-08-19 01:02:56 +02:00
# include "engine.h"
2017-06-23 17:03:41 +02:00
# include "method_bind_ext.gen.inc"
2014-02-10 02:10:30 +01:00
# include "scene/scene_string_names.h"
2017-10-03 18:49:32 +02:00
# ifdef TOOLS_ENABLED
# include "editor/plugins/spatial_editor_plugin.h"
# endif
2014-02-10 02:10:30 +01:00
void PhysicsBody : : _notification ( int p_what ) {
2017-03-05 16:44:50 +01:00
/*
2014-02-10 02:10:30 +01:00
switch ( p_what ) {
case NOTIFICATION_TRANSFORM_CHANGED : {
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_TRANSFORM , get_global_transform ( ) ) ;
} break ;
}
*/
}
2014-08-14 15:31:38 +02:00
Vector3 PhysicsBody : : get_linear_velocity ( ) const {
return Vector3 ( ) ;
}
Vector3 PhysicsBody : : get_angular_velocity ( ) const {
return Vector3 ( ) ;
}
float PhysicsBody : : get_inverse_mass ( ) const {
return 0 ;
}
2017-06-13 17:45:01 +02:00
void PhysicsBody : : set_collision_layer ( uint32_t p_layer ) {
2014-02-10 02:10:30 +01:00
2017-06-13 17:45:01 +02:00
collision_layer = p_layer ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_layer ( get_rid ( ) , p_layer ) ;
2014-02-10 02:10:30 +01:00
}
2017-01-13 15:01:19 +01:00
uint32_t PhysicsBody : : get_collision_layer ( ) const {
2014-02-10 02:10:30 +01:00
2017-06-13 17:45:01 +02:00
return collision_layer ;
2014-02-10 02:10:30 +01:00
}
2016-04-09 20:54:09 +02:00
void PhysicsBody : : set_collision_mask ( uint32_t p_mask ) {
2017-03-05 16:44:50 +01:00
collision_mask = p_mask ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_mask ( get_rid ( ) , p_mask ) ;
2016-04-09 20:54:09 +02:00
}
uint32_t PhysicsBody : : get_collision_mask ( ) const {
return collision_mask ;
}
void PhysicsBody : : set_collision_mask_bit ( int p_bit , bool p_value ) {
uint32_t mask = get_collision_mask ( ) ;
if ( p_value )
2017-03-05 16:44:50 +01:00
mask | = 1 < < p_bit ;
2016-04-09 20:54:09 +02:00
else
2017-03-05 16:44:50 +01:00
mask & = ~ ( 1 < < p_bit ) ;
2016-04-09 20:54:09 +02:00
set_collision_mask ( mask ) ;
}
2017-03-05 16:44:50 +01:00
bool PhysicsBody : : get_collision_mask_bit ( int p_bit ) const {
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
return get_collision_mask ( ) & ( 1 < < p_bit ) ;
2016-04-09 20:54:09 +02:00
}
2017-01-13 15:01:19 +01:00
void PhysicsBody : : set_collision_layer_bit ( int p_bit , bool p_value ) {
2016-04-09 20:54:09 +02:00
2017-01-13 15:01:19 +01:00
uint32_t mask = get_collision_layer ( ) ;
2016-04-09 20:54:09 +02:00
if ( p_value )
2017-03-05 16:44:50 +01:00
mask | = 1 < < p_bit ;
2016-04-09 20:54:09 +02:00
else
2017-03-05 16:44:50 +01:00
mask & = ~ ( 1 < < p_bit ) ;
2017-01-13 15:01:19 +01:00
set_collision_layer ( mask ) ;
2016-04-09 20:54:09 +02:00
}
2017-03-05 16:44:50 +01:00
bool PhysicsBody : : get_collision_layer_bit ( int p_bit ) const {
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
return get_collision_layer ( ) & ( 1 < < p_bit ) ;
2016-04-09 20:54:09 +02:00
}
2017-03-05 16:44:50 +01:00
void PhysicsBody : : add_collision_exception_with ( Node * p_node ) {
2014-09-22 06:03:56 +02:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 22:58:51 +02:00
PhysicsBody * physics_body = Object : : cast_to < PhysicsBody > ( p_node ) ;
2014-09-22 06:03:56 +02:00
if ( ! physics_body ) {
ERR_EXPLAIN ( " Collision exception only works between two objects of PhysicsBody type " ) ;
}
ERR_FAIL_COND ( ! physics_body ) ;
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_add_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 06:03:56 +02:00
}
2017-03-05 16:44:50 +01:00
void PhysicsBody : : remove_collision_exception_with ( Node * p_node ) {
2014-09-22 06:03:56 +02:00
ERR_FAIL_NULL ( p_node ) ;
2017-08-24 22:58:51 +02:00
PhysicsBody * physics_body = Object : : cast_to < PhysicsBody > ( p_node ) ;
2014-09-22 06:03:56 +02:00
if ( ! physics_body ) {
ERR_EXPLAIN ( " Collision exception only works between two objects of PhysicsBody type " ) ;
}
ERR_FAIL_COND ( ! physics_body ) ;
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_remove_collision_exception ( get_rid ( ) , physics_body - > get_rid ( ) ) ;
2014-09-22 06:03:56 +02:00
}
2016-04-09 20:54:09 +02:00
void PhysicsBody : : _set_layers ( uint32_t p_mask ) {
2017-01-13 15:01:19 +01:00
set_collision_layer ( p_mask ) ;
2016-04-09 20:54:09 +02:00
set_collision_mask ( p_mask ) ;
}
2017-03-05 16:44:50 +01:00
uint32_t PhysicsBody : : _get_layers ( ) const {
2016-04-09 20:54:09 +02:00
2017-01-13 15:01:19 +01:00
return get_collision_layer ( ) ;
2016-04-09 20:54:09 +02:00
}
2015-01-13 14:49:26 +01:00
2014-09-03 04:13:40 +02:00
void PhysicsBody : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_layer " , " layer " ) , & PhysicsBody : : set_collision_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_layer " ) , & PhysicsBody : : get_collision_layer ) ;
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_mask " , " mask " ) , & PhysicsBody : : set_collision_mask ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_mask " ) , & PhysicsBody : : get_collision_mask ) ;
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_mask_bit " , " bit " , " value " ) , & PhysicsBody : : set_collision_mask_bit ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_mask_bit " , " bit " ) , & PhysicsBody : : get_collision_mask_bit ) ;
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_collision_layer_bit " , " bit " , " value " ) , & PhysicsBody : : set_collision_layer_bit ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_layer_bit " , " bit " ) , & PhysicsBody : : get_collision_layer_bit ) ;
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _set_layers " , " mask " ) , & PhysicsBody : : _set_layers ) ;
ClassDB : : bind_method ( D_METHOD ( " _get_layers " ) , & PhysicsBody : : _get_layers ) ;
2016-04-09 20:54:09 +02:00
2017-03-05 16:44:50 +01:00
ADD_GROUP ( " Collision " , " collision_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision_layer " , PROPERTY_HINT_LAYERS_3D_PHYSICS ) , " set_collision_layer " , " get_collision_layer " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision_mask " , PROPERTY_HINT_LAYERS_3D_PHYSICS ) , " set_collision_mask " , " get_collision_mask " ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-06 21:36:34 +01:00
PhysicsBody : : PhysicsBody ( PhysicsServer : : BodyMode p_mode ) :
CollisionObject ( PhysicsServer : : get_singleton ( ) - > body_create ( p_mode ) , false ) {
2014-02-10 02:10:30 +01:00
2017-06-13 17:45:01 +02:00
collision_layer = 1 ;
2017-03-05 16:44:50 +01:00
collision_mask = 1 ;
2014-09-03 04:13:40 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
void StaticBody : : set_friction ( real_t p_friction ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_friction < 0 | | p_friction > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
friction = p_friction ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_FRICTION , friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t StaticBody : : get_friction ( ) const {
2014-02-10 02:10:30 +01:00
2014-09-03 04:13:40 +02:00
return friction ;
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
void StaticBody : : set_bounce ( real_t p_bounce ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bounce = p_bounce ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_BOUNCE , bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t StaticBody : : get_bounce ( ) const {
2014-02-10 02:10:30 +01:00
2014-09-03 04:13:40 +02:00
return bounce ;
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
void StaticBody : : set_constant_linear_velocity ( const Vector3 & p_vel ) {
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
constant_linear_velocity = p_vel ;
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_LINEAR_VELOCITY , constant_linear_velocity ) ;
2014-09-03 04:13:40 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
void StaticBody : : set_constant_angular_velocity ( const Vector3 & p_vel ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
constant_angular_velocity = p_vel ;
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_ANGULAR_VELOCITY , constant_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
}
2014-09-03 04:13:40 +02:00
Vector3 StaticBody : : get_constant_linear_velocity ( ) const {
2014-02-10 02:10:30 +01:00
2014-09-03 04:13:40 +02:00
return constant_linear_velocity ;
}
Vector3 StaticBody : : get_constant_angular_velocity ( ) const {
2014-02-10 02:10:30 +01:00
2014-09-03 04:13:40 +02:00
return constant_angular_velocity ;
2014-02-10 02:10:30 +01:00
}
void StaticBody : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_constant_linear_velocity " , " vel " ) , & StaticBody : : set_constant_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " set_constant_angular_velocity " , " vel " ) , & StaticBody : : set_constant_angular_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_constant_linear_velocity " ) , & StaticBody : : get_constant_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_constant_angular_velocity " ) , & StaticBody : : get_constant_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_friction " , " friction " ) , & StaticBody : : set_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " get_friction " ) , & StaticBody : : get_friction ) ;
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_bounce " , " bounce " ) , & StaticBody : : set_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " get_bounce " ) , & StaticBody : : get_bounce ) ;
2014-09-03 04:13:40 +02:00
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " add_collision_exception_with " , " body " ) , & PhysicsBody : : add_collision_exception_with ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_collision_exception_with " , " body " ) , & PhysicsBody : : remove_collision_exception_with ) ;
2014-09-22 06:03:56 +02:00
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_friction " , " get_friction " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_bounce " , " get_bounce " ) ;
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " constant_linear_velocity " ) , " set_constant_linear_velocity " , " get_constant_linear_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " constant_angular_velocity " ) , " set_constant_angular_velocity " , " get_constant_angular_velocity " ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-06 21:36:34 +01:00
StaticBody : : StaticBody ( ) :
PhysicsBody ( PhysicsServer : : BODY_MODE_STATIC ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bounce = 0 ;
friction = 1 ;
2014-02-10 02:10:30 +01:00
}
StaticBody : : ~ StaticBody ( ) {
}
2014-11-06 01:20:42 +01:00
void RigidBody : : _body_enter_tree ( ObjectID p_id ) {
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! E ) ;
2014-11-06 01:20:42 +01:00
ERR_FAIL_COND ( E - > get ( ) . in_tree ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_tree = true ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01: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 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2014-11-06 01:20:42 +01:00
void RigidBody : : _body_exit_tree ( ObjectID p_id ) {
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( p_id ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! node ) ;
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( p_id ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! E ) ;
2014-11-06 01:20:42 +01:00
ERR_FAIL_COND ( ! E - > get ( ) . in_tree ) ;
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_tree = false ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , node ) ;
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01: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 02:10:30 +01:00
}
2016-01-12 10:14:15 +01:00
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void RigidBody : : _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-05 16:44:50 +01:00
bool body_in = p_status = = 1 ;
ObjectID objid = p_instance ;
2014-02-10 02:10:30 +01:00
Object * obj = ObjectDB : : get_instance ( objid ) ;
2017-08-24 22:58:51 +02:00
Node * node = Object : : cast_to < Node > ( obj ) ;
2014-02-10 02:10:30 +01:00
2018-01-21 12:46:13 +01:00
ERR_FAIL_COND ( ! contact_monitor ) ;
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( objid ) ;
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND ( ! body_in & & ! E ) ;
if ( body_in ) {
if ( ! E ) {
2017-03-05 16:44:50 +01:00
E = contact_monitor - > body_map . insert ( objid , BodyState ( ) ) ;
2014-10-03 13:58:41 +02:00
//E->get().rc=0;
2017-03-05 16:44:50 +01:00
E - > get ( ) . in_tree = node & & node - > is_inside_tree ( ) ;
2014-02-10 02:10:30 +01:00
if ( node ) {
2017-03-05 16:44:50 +01:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree , make_binds ( objid ) ) ;
2018-01-12 12:28:39 +01:00
node - > connect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree , make_binds ( objid ) ) ;
2014-11-06 01:20:42 +01:00
if ( E - > get ( ) . in_tree ) {
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_entered , node ) ;
2014-02-10 02:10:30 +01:00
}
}
}
2014-10-03 13:58:41 +02:00
//E->get().rc++;
2014-02-10 02:10:30 +01:00
if ( node )
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes . insert ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
if ( E - > get ( ) . in_tree ) {
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_entered , 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-05 16:44:50 +01:00
E - > get ( ) . shapes . erase ( ShapePair ( p_body_shape , p_local_shape ) ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
bool in_tree = E - > get ( ) . in_tree ;
2014-10-03 13:58:41 +02:00
if ( E - > get ( ) . shapes . empty ( ) ) {
2014-02-10 02:10:30 +01:00
if ( node ) {
2017-03-05 16:44:50 +01:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree ) ;
2018-01-12 12:28:39 +01:00
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree ) ;
2014-11-06 01:20:42 +01:00
if ( in_tree )
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_exited , obj ) ;
2014-02-10 02:10:30 +01:00
}
contact_monitor - > body_map . erase ( E ) ;
}
2014-11-06 01:20:42 +01:00
if ( node & & in_tree ) {
2017-03-05 16:44:50 +01:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > body_shape_exited , objid , obj , p_body_shape , p_local_shape ) ;
2014-02-10 02:10:30 +01:00
}
}
}
struct _RigidBodyInOut {
ObjectID id ;
int shape ;
int local_shape ;
} ;
void RigidBody : : _direct_state_changed ( Object * p_state ) {
# ifdef DEBUG_ENABLED
2017-08-24 22:58:51 +02:00
state = Object : : cast_to < PhysicsDirectBodyState > ( p_state ) ;
2014-02-10 02:10:30 +01:00
# else
2017-03-05 16:44:50 +01:00
state = ( PhysicsDirectBodyState * ) p_state ; //trust it
2014-02-10 02:10:30 +01:00
# endif
2016-06-17 21:45:10 +02:00
set_ignore_transform_notification ( true ) ;
set_global_transform ( state - > get_transform ( ) ) ;
2017-03-05 16:44:50 +01:00
linear_velocity = state - > get_linear_velocity ( ) ;
angular_velocity = state - > get_angular_velocity ( ) ;
if ( sleeping ! = state - > is_sleeping ( ) ) {
sleeping = state - > is_sleeping ( ) ;
2016-06-17 21:45:10 +02:00
emit_signal ( SceneStringNames : : get_singleton ( ) - > sleeping_state_changed ) ;
}
if ( get_script_instance ( ) )
2017-03-05 16:44:50 +01:00
get_script_instance ( ) - > call ( " _integrate_forces " , state ) ;
2016-06-17 21:45:10 +02:00
set_ignore_transform_notification ( false ) ;
2014-02-10 02:10:30 +01:00
if ( contact_monitor ) {
2017-03-05 16:44:50 +01:00
contact_monitor - > locked = true ;
2016-01-12 10:14:15 +01:00
2014-02-10 02:10:30 +01:00
//untag all
2017-03-05 16:44:50 +01:00
int rc = 0 ;
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < E - > get ( ) . shapes . size ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes [ i ] . tagged = false ;
2014-02-10 02:10:30 +01:00
rc + + ;
}
}
2017-03-05 16:44:50 +01:00
_RigidBodyInOut * toadd = ( _RigidBodyInOut * ) alloca ( state - > get_contact_count ( ) * sizeof ( _RigidBodyInOut ) ) ;
int toadd_count = 0 ; //state->get_contact_count();
RigidBody_RemoveAction * toremove = ( RigidBody_RemoveAction * ) alloca ( rc * sizeof ( RigidBody_RemoveAction ) ) ;
int toremove_count = 0 ;
2014-02-10 02:10:30 +01:00
//put the ones to add
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < state - > get_contact_count ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
ObjectID obj = state - > get_contact_collider_id ( i ) ;
int local_shape = state - > get_contact_local_shape ( i ) ;
int shape = state - > get_contact_collider_shape ( i ) ;
2017-01-14 12:26:56 +01:00
//bool found=false;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . find ( obj ) ;
2014-02-10 02:10:30 +01:00
if ( ! E ) {
2017-03-05 16:44:50 +01:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 02:10:30 +01:00
toadd_count + + ;
continue ;
}
2017-03-05 16:44:50 +01:00
ShapePair sp ( shape , local_shape ) ;
2014-02-10 02:10:30 +01:00
int idx = E - > get ( ) . shapes . find ( sp ) ;
2017-03-05 16:44:50 +01:00
if ( idx = = - 1 ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
toadd [ toadd_count ] . local_shape = local_shape ;
toadd [ toadd_count ] . id = obj ;
toadd [ toadd_count ] . shape = shape ;
2014-02-10 02:10:30 +01:00
toadd_count + + ;
continue ;
}
2017-03-05 16:44:50 +01:00
E - > get ( ) . shapes [ idx ] . tagged = true ;
2014-02-10 02:10:30 +01:00
}
//put the ones to remove
2017-03-05 16:44:50 +01:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
toremove [ toremove_count ] . body_id = E - > key ( ) ;
toremove [ toremove_count ] . pair = E - > get ( ) . shapes [ i ] ;
2014-02-10 02:10:30 +01:00
toremove_count + + ;
}
}
}
//process remotions
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < toremove_count ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
for ( int i = 0 ; i < toadd_count ; i + + ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
state = NULL ;
2014-02-10 02:10:30 +01:00
}
void RigidBody : : _notification ( int p_what ) {
2017-08-05 21:06:15 +02:00
# ifdef TOOLS_ENABLED
if ( p_what = = NOTIFICATION_ENTER_TREE ) {
2017-08-19 01:02:56 +02:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 21:06:15 +02:00
set_notify_local_transform ( true ) ; //used for warnings and only in editor
}
}
if ( p_what = = NOTIFICATION_LOCAL_TRANSFORM_CHANGED ) {
2017-08-19 01:02:56 +02:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-08-05 21:06:15 +02:00
update_configuration_warning ( ) ;
}
}
# endif
2014-02-10 02:10:30 +01:00
}
void RigidBody : : set_mode ( Mode p_mode ) {
2017-03-05 16:44:50 +01:00
mode = p_mode ;
switch ( p_mode ) {
2014-02-10 02:10:30 +01:00
case MODE_RIGID : {
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_RIGID ) ;
2014-02-10 02:10:30 +01:00
} break ;
case MODE_STATIC : {
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_STATIC ) ;
2014-02-10 02:10:30 +01:00
} break ;
case MODE_CHARACTER : {
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_CHARACTER ) ;
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-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_KINEMATIC ) ;
2014-02-10 02:10:30 +01:00
} break ;
}
}
2017-03-05 16:44:50 +01:00
RigidBody : : Mode RigidBody : : get_mode ( ) const {
2014-02-10 02:10:30 +01:00
return mode ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_mass ( real_t p_mass ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_MASS , mass ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_mass ( ) const {
2014-02-10 02:10:30 +01:00
return mass ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_weight ( real_t p_weight ) {
2014-02-10 02:10:30 +01:00
2017-07-04 14:57:15 +02:00
set_mass ( p_weight / real_t ( GLOBAL_DEF ( " physics/3d/default_gravity " , 9.8 ) ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_weight ( ) const {
2014-02-10 02:10:30 +01:00
2017-07-04 14:57:15 +02:00
return mass * real_t ( GLOBAL_DEF ( " physics/3d/default_gravity " , 9.8 ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_friction ( real_t p_friction ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_friction < 0 | | p_friction > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
friction = p_friction ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_FRICTION , friction ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_friction ( ) const {
2014-02-10 02:10:30 +01:00
return friction ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_bounce ( real_t p_bounce ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bounce = p_bounce ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_BOUNCE , bounce ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_bounce ( ) const {
2014-02-10 02:10:30 +01:00
return bounce ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_gravity_scale ( real_t p_gravity_scale ) {
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
gravity_scale = p_gravity_scale ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_GRAVITY_SCALE , gravity_scale ) ;
2015-08-30 23:57:17 +02:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_gravity_scale ( ) const {
2015-08-30 23:57:17 +02:00
return gravity_scale ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_linear_damp ( real_t p_linear_damp ) {
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_linear_damp < - 1 ) ;
linear_damp = p_linear_damp ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_LINEAR_DAMP , linear_damp ) ;
2015-08-30 23:57:17 +02:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_linear_damp ( ) const {
2015-08-30 23:57:17 +02:00
return linear_damp ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_angular_damp ( real_t p_angular_damp ) {
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND ( p_angular_damp < - 1 ) ;
angular_damp = p_angular_damp ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_ANGULAR_DAMP , angular_damp ) ;
2015-08-30 23:57:17 +02:00
}
2017-03-05 16:44:50 +01:00
real_t RigidBody : : get_angular_damp ( ) const {
2015-08-30 23:57:17 +02:00
return angular_damp ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_axis_velocity ( const Vector3 & p_axis ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Vector3 v = state ? state - > get_linear_velocity ( ) : linear_velocity ;
2014-02-10 02:10:30 +01:00
Vector3 axis = p_axis . normalized ( ) ;
2017-03-05 16:44:50 +01:00
v - = axis * axis . dot ( v ) ;
v + = p_axis ;
2014-02-10 02:10:30 +01:00
if ( state ) {
set_linear_velocity ( v ) ;
} else {
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_axis_velocity ( get_rid ( ) , p_axis ) ;
linear_velocity = v ;
2014-02-10 02:10:30 +01:00
}
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_linear_velocity ( const Vector3 & p_velocity ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_LINEAR_VELOCITY , linear_velocity ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Vector3 RigidBody : : get_linear_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return linear_velocity ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_angular_velocity ( const Vector3 & p_velocity ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_ANGULAR_VELOCITY , angular_velocity ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Vector3 RigidBody : : get_angular_velocity ( ) const {
2014-02-10 02:10:30 +01:00
return angular_velocity ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : set_use_custom_integrator ( bool p_enable ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
if ( custom_integrator = = p_enable )
2014-02-10 02:10:30 +01:00
return ;
2017-03-05 16:44:50 +01:00
custom_integrator = p_enable ;
PhysicsServer : : get_singleton ( ) - > body_set_omit_force_integration ( get_rid ( ) , p_enable ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
bool RigidBody : : is_using_custom_integrator ( ) {
2014-02-10 02:10:30 +01:00
return custom_integrator ;
}
2014-09-22 05:50:48 +02:00
void RigidBody : : set_sleeping ( bool p_sleeping ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
sleeping = p_sleeping ;
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_SLEEPING , sleeping ) ;
2014-02-10 02:10:30 +01:00
}
void RigidBody : : set_can_sleep ( bool p_active ) {
2017-03-05 16:44:50 +01:00
can_sleep = p_active ;
PhysicsServer : : get_singleton ( ) - > body_set_state ( get_rid ( ) , PhysicsServer : : BODY_STATE_CAN_SLEEP , p_active ) ;
2014-02-10 02:10:30 +01:00
}
bool RigidBody : : is_able_to_sleep ( ) const {
return can_sleep ;
}
2014-09-22 05:50:48 +02:00
bool RigidBody : : 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 RigidBody : : set_max_contacts_reported ( int p_amount ) {
2017-03-05 16:44:50 +01:00
max_contacts_reported = p_amount ;
PhysicsServer : : get_singleton ( ) - > body_set_max_contacts_reported ( get_rid ( ) , p_amount ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
int RigidBody : : get_max_contacts_reported ( ) const {
2014-02-10 02:10:30 +01:00
return max_contacts_reported ;
}
2017-03-05 16:44:50 +01:00
void RigidBody : : apply_impulse ( const Vector3 & p_pos , const Vector3 & p_impulse ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_apply_impulse ( get_rid ( ) , p_pos , p_impulse ) ;
2014-02-10 02:10:30 +01:00
}
2018-01-25 09:45:00 +01:00
void RigidBody : : apply_torque_impulse ( const Vector3 & p_impulse ) {
PhysicsServer : : get_singleton ( ) - > body_apply_torque_impulse ( get_rid ( ) , p_impulse ) ;
}
2014-02-10 02:10:30 +01:00
void RigidBody : : set_use_continuous_collision_detection ( bool p_enable ) {
2017-03-05 16:44:50 +01:00
ccd = p_enable ;
PhysicsServer : : get_singleton ( ) - > body_set_enable_continuous_collision_detection ( get_rid ( ) , p_enable ) ;
2014-02-10 02:10:30 +01:00
}
bool RigidBody : : is_using_continuous_collision_detection ( ) const {
return ccd ;
}
void RigidBody : : set_contact_monitor ( bool p_enabled ) {
2017-03-05 16:44:50 +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-05 16:44:50 +01:00
for ( Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
//clean up mess
2018-01-21 12:46:13 +01:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
Node * node = Object : : cast_to < Node > ( obj ) ;
if ( node ) {
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_entered , this , SceneStringNames : : get_singleton ( ) - > _body_enter_tree ) ;
node - > disconnect ( SceneStringNames : : get_singleton ( ) - > tree_exiting , this , SceneStringNames : : get_singleton ( ) - > _body_exit_tree ) ;
}
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
memdelete ( contact_monitor ) ;
contact_monitor = NULL ;
2014-02-10 02:10:30 +01:00
} else {
2017-03-05 16:44:50 +01:00
contact_monitor = memnew ( ContactMonitor ) ;
contact_monitor - > locked = false ;
2014-02-10 02:10:30 +01:00
}
}
bool RigidBody : : is_contact_monitor_enabled ( ) const {
2017-03-05 16:44:50 +01:00
return contact_monitor ! = NULL ;
2014-02-10 02:10:30 +01:00
}
2017-12-10 17:21:14 +01:00
void RigidBody : : set_axis_lock ( PhysicsServer : : BodyAxis p_axis , bool p_lock ) {
PhysicsServer : : get_singleton ( ) - > body_set_axis_lock ( get_rid ( ) , p_axis , p_lock ) ;
2017-11-08 22:35:47 +01:00
}
2017-12-10 17:21:14 +01:00
bool RigidBody : : get_axis_lock ( PhysicsServer : : BodyAxis p_axis ) const {
return PhysicsServer : : get_singleton ( ) - > body_is_axis_locked ( get_rid ( ) , p_axis ) ;
2014-05-14 06:22:15 +02:00
}
2014-02-10 02:10:30 +01:00
2014-11-13 04:53:12 +01:00
Array RigidBody : : get_colliding_bodies ( ) const {
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V ( ! contact_monitor , Array ( ) ) ;
2014-11-13 04:53:12 +01:00
Array ret ;
ret . resize ( contact_monitor - > body_map . size ( ) ) ;
2017-03-05 16:44:50 +01:00
int idx = 0 ;
for ( const Map < ObjectID , BodyState > : : Element * E = contact_monitor - > body_map . front ( ) ; E ; E = E - > next ( ) ) {
2014-11-13 04:53:12 +01:00
Object * obj = ObjectDB : : get_instance ( E - > key ( ) ) ;
if ( ! obj ) {
2017-03-05 16:44:50 +01:00
ret . resize ( ret . size ( ) - 1 ) ; //ops
2014-11-13 04:53:12 +01:00
} else {
2017-03-05 16:44:50 +01:00
ret [ idx + + ] = obj ;
2014-11-13 04:53:12 +01:00
}
}
return ret ;
}
2017-08-05 21:06:15 +02:00
String RigidBody : : get_configuration_warning ( ) const {
Transform t = get_transform ( ) ;
String warning = CollisionObject : : get_configuration_warning ( ) ;
2018-04-09 08:28:31 +02:00
if ( ( get_mode ( ) = = MODE_RIGID | | get_mode ( ) = = MODE_CHARACTER ) & & ( ABS ( t . basis . get_axis ( 0 ) . length ( ) - 1.0 ) > 0.05 | | ABS ( t . basis . get_axis ( 1 ) . length ( ) - 1.0 ) > 0.05 | | ABS ( t . basis . get_axis ( 2 ) . length ( ) - 1.0 ) > 0.05 ) ) {
2017-08-05 21:06:15 +02:00
if ( warning ! = String ( ) ) {
warning + = " \n " ;
}
2018-01-18 21:37:17 +01:00
warning + = TTR ( " Size changes to RigidBody (in character or rigid modes) will be overridden by the physics engine when running. \n Change the size in children collision shapes instead. " ) ;
2017-08-05 21:06:15 +02:00
}
return warning ;
}
2014-02-10 02:10:30 +01:00
void RigidBody : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_mode " , " mode " ) , & RigidBody : : set_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " get_mode " ) , & RigidBody : : get_mode ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_mass " , " mass " ) , & RigidBody : : set_mass ) ;
ClassDB : : bind_method ( D_METHOD ( " get_mass " ) , & RigidBody : : get_mass ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_weight " , " weight " ) , & RigidBody : : set_weight ) ;
ClassDB : : bind_method ( D_METHOD ( " get_weight " ) , & RigidBody : : get_weight ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_friction " , " friction " ) , & RigidBody : : set_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " get_friction " ) , & RigidBody : : get_friction ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_bounce " , " bounce " ) , & RigidBody : : set_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " get_bounce " ) , & RigidBody : : get_bounce ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_linear_velocity " , " linear_velocity " ) , & RigidBody : : set_linear_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_linear_velocity " ) , & RigidBody : : get_linear_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_angular_velocity " , " angular_velocity " ) , & RigidBody : : set_angular_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_angular_velocity " ) , & RigidBody : : get_angular_velocity ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_gravity_scale " , " gravity_scale " ) , & RigidBody : : set_gravity_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_gravity_scale " ) , & RigidBody : : get_gravity_scale ) ;
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_linear_damp " , " linear_damp " ) , & RigidBody : : set_linear_damp ) ;
ClassDB : : bind_method ( D_METHOD ( " get_linear_damp " ) , & RigidBody : : get_linear_damp ) ;
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_angular_damp " , " angular_damp " ) , & RigidBody : : set_angular_damp ) ;
ClassDB : : bind_method ( D_METHOD ( " get_angular_damp " ) , & RigidBody : : get_angular_damp ) ;
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_max_contacts_reported " , " amount " ) , & RigidBody : : set_max_contacts_reported ) ;
ClassDB : : bind_method ( D_METHOD ( " get_max_contacts_reported " ) , & RigidBody : : get_max_contacts_reported ) ;
2015-08-30 23:57:17 +02:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_use_custom_integrator " , " enable " ) , & RigidBody : : set_use_custom_integrator ) ;
ClassDB : : bind_method ( D_METHOD ( " is_using_custom_integrator " ) , & RigidBody : : is_using_custom_integrator ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_contact_monitor " , " enabled " ) , & RigidBody : : set_contact_monitor ) ;
ClassDB : : bind_method ( D_METHOD ( " is_contact_monitor_enabled " ) , & RigidBody : : is_contact_monitor_enabled ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_use_continuous_collision_detection " , " enable " ) , & RigidBody : : set_use_continuous_collision_detection ) ;
ClassDB : : bind_method ( D_METHOD ( " is_using_continuous_collision_detection " ) , & RigidBody : : is_using_continuous_collision_detection ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_axis_velocity " , " axis_velocity " ) , & RigidBody : : set_axis_velocity ) ;
2017-09-10 15:37:49 +02:00
ClassDB : : bind_method ( D_METHOD ( " apply_impulse " , " position " , " impulse " ) , & RigidBody : : apply_impulse ) ;
2018-01-25 09:45:00 +01:00
ClassDB : : bind_method ( D_METHOD ( " apply_torque_impulse " , " impulse " ) , & RigidBody : : apply_torque_impulse ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_sleeping " , " sleeping " ) , & RigidBody : : set_sleeping ) ;
ClassDB : : bind_method ( D_METHOD ( " is_sleeping " ) , & RigidBody : : is_sleeping ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_can_sleep " , " able_to_sleep " ) , & RigidBody : : set_can_sleep ) ;
ClassDB : : bind_method ( D_METHOD ( " is_able_to_sleep " ) , & RigidBody : : is_able_to_sleep ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _direct_state_changed " ) , & RigidBody : : _direct_state_changed ) ;
ClassDB : : bind_method ( D_METHOD ( " _body_enter_tree " ) , & RigidBody : : _body_enter_tree ) ;
ClassDB : : bind_method ( D_METHOD ( " _body_exit_tree " ) , & RigidBody : : _body_exit_tree ) ;
2014-02-10 02:10:30 +01:00
2017-12-10 17:21:14 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_axis_lock " , " axis " , " lock " ) , & RigidBody : : set_axis_lock ) ;
ClassDB : : bind_method ( D_METHOD ( " get_axis_lock " , " axis " ) , & RigidBody : : get_axis_lock ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_colliding_bodies " ) , & RigidBody : : get_colliding_bodies ) ;
2014-05-14 06:22:15 +02:00
2017-08-29 07:15:46 +02:00
BIND_VMETHOD ( MethodInfo ( " _integrate_forces " , PropertyInfo ( Variant : : OBJECT , " state " , PROPERTY_HINT_RESOURCE_TYPE , " PhysicsDirectBodyState " ) ) ) ;
2014-11-13 04:53:12 +01:00
2017-03-05 16:44:50 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " mode " , PROPERTY_HINT_ENUM , " Rigid,Static,Character,Kinematic " ) , " set_mode " , " get_mode " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " mass " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " ) , " set_mass " , " get_mass " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " weight " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " , PROPERTY_USAGE_EDITOR ) , " set_weight " , " get_weight " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_friction " , " get_friction " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_bounce " , " get_bounce " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " gravity_scale " , PROPERTY_HINT_RANGE , " -128,128,0.01 " ) , " set_gravity_scale " , " get_gravity_scale " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " custom_integrator " ) , " set_use_custom_integrator " , " is_using_custom_integrator " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " continuous_cd " ) , " set_use_continuous_collision_detection " , " is_using_continuous_collision_detection " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " contacts_reported " ) , " set_max_contacts_reported " , " get_max_contacts_reported " ) ;
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 " ) ;
2017-11-08 22:35:47 +01:00
ADD_GROUP ( " Axis Lock " , " axis_lock_ " ) ;
2017-12-10 17:21:14 +01:00
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_x " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_X ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_y " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_Y ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_z " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_Z ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_x " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_X ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_y " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_Y ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_z " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_Z ) ;
2017-03-05 16:44:50 +01:00
ADD_GROUP ( " Linear " , " linear_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " linear_velocity " ) , " set_linear_velocity " , " get_linear_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " linear_damp " , PROPERTY_HINT_RANGE , " -1,128,0.01 " ) , " set_linear_damp " , " get_linear_damp " ) ;
ADD_GROUP ( " Angular " , " angular_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " angular_velocity " ) , " set_angular_velocity " , " get_angular_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " angular_damp " , PROPERTY_HINT_RANGE , " -1,128,0.01 " ) , " set_angular_damp " , " get_angular_damp " ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ADD_SIGNAL ( MethodInfo ( " body_shape_entered " , PropertyInfo ( Variant : : INT , " body_id " ) , PropertyInfo ( Variant : : OBJECT , " body " ) , 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 " ) , PropertyInfo ( Variant : : INT , " body_shape " ) , PropertyInfo ( Variant : : INT , " local_shape " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_entered " , PropertyInfo ( Variant : : OBJECT , " body " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " body_exited " , PropertyInfo ( Variant : : OBJECT , " body " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " sleeping_state_changed " ) ) ;
2014-02-10 02:10:30 +01:00
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( MODE_RIGID ) ;
2017-10-21 20:58:02 +02:00
BIND_ENUM_CONSTANT ( MODE_STATIC ) ;
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( MODE_CHARACTER ) ;
2017-10-21 20:58:02 +02:00
BIND_ENUM_CONSTANT ( MODE_KINEMATIC ) ;
2014-02-10 02:10:30 +01:00
}
2017-12-06 21:36:34 +01:00
RigidBody : : RigidBody ( ) :
PhysicsBody ( PhysicsServer : : BODY_MODE_RIGID ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
mode = MODE_RIGID ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bounce = 0 ;
mass = 1 ;
friction = 1 ;
max_contacts_reported = 0 ;
state = NULL ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
gravity_scale = 1 ;
linear_damp = - 1 ;
angular_damp = - 1 ;
2015-08-30 23:57:17 +02:00
2014-02-10 02:10:30 +01:00
//angular_velocity=0;
2017-03-05 16:44:50 +01:00
sleeping = false ;
ccd = false ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
custom_integrator = false ;
contact_monitor = NULL ;
can_sleep = true ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
2014-02-10 02:10:30 +01:00
}
RigidBody : : ~ RigidBody ( ) {
if ( contact_monitor )
2017-03-05 16:44:50 +01:00
memdelete ( contact_monitor ) ;
2014-02-10 02:10:30 +01:00
}
2014-09-03 04:13:40 +02:00
//////////////////////////////////////////////////////
//////////////////////////
2018-02-16 19:06:00 +01:00
Ref < KinematicCollision > KinematicBody : : _move ( const Vector3 & p_motion , bool p_infinite_inertia ) {
2017-07-15 06:23:10 +02:00
Collision col ;
2018-02-16 19:06:00 +01:00
if ( move_and_collide ( p_motion , p_infinite_inertia , col ) ) {
2017-09-04 12:48:14 +02:00
if ( motion_cache . is_null ( ) ) {
motion_cache . instance ( ) ;
motion_cache - > owner = this ;
2017-07-15 06:23:10 +02:00
}
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
motion_cache - > collision = col ;
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
return motion_cache ;
2014-09-03 04:13:40 +02:00
}
2017-09-04 12:48:14 +02:00
return Ref < KinematicCollision > ( ) ;
2014-09-03 04:13:40 +02:00
}
2018-02-16 19:06:00 +01:00
bool KinematicBody : : move_and_collide ( const Vector3 & p_motion , bool p_infinite_inertia , Collision & r_collision ) {
2017-04-13 20:37:17 +02:00
Transform gt = get_global_transform ( ) ;
2017-07-15 06:23:10 +02:00
PhysicsServer : : MotionResult result ;
2018-02-16 19:06:00 +01:00
bool colliding = PhysicsServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , gt , p_motion , p_infinite_inertia , & result ) ;
2017-07-15 06:23:10 +02:00
if ( colliding ) {
r_collision . collider_metadata = result . collider_metadata ;
r_collision . collider_shape = result . collider_shape ;
r_collision . collider_vel = result . collider_velocity ;
r_collision . collision = result . collision_point ;
r_collision . normal = result . collision_normal ;
r_collision . collider = result . collider_id ;
r_collision . travel = result . motion ;
r_collision . remainder = result . remainder ;
r_collision . local_shape = result . collision_local_shape ;
2014-09-03 04:13:40 +02:00
}
2017-11-08 22:35:47 +01:00
for ( int i = 0 ; i < 3 ; i + + ) {
2017-12-10 17:21:14 +01:00
if ( locked_axis & ( 1 < < i ) ) {
2017-11-08 22:35:47 +01:00
result . motion [ i ] = 0 ;
}
}
2017-07-15 06:23:10 +02:00
gt . origin + = result . motion ;
2014-09-03 04:13:40 +02:00
set_global_transform ( gt ) ;
2017-07-15 06:23:10 +02:00
return colliding ;
2014-09-03 04:13:40 +02:00
}
2018-07-01 11:38:13 +02:00
Vector3 KinematicBody : : move_and_slide ( const Vector3 & p_linear_velocity , const Vector3 & p_floor_direction , float p_slope_stop_min_velocity , int p_max_slides , float p_floor_max_angle , bool p_infinite_inertia ) {
2017-04-13 20:37:17 +02:00
Vector3 lv = p_linear_velocity ;
2017-11-08 22:35:47 +01:00
for ( int i = 0 ; i < 3 ; i + + ) {
2017-12-10 17:21:14 +01:00
if ( locked_axis & ( 1 < < i ) ) {
2017-11-08 22:35:47 +01:00
lv [ i ] = 0 ;
}
}
Vector3 motion = ( floor_velocity + lv ) * get_physics_process_delta_time ( ) ;
2017-07-15 06:23:10 +02:00
on_floor = false ;
on_ceiling = false ;
on_wall = false ;
colliders . clear ( ) ;
floor_velocity = Vector3 ( ) ;
2017-04-13 20:37:17 +02:00
2017-09-04 12:48:14 +02:00
while ( p_max_slides ) {
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
Collision collision ;
2017-04-13 20:37:17 +02:00
2018-02-16 19:06:00 +01:00
bool collided = move_and_collide ( motion , p_infinite_inertia , collision ) ;
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
if ( collided ) {
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
motion = collision . remainder ;
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
if ( p_floor_direction = = Vector3 ( ) ) {
//all is a wall
on_wall = true ;
} else {
if ( collision . normal . dot ( p_floor_direction ) > = Math : : cos ( p_floor_max_angle ) ) { //floor
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
on_floor = true ;
floor_velocity = collision . collider_vel ;
2017-04-13 20:37:17 +02:00
2017-11-09 21:31:29 +01:00
Vector3 rel_v = lv - floor_velocity ;
Vector3 hv = rel_v - p_floor_direction * p_floor_direction . dot ( rel_v ) ;
if ( collision . travel . length ( ) < 0.05 & & hv . length ( ) < p_slope_stop_min_velocity ) {
2017-07-15 06:23:10 +02:00
Transform gt = get_global_transform ( ) ;
2017-11-09 21:31:29 +01:00
gt . origin - = collision . travel ;
2017-07-15 06:23:10 +02:00
set_global_transform ( gt ) ;
2017-11-10 03:34:01 +01:00
return floor_velocity - p_floor_direction * p_floor_direction . dot ( floor_velocity ) ;
2017-11-09 21:31:29 +01:00
}
2017-07-15 06:23:10 +02:00
} else if ( collision . normal . dot ( - p_floor_direction ) > = Math : : cos ( p_floor_max_angle ) ) { //ceiling
on_ceiling = true ;
} else {
on_wall = true ;
2017-04-13 20:37:17 +02:00
}
}
2017-07-15 06:23:10 +02:00
Vector3 n = collision . normal ;
2017-04-13 20:37:17 +02:00
motion = motion . slide ( n ) ;
lv = lv . slide ( n ) ;
2017-07-15 06:23:10 +02:00
2017-11-08 22:35:47 +01:00
for ( int i = 0 ; i < 3 ; i + + ) {
2017-12-10 17:21:14 +01:00
if ( locked_axis & ( 1 < < i ) ) {
2017-11-08 22:35:47 +01:00
lv [ i ] = 0 ;
}
}
2017-07-15 06:23:10 +02:00
colliders . push_back ( collision ) ;
2017-04-13 20:37:17 +02:00
} else {
break ;
}
2017-09-04 12:48:14 +02:00
p_max_slides - - ;
2017-04-13 20:37:17 +02:00
if ( motion = = Vector3 ( ) )
break ;
}
return lv ;
}
2017-07-15 06:23:10 +02:00
bool KinematicBody : : is_on_floor ( ) const {
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
return on_floor ;
2017-04-13 20:37:17 +02:00
}
2017-07-15 06:23:10 +02:00
bool KinematicBody : : is_on_wall ( ) const {
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
return on_wall ;
2017-04-13 20:37:17 +02:00
}
2017-07-15 06:23:10 +02:00
bool KinematicBody : : is_on_ceiling ( ) const {
2017-04-13 20:37:17 +02:00
2017-07-15 06:23:10 +02:00
return on_ceiling ;
2017-04-13 20:37:17 +02:00
}
2017-07-15 06:23:10 +02:00
Vector3 KinematicBody : : get_floor_velocity ( ) const {
2014-09-03 04:13:40 +02:00
2017-07-15 06:23:10 +02:00
return floor_velocity ;
2014-09-03 04:13:40 +02:00
}
2018-02-16 19:06:00 +01:00
bool KinematicBody : : test_move ( const Transform & p_from , const Vector3 & p_motion , bool p_infinite_inertia ) {
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V ( ! is_inside_tree ( ) , false ) ;
2014-09-03 04:13:40 +02:00
2018-02-16 19:06:00 +01:00
return PhysicsServer : : get_singleton ( ) - > body_test_motion ( get_rid ( ) , p_from , p_motion , p_infinite_inertia ) ;
2014-09-03 04:13:40 +02:00
}
2017-12-10 17:21:14 +01:00
void KinematicBody : : set_axis_lock ( PhysicsServer : : BodyAxis p_axis , bool p_lock ) {
PhysicsServer : : get_singleton ( ) - > body_set_axis_lock ( get_rid ( ) , p_axis , p_lock ) ;
2017-11-08 22:35:47 +01:00
}
2017-12-10 17:21:14 +01:00
bool KinematicBody : : get_axis_lock ( PhysicsServer : : BodyAxis p_axis ) const {
return PhysicsServer : : get_singleton ( ) - > body_is_axis_locked ( get_rid ( ) , p_axis ) ;
2017-11-08 22:35:47 +01:00
}
2017-07-15 06:23:10 +02:00
void KinematicBody : : set_safe_margin ( float p_margin ) {
2014-09-03 04:13:40 +02:00
2017-07-15 06:23:10 +02:00
margin = p_margin ;
2017-11-07 15:22:09 +01:00
PhysicsServer : : get_singleton ( ) - > body_set_kinematic_safe_margin ( get_rid ( ) , margin ) ;
2014-09-03 04:13:40 +02:00
}
2017-07-15 06:23:10 +02:00
float KinematicBody : : get_safe_margin ( ) const {
2014-09-03 04:13:40 +02:00
2017-07-15 06:23:10 +02:00
return margin ;
2014-09-03 04:13:40 +02:00
}
2017-09-04 12:48:14 +02:00
int KinematicBody : : get_slide_count ( ) const {
2014-09-03 04:13:40 +02:00
2017-07-15 06:23:10 +02:00
return colliders . size ( ) ;
2014-09-03 04:13:40 +02:00
}
2017-09-04 12:48:14 +02:00
KinematicBody : : Collision KinematicBody : : get_slide_collision ( int p_bounce ) const {
ERR_FAIL_INDEX_V ( p_bounce , colliders . size ( ) , Collision ( ) ) ;
return colliders [ p_bounce ] ;
2014-09-03 04:13:40 +02:00
}
2017-09-04 12:48:14 +02:00
Ref < KinematicCollision > KinematicBody : : _get_slide_collision ( int p_bounce ) {
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
ERR_FAIL_INDEX_V ( p_bounce , colliders . size ( ) , Ref < KinematicCollision > ( ) ) ;
2017-09-10 18:07:47 +02:00
if ( p_bounce > = slide_colliders . size ( ) ) {
2017-09-04 12:48:14 +02:00
slide_colliders . resize ( p_bounce + 1 ) ;
2017-07-15 06:23:10 +02:00
}
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
if ( slide_colliders [ p_bounce ] . is_null ( ) ) {
slide_colliders [ p_bounce ] . instance ( ) ;
slide_colliders [ p_bounce ] - > owner = this ;
2017-07-15 06:23:10 +02:00
}
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
slide_colliders [ p_bounce ] - > collision = colliders [ p_bounce ] ;
return slide_colliders [ p_bounce ] ;
2014-09-03 04:13:40 +02:00
}
void KinematicBody : : _bind_methods ( ) {
2018-02-16 19:06:00 +01:00
ClassDB : : bind_method ( D_METHOD ( " move_and_collide " , " rel_vec " , " infinite_inertia " ) , & KinematicBody : : _move , DEFVAL ( true ) ) ;
2018-07-01 11:38:13 +02:00
ClassDB : : bind_method ( D_METHOD ( " move_and_slide " , " linear_velocity " , " floor_normal " , " slope_stop_min_velocity " , " max_slides " , " floor_max_angle " , " infinite_inertia " ) , & KinematicBody : : move_and_slide , DEFVAL ( Vector3 ( 0 , 0 , 0 ) ) , DEFVAL ( 0.05 ) , DEFVAL ( 4 ) , DEFVAL ( Math : : deg2rad ( ( float ) 45 ) ) , DEFVAL ( true ) ) ;
2014-09-03 04:13:40 +02:00
2018-02-16 19:06:00 +01:00
ClassDB : : bind_method ( D_METHOD ( " test_move " , " from " , " rel_vec " , " infinite_inertia " ) , & KinematicBody : : test_move ) ;
2014-09-03 04:13:40 +02:00
2017-07-15 06:23:10 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_on_floor " ) , & KinematicBody : : is_on_floor ) ;
ClassDB : : bind_method ( D_METHOD ( " is_on_ceiling " ) , & KinematicBody : : is_on_ceiling ) ;
ClassDB : : bind_method ( D_METHOD ( " is_on_wall " ) , & KinematicBody : : is_on_wall ) ;
ClassDB : : bind_method ( D_METHOD ( " get_floor_velocity " ) , & KinematicBody : : get_floor_velocity ) ;
2014-09-03 04:13:40 +02:00
2017-12-11 01:42:16 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_axis_lock " , " axis " , " lock " ) , & KinematicBody : : set_axis_lock ) ;
ClassDB : : bind_method ( D_METHOD ( " get_axis_lock " , " axis " ) , & KinematicBody : : get_axis_lock ) ;
2017-11-08 22:35:47 +01:00
2017-07-15 06:23:10 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_safe_margin " , " pixels " ) , & KinematicBody : : set_safe_margin ) ;
2017-08-09 13:54:55 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_safe_margin " ) , & KinematicBody : : get_safe_margin ) ;
2014-09-03 04:13:40 +02:00
2017-09-04 12:48:14 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_slide_count " ) , & KinematicBody : : get_slide_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_slide_collision " , " slide_idx " ) , & KinematicBody : : _get_slide_collision ) ;
2014-09-03 04:13:40 +02:00
2017-11-08 22:35:47 +01:00
ADD_GROUP ( " Axis Lock " , " axis_lock_ " ) ;
2017-12-10 17:21:14 +01:00
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_x " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_X ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_y " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_Y ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_linear_z " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_LINEAR_Z ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_x " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_X ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_y " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_Y ) ;
ADD_PROPERTYI ( PropertyInfo ( Variant : : BOOL , " axis_lock_angular_z " ) , " set_axis_lock " , " get_axis_lock " , PhysicsServer : : BODY_AXIS_ANGULAR_Z ) ;
2017-11-08 22:35:47 +01:00
2017-07-15 06:23:10 +02:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " collision/safe_margin " , PROPERTY_HINT_RANGE , " 0.001,256,0.001 " ) , " set_safe_margin " , " get_safe_margin " ) ;
2014-09-03 04:13:40 +02:00
}
2017-12-06 21:36:34 +01:00
KinematicBody : : KinematicBody ( ) :
PhysicsBody ( PhysicsServer : : BODY_MODE_KINEMATIC ) {
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
margin = 0.001 ;
2017-12-10 17:21:14 +01:00
locked_axis = 0 ;
2017-07-15 06:23:10 +02:00
on_floor = false ;
on_ceiling = false ;
on_wall = false ;
2014-09-03 04:13:40 +02:00
}
2017-03-05 16:44:50 +01:00
KinematicBody : : ~ KinematicBody ( ) {
2017-09-04 12:48:14 +02: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 ( ) ) {
slide_colliders [ i ] - > owner = NULL ;
}
}
}
///////////////////////////////////////
Vector3 KinematicCollision : : get_position ( ) const {
return collision . collision ;
}
Vector3 KinematicCollision : : get_normal ( ) const {
return collision . normal ;
}
Vector3 KinematicCollision : : get_travel ( ) const {
return collision . travel ;
}
Vector3 KinematicCollision : : get_remainder ( ) const {
return collision . remainder ;
}
Object * KinematicCollision : : get_local_shape ( ) const {
ERR_FAIL_COND_V ( ! owner , NULL ) ;
uint32_t ownerid = owner - > shape_find_owner ( collision . local_shape ) ;
return owner - > shape_owner_get_owner ( ownerid ) ;
}
Object * KinematicCollision : : get_collider ( ) const {
if ( collision . collider ) {
return ObjectDB : : get_instance ( collision . collider ) ;
}
return NULL ;
}
ObjectID KinematicCollision : : get_collider_id ( ) const {
return collision . collider ;
}
Object * KinematicCollision : : get_collider_shape ( ) const {
Object * collider = get_collider ( ) ;
if ( collider ) {
CollisionObject * obj2d = Object : : cast_to < CollisionObject > ( collider ) ;
if ( obj2d ) {
uint32_t ownerid = obj2d - > shape_find_owner ( collision . collider_shape ) ;
return obj2d - > shape_owner_get_owner ( ownerid ) ;
}
}
return NULL ;
}
int KinematicCollision : : get_collider_shape_index ( ) const {
return collision . collider_shape ;
}
Vector3 KinematicCollision : : get_collider_velocity ( ) const {
return collision . collider_vel ;
}
Variant KinematicCollision : : get_collider_metadata ( ) const {
return Variant ( ) ;
}
void KinematicCollision : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " get_position " ) , & KinematicCollision : : get_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_normal " ) , & KinematicCollision : : get_normal ) ;
ClassDB : : bind_method ( D_METHOD ( " get_travel " ) , & KinematicCollision : : get_travel ) ;
ClassDB : : bind_method ( D_METHOD ( " get_remainder " ) , & KinematicCollision : : get_remainder ) ;
ClassDB : : bind_method ( D_METHOD ( " get_local_shape " ) , & KinematicCollision : : get_local_shape ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider " ) , & KinematicCollision : : get_collider ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_id " ) , & KinematicCollision : : get_collider_id ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_shape " ) , & KinematicCollision : : get_collider_shape ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_shape_index " ) , & KinematicCollision : : get_collider_shape_index ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_velocity " ) , & KinematicCollision : : get_collider_velocity ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collider_metadata " ) , & KinematicCollision : : get_collider_metadata ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " position " ) , " " , " get_position " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " normal " ) , " " , " get_normal " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " travel " ) , " " , " get_travel " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR3 , " 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 : : VECTOR3 , " collider_velocity " ) , " " , " get_collider_velocity " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : NIL , " collider_metadata " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NIL_IS_VARIANT ) , " " , " get_collider_metadata " ) ;
}
KinematicCollision : : KinematicCollision ( ) {
collision . collider = 0 ;
collision . collider_shape = 0 ;
collision . local_shape = 0 ;
owner = NULL ;
2014-09-03 04:13:40 +02:00
}
2017-10-03 18:49:32 +02:00
///////////////////////////////////////
bool PhysicalBone : : JointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
return false ;
}
bool PhysicalBone : : JointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
return false ;
}
void PhysicalBone : : JointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
}
bool PhysicalBone : : PinJointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
if ( JointData : : _set ( p_name , p_value , j ) ) {
return true ;
}
if ( " joint_constraints/bias " = = p_name ) {
bias = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( j , PhysicsServer : : PIN_JOINT_BIAS , bias ) ;
} else if ( " joint_constraints/damping " = = p_name ) {
damping = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( j , PhysicsServer : : PIN_JOINT_DAMPING , damping ) ;
} else if ( " joint_constraints/impulse_clamp " = = p_name ) {
impulse_clamp = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( j , PhysicsServer : : PIN_JOINT_IMPULSE_CLAMP , impulse_clamp ) ;
} else {
return false ;
}
return true ;
}
bool PhysicalBone : : PinJointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( JointData : : _get ( p_name , r_ret ) ) {
return true ;
}
if ( " joint_constraints/bias " = = p_name ) {
r_ret = bias ;
} else if ( " joint_constraints/damping " = = p_name ) {
r_ret = damping ;
} else if ( " joint_constraints/impulse_clamp " = = p_name ) {
r_ret = impulse_clamp ;
} else {
return false ;
}
return true ;
}
void PhysicalBone : : PinJointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
JointData : : _get_property_list ( p_list ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/bias " , PROPERTY_HINT_RANGE , " 0.01,0.99,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/damping " , PROPERTY_HINT_RANGE , " 0.01,8.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/impulse_clamp " , PROPERTY_HINT_RANGE , " 0.0,64.0,0.01 " ) ) ;
}
bool PhysicalBone : : ConeJointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
if ( JointData : : _set ( p_name , p_value , j ) ) {
return true ;
}
if ( " joint_constraints/swing_span " = = p_name ) {
swing_span = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( j , PhysicsServer : : CONE_TWIST_JOINT_SWING_SPAN , swing_span ) ;
} else if ( " joint_constraints/twist_span " = = p_name ) {
twist_span = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( j , PhysicsServer : : CONE_TWIST_JOINT_TWIST_SPAN , twist_span ) ;
} else if ( " joint_constraints/bias " = = p_name ) {
bias = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( j , PhysicsServer : : CONE_TWIST_JOINT_BIAS , bias ) ;
} else if ( " joint_constraints/softness " = = p_name ) {
softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( j , PhysicsServer : : CONE_TWIST_JOINT_SOFTNESS , softness ) ;
} else if ( " joint_constraints/relaxation " = = p_name ) {
relaxation = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( j , PhysicsServer : : CONE_TWIST_JOINT_RELAXATION , relaxation ) ;
} else {
return false ;
}
return true ;
}
bool PhysicalBone : : ConeJointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( JointData : : _get ( p_name , r_ret ) ) {
return true ;
}
if ( " joint_constraints/swing_span " = = p_name ) {
r_ret = Math : : rad2deg ( swing_span ) ;
} else if ( " joint_constraints/twist_span " = = p_name ) {
r_ret = Math : : rad2deg ( twist_span ) ;
} else if ( " joint_constraints/bias " = = p_name ) {
r_ret = bias ;
} else if ( " joint_constraints/softness " = = p_name ) {
r_ret = softness ;
} else if ( " joint_constraints/relaxation " = = p_name ) {
r_ret = relaxation ;
} else {
return false ;
}
return true ;
}
void PhysicalBone : : ConeJointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
JointData : : _get_property_list ( p_list ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/swing_span " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
2018-05-16 14:13:41 +02:00
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/twist_span " , PROPERTY_HINT_RANGE , " -40000,40000,0.1,or_lesser,or_greater " ) ) ;
2017-10-03 18:49:32 +02:00
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/bias " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/softness " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/relaxation " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
}
bool PhysicalBone : : HingeJointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
if ( JointData : : _set ( p_name , p_value , j ) ) {
return true ;
}
if ( " joint_constraints/angular_limit_enabled " = = p_name ) {
angular_limit_enabled = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_flag ( j , PhysicsServer : : HINGE_JOINT_FLAG_USE_LIMIT , angular_limit_enabled ) ;
} else if ( " joint_constraints/angular_limit_upper " = = p_name ) {
angular_limit_upper = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( j , PhysicsServer : : HINGE_JOINT_LIMIT_UPPER , angular_limit_upper ) ;
} else if ( " joint_constraints/angular_limit_lower " = = p_name ) {
angular_limit_lower = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( j , PhysicsServer : : HINGE_JOINT_LIMIT_LOWER , angular_limit_lower ) ;
} else if ( " joint_constraints/angular_limit_bias " = = p_name ) {
angular_limit_bias = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( j , PhysicsServer : : HINGE_JOINT_LIMIT_BIAS , angular_limit_bias ) ;
} else if ( " joint_constraints/angular_limit_softness " = = p_name ) {
angular_limit_softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( j , PhysicsServer : : HINGE_JOINT_LIMIT_SOFTNESS , angular_limit_softness ) ;
} else if ( " joint_constraints/angular_limit_relaxation " = = p_name ) {
angular_limit_relaxation = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( j , PhysicsServer : : HINGE_JOINT_LIMIT_RELAXATION , angular_limit_relaxation ) ;
} else {
return false ;
}
return true ;
}
bool PhysicalBone : : HingeJointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( JointData : : _get ( p_name , r_ret ) ) {
return true ;
}
if ( " joint_constraints/angular_limit_enabled " = = p_name ) {
r_ret = angular_limit_enabled ;
} else if ( " joint_constraints/angular_limit_upper " = = p_name ) {
r_ret = Math : : rad2deg ( angular_limit_upper ) ;
} else if ( " joint_constraints/angular_limit_lower " = = p_name ) {
r_ret = Math : : rad2deg ( angular_limit_lower ) ;
} else if ( " joint_constraints/angular_limit_bias " = = p_name ) {
r_ret = angular_limit_bias ;
} else if ( " joint_constraints/angular_limit_softness " = = p_name ) {
r_ret = angular_limit_softness ;
} else if ( " joint_constraints/angular_limit_relaxation " = = p_name ) {
r_ret = angular_limit_relaxation ;
} else {
return false ;
}
return true ;
}
void PhysicalBone : : HingeJointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
JointData : : _get_property_list ( p_list ) ;
p_list - > push_back ( PropertyInfo ( Variant : : BOOL , " joint_constraints/angular_limit_enabled " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_upper " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_lower " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_bias " , PROPERTY_HINT_RANGE , " 0.01,0.99,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_softness " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_relaxation " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
}
bool PhysicalBone : : SliderJointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
if ( JointData : : _set ( p_name , p_value , j ) ) {
return true ;
}
if ( " joint_constraints/linear_limit_upper " = = p_name ) {
linear_limit_upper = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_UPPER , linear_limit_upper ) ;
} else if ( " joint_constraints/linear_limit_lower " = = p_name ) {
linear_limit_lower = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_LOWER , linear_limit_lower ) ;
} else if ( " joint_constraints/linear_limit_softness " = = p_name ) {
linear_limit_softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS , linear_limit_softness ) ;
} else if ( " joint_constraints/linear_limit_restitution " = = p_name ) {
linear_limit_restitution = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION , linear_limit_restitution ) ;
} else if ( " joint_constraints/linear_limit_damping " = = p_name ) {
linear_limit_damping = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_DAMPING , linear_limit_restitution ) ;
} else if ( " joint_constraints/angular_limit_upper " = = p_name ) {
angular_limit_upper = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_UPPER , angular_limit_upper ) ;
} else if ( " joint_constraints/angular_limit_lower " = = p_name ) {
angular_limit_lower = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_LOWER , angular_limit_lower ) ;
} else if ( " joint_constraints/angular_limit_softness " = = p_name ) {
angular_limit_softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS , angular_limit_softness ) ;
} else if ( " joint_constraints/angular_limit_restitution " = = p_name ) {
angular_limit_restitution = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS , angular_limit_softness ) ;
} else if ( " joint_constraints/angular_limit_damping " = = p_name ) {
angular_limit_damping = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( j , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_DAMPING , angular_limit_damping ) ;
} else {
return false ;
}
return true ;
}
bool PhysicalBone : : SliderJointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( JointData : : _get ( p_name , r_ret ) ) {
return true ;
}
if ( " joint_constraints/linear_limit_upper " = = p_name ) {
r_ret = linear_limit_upper ;
} else if ( " joint_constraints/linear_limit_lower " = = p_name ) {
r_ret = linear_limit_lower ;
} else if ( " joint_constraints/linear_limit_softness " = = p_name ) {
r_ret = linear_limit_softness ;
} else if ( " joint_constraints/linear_limit_restitution " = = p_name ) {
r_ret = linear_limit_restitution ;
} else if ( " joint_constraints/linear_limit_damping " = = p_name ) {
r_ret = linear_limit_damping ;
} else if ( " joint_constraints/angular_limit_upper " = = p_name ) {
r_ret = Math : : rad2deg ( angular_limit_upper ) ;
} else if ( " joint_constraints/angular_limit_lower " = = p_name ) {
r_ret = Math : : rad2deg ( angular_limit_lower ) ;
} else if ( " joint_constraints/angular_limit_softness " = = p_name ) {
r_ret = angular_limit_softness ;
} else if ( " joint_constraints/angular_limit_restitution " = = p_name ) {
r_ret = angular_limit_restitution ;
} else if ( " joint_constraints/angular_limit_damping " = = p_name ) {
r_ret = angular_limit_damping ;
} else {
return false ;
}
return true ;
}
void PhysicalBone : : SliderJointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
JointData : : _get_property_list ( p_list ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/linear_limit_upper " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/linear_limit_lower " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/linear_limit_softness " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/linear_limit_restitution " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/linear_limit_damping " , PROPERTY_HINT_RANGE , " 0,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_upper " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_lower " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_softness " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_restitution " , PROPERTY_HINT_RANGE , " 0.01,16.0,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/angular_limit_damping " , PROPERTY_HINT_RANGE , " 0,16.0,0.01 " ) ) ;
}
bool PhysicalBone : : SixDOFJointData : : _set ( const StringName & p_name , const Variant & p_value , RID j ) {
if ( JointData : : _set ( p_name , p_value , j ) ) {
return true ;
}
String path = p_name ;
Vector3 : : Axis axis ;
{
const String axis_s = path . get_slicec ( ' / ' , 1 ) ;
if ( " x " = = axis_s ) {
axis = Vector3 : : AXIS_X ;
} else if ( " y " = = axis_s ) {
axis = Vector3 : : AXIS_Y ;
} else if ( " z " = = axis_s ) {
axis = Vector3 : : AXIS_Z ;
} else {
return false ;
}
}
String var_name = path . get_slicec ( ' / ' , 2 ) ;
if ( " linear_limit_enabled " = = var_name ) {
axis_data [ axis ] . linear_limit_enabled = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_flag ( j , axis , PhysicsServer : : G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT , axis_data [ axis ] . linear_limit_enabled ) ;
} else if ( " linear_limit_upper " = = var_name ) {
axis_data [ axis ] . linear_limit_upper = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_LINEAR_UPPER_LIMIT , axis_data [ axis ] . linear_limit_upper ) ;
} else if ( " linear_limit_lower " = = var_name ) {
axis_data [ axis ] . linear_limit_lower = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_LINEAR_LOWER_LIMIT , axis_data [ axis ] . linear_limit_lower ) ;
} else if ( " linear_limit_softness " = = var_name ) {
axis_data [ axis ] . linear_limit_softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS , axis_data [ axis ] . linear_limit_softness ) ;
} else if ( " linear_restitution " = = var_name ) {
axis_data [ axis ] . linear_restitution = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_LINEAR_RESTITUTION , axis_data [ axis ] . linear_restitution ) ;
} else if ( " linear_damping " = = var_name ) {
axis_data [ axis ] . linear_damping = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_LINEAR_DAMPING , axis_data [ axis ] . linear_damping ) ;
} else if ( " angular_limit_enabled " = = var_name ) {
axis_data [ axis ] . angular_limit_enabled = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_flag ( j , axis , PhysicsServer : : G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT , axis_data [ axis ] . angular_limit_enabled ) ;
} else if ( " angular_limit_upper " = = var_name ) {
axis_data [ axis ] . angular_limit_upper = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_UPPER_LIMIT , axis_data [ axis ] . angular_limit_upper ) ;
} else if ( " angular_limit_lower " = = var_name ) {
axis_data [ axis ] . angular_limit_lower = Math : : deg2rad ( real_t ( p_value ) ) ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_LOWER_LIMIT , axis_data [ axis ] . angular_limit_lower ) ;
} else if ( " angular_limit_softness " = = var_name ) {
axis_data [ axis ] . angular_limit_softness = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS , axis_data [ axis ] . angular_limit_softness ) ;
} else if ( " angular_restitution " = = var_name ) {
axis_data [ axis ] . angular_restitution = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_RESTITUTION , axis_data [ axis ] . angular_restitution ) ;
} else if ( " angular_damping " = = var_name ) {
axis_data [ axis ] . angular_damping = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_DAMPING , axis_data [ axis ] . angular_damping ) ;
} else if ( " erp " = = var_name ) {
axis_data [ axis ] . erp = p_value ;
if ( j . is_valid ( ) )
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( j , axis , PhysicsServer : : G6DOF_JOINT_ANGULAR_ERP , axis_data [ axis ] . erp ) ;
} else {
return false ;
}
return true ;
}
bool PhysicalBone : : SixDOFJointData : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( JointData : : _get ( p_name , r_ret ) ) {
return true ;
}
String path = p_name ;
int axis ;
{
const String axis_s = path . get_slicec ( ' / ' , 1 ) ;
if ( " x " = = axis_s ) {
axis = 0 ;
} else if ( " y " = = axis_s ) {
axis = 1 ;
} else if ( " z " = = axis_s ) {
axis = 2 ;
} else {
return false ;
}
}
String var_name = path . get_slicec ( ' / ' , 2 ) ;
if ( " linear_limit_enabled " = = var_name ) {
r_ret = axis_data [ axis ] . linear_limit_enabled ;
} else if ( " linear_limit_upper " = = var_name ) {
r_ret = axis_data [ axis ] . linear_limit_upper ;
} else if ( " linear_limit_lower " = = var_name ) {
r_ret = axis_data [ axis ] . linear_limit_lower ;
} else if ( " linear_limit_softness " = = var_name ) {
r_ret = axis_data [ axis ] . linear_limit_softness ;
} else if ( " linear_restitution " = = var_name ) {
r_ret = axis_data [ axis ] . linear_restitution ;
} else if ( " linear_damping " = = var_name ) {
r_ret = axis_data [ axis ] . linear_damping ;
} else if ( " angular_limit_enabled " = = var_name ) {
r_ret = axis_data [ axis ] . angular_limit_enabled ;
} else if ( " angular_limit_upper " = = var_name ) {
r_ret = Math : : rad2deg ( axis_data [ axis ] . angular_limit_upper ) ;
} else if ( " angular_limit_lower " = = var_name ) {
r_ret = Math : : rad2deg ( axis_data [ axis ] . angular_limit_lower ) ;
} else if ( " angular_limit_softness " = = var_name ) {
r_ret = axis_data [ axis ] . angular_limit_softness ;
} else if ( " angular_restitution " = = var_name ) {
r_ret = axis_data [ axis ] . angular_restitution ;
} else if ( " angular_damping " = = var_name ) {
r_ret = axis_data [ axis ] . angular_damping ;
} else if ( " erp " = = var_name ) {
r_ret = axis_data [ axis ] . erp ;
} else {
return false ;
}
return true ;
}
void PhysicalBone : : SixDOFJointData : : _get_property_list ( List < PropertyInfo > * p_list ) const {
const StringName axis_names [ ] = { " x " , " y " , " z " } ;
for ( int i = 0 ; i < 3 ; + + i ) {
p_list - > push_back ( PropertyInfo ( Variant : : BOOL , " joint_constraints/ " + axis_names [ i ] + " /linear_limit_enabled " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /linear_limit_upper " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /linear_limit_lower " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /linear_limit_softness " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /linear_restitution " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /linear_damping " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : BOOL , " joint_constraints/ " + axis_names [ i ] + " /angular_limit_enabled " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /angular_limit_upper " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /angular_limit_lower " , PROPERTY_HINT_RANGE , " -180,180,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /angular_limit_softness " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /angular_restitution " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /angular_damping " , PROPERTY_HINT_RANGE , " 0.01,16,0.01 " ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : REAL , " joint_constraints/ " + axis_names [ i ] + " /erp " ) ) ;
}
}
bool PhysicalBone : : _set ( const StringName & p_name , const Variant & p_value ) {
if ( p_name = = " bone_name " ) {
set_bone_name ( p_value ) ;
return true ;
}
if ( joint_data ) {
if ( joint_data - > _set ( p_name , p_value ) ) {
# ifdef TOOLS_ENABLED
if ( get_gizmo ( ) . is_valid ( ) )
get_gizmo ( ) - > redraw ( ) ;
# endif
return true ;
}
}
return false ;
}
bool PhysicalBone : : _get ( const StringName & p_name , Variant & r_ret ) const {
if ( p_name = = " bone_name " ) {
r_ret = get_bone_name ( ) ;
return true ;
}
if ( joint_data ) {
return joint_data - > _get ( p_name , r_ret ) ;
}
return false ;
}
void PhysicalBone : : _get_property_list ( List < PropertyInfo > * p_list ) const {
Skeleton * parent = find_skeleton_parent ( get_parent ( ) ) ;
if ( parent ) {
String names ;
for ( int i = 0 ; i < parent - > get_bone_count ( ) ; i + + ) {
if ( i > 0 )
names + = " , " ;
names + = parent - > get_bone_name ( i ) ;
}
p_list - > push_back ( PropertyInfo ( Variant : : STRING , " bone_name " , PROPERTY_HINT_ENUM , names ) ) ;
} else {
p_list - > push_back ( PropertyInfo ( Variant : : STRING , " bone_name " ) ) ;
}
if ( joint_data ) {
joint_data - > _get_property_list ( p_list ) ;
}
}
void PhysicalBone : : _notification ( int p_what ) {
switch ( p_what ) {
case NOTIFICATION_ENTER_TREE :
parent_skeleton = find_skeleton_parent ( get_parent ( ) ) ;
update_bone_id ( ) ;
reset_to_rest_position ( ) ;
2018-05-10 13:23:05 +02:00
_reset_physics_simulation_state ( ) ;
2017-10-03 18:49:32 +02:00
break ;
case NOTIFICATION_EXIT_TREE :
if ( parent_skeleton ) {
if ( - 1 ! = bone_id ) {
parent_skeleton - > unbind_physical_bone_from_bone ( bone_id ) ;
}
}
parent_skeleton = NULL ;
update_bone_id ( ) ;
break ;
case NOTIFICATION_TRANSFORM_CHANGED :
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
update_offset ( ) ;
}
break ;
}
}
void PhysicalBone : : _direct_state_changed ( Object * p_state ) {
if ( ! simulate_physics ) {
return ;
}
/// Update bone transform
PhysicsDirectBodyState * state ;
# ifdef DEBUG_ENABLED
state = Object : : cast_to < PhysicsDirectBodyState > ( p_state ) ;
# else
state = ( PhysicsDirectBodyState * ) p_state ; //trust it
# endif
Transform global_transform ( state - > get_transform ( ) ) ;
set_ignore_transform_notification ( true ) ;
set_global_transform ( global_transform ) ;
set_ignore_transform_notification ( false ) ;
// Update skeleton
if ( parent_skeleton ) {
if ( - 1 ! = bone_id ) {
parent_skeleton - > set_bone_global_pose ( bone_id , parent_skeleton - > get_global_transform ( ) . affine_inverse ( ) * ( global_transform * body_offset_inverse ) ) ;
}
}
}
void PhysicalBone : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " _direct_state_changed " ) , & PhysicalBone : : _direct_state_changed ) ;
ClassDB : : bind_method ( D_METHOD ( " set_joint_type " , " joint_type " ) , & PhysicalBone : : set_joint_type ) ;
ClassDB : : bind_method ( D_METHOD ( " get_joint_type " ) , & PhysicalBone : : get_joint_type ) ;
ClassDB : : bind_method ( D_METHOD ( " set_joint_offset " , " offset " ) , & PhysicalBone : : set_joint_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " get_joint_offset " ) , & PhysicalBone : : get_joint_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " set_body_offset " , " offset " ) , & PhysicalBone : : set_body_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " get_body_offset " ) , & PhysicalBone : : get_body_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " is_static_body " ) , & PhysicalBone : : is_static_body ) ;
ClassDB : : bind_method ( D_METHOD ( " get_simulate_physics " ) , & PhysicalBone : : get_simulate_physics ) ;
ClassDB : : bind_method ( D_METHOD ( " is_simulating_physics " ) , & PhysicalBone : : is_simulating_physics ) ;
ClassDB : : bind_method ( D_METHOD ( " set_mass " , " mass " ) , & PhysicalBone : : set_mass ) ;
ClassDB : : bind_method ( D_METHOD ( " get_mass " ) , & PhysicalBone : : get_mass ) ;
ClassDB : : bind_method ( D_METHOD ( " set_weight " , " weight " ) , & PhysicalBone : : set_weight ) ;
ClassDB : : bind_method ( D_METHOD ( " get_weight " ) , & PhysicalBone : : get_weight ) ;
ClassDB : : bind_method ( D_METHOD ( " set_friction " , " friction " ) , & PhysicalBone : : set_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " get_friction " ) , & PhysicalBone : : get_friction ) ;
ClassDB : : bind_method ( D_METHOD ( " set_bounce " , " bounce " ) , & PhysicalBone : : set_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " get_bounce " ) , & PhysicalBone : : get_bounce ) ;
ClassDB : : bind_method ( D_METHOD ( " set_gravity_scale " , " gravity_scale " ) , & PhysicalBone : : set_gravity_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_gravity_scale " ) , & PhysicalBone : : get_gravity_scale ) ;
ADD_GROUP ( " Joint " , " joint_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " joint_type " , PROPERTY_HINT_ENUM , " None,PinJoint,ConeJoint,HingeJoint,SliderJoint,6DOFJoint " ) , " set_joint_type " , " get_joint_type " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : TRANSFORM , " joint_offset " ) , " set_joint_offset " , " get_joint_offset " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : TRANSFORM , " body_offset " ) , " set_body_offset " , " get_body_offset " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " mass " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " ) , " set_mass " , " get_mass " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " weight " , PROPERTY_HINT_EXP_RANGE , " 0.01,65535,0.01 " ) , " set_weight " , " get_weight " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " friction " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_friction " , " get_friction " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " bounce " , PROPERTY_HINT_RANGE , " 0,1,0.01 " ) , " set_bounce " , " get_bounce " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " gravity_scale " , PROPERTY_HINT_RANGE , " -10,10,0.01 " ) , " set_gravity_scale " , " get_gravity_scale " ) ;
2018-05-09 02:14:31 +02:00
BIND_ENUM_CONSTANT ( JOINT_TYPE_NONE ) ;
BIND_ENUM_CONSTANT ( JOINT_TYPE_PIN ) ;
BIND_ENUM_CONSTANT ( JOINT_TYPE_CONE ) ;
BIND_ENUM_CONSTANT ( JOINT_TYPE_HINGE ) ;
BIND_ENUM_CONSTANT ( JOINT_TYPE_SLIDER ) ;
BIND_ENUM_CONSTANT ( JOINT_TYPE_6DOF ) ;
2017-10-03 18:49:32 +02:00
}
Skeleton * PhysicalBone : : find_skeleton_parent ( Node * p_parent ) {
if ( ! p_parent ) {
return NULL ;
}
Skeleton * s = Object : : cast_to < Skeleton > ( p_parent ) ;
return s ? s : find_skeleton_parent ( p_parent - > get_parent ( ) ) ;
}
void PhysicalBone : : _fix_joint_offset ( ) {
// Clamp joint origin to bone origin
if ( parent_skeleton ) {
joint_offset . origin = body_offset . affine_inverse ( ) . origin ;
}
}
void PhysicalBone : : _reload_joint ( ) {
if ( joint . is_valid ( ) ) {
PhysicsServer : : get_singleton ( ) - > free ( joint ) ;
joint = RID ( ) ;
}
if ( ! parent_skeleton ) {
return ;
}
PhysicalBone * body_a = parent_skeleton - > get_physical_bone_parent ( bone_id ) ;
if ( ! body_a ) {
return ;
}
Transform joint_transf = get_global_transform ( ) * joint_offset ;
Transform local_a = body_a - > get_global_transform ( ) . affine_inverse ( ) * joint_transf ;
local_a . orthonormalize ( ) ;
switch ( get_joint_type ( ) ) {
case JOINT_TYPE_PIN : {
joint = PhysicsServer : : get_singleton ( ) - > joint_create_pin ( body_a - > get_rid ( ) , local_a . origin , get_rid ( ) , joint_offset . origin ) ;
const PinJointData * pjd ( static_cast < const PinJointData * > ( joint_data ) ) ;
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( joint , PhysicsServer : : PIN_JOINT_BIAS , pjd - > bias ) ;
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( joint , PhysicsServer : : PIN_JOINT_DAMPING , pjd - > damping ) ;
PhysicsServer : : get_singleton ( ) - > pin_joint_set_param ( joint , PhysicsServer : : PIN_JOINT_IMPULSE_CLAMP , pjd - > impulse_clamp ) ;
} break ;
case JOINT_TYPE_CONE : {
joint = PhysicsServer : : get_singleton ( ) - > joint_create_cone_twist ( body_a - > get_rid ( ) , local_a , get_rid ( ) , joint_offset ) ;
const ConeJointData * cjd ( static_cast < const ConeJointData * > ( joint_data ) ) ;
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( joint , PhysicsServer : : CONE_TWIST_JOINT_SWING_SPAN , cjd - > swing_span ) ;
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( joint , PhysicsServer : : CONE_TWIST_JOINT_TWIST_SPAN , cjd - > twist_span ) ;
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( joint , PhysicsServer : : CONE_TWIST_JOINT_BIAS , cjd - > bias ) ;
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( joint , PhysicsServer : : CONE_TWIST_JOINT_SOFTNESS , cjd - > softness ) ;
PhysicsServer : : get_singleton ( ) - > cone_twist_joint_set_param ( joint , PhysicsServer : : CONE_TWIST_JOINT_RELAXATION , cjd - > relaxation ) ;
} break ;
case JOINT_TYPE_HINGE : {
joint = PhysicsServer : : get_singleton ( ) - > joint_create_hinge ( body_a - > get_rid ( ) , local_a , get_rid ( ) , joint_offset ) ;
const HingeJointData * hjd ( static_cast < const HingeJointData * > ( joint_data ) ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_flag ( joint , PhysicsServer : : HINGE_JOINT_FLAG_USE_LIMIT , hjd - > angular_limit_enabled ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( joint , PhysicsServer : : HINGE_JOINT_LIMIT_UPPER , hjd - > angular_limit_upper ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( joint , PhysicsServer : : HINGE_JOINT_LIMIT_LOWER , hjd - > angular_limit_lower ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( joint , PhysicsServer : : HINGE_JOINT_LIMIT_BIAS , hjd - > angular_limit_bias ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( joint , PhysicsServer : : HINGE_JOINT_LIMIT_SOFTNESS , hjd - > angular_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > hinge_joint_set_param ( joint , PhysicsServer : : HINGE_JOINT_LIMIT_RELAXATION , hjd - > angular_limit_relaxation ) ;
} break ;
case JOINT_TYPE_SLIDER : {
joint = PhysicsServer : : get_singleton ( ) - > joint_create_slider ( body_a - > get_rid ( ) , local_a , get_rid ( ) , joint_offset ) ;
const SliderJointData * sjd ( static_cast < const SliderJointData * > ( joint_data ) ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_UPPER , sjd - > linear_limit_upper ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_LOWER , sjd - > linear_limit_lower ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS , sjd - > linear_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION , sjd - > linear_limit_restitution ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_LINEAR_LIMIT_DAMPING , sjd - > linear_limit_restitution ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_UPPER , sjd - > angular_limit_upper ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_LOWER , sjd - > angular_limit_lower ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS , sjd - > angular_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS , sjd - > angular_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > slider_joint_set_param ( joint , PhysicsServer : : SLIDER_JOINT_ANGULAR_LIMIT_DAMPING , sjd - > angular_limit_damping ) ;
} break ;
case JOINT_TYPE_6DOF : {
joint = PhysicsServer : : get_singleton ( ) - > joint_create_generic_6dof ( body_a - > get_rid ( ) , local_a , get_rid ( ) , joint_offset ) ;
const SixDOFJointData * g6dofjd ( static_cast < const SixDOFJointData * > ( joint_data ) ) ;
for ( int axis = 0 ; axis < 3 ; + + axis ) {
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_flag ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT , g6dofjd - > axis_data [ axis ] . linear_limit_enabled ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_LINEAR_UPPER_LIMIT , g6dofjd - > axis_data [ axis ] . linear_limit_upper ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_LINEAR_LOWER_LIMIT , g6dofjd - > axis_data [ axis ] . linear_limit_lower ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS , g6dofjd - > axis_data [ axis ] . linear_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_LINEAR_RESTITUTION , g6dofjd - > axis_data [ axis ] . linear_restitution ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_LINEAR_DAMPING , g6dofjd - > axis_data [ axis ] . linear_damping ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_flag ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT , g6dofjd - > axis_data [ axis ] . angular_limit_enabled ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_UPPER_LIMIT , g6dofjd - > axis_data [ axis ] . angular_limit_upper ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_LOWER_LIMIT , g6dofjd - > axis_data [ axis ] . angular_limit_lower ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS , g6dofjd - > axis_data [ axis ] . angular_limit_softness ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_RESTITUTION , g6dofjd - > axis_data [ axis ] . angular_restitution ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_DAMPING , g6dofjd - > axis_data [ axis ] . angular_damping ) ;
PhysicsServer : : get_singleton ( ) - > generic_6dof_joint_set_param ( joint , static_cast < Vector3 : : Axis > ( axis ) , PhysicsServer : : G6DOF_JOINT_ANGULAR_ERP , g6dofjd - > axis_data [ axis ] . erp ) ;
}
} break ;
}
}
void PhysicalBone : : _on_bone_parent_changed ( ) {
_reload_joint ( ) ;
}
void PhysicalBone : : _set_gizmo_move_joint ( bool p_move_joint ) {
# ifdef TOOLS_ENABLED
gizmo_move_joint = p_move_joint ;
SpatialEditor : : get_singleton ( ) - > update_transform_gizmo ( ) ;
# endif
}
# ifdef TOOLS_ENABLED
Transform PhysicalBone : : get_global_gizmo_transform ( ) const {
return gizmo_move_joint ? get_global_transform ( ) * joint_offset : get_global_transform ( ) ;
}
Transform PhysicalBone : : get_local_gizmo_transform ( ) const {
return gizmo_move_joint ? get_transform ( ) * joint_offset : get_transform ( ) ;
}
# endif
const PhysicalBone : : JointData * PhysicalBone : : get_joint_data ( ) const {
return joint_data ;
}
Skeleton * PhysicalBone : : find_skeleton_parent ( ) {
return find_skeleton_parent ( this ) ;
}
void PhysicalBone : : set_joint_type ( JointType p_joint_type ) {
if ( p_joint_type = = get_joint_type ( ) )
return ;
memdelete ( joint_data ) ;
joint_data = NULL ;
switch ( p_joint_type ) {
case JOINT_TYPE_PIN :
joint_data = memnew ( PinJointData ) ;
break ;
case JOINT_TYPE_CONE :
joint_data = memnew ( ConeJointData ) ;
break ;
case JOINT_TYPE_HINGE :
joint_data = memnew ( HingeJointData ) ;
break ;
case JOINT_TYPE_SLIDER :
joint_data = memnew ( SliderJointData ) ;
break ;
case JOINT_TYPE_6DOF :
joint_data = memnew ( SixDOFJointData ) ;
break ;
}
_reload_joint ( ) ;
# ifdef TOOLS_ENABLED
_change_notify ( ) ;
if ( get_gizmo ( ) . is_valid ( ) )
get_gizmo ( ) - > redraw ( ) ;
# endif
}
PhysicalBone : : JointType PhysicalBone : : get_joint_type ( ) const {
return joint_data ? joint_data - > get_joint_type ( ) : JOINT_TYPE_NONE ;
}
void PhysicalBone : : set_joint_offset ( const Transform & p_offset ) {
joint_offset = p_offset ;
_fix_joint_offset ( ) ;
set_ignore_transform_notification ( true ) ;
reset_to_rest_position ( ) ;
set_ignore_transform_notification ( false ) ;
# ifdef TOOLS_ENABLED
if ( get_gizmo ( ) . is_valid ( ) )
get_gizmo ( ) - > redraw ( ) ;
# endif
}
const Transform & PhysicalBone : : get_body_offset ( ) const {
return body_offset ;
}
void PhysicalBone : : set_body_offset ( const Transform & p_offset ) {
body_offset = p_offset ;
body_offset_inverse = body_offset . affine_inverse ( ) ;
_fix_joint_offset ( ) ;
set_ignore_transform_notification ( true ) ;
reset_to_rest_position ( ) ;
set_ignore_transform_notification ( false ) ;
# ifdef TOOLS_ENABLED
if ( get_gizmo ( ) . is_valid ( ) )
get_gizmo ( ) - > redraw ( ) ;
# endif
}
const Transform & PhysicalBone : : get_joint_offset ( ) const {
return joint_offset ;
}
void PhysicalBone : : set_static_body ( bool p_static ) {
static_body = p_static ;
set_as_toplevel ( ! static_body ) ;
_reset_physics_simulation_state ( ) ;
}
bool PhysicalBone : : is_static_body ( ) {
return static_body ;
}
void PhysicalBone : : set_simulate_physics ( bool p_simulate ) {
if ( simulate_physics = = p_simulate ) {
return ;
}
simulate_physics = p_simulate ;
_reset_physics_simulation_state ( ) ;
}
bool PhysicalBone : : get_simulate_physics ( ) {
return simulate_physics ;
}
bool PhysicalBone : : is_simulating_physics ( ) {
return _internal_simulate_physics & & ! _internal_static_body ;
}
void PhysicalBone : : set_bone_name ( const String & p_name ) {
bone_name = p_name ;
bone_id = - 1 ;
update_bone_id ( ) ;
reset_to_rest_position ( ) ;
}
const String & PhysicalBone : : get_bone_name ( ) const {
return bone_name ;
}
void PhysicalBone : : set_mass ( real_t p_mass ) {
ERR_FAIL_COND ( p_mass < = 0 ) ;
mass = p_mass ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_MASS , mass ) ;
}
real_t PhysicalBone : : get_mass ( ) const {
return mass ;
}
void PhysicalBone : : set_weight ( real_t p_weight ) {
set_mass ( p_weight / real_t ( GLOBAL_DEF ( " physics/3d/default_gravity " , 9.8 ) ) ) ;
}
real_t PhysicalBone : : get_weight ( ) const {
return mass * real_t ( GLOBAL_DEF ( " physics/3d/default_gravity " , 9.8 ) ) ;
}
void PhysicalBone : : set_friction ( real_t p_friction ) {
ERR_FAIL_COND ( p_friction < 0 | | p_friction > 1 ) ;
friction = p_friction ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_FRICTION , friction ) ;
}
real_t PhysicalBone : : get_friction ( ) const {
return friction ;
}
void PhysicalBone : : set_bounce ( real_t p_bounce ) {
ERR_FAIL_COND ( p_bounce < 0 | | p_bounce > 1 ) ;
bounce = p_bounce ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_BOUNCE , bounce ) ;
}
real_t PhysicalBone : : get_bounce ( ) const {
return bounce ;
}
void PhysicalBone : : set_gravity_scale ( real_t p_gravity_scale ) {
gravity_scale = p_gravity_scale ;
PhysicsServer : : get_singleton ( ) - > body_set_param ( get_rid ( ) , PhysicsServer : : BODY_PARAM_GRAVITY_SCALE , gravity_scale ) ;
}
real_t PhysicalBone : : get_gravity_scale ( ) const {
return gravity_scale ;
}
PhysicalBone : : PhysicalBone ( ) :
PhysicsBody ( PhysicsServer : : BODY_MODE_STATIC ) ,
# ifdef TOOLS_ENABLED
gizmo_move_joint ( false ) ,
# endif
joint_data ( NULL ) ,
static_body ( false ) ,
simulate_physics ( false ) ,
2018-05-10 13:23:05 +02:00
_internal_static_body ( false ) ,
_internal_simulate_physics ( false ) ,
2017-10-03 18:49:32 +02:00
bone_id ( - 1 ) ,
parent_skeleton ( NULL ) ,
bone_name ( " " ) ,
bounce ( 0 ) ,
mass ( 1 ) ,
friction ( 1 ) ,
gravity_scale ( 1 ) {
set_static_body ( static_body ) ;
_reset_physics_simulation_state ( ) ;
}
PhysicalBone : : ~ PhysicalBone ( ) {
memdelete ( joint_data ) ;
}
void PhysicalBone : : update_bone_id ( ) {
if ( ! parent_skeleton ) {
return ;
}
const int new_bone_id = parent_skeleton - > find_bone ( bone_name ) ;
if ( new_bone_id ! = bone_id ) {
if ( - 1 ! = bone_id ) {
// Assert the unbind from old node
parent_skeleton - > unbind_physical_bone_from_bone ( bone_id ) ;
parent_skeleton - > unbind_child_node_from_bone ( bone_id , this ) ;
}
bone_id = new_bone_id ;
parent_skeleton - > bind_physical_bone_to_bone ( bone_id , this ) ;
_fix_joint_offset ( ) ;
_internal_static_body = ! static_body ; // Force staticness reset
_reset_staticness_state ( ) ;
}
}
void PhysicalBone : : update_offset ( ) {
# ifdef TOOLS_ENABLED
if ( parent_skeleton ) {
Transform bone_transform ( parent_skeleton - > get_global_transform ( ) ) ;
if ( - 1 ! = bone_id )
bone_transform * = parent_skeleton - > get_bone_global_pose ( bone_id ) ;
if ( gizmo_move_joint ) {
bone_transform * = body_offset ;
set_joint_offset ( bone_transform . affine_inverse ( ) * get_global_transform ( ) ) ;
} else {
set_body_offset ( bone_transform . affine_inverse ( ) * get_global_transform ( ) ) ;
}
}
# endif
}
void PhysicalBone : : reset_to_rest_position ( ) {
if ( parent_skeleton ) {
if ( - 1 = = bone_id ) {
set_global_transform ( parent_skeleton - > get_global_transform ( ) * body_offset ) ;
} else {
set_global_transform ( parent_skeleton - > get_global_transform ( ) * parent_skeleton - > get_bone_global_pose ( bone_id ) * body_offset ) ;
}
}
}
void PhysicalBone : : _reset_physics_simulation_state ( ) {
if ( simulate_physics & & ! static_body ) {
_start_physics_simulation ( ) ;
} else {
_stop_physics_simulation ( ) ;
}
_reset_staticness_state ( ) ;
}
void PhysicalBone : : _reset_staticness_state ( ) {
if ( parent_skeleton & & - 1 ! = bone_id ) {
if ( static_body & & simulate_physics ) { // With this check I'm sure the position of this body is updated only when it's necessary
if ( _internal_static_body ) {
return ;
}
parent_skeleton - > bind_child_node_to_bone ( bone_id , this ) ;
_internal_static_body = true ;
} else {
if ( ! _internal_static_body ) {
return ;
}
parent_skeleton - > unbind_child_node_from_bone ( bone_id , this ) ;
_internal_static_body = false ;
}
}
}
void PhysicalBone : : _start_physics_simulation ( ) {
if ( _internal_simulate_physics | | ! parent_skeleton ) {
return ;
}
reset_to_rest_position ( ) ;
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_RIGID ) ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_layer ( get_rid ( ) , get_collision_layer ( ) ) ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_mask ( get_rid ( ) , get_collision_mask ( ) ) ;
PhysicsServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , this , " _direct_state_changed " ) ;
parent_skeleton - > set_bone_ignore_animation ( bone_id , true ) ;
_internal_simulate_physics = true ;
}
void PhysicalBone : : _stop_physics_simulation ( ) {
if ( ! _internal_simulate_physics | | ! parent_skeleton ) {
return ;
}
PhysicsServer : : get_singleton ( ) - > body_set_mode ( get_rid ( ) , PhysicsServer : : BODY_MODE_STATIC ) ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_layer ( get_rid ( ) , 0 ) ;
PhysicsServer : : get_singleton ( ) - > body_set_collision_mask ( get_rid ( ) , 0 ) ;
PhysicsServer : : get_singleton ( ) - > body_set_force_integration_callback ( get_rid ( ) , NULL , " " ) ;
parent_skeleton - > set_bone_ignore_animation ( bone_id , false ) ;
_internal_simulate_physics = false ;
}