21 files changed, 1685 insertions, 94 deletions
diff --git a/scene/3d/area.cpp b/scene/3d/area.cpp
index 21f471039f..6ea980ec97 100644
--- a/scene/3d/area.cpp
+++ b/scene/3d/area.cpp
@@ -711,7 +711,7 @@ void Area::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "space_override", PROPERTY_HINT_ENUM, "Disabled,Combine,Combine-Replace,Replace,Replace-Combine"), "set_space_override_mode", "get_space_override_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gravity_point"), "set_gravity_is_point", "is_gravity_a_point");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity_distance_scale", PROPERTY_HINT_RANGE, "0,1024,0.001"), "set_gravity_distance_scale", "get_gravity_distance_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity_distance_scale", PROPERTY_HINT_EXP_RANGE, "0,1024,0.001,or_greater"), "set_gravity_distance_scale", "get_gravity_distance_scale");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity_vec"), "set_gravity_vector", "get_gravity_vector");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity", PROPERTY_HINT_RANGE, "-1024,1024,0.01"), "set_gravity", "get_gravity");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "linear_damp", PROPERTY_HINT_RANGE, "0,1024,0.001"), "set_linear_damp", "get_linear_damp");
diff --git a/scene/3d/audio_stream_player_3d.cpp b/scene/3d/audio_stream_player_3d.cpp
index c2a50ec7bb..e7b3645001 100644
--- a/scene/3d/audio_stream_player_3d.cpp
+++ b/scene/3d/audio_stream_player_3d.cpp
@@ -898,7 +898,7 @@ void AudioStreamPlayer3D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "pitch_scale", PROPERTY_HINT_RANGE, "0.01,32,0.01"), "set_pitch_scale", "get_pitch_scale");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "playing", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "_set_playing", "is_playing");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "autoplay"), "set_autoplay", "is_autoplay_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_RANGE, "0,65536,1"), "set_max_distance", "get_max_distance");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_EXP_RANGE, "0,4096,1,or_greater"), "set_max_distance", "get_max_distance");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "out_of_range_mode", PROPERTY_HINT_ENUM, "Mix,Pause"), "set_out_of_range_mode", "get_out_of_range_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "bus", PROPERTY_HINT_ENUM, ""), "set_bus", "get_bus");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "area_mask", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_area_mask", "get_area_mask");
diff --git a/scene/3d/camera.cpp b/scene/3d/camera.cpp
index 9de189c158..e11e8abe5b 100644
--- a/scene/3d/camera.cpp
+++ b/scene/3d/camera.cpp
@@ -480,8 +480,8 @@ void Camera::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "current"), "set_current", "is_current");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "fov", PROPERTY_HINT_RANGE, "1,179,0.1"), "set_fov", "get_fov");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "size", PROPERTY_HINT_RANGE, "0.1,16384,0.01"), "set_size", "get_size");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "near"), "set_znear", "get_znear");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "far"), "set_zfar", "get_zfar");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "near", PROPERTY_HINT_EXP_RANGE, "0.1,8192,0.1,or_greater"), "set_znear", "get_znear");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "far", PROPERTY_HINT_EXP_RANGE, "0.1,8192,0.1,or_greater"), "set_zfar", "get_zfar");
 
 	BIND_ENUM_CONSTANT(PROJECTION_PERSPECTIVE);
 	BIND_ENUM_CONSTANT(PROJECTION_ORTHOGONAL);
diff --git a/scene/3d/camera.h b/scene/3d/camera.h
index 109bf3adc6..1b506e0c4f 100644
--- a/scene/3d/camera.h
+++ b/scene/3d/camera.h
@@ -132,9 +132,9 @@ public:
 
 	virtual Transform get_camera_transform() const;
 
-	Vector3 project_ray_normal(const Point2 &p_pos) const;
+	virtual Vector3 project_ray_normal(const Point2 &p_pos) const;
 	virtual Vector3 project_ray_origin(const Point2 &p_pos) const;
-	Vector3 project_local_ray_normal(const Point2 &p_pos) const;
+	virtual Vector3 project_local_ray_normal(const Point2 &p_pos) const;
 	virtual Point2 unproject_position(const Vector3 &p_pos) const;
 	bool is_position_behind(const Vector3 &p_pos) const;
 	virtual Vector3 project_position(const Point2 &p_point) const;
diff --git a/scene/3d/collision_polygon.cpp b/scene/3d/collision_polygon.cpp
index 3a77360bc2..379dd21c39 100644
--- a/scene/3d/collision_polygon.cpp
+++ b/scene/3d/collision_polygon.cpp
@@ -173,6 +173,9 @@ String CollisionPolygon::get_configuration_warning() const {
 	return String();
 }
 
+bool CollisionPolygon::_is_editable_3d_polygon() const {
+	return true;
+}
 void CollisionPolygon::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_depth", "depth"), &CollisionPolygon::set_depth);
@@ -184,6 +187,8 @@ void CollisionPolygon::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_disabled", "disabled"), &CollisionPolygon::set_disabled);
 	ClassDB::bind_method(D_METHOD("is_disabled"), &CollisionPolygon::is_disabled);
 
+	ClassDB::bind_method(D_METHOD("_is_editable_3d_polygon"), &CollisionPolygon::_is_editable_3d_polygon);
+
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "depth"), "set_depth", "get_depth");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
 	ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "polygon"), "set_polygon", "get_polygon");
diff --git a/scene/3d/collision_polygon.h b/scene/3d/collision_polygon.h
index 971c67f1ad..f1f137c9c5 100644
--- a/scene/3d/collision_polygon.h
+++ b/scene/3d/collision_polygon.h
@@ -53,6 +53,8 @@ protected:
 
 	void _update_in_shape_owner(bool p_xform_only = false);
 
+	bool _is_editable_3d_polygon() const;
+
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
diff --git a/scene/3d/light.cpp b/scene/3d/light.cpp
index 240bd631a1..7c42638107 100644
--- a/scene/3d/light.cpp
+++ b/scene/3d/light.cpp
@@ -375,7 +375,7 @@ void DirectionalLight::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_normal_bias", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_param", "get_param", PARAM_SHADOW_NORMAL_BIAS);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_bias_split_scale", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param", "get_param", PARAM_SHADOW_BIAS_SPLIT_SCALE);
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "directional_shadow_depth_range", PROPERTY_HINT_ENUM, "Stable,Optimized"), "set_shadow_depth_range", "get_shadow_depth_range");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_max_distance", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_SHADOW_MAX_DISTANCE);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_max_distance", PROPERTY_HINT_EXP_RANGE, "0,8192,0.1,or_greater"), "set_param", "get_param", PARAM_SHADOW_MAX_DISTANCE);
 
 	BIND_ENUM_CONSTANT(SHADOW_ORTHOGONAL);
 	BIND_ENUM_CONSTANT(SHADOW_PARALLEL_2_SPLITS);
@@ -428,8 +428,8 @@ void OmniLight::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_shadow_detail"), &OmniLight::get_shadow_detail);
 
 	ADD_GROUP("Omni", "omni_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_range", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_RANGE);
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_ATTENUATION);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_range", PROPERTY_HINT_EXP_RANGE, "0,4096,0.1,or_greater"), "set_param", "get_param", PARAM_RANGE);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_ATTENUATION);
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "omni_shadow_mode", PROPERTY_HINT_ENUM, "Dual Paraboloid,Cube"), "set_shadow_mode", "get_shadow_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "omni_shadow_detail", PROPERTY_HINT_ENUM, "Vertical,Horizontal"), "set_shadow_detail", "get_shadow_detail");
 
@@ -450,8 +450,8 @@ OmniLight::OmniLight() :
 void SpotLight::_bind_methods() {
 
 	ADD_GROUP("Spot", "spot_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_range", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_RANGE);
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_ATTENUATION);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_range", PROPERTY_HINT_EXP_RANGE, "0,4096,0.1,or_greater"), "set_param", "get_param", PARAM_RANGE);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_ATTENUATION);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle", PROPERTY_HINT_RANGE, "0,180,0.1"), "set_param", "get_param", PARAM_SPOT_ANGLE);
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_SPOT_ATTENUATION);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_SPOT_ATTENUATION);
 }
diff --git a/scene/3d/particles.cpp b/scene/3d/particles.cpp
index 693b416f6d..7b5eb8ebc3 100644
--- a/scene/3d/particles.cpp
+++ b/scene/3d/particles.cpp
@@ -324,11 +324,11 @@ void Particles::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("capture_aabb"), &Particles::capture_aabb);
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "emitting"), "set_emitting", "is_emitting");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "amount", PROPERTY_HINT_RANGE, "1,100000,1"), "set_amount", "get_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "amount", PROPERTY_HINT_EXP_RANGE, "1,1000000,1"), "set_amount", "get_amount");
 	ADD_GROUP("Time", "");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "lifetime", PROPERTY_HINT_RANGE, "0.01,600.0,0.01"), "set_lifetime", "get_lifetime");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "lifetime", PROPERTY_HINT_EXP_RANGE, "0.01,600.0,0.01"), "set_lifetime", "get_lifetime");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "one_shot"), "set_one_shot", "get_one_shot");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "preprocess", PROPERTY_HINT_RANGE, "0.00,600.0,0.01"), "set_pre_process_time", "get_pre_process_time");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "preprocess", PROPERTY_HINT_EXP_RANGE, "0.00,600.0,0.01"), "set_pre_process_time", "get_pre_process_time");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "speed_scale", PROPERTY_HINT_RANGE, "0.01,64,0.01"), "set_speed_scale", "get_speed_scale");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "explosiveness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_explosiveness_ratio", "get_explosiveness_ratio");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "randomness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_randomness_ratio", "get_randomness_ratio");
@@ -1028,8 +1028,6 @@ void ParticlesMaterial::set_param(Parameter p_param, float p_value) {
 		case PARAM_ANIM_OFFSET: {
 			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset, p_value);
 		} break;
-		case PARAM_MAX: {
-		};
 	}
 }
 float ParticlesMaterial::get_param(Parameter p_param) const {
@@ -1082,8 +1080,6 @@ void ParticlesMaterial::set_param_randomness(Parameter p_param, float p_value) {
 		case PARAM_ANIM_OFFSET: {
 			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_random, p_value);
 		} break;
-		case PARAM_MAX: {
-		};
 	}
 }
 float ParticlesMaterial::get_param_randomness(Parameter p_param) const {
@@ -1160,8 +1156,6 @@ void ParticlesMaterial::set_param_texture(Parameter p_param, const Ref<Texture>
 		case PARAM_ANIM_OFFSET: {
 			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_texture, p_texture);
 		} break;
-		case PARAM_MAX: {
-		};
 	}
 
 	_queue_shader_change();
@@ -1233,28 +1227,19 @@ void ParticlesMaterial::set_emission_box_extents(Vector3 p_extents) {
 void ParticlesMaterial::set_emission_point_texture(const Ref<Texture> &p_points) {
 
 	emission_point_texture = p_points;
-	RID texture;
-	if (p_points.is_valid())
-		texture = p_points->get_rid();
-	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_points, texture);
+	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_points, p_points);
 }
 
 void ParticlesMaterial::set_emission_normal_texture(const Ref<Texture> &p_normals) {
 
 	emission_normal_texture = p_normals;
-	RID texture;
-	if (p_normals.is_valid())
-		texture = p_normals->get_rid();
-	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_normal, texture);
+	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_normal, p_normals);
 }
 
 void ParticlesMaterial::set_emission_color_texture(const Ref<Texture> &p_colors) {
 
 	emission_color_texture = p_colors;
-	RID texture;
-	if (p_colors.is_valid())
-		texture = p_colors->get_rid();
-	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_color, texture);
+	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_color, p_colors);
 	_queue_shader_change();
 }
 
@@ -1316,10 +1301,7 @@ void ParticlesMaterial::set_trail_size_modifier(const Ref<CurveTexture> &p_trail
 		curve->ensure_default_setup();
 	}
 
-	RID texture;
-	if (p_trail_size_modifier.is_valid())
-		texture = p_trail_size_modifier->get_rid();
-	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_size_modifier, texture);
+	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_size_modifier, curve);
 	_queue_shader_change();
 }
 
@@ -1331,10 +1313,7 @@ Ref<CurveTexture> ParticlesMaterial::get_trail_size_modifier() const {
 void ParticlesMaterial::set_trail_color_modifier(const Ref<GradientTexture> &p_trail_color_modifier) {
 
 	trail_color_modifier = p_trail_color_modifier;
-	RID texture;
-	if (p_trail_color_modifier.is_valid())
-		texture = p_trail_color_modifier->get_rid();
-	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_color_modifier, texture);
+	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_color_modifier, p_trail_color_modifier);
 	_queue_shader_change();
 }
 
@@ -1481,26 +1460,26 @@ void ParticlesMaterial::_bind_methods() {
 	ADD_GROUP("Gravity", "");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity"), "set_gravity", "get_gravity");
 	ADD_GROUP("Initial Velocity", "initial_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "initial_velocity", PROPERTY_HINT_RANGE, "0,1000,0.01"), "set_param", "get_param", PARAM_INITIAL_LINEAR_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "initial_velocity", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param", "get_param", PARAM_INITIAL_LINEAR_VELOCITY);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "initial_velocity_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_INITIAL_LINEAR_VELOCITY);
 	ADD_GROUP("Angular Velocity", "angular_");
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "angular_velocity", PROPERTY_HINT_RANGE, "-360,360,0.01"), "set_param", "get_param", PARAM_ANGULAR_VELOCITY);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "angular_velocity_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_ANGULAR_VELOCITY);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "angular_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANGULAR_VELOCITY);
 	ADD_GROUP("Orbit Velocity", "orbit_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "orbit_velocity", PROPERTY_HINT_RANGE, "-1000,1000,0.01"), "set_param", "get_param", PARAM_ORBIT_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "orbit_velocity", PROPERTY_HINT_RANGE, "-1000,1000,0.01,or_lesser,or_greater"), "set_param", "get_param", PARAM_ORBIT_VELOCITY);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "orbit_velocity_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_ORBIT_VELOCITY);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "orbit_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ORBIT_VELOCITY);
 	ADD_GROUP("Linear Accel", "linear_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_accel", PROPERTY_HINT_RANGE, "-100,100,0.01"), "set_param", "get_param", PARAM_LINEAR_ACCEL);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_accel", PROPERTY_HINT_RANGE, "-100,100,0.01,or_lesser,or_greater"), "set_param", "get_param", PARAM_LINEAR_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_accel_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_LINEAR_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "linear_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_LINEAR_ACCEL);
 	ADD_GROUP("Radial Accel", "radial_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "radial_accel", PROPERTY_HINT_RANGE, "-100,100,0.01"), "set_param", "get_param", PARAM_RADIAL_ACCEL);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "radial_accel", PROPERTY_HINT_RANGE, "-100,100,0.01,or_lesser,or_greater"), "set_param", "get_param", PARAM_RADIAL_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "radial_accel_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_RADIAL_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "radial_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_RADIAL_ACCEL);
 	ADD_GROUP("Tangential Accel", "tangential_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "tangential_accel", PROPERTY_HINT_RANGE, "-100,100,0.01"), "set_param", "get_param", PARAM_TANGENTIAL_ACCEL);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "tangential_accel", PROPERTY_HINT_RANGE, "-100,100,0.01,or_lesser,or_greater"), "set_param", "get_param", PARAM_TANGENTIAL_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "tangential_accel_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_TANGENTIAL_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "tangential_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_TANGENTIAL_ACCEL);
 	ADD_GROUP("Damping", "");
@@ -1508,11 +1487,11 @@ void ParticlesMaterial::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "damping_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_DAMPING);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "damping_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_DAMPING);
 	ADD_GROUP("Angle", "");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "angle", PROPERTY_HINT_RANGE, "-720,720,0.1"), "set_param", "get_param", PARAM_ANGLE);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "angle", PROPERTY_HINT_RANGE, "-720,720,0.1,or_lesser,or_greater"), "set_param", "get_param", PARAM_ANGLE);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "angle_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_ANGLE);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "angle_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANGLE);
 	ADD_GROUP("Scale", "");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "scale", PROPERTY_HINT_RANGE, "0,1000,0.01"), "set_param", "get_param", PARAM_SCALE);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "scale", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param", "get_param", PARAM_SCALE);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "scale_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_SCALE);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "scale_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_SCALE);
 	ADD_GROUP("Color", "");
@@ -1524,7 +1503,7 @@ void ParticlesMaterial::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "hue_variation_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_HUE_VARIATION);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "hue_variation_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_HUE_VARIATION);
 	ADD_GROUP("Animation", "anim_");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "anim_speed", PROPERTY_HINT_RANGE, "0,128,0.01"), "set_param", "get_param", PARAM_ANIM_SPEED);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "anim_speed", PROPERTY_HINT_RANGE, "0,128,0.01,or_greater"), "set_param", "get_param", PARAM_ANIM_SPEED);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "anim_speed_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_ANIM_SPEED);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anim_speed_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANIM_SPEED);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "anim_offset", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param", "get_param", PARAM_ANIM_OFFSET);
diff --git a/scene/3d/path.cpp b/scene/3d/path.cpp
index 7ac7f74bb0..154dcb4259 100644
--- a/scene/3d/path.cpp
+++ b/scene/3d/path.cpp
@@ -40,6 +40,9 @@ void Path::_curve_changed() {
 
 	if (is_inside_tree() && Engine::get_singleton()->is_editor_hint())
 		update_gizmo();
+	if (is_inside_tree()) {
+		emit_signal("curve_changed");
+	}
 }
 
 void Path::set_curve(const Ref<Curve3D> &p_curve) {
@@ -68,6 +71,8 @@ void Path::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_curve_changed"), &Path::_curve_changed);
 
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "curve", PROPERTY_HINT_RESOURCE_TYPE, "Curve3D"), "set_curve", "get_curve");
+
+	ADD_SIGNAL(MethodInfo("curve_changed"));
 }
 
 Path::Path() {
@@ -225,7 +230,7 @@ void PathFollow::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_loop", "loop"), &PathFollow::set_loop);
 	ClassDB::bind_method(D_METHOD("has_loop"), &PathFollow::has_loop);
 
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset", PROPERTY_HINT_RANGE, "0,10000,0.01"), "set_offset", "get_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset", PROPERTY_HINT_EXP_RANGE, "0,10000,0.01,or_greater"), "set_offset", "get_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "unit_offset", PROPERTY_HINT_RANGE, "0,1,0.0001", PROPERTY_USAGE_EDITOR), "set_unit_offset", "get_unit_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "h_offset"), "set_h_offset", "get_h_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "v_offset"), "set_v_offset", "get_v_offset");
diff --git a/scene/3d/physics_body.cpp b/scene/3d/physics_body.cpp
index 9aac391d80..5056fb2fe4 100644
--- a/scene/3d/physics_body.cpp
+++ b/scene/3d/physics_body.cpp
@@ -34,6 +34,10 @@
 #include "method_bind_ext.gen.inc"
 #include "scene/scene_string_names.h"
 
+#ifdef TOOLS_ENABLED
+#include "editor/plugins/spatial_editor_plugin.h"
+#endif
+
 void PhysicsBody::_notification(int p_what) {
 
 	/*
@@ -1266,3 +1270,1112 @@ KinematicCollision::KinematicCollision() {
 	collision.local_shape = 0;
 	owner = NULL;
 }
+
+///////////////////////////////////////
+
+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"));
+	p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/twist_span", PROPERTY_HINT_RANGE, "-40000,40000,0.1,or_lesser,or_greater"));
+	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();
+			_reset_physics_simulation_state();
+			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");
+
+	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);
+}
+
+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),
+		_internal_static_body(false),
+		_internal_simulate_physics(false),
+		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;
+}
diff --git a/scene/3d/physics_body.h b/scene/3d/physics_body.h
index ffdc9ab309..17d2769c79 100644
--- a/scene/3d/physics_body.h
+++ b/scene/3d/physics_body.h
@@ -33,6 +33,7 @@
 
 #include "scene/3d/collision_object.h"
 #include "servers/physics_server.h"
+#include "skeleton.h"
 #include "vset.h"
 
 class PhysicsBody : public CollisionObject {
@@ -342,4 +343,267 @@ public:
 	KinematicCollision();
 };
 
+class PhysicalBone : public PhysicsBody {
+
+	GDCLASS(PhysicalBone, PhysicsBody);
+
+public:
+	enum JointType {
+		JOINT_TYPE_NONE,
+		JOINT_TYPE_PIN,
+		JOINT_TYPE_CONE,
+		JOINT_TYPE_HINGE,
+		JOINT_TYPE_SLIDER,
+		JOINT_TYPE_6DOF
+	};
+
+	struct JointData {
+		virtual JointType get_joint_type() { return JOINT_TYPE_NONE; }
+
+		/// "j" is used to set the parameter inside the PhysicsServer
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+	};
+
+	struct PinJointData : public JointData {
+		virtual JointType get_joint_type() { return JOINT_TYPE_PIN; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		real_t bias;
+		real_t damping;
+		real_t impulse_clamp;
+
+		PinJointData() :
+				bias(0.3),
+				damping(1.),
+				impulse_clamp(0) {}
+	};
+
+	struct ConeJointData : public JointData {
+		virtual JointType get_joint_type() { return JOINT_TYPE_CONE; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		real_t swing_span;
+		real_t twist_span;
+		real_t bias;
+		real_t softness;
+		real_t relaxation;
+
+		ConeJointData() :
+				swing_span(Math_PI * 0.25),
+				twist_span(Math_PI),
+				bias(0.3),
+				softness(0.8),
+				relaxation(1.) {}
+	};
+
+	struct HingeJointData : public JointData {
+		virtual JointType get_joint_type() { return JOINT_TYPE_HINGE; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		bool angular_limit_enabled;
+		real_t angular_limit_upper;
+		real_t angular_limit_lower;
+		real_t angular_limit_bias;
+		real_t angular_limit_softness;
+		real_t angular_limit_relaxation;
+
+		HingeJointData() :
+				angular_limit_enabled(false),
+				angular_limit_upper(Math_PI * 0.5),
+				angular_limit_lower(-Math_PI * 0.5),
+				angular_limit_bias(0.3),
+				angular_limit_softness(0.9),
+				angular_limit_relaxation(1.) {}
+	};
+
+	struct SliderJointData : public JointData {
+		virtual JointType get_joint_type() { return JOINT_TYPE_SLIDER; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		real_t linear_limit_upper;
+		real_t linear_limit_lower;
+		real_t linear_limit_softness;
+		real_t linear_limit_restitution;
+		real_t linear_limit_damping;
+		real_t angular_limit_upper;
+		real_t angular_limit_lower;
+		real_t angular_limit_softness;
+		real_t angular_limit_restitution;
+		real_t angular_limit_damping;
+
+		SliderJointData() :
+				linear_limit_upper(1.),
+				linear_limit_lower(-1.),
+				linear_limit_softness(1.),
+				linear_limit_restitution(0.7),
+				linear_limit_damping(1.),
+				angular_limit_upper(0),
+				angular_limit_lower(0),
+				angular_limit_softness(1.),
+				angular_limit_restitution(0.7),
+				angular_limit_damping(1.) {}
+	};
+
+	struct SixDOFJointData : public JointData {
+		struct SixDOFAxisData {
+			bool linear_limit_enabled;
+			real_t linear_limit_upper;
+			real_t linear_limit_lower;
+			real_t linear_limit_softness;
+			real_t linear_restitution;
+			real_t linear_damping;
+			bool angular_limit_enabled;
+			real_t angular_limit_upper;
+			real_t angular_limit_lower;
+			real_t angular_limit_softness;
+			real_t angular_restitution;
+			real_t angular_damping;
+			real_t erp;
+
+			SixDOFAxisData() :
+					linear_limit_enabled(true),
+					linear_limit_upper(0),
+					linear_limit_lower(0),
+					linear_limit_softness(0.7),
+					linear_restitution(0.5),
+					linear_damping(1.),
+					angular_limit_enabled(true),
+					angular_limit_upper(0),
+					angular_limit_lower(0),
+					angular_limit_softness(0.5),
+					angular_restitution(0),
+					angular_damping(1.),
+					erp(0.5) {}
+		};
+
+		virtual JointType get_joint_type() { return JOINT_TYPE_6DOF; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j = RID());
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		SixDOFAxisData axis_data[3];
+
+		SixDOFJointData() {}
+	};
+
+private:
+#ifdef TOOLS_ENABLED
+	// if false gizmo move body
+	bool gizmo_move_joint;
+#endif
+
+	JointData *joint_data;
+	Transform joint_offset;
+	RID joint;
+
+	Skeleton *parent_skeleton;
+	Transform body_offset;
+	Transform body_offset_inverse;
+	bool static_body;
+	bool _internal_static_body;
+	bool simulate_physics;
+	bool _internal_simulate_physics;
+	int bone_id;
+
+	String bone_name;
+	real_t bounce;
+	real_t mass;
+	real_t friction;
+	real_t gravity_scale;
+
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
+	void _notification(int p_what);
+	void _direct_state_changed(Object *p_state);
+
+	static void _bind_methods();
+
+private:
+	static Skeleton *find_skeleton_parent(Node *p_parent);
+	void _fix_joint_offset();
+	void _reload_joint();
+
+public:
+	void _on_bone_parent_changed();
+	void _set_gizmo_move_joint(bool p_move_joint);
+
+public:
+#ifdef TOOLS_ENABLED
+	virtual Transform get_global_gizmo_transform() const;
+	virtual Transform get_local_gizmo_transform() const;
+#endif
+
+	const JointData *get_joint_data() const;
+	Skeleton *find_skeleton_parent();
+
+	int get_bone_id() const { return bone_id; }
+
+	void set_joint_type(JointType p_joint_type);
+	JointType get_joint_type() const;
+
+	void set_joint_offset(const Transform &p_offset);
+	const Transform &get_joint_offset() const;
+
+	void set_body_offset(const Transform &p_offset);
+	const Transform &get_body_offset() const;
+
+	void set_static_body(bool p_static);
+	bool is_static_body();
+
+	void set_simulate_physics(bool p_simulate);
+	bool get_simulate_physics();
+	bool is_simulating_physics();
+
+	void set_bone_name(const String &p_name);
+	const String &get_bone_name() const;
+
+	void set_mass(real_t p_mass);
+	real_t get_mass() const;
+
+	void set_weight(real_t p_weight);
+	real_t get_weight() const;
+
+	void set_friction(real_t p_friction);
+	real_t get_friction() const;
+
+	void set_bounce(real_t p_bounce);
+	real_t get_bounce() const;
+
+	void set_gravity_scale(real_t p_gravity_scale);
+	real_t get_gravity_scale() const;
+
+	PhysicalBone();
+	~PhysicalBone();
+
+private:
+	void update_bone_id();
+	void update_offset();
+	void reset_to_rest_position();
+
+	void _reset_physics_simulation_state();
+	void _reset_staticness_state();
+
+	void _start_physics_simulation();
+	void _stop_physics_simulation();
+};
+
+VARIANT_ENUM_CAST(PhysicalBone::JointType);
+
 #endif // PHYSICS_BODY__H
diff --git a/scene/3d/physics_joint.cpp b/scene/3d/physics_joint.cpp
index 2e9f1a241a..b2d10006f7 100644
--- a/scene/3d/physics_joint.cpp
+++ b/scene/3d/physics_joint.cpp
@@ -716,6 +716,9 @@ void Generic6DOFJoint::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_x/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_LINEAR_LIMIT_SOFTNESS);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_x/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_LINEAR_RESTITUTION);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_x/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_LINEAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_x/target_velocity"), "set_param_x", "get_param_x", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_x/force_limit"), "set_param_x", "get_param_x", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_ANGULAR_LIMIT);
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_x/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_hi_limit_x", "_get_angular_hi_limit_x");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_x/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_lo_limit_x", "_get_angular_lo_limit_x");
@@ -734,6 +737,9 @@ void Generic6DOFJoint::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_y/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_LINEAR_LIMIT_SOFTNESS);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_y/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_LINEAR_RESTITUTION);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_y/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_LINEAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_y/target_velocity"), "set_param_y", "get_param_y", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_y/force_limit"), "set_param_y", "get_param_y", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_ANGULAR_LIMIT);
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_y/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_hi_limit_y", "_get_angular_hi_limit_y");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_y/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_lo_limit_y", "_get_angular_lo_limit_y");
@@ -752,6 +758,9 @@ void Generic6DOFJoint::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_z/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_LINEAR_LIMIT_SOFTNESS);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_z/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_LINEAR_RESTITUTION);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_limit_z/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_LINEAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_z/target_velocity"), "set_param_z", "get_param_z", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "linear_motor_z/force_limit"), "set_param_z", "get_param_z", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_ANGULAR_LIMIT);
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_z/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_hi_limit_z", "_get_angular_hi_limit_z");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "angular_limit_z/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01"), "_set_angular_lo_limit_z", "_get_angular_lo_limit_z");
@@ -769,6 +778,8 @@ void Generic6DOFJoint::_bind_methods() {
 	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_SOFTNESS);
 	BIND_ENUM_CONSTANT(PARAM_LINEAR_RESTITUTION);
 	BIND_ENUM_CONSTANT(PARAM_LINEAR_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_MOTOR_FORCE_LIMIT);
 	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LOWER_LIMIT);
 	BIND_ENUM_CONSTANT(PARAM_ANGULAR_UPPER_LIMIT);
 	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_SOFTNESS);
@@ -783,6 +794,7 @@ void Generic6DOFJoint::_bind_methods() {
 	BIND_ENUM_CONSTANT(FLAG_ENABLE_LINEAR_LIMIT);
 	BIND_ENUM_CONSTANT(FLAG_ENABLE_ANGULAR_LIMIT);
 	BIND_ENUM_CONSTANT(FLAG_ENABLE_MOTOR);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_LINEAR_MOTOR);
 	BIND_ENUM_CONSTANT(FLAG_MAX);
 }
 
@@ -912,6 +924,8 @@ Generic6DOFJoint::Generic6DOFJoint() {
 	set_param_x(PARAM_LINEAR_LIMIT_SOFTNESS, 0.7);
 	set_param_x(PARAM_LINEAR_RESTITUTION, 0.5);
 	set_param_x(PARAM_LINEAR_DAMPING, 1.0);
+	set_param_x(PARAM_LINEAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_x(PARAM_LINEAR_MOTOR_FORCE_LIMIT, 0);
 	set_param_x(PARAM_ANGULAR_LOWER_LIMIT, 0);
 	set_param_x(PARAM_ANGULAR_UPPER_LIMIT, 0);
 	set_param_x(PARAM_ANGULAR_LIMIT_SOFTNESS, 0.5f);
@@ -925,12 +939,15 @@ Generic6DOFJoint::Generic6DOFJoint() {
 	set_flag_x(FLAG_ENABLE_ANGULAR_LIMIT, true);
 	set_flag_x(FLAG_ENABLE_LINEAR_LIMIT, true);
 	set_flag_x(FLAG_ENABLE_MOTOR, false);
+	set_flag_x(FLAG_ENABLE_LINEAR_MOTOR, false);
 
 	set_param_y(PARAM_LINEAR_LOWER_LIMIT, 0);
 	set_param_y(PARAM_LINEAR_UPPER_LIMIT, 0);
 	set_param_y(PARAM_LINEAR_LIMIT_SOFTNESS, 0.7);
 	set_param_y(PARAM_LINEAR_RESTITUTION, 0.5);
 	set_param_y(PARAM_LINEAR_DAMPING, 1.0);
+	set_param_y(PARAM_LINEAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_y(PARAM_LINEAR_MOTOR_FORCE_LIMIT, 0);
 	set_param_y(PARAM_ANGULAR_LOWER_LIMIT, 0);
 	set_param_y(PARAM_ANGULAR_UPPER_LIMIT, 0);
 	set_param_y(PARAM_ANGULAR_LIMIT_SOFTNESS, 0.5f);
@@ -944,12 +961,15 @@ Generic6DOFJoint::Generic6DOFJoint() {
 	set_flag_y(FLAG_ENABLE_ANGULAR_LIMIT, true);
 	set_flag_y(FLAG_ENABLE_LINEAR_LIMIT, true);
 	set_flag_y(FLAG_ENABLE_MOTOR, false);
+	set_flag_y(FLAG_ENABLE_LINEAR_MOTOR, false);
 
 	set_param_z(PARAM_LINEAR_LOWER_LIMIT, 0);
 	set_param_z(PARAM_LINEAR_UPPER_LIMIT, 0);
 	set_param_z(PARAM_LINEAR_LIMIT_SOFTNESS, 0.7);
 	set_param_z(PARAM_LINEAR_RESTITUTION, 0.5);
 	set_param_z(PARAM_LINEAR_DAMPING, 1.0);
+	set_param_z(PARAM_LINEAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_z(PARAM_LINEAR_MOTOR_FORCE_LIMIT, 0);
 	set_param_z(PARAM_ANGULAR_LOWER_LIMIT, 0);
 	set_param_z(PARAM_ANGULAR_UPPER_LIMIT, 0);
 	set_param_z(PARAM_ANGULAR_LIMIT_SOFTNESS, 0.5f);
@@ -963,4 +983,5 @@ Generic6DOFJoint::Generic6DOFJoint() {
 	set_flag_z(FLAG_ENABLE_ANGULAR_LIMIT, true);
 	set_flag_z(FLAG_ENABLE_LINEAR_LIMIT, true);
 	set_flag_z(FLAG_ENABLE_MOTOR, false);
+	set_flag_z(FLAG_ENABLE_LINEAR_MOTOR, false);
 }
diff --git a/scene/3d/physics_joint.h b/scene/3d/physics_joint.h
index 000109ac55..37870d6f30 100644
--- a/scene/3d/physics_joint.h
+++ b/scene/3d/physics_joint.h
@@ -249,6 +249,8 @@ public:
 		PARAM_LINEAR_LIMIT_SOFTNESS = PhysicsServer::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS,
 		PARAM_LINEAR_RESTITUTION = PhysicsServer::G6DOF_JOINT_LINEAR_RESTITUTION,
 		PARAM_LINEAR_DAMPING = PhysicsServer::G6DOF_JOINT_LINEAR_DAMPING,
+		PARAM_LINEAR_MOTOR_TARGET_VELOCITY = PhysicsServer::G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY,
+		PARAM_LINEAR_MOTOR_FORCE_LIMIT = PhysicsServer::G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT,
 		PARAM_ANGULAR_LOWER_LIMIT = PhysicsServer::G6DOF_JOINT_ANGULAR_LOWER_LIMIT,
 		PARAM_ANGULAR_UPPER_LIMIT = PhysicsServer::G6DOF_JOINT_ANGULAR_UPPER_LIMIT,
 		PARAM_ANGULAR_LIMIT_SOFTNESS = PhysicsServer::G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS,
@@ -265,6 +267,7 @@ public:
 		FLAG_ENABLE_LINEAR_LIMIT = PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT,
 		FLAG_ENABLE_ANGULAR_LIMIT = PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT,
 		FLAG_ENABLE_MOTOR = PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_MOTOR,
+		FLAG_ENABLE_LINEAR_MOTOR = PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR,
 		FLAG_MAX = PhysicsServer::G6DOF_JOINT_FLAG_MAX
 	};
 
diff --git a/scene/3d/reflection_probe.cpp b/scene/3d/reflection_probe.cpp
index 2178da02b5..7e3a87cbd4 100644
--- a/scene/3d/reflection_probe.cpp
+++ b/scene/3d/reflection_probe.cpp
@@ -240,7 +240,7 @@ void ReflectionProbe::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "update_mode", PROPERTY_HINT_ENUM, "Once,Always"), "set_update_mode", "get_update_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "intensity", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_intensity", "get_intensity");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_RANGE, "0,16384,0.1"), "set_max_distance", "get_max_distance");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_EXP_RANGE, "0,16384,0.1,or_greater"), "set_max_distance", "get_max_distance");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "extents"), "set_extents", "get_extents");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "origin_offset"), "set_origin_offset", "get_origin_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "box_projection"), "set_enable_box_projection", "is_box_projection_enabled");
diff --git a/scene/3d/skeleton.cpp b/scene/3d/skeleton.cpp
index d3a13c741e..76d90dc6ff 100644
--- a/scene/3d/skeleton.cpp
+++ b/scene/3d/skeleton.cpp
@@ -33,6 +33,7 @@
 #include "message_queue.h"
 
 #include "core/project_settings.h"
+#include "scene/3d/physics_body.h"
 #include "scene/resources/surface_tool.h"
 
 bool Skeleton::_set(const StringName &p_path, const Variant &p_value) {
@@ -329,7 +330,7 @@ void Skeleton::add_bone(const String &p_name) {
 	_make_dirty();
 	update_gizmo();
 }
-int Skeleton::find_bone(String p_name) const {
+int Skeleton::find_bone(const String &p_name) const {
 
 	for (int i = 0; i < bones.size(); i++) {
 
@@ -346,6 +347,19 @@ String Skeleton::get_bone_name(int p_bone) const {
 	return bones[p_bone].name;
 }
 
+bool Skeleton::is_bone_parent_of(int p_bone, int p_parent_bone_id) const {
+
+	int parent_of_bone = get_bone_parent(p_bone);
+
+	if (-1 == parent_of_bone)
+		return false;
+
+	if (parent_of_bone == p_parent_bone_id)
+		return true;
+
+	return is_bone_parent_of(parent_of_bone, p_parent_bone_id);
+}
+
 int Skeleton::get_bone_count() const {
 
 	return bones.size();
@@ -377,6 +391,17 @@ void Skeleton::unparent_bone_and_rest(int p_bone) {
 	_make_dirty();
 }
 
+void Skeleton::set_bone_ignore_animation(int p_bone, bool p_ignore) {
+	ERR_FAIL_INDEX(p_bone, bones.size());
+	bones[p_bone].ignore_animation = p_ignore;
+}
+
+bool Skeleton::is_bone_ignore_animation(int p_bone) const {
+
+	ERR_FAIL_INDEX_V(p_bone, bones.size(), false);
+	return bones[p_bone].ignore_animation;
+}
+
 void Skeleton::set_bone_disable_rest(int p_bone, bool p_disable) {
 
 	ERR_FAIL_INDEX(p_bone, bones.size());
@@ -522,6 +547,150 @@ void Skeleton::localize_rests() {
 	}
 }
 
+void Skeleton::bind_physical_bone_to_bone(int p_bone, PhysicalBone *p_physical_bone) {
+	ERR_FAIL_INDEX(p_bone, bones.size());
+	ERR_FAIL_COND(bones[p_bone].physical_bone);
+	ERR_FAIL_COND(!p_physical_bone);
+	bones[p_bone].physical_bone = p_physical_bone;
+
+	_rebuild_physical_bones_cache();
+}
+
+void Skeleton::unbind_physical_bone_from_bone(int p_bone) {
+	ERR_FAIL_INDEX(p_bone, bones.size());
+	bones[p_bone].physical_bone = NULL;
+
+	_rebuild_physical_bones_cache();
+}
+
+PhysicalBone *Skeleton::get_physical_bone(int p_bone) {
+	ERR_FAIL_INDEX_V(p_bone, bones.size(), NULL);
+
+	return bones[p_bone].physical_bone;
+}
+
+PhysicalBone *Skeleton::get_physical_bone_parent(int p_bone) {
+	ERR_FAIL_INDEX_V(p_bone, bones.size(), NULL);
+
+	if (bones[p_bone].cache_parent_physical_bone) {
+		return bones[p_bone].cache_parent_physical_bone;
+	}
+
+	return _get_physical_bone_parent(p_bone);
+}
+
+PhysicalBone *Skeleton::_get_physical_bone_parent(int p_bone) {
+	ERR_FAIL_INDEX_V(p_bone, bones.size(), NULL);
+
+	const int parent_bone = bones[p_bone].parent;
+	if (0 > parent_bone) {
+		return NULL;
+	}
+
+	PhysicalBone *pb = bones[parent_bone].physical_bone;
+	if (pb) {
+		return pb;
+	} else {
+		return get_physical_bone_parent(parent_bone);
+	}
+}
+
+void Skeleton::_rebuild_physical_bones_cache() {
+	const int b_size = bones.size();
+	for (int i = 0; i < b_size; ++i) {
+		bones[i].cache_parent_physical_bone = _get_physical_bone_parent(i);
+		if (bones[i].physical_bone)
+			bones[i].physical_bone->_on_bone_parent_changed();
+	}
+}
+
+void _pb_stop_simulation(Node *p_node) {
+
+	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
+		_pb_stop_simulation(p_node->get_child(i));
+	}
+
+	PhysicalBone *pb = Object::cast_to<PhysicalBone>(p_node);
+	if (pb) {
+		pb->set_simulate_physics(false);
+		pb->set_static_body(false);
+	}
+}
+
+void Skeleton::physical_bones_stop_simulation() {
+	_pb_stop_simulation(this);
+}
+
+void _pb_start_simulation(const Skeleton *p_skeleton, Node *p_node, const Vector<int> &p_sim_bones) {
+
+	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
+		_pb_start_simulation(p_skeleton, p_node->get_child(i), p_sim_bones);
+	}
+
+	PhysicalBone *pb = Object::cast_to<PhysicalBone>(p_node);
+	if (pb) {
+		bool sim = false;
+		for (int i = p_sim_bones.size() - 1; 0 <= i; --i) {
+			if (p_sim_bones[i] == pb->get_bone_id() || p_skeleton->is_bone_parent_of(pb->get_bone_id(), p_sim_bones[i])) {
+				sim = true;
+				break;
+			}
+		}
+
+		pb->set_simulate_physics(true);
+		if (sim) {
+			pb->set_static_body(false);
+		} else {
+			pb->set_static_body(true);
+		}
+	}
+}
+
+void Skeleton::physical_bones_start_simulation_on(const Array &p_bones) {
+
+	Vector<int> sim_bones;
+	if (p_bones.size() <= 0) {
+		sim_bones.push_back(0); // if no bones is specified, activate ragdoll on full body
+	} else {
+		sim_bones.resize(p_bones.size());
+		int c = 0;
+		for (int i = sim_bones.size() - 1; 0 <= i; --i) {
+			if (Variant::STRING == p_bones.get(i).get_type()) {
+				int bone_id = find_bone(p_bones.get(i));
+				if (bone_id != -1)
+					sim_bones[c++] = bone_id;
+			}
+		}
+		sim_bones.resize(c);
+	}
+
+	_pb_start_simulation(this, this, sim_bones);
+}
+
+void _physical_bones_add_remove_collision_exception(bool p_add, Node *p_node, RID p_exception) {
+
+	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
+		_physical_bones_add_remove_collision_exception(p_add, p_node->get_child(i), p_exception);
+	}
+
+	CollisionObject *co = Object::cast_to<CollisionObject>(p_node);
+	if (co) {
+		if (p_add) {
+			PhysicsServer::get_singleton()->body_add_collision_exception(co->get_rid(), p_exception);
+		} else {
+			PhysicsServer::get_singleton()->body_remove_collision_exception(co->get_rid(), p_exception);
+		}
+	}
+}
+
+void Skeleton::physical_bones_add_collision_exception(RID p_exception) {
+	_physical_bones_add_remove_collision_exception(true, this, p_exception);
+}
+
+void Skeleton::physical_bones_remove_collision_exception(RID p_exception) {
+	_physical_bones_add_remove_collision_exception(false, this, p_exception);
+}
+
 void Skeleton::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("add_bone", "name"), &Skeleton::add_bone);
@@ -558,6 +727,11 @@ void Skeleton::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("get_bone_transform", "bone_idx"), &Skeleton::get_bone_transform);
 
+	ClassDB::bind_method(D_METHOD("physical_bones_stop_simulation"), &Skeleton::physical_bones_stop_simulation);
+	ClassDB::bind_method(D_METHOD("physical_bones_start_simulation", "bones"), &Skeleton::physical_bones_start_simulation_on, DEFVAL(Array()));
+	ClassDB::bind_method(D_METHOD("physical_bones_add_collision_exception", "exception"), &Skeleton::physical_bones_add_collision_exception);
+	ClassDB::bind_method(D_METHOD("physical_bones_remove_collision_exception", "exception"), &Skeleton::physical_bones_remove_collision_exception);
+
 	BIND_CONSTANT(NOTIFICATION_UPDATE_SKELETON);
 }
 
@@ -570,6 +744,5 @@ Skeleton::Skeleton() {
 }
 
 Skeleton::~Skeleton() {
-
 	VisualServer::get_singleton()->free(skeleton);
 }
diff --git a/scene/3d/skeleton.h b/scene/3d/skeleton.h
index d693670055..dad11960a5 100644
--- a/scene/3d/skeleton.h
+++ b/scene/3d/skeleton.h
@@ -37,6 +37,8 @@
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
+
+class PhysicalBone;
 class Skeleton : public Spatial {
 
 	GDCLASS(Skeleton, Spatial);
@@ -48,6 +50,8 @@ class Skeleton : public Spatial {
 		bool enabled;
 		int parent;
 
+		bool ignore_animation;
+
 		bool disable_rest;
 		Transform rest;
 		Transform rest_global_inverse;
@@ -60,13 +64,19 @@ class Skeleton : public Spatial {
 
 		Transform transform_final;
 
+		PhysicalBone *physical_bone;
+		PhysicalBone *cache_parent_physical_bone;
+
 		List<uint32_t> nodes_bound;
 
 		Bone() {
 			parent = -1;
 			enabled = true;
+			ignore_animation = false;
 			custom_pose_enable = false;
 			disable_rest = false;
+			physical_bone = NULL;
+			cache_parent_physical_bone = NULL;
 		}
 	};
 
@@ -110,14 +120,19 @@ public:
 
 	// skeleton creation api
 	void add_bone(const String &p_name);
-	int find_bone(String p_name) const;
+	int find_bone(const String &p_name) const;
 	String get_bone_name(int p_bone) const;
 
+	bool is_bone_parent_of(int p_bone_id, int p_parent_bone_id) const;
+
 	void set_bone_parent(int p_bone, int p_parent);
 	int get_bone_parent(int p_bone) const;
 
 	void unparent_bone_and_rest(int p_bone);
 
+	void set_bone_ignore_animation(int p_bone, bool p_ignore);
+	bool is_bone_ignore_animation(int p_bone) const;
+
 	void set_bone_disable_rest(int p_bone, bool p_disable);
 	bool is_bone_rest_disabled(int p_bone) const;
 
@@ -149,6 +164,26 @@ public:
 
 	void localize_rests(); // used for loaders and tools
 
+	// Physical bone API
+
+	void bind_physical_bone_to_bone(int p_bone, PhysicalBone *p_physical_bone);
+	void unbind_physical_bone_from_bone(int p_bone);
+
+	PhysicalBone *get_physical_bone(int p_bone);
+	PhysicalBone *get_physical_bone_parent(int p_bone);
+
+private:
+	/// This is a slow API os it's cached
+	PhysicalBone *_get_physical_bone_parent(int p_bone);
+	void _rebuild_physical_bones_cache();
+
+public:
+	void physical_bones_stop_simulation();
+	void physical_bones_start_simulation_on(const Array &p_bones);
+	void physical_bones_add_collision_exception(RID p_exception);
+	void physical_bones_remove_collision_exception(RID p_exception);
+
+public:
 	Skeleton();
 	~Skeleton();
 };
diff --git a/scene/3d/spatial.cpp b/scene/3d/spatial.cpp
index dab0e573d7..748aa8aad4 100644
--- a/scene/3d/spatial.cpp
+++ b/scene/3d/spatial.cpp
@@ -286,6 +286,16 @@ Transform Spatial::get_global_transform() const {
 	return data.global_transform;
 }
 
+#ifdef TOOLS_ENABLED
+Transform Spatial::get_global_gizmo_transform() const {
+	return get_global_transform();
+}
+
+Transform Spatial::get_local_gizmo_transform() const {
+	return get_transform();
+}
+#endif
+
 Spatial *Spatial::get_parent_spatial() const {
 
 	return data.parent;
@@ -430,10 +440,9 @@ Ref<SpatialGizmo> Spatial::get_gizmo() const {
 #endif
 }
 
-#ifdef TOOLS_ENABLED
-
 void Spatial::_update_gizmo() {
 
+#ifdef TOOLS_ENABLED
 	if (!is_inside_world())
 		return;
 	data.gizmo_dirty = false;
@@ -445,8 +454,10 @@ void Spatial::_update_gizmo() {
 				data.gizmo->clear();
 		}
 	}
+#endif
 }
 
+#ifdef TOOLS_ENABLED
 void Spatial::set_disable_gizmo(bool p_enabled) {
 
 	data.gizmo_disabled = p_enabled;
@@ -726,9 +737,7 @@ void Spatial::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_set_as_toplevel"), &Spatial::is_set_as_toplevel);
 	ClassDB::bind_method(D_METHOD("get_world"), &Spatial::get_world);
 
-#ifdef TOOLS_ENABLED
 	ClassDB::bind_method(D_METHOD("_update_gizmo"), &Spatial::_update_gizmo);
-#endif
 
 	ClassDB::bind_method(D_METHOD("update_gizmo"), &Spatial::update_gizmo);
 	ClassDB::bind_method(D_METHOD("set_gizmo", "gizmo"), &Spatial::set_gizmo);
@@ -790,9 +799,7 @@ void Spatial::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "scale", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_scale", "get_scale");
 	ADD_GROUP("Visibility", "");
 	ADD_PROPERTYNO(PropertyInfo(Variant::BOOL, "visible"), "set_visible", "is_visible");
-#ifdef TOOLS_ENABLED
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "gizmo", PROPERTY_HINT_RESOURCE_TYPE, "SpatialGizmo", 0), "set_gizmo", "get_gizmo");
-#endif
 
 	ADD_SIGNAL(MethodInfo("visibility_changed"));
 }
diff --git a/scene/3d/spatial.h b/scene/3d/spatial.h
index 518bba9a51..a43bed3e4a 100644
--- a/scene/3d/spatial.h
+++ b/scene/3d/spatial.h
@@ -100,10 +100,8 @@ class Spatial : public Node {
 #endif
 
 	} data;
-#ifdef TOOLS_ENABLED
 
 	void _update_gizmo();
-#endif
 	void _notify_dirty();
 	void _propagate_transform_changed(Spatial *p_origin);
 
@@ -147,6 +145,11 @@ public:
 	Transform get_transform() const;
 	Transform get_global_transform() const;
 
+#ifdef TOOLS_ENABLED
+	virtual Transform get_global_gizmo_transform() const;
+	virtual Transform get_local_gizmo_transform() const;
+#endif
+
 	void set_as_toplevel(bool p_enabled);
 	bool is_set_as_toplevel() const;
 
diff --git a/scene/3d/sprite_3d.cpp b/scene/3d/sprite_3d.cpp
index bc44c91f64..232855c978 100644
--- a/scene/3d/sprite_3d.cpp
+++ b/scene/3d/sprite_3d.cpp
@@ -366,17 +366,11 @@ void Sprite3D::_draw() {
 		final_rect.position * pixel_size,
 
 	};
-
-	// Properly setup UVs for impostor textures (AtlasTexture).
-	RID texture_rid = texture->get_rid();
-	Vector2 src_tsize = Vector2(
-			VS::get_singleton()->texture_get_width(texture_rid),
-			VS::get_singleton()->texture_get_height(texture_rid));
 	Vector2 uvs[4] = {
-		final_src_rect.position / src_tsize,
-		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / src_tsize,
-		(final_src_rect.position + final_src_rect.size) / src_tsize,
-		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / src_tsize,
+		final_src_rect.position / tsize,
+		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
+		(final_src_rect.position + final_src_rect.size) / tsize,
+		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / tsize,
 	};
 
 	if (is_flipped_h()) {
@@ -655,23 +649,18 @@ void AnimatedSprite3D::_draw() {
 	float pixel_size = get_pixel_size();
 
 	Vector2 vertices[4] = {
+
 		(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
 		(final_rect.position + final_rect.size) * pixel_size,
 		(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
 		final_rect.position * pixel_size,
 
 	};
-
-	// Properly setup UVs for impostor textures (AtlasTexture).
-	RID texture_rid = texture->get_rid();
-	Vector2 src_tsize = Vector2(
-			VS::get_singleton()->texture_get_width(texture_rid),
-			VS::get_singleton()->texture_get_height(texture_rid));
 	Vector2 uvs[4] = {
-		final_src_rect.position / src_tsize,
-		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / src_tsize,
-		(final_src_rect.position + final_src_rect.size) / src_tsize,
-		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / src_tsize,
+		final_src_rect.position / tsize,
+		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
+		(final_src_rect.position + final_src_rect.size) / tsize,
+		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / tsize,
 	};
 
 	if (is_flipped_h()) {
diff --git a/scene/3d/vehicle_body.cpp b/scene/3d/vehicle_body.cpp
index b72665aa2b..ee8d249981 100644
--- a/scene/3d/vehicle_body.cpp
+++ b/scene/3d/vehicle_body.cpp
@@ -672,13 +672,8 @@ void VehicleBody::_update_friction(PhysicsDirectBodyState *s) {
 	m_forwardImpulse.resize(numWheel);
 	m_sideImpulse.resize(numWheel);
 
-	int numWheelsOnGround = 0;
-
 	//collapse all those loops into one!
 	for (int i = 0; i < wheels.size(); i++) {
-		VehicleWheel &wheelInfo = *wheels[i];
-		if (wheelInfo.m_raycastInfo.m_isInContact)
-			numWheelsOnGround++;
 		m_sideImpulse[i] = real_t(0.);
 		m_forwardImpulse[i] = real_t(0.);
 	}
@@ -929,7 +924,7 @@ void VehicleBody::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_steering"), &VehicleBody::get_steering);
 
 	ADD_GROUP("Motion", "");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "engine_force", PROPERTY_HINT_RANGE, "0.00,1024.0,0.01"), "set_engine_force", "get_engine_force");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "engine_force", PROPERTY_HINT_RANGE, "0.00,1024.0,0.01,or_greater"), "set_engine_force", "get_engine_force");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "brake", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"), "set_brake", "get_brake");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "steering", PROPERTY_HINT_RANGE, "-180,180.0,0.01"), "set_steering", "get_steering");
 }
diff --git a/scene/3d/voxel_light_baker.cpp b/scene/3d/voxel_light_baker.cpp
index d389b69ef3..670df5cc7f 100644
--- a/scene/3d/voxel_light_baker.cpp
+++ b/scene/3d/voxel_light_baker.cpp
@@ -2316,13 +2316,10 @@ Ref<MultiMesh> VoxelLightBaker::create_debug_multimesh(DebugMode p_mode) {
 
 		PoolVector<Vector3> vertices;
 		PoolVector<Color> colors;
-
-		int vtx_idx = 0;
 #define ADD_VTX(m_idx)                      \
 	;                                       \
 	vertices.push_back(face_points[m_idx]); \
-	colors.push_back(Color(1, 1, 1, 1));    \
-	vtx_idx++;
+	colors.push_back(Color(1, 1, 1, 1));
 
 		for (int i = 0; i < 6; i++) {
 
@@ -2338,9 +2335,9 @@ Ref<MultiMesh> VoxelLightBaker::create_debug_multimesh(DebugMode p_mode) {
 				for (int k = 0; k < 3; k++) {
 
 					if (i < 3)
-						face_points[j][(i + k) % 3] = v[k] * (i >= 3 ? -1 : 1);
+						face_points[j][(i + k) % 3] = v[k];
 					else
-						face_points[3 - j][(i + k) % 3] = v[k] * (i >= 3 ? -1 : 1);
+						face_points[3 - j][(i + k) % 3] = -v[k];
 				}
 			}