Split monolithic physics class files

Splits monolithic physics class files.

44 files changed, 11785 insertions, 0 deletions

diff --git a/scene/3d/physics/SCsub b/scene/3d/physics/SCsub
new file mode 100644
index 0000000000..e7fd3fe643
--- /dev/null
+++ b/scene/3d/physics/SCsub
@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env.add_source_files(env.scene_sources, "*.cpp")
+
+# Chain load SCsubs
+SConscript("joints/SCsub")
diff --git a/scene/3d/physics/animatable_body_3d.cpp b/scene/3d/physics/animatable_body_3d.cpp
new file mode 100644
index 0000000000..407e23a57e
--- /dev/null
+++ b/scene/3d/physics/animatable_body_3d.cpp
@@ -0,0 +1,128 @@
+/**************************************************************************/
+/*  animatable_body_3d.cpp                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "animatable_body_3d.h"
+
+Vector3 AnimatableBody3D::get_linear_velocity() const {
+	return linear_velocity;
+}
+
+Vector3 AnimatableBody3D::get_angular_velocity() const {
+	return angular_velocity;
+}
+
+void AnimatableBody3D::set_sync_to_physics(bool p_enable) {
+	if (sync_to_physics == p_enable) {
+		return;
+	}
+
+	sync_to_physics = p_enable;
+
+	_update_kinematic_motion();
+}
+
+bool AnimatableBody3D::is_sync_to_physics_enabled() const {
+	return sync_to_physics;
+}
+
+void AnimatableBody3D::_update_kinematic_motion() {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+#endif
+
+	if (sync_to_physics) {
+		set_only_update_transform_changes(true);
+		set_notify_local_transform(true);
+	} else {
+		set_only_update_transform_changes(false);
+		set_notify_local_transform(false);
+	}
+}
+
+void AnimatableBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
+	linear_velocity = p_state->get_linear_velocity();
+	angular_velocity = p_state->get_angular_velocity();
+
+	if (!sync_to_physics) {
+		return;
+	}
+
+	last_valid_transform = p_state->get_transform();
+	set_notify_local_transform(false);
+	set_global_transform(last_valid_transform);
+	set_notify_local_transform(true);
+	_on_transform_changed();
+}
+
+void AnimatableBody3D::_notification(int p_what) {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+#endif
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			last_valid_transform = get_global_transform();
+			_update_kinematic_motion();
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			set_only_update_transform_changes(false);
+			set_notify_local_transform(false);
+		} break;
+
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+			// Used by sync to physics, send the new transform to the physics...
+			Transform3D new_transform = get_global_transform();
+
+			PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_TRANSFORM, new_transform);
+
+			// ... but then revert changes.
+			set_notify_local_transform(false);
+			set_global_transform(last_valid_transform);
+			set_notify_local_transform(true);
+			_on_transform_changed();
+		} break;
+	}
+}
+
+void AnimatableBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_sync_to_physics", "enable"), &AnimatableBody3D::set_sync_to_physics);
+	ClassDB::bind_method(D_METHOD("is_sync_to_physics_enabled"), &AnimatableBody3D::is_sync_to_physics_enabled);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync_to_physics"), "set_sync_to_physics", "is_sync_to_physics_enabled");
+}
+
+AnimatableBody3D::AnimatableBody3D() :
+		StaticBody3D(PhysicsServer3D::BODY_MODE_KINEMATIC) {
+	PhysicsServer3D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &AnimatableBody3D::_body_state_changed));
+}
diff --git a/scene/3d/physics/animatable_body_3d.h b/scene/3d/physics/animatable_body_3d.h
new file mode 100644
index 0000000000..715b6917c0
--- /dev/null
+++ b/scene/3d/physics/animatable_body_3d.h
@@ -0,0 +1,67 @@
+/**************************************************************************/
+/*  animatable_body_3d.h                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef ANIMATABLE_BODY_3D_H
+#define ANIMATABLE_BODY_3D_H
+
+#include "scene/3d/physics/static_body_3d.h"
+
+class AnimatableBody3D : public StaticBody3D {
+	GDCLASS(AnimatableBody3D, StaticBody3D);
+
+private:
+	Vector3 linear_velocity;
+	Vector3 angular_velocity;
+
+	bool sync_to_physics = true;
+
+	Transform3D last_valid_transform;
+
+	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state);
+	void _body_state_changed(PhysicsDirectBodyState3D *p_state);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	virtual Vector3 get_linear_velocity() const override;
+	virtual Vector3 get_angular_velocity() const override;
+
+	AnimatableBody3D();
+
+private:
+	void _update_kinematic_motion();
+
+	void set_sync_to_physics(bool p_enable);
+	bool is_sync_to_physics_enabled() const;
+};
+
+#endif // ANIMATABLE_BODY_3D_H
diff --git a/scene/3d/physics/area_3d.cpp b/scene/3d/physics/area_3d.cpp
new file mode 100644
index 0000000000..014c33cad0
--- /dev/null
+++ b/scene/3d/physics/area_3d.cpp
@@ -0,0 +1,822 @@
+/**************************************************************************/
+/*  area_3d.cpp                                                           */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "area_3d.h"
+
+#include "scene/scene_string_names.h"
+#include "servers/audio_server.h"
+
+void Area3D::set_gravity_space_override_mode(SpaceOverride p_mode) {
+	gravity_space_override = p_mode;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY_OVERRIDE_MODE, p_mode);
+}
+
+Area3D::SpaceOverride Area3D::get_gravity_space_override_mode() const {
+	return gravity_space_override;
+}
+
+void Area3D::set_gravity_is_point(bool p_enabled) {
+	gravity_is_point = p_enabled;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY_IS_POINT, p_enabled);
+}
+
+bool Area3D::is_gravity_a_point() const {
+	return gravity_is_point;
+}
+
+void Area3D::set_gravity_point_unit_distance(real_t p_scale) {
+	gravity_point_unit_distance = p_scale;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY_POINT_UNIT_DISTANCE, p_scale);
+}
+
+real_t Area3D::get_gravity_point_unit_distance() const {
+	return gravity_point_unit_distance;
+}
+
+void Area3D::set_gravity_point_center(const Vector3 &p_center) {
+	gravity_vec = p_center;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY_VECTOR, p_center);
+}
+
+const Vector3 &Area3D::get_gravity_point_center() const {
+	return gravity_vec;
+}
+
+void Area3D::set_gravity_direction(const Vector3 &p_direction) {
+	gravity_vec = p_direction;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY_VECTOR, p_direction);
+}
+
+const Vector3 &Area3D::get_gravity_direction() const {
+	return gravity_vec;
+}
+
+void Area3D::set_gravity(real_t p_gravity) {
+	gravity = p_gravity;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_GRAVITY, p_gravity);
+}
+
+real_t Area3D::get_gravity() const {
+	return gravity;
+}
+
+void Area3D::set_linear_damp_space_override_mode(SpaceOverride p_mode) {
+	linear_damp_space_override = p_mode;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_LINEAR_DAMP_OVERRIDE_MODE, p_mode);
+}
+
+Area3D::SpaceOverride Area3D::get_linear_damp_space_override_mode() const {
+	return linear_damp_space_override;
+}
+
+void Area3D::set_angular_damp_space_override_mode(SpaceOverride p_mode) {
+	angular_damp_space_override = p_mode;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_ANGULAR_DAMP_OVERRIDE_MODE, p_mode);
+}
+
+Area3D::SpaceOverride Area3D::get_angular_damp_space_override_mode() const {
+	return angular_damp_space_override;
+}
+
+void Area3D::set_linear_damp(real_t p_linear_damp) {
+	linear_damp = p_linear_damp;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_LINEAR_DAMP, p_linear_damp);
+}
+
+real_t Area3D::get_linear_damp() const {
+	return linear_damp;
+}
+
+void Area3D::set_angular_damp(real_t p_angular_damp) {
+	angular_damp = p_angular_damp;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_ANGULAR_DAMP, p_angular_damp);
+}
+
+real_t Area3D::get_angular_damp() const {
+	return angular_damp;
+}
+
+void Area3D::set_priority(int p_priority) {
+	priority = p_priority;
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_PRIORITY, p_priority);
+}
+
+int Area3D::get_priority() const {
+	return priority;
+}
+
+void Area3D::set_wind_force_magnitude(real_t p_wind_force_magnitude) {
+	wind_force_magnitude = p_wind_force_magnitude;
+	if (is_inside_tree()) {
+		_initialize_wind();
+	}
+}
+
+real_t Area3D::get_wind_force_magnitude() const {
+	return wind_force_magnitude;
+}
+
+void Area3D::set_wind_attenuation_factor(real_t p_wind_force_attenuation_factor) {
+	wind_attenuation_factor = p_wind_force_attenuation_factor;
+	if (is_inside_tree()) {
+		_initialize_wind();
+	}
+}
+
+real_t Area3D::get_wind_attenuation_factor() const {
+	return wind_attenuation_factor;
+}
+
+void Area3D::set_wind_source_path(const NodePath &p_wind_source_path) {
+	wind_source_path = p_wind_source_path;
+	if (is_inside_tree()) {
+		_initialize_wind();
+	}
+}
+
+const NodePath &Area3D::get_wind_source_path() const {
+	return wind_source_path;
+}
+
+void Area3D::_initialize_wind() {
+	real_t temp_magnitude = 0.0;
+	Vector3 wind_direction(0., 0., 0.);
+	Vector3 wind_source(0., 0., 0.);
+
+	// Overwrite with area-specified info if available
+	if (!wind_source_path.is_empty()) {
+		Node *wind_source_node = get_node_or_null(wind_source_path);
+		ERR_FAIL_NULL_MSG(wind_source_node, "Path to wind source is invalid: '" + wind_source_path + "'.");
+		Node3D *wind_source_node3d = Object::cast_to<Node3D>(wind_source_node);
+		ERR_FAIL_NULL_MSG(wind_source_node3d, "Path to wind source does not point to a Node3D: '" + wind_source_path + "'.");
+		Transform3D global_transform = wind_source_node3d->get_transform();
+		wind_direction = -global_transform.basis.get_column(Vector3::AXIS_Z).normalized();
+		wind_source = global_transform.origin;
+		temp_magnitude = wind_force_magnitude;
+	}
+
+	// Set force, source and direction in the physics server.
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_WIND_ATTENUATION_FACTOR, wind_attenuation_factor);
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_WIND_SOURCE, wind_source);
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_WIND_DIRECTION, wind_direction);
+	PhysicsServer3D::get_singleton()->area_set_param(get_rid(), PhysicsServer3D::AREA_PARAM_WIND_FORCE_MAGNITUDE, temp_magnitude);
+}
+
+void Area3D::_body_enter_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(E->value.in_tree);
+
+	E->value.in_tree = true;
+	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
+	}
+}
+
+void Area3D::_body_exit_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
+	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
+	}
+}
+
+void Area3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_area_shape) {
+	bool body_in = p_status == PhysicsServer3D::AREA_BODY_ADDED;
+	ObjectID objid = p_instance;
+
+	// Exit early if instance is invalid.
+	if (objid.is_null()) {
+		lock_callback();
+		locked = true;
+		// Emit the appropriate signals.
+		if (body_in) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, (Node *)nullptr, p_body_shape, p_area_shape);
+		} else {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, (Node *)nullptr, p_body_shape, p_area_shape);
+		}
+		locked = false;
+		unlock_callback();
+		return;
+	}
+
+	Object *obj = ObjectDB::get_instance(objid);
+	Node *node = Object::cast_to<Node>(obj);
+
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(objid);
+
+	if (!body_in && !E) {
+		return; //likely removed from the tree
+	}
+
+	lock_callback();
+	locked = true;
+
+	if (body_in) {
+		if (!E) {
+			E = body_map.insert(objid, BodyState());
+			E->value.rid = p_body;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
+			if (node) {
+				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_body_enter_tree).bind(objid));
+				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_body_exit_tree).bind(objid));
+				if (E->value.in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
+				}
+			}
+		}
+		E->value.rc++;
+		if (node) {
+			E->value.shapes.insert(ShapePair(p_body_shape, p_area_shape));
+		}
+
+		if (!node || E->value.in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_area_shape);
+		}
+
+	} else {
+		E->value.rc--;
+
+		if (node) {
+			E->value.shapes.erase(ShapePair(p_body_shape, p_area_shape));
+		}
+
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			body_map.remove(E);
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_body_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_body_exit_tree));
+				if (in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->body_exited, obj);
+				}
+			}
+		}
+		if (!node || in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, obj, p_body_shape, p_area_shape);
+		}
+	}
+
+	locked = false;
+	unlock_callback();
+}
+
+void Area3D::_clear_monitoring() {
+	ERR_FAIL_COND_MSG(locked, "This function can't be used during the in/out signal.");
+
+	{
+		HashMap<ObjectID, BodyState> bmcopy = body_map;
+		body_map.clear();
+		//disconnect all monitored stuff
+
+		for (const KeyValue<ObjectID, BodyState> &E : bmcopy) {
+			Object *obj = ObjectDB::get_instance(E.key);
+			Node *node = Object::cast_to<Node>(obj);
+
+			if (!node) { //node may have been deleted in previous frame or at other legitimate point
+				continue;
+			}
+			//ERR_CONTINUE(!node);
+
+			node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_body_enter_tree));
+			node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_body_exit_tree));
+
+			if (!E.value.in_tree) {
+				continue;
+			}
+
+			for (int i = 0; i < E.value.shapes.size(); i++) {
+				emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E.value.rid, node, E.value.shapes[i].body_shape, E.value.shapes[i].area_shape);
+			}
+
+			emit_signal(SceneStringNames::get_singleton()->body_exited, node);
+		}
+	}
+
+	{
+		HashMap<ObjectID, AreaState> bmcopy = area_map;
+		area_map.clear();
+		//disconnect all monitored stuff
+
+		for (const KeyValue<ObjectID, AreaState> &E : bmcopy) {
+			Object *obj = ObjectDB::get_instance(E.key);
+			Node *node = Object::cast_to<Node>(obj);
+
+			if (!node) { //node may have been deleted in previous frame or at other legitimate point
+				continue;
+			}
+			//ERR_CONTINUE(!node);
+
+			node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_area_enter_tree));
+			node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_area_exit_tree));
+
+			if (!E.value.in_tree) {
+				continue;
+			}
+
+			for (int i = 0; i < E.value.shapes.size(); i++) {
+				emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E.value.rid, node, E.value.shapes[i].area_shape, E.value.shapes[i].self_shape);
+			}
+
+			emit_signal(SceneStringNames::get_singleton()->area_exited, obj);
+		}
+	}
+}
+
+void Area3D::_space_changed(const RID &p_new_space) {
+	if (p_new_space.is_null()) {
+		_clear_monitoring();
+	}
+}
+
+void Area3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			_initialize_wind();
+		} break;
+	}
+}
+
+void Area3D::set_monitoring(bool p_enable) {
+	ERR_FAIL_COND_MSG(locked, "Function blocked during in/out signal. Use set_deferred(\"monitoring\", true/false).");
+
+	if (p_enable == monitoring) {
+		return;
+	}
+
+	monitoring = p_enable;
+
+	if (monitoring) {
+		PhysicsServer3D::get_singleton()->area_set_monitor_callback(get_rid(), callable_mp(this, &Area3D::_body_inout));
+		PhysicsServer3D::get_singleton()->area_set_area_monitor_callback(get_rid(), callable_mp(this, &Area3D::_area_inout));
+	} else {
+		PhysicsServer3D::get_singleton()->area_set_monitor_callback(get_rid(), Callable());
+		PhysicsServer3D::get_singleton()->area_set_area_monitor_callback(get_rid(), Callable());
+		_clear_monitoring();
+	}
+}
+
+void Area3D::_area_enter_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(E->value.in_tree);
+
+	E->value.in_tree = true;
+	emit_signal(SceneStringNames::get_singleton()->area_entered, node);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_entered, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
+	}
+}
+
+void Area3D::_area_exit_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
+	emit_signal(SceneStringNames::get_singleton()->area_exited, node);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
+	}
+}
+
+void Area3D::_area_inout(int p_status, const RID &p_area, ObjectID p_instance, int p_area_shape, int p_self_shape) {
+	bool area_in = p_status == PhysicsServer3D::AREA_BODY_ADDED;
+	ObjectID objid = p_instance;
+
+	// Exit if instance is invalid.
+	if (objid.is_null()) {
+		lock_callback();
+		locked = true;
+		// Emit the appropriate signals.
+		if (area_in) {
+			emit_signal(SceneStringNames::get_singleton()->area_shape_entered, p_area, (Node *)nullptr, p_area_shape, p_self_shape);
+		} else {
+			emit_signal(SceneStringNames::get_singleton()->area_shape_exited, p_area, (Node *)nullptr, p_area_shape, p_self_shape);
+		}
+		locked = false;
+		unlock_callback();
+		return;
+	}
+
+	Object *obj = ObjectDB::get_instance(objid);
+	Node *node = Object::cast_to<Node>(obj);
+
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(objid);
+
+	if (!area_in && !E) {
+		return; //likely removed from the tree
+	}
+
+	lock_callback();
+	locked = true;
+
+	if (area_in) {
+		if (!E) {
+			E = area_map.insert(objid, AreaState());
+			E->value.rid = p_area;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
+			if (node) {
+				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_area_enter_tree).bind(objid));
+				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_area_exit_tree).bind(objid));
+				if (E->value.in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->area_entered, node);
+				}
+			}
+		}
+		E->value.rc++;
+		if (node) {
+			E->value.shapes.insert(AreaShapePair(p_area_shape, p_self_shape));
+		}
+
+		if (!node || E->value.in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->area_shape_entered, p_area, node, p_area_shape, p_self_shape);
+		}
+
+	} else {
+		E->value.rc--;
+
+		if (node) {
+			E->value.shapes.erase(AreaShapePair(p_area_shape, p_self_shape));
+		}
+
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			area_map.remove(E);
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_area_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_area_exit_tree));
+				if (in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->area_exited, obj);
+				}
+			}
+		}
+		if (!node || in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->area_shape_exited, p_area, obj, p_area_shape, p_self_shape);
+		}
+	}
+
+	locked = false;
+	unlock_callback();
+}
+
+bool Area3D::is_monitoring() const {
+	return monitoring;
+}
+
+TypedArray<Node3D> Area3D::get_overlapping_bodies() const {
+	TypedArray<Node3D> ret;
+	ERR_FAIL_COND_V_MSG(!monitoring, ret, "Can't find overlapping bodies when monitoring is off.");
+	ret.resize(body_map.size());
+	int idx = 0;
+	for (const KeyValue<ObjectID, BodyState> &E : body_map) {
+		Object *obj = ObjectDB::get_instance(E.key);
+		if (obj) {
+			ret[idx] = obj;
+			idx++;
+		}
+	}
+
+	ret.resize(idx);
+	return ret;
+}
+
+bool Area3D::has_overlapping_bodies() const {
+	ERR_FAIL_COND_V_MSG(!monitoring, false, "Can't find overlapping bodies when monitoring is off.");
+	return !body_map.is_empty();
+}
+
+void Area3D::set_monitorable(bool p_enable) {
+	ERR_FAIL_COND_MSG(locked || (is_inside_tree() && PhysicsServer3D::get_singleton()->is_flushing_queries()), "Function blocked during in/out signal. Use set_deferred(\"monitorable\", true/false).");
+
+	if (p_enable == monitorable) {
+		return;
+	}
+
+	monitorable = p_enable;
+
+	PhysicsServer3D::get_singleton()->area_set_monitorable(get_rid(), monitorable);
+}
+
+bool Area3D::is_monitorable() const {
+	return monitorable;
+}
+
+TypedArray<Area3D> Area3D::get_overlapping_areas() const {
+	TypedArray<Area3D> ret;
+	ERR_FAIL_COND_V_MSG(!monitoring, ret, "Can't find overlapping areas when monitoring is off.");
+	ret.resize(area_map.size());
+	int idx = 0;
+	for (const KeyValue<ObjectID, AreaState> &E : area_map) {
+		Object *obj = ObjectDB::get_instance(E.key);
+		if (obj) {
+			ret[idx] = obj;
+			idx++;
+		}
+	}
+	ret.resize(idx);
+	return ret;
+}
+
+bool Area3D::has_overlapping_areas() const {
+	ERR_FAIL_COND_V_MSG(!monitoring, false, "Can't find overlapping areas when monitoring is off.");
+	return !area_map.is_empty();
+}
+
+bool Area3D::overlaps_area(Node *p_area) const {
+	ERR_FAIL_NULL_V(p_area, false);
+	HashMap<ObjectID, AreaState>::ConstIterator E = area_map.find(p_area->get_instance_id());
+	if (!E) {
+		return false;
+	}
+	return E->value.in_tree;
+}
+
+bool Area3D::overlaps_body(Node *p_body) const {
+	ERR_FAIL_NULL_V(p_body, false);
+	HashMap<ObjectID, BodyState>::ConstIterator E = body_map.find(p_body->get_instance_id());
+	if (!E) {
+		return false;
+	}
+	return E->value.in_tree;
+}
+
+void Area3D::set_audio_bus_override(bool p_override) {
+	audio_bus_override = p_override;
+}
+
+bool Area3D::is_overriding_audio_bus() const {
+	return audio_bus_override;
+}
+
+void Area3D::set_audio_bus_name(const StringName &p_audio_bus) {
+	audio_bus = p_audio_bus;
+}
+
+StringName Area3D::get_audio_bus_name() const {
+	for (int i = 0; i < AudioServer::get_singleton()->get_bus_count(); i++) {
+		if (AudioServer::get_singleton()->get_bus_name(i) == audio_bus) {
+			return audio_bus;
+		}
+	}
+	return SceneStringNames::get_singleton()->Master;
+}
+
+void Area3D::set_use_reverb_bus(bool p_enable) {
+	use_reverb_bus = p_enable;
+}
+
+bool Area3D::is_using_reverb_bus() const {
+	return use_reverb_bus;
+}
+
+void Area3D::set_reverb_bus_name(const StringName &p_audio_bus) {
+	reverb_bus = p_audio_bus;
+}
+
+StringName Area3D::get_reverb_bus_name() const {
+	for (int i = 0; i < AudioServer::get_singleton()->get_bus_count(); i++) {
+		if (AudioServer::get_singleton()->get_bus_name(i) == reverb_bus) {
+			return reverb_bus;
+		}
+	}
+	return SceneStringNames::get_singleton()->Master;
+}
+
+void Area3D::set_reverb_amount(float p_amount) {
+	reverb_amount = p_amount;
+}
+
+float Area3D::get_reverb_amount() const {
+	return reverb_amount;
+}
+
+void Area3D::set_reverb_uniformity(float p_uniformity) {
+	reverb_uniformity = p_uniformity;
+}
+
+float Area3D::get_reverb_uniformity() const {
+	return reverb_uniformity;
+}
+
+void Area3D::_validate_property(PropertyInfo &p_property) const {
+	if (p_property.name == "audio_bus_name" || p_property.name == "reverb_bus_name") {
+		String options;
+		for (int i = 0; i < AudioServer::get_singleton()->get_bus_count(); i++) {
+			if (i > 0) {
+				options += ",";
+			}
+			String name = AudioServer::get_singleton()->get_bus_name(i);
+			options += name;
+		}
+
+		p_property.hint_string = options;
+	} else if (p_property.name.begins_with("gravity") && p_property.name != "gravity_space_override") {
+		if (gravity_space_override == SPACE_OVERRIDE_DISABLED) {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		} else {
+			if (gravity_is_point) {
+				if (p_property.name == "gravity_direction") {
+					p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+				}
+			} else {
+				if (p_property.name.begins_with("gravity_point_")) {
+					p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+				}
+			}
+		}
+	} else if (p_property.name.begins_with("linear_damp") && p_property.name != "linear_damp_space_override") {
+		if (linear_damp_space_override == SPACE_OVERRIDE_DISABLED) {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	} else if (p_property.name.begins_with("angular_damp") && p_property.name != "angular_damp_space_override") {
+		if (angular_damp_space_override == SPACE_OVERRIDE_DISABLED) {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	}
+}
+
+void Area3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_gravity_space_override_mode", "space_override_mode"), &Area3D::set_gravity_space_override_mode);
+	ClassDB::bind_method(D_METHOD("get_gravity_space_override_mode"), &Area3D::get_gravity_space_override_mode);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_is_point", "enable"), &Area3D::set_gravity_is_point);
+	ClassDB::bind_method(D_METHOD("is_gravity_a_point"), &Area3D::is_gravity_a_point);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_point_unit_distance", "distance_scale"), &Area3D::set_gravity_point_unit_distance);
+	ClassDB::bind_method(D_METHOD("get_gravity_point_unit_distance"), &Area3D::get_gravity_point_unit_distance);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_point_center", "center"), &Area3D::set_gravity_point_center);
+	ClassDB::bind_method(D_METHOD("get_gravity_point_center"), &Area3D::get_gravity_point_center);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_direction", "direction"), &Area3D::set_gravity_direction);
+	ClassDB::bind_method(D_METHOD("get_gravity_direction"), &Area3D::get_gravity_direction);
+
+	ClassDB::bind_method(D_METHOD("set_gravity", "gravity"), &Area3D::set_gravity);
+	ClassDB::bind_method(D_METHOD("get_gravity"), &Area3D::get_gravity);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp_space_override_mode", "space_override_mode"), &Area3D::set_linear_damp_space_override_mode);
+	ClassDB::bind_method(D_METHOD("get_linear_damp_space_override_mode"), &Area3D::get_linear_damp_space_override_mode);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp_space_override_mode", "space_override_mode"), &Area3D::set_angular_damp_space_override_mode);
+	ClassDB::bind_method(D_METHOD("get_angular_damp_space_override_mode"), &Area3D::get_angular_damp_space_override_mode);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &Area3D::set_angular_damp);
+	ClassDB::bind_method(D_METHOD("get_angular_damp"), &Area3D::get_angular_damp);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &Area3D::set_linear_damp);
+	ClassDB::bind_method(D_METHOD("get_linear_damp"), &Area3D::get_linear_damp);
+
+	ClassDB::bind_method(D_METHOD("set_priority", "priority"), &Area3D::set_priority);
+	ClassDB::bind_method(D_METHOD("get_priority"), &Area3D::get_priority);
+
+	ClassDB::bind_method(D_METHOD("set_wind_force_magnitude", "wind_force_magnitude"), &Area3D::set_wind_force_magnitude);
+	ClassDB::bind_method(D_METHOD("get_wind_force_magnitude"), &Area3D::get_wind_force_magnitude);
+
+	ClassDB::bind_method(D_METHOD("set_wind_attenuation_factor", "wind_attenuation_factor"), &Area3D::set_wind_attenuation_factor);
+	ClassDB::bind_method(D_METHOD("get_wind_attenuation_factor"), &Area3D::get_wind_attenuation_factor);
+
+	ClassDB::bind_method(D_METHOD("set_wind_source_path", "wind_source_path"), &Area3D::set_wind_source_path);
+	ClassDB::bind_method(D_METHOD("get_wind_source_path"), &Area3D::get_wind_source_path);
+
+	ClassDB::bind_method(D_METHOD("set_monitorable", "enable"), &Area3D::set_monitorable);
+	ClassDB::bind_method(D_METHOD("is_monitorable"), &Area3D::is_monitorable);
+
+	ClassDB::bind_method(D_METHOD("set_monitoring", "enable"), &Area3D::set_monitoring);
+	ClassDB::bind_method(D_METHOD("is_monitoring"), &Area3D::is_monitoring);
+
+	ClassDB::bind_method(D_METHOD("get_overlapping_bodies"), &Area3D::get_overlapping_bodies);
+	ClassDB::bind_method(D_METHOD("get_overlapping_areas"), &Area3D::get_overlapping_areas);
+
+	ClassDB::bind_method(D_METHOD("has_overlapping_bodies"), &Area3D::has_overlapping_bodies);
+	ClassDB::bind_method(D_METHOD("has_overlapping_areas"), &Area3D::has_overlapping_areas);
+
+	ClassDB::bind_method(D_METHOD("overlaps_body", "body"), &Area3D::overlaps_body);
+	ClassDB::bind_method(D_METHOD("overlaps_area", "area"), &Area3D::overlaps_area);
+
+	ClassDB::bind_method(D_METHOD("set_audio_bus_override", "enable"), &Area3D::set_audio_bus_override);
+	ClassDB::bind_method(D_METHOD("is_overriding_audio_bus"), &Area3D::is_overriding_audio_bus);
+
+	ClassDB::bind_method(D_METHOD("set_audio_bus_name", "name"), &Area3D::set_audio_bus_name);
+	ClassDB::bind_method(D_METHOD("get_audio_bus_name"), &Area3D::get_audio_bus_name);
+
+	ClassDB::bind_method(D_METHOD("set_use_reverb_bus", "enable"), &Area3D::set_use_reverb_bus);
+	ClassDB::bind_method(D_METHOD("is_using_reverb_bus"), &Area3D::is_using_reverb_bus);
+
+	ClassDB::bind_method(D_METHOD("set_reverb_bus_name", "name"), &Area3D::set_reverb_bus_name);
+	ClassDB::bind_method(D_METHOD("get_reverb_bus_name"), &Area3D::get_reverb_bus_name);
+
+	ClassDB::bind_method(D_METHOD("set_reverb_amount", "amount"), &Area3D::set_reverb_amount);
+	ClassDB::bind_method(D_METHOD("get_reverb_amount"), &Area3D::get_reverb_amount);
+
+	ClassDB::bind_method(D_METHOD("set_reverb_uniformity", "amount"), &Area3D::set_reverb_uniformity);
+	ClassDB::bind_method(D_METHOD("get_reverb_uniformity"), &Area3D::get_reverb_uniformity);
+
+	ADD_SIGNAL(MethodInfo("body_shape_entered", PropertyInfo(Variant::RID, "body_rid"), PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node3D"), PropertyInfo(Variant::INT, "body_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("body_shape_exited", PropertyInfo(Variant::RID, "body_rid"), PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node3D"), PropertyInfo(Variant::INT, "body_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("body_entered", PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node3D")));
+	ADD_SIGNAL(MethodInfo("body_exited", PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node3D")));
+
+	ADD_SIGNAL(MethodInfo("area_shape_entered", PropertyInfo(Variant::RID, "area_rid"), PropertyInfo(Variant::OBJECT, "area", PROPERTY_HINT_RESOURCE_TYPE, "Area3D"), PropertyInfo(Variant::INT, "area_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("area_shape_exited", PropertyInfo(Variant::RID, "area_rid"), PropertyInfo(Variant::OBJECT, "area", PROPERTY_HINT_RESOURCE_TYPE, "Area3D"), PropertyInfo(Variant::INT, "area_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("area_entered", PropertyInfo(Variant::OBJECT, "area", PROPERTY_HINT_RESOURCE_TYPE, "Area3D")));
+	ADD_SIGNAL(MethodInfo("area_exited", PropertyInfo(Variant::OBJECT, "area", PROPERTY_HINT_RESOURCE_TYPE, "Area3D")));
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "monitoring"), "set_monitoring", "is_monitoring");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "monitorable"), "set_monitorable", "is_monitorable");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "priority", PROPERTY_HINT_RANGE, "0,100000,1,or_greater,or_less"), "set_priority", "get_priority");
+
+	ADD_GROUP("Gravity", "gravity_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "gravity_space_override", PROPERTY_HINT_ENUM, "Disabled,Combine,Combine-Replace,Replace,Replace-Combine", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_gravity_space_override_mode", "get_gravity_space_override_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gravity_point", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_gravity_is_point", "is_gravity_a_point");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "gravity_point_unit_distance", PROPERTY_HINT_RANGE, "0,1024,0.001,or_greater,exp,suffix:m"), "set_gravity_point_unit_distance", "get_gravity_point_unit_distance");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity_point_center", PROPERTY_HINT_NONE, "suffix:m"), "set_gravity_point_center", "get_gravity_point_center");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity_direction"), "set_gravity_direction", "get_gravity_direction");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "gravity", PROPERTY_HINT_RANGE, U"-32,32,0.001,or_less,or_greater,suffix:m/s\u00B2"), "set_gravity", "get_gravity");
+
+	ADD_GROUP("Linear Damp", "linear_damp_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "linear_damp_space_override", PROPERTY_HINT_ENUM, "Disabled,Combine,Combine-Replace,Replace,Replace-Combine", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_linear_damp_space_override_mode", "get_linear_damp_space_override_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "linear_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_linear_damp", "get_linear_damp");
+
+	ADD_GROUP("Angular Damp", "angular_damp_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "angular_damp_space_override", PROPERTY_HINT_ENUM, "Disabled,Combine,Combine-Replace,Replace,Replace-Combine", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_angular_damp_space_override_mode", "get_angular_damp_space_override_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_angular_damp", "get_angular_damp");
+
+	ADD_GROUP("Wind", "wind_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wind_force_magnitude", PROPERTY_HINT_RANGE, "0,10,0.001,or_greater"), "set_wind_force_magnitude", "get_wind_force_magnitude");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wind_attenuation_factor", PROPERTY_HINT_RANGE, "0.0,3.0,0.001,or_greater"), "set_wind_attenuation_factor", "get_wind_attenuation_factor");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "wind_source_path", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_wind_source_path", "get_wind_source_path");
+
+	ADD_GROUP("Audio Bus", "audio_bus_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "audio_bus_override"), "set_audio_bus_override", "is_overriding_audio_bus");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "audio_bus_name", PROPERTY_HINT_ENUM, ""), "set_audio_bus_name", "get_audio_bus_name");
+
+	ADD_GROUP("Reverb Bus", "reverb_bus_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "reverb_bus_enabled"), "set_use_reverb_bus", "is_using_reverb_bus");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "reverb_bus_name", PROPERTY_HINT_ENUM, ""), "set_reverb_bus_name", "get_reverb_bus_name");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "reverb_bus_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_reverb_amount", "get_reverb_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "reverb_bus_uniformity", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_reverb_uniformity", "get_reverb_uniformity");
+
+	BIND_ENUM_CONSTANT(SPACE_OVERRIDE_DISABLED);
+	BIND_ENUM_CONSTANT(SPACE_OVERRIDE_COMBINE);
+	BIND_ENUM_CONSTANT(SPACE_OVERRIDE_COMBINE_REPLACE);
+	BIND_ENUM_CONSTANT(SPACE_OVERRIDE_REPLACE);
+	BIND_ENUM_CONSTANT(SPACE_OVERRIDE_REPLACE_COMBINE);
+}
+
+Area3D::Area3D() :
+		CollisionObject3D(PhysicsServer3D::get_singleton()->area_create(), true) {
+	set_gravity(9.8);
+	set_gravity_direction(Vector3(0, -1, 0));
+	set_monitoring(true);
+	set_monitorable(true);
+}
+
+Area3D::~Area3D() {
+}
diff --git a/scene/3d/physics/area_3d.h b/scene/3d/physics/area_3d.h
new file mode 100644
index 0000000000..41382b6128
--- /dev/null
+++ b/scene/3d/physics/area_3d.h
@@ -0,0 +1,236 @@
+/**************************************************************************/
+/*  area_3d.h                                                             */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef AREA_3D_H
+#define AREA_3D_H
+
+#include "core/templates/vset.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/scene_string_names.h"
+
+class Area3D : public CollisionObject3D {
+	GDCLASS(Area3D, CollisionObject3D);
+
+public:
+	enum SpaceOverride {
+		SPACE_OVERRIDE_DISABLED,
+		SPACE_OVERRIDE_COMBINE,
+		SPACE_OVERRIDE_COMBINE_REPLACE,
+		SPACE_OVERRIDE_REPLACE,
+		SPACE_OVERRIDE_REPLACE_COMBINE
+	};
+
+private:
+	SpaceOverride gravity_space_override = SPACE_OVERRIDE_DISABLED;
+	Vector3 gravity_vec;
+	real_t gravity = 0.0;
+	bool gravity_is_point = false;
+	real_t gravity_point_unit_distance = 0.0;
+
+	SpaceOverride linear_damp_space_override = SPACE_OVERRIDE_DISABLED;
+	SpaceOverride angular_damp_space_override = SPACE_OVERRIDE_DISABLED;
+	real_t angular_damp = 0.1;
+	real_t linear_damp = 0.1;
+
+	int priority = 0;
+
+	real_t wind_force_magnitude = 0.0;
+	real_t wind_attenuation_factor = 0.0;
+	NodePath wind_source_path;
+
+	bool monitoring = false;
+	bool monitorable = false;
+	bool locked = false;
+
+	void _body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_area_shape);
+
+	void _body_enter_tree(ObjectID p_id);
+	void _body_exit_tree(ObjectID p_id);
+
+	struct ShapePair {
+		int body_shape = 0;
+		int area_shape = 0;
+		bool operator<(const ShapePair &p_sp) const {
+			if (body_shape == p_sp.body_shape) {
+				return area_shape < p_sp.area_shape;
+			} else {
+				return body_shape < p_sp.body_shape;
+			}
+		}
+
+		ShapePair() {}
+		ShapePair(int p_bs, int p_as) {
+			body_shape = p_bs;
+			area_shape = p_as;
+		}
+	};
+
+	struct BodyState {
+		RID rid;
+		int rc = 0;
+		bool in_tree = false;
+		VSet<ShapePair> shapes;
+	};
+
+	HashMap<ObjectID, BodyState> body_map;
+
+	void _area_inout(int p_status, const RID &p_area, ObjectID p_instance, int p_area_shape, int p_self_shape);
+
+	void _area_enter_tree(ObjectID p_id);
+	void _area_exit_tree(ObjectID p_id);
+
+	struct AreaShapePair {
+		int area_shape = 0;
+		int self_shape = 0;
+		bool operator<(const AreaShapePair &p_sp) const {
+			if (area_shape == p_sp.area_shape) {
+				return self_shape < p_sp.self_shape;
+			} else {
+				return area_shape < p_sp.area_shape;
+			}
+		}
+
+		AreaShapePair() {}
+		AreaShapePair(int p_bs, int p_as) {
+			area_shape = p_bs;
+			self_shape = p_as;
+		}
+	};
+
+	struct AreaState {
+		RID rid;
+		int rc = 0;
+		bool in_tree = false;
+		VSet<AreaShapePair> shapes;
+	};
+
+	HashMap<ObjectID, AreaState> area_map;
+	void _clear_monitoring();
+
+	bool audio_bus_override = false;
+	StringName audio_bus = SceneStringNames::get_singleton()->Master;
+
+	bool use_reverb_bus = false;
+	StringName reverb_bus = SceneStringNames::get_singleton()->Master;
+	float reverb_amount = 0.0;
+	float reverb_uniformity = 0.0;
+
+	void _initialize_wind();
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+	void _validate_property(PropertyInfo &p_property) const;
+
+	virtual void _space_changed(const RID &p_new_space) override;
+
+public:
+	void set_gravity_space_override_mode(SpaceOverride p_mode);
+	SpaceOverride get_gravity_space_override_mode() const;
+
+	void set_gravity_is_point(bool p_enabled);
+	bool is_gravity_a_point() const;
+
+	void set_gravity_point_unit_distance(real_t p_scale);
+	real_t get_gravity_point_unit_distance() const;
+
+	void set_gravity_point_center(const Vector3 &p_center);
+	const Vector3 &get_gravity_point_center() const;
+
+	void set_gravity_direction(const Vector3 &p_direction);
+	const Vector3 &get_gravity_direction() const;
+
+	void set_gravity(real_t p_gravity);
+	real_t get_gravity() const;
+
+	void set_linear_damp_space_override_mode(SpaceOverride p_mode);
+	SpaceOverride get_linear_damp_space_override_mode() const;
+
+	void set_angular_damp_space_override_mode(SpaceOverride p_mode);
+	SpaceOverride get_angular_damp_space_override_mode() const;
+
+	void set_angular_damp(real_t p_angular_damp);
+	real_t get_angular_damp() const;
+
+	void set_linear_damp(real_t p_linear_damp);
+	real_t get_linear_damp() const;
+
+	void set_priority(int p_priority);
+	int get_priority() const;
+
+	void set_wind_force_magnitude(real_t p_wind_force_magnitude);
+	real_t get_wind_force_magnitude() const;
+
+	void set_wind_attenuation_factor(real_t p_wind_attenuation_factor);
+	real_t get_wind_attenuation_factor() const;
+
+	void set_wind_source_path(const NodePath &p_wind_source_path);
+	const NodePath &get_wind_source_path() const;
+
+	void set_monitoring(bool p_enable);
+	bool is_monitoring() const;
+
+	void set_monitorable(bool p_enable);
+	bool is_monitorable() const;
+
+	TypedArray<Node3D> get_overlapping_bodies() const;
+	TypedArray<Area3D> get_overlapping_areas() const; //function for script
+
+	bool has_overlapping_bodies() const;
+	bool has_overlapping_areas() const;
+
+	bool overlaps_area(Node *p_area) const;
+	bool overlaps_body(Node *p_body) const;
+
+	void set_audio_bus_override(bool p_override);
+	bool is_overriding_audio_bus() const;
+
+	void set_audio_bus_name(const StringName &p_audio_bus);
+	StringName get_audio_bus_name() const;
+
+	void set_use_reverb_bus(bool p_enable);
+	bool is_using_reverb_bus() const;
+
+	void set_reverb_bus_name(const StringName &p_audio_bus);
+	StringName get_reverb_bus_name() const;
+
+	void set_reverb_amount(float p_amount);
+	float get_reverb_amount() const;
+
+	void set_reverb_uniformity(float p_uniformity);
+	float get_reverb_uniformity() const;
+
+	Area3D();
+	~Area3D();
+};
+
+VARIANT_ENUM_CAST(Area3D::SpaceOverride);
+
+#endif // AREA_3D_H
diff --git a/scene/3d/physics/character_body_3d.cpp b/scene/3d/physics/character_body_3d.cpp
new file mode 100644
index 0000000000..b71b9519a9
--- /dev/null
+++ b/scene/3d/physics/character_body_3d.cpp
@@ -0,0 +1,939 @@
+/**************************************************************************/
+/*  character_body_3d.cpp                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "character_body_3d.h"
+
+//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
+#define FLOOR_ANGLE_THRESHOLD 0.01
+
+bool CharacterBody3D::move_and_slide() {
+	// Hack in order to work with calling from _process as well as from _physics_process; calling from thread is risky
+	double delta = Engine::get_singleton()->is_in_physics_frame() ? get_physics_process_delta_time() : get_process_delta_time();
+
+	for (int i = 0; i < 3; i++) {
+		if (locked_axis & (1 << i)) {
+			velocity[i] = 0.0;
+		}
+	}
+
+	Transform3D gt = get_global_transform();
+	previous_position = gt.origin;
+
+	Vector3 current_platform_velocity = platform_velocity;
+
+	if ((collision_state.floor || collision_state.wall) && platform_rid.is_valid()) {
+		bool excluded = false;
+		if (collision_state.floor) {
+			excluded = (platform_floor_layers & platform_layer) == 0;
+		} else if (collision_state.wall) {
+			excluded = (platform_wall_layers & platform_layer) == 0;
+		}
+		if (!excluded) {
+			//this approach makes sure there is less delay between the actual body velocity and the one we saved
+			PhysicsDirectBodyState3D *bs = PhysicsServer3D::get_singleton()->body_get_direct_state(platform_rid);
+			if (bs) {
+				Vector3 local_position = gt.origin - bs->get_transform().origin;
+				current_platform_velocity = bs->get_velocity_at_local_position(local_position);
+			} else {
+				// Body is removed or destroyed, invalidate floor.
+				current_platform_velocity = Vector3();
+				platform_rid = RID();
+			}
+		} else {
+			current_platform_velocity = Vector3();
+		}
+	}
+
+	motion_results.clear();
+
+	bool was_on_floor = collision_state.floor;
+	collision_state.state = 0;
+
+	last_motion = Vector3();
+
+	if (!current_platform_velocity.is_zero_approx()) {
+		PhysicsServer3D::MotionParameters parameters(get_global_transform(), current_platform_velocity * delta, margin);
+		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+
+		parameters.exclude_bodies.insert(platform_rid);
+		if (platform_object_id.is_valid()) {
+			parameters.exclude_objects.insert(platform_object_id);
+		}
+
+		PhysicsServer3D::MotionResult floor_result;
+		if (move_and_collide(parameters, floor_result, false, false)) {
+			motion_results.push_back(floor_result);
+
+			CollisionState result_state;
+			_set_collision_direction(floor_result, result_state);
+		}
+	}
+
+	if (motion_mode == MOTION_MODE_GROUNDED) {
+		_move_and_slide_grounded(delta, was_on_floor);
+	} else {
+		_move_and_slide_floating(delta);
+	}
+
+	// Compute real velocity.
+	real_velocity = get_position_delta() / delta;
+
+	if (platform_on_leave != PLATFORM_ON_LEAVE_DO_NOTHING) {
+		// Add last platform velocity when just left a moving platform.
+		if (!collision_state.floor && !collision_state.wall) {
+			if (platform_on_leave == PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY && current_platform_velocity.dot(up_direction) < 0) {
+				current_platform_velocity = current_platform_velocity.slide(up_direction);
+			}
+			velocity += current_platform_velocity;
+		}
+	}
+
+	return motion_results.size() > 0;
+}
+
+void CharacterBody3D::_move_and_slide_grounded(double p_delta, bool p_was_on_floor) {
+	Vector3 motion = velocity * p_delta;
+	Vector3 motion_slide_up = motion.slide(up_direction);
+	Vector3 prev_floor_normal = floor_normal;
+
+	platform_rid = RID();
+	platform_object_id = ObjectID();
+	platform_velocity = Vector3();
+	platform_angular_velocity = Vector3();
+	platform_ceiling_velocity = Vector3();
+	floor_normal = Vector3();
+	wall_normal = Vector3();
+	ceiling_normal = Vector3();
+
+	// No sliding on first attempt to keep floor motion stable when possible,
+	// When stop on slope is enabled or when there is no up direction.
+	bool sliding_enabled = !floor_stop_on_slope;
+	// Constant speed can be applied only the first time sliding is enabled.
+	bool can_apply_constant_speed = sliding_enabled;
+	// If the platform's ceiling push down the body.
+	bool apply_ceiling_velocity = false;
+	bool first_slide = true;
+	bool vel_dir_facing_up = velocity.dot(up_direction) > 0;
+	Vector3 total_travel;
+
+	for (int iteration = 0; iteration < max_slides; ++iteration) {
+		PhysicsServer3D::MotionParameters parameters(get_global_transform(), motion, margin);
+		parameters.max_collisions = 6; // There can be 4 collisions between 2 walls + 2 more for the floor.
+		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+
+		PhysicsServer3D::MotionResult result;
+		bool collided = move_and_collide(parameters, result, false, !sliding_enabled);
+
+		last_motion = result.travel;
+
+		if (collided) {
+			motion_results.push_back(result);
+
+			CollisionState previous_state = collision_state;
+
+			CollisionState result_state;
+			_set_collision_direction(result, result_state);
+
+			// If we hit a ceiling platform, we set the vertical velocity to at least the platform one.
+			if (collision_state.ceiling && platform_ceiling_velocity != Vector3() && platform_ceiling_velocity.dot(up_direction) < 0) {
+				// If ceiling sliding is on, only apply when the ceiling is flat or when the motion is upward.
+				if (!slide_on_ceiling || motion.dot(up_direction) < 0 || (ceiling_normal + up_direction).length() < 0.01) {
+					apply_ceiling_velocity = true;
+					Vector3 ceiling_vertical_velocity = up_direction * up_direction.dot(platform_ceiling_velocity);
+					Vector3 motion_vertical_velocity = up_direction * up_direction.dot(velocity);
+					if (motion_vertical_velocity.dot(up_direction) > 0 || ceiling_vertical_velocity.length_squared() > motion_vertical_velocity.length_squared()) {
+						velocity = ceiling_vertical_velocity + velocity.slide(up_direction);
+					}
+				}
+			}
+
+			if (collision_state.floor && floor_stop_on_slope && (velocity.normalized() + up_direction).length() < 0.01) {
+				Transform3D gt = get_global_transform();
+				if (result.travel.length() <= margin + CMP_EPSILON) {
+					gt.origin -= result.travel;
+				}
+				set_global_transform(gt);
+				velocity = Vector3();
+				motion = Vector3();
+				last_motion = Vector3();
+				break;
+			}
+
+			if (result.remainder.is_zero_approx()) {
+				motion = Vector3();
+				break;
+			}
+
+			// Apply regular sliding by default.
+			bool apply_default_sliding = true;
+
+			// Wall collision checks.
+			if (result_state.wall && (motion_slide_up.dot(wall_normal) <= 0)) {
+				// Move on floor only checks.
+				if (floor_block_on_wall) {
+					// Needs horizontal motion from current motion instead of motion_slide_up
+					// to properly test the angle and avoid standing on slopes
+					Vector3 horizontal_motion = motion.slide(up_direction);
+					Vector3 horizontal_normal = wall_normal.slide(up_direction).normalized();
+					real_t motion_angle = Math::abs(Math::acos(-horizontal_normal.dot(horizontal_motion.normalized())));
+
+					// Avoid to move forward on a wall if floor_block_on_wall is true.
+					// Applies only when the motion angle is under 90 degrees,
+					// in order to avoid blocking lateral motion along a wall.
+					if (motion_angle < .5 * Math_PI) {
+						apply_default_sliding = false;
+						if (p_was_on_floor && !vel_dir_facing_up) {
+							// Cancel the motion.
+							Transform3D gt = get_global_transform();
+							real_t travel_total = result.travel.length();
+							real_t cancel_dist_max = MIN(0.1, margin * 20);
+							if (travel_total <= margin + CMP_EPSILON) {
+								gt.origin -= result.travel;
+								result.travel = Vector3(); // Cancel for constant speed computation.
+							} else if (travel_total < cancel_dist_max) { // If the movement is large the body can be prevented from reaching the walls.
+								gt.origin -= result.travel.slide(up_direction);
+								// Keep remaining motion in sync with amount canceled.
+								motion = motion.slide(up_direction);
+								result.travel = Vector3();
+							} else {
+								// Travel is too high to be safely canceled, we take it into account.
+								result.travel = result.travel.slide(up_direction);
+								motion = motion.normalized() * result.travel.length();
+							}
+							set_global_transform(gt);
+							// Determines if you are on the ground, and limits the possibility of climbing on the walls because of the approximations.
+							_snap_on_floor(true, false);
+						} else {
+							// If the movement is not canceled we only keep the remaining.
+							motion = result.remainder;
+						}
+
+						// Apply slide on forward in order to allow only lateral motion on next step.
+						Vector3 forward = wall_normal.slide(up_direction).normalized();
+						motion = motion.slide(forward);
+
+						// Scales the horizontal velocity according to the wall slope.
+						if (vel_dir_facing_up) {
+							Vector3 slide_motion = velocity.slide(result.collisions[0].normal);
+							// Keeps the vertical motion from velocity and add the horizontal motion of the projection.
+							velocity = up_direction * up_direction.dot(velocity) + slide_motion.slide(up_direction);
+						} else {
+							velocity = velocity.slide(forward);
+						}
+
+						// Allow only lateral motion along previous floor when already on floor.
+						// Fixes slowing down when moving in diagonal against an inclined wall.
+						if (p_was_on_floor && !vel_dir_facing_up && (motion.dot(up_direction) > 0.0)) {
+							// Slide along the corner between the wall and previous floor.
+							Vector3 floor_side = prev_floor_normal.cross(wall_normal);
+							if (floor_side != Vector3()) {
+								motion = floor_side * motion.dot(floor_side);
+							}
+						}
+
+						// Stop all motion when a second wall is hit (unless sliding down or jumping),
+						// in order to avoid jittering in corner cases.
+						bool stop_all_motion = previous_state.wall && !vel_dir_facing_up;
+
+						// Allow sliding when the body falls.
+						if (!collision_state.floor && motion.dot(up_direction) < 0) {
+							Vector3 slide_motion = motion.slide(wall_normal);
+							// Test again to allow sliding only if the result goes downwards.
+							// Fixes jittering issues at the bottom of inclined walls.
+							if (slide_motion.dot(up_direction) < 0) {
+								stop_all_motion = false;
+								motion = slide_motion;
+							}
+						}
+
+						if (stop_all_motion) {
+							motion = Vector3();
+							velocity = Vector3();
+						}
+					}
+				}
+
+				// Stop horizontal motion when under wall slide threshold.
+				if (p_was_on_floor && (wall_min_slide_angle > 0.0) && result_state.wall) {
+					Vector3 horizontal_normal = wall_normal.slide(up_direction).normalized();
+					real_t motion_angle = Math::abs(Math::acos(-horizontal_normal.dot(motion_slide_up.normalized())));
+					if (motion_angle < wall_min_slide_angle) {
+						motion = up_direction * motion.dot(up_direction);
+						velocity = up_direction * velocity.dot(up_direction);
+
+						apply_default_sliding = false;
+					}
+				}
+			}
+
+			if (apply_default_sliding) {
+				// Regular sliding, the last part of the test handle the case when you don't want to slide on the ceiling.
+				if ((sliding_enabled || !collision_state.floor) && (!collision_state.ceiling || slide_on_ceiling || !vel_dir_facing_up) && !apply_ceiling_velocity) {
+					const PhysicsServer3D::MotionCollision &collision = result.collisions[0];
+
+					Vector3 slide_motion = result.remainder.slide(collision.normal);
+					if (collision_state.floor && !collision_state.wall && !motion_slide_up.is_zero_approx()) {
+						// Slide using the intersection between the motion plane and the floor plane,
+						// in order to keep the direction intact.
+						real_t motion_length = slide_motion.length();
+						slide_motion = up_direction.cross(result.remainder).cross(floor_normal);
+
+						// Keep the length from default slide to change speed in slopes by default,
+						// when constant speed is not enabled.
+						slide_motion.normalize();
+						slide_motion *= motion_length;
+					}
+
+					if (slide_motion.dot(velocity) > 0.0) {
+						motion = slide_motion;
+					} else {
+						motion = Vector3();
+					}
+
+					if (slide_on_ceiling && result_state.ceiling) {
+						// Apply slide only in the direction of the input motion, otherwise just stop to avoid jittering when moving against a wall.
+						if (vel_dir_facing_up) {
+							velocity = velocity.slide(collision.normal);
+						} else {
+							// Avoid acceleration in slope when falling.
+							velocity = up_direction * up_direction.dot(velocity);
+						}
+					}
+				}
+				// No sliding on first attempt to keep floor motion stable when possible.
+				else {
+					motion = result.remainder;
+					if (result_state.ceiling && !slide_on_ceiling && vel_dir_facing_up) {
+						velocity = velocity.slide(up_direction);
+						motion = motion.slide(up_direction);
+					}
+				}
+			}
+
+			total_travel += result.travel;
+
+			// Apply Constant Speed.
+			if (p_was_on_floor && floor_constant_speed && can_apply_constant_speed && collision_state.floor && !motion.is_zero_approx()) {
+				Vector3 travel_slide_up = total_travel.slide(up_direction);
+				motion = motion.normalized() * MAX(0, (motion_slide_up.length() - travel_slide_up.length()));
+			}
+		}
+		// When you move forward in a downward slope you don’t collide because you will be in the air.
+		// This test ensures that constant speed is applied, only if the player is still on the ground after the snap is applied.
+		else if (floor_constant_speed && first_slide && _on_floor_if_snapped(p_was_on_floor, vel_dir_facing_up)) {
+			can_apply_constant_speed = false;
+			sliding_enabled = true;
+			Transform3D gt = get_global_transform();
+			gt.origin = gt.origin - result.travel;
+			set_global_transform(gt);
+
+			// Slide using the intersection between the motion plane and the floor plane,
+			// in order to keep the direction intact.
+			Vector3 motion_slide_norm = up_direction.cross(motion).cross(prev_floor_normal);
+			motion_slide_norm.normalize();
+
+			motion = motion_slide_norm * (motion_slide_up.length());
+			collided = true;
+		}
+
+		if (!collided || motion.is_zero_approx()) {
+			break;
+		}
+
+		can_apply_constant_speed = !can_apply_constant_speed && !sliding_enabled;
+		sliding_enabled = true;
+		first_slide = false;
+	}
+
+	_snap_on_floor(p_was_on_floor, vel_dir_facing_up);
+
+	// Reset the gravity accumulation when touching the ground.
+	if (collision_state.floor && !vel_dir_facing_up) {
+		velocity = velocity.slide(up_direction);
+	}
+}
+
+void CharacterBody3D::_move_and_slide_floating(double p_delta) {
+	Vector3 motion = velocity * p_delta;
+
+	platform_rid = RID();
+	platform_object_id = ObjectID();
+	floor_normal = Vector3();
+	platform_velocity = Vector3();
+	platform_angular_velocity = Vector3();
+
+	bool first_slide = true;
+	for (int iteration = 0; iteration < max_slides; ++iteration) {
+		PhysicsServer3D::MotionParameters parameters(get_global_transform(), motion, margin);
+		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+
+		PhysicsServer3D::MotionResult result;
+		bool collided = move_and_collide(parameters, result, false, false);
+
+		last_motion = result.travel;
+
+		if (collided) {
+			motion_results.push_back(result);
+
+			CollisionState result_state;
+			_set_collision_direction(result, result_state);
+
+			if (result.remainder.is_zero_approx()) {
+				motion = Vector3();
+				break;
+			}
+
+			if (wall_min_slide_angle != 0 && Math::acos(wall_normal.dot(-velocity.normalized())) < wall_min_slide_angle + FLOOR_ANGLE_THRESHOLD) {
+				motion = Vector3();
+				if (result.travel.length() < margin + CMP_EPSILON) {
+					Transform3D gt = get_global_transform();
+					gt.origin -= result.travel;
+					set_global_transform(gt);
+				}
+			} else if (first_slide) {
+				Vector3 motion_slide_norm = result.remainder.slide(wall_normal).normalized();
+				motion = motion_slide_norm * (motion.length() - result.travel.length());
+			} else {
+				motion = result.remainder.slide(wall_normal);
+			}
+
+			if (motion.dot(velocity) <= 0.0) {
+				motion = Vector3();
+			}
+		}
+
+		if (!collided || motion.is_zero_approx()) {
+			break;
+		}
+
+		first_slide = false;
+	}
+}
+
+void CharacterBody3D::apply_floor_snap() {
+	if (collision_state.floor) {
+		return;
+	}
+
+	// Snap by at least collision margin to keep floor state consistent.
+	real_t length = MAX(floor_snap_length, margin);
+
+	PhysicsServer3D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
+	parameters.max_collisions = 4;
+	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+	parameters.collide_separation_ray = true;
+
+	PhysicsServer3D::MotionResult result;
+	if (move_and_collide(parameters, result, true, false)) {
+		CollisionState result_state;
+		// Apply direction for floor only.
+		_set_collision_direction(result, result_state, CollisionState(true, false, false));
+
+		if (result_state.floor) {
+			if (floor_stop_on_slope) {
+				// move and collide may stray the object a bit because of pre un-stucking,
+				// so only ensure that motion happens on floor direction in this case.
+				if (result.travel.length() > margin) {
+					result.travel = up_direction * up_direction.dot(result.travel);
+				} else {
+					result.travel = Vector3();
+				}
+			}
+
+			parameters.from.origin += result.travel;
+			set_global_transform(parameters.from);
+		}
+	}
+}
+
+void CharacterBody3D::_snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up) {
+	if (collision_state.floor || !p_was_on_floor || p_vel_dir_facing_up) {
+		return;
+	}
+
+	apply_floor_snap();
+}
+
+bool CharacterBody3D::_on_floor_if_snapped(bool p_was_on_floor, bool p_vel_dir_facing_up) {
+	if (up_direction == Vector3() || collision_state.floor || !p_was_on_floor || p_vel_dir_facing_up) {
+		return false;
+	}
+
+	// Snap by at least collision margin to keep floor state consistent.
+	real_t length = MAX(floor_snap_length, margin);
+
+	PhysicsServer3D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
+	parameters.max_collisions = 4;
+	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+	parameters.collide_separation_ray = true;
+
+	PhysicsServer3D::MotionResult result;
+	if (move_and_collide(parameters, result, true, false)) {
+		CollisionState result_state;
+		// Don't apply direction for any type.
+		_set_collision_direction(result, result_state, CollisionState());
+
+		return result_state.floor;
+	}
+
+	return false;
+}
+
+void CharacterBody3D::_set_collision_direction(const PhysicsServer3D::MotionResult &p_result, CollisionState &r_state, CollisionState p_apply_state) {
+	r_state.state = 0;
+
+	real_t wall_depth = -1.0;
+	real_t floor_depth = -1.0;
+
+	bool was_on_wall = collision_state.wall;
+	Vector3 prev_wall_normal = wall_normal;
+	int wall_collision_count = 0;
+	Vector3 combined_wall_normal;
+	Vector3 tmp_wall_col; // Avoid duplicate on average calculation.
+
+	for (int i = p_result.collision_count - 1; i >= 0; i--) {
+		const PhysicsServer3D::MotionCollision &collision = p_result.collisions[i];
+
+		if (motion_mode == MOTION_MODE_GROUNDED) {
+			// Check if any collision is floor.
+			real_t floor_angle = collision.get_angle(up_direction);
+			if (floor_angle <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+				r_state.floor = true;
+				if (p_apply_state.floor && collision.depth > floor_depth) {
+					collision_state.floor = true;
+					floor_normal = collision.normal;
+					floor_depth = collision.depth;
+					_set_platform_data(collision);
+				}
+				continue;
+			}
+
+			// Check if any collision is ceiling.
+			real_t ceiling_angle = collision.get_angle(-up_direction);
+			if (ceiling_angle <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+				r_state.ceiling = true;
+				if (p_apply_state.ceiling) {
+					platform_ceiling_velocity = collision.collider_velocity;
+					ceiling_normal = collision.normal;
+					collision_state.ceiling = true;
+				}
+				continue;
+			}
+		}
+
+		// Collision is wall by default.
+		r_state.wall = true;
+
+		if (p_apply_state.wall && collision.depth > wall_depth) {
+			collision_state.wall = true;
+			wall_depth = collision.depth;
+			wall_normal = collision.normal;
+
+			// Don't apply wall velocity when the collider is a CharacterBody3D.
+			if (Object::cast_to<CharacterBody3D>(ObjectDB::get_instance(collision.collider_id)) == nullptr) {
+				_set_platform_data(collision);
+			}
+		}
+
+		// Collect normal for calculating average.
+		if (!collision.normal.is_equal_approx(tmp_wall_col)) {
+			tmp_wall_col = collision.normal;
+			combined_wall_normal += collision.normal;
+			wall_collision_count++;
+		}
+	}
+
+	if (r_state.wall) {
+		if (wall_collision_count > 1 && !r_state.floor) {
+			// Check if wall normals cancel out to floor support.
+			if (!r_state.floor && motion_mode == MOTION_MODE_GROUNDED) {
+				combined_wall_normal.normalize();
+				real_t floor_angle = Math::acos(combined_wall_normal.dot(up_direction));
+				if (floor_angle <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+					r_state.floor = true;
+					r_state.wall = false;
+					if (p_apply_state.floor) {
+						collision_state.floor = true;
+						floor_normal = combined_wall_normal;
+					}
+					if (p_apply_state.wall) {
+						collision_state.wall = was_on_wall;
+						wall_normal = prev_wall_normal;
+					}
+					return;
+				}
+			}
+		}
+	}
+}
+
+void CharacterBody3D::_set_platform_data(const PhysicsServer3D::MotionCollision &p_collision) {
+	platform_rid = p_collision.collider;
+	platform_object_id = p_collision.collider_id;
+	platform_velocity = p_collision.collider_velocity;
+	platform_angular_velocity = p_collision.collider_angular_velocity;
+	platform_layer = PhysicsServer3D::get_singleton()->body_get_collision_layer(platform_rid);
+}
+
+void CharacterBody3D::set_safe_margin(real_t p_margin) {
+	margin = p_margin;
+}
+
+real_t CharacterBody3D::get_safe_margin() const {
+	return margin;
+}
+
+const Vector3 &CharacterBody3D::get_velocity() const {
+	return velocity;
+}
+
+void CharacterBody3D::set_velocity(const Vector3 &p_velocity) {
+	velocity = p_velocity;
+}
+
+bool CharacterBody3D::is_on_floor() const {
+	return collision_state.floor;
+}
+
+bool CharacterBody3D::is_on_floor_only() const {
+	return collision_state.floor && !collision_state.wall && !collision_state.ceiling;
+}
+
+bool CharacterBody3D::is_on_wall() const {
+	return collision_state.wall;
+}
+
+bool CharacterBody3D::is_on_wall_only() const {
+	return collision_state.wall && !collision_state.floor && !collision_state.ceiling;
+}
+
+bool CharacterBody3D::is_on_ceiling() const {
+	return collision_state.ceiling;
+}
+
+bool CharacterBody3D::is_on_ceiling_only() const {
+	return collision_state.ceiling && !collision_state.floor && !collision_state.wall;
+}
+
+const Vector3 &CharacterBody3D::get_floor_normal() const {
+	return floor_normal;
+}
+
+const Vector3 &CharacterBody3D::get_wall_normal() const {
+	return wall_normal;
+}
+
+const Vector3 &CharacterBody3D::get_last_motion() const {
+	return last_motion;
+}
+
+Vector3 CharacterBody3D::get_position_delta() const {
+	return get_global_transform().origin - previous_position;
+}
+
+const Vector3 &CharacterBody3D::get_real_velocity() const {
+	return real_velocity;
+}
+
+real_t CharacterBody3D::get_floor_angle(const Vector3 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector3(), 0);
+	return Math::acos(floor_normal.dot(p_up_direction));
+}
+
+const Vector3 &CharacterBody3D::get_platform_velocity() const {
+	return platform_velocity;
+}
+
+const Vector3 &CharacterBody3D::get_platform_angular_velocity() const {
+	return platform_angular_velocity;
+}
+
+Vector3 CharacterBody3D::get_linear_velocity() const {
+	return get_real_velocity();
+}
+
+int CharacterBody3D::get_slide_collision_count() const {
+	return motion_results.size();
+}
+
+PhysicsServer3D::MotionResult CharacterBody3D::get_slide_collision(int p_bounce) const {
+	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), PhysicsServer3D::MotionResult());
+	return motion_results[p_bounce];
+}
+
+Ref<KinematicCollision3D> CharacterBody3D::_get_slide_collision(int p_bounce) {
+	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), Ref<KinematicCollision3D>());
+	if (p_bounce >= slide_colliders.size()) {
+		slide_colliders.resize(p_bounce + 1);
+	}
+
+	// Create a new instance when the cached reference is invalid or still in use in script.
+	if (slide_colliders[p_bounce].is_null() || slide_colliders[p_bounce]->get_reference_count() > 1) {
+		slide_colliders.write[p_bounce].instantiate();
+		slide_colliders.write[p_bounce]->owner = this;
+	}
+
+	slide_colliders.write[p_bounce]->result = motion_results[p_bounce];
+	return slide_colliders[p_bounce];
+}
+
+Ref<KinematicCollision3D> CharacterBody3D::_get_last_slide_collision() {
+	if (motion_results.size() == 0) {
+		return Ref<KinematicCollision3D>();
+	}
+	return _get_slide_collision(motion_results.size() - 1);
+}
+
+bool CharacterBody3D::is_floor_stop_on_slope_enabled() const {
+	return floor_stop_on_slope;
+}
+
+void CharacterBody3D::set_floor_stop_on_slope_enabled(bool p_enabled) {
+	floor_stop_on_slope = p_enabled;
+}
+
+bool CharacterBody3D::is_floor_constant_speed_enabled() const {
+	return floor_constant_speed;
+}
+
+void CharacterBody3D::set_floor_constant_speed_enabled(bool p_enabled) {
+	floor_constant_speed = p_enabled;
+}
+
+bool CharacterBody3D::is_floor_block_on_wall_enabled() const {
+	return floor_block_on_wall;
+}
+
+void CharacterBody3D::set_floor_block_on_wall_enabled(bool p_enabled) {
+	floor_block_on_wall = p_enabled;
+}
+
+bool CharacterBody3D::is_slide_on_ceiling_enabled() const {
+	return slide_on_ceiling;
+}
+
+void CharacterBody3D::set_slide_on_ceiling_enabled(bool p_enabled) {
+	slide_on_ceiling = p_enabled;
+}
+
+uint32_t CharacterBody3D::get_platform_floor_layers() const {
+	return platform_floor_layers;
+}
+
+void CharacterBody3D::set_platform_floor_layers(uint32_t p_exclude_layers) {
+	platform_floor_layers = p_exclude_layers;
+}
+
+uint32_t CharacterBody3D::get_platform_wall_layers() const {
+	return platform_wall_layers;
+}
+
+void CharacterBody3D::set_platform_wall_layers(uint32_t p_exclude_layers) {
+	platform_wall_layers = p_exclude_layers;
+}
+
+void CharacterBody3D::set_motion_mode(MotionMode p_mode) {
+	motion_mode = p_mode;
+}
+
+CharacterBody3D::MotionMode CharacterBody3D::get_motion_mode() const {
+	return motion_mode;
+}
+
+void CharacterBody3D::set_platform_on_leave(PlatformOnLeave p_on_leave_apply_velocity) {
+	platform_on_leave = p_on_leave_apply_velocity;
+}
+
+CharacterBody3D::PlatformOnLeave CharacterBody3D::get_platform_on_leave() const {
+	return platform_on_leave;
+}
+
+int CharacterBody3D::get_max_slides() const {
+	return max_slides;
+}
+
+void CharacterBody3D::set_max_slides(int p_max_slides) {
+	ERR_FAIL_COND(p_max_slides < 1);
+	max_slides = p_max_slides;
+}
+
+real_t CharacterBody3D::get_floor_max_angle() const {
+	return floor_max_angle;
+}
+
+void CharacterBody3D::set_floor_max_angle(real_t p_radians) {
+	floor_max_angle = p_radians;
+}
+
+real_t CharacterBody3D::get_floor_snap_length() {
+	return floor_snap_length;
+}
+
+void CharacterBody3D::set_floor_snap_length(real_t p_floor_snap_length) {
+	ERR_FAIL_COND(p_floor_snap_length < 0);
+	floor_snap_length = p_floor_snap_length;
+}
+
+real_t CharacterBody3D::get_wall_min_slide_angle() const {
+	return wall_min_slide_angle;
+}
+
+void CharacterBody3D::set_wall_min_slide_angle(real_t p_radians) {
+	wall_min_slide_angle = p_radians;
+}
+
+const Vector3 &CharacterBody3D::get_up_direction() const {
+	return up_direction;
+}
+
+void CharacterBody3D::set_up_direction(const Vector3 &p_up_direction) {
+	ERR_FAIL_COND_MSG(p_up_direction == Vector3(), "up_direction can't be equal to Vector3.ZERO, consider using Floating motion mode instead.");
+	up_direction = p_up_direction.normalized();
+}
+
+void CharacterBody3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			// Reset move_and_slide() data.
+			collision_state.state = 0;
+			platform_rid = RID();
+			platform_object_id = ObjectID();
+			motion_results.clear();
+			platform_velocity = Vector3();
+			platform_angular_velocity = Vector3();
+		} break;
+	}
+}
+
+void CharacterBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("move_and_slide"), &CharacterBody3D::move_and_slide);
+	ClassDB::bind_method(D_METHOD("apply_floor_snap"), &CharacterBody3D::apply_floor_snap);
+
+	ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &CharacterBody3D::set_velocity);
+	ClassDB::bind_method(D_METHOD("get_velocity"), &CharacterBody3D::get_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_safe_margin", "margin"), &CharacterBody3D::set_safe_margin);
+	ClassDB::bind_method(D_METHOD("get_safe_margin"), &CharacterBody3D::get_safe_margin);
+	ClassDB::bind_method(D_METHOD("is_floor_stop_on_slope_enabled"), &CharacterBody3D::is_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_stop_on_slope_enabled", "enabled"), &CharacterBody3D::set_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_constant_speed_enabled", "enabled"), &CharacterBody3D::set_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_constant_speed_enabled"), &CharacterBody3D::is_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_block_on_wall_enabled", "enabled"), &CharacterBody3D::set_floor_block_on_wall_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_block_on_wall_enabled"), &CharacterBody3D::is_floor_block_on_wall_enabled);
+	ClassDB::bind_method(D_METHOD("set_slide_on_ceiling_enabled", "enabled"), &CharacterBody3D::set_slide_on_ceiling_enabled);
+	ClassDB::bind_method(D_METHOD("is_slide_on_ceiling_enabled"), &CharacterBody3D::is_slide_on_ceiling_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_platform_floor_layers", "exclude_layer"), &CharacterBody3D::set_platform_floor_layers);
+	ClassDB::bind_method(D_METHOD("get_platform_floor_layers"), &CharacterBody3D::get_platform_floor_layers);
+	ClassDB::bind_method(D_METHOD("set_platform_wall_layers", "exclude_layer"), &CharacterBody3D::set_platform_wall_layers);
+	ClassDB::bind_method(D_METHOD("get_platform_wall_layers"), &CharacterBody3D::get_platform_wall_layers);
+
+	ClassDB::bind_method(D_METHOD("get_max_slides"), &CharacterBody3D::get_max_slides);
+	ClassDB::bind_method(D_METHOD("set_max_slides", "max_slides"), &CharacterBody3D::set_max_slides);
+	ClassDB::bind_method(D_METHOD("get_floor_max_angle"), &CharacterBody3D::get_floor_max_angle);
+	ClassDB::bind_method(D_METHOD("set_floor_max_angle", "radians"), &CharacterBody3D::set_floor_max_angle);
+	ClassDB::bind_method(D_METHOD("get_floor_snap_length"), &CharacterBody3D::get_floor_snap_length);
+	ClassDB::bind_method(D_METHOD("set_floor_snap_length", "floor_snap_length"), &CharacterBody3D::set_floor_snap_length);
+	ClassDB::bind_method(D_METHOD("get_wall_min_slide_angle"), &CharacterBody3D::get_wall_min_slide_angle);
+	ClassDB::bind_method(D_METHOD("set_wall_min_slide_angle", "radians"), &CharacterBody3D::set_wall_min_slide_angle);
+	ClassDB::bind_method(D_METHOD("get_up_direction"), &CharacterBody3D::get_up_direction);
+	ClassDB::bind_method(D_METHOD("set_up_direction", "up_direction"), &CharacterBody3D::set_up_direction);
+	ClassDB::bind_method(D_METHOD("set_motion_mode", "mode"), &CharacterBody3D::set_motion_mode);
+	ClassDB::bind_method(D_METHOD("get_motion_mode"), &CharacterBody3D::get_motion_mode);
+	ClassDB::bind_method(D_METHOD("set_platform_on_leave", "on_leave_apply_velocity"), &CharacterBody3D::set_platform_on_leave);
+	ClassDB::bind_method(D_METHOD("get_platform_on_leave"), &CharacterBody3D::get_platform_on_leave);
+
+	ClassDB::bind_method(D_METHOD("is_on_floor"), &CharacterBody3D::is_on_floor);
+	ClassDB::bind_method(D_METHOD("is_on_floor_only"), &CharacterBody3D::is_on_floor_only);
+	ClassDB::bind_method(D_METHOD("is_on_ceiling"), &CharacterBody3D::is_on_ceiling);
+	ClassDB::bind_method(D_METHOD("is_on_ceiling_only"), &CharacterBody3D::is_on_ceiling_only);
+	ClassDB::bind_method(D_METHOD("is_on_wall"), &CharacterBody3D::is_on_wall);
+	ClassDB::bind_method(D_METHOD("is_on_wall_only"), &CharacterBody3D::is_on_wall_only);
+	ClassDB::bind_method(D_METHOD("get_floor_normal"), &CharacterBody3D::get_floor_normal);
+	ClassDB::bind_method(D_METHOD("get_wall_normal"), &CharacterBody3D::get_wall_normal);
+	ClassDB::bind_method(D_METHOD("get_last_motion"), &CharacterBody3D::get_last_motion);
+	ClassDB::bind_method(D_METHOD("get_position_delta"), &CharacterBody3D::get_position_delta);
+	ClassDB::bind_method(D_METHOD("get_real_velocity"), &CharacterBody3D::get_real_velocity);
+	ClassDB::bind_method(D_METHOD("get_floor_angle", "up_direction"), &CharacterBody3D::get_floor_angle, DEFVAL(Vector3(0.0, 1.0, 0.0)));
+	ClassDB::bind_method(D_METHOD("get_platform_velocity"), &CharacterBody3D::get_platform_velocity);
+	ClassDB::bind_method(D_METHOD("get_platform_angular_velocity"), &CharacterBody3D::get_platform_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_slide_collision_count"), &CharacterBody3D::get_slide_collision_count);
+	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &CharacterBody3D::_get_slide_collision);
+	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody3D::_get_last_slide_collision);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "motion_mode", PROPERTY_HINT_ENUM, "Grounded,Floating", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_motion_mode", "get_motion_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "up_direction"), "set_up_direction", "get_up_direction");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_ceiling"), "set_slide_on_ceiling_enabled", "is_slide_on_ceiling_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "velocity", PROPERTY_HINT_NONE, "suffix:m/s", PROPERTY_USAGE_NO_EDITOR), "set_velocity", "get_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_slides", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_max_slides", "get_max_slides");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wall_min_slide_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians_as_degrees", PROPERTY_USAGE_DEFAULT), "set_wall_min_slide_angle", "get_wall_min_slide_angle");
+
+	ADD_GROUP("Floor", "floor_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_stop_on_slope"), "set_floor_stop_on_slope_enabled", "is_floor_stop_on_slope_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_constant_speed"), "set_floor_constant_speed_enabled", "is_floor_constant_speed_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_block_on_wall"), "set_floor_block_on_wall_enabled", "is_floor_block_on_wall_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_max_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians_as_degrees"), "set_floor_max_angle", "get_floor_max_angle");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_snap_length", PROPERTY_HINT_RANGE, "0,1,0.01,or_greater,suffix:m"), "set_floor_snap_length", "get_floor_snap_length");
+
+	ADD_GROUP("Moving Platform", "platform_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "platform_on_leave", PROPERTY_HINT_ENUM, "Add Velocity,Add Upward Velocity,Do Nothing", PROPERTY_USAGE_DEFAULT), "set_platform_on_leave", "get_platform_on_leave");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "platform_floor_layers", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_platform_floor_layers", "get_platform_floor_layers");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "platform_wall_layers", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_platform_wall_layers", "get_platform_wall_layers");
+
+	ADD_GROUP("Collision", "");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001,suffix:m"), "set_safe_margin", "get_safe_margin");
+
+	BIND_ENUM_CONSTANT(MOTION_MODE_GROUNDED);
+	BIND_ENUM_CONSTANT(MOTION_MODE_FLOATING);
+
+	BIND_ENUM_CONSTANT(PLATFORM_ON_LEAVE_ADD_VELOCITY);
+	BIND_ENUM_CONSTANT(PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY);
+	BIND_ENUM_CONSTANT(PLATFORM_ON_LEAVE_DO_NOTHING);
+}
+
+void CharacterBody3D::_validate_property(PropertyInfo &p_property) const {
+	if (motion_mode == MOTION_MODE_FLOATING) {
+		if (p_property.name.begins_with("floor_") || p_property.name == "up_direction" || p_property.name == "slide_on_ceiling") {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	}
+}
+
+CharacterBody3D::CharacterBody3D() :
+		PhysicsBody3D(PhysicsServer3D::BODY_MODE_KINEMATIC) {
+}
+
+CharacterBody3D::~CharacterBody3D() {
+	for (int i = 0; i < slide_colliders.size(); i++) {
+		if (slide_colliders[i].is_valid()) {
+			slide_colliders.write[i]->owner = nullptr;
+		}
+	}
+}
diff --git a/scene/3d/physics/character_body_3d.h b/scene/3d/physics/character_body_3d.h
new file mode 100644
index 0000000000..cffc0f8e63
--- /dev/null
+++ b/scene/3d/physics/character_body_3d.h
@@ -0,0 +1,190 @@
+/**************************************************************************/
+/*  character_body_3d.h                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef CHARACTER_BODY_3D_H
+#define CHARACTER_BODY_3D_H
+
+#include "scene/3d/physics/kinematic_collision_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+
+class CharacterBody3D : public PhysicsBody3D {
+	GDCLASS(CharacterBody3D, PhysicsBody3D);
+
+public:
+	enum MotionMode {
+		MOTION_MODE_GROUNDED,
+		MOTION_MODE_FLOATING,
+	};
+	enum PlatformOnLeave {
+		PLATFORM_ON_LEAVE_ADD_VELOCITY,
+		PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY,
+		PLATFORM_ON_LEAVE_DO_NOTHING,
+	};
+	bool move_and_slide();
+	void apply_floor_snap();
+
+	const Vector3 &get_velocity() const;
+	void set_velocity(const Vector3 &p_velocity);
+
+	bool is_on_floor() const;
+	bool is_on_floor_only() const;
+	bool is_on_wall() const;
+	bool is_on_wall_only() const;
+	bool is_on_ceiling() const;
+	bool is_on_ceiling_only() const;
+	const Vector3 &get_last_motion() const;
+	Vector3 get_position_delta() const;
+	const Vector3 &get_floor_normal() const;
+	const Vector3 &get_wall_normal() const;
+	const Vector3 &get_real_velocity() const;
+	real_t get_floor_angle(const Vector3 &p_up_direction = Vector3(0.0, 1.0, 0.0)) const;
+	const Vector3 &get_platform_velocity() const;
+	const Vector3 &get_platform_angular_velocity() const;
+
+	virtual Vector3 get_linear_velocity() const override;
+
+	int get_slide_collision_count() const;
+	PhysicsServer3D::MotionResult get_slide_collision(int p_bounce) const;
+
+	void set_safe_margin(real_t p_margin);
+	real_t get_safe_margin() const;
+
+	bool is_floor_stop_on_slope_enabled() const;
+	void set_floor_stop_on_slope_enabled(bool p_enabled);
+
+	bool is_floor_constant_speed_enabled() const;
+	void set_floor_constant_speed_enabled(bool p_enabled);
+
+	bool is_floor_block_on_wall_enabled() const;
+	void set_floor_block_on_wall_enabled(bool p_enabled);
+
+	bool is_slide_on_ceiling_enabled() const;
+	void set_slide_on_ceiling_enabled(bool p_enabled);
+
+	int get_max_slides() const;
+	void set_max_slides(int p_max_slides);
+
+	real_t get_floor_max_angle() const;
+	void set_floor_max_angle(real_t p_radians);
+
+	real_t get_floor_snap_length();
+	void set_floor_snap_length(real_t p_floor_snap_length);
+
+	real_t get_wall_min_slide_angle() const;
+	void set_wall_min_slide_angle(real_t p_radians);
+
+	uint32_t get_platform_floor_layers() const;
+	void set_platform_floor_layers(const uint32_t p_exclude_layer);
+
+	uint32_t get_platform_wall_layers() const;
+	void set_platform_wall_layers(const uint32_t p_exclude_layer);
+
+	void set_motion_mode(MotionMode p_mode);
+	MotionMode get_motion_mode() const;
+
+	void set_platform_on_leave(PlatformOnLeave p_on_leave_velocity);
+	PlatformOnLeave get_platform_on_leave() const;
+
+	CharacterBody3D();
+	~CharacterBody3D();
+
+private:
+	real_t margin = 0.001;
+	MotionMode motion_mode = MOTION_MODE_GROUNDED;
+	PlatformOnLeave platform_on_leave = PLATFORM_ON_LEAVE_ADD_VELOCITY;
+	union CollisionState {
+		uint32_t state = 0;
+		struct {
+			bool floor;
+			bool wall;
+			bool ceiling;
+		};
+
+		CollisionState() {
+		}
+
+		CollisionState(bool p_floor, bool p_wall, bool p_ceiling) {
+			floor = p_floor;
+			wall = p_wall;
+			ceiling = p_ceiling;
+		}
+	};
+
+	CollisionState collision_state;
+	bool floor_constant_speed = false;
+	bool floor_stop_on_slope = true;
+	bool floor_block_on_wall = true;
+	bool slide_on_ceiling = true;
+	int max_slides = 6;
+	int platform_layer = 0;
+	RID platform_rid;
+	ObjectID platform_object_id;
+	uint32_t platform_floor_layers = UINT32_MAX;
+	uint32_t platform_wall_layers = 0;
+	real_t floor_snap_length = 0.1;
+	real_t floor_max_angle = Math::deg_to_rad((real_t)45.0);
+	real_t wall_min_slide_angle = Math::deg_to_rad((real_t)15.0);
+	Vector3 up_direction = Vector3(0.0, 1.0, 0.0);
+	Vector3 velocity;
+	Vector3 floor_normal;
+	Vector3 wall_normal;
+	Vector3 ceiling_normal;
+	Vector3 last_motion;
+	Vector3 platform_velocity;
+	Vector3 platform_angular_velocity;
+	Vector3 platform_ceiling_velocity;
+	Vector3 previous_position;
+	Vector3 real_velocity;
+
+	Vector<PhysicsServer3D::MotionResult> motion_results;
+	Vector<Ref<KinematicCollision3D>> slide_colliders;
+
+	void _move_and_slide_floating(double p_delta);
+	void _move_and_slide_grounded(double p_delta, bool p_was_on_floor);
+
+	Ref<KinematicCollision3D> _get_slide_collision(int p_bounce);
+	Ref<KinematicCollision3D> _get_last_slide_collision();
+	const Vector3 &get_up_direction() const;
+	bool _on_floor_if_snapped(bool p_was_on_floor, bool p_vel_dir_facing_up);
+	void set_up_direction(const Vector3 &p_up_direction);
+	void _set_collision_direction(const PhysicsServer3D::MotionResult &p_result, CollisionState &r_state, CollisionState p_apply_state = CollisionState(true, true, true));
+	void _set_platform_data(const PhysicsServer3D::MotionCollision &p_collision);
+	void _snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+	void _validate_property(PropertyInfo &p_property) const;
+};
+
+VARIANT_ENUM_CAST(CharacterBody3D::MotionMode);
+VARIANT_ENUM_CAST(CharacterBody3D::PlatformOnLeave);
+
+#endif // CHARACTER_BODY_3D_H
diff --git a/scene/3d/physics/collision_object_3d.cpp b/scene/3d/physics/collision_object_3d.cpp
new file mode 100644
index 0000000000..bbd2ef2fb8
--- /dev/null
+++ b/scene/3d/physics/collision_object_3d.cpp
@@ -0,0 +1,756 @@
+/**************************************************************************/
+/*  collision_object_3d.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "collision_object_3d.h"
+
+#include "scene/resources/3d/shape_3d.h"
+#include "scene/scene_string_names.h"
+
+void CollisionObject3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			if (_are_collision_shapes_visible()) {
+				debug_shape_old_transform = get_global_transform();
+				for (const KeyValue<uint32_t, ShapeData> &E : shapes) {
+					debug_shapes_to_update.insert(E.key);
+				}
+				_update_debug_shapes();
+			}
+#ifdef TOOLS_ENABLED
+			if (Engine::get_singleton()->is_editor_hint()) {
+				set_notify_local_transform(true); // Used for warnings and only in editor.
+			}
+#endif
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (debug_shapes_count > 0) {
+				_clear_debug_shapes();
+			}
+		} break;
+
+		case NOTIFICATION_ENTER_WORLD: {
+			if (area) {
+				PhysicsServer3D::get_singleton()->area_set_transform(rid, get_global_transform());
+			} else {
+				PhysicsServer3D::get_singleton()->body_set_state(rid, PhysicsServer3D::BODY_STATE_TRANSFORM, get_global_transform());
+			}
+
+			bool disabled = !is_enabled();
+
+			if (disabled && (disable_mode != DISABLE_MODE_REMOVE)) {
+				_apply_disabled();
+			}
+
+			if (!disabled || (disable_mode != DISABLE_MODE_REMOVE)) {
+				Ref<World3D> world_ref = get_world_3d();
+				ERR_FAIL_COND(!world_ref.is_valid());
+				RID space = world_ref->get_space();
+				if (area) {
+					PhysicsServer3D::get_singleton()->area_set_space(rid, space);
+				} else {
+					PhysicsServer3D::get_singleton()->body_set_space(rid, space);
+				}
+				_space_changed(space);
+			}
+
+			_update_pickable();
+		} break;
+
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+			update_configuration_warnings();
+		} break;
+
+		case NOTIFICATION_TRANSFORM_CHANGED: {
+			if (only_update_transform_changes) {
+				return;
+			}
+
+			if (area) {
+				PhysicsServer3D::get_singleton()->area_set_transform(rid, get_global_transform());
+			} else {
+				PhysicsServer3D::get_singleton()->body_set_state(rid, PhysicsServer3D::BODY_STATE_TRANSFORM, get_global_transform());
+			}
+
+			_on_transform_changed();
+		} break;
+
+		case NOTIFICATION_VISIBILITY_CHANGED: {
+			_update_pickable();
+		} break;
+
+		case NOTIFICATION_EXIT_WORLD: {
+			bool disabled = !is_enabled();
+
+			if (!disabled || (disable_mode != DISABLE_MODE_REMOVE)) {
+				if (callback_lock > 0) {
+					ERR_PRINT("Removing a CollisionObject node during a physics callback is not allowed and will cause undesired behavior. Remove with call_deferred() instead.");
+				} else {
+					if (area) {
+						PhysicsServer3D::get_singleton()->area_set_space(rid, RID());
+					} else {
+						PhysicsServer3D::get_singleton()->body_set_space(rid, RID());
+					}
+					_space_changed(RID());
+				}
+			}
+
+			if (disabled && (disable_mode != DISABLE_MODE_REMOVE)) {
+				_apply_enabled();
+			}
+		} break;
+
+		case NOTIFICATION_DISABLED: {
+			_apply_disabled();
+		} break;
+
+		case NOTIFICATION_ENABLED: {
+			_apply_enabled();
+		} break;
+	}
+}
+
+void CollisionObject3D::set_collision_layer(uint32_t p_layer) {
+	collision_layer = p_layer;
+	if (area) {
+		PhysicsServer3D::get_singleton()->area_set_collision_layer(get_rid(), p_layer);
+	} else {
+		PhysicsServer3D::get_singleton()->body_set_collision_layer(get_rid(), p_layer);
+	}
+}
+
+uint32_t CollisionObject3D::get_collision_layer() const {
+	return collision_layer;
+}
+
+void CollisionObject3D::set_collision_mask(uint32_t p_mask) {
+	collision_mask = p_mask;
+	if (area) {
+		PhysicsServer3D::get_singleton()->area_set_collision_mask(get_rid(), p_mask);
+	} else {
+		PhysicsServer3D::get_singleton()->body_set_collision_mask(get_rid(), p_mask);
+	}
+}
+
+uint32_t CollisionObject3D::get_collision_mask() const {
+	return collision_mask;
+}
+
+void CollisionObject3D::set_collision_layer_value(int p_layer_number, bool p_value) {
+	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
+	uint32_t collision_layer_new = get_collision_layer();
+	if (p_value) {
+		collision_layer_new |= 1 << (p_layer_number - 1);
+	} else {
+		collision_layer_new &= ~(1 << (p_layer_number - 1));
+	}
+	set_collision_layer(collision_layer_new);
+}
+
+bool CollisionObject3D::get_collision_layer_value(int p_layer_number) const {
+	ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
+	return get_collision_layer() & (1 << (p_layer_number - 1));
+}
+
+void CollisionObject3D::set_collision_mask_value(int p_layer_number, bool p_value) {
+	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
+	uint32_t mask = get_collision_mask();
+	if (p_value) {
+		mask |= 1 << (p_layer_number - 1);
+	} else {
+		mask &= ~(1 << (p_layer_number - 1));
+	}
+	set_collision_mask(mask);
+}
+
+bool CollisionObject3D::get_collision_mask_value(int p_layer_number) const {
+	ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
+	return get_collision_mask() & (1 << (p_layer_number - 1));
+}
+
+void CollisionObject3D::set_collision_priority(real_t p_priority) {
+	collision_priority = p_priority;
+	if (!area) {
+		PhysicsServer3D::get_singleton()->body_set_collision_priority(get_rid(), p_priority);
+	}
+}
+
+real_t CollisionObject3D::get_collision_priority() const {
+	return collision_priority;
+}
+
+void CollisionObject3D::set_disable_mode(DisableMode p_mode) {
+	if (disable_mode == p_mode) {
+		return;
+	}
+
+	bool disabled = is_inside_tree() && !is_enabled();
+
+	if (disabled) {
+		// Cancel previous disable mode.
+		_apply_enabled();
+	}
+
+	disable_mode = p_mode;
+
+	if (disabled) {
+		// Apply new disable mode.
+		_apply_disabled();
+	}
+}
+
+CollisionObject3D::DisableMode CollisionObject3D::get_disable_mode() const {
+	return disable_mode;
+}
+
+void CollisionObject3D::_apply_disabled() {
+	switch (disable_mode) {
+		case DISABLE_MODE_REMOVE: {
+			if (is_inside_tree()) {
+				if (callback_lock > 0) {
+					ERR_PRINT("Disabling a CollisionObject node during a physics callback is not allowed and will cause undesired behavior. Disable with call_deferred() instead.");
+				} else {
+					if (area) {
+						PhysicsServer3D::get_singleton()->area_set_space(rid, RID());
+					} else {
+						PhysicsServer3D::get_singleton()->body_set_space(rid, RID());
+					}
+					_space_changed(RID());
+				}
+			}
+		} break;
+
+		case DISABLE_MODE_MAKE_STATIC: {
+			if (!area && (body_mode != PhysicsServer3D::BODY_MODE_STATIC)) {
+				PhysicsServer3D::get_singleton()->body_set_mode(rid, PhysicsServer3D::BODY_MODE_STATIC);
+			}
+		} break;
+
+		case DISABLE_MODE_KEEP_ACTIVE: {
+			// Nothing to do.
+		} break;
+	}
+}
+
+void CollisionObject3D::_apply_enabled() {
+	switch (disable_mode) {
+		case DISABLE_MODE_REMOVE: {
+			if (is_inside_tree()) {
+				RID space = get_world_3d()->get_space();
+				if (area) {
+					PhysicsServer3D::get_singleton()->area_set_space(rid, space);
+				} else {
+					PhysicsServer3D::get_singleton()->body_set_space(rid, space);
+				}
+				_space_changed(space);
+			}
+		} break;
+
+		case DISABLE_MODE_MAKE_STATIC: {
+			if (!area && (body_mode != PhysicsServer3D::BODY_MODE_STATIC)) {
+				PhysicsServer3D::get_singleton()->body_set_mode(rid, body_mode);
+			}
+		} break;
+
+		case DISABLE_MODE_KEEP_ACTIVE: {
+			// Nothing to do.
+		} break;
+	}
+}
+
+void CollisionObject3D::_input_event_call(Camera3D *p_camera, const Ref<InputEvent> &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape) {
+	GDVIRTUAL_CALL(_input_event, p_camera, p_input_event, p_pos, p_normal, p_shape);
+	emit_signal(SceneStringNames::get_singleton()->input_event, p_camera, p_input_event, p_pos, p_normal, p_shape);
+}
+
+void CollisionObject3D::_mouse_enter() {
+	GDVIRTUAL_CALL(_mouse_enter);
+	emit_signal(SceneStringNames::get_singleton()->mouse_entered);
+}
+
+void CollisionObject3D::_mouse_exit() {
+	GDVIRTUAL_CALL(_mouse_exit);
+	emit_signal(SceneStringNames::get_singleton()->mouse_exited);
+}
+
+void CollisionObject3D::set_body_mode(PhysicsServer3D::BodyMode p_mode) {
+	ERR_FAIL_COND(area);
+
+	if (body_mode == p_mode) {
+		return;
+	}
+
+	body_mode = p_mode;
+
+	if (is_inside_tree() && !is_enabled() && (disable_mode == DISABLE_MODE_MAKE_STATIC)) {
+		return;
+	}
+
+	PhysicsServer3D::get_singleton()->body_set_mode(rid, p_mode);
+}
+
+void CollisionObject3D::_space_changed(const RID &p_new_space) {
+}
+
+void CollisionObject3D::set_only_update_transform_changes(bool p_enable) {
+	only_update_transform_changes = p_enable;
+}
+
+bool CollisionObject3D::is_only_update_transform_changes_enabled() const {
+	return only_update_transform_changes;
+}
+
+void CollisionObject3D::_update_pickable() {
+	if (!is_inside_tree()) {
+		return;
+	}
+
+	bool pickable = ray_pickable && is_visible_in_tree();
+	if (area) {
+		PhysicsServer3D::get_singleton()->area_set_ray_pickable(rid, pickable);
+	} else {
+		PhysicsServer3D::get_singleton()->body_set_ray_pickable(rid, pickable);
+	}
+}
+
+bool CollisionObject3D::_are_collision_shapes_visible() {
+	return is_inside_tree() && get_tree()->is_debugging_collisions_hint() && !Engine::get_singleton()->is_editor_hint();
+}
+
+void CollisionObject3D::_update_shape_data(uint32_t p_owner) {
+	if (_are_collision_shapes_visible()) {
+		if (debug_shapes_to_update.is_empty()) {
+			callable_mp(this, &CollisionObject3D::_update_debug_shapes).call_deferred();
+		}
+		debug_shapes_to_update.insert(p_owner);
+	}
+}
+
+void CollisionObject3D::_shape_changed(const Ref<Shape3D> &p_shape) {
+	for (KeyValue<uint32_t, ShapeData> &E : shapes) {
+		ShapeData &shapedata = E.value;
+		ShapeData::ShapeBase *shape_bases = shapedata.shapes.ptrw();
+		for (int i = 0; i < shapedata.shapes.size(); i++) {
+			ShapeData::ShapeBase &s = shape_bases[i];
+			if (s.shape == p_shape && s.debug_shape.is_valid()) {
+				Ref<Mesh> mesh = s.shape->get_debug_mesh();
+				RS::get_singleton()->instance_set_base(s.debug_shape, mesh->get_rid());
+			}
+		}
+	}
+}
+
+void CollisionObject3D::_update_debug_shapes() {
+	ERR_FAIL_NULL(RenderingServer::get_singleton());
+
+	if (!is_inside_tree()) {
+		debug_shapes_to_update.clear();
+		return;
+	}
+
+	for (const uint32_t &shapedata_idx : debug_shapes_to_update) {
+		if (shapes.has(shapedata_idx)) {
+			ShapeData &shapedata = shapes[shapedata_idx];
+			ShapeData::ShapeBase *shape_bases = shapedata.shapes.ptrw();
+			for (int i = 0; i < shapedata.shapes.size(); i++) {
+				ShapeData::ShapeBase &s = shape_bases[i];
+				if (s.shape.is_null() || shapedata.disabled) {
+					if (s.debug_shape.is_valid()) {
+						RS::get_singleton()->free(s.debug_shape);
+						s.debug_shape = RID();
+						--debug_shapes_count;
+					}
+					continue;
+				}
+
+				if (s.debug_shape.is_null()) {
+					s.debug_shape = RS::get_singleton()->instance_create();
+					RS::get_singleton()->instance_set_scenario(s.debug_shape, get_world_3d()->get_scenario());
+					s.shape->connect_changed(callable_mp(this, &CollisionObject3D::_shape_changed).bind(s.shape), CONNECT_DEFERRED);
+					++debug_shapes_count;
+				}
+
+				Ref<Mesh> mesh = s.shape->get_debug_mesh();
+				RS::get_singleton()->instance_set_base(s.debug_shape, mesh->get_rid());
+				RS::get_singleton()->instance_set_transform(s.debug_shape, get_global_transform() * shapedata.xform);
+			}
+		}
+	}
+	debug_shapes_to_update.clear();
+}
+
+void CollisionObject3D::_clear_debug_shapes() {
+	ERR_FAIL_NULL(RenderingServer::get_singleton());
+
+	for (KeyValue<uint32_t, ShapeData> &E : shapes) {
+		ShapeData &shapedata = E.value;
+		ShapeData::ShapeBase *shape_bases = shapedata.shapes.ptrw();
+		for (int i = 0; i < shapedata.shapes.size(); i++) {
+			ShapeData::ShapeBase &s = shape_bases[i];
+			if (s.debug_shape.is_valid()) {
+				RS::get_singleton()->free(s.debug_shape);
+				s.debug_shape = RID();
+				if (s.shape.is_valid()) {
+					s.shape->disconnect_changed(callable_mp(this, &CollisionObject3D::_update_shape_data));
+				}
+			}
+		}
+	}
+	debug_shapes_count = 0;
+}
+
+void CollisionObject3D::_on_transform_changed() {
+	if (debug_shapes_count > 0 && !debug_shape_old_transform.is_equal_approx(get_global_transform())) {
+		debug_shape_old_transform = get_global_transform();
+		for (KeyValue<uint32_t, ShapeData> &E : shapes) {
+			ShapeData &shapedata = E.value;
+			if (shapedata.disabled) {
+				continue; // If disabled then there are no debug shapes to update.
+			}
+			const ShapeData::ShapeBase *shape_bases = shapedata.shapes.ptr();
+			for (int i = 0; i < shapedata.shapes.size(); i++) {
+				RS::get_singleton()->instance_set_transform(shape_bases[i].debug_shape, debug_shape_old_transform * shapedata.xform);
+			}
+		}
+	}
+}
+
+void CollisionObject3D::set_ray_pickable(bool p_ray_pickable) {
+	ray_pickable = p_ray_pickable;
+	_update_pickable();
+}
+
+bool CollisionObject3D::is_ray_pickable() const {
+	return ray_pickable;
+}
+
+void CollisionObject3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &CollisionObject3D::set_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_collision_layer"), &CollisionObject3D::get_collision_layer);
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &CollisionObject3D::set_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &CollisionObject3D::get_collision_mask);
+	ClassDB::bind_method(D_METHOD("set_collision_layer_value", "layer_number", "value"), &CollisionObject3D::set_collision_layer_value);
+	ClassDB::bind_method(D_METHOD("get_collision_layer_value", "layer_number"), &CollisionObject3D::get_collision_layer_value);
+	ClassDB::bind_method(D_METHOD("set_collision_mask_value", "layer_number", "value"), &CollisionObject3D::set_collision_mask_value);
+	ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &CollisionObject3D::get_collision_mask_value);
+	ClassDB::bind_method(D_METHOD("set_collision_priority", "priority"), &CollisionObject3D::set_collision_priority);
+	ClassDB::bind_method(D_METHOD("get_collision_priority"), &CollisionObject3D::get_collision_priority);
+	ClassDB::bind_method(D_METHOD("set_disable_mode", "mode"), &CollisionObject3D::set_disable_mode);
+	ClassDB::bind_method(D_METHOD("get_disable_mode"), &CollisionObject3D::get_disable_mode);
+	ClassDB::bind_method(D_METHOD("set_ray_pickable", "ray_pickable"), &CollisionObject3D::set_ray_pickable);
+	ClassDB::bind_method(D_METHOD("is_ray_pickable"), &CollisionObject3D::is_ray_pickable);
+	ClassDB::bind_method(D_METHOD("set_capture_input_on_drag", "enable"), &CollisionObject3D::set_capture_input_on_drag);
+	ClassDB::bind_method(D_METHOD("get_capture_input_on_drag"), &CollisionObject3D::get_capture_input_on_drag);
+	ClassDB::bind_method(D_METHOD("get_rid"), &CollisionObject3D::get_rid);
+	ClassDB::bind_method(D_METHOD("create_shape_owner", "owner"), &CollisionObject3D::create_shape_owner);
+	ClassDB::bind_method(D_METHOD("remove_shape_owner", "owner_id"), &CollisionObject3D::remove_shape_owner);
+	ClassDB::bind_method(D_METHOD("get_shape_owners"), &CollisionObject3D::_get_shape_owners);
+	ClassDB::bind_method(D_METHOD("shape_owner_set_transform", "owner_id", "transform"), &CollisionObject3D::shape_owner_set_transform);
+	ClassDB::bind_method(D_METHOD("shape_owner_get_transform", "owner_id"), &CollisionObject3D::shape_owner_get_transform);
+	ClassDB::bind_method(D_METHOD("shape_owner_get_owner", "owner_id"), &CollisionObject3D::shape_owner_get_owner);
+	ClassDB::bind_method(D_METHOD("shape_owner_set_disabled", "owner_id", "disabled"), &CollisionObject3D::shape_owner_set_disabled);
+	ClassDB::bind_method(D_METHOD("is_shape_owner_disabled", "owner_id"), &CollisionObject3D::is_shape_owner_disabled);
+	ClassDB::bind_method(D_METHOD("shape_owner_add_shape", "owner_id", "shape"), &CollisionObject3D::shape_owner_add_shape);
+	ClassDB::bind_method(D_METHOD("shape_owner_get_shape_count", "owner_id"), &CollisionObject3D::shape_owner_get_shape_count);
+	ClassDB::bind_method(D_METHOD("shape_owner_get_shape", "owner_id", "shape_id"), &CollisionObject3D::shape_owner_get_shape);
+	ClassDB::bind_method(D_METHOD("shape_owner_get_shape_index", "owner_id", "shape_id"), &CollisionObject3D::shape_owner_get_shape_index);
+	ClassDB::bind_method(D_METHOD("shape_owner_remove_shape", "owner_id", "shape_id"), &CollisionObject3D::shape_owner_remove_shape);
+	ClassDB::bind_method(D_METHOD("shape_owner_clear_shapes", "owner_id"), &CollisionObject3D::shape_owner_clear_shapes);
+	ClassDB::bind_method(D_METHOD("shape_find_owner", "shape_index"), &CollisionObject3D::shape_find_owner);
+
+	GDVIRTUAL_BIND(_input_event, "camera", "event", "position", "normal", "shape_idx");
+	GDVIRTUAL_BIND(_mouse_enter);
+	GDVIRTUAL_BIND(_mouse_exit);
+
+	ADD_SIGNAL(MethodInfo("input_event", PropertyInfo(Variant::OBJECT, "camera", PROPERTY_HINT_RESOURCE_TYPE, "Node"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), PropertyInfo(Variant::VECTOR3, "position"), PropertyInfo(Variant::VECTOR3, "normal"), PropertyInfo(Variant::INT, "shape_idx")));
+	ADD_SIGNAL(MethodInfo("mouse_entered"));
+	ADD_SIGNAL(MethodInfo("mouse_exited"));
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "disable_mode", PROPERTY_HINT_ENUM, "Remove,Make Static,Keep Active"), "set_disable_mode", "get_disable_mode");
+
+	ADD_GROUP("Collision", "collision_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision_priority"), "set_collision_priority", "get_collision_priority");
+
+	ADD_GROUP("Input", "input_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "input_ray_pickable"), "set_ray_pickable", "is_ray_pickable");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "input_capture_on_drag"), "set_capture_input_on_drag", "get_capture_input_on_drag");
+
+	BIND_ENUM_CONSTANT(DISABLE_MODE_REMOVE);
+	BIND_ENUM_CONSTANT(DISABLE_MODE_MAKE_STATIC);
+	BIND_ENUM_CONSTANT(DISABLE_MODE_KEEP_ACTIVE);
+}
+
+uint32_t CollisionObject3D::create_shape_owner(Object *p_owner) {
+	ShapeData sd;
+	uint32_t id;
+
+	if (shapes.size() == 0) {
+		id = 0;
+	} else {
+		id = shapes.back()->key() + 1;
+	}
+
+	sd.owner_id = p_owner ? p_owner->get_instance_id() : ObjectID();
+
+	shapes[id] = sd;
+
+	return id;
+}
+
+void CollisionObject3D::remove_shape_owner(uint32_t owner) {
+	ERR_FAIL_COND(!shapes.has(owner));
+
+	shape_owner_clear_shapes(owner);
+
+	shapes.erase(owner);
+}
+
+void CollisionObject3D::shape_owner_set_disabled(uint32_t p_owner, bool p_disabled) {
+	ERR_FAIL_COND(!shapes.has(p_owner));
+
+	ShapeData &sd = shapes[p_owner];
+	if (sd.disabled == p_disabled) {
+		return;
+	}
+	sd.disabled = p_disabled;
+
+	for (int i = 0; i < sd.shapes.size(); i++) {
+		if (area) {
+			PhysicsServer3D::get_singleton()->area_set_shape_disabled(rid, sd.shapes[i].index, p_disabled);
+		} else {
+			PhysicsServer3D::get_singleton()->body_set_shape_disabled(rid, sd.shapes[i].index, p_disabled);
+		}
+	}
+	_update_shape_data(p_owner);
+}
+
+bool CollisionObject3D::is_shape_owner_disabled(uint32_t p_owner) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), false);
+
+	return shapes[p_owner].disabled;
+}
+
+void CollisionObject3D::get_shape_owners(List<uint32_t> *r_owners) {
+	for (const KeyValue<uint32_t, ShapeData> &E : shapes) {
+		r_owners->push_back(E.key);
+	}
+}
+
+PackedInt32Array CollisionObject3D::_get_shape_owners() {
+	PackedInt32Array ret;
+	for (const KeyValue<uint32_t, ShapeData> &E : shapes) {
+		ret.push_back(E.key);
+	}
+
+	return ret;
+}
+
+void CollisionObject3D::shape_owner_set_transform(uint32_t p_owner, const Transform3D &p_transform) {
+	ERR_FAIL_COND(!shapes.has(p_owner));
+
+	ShapeData &sd = shapes[p_owner];
+	sd.xform = p_transform;
+	for (int i = 0; i < sd.shapes.size(); i++) {
+		if (area) {
+			PhysicsServer3D::get_singleton()->area_set_shape_transform(rid, sd.shapes[i].index, p_transform);
+		} else {
+			PhysicsServer3D::get_singleton()->body_set_shape_transform(rid, sd.shapes[i].index, p_transform);
+		}
+	}
+
+	_update_shape_data(p_owner);
+}
+Transform3D CollisionObject3D::shape_owner_get_transform(uint32_t p_owner) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), Transform3D());
+
+	return shapes[p_owner].xform;
+}
+
+Object *CollisionObject3D::shape_owner_get_owner(uint32_t p_owner) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), nullptr);
+
+	return ObjectDB::get_instance(shapes[p_owner].owner_id);
+}
+
+void CollisionObject3D::shape_owner_add_shape(uint32_t p_owner, const Ref<Shape3D> &p_shape) {
+	ERR_FAIL_COND(!shapes.has(p_owner));
+	ERR_FAIL_COND(p_shape.is_null());
+
+	ShapeData &sd = shapes[p_owner];
+	ShapeData::ShapeBase s;
+	s.index = total_subshapes;
+	s.shape = p_shape;
+
+	if (area) {
+		PhysicsServer3D::get_singleton()->area_add_shape(rid, p_shape->get_rid(), sd.xform, sd.disabled);
+	} else {
+		PhysicsServer3D::get_singleton()->body_add_shape(rid, p_shape->get_rid(), sd.xform, sd.disabled);
+	}
+	sd.shapes.push_back(s);
+
+	total_subshapes++;
+
+	_update_shape_data(p_owner);
+	update_gizmos();
+}
+
+int CollisionObject3D::shape_owner_get_shape_count(uint32_t p_owner) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), 0);
+
+	return shapes[p_owner].shapes.size();
+}
+
+Ref<Shape3D> CollisionObject3D::shape_owner_get_shape(uint32_t p_owner, int p_shape) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), Ref<Shape3D>());
+	ERR_FAIL_INDEX_V(p_shape, shapes[p_owner].shapes.size(), Ref<Shape3D>());
+
+	return shapes[p_owner].shapes[p_shape].shape;
+}
+
+int CollisionObject3D::shape_owner_get_shape_index(uint32_t p_owner, int p_shape) const {
+	ERR_FAIL_COND_V(!shapes.has(p_owner), -1);
+	ERR_FAIL_INDEX_V(p_shape, shapes[p_owner].shapes.size(), -1);
+
+	return shapes[p_owner].shapes[p_shape].index;
+}
+
+void CollisionObject3D::shape_owner_remove_shape(uint32_t p_owner, int p_shape) {
+	ERR_FAIL_NULL(RenderingServer::get_singleton());
+	ERR_FAIL_COND(!shapes.has(p_owner));
+	ERR_FAIL_INDEX(p_shape, shapes[p_owner].shapes.size());
+
+	ShapeData::ShapeBase &s = shapes[p_owner].shapes.write[p_shape];
+	int index_to_remove = s.index;
+
+	if (area) {
+		PhysicsServer3D::get_singleton()->area_remove_shape(rid, index_to_remove);
+	} else {
+		PhysicsServer3D::get_singleton()->body_remove_shape(rid, index_to_remove);
+	}
+
+	if (s.debug_shape.is_valid()) {
+		RS::get_singleton()->free(s.debug_shape);
+		if (s.shape.is_valid()) {
+			s.shape->disconnect_changed(callable_mp(this, &CollisionObject3D::_shape_changed));
+		}
+		--debug_shapes_count;
+	}
+
+	shapes[p_owner].shapes.remove_at(p_shape);
+
+	for (KeyValue<uint32_t, ShapeData> &E : shapes) {
+		for (int i = 0; i < E.value.shapes.size(); i++) {
+			if (E.value.shapes[i].index > index_to_remove) {
+				E.value.shapes.write[i].index -= 1;
+			}
+		}
+	}
+
+	total_subshapes--;
+}
+
+void CollisionObject3D::shape_owner_clear_shapes(uint32_t p_owner) {
+	ERR_FAIL_COND(!shapes.has(p_owner));
+
+	while (shape_owner_get_shape_count(p_owner) > 0) {
+		shape_owner_remove_shape(p_owner, 0);
+	}
+
+	update_gizmos();
+}
+
+uint32_t CollisionObject3D::shape_find_owner(int p_shape_index) const {
+	ERR_FAIL_INDEX_V(p_shape_index, total_subshapes, UINT32_MAX);
+
+	for (const KeyValue<uint32_t, ShapeData> &E : shapes) {
+		for (int i = 0; i < E.value.shapes.size(); i++) {
+			if (E.value.shapes[i].index == p_shape_index) {
+				return E.key;
+			}
+		}
+	}
+
+	//in theory it should be unreachable
+	ERR_FAIL_V_MSG(UINT32_MAX, "Can't find owner for shape index " + itos(p_shape_index) + ".");
+}
+
+CollisionObject3D::CollisionObject3D(RID p_rid, bool p_area) {
+	rid = p_rid;
+	area = p_area;
+	set_notify_transform(true);
+
+	if (p_area) {
+		PhysicsServer3D::get_singleton()->area_attach_object_instance_id(rid, get_instance_id());
+	} else {
+		PhysicsServer3D::get_singleton()->body_attach_object_instance_id(rid, get_instance_id());
+		PhysicsServer3D::get_singleton()->body_set_mode(rid, body_mode);
+	}
+}
+
+void CollisionObject3D::set_capture_input_on_drag(bool p_capture) {
+	capture_input_on_drag = p_capture;
+}
+
+bool CollisionObject3D::get_capture_input_on_drag() const {
+	return capture_input_on_drag;
+}
+
+PackedStringArray CollisionObject3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node::get_configuration_warnings();
+
+	if (shapes.is_empty()) {
+		warnings.push_back(RTR("This node has no shape, so it can't collide or interact with other objects.\nConsider adding a CollisionShape3D or CollisionPolygon3D as a child to define its shape."));
+	}
+
+	Vector3 scale = get_transform().get_basis().get_scale();
+	if (!(Math::is_zero_approx(scale.x - scale.y) && Math::is_zero_approx(scale.y - scale.z))) {
+		warnings.push_back(RTR("With a non-uniform scale this node will probably not function as expected.\nPlease make its scale uniform (i.e. the same on all axes), and change the size in children collision shapes instead."));
+	}
+
+	return warnings;
+}
+
+CollisionObject3D::CollisionObject3D() {
+	set_notify_transform(true);
+	//owner=
+
+	//set_transform_notify(true);
+}
+
+CollisionObject3D::~CollisionObject3D() {
+	ERR_FAIL_NULL(PhysicsServer3D::get_singleton());
+	PhysicsServer3D::get_singleton()->free(rid);
+}
diff --git a/scene/3d/physics/collision_object_3d.h b/scene/3d/physics/collision_object_3d.h
new file mode 100644
index 0000000000..b51423f021
--- /dev/null
+++ b/scene/3d/physics/collision_object_3d.h
@@ -0,0 +1,184 @@
+/**************************************************************************/
+/*  collision_object_3d.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef COLLISION_OBJECT_3D_H
+#define COLLISION_OBJECT_3D_H
+
+#include "scene/3d/camera_3d.h"
+#include "scene/3d/node_3d.h"
+
+class CollisionObject3D : public Node3D {
+	GDCLASS(CollisionObject3D, Node3D);
+
+public:
+	enum DisableMode {
+		DISABLE_MODE_REMOVE,
+		DISABLE_MODE_MAKE_STATIC,
+		DISABLE_MODE_KEEP_ACTIVE,
+	};
+
+private:
+	uint32_t collision_layer = 1;
+	uint32_t collision_mask = 1;
+	real_t collision_priority = 1.0;
+
+	bool area = false;
+
+	RID rid;
+	uint32_t callback_lock = 0;
+
+	DisableMode disable_mode = DISABLE_MODE_REMOVE;
+
+	PhysicsServer3D::BodyMode body_mode = PhysicsServer3D::BODY_MODE_STATIC;
+
+	struct ShapeData {
+		ObjectID owner_id;
+		Transform3D xform;
+		struct ShapeBase {
+			RID debug_shape;
+			Ref<Shape3D> shape;
+			int index = 0;
+		};
+
+		Vector<ShapeBase> shapes;
+		bool disabled = false;
+	};
+
+	int total_subshapes = 0;
+
+	RBMap<uint32_t, ShapeData> shapes;
+
+	bool only_update_transform_changes = false; // This is used for sync to physics.
+
+	bool capture_input_on_drag = false;
+	bool ray_pickable = true;
+
+	HashSet<uint32_t> debug_shapes_to_update;
+	int debug_shapes_count = 0;
+	Transform3D debug_shape_old_transform;
+
+	void _update_pickable();
+
+	bool _are_collision_shapes_visible();
+	void _update_shape_data(uint32_t p_owner);
+	void _shape_changed(const Ref<Shape3D> &p_shape);
+	void _update_debug_shapes();
+	void _clear_debug_shapes();
+
+	void _apply_disabled();
+	void _apply_enabled();
+
+protected:
+	CollisionObject3D(RID p_rid, bool p_area);
+
+	_FORCE_INLINE_ void lock_callback() { callback_lock++; }
+	_FORCE_INLINE_ void unlock_callback() {
+		ERR_FAIL_COND(callback_lock == 0);
+		callback_lock--;
+	}
+
+	void _notification(int p_what);
+	static void _bind_methods();
+
+	void _on_transform_changed();
+
+	friend class Viewport;
+	virtual void _input_event_call(Camera3D *p_camera, const Ref<InputEvent> &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape);
+	virtual void _mouse_enter();
+	virtual void _mouse_exit();
+
+	void set_body_mode(PhysicsServer3D::BodyMode p_mode);
+
+	virtual void _space_changed(const RID &p_new_space);
+
+	void set_only_update_transform_changes(bool p_enable);
+	bool is_only_update_transform_changes_enabled() const;
+
+	GDVIRTUAL5(_input_event, Camera3D *, Ref<InputEvent>, Vector3, Vector3, int)
+	GDVIRTUAL0(_mouse_enter)
+	GDVIRTUAL0(_mouse_exit)
+public:
+	void set_collision_layer(uint32_t p_layer);
+	uint32_t get_collision_layer() const;
+
+	void set_collision_mask(uint32_t p_mask);
+	uint32_t get_collision_mask() const;
+
+	void set_collision_layer_value(int p_layer_number, bool p_value);
+	bool get_collision_layer_value(int p_layer_number) const;
+
+	void set_collision_mask_value(int p_layer_number, bool p_value);
+	bool get_collision_mask_value(int p_layer_number) const;
+
+	void set_collision_priority(real_t p_priority);
+	real_t get_collision_priority() const;
+
+	void set_disable_mode(DisableMode p_mode);
+	DisableMode get_disable_mode() const;
+
+	uint32_t create_shape_owner(Object *p_owner);
+	void remove_shape_owner(uint32_t owner);
+	void get_shape_owners(List<uint32_t> *r_owners);
+	PackedInt32Array _get_shape_owners();
+
+	void shape_owner_set_transform(uint32_t p_owner, const Transform3D &p_transform);
+	Transform3D shape_owner_get_transform(uint32_t p_owner) const;
+	Object *shape_owner_get_owner(uint32_t p_owner) const;
+
+	void shape_owner_set_disabled(uint32_t p_owner, bool p_disabled);
+	bool is_shape_owner_disabled(uint32_t p_owner) const;
+
+	void shape_owner_add_shape(uint32_t p_owner, const Ref<Shape3D> &p_shape);
+	int shape_owner_get_shape_count(uint32_t p_owner) const;
+	Ref<Shape3D> shape_owner_get_shape(uint32_t p_owner, int p_shape) const;
+	int shape_owner_get_shape_index(uint32_t p_owner, int p_shape) const;
+
+	void shape_owner_remove_shape(uint32_t p_owner, int p_shape);
+	void shape_owner_clear_shapes(uint32_t p_owner);
+
+	uint32_t shape_find_owner(int p_shape_index) const;
+
+	void set_ray_pickable(bool p_ray_pickable);
+	bool is_ray_pickable() const;
+
+	void set_capture_input_on_drag(bool p_capture);
+	bool get_capture_input_on_drag() const;
+
+	_FORCE_INLINE_ RID get_rid() const { return rid; }
+
+	PackedStringArray get_configuration_warnings() const override;
+
+	CollisionObject3D();
+	~CollisionObject3D();
+};
+
+VARIANT_ENUM_CAST(CollisionObject3D::DisableMode);
+
+#endif // COLLISION_OBJECT_3D_H
diff --git a/scene/3d/physics/collision_polygon_3d.cpp b/scene/3d/physics/collision_polygon_3d.cpp
new file mode 100644
index 0000000000..76cd4db779
--- /dev/null
+++ b/scene/3d/physics/collision_polygon_3d.cpp
@@ -0,0 +1,217 @@
+/**************************************************************************/
+/*  collision_polygon_3d.cpp                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "collision_polygon_3d.h"
+
+#include "core/math/geometry_2d.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/resources/3d/convex_polygon_shape_3d.h"
+
+void CollisionPolygon3D::_build_polygon() {
+	if (!collision_object) {
+		return;
+	}
+
+	collision_object->shape_owner_clear_shapes(owner_id);
+
+	if (polygon.size() == 0) {
+		return;
+	}
+
+	Vector<Vector<Vector2>> decomp = Geometry2D::decompose_polygon_in_convex(polygon);
+	if (decomp.size() == 0) {
+		return;
+	}
+
+	//here comes the sun, lalalala
+	//decompose concave into multiple convex polygons and add them
+
+	for (int i = 0; i < decomp.size(); i++) {
+		Ref<ConvexPolygonShape3D> convex = memnew(ConvexPolygonShape3D);
+		Vector<Vector3> cp;
+		int cs = decomp[i].size();
+		cp.resize(cs * 2);
+		{
+			Vector3 *w = cp.ptrw();
+			int idx = 0;
+			for (int j = 0; j < cs; j++) {
+				Vector2 d = decomp[i][j];
+				w[idx++] = Vector3(d.x, d.y, depth * 0.5);
+				w[idx++] = Vector3(d.x, d.y, -depth * 0.5);
+			}
+		}
+
+		convex->set_points(cp);
+		convex->set_margin(margin);
+		collision_object->shape_owner_add_shape(owner_id, convex);
+		collision_object->shape_owner_set_disabled(owner_id, disabled);
+	}
+}
+
+void CollisionPolygon3D::_update_in_shape_owner(bool p_xform_only) {
+	collision_object->shape_owner_set_transform(owner_id, get_transform());
+	if (p_xform_only) {
+		return;
+	}
+	collision_object->shape_owner_set_disabled(owner_id, disabled);
+}
+
+void CollisionPolygon3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_PARENTED: {
+			collision_object = Object::cast_to<CollisionObject3D>(get_parent());
+			if (collision_object) {
+				owner_id = collision_object->create_shape_owner(this);
+				_build_polygon();
+				_update_in_shape_owner();
+			}
+		} break;
+
+		case NOTIFICATION_ENTER_TREE: {
+			if (collision_object) {
+				_update_in_shape_owner();
+			}
+		} break;
+
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+			if (collision_object) {
+				_update_in_shape_owner(true);
+			}
+			update_configuration_warnings();
+		} break;
+
+		case NOTIFICATION_UNPARENTED: {
+			if (collision_object) {
+				collision_object->remove_shape_owner(owner_id);
+			}
+			owner_id = 0;
+			collision_object = nullptr;
+		} break;
+	}
+}
+
+void CollisionPolygon3D::set_polygon(const Vector<Point2> &p_polygon) {
+	polygon = p_polygon;
+	if (collision_object) {
+		_build_polygon();
+	}
+	update_configuration_warnings();
+	update_gizmos();
+}
+
+Vector<Point2> CollisionPolygon3D::get_polygon() const {
+	return polygon;
+}
+
+AABB CollisionPolygon3D::get_item_rect() const {
+	return aabb;
+}
+
+void CollisionPolygon3D::set_depth(real_t p_depth) {
+	depth = p_depth;
+	_build_polygon();
+	update_gizmos();
+}
+
+real_t CollisionPolygon3D::get_depth() const {
+	return depth;
+}
+
+void CollisionPolygon3D::set_disabled(bool p_disabled) {
+	disabled = p_disabled;
+	update_gizmos();
+
+	if (collision_object) {
+		collision_object->shape_owner_set_disabled(owner_id, p_disabled);
+	}
+}
+
+bool CollisionPolygon3D::is_disabled() const {
+	return disabled;
+}
+
+real_t CollisionPolygon3D::get_margin() const {
+	return margin;
+}
+
+void CollisionPolygon3D::set_margin(real_t p_margin) {
+	margin = p_margin;
+	if (collision_object) {
+		_build_polygon();
+	}
+}
+
+PackedStringArray CollisionPolygon3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node::get_configuration_warnings();
+
+	if (!Object::cast_to<CollisionObject3D>(get_parent())) {
+		warnings.push_back(RTR("CollisionPolygon3D only serves to provide a collision shape to a CollisionObject3D derived node.\nPlease only use it as a child of Area3D, StaticBody3D, RigidBody3D, CharacterBody3D, etc. to give them a shape."));
+	}
+
+	if (polygon.is_empty()) {
+		warnings.push_back(RTR("An empty CollisionPolygon3D has no effect on collision."));
+	}
+
+	Vector3 scale = get_transform().get_basis().get_scale();
+	if (!(Math::is_zero_approx(scale.x - scale.y) && Math::is_zero_approx(scale.y - scale.z))) {
+		warnings.push_back(RTR("A non-uniformly scaled CollisionPolygon3D node will probably not function as expected.\nPlease make its scale uniform (i.e. the same on all axes), and change its polygon's vertices instead."));
+	}
+
+	return warnings;
+}
+
+bool CollisionPolygon3D::_is_editable_3d_polygon() const {
+	return true;
+}
+
+void CollisionPolygon3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_depth", "depth"), &CollisionPolygon3D::set_depth);
+	ClassDB::bind_method(D_METHOD("get_depth"), &CollisionPolygon3D::get_depth);
+
+	ClassDB::bind_method(D_METHOD("set_polygon", "polygon"), &CollisionPolygon3D::set_polygon);
+	ClassDB::bind_method(D_METHOD("get_polygon"), &CollisionPolygon3D::get_polygon);
+
+	ClassDB::bind_method(D_METHOD("set_disabled", "disabled"), &CollisionPolygon3D::set_disabled);
+	ClassDB::bind_method(D_METHOD("is_disabled"), &CollisionPolygon3D::is_disabled);
+
+	ClassDB::bind_method(D_METHOD("set_margin", "margin"), &CollisionPolygon3D::set_margin);
+	ClassDB::bind_method(D_METHOD("get_margin"), &CollisionPolygon3D::get_margin);
+
+	ClassDB::bind_method(D_METHOD("_is_editable_3d_polygon"), &CollisionPolygon3D::_is_editable_3d_polygon);
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "depth", PROPERTY_HINT_NONE, "suffix:m"), "set_depth", "get_depth");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
+	ADD_PROPERTY(PropertyInfo(Variant::PACKED_VECTOR2_ARRAY, "polygon"), "set_polygon", "get_polygon");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "margin", PROPERTY_HINT_RANGE, "0.001,10,0.001,suffix:m"), "set_margin", "get_margin");
+}
+
+CollisionPolygon3D::CollisionPolygon3D() {
+	set_notify_local_transform(true);
+}
diff --git a/scene/3d/physics/collision_polygon_3d.h b/scene/3d/physics/collision_polygon_3d.h
new file mode 100644
index 0000000000..fe4cf40ee3
--- /dev/null
+++ b/scene/3d/physics/collision_polygon_3d.h
@@ -0,0 +1,82 @@
+/**************************************************************************/
+/*  collision_polygon_3d.h                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef COLLISION_POLYGON_3D_H
+#define COLLISION_POLYGON_3D_H
+
+#include "scene/3d/node_3d.h"
+#include "scene/resources/3d/shape_3d.h"
+
+class CollisionObject3D;
+class CollisionPolygon3D : public Node3D {
+	GDCLASS(CollisionPolygon3D, Node3D);
+	real_t margin = 0.04;
+
+protected:
+	real_t depth = 1.0;
+	AABB aabb = AABB(Vector3(-1, -1, -1), Vector3(2, 2, 2));
+	Vector<Point2> polygon;
+
+	uint32_t owner_id = 0;
+	CollisionObject3D *collision_object = nullptr;
+
+	bool disabled = false;
+
+	void _build_polygon();
+
+	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();
+
+public:
+	void set_depth(real_t p_depth);
+	real_t get_depth() const;
+
+	void set_polygon(const Vector<Point2> &p_polygon);
+	Vector<Point2> get_polygon() const;
+
+	void set_disabled(bool p_disabled);
+	bool is_disabled() const;
+
+	virtual AABB get_item_rect() const;
+
+	real_t get_margin() const;
+	void set_margin(real_t p_margin);
+
+	PackedStringArray get_configuration_warnings() const override;
+
+	CollisionPolygon3D();
+};
+
+#endif // COLLISION_POLYGON_3D_H
diff --git a/scene/3d/physics/collision_shape_3d.cpp b/scene/3d/physics/collision_shape_3d.cpp
new file mode 100644
index 0000000000..f3492a3cf3
--- /dev/null
+++ b/scene/3d/physics/collision_shape_3d.cpp
@@ -0,0 +1,225 @@
+/**************************************************************************/
+/*  collision_shape_3d.cpp                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "collision_shape_3d.h"
+
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/character_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/vehicle_body_3d.h"
+#include "scene/resources/3d/concave_polygon_shape_3d.h"
+#include "scene/resources/3d/convex_polygon_shape_3d.h"
+#include "scene/resources/3d/world_boundary_shape_3d.h"
+
+void CollisionShape3D::make_convex_from_siblings() {
+	Node *p = get_parent();
+	if (!p) {
+		return;
+	}
+
+	Vector<Vector3> vertices;
+
+	for (int i = 0; i < p->get_child_count(); i++) {
+		Node *n = p->get_child(i);
+		MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(n);
+		if (mi) {
+			Ref<Mesh> m = mi->get_mesh();
+			if (m.is_valid()) {
+				for (int j = 0; j < m->get_surface_count(); j++) {
+					Array a = m->surface_get_arrays(j);
+					if (!a.is_empty()) {
+						Vector<Vector3> v = a[RenderingServer::ARRAY_VERTEX];
+						for (int k = 0; k < v.size(); k++) {
+							vertices.append(mi->get_transform().xform(v[k]));
+						}
+					}
+				}
+			}
+		}
+	}
+
+	Ref<ConvexPolygonShape3D> shape_new = memnew(ConvexPolygonShape3D);
+	shape_new->set_points(vertices);
+	set_shape(shape_new);
+}
+
+void CollisionShape3D::_update_in_shape_owner(bool p_xform_only) {
+	collision_object->shape_owner_set_transform(owner_id, get_transform());
+	if (p_xform_only) {
+		return;
+	}
+	collision_object->shape_owner_set_disabled(owner_id, disabled);
+}
+
+void CollisionShape3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_PARENTED: {
+			collision_object = Object::cast_to<CollisionObject3D>(get_parent());
+			if (collision_object) {
+				owner_id = collision_object->create_shape_owner(this);
+				if (shape.is_valid()) {
+					collision_object->shape_owner_add_shape(owner_id, shape);
+				}
+				_update_in_shape_owner();
+			}
+		} break;
+
+		case NOTIFICATION_ENTER_TREE: {
+			if (collision_object) {
+				_update_in_shape_owner();
+			}
+		} break;
+
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+			if (collision_object) {
+				_update_in_shape_owner(true);
+			}
+			update_configuration_warnings();
+		} break;
+
+		case NOTIFICATION_UNPARENTED: {
+			if (collision_object) {
+				collision_object->remove_shape_owner(owner_id);
+			}
+			owner_id = 0;
+			collision_object = nullptr;
+		} break;
+	}
+}
+
+#ifndef DISABLE_DEPRECATED
+void CollisionShape3D::resource_changed(Ref<Resource> res) {
+}
+#endif
+
+PackedStringArray CollisionShape3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node::get_configuration_warnings();
+
+	CollisionObject3D *col_object = Object::cast_to<CollisionObject3D>(get_parent());
+	if (col_object == nullptr) {
+		warnings.push_back(RTR("CollisionShape3D only serves to provide a collision shape to a CollisionObject3D derived node.\nPlease only use it as a child of Area3D, StaticBody3D, RigidBody3D, CharacterBody3D, etc. to give them a shape."));
+	}
+
+	if (!shape.is_valid()) {
+		warnings.push_back(RTR("A shape must be provided for CollisionShape3D to function. Please create a shape resource for it."));
+	}
+
+	if (shape.is_valid() && Object::cast_to<RigidBody3D>(col_object)) {
+		String body_type = "RigidBody3D";
+		if (Object::cast_to<VehicleBody3D>(col_object)) {
+			body_type = "VehicleBody3D";
+		}
+
+		if (Object::cast_to<ConcavePolygonShape3D>(*shape)) {
+			warnings.push_back(vformat(RTR("When used for collision, ConcavePolygonShape3D is intended to work with static CollisionObject3D nodes like StaticBody3D.\nIt will likely not behave well for %ss (except when frozen and freeze_mode set to FREEZE_MODE_STATIC)."), body_type));
+		} else if (Object::cast_to<WorldBoundaryShape3D>(*shape)) {
+			warnings.push_back(RTR("WorldBoundaryShape3D doesn't support RigidBody3D in another mode than static."));
+		}
+	}
+
+	if (shape.is_valid() && Object::cast_to<CharacterBody3D>(col_object)) {
+		if (Object::cast_to<ConcavePolygonShape3D>(*shape)) {
+			warnings.push_back(RTR("When used for collision, ConcavePolygonShape3D is intended to work with static CollisionObject3D nodes like StaticBody3D.\nIt will likely not behave well for CharacterBody3Ds."));
+		}
+	}
+
+	Vector3 scale = get_transform().get_basis().get_scale();
+	if (!(Math::is_zero_approx(scale.x - scale.y) && Math::is_zero_approx(scale.y - scale.z))) {
+		warnings.push_back(RTR("A non-uniformly scaled CollisionShape3D node will probably not function as expected.\nPlease make its scale uniform (i.e. the same on all axes), and change the size of its shape resource instead."));
+	}
+
+	return warnings;
+}
+
+void CollisionShape3D::_bind_methods() {
+#ifndef DISABLE_DEPRECATED
+	ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &CollisionShape3D::resource_changed);
+#endif
+	ClassDB::bind_method(D_METHOD("set_shape", "shape"), &CollisionShape3D::set_shape);
+	ClassDB::bind_method(D_METHOD("get_shape"), &CollisionShape3D::get_shape);
+	ClassDB::bind_method(D_METHOD("set_disabled", "enable"), &CollisionShape3D::set_disabled);
+	ClassDB::bind_method(D_METHOD("is_disabled"), &CollisionShape3D::is_disabled);
+	ClassDB::bind_method(D_METHOD("make_convex_from_siblings"), &CollisionShape3D::make_convex_from_siblings);
+	ClassDB::set_method_flags("CollisionShape3D", "make_convex_from_siblings", METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape3D"), "set_shape", "get_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
+}
+
+void CollisionShape3D::set_shape(const Ref<Shape3D> &p_shape) {
+	if (p_shape == shape) {
+		return;
+	}
+	if (shape.is_valid()) {
+		shape->disconnect_changed(callable_mp((Node3D *)this, &Node3D::update_gizmos));
+	}
+	shape = p_shape;
+	if (shape.is_valid()) {
+		shape->connect_changed(callable_mp((Node3D *)this, &Node3D::update_gizmos));
+	}
+	update_gizmos();
+	if (collision_object) {
+		collision_object->shape_owner_clear_shapes(owner_id);
+		if (shape.is_valid()) {
+			collision_object->shape_owner_add_shape(owner_id, shape);
+		}
+	}
+
+	if (is_inside_tree() && collision_object) {
+		// If this is a heightfield shape our center may have changed
+		_update_in_shape_owner(true);
+	}
+	update_configuration_warnings();
+}
+
+Ref<Shape3D> CollisionShape3D::get_shape() const {
+	return shape;
+}
+
+void CollisionShape3D::set_disabled(bool p_disabled) {
+	disabled = p_disabled;
+	update_gizmos();
+	if (collision_object) {
+		collision_object->shape_owner_set_disabled(owner_id, p_disabled);
+	}
+}
+
+bool CollisionShape3D::is_disabled() const {
+	return disabled;
+}
+
+CollisionShape3D::CollisionShape3D() {
+	//indicator = RenderingServer::get_singleton()->mesh_create();
+	set_notify_local_transform(true);
+}
+
+CollisionShape3D::~CollisionShape3D() {
+	//RenderingServer::get_singleton()->free(indicator);
+}
diff --git a/scene/3d/physics/collision_shape_3d.h b/scene/3d/physics/collision_shape_3d.h
new file mode 100644
index 0000000000..15f6ef73cb
--- /dev/null
+++ b/scene/3d/physics/collision_shape_3d.h
@@ -0,0 +1,73 @@
+/**************************************************************************/
+/*  collision_shape_3d.h                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef COLLISION_SHAPE_3D_H
+#define COLLISION_SHAPE_3D_H
+
+#include "scene/3d/node_3d.h"
+#include "scene/resources/3d/shape_3d.h"
+
+class CollisionObject3D;
+class CollisionShape3D : public Node3D {
+	GDCLASS(CollisionShape3D, Node3D);
+
+	Ref<Shape3D> shape;
+
+	uint32_t owner_id = 0;
+	CollisionObject3D *collision_object = nullptr;
+
+#ifndef DISABLE_DEPRECATED
+	void resource_changed(Ref<Resource> res);
+#endif
+	bool disabled = false;
+
+protected:
+	void _update_in_shape_owner(bool p_xform_only = false);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void make_convex_from_siblings();
+
+	void set_shape(const Ref<Shape3D> &p_shape);
+	Ref<Shape3D> get_shape() const;
+
+	void set_disabled(bool p_disabled);
+	bool is_disabled() const;
+
+	PackedStringArray get_configuration_warnings() const override;
+
+	CollisionShape3D();
+	~CollisionShape3D();
+};
+
+#endif // COLLISION_SHAPE_3D_H
diff --git a/scene/3d/physics/joints/SCsub b/scene/3d/physics/joints/SCsub
new file mode 100644
index 0000000000..fc61250247
--- /dev/null
+++ b/scene/3d/physics/joints/SCsub
@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env.add_source_files(env.scene_sources, "*.cpp")
diff --git a/scene/3d/physics/joints/cone_twist_joint_3d.cpp b/scene/3d/physics/joints/cone_twist_joint_3d.cpp
new file mode 100644
index 0000000000..404c074911
--- /dev/null
+++ b/scene/3d/physics/joints/cone_twist_joint_3d.cpp
@@ -0,0 +1,97 @@
+/**************************************************************************/
+/*  cone_twist_joint_3d.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "cone_twist_joint_3d.h"
+
+#include "scene/scene_string_names.h"
+
+void ConeTwistJoint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &ConeTwistJoint3D::set_param);
+	ClassDB::bind_method(D_METHOD("get_param", "param"), &ConeTwistJoint3D::get_param);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "swing_span", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_SWING_SPAN);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "twist_span", PROPERTY_HINT_RANGE, "-40000,40000,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_TWIST_SPAN);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "bias", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_BIAS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "relaxation", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_RELAXATION);
+
+	BIND_ENUM_CONSTANT(PARAM_SWING_SPAN);
+	BIND_ENUM_CONSTANT(PARAM_TWIST_SPAN);
+	BIND_ENUM_CONSTANT(PARAM_BIAS);
+	BIND_ENUM_CONSTANT(PARAM_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_RELAXATION);
+	BIND_ENUM_CONSTANT(PARAM_MAX);
+}
+
+void ConeTwistJoint3D::set_param(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(get_rid(), PhysicsServer3D::ConeTwistJointParam(p_param), p_value);
+	}
+
+	update_gizmos();
+}
+
+real_t ConeTwistJoint3D::get_param(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params[p_param];
+}
+
+void ConeTwistJoint3D::_configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) {
+	Transform3D gt = get_global_transform();
+
+	Transform3D ainv = body_a->get_global_transform().affine_inverse();
+
+	Transform3D local_a = ainv * gt;
+	local_a.orthonormalize();
+	Transform3D local_b = gt;
+
+	if (body_b) {
+		Transform3D binv = body_b->get_global_transform().affine_inverse();
+		local_b = binv * gt;
+	}
+
+	local_b.orthonormalize();
+
+	PhysicsServer3D::get_singleton()->joint_make_cone_twist(p_joint, body_a->get_rid(), local_a, body_b ? body_b->get_rid() : RID(), local_b);
+	for (int i = 0; i < PARAM_MAX; i++) {
+		PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(p_joint, PhysicsServer3D::ConeTwistJointParam(i), params[i]);
+	}
+}
+
+ConeTwistJoint3D::ConeTwistJoint3D() {
+	params[PARAM_SWING_SPAN] = Math_PI * 0.25;
+	params[PARAM_TWIST_SPAN] = Math_PI;
+	params[PARAM_BIAS] = 0.3;
+	params[PARAM_SOFTNESS] = 0.8;
+	params[PARAM_RELAXATION] = 1.0;
+}
diff --git a/scene/3d/physics/joints/cone_twist_joint_3d.h b/scene/3d/physics/joints/cone_twist_joint_3d.h
new file mode 100644
index 0000000000..a24c805390
--- /dev/null
+++ b/scene/3d/physics/joints/cone_twist_joint_3d.h
@@ -0,0 +1,63 @@
+/**************************************************************************/
+/*  cone_twist_joint_3d.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef CONE_TWIST_JOINT_3D_H
+#define CONE_TWIST_JOINT_3D_H
+
+#include "scene/3d/physics/joints/joint_3d.h"
+
+class ConeTwistJoint3D : public Joint3D {
+	GDCLASS(ConeTwistJoint3D, Joint3D);
+
+public:
+	enum Param {
+		PARAM_SWING_SPAN,
+		PARAM_TWIST_SPAN,
+		PARAM_BIAS,
+		PARAM_SOFTNESS,
+		PARAM_RELAXATION,
+		PARAM_MAX
+	};
+
+protected:
+	real_t params[PARAM_MAX];
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_param(Param p_param, real_t p_value);
+	real_t get_param(Param p_param) const;
+
+	ConeTwistJoint3D();
+};
+
+VARIANT_ENUM_CAST(ConeTwistJoint3D::Param);
+
+#endif // CONE_TWIST_JOINT_3D_H
diff --git a/scene/3d/physics/joints/generic_6dof_joint_3d.cpp b/scene/3d/physics/joints/generic_6dof_joint_3d.cpp
new file mode 100644
index 0000000000..9f440b65cc
--- /dev/null
+++ b/scene/3d/physics/joints/generic_6dof_joint_3d.cpp
@@ -0,0 +1,405 @@
+/**************************************************************************/
+/*  generic_6dof_joint_3d.cpp                                             */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "generic_6dof_joint_3d.h"
+
+void Generic6DOFJoint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_param_x", "param", "value"), &Generic6DOFJoint3D::set_param_x);
+	ClassDB::bind_method(D_METHOD("get_param_x", "param"), &Generic6DOFJoint3D::get_param_x);
+
+	ClassDB::bind_method(D_METHOD("set_param_y", "param", "value"), &Generic6DOFJoint3D::set_param_y);
+	ClassDB::bind_method(D_METHOD("get_param_y", "param"), &Generic6DOFJoint3D::get_param_y);
+
+	ClassDB::bind_method(D_METHOD("set_param_z", "param", "value"), &Generic6DOFJoint3D::set_param_z);
+	ClassDB::bind_method(D_METHOD("get_param_z", "param"), &Generic6DOFJoint3D::get_param_z);
+
+	ClassDB::bind_method(D_METHOD("set_flag_x", "flag", "value"), &Generic6DOFJoint3D::set_flag_x);
+	ClassDB::bind_method(D_METHOD("get_flag_x", "flag"), &Generic6DOFJoint3D::get_flag_x);
+
+	ClassDB::bind_method(D_METHOD("set_flag_y", "flag", "value"), &Generic6DOFJoint3D::set_flag_y);
+	ClassDB::bind_method(D_METHOD("get_flag_y", "flag"), &Generic6DOFJoint3D::get_flag_y);
+
+	ClassDB::bind_method(D_METHOD("set_flag_z", "flag", "value"), &Generic6DOFJoint3D::set_flag_z);
+	ClassDB::bind_method(D_METHOD("get_flag_z", "flag"), &Generic6DOFJoint3D::get_flag_z);
+
+	ADD_GROUP("Linear Limit", "linear_limit_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_limit_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_LINEAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_x/upper_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_x", "get_param_x", PARAM_LINEAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_x/lower_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_x", "get_param_x", PARAM_LINEAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "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::FLOAT, "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::FLOAT, "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_limit_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_LINEAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_y/upper_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_y", "get_param_y", PARAM_LINEAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_y/lower_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_y", "get_param_y", PARAM_LINEAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "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::FLOAT, "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::FLOAT, "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_limit_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_LINEAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_z/upper_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_z", "get_param_z", PARAM_LINEAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit_z/lower_distance", PROPERTY_HINT_NONE, "suffix:m"), "set_param_z", "get_param_z", PARAM_LINEAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "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::FLOAT, "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::FLOAT, "linear_limit_z/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_LINEAR_DAMPING);
+
+	ADD_GROUP("Linear Motor", "linear_motor_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_x/target_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_param_x", "get_param_x", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_x/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m/s\u00B2 (N)"), "set_param_x", "get_param_x", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_y/target_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_param_y", "get_param_y", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_y/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m/s\u00B2 (N)"), "set_param_y", "get_param_y", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_motor_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_LINEAR_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_z/target_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_param_z", "get_param_z", PARAM_LINEAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motor_z/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m/s\u00B2 (N)"), "set_param_z", "get_param_z", PARAM_LINEAR_MOTOR_FORCE_LIMIT);
+
+	ADD_GROUP("Linear Spring", "linear_spring_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_spring_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_LINEAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_x/stiffness"), "set_param_x", "get_param_x", PARAM_LINEAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_x/damping"), "set_param_x", "get_param_x", PARAM_LINEAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_x/equilibrium_point", PROPERTY_HINT_NONE, "suffix:m"), "set_param_x", "get_param_x", PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_spring_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_LINEAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_y/stiffness"), "set_param_y", "get_param_y", PARAM_LINEAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_y/damping"), "set_param_y", "get_param_y", PARAM_LINEAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_y/equilibrium_point", PROPERTY_HINT_NONE, "suffix:m"), "set_param_y", "get_param_y", PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "linear_spring_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_LINEAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_z/stiffness"), "set_param_z", "get_param_z", PARAM_LINEAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_z/damping"), "set_param_z", "get_param_z", PARAM_LINEAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_spring_z/equilibrium_point", PROPERTY_HINT_NONE, "suffix:m"), "set_param_z", "get_param_z", PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT);
+
+	ADD_GROUP("Angular Limit", "angular_limit_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_ANGULAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_x", "get_param_x", PARAM_ANGULAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_x", "get_param_x", PARAM_ANGULAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_ANGULAR_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_ANGULAR_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_x", "get_param_x", PARAM_ANGULAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_x", "get_param_x", PARAM_ANGULAR_FORCE_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_x/erp"), "set_param_x", "get_param_x", PARAM_ANGULAR_ERP);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_ANGULAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_y", "get_param_y", PARAM_ANGULAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_y", "get_param_y", PARAM_ANGULAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_ANGULAR_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_ANGULAR_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_y", "get_param_y", PARAM_ANGULAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_y", "get_param_y", PARAM_ANGULAR_FORCE_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_y/erp"), "set_param_y", "get_param_y", PARAM_ANGULAR_ERP);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_ANGULAR_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_z", "get_param_z", PARAM_ANGULAR_UPPER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_z", "get_param_z", PARAM_ANGULAR_LOWER_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_ANGULAR_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_ANGULAR_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/damping", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param_z", "get_param_z", PARAM_ANGULAR_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_z", "get_param_z", PARAM_ANGULAR_FORCE_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit_z/erp"), "set_param_z", "get_param_z", PARAM_ANGULAR_ERP);
+
+	ADD_GROUP("Angular Motor", "angular_motor_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_motor_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_x/target_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_param_x", "get_param_x", PARAM_ANGULAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_x/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_x", "get_param_x", PARAM_ANGULAR_MOTOR_FORCE_LIMIT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_motor_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_y/target_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_param_y", "get_param_y", PARAM_ANGULAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_y/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_y", "get_param_y", PARAM_ANGULAR_MOTOR_FORCE_LIMIT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_motor_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_z/target_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_param_z", "get_param_z", PARAM_ANGULAR_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motor_z/force_limit", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2 (Nm)"), "set_param_z", "get_param_z", PARAM_ANGULAR_MOTOR_FORCE_LIMIT);
+
+	ADD_GROUP("Angular Spring", "angular_spring_");
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_spring_x/enabled"), "set_flag_x", "get_flag_x", FLAG_ENABLE_ANGULAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_x/stiffness"), "set_param_x", "get_param_x", PARAM_ANGULAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_x/damping"), "set_param_x", "get_param_x", PARAM_ANGULAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_x/equilibrium_point", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_x", "get_param_x", PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_spring_y/enabled"), "set_flag_y", "get_flag_y", FLAG_ENABLE_ANGULAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_y/stiffness"), "set_param_y", "get_param_y", PARAM_ANGULAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_y/damping"), "set_param_y", "get_param_y", PARAM_ANGULAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_y/equilibrium_point", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_y", "get_param_y", PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_spring_z/enabled"), "set_flag_z", "get_flag_z", FLAG_ENABLE_ANGULAR_SPRING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_z/stiffness"), "set_param_z", "get_param_z", PARAM_ANGULAR_SPRING_STIFFNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_z/damping"), "set_param_z", "get_param_z", PARAM_ANGULAR_SPRING_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_spring_z/equilibrium_point", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_param_z", "get_param_z", PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT);
+
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LOWER_LIMIT);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_UPPER_LIMIT);
+	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_LINEAR_SPRING_STIFFNESS);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_SPRING_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LOWER_LIMIT);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_UPPER_LIMIT);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_FORCE_LIMIT);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_ERP);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_MOTOR_TARGET_VELOCITY);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_MOTOR_FORCE_LIMIT);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_SPRING_STIFFNESS);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_SPRING_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT);
+	BIND_ENUM_CONSTANT(PARAM_MAX);
+
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_LINEAR_LIMIT);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_ANGULAR_LIMIT);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_LINEAR_SPRING);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_ANGULAR_SPRING);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_MOTOR);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_LINEAR_MOTOR);
+	BIND_ENUM_CONSTANT(FLAG_MAX);
+}
+
+void Generic6DOFJoint3D::set_param_x(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params_x[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(get_rid(), Vector3::AXIS_X, PhysicsServer3D::G6DOFJointAxisParam(p_param), p_value);
+	}
+
+	update_gizmos();
+}
+
+real_t Generic6DOFJoint3D::get_param_x(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params_x[p_param];
+}
+
+void Generic6DOFJoint3D::set_param_y(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params_y[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(get_rid(), Vector3::AXIS_Y, PhysicsServer3D::G6DOFJointAxisParam(p_param), p_value);
+	}
+	update_gizmos();
+}
+
+real_t Generic6DOFJoint3D::get_param_y(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params_y[p_param];
+}
+
+void Generic6DOFJoint3D::set_param_z(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params_z[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(get_rid(), Vector3::AXIS_Z, PhysicsServer3D::G6DOFJointAxisParam(p_param), p_value);
+	}
+	update_gizmos();
+}
+
+real_t Generic6DOFJoint3D::get_param_z(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params_z[p_param];
+}
+
+void Generic6DOFJoint3D::set_flag_x(Flag p_flag, bool p_enabled) {
+	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
+	flags_x[p_flag] = p_enabled;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(get_rid(), Vector3::AXIS_X, PhysicsServer3D::G6DOFJointAxisFlag(p_flag), p_enabled);
+	}
+	update_gizmos();
+}
+
+bool Generic6DOFJoint3D::get_flag_x(Flag p_flag) const {
+	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
+	return flags_x[p_flag];
+}
+
+void Generic6DOFJoint3D::set_flag_y(Flag p_flag, bool p_enabled) {
+	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
+	flags_y[p_flag] = p_enabled;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(get_rid(), Vector3::AXIS_Y, PhysicsServer3D::G6DOFJointAxisFlag(p_flag), p_enabled);
+	}
+	update_gizmos();
+}
+
+bool Generic6DOFJoint3D::get_flag_y(Flag p_flag) const {
+	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
+	return flags_y[p_flag];
+}
+
+void Generic6DOFJoint3D::set_flag_z(Flag p_flag, bool p_enabled) {
+	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
+	flags_z[p_flag] = p_enabled;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(get_rid(), Vector3::AXIS_Z, PhysicsServer3D::G6DOFJointAxisFlag(p_flag), p_enabled);
+	}
+	update_gizmos();
+}
+
+bool Generic6DOFJoint3D::get_flag_z(Flag p_flag) const {
+	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
+	return flags_z[p_flag];
+}
+
+void Generic6DOFJoint3D::_configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) {
+	Transform3D gt = get_global_transform();
+	//Vector3 cone_twistpos = gt.origin;
+	//Vector3 cone_twistdir = gt.basis.get_axis(2);
+
+	Transform3D ainv = body_a->get_global_transform().affine_inverse();
+
+	Transform3D local_a = ainv * gt;
+	local_a.orthonormalize();
+	Transform3D local_b = gt;
+
+	if (body_b) {
+		Transform3D binv = body_b->get_global_transform().affine_inverse();
+		local_b = binv * gt;
+	}
+
+	local_b.orthonormalize();
+
+	PhysicsServer3D::get_singleton()->joint_make_generic_6dof(p_joint, body_a->get_rid(), local_a, body_b ? body_b->get_rid() : RID(), local_b);
+	for (int i = 0; i < PARAM_MAX; i++) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(p_joint, Vector3::AXIS_X, PhysicsServer3D::G6DOFJointAxisParam(i), params_x[i]);
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(p_joint, Vector3::AXIS_Y, PhysicsServer3D::G6DOFJointAxisParam(i), params_y[i]);
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(p_joint, Vector3::AXIS_Z, PhysicsServer3D::G6DOFJointAxisParam(i), params_z[i]);
+	}
+	for (int i = 0; i < FLAG_MAX; i++) {
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(p_joint, Vector3::AXIS_X, PhysicsServer3D::G6DOFJointAxisFlag(i), flags_x[i]);
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(p_joint, Vector3::AXIS_Y, PhysicsServer3D::G6DOFJointAxisFlag(i), flags_y[i]);
+		PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(p_joint, Vector3::AXIS_Z, PhysicsServer3D::G6DOFJointAxisFlag(i), flags_z[i]);
+	}
+}
+
+Generic6DOFJoint3D::Generic6DOFJoint3D() {
+	set_param_x(PARAM_LINEAR_LOWER_LIMIT, 0);
+	set_param_x(PARAM_LINEAR_UPPER_LIMIT, 0);
+	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_LINEAR_SPRING_STIFFNESS, 0.01);
+	set_param_x(PARAM_LINEAR_SPRING_DAMPING, 0.01);
+	set_param_x(PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT, 0.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);
+	set_param_x(PARAM_ANGULAR_DAMPING, 1.0f);
+	set_param_x(PARAM_ANGULAR_RESTITUTION, 0);
+	set_param_x(PARAM_ANGULAR_FORCE_LIMIT, 0);
+	set_param_x(PARAM_ANGULAR_ERP, 0.5);
+	set_param_x(PARAM_ANGULAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_x(PARAM_ANGULAR_MOTOR_FORCE_LIMIT, 300);
+	set_param_x(PARAM_ANGULAR_SPRING_STIFFNESS, 0);
+	set_param_x(PARAM_ANGULAR_SPRING_DAMPING, 0);
+	set_param_x(PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT, 0);
+
+	set_flag_x(FLAG_ENABLE_ANGULAR_LIMIT, true);
+	set_flag_x(FLAG_ENABLE_LINEAR_LIMIT, true);
+	set_flag_x(FLAG_ENABLE_ANGULAR_SPRING, false);
+	set_flag_x(FLAG_ENABLE_LINEAR_SPRING, false);
+	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_LINEAR_SPRING_STIFFNESS, 0.01);
+	set_param_y(PARAM_LINEAR_SPRING_DAMPING, 0.01);
+	set_param_y(PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT, 0.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);
+	set_param_y(PARAM_ANGULAR_DAMPING, 1.0f);
+	set_param_y(PARAM_ANGULAR_RESTITUTION, 0);
+	set_param_y(PARAM_ANGULAR_FORCE_LIMIT, 0);
+	set_param_y(PARAM_ANGULAR_ERP, 0.5);
+	set_param_y(PARAM_ANGULAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_y(PARAM_ANGULAR_MOTOR_FORCE_LIMIT, 300);
+	set_param_y(PARAM_ANGULAR_SPRING_STIFFNESS, 0);
+	set_param_y(PARAM_ANGULAR_SPRING_DAMPING, 0);
+	set_param_y(PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT, 0);
+
+	set_flag_y(FLAG_ENABLE_ANGULAR_LIMIT, true);
+	set_flag_y(FLAG_ENABLE_LINEAR_LIMIT, true);
+	set_flag_y(FLAG_ENABLE_ANGULAR_SPRING, false);
+	set_flag_y(FLAG_ENABLE_LINEAR_SPRING, false);
+	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_LINEAR_SPRING_STIFFNESS, 0.01);
+	set_param_z(PARAM_LINEAR_SPRING_DAMPING, 0.01);
+	set_param_z(PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT, 0.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);
+	set_param_z(PARAM_ANGULAR_DAMPING, 1.0f);
+	set_param_z(PARAM_ANGULAR_RESTITUTION, 0);
+	set_param_z(PARAM_ANGULAR_FORCE_LIMIT, 0);
+	set_param_z(PARAM_ANGULAR_ERP, 0.5);
+	set_param_z(PARAM_ANGULAR_MOTOR_TARGET_VELOCITY, 0);
+	set_param_z(PARAM_ANGULAR_MOTOR_FORCE_LIMIT, 300);
+	set_param_z(PARAM_ANGULAR_SPRING_STIFFNESS, 0);
+	set_param_z(PARAM_ANGULAR_SPRING_DAMPING, 0);
+	set_param_z(PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT, 0);
+
+	set_flag_z(FLAG_ENABLE_ANGULAR_LIMIT, true);
+	set_flag_z(FLAG_ENABLE_LINEAR_LIMIT, true);
+	set_flag_z(FLAG_ENABLE_ANGULAR_SPRING, false);
+	set_flag_z(FLAG_ENABLE_LINEAR_SPRING, false);
+	set_flag_z(FLAG_ENABLE_MOTOR, false);
+	set_flag_z(FLAG_ENABLE_LINEAR_MOTOR, false);
+}
diff --git a/scene/3d/physics/joints/generic_6dof_joint_3d.h b/scene/3d/physics/joints/generic_6dof_joint_3d.h
new file mode 100644
index 0000000000..9b3e4c01b3
--- /dev/null
+++ b/scene/3d/physics/joints/generic_6dof_joint_3d.h
@@ -0,0 +1,112 @@
+/**************************************************************************/
+/*  generic_6dof_joint_3d.h                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef GENERIC_6DOF_JOINT_3D_H
+#define GENERIC_6DOF_JOINT_3D_H
+
+#include "scene/3d/physics/joints/joint_3d.h"
+
+class Generic6DOFJoint3D : public Joint3D {
+	GDCLASS(Generic6DOFJoint3D, Joint3D);
+
+public:
+	enum Param {
+		PARAM_LINEAR_LOWER_LIMIT = PhysicsServer3D::G6DOF_JOINT_LINEAR_LOWER_LIMIT,
+		PARAM_LINEAR_UPPER_LIMIT = PhysicsServer3D::G6DOF_JOINT_LINEAR_UPPER_LIMIT,
+		PARAM_LINEAR_LIMIT_SOFTNESS = PhysicsServer3D::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS,
+		PARAM_LINEAR_RESTITUTION = PhysicsServer3D::G6DOF_JOINT_LINEAR_RESTITUTION,
+		PARAM_LINEAR_DAMPING = PhysicsServer3D::G6DOF_JOINT_LINEAR_DAMPING,
+		PARAM_LINEAR_MOTOR_TARGET_VELOCITY = PhysicsServer3D::G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY,
+		PARAM_LINEAR_MOTOR_FORCE_LIMIT = PhysicsServer3D::G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT,
+		PARAM_LINEAR_SPRING_STIFFNESS = PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_STIFFNESS,
+		PARAM_LINEAR_SPRING_DAMPING = PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_DAMPING,
+		PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT = PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_EQUILIBRIUM_POINT,
+		PARAM_ANGULAR_LOWER_LIMIT = PhysicsServer3D::G6DOF_JOINT_ANGULAR_LOWER_LIMIT,
+		PARAM_ANGULAR_UPPER_LIMIT = PhysicsServer3D::G6DOF_JOINT_ANGULAR_UPPER_LIMIT,
+		PARAM_ANGULAR_LIMIT_SOFTNESS = PhysicsServer3D::G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS,
+		PARAM_ANGULAR_DAMPING = PhysicsServer3D::G6DOF_JOINT_ANGULAR_DAMPING,
+		PARAM_ANGULAR_RESTITUTION = PhysicsServer3D::G6DOF_JOINT_ANGULAR_RESTITUTION,
+		PARAM_ANGULAR_FORCE_LIMIT = PhysicsServer3D::G6DOF_JOINT_ANGULAR_FORCE_LIMIT,
+		PARAM_ANGULAR_ERP = PhysicsServer3D::G6DOF_JOINT_ANGULAR_ERP,
+		PARAM_ANGULAR_MOTOR_TARGET_VELOCITY = PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY,
+		PARAM_ANGULAR_MOTOR_FORCE_LIMIT = PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT,
+		PARAM_ANGULAR_SPRING_STIFFNESS = PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_STIFFNESS,
+		PARAM_ANGULAR_SPRING_DAMPING = PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_DAMPING,
+		PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT = PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_EQUILIBRIUM_POINT,
+		PARAM_MAX = PhysicsServer3D::G6DOF_JOINT_MAX,
+	};
+
+	enum Flag {
+		FLAG_ENABLE_LINEAR_LIMIT = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT,
+		FLAG_ENABLE_ANGULAR_LIMIT = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT,
+		FLAG_ENABLE_LINEAR_SPRING = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_SPRING,
+		FLAG_ENABLE_ANGULAR_SPRING = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_SPRING,
+		FLAG_ENABLE_MOTOR = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_MOTOR,
+		FLAG_ENABLE_LINEAR_MOTOR = PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR,
+		FLAG_MAX = PhysicsServer3D::G6DOF_JOINT_FLAG_MAX
+	};
+
+protected:
+	real_t params_x[PARAM_MAX];
+	bool flags_x[FLAG_MAX];
+	real_t params_y[PARAM_MAX];
+	bool flags_y[FLAG_MAX];
+	real_t params_z[PARAM_MAX];
+	bool flags_z[FLAG_MAX];
+
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_param_x(Param p_param, real_t p_value);
+	real_t get_param_x(Param p_param) const;
+
+	void set_param_y(Param p_param, real_t p_value);
+	real_t get_param_y(Param p_param) const;
+
+	void set_param_z(Param p_param, real_t p_value);
+	real_t get_param_z(Param p_param) const;
+
+	void set_flag_x(Flag p_flag, bool p_enabled);
+	bool get_flag_x(Flag p_flag) const;
+
+	void set_flag_y(Flag p_flag, bool p_enabled);
+	bool get_flag_y(Flag p_flag) const;
+
+	void set_flag_z(Flag p_flag, bool p_enabled);
+	bool get_flag_z(Flag p_flag) const;
+
+	Generic6DOFJoint3D();
+};
+
+VARIANT_ENUM_CAST(Generic6DOFJoint3D::Param);
+VARIANT_ENUM_CAST(Generic6DOFJoint3D::Flag);
+
+#endif // GENERIC_6DOF_JOINT_3D_H
diff --git a/scene/3d/physics/joints/hinge_joint_3d.cpp b/scene/3d/physics/joints/hinge_joint_3d.cpp
new file mode 100644
index 0000000000..92472a45e4
--- /dev/null
+++ b/scene/3d/physics/joints/hinge_joint_3d.cpp
@@ -0,0 +1,135 @@
+/**************************************************************************/
+/*  hinge_joint_3d.cpp                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "hinge_joint_3d.h"
+
+void HingeJoint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &HingeJoint3D::set_param);
+	ClassDB::bind_method(D_METHOD("get_param", "param"), &HingeJoint3D::get_param);
+
+	ClassDB::bind_method(D_METHOD("set_flag", "flag", "enabled"), &HingeJoint3D::set_flag);
+	ClassDB::bind_method(D_METHOD("get_flag", "flag"), &HingeJoint3D::get_flag);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "params/bias", PROPERTY_HINT_RANGE, "0.00,0.99,0.01"), "set_param", "get_param", PARAM_BIAS);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "angular_limit/enable"), "set_flag", "get_flag", FLAG_USE_LIMIT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/upper", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_LIMIT_UPPER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/lower", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_LIMIT_LOWER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/bias", PROPERTY_HINT_RANGE, "0.01,0.99,0.01"), "set_param", "get_param", PARAM_LIMIT_BIAS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/softness", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param", "get_param", PARAM_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/relaxation", PROPERTY_HINT_RANGE, "0.01,16,0.01"), "set_param", "get_param", PARAM_LIMIT_RELAXATION);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "motor/enable"), "set_flag", "get_flag", FLAG_ENABLE_MOTOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "motor/target_velocity", PROPERTY_HINT_RANGE, U"-200,200,0.01,or_greater,or_less,radians_as_degrees,suffix:\u00B0/s"), "set_param", "get_param", PARAM_MOTOR_TARGET_VELOCITY);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "motor/max_impulse", PROPERTY_HINT_RANGE, "0.01,1024,0.01"), "set_param", "get_param", PARAM_MOTOR_MAX_IMPULSE);
+
+	BIND_ENUM_CONSTANT(PARAM_BIAS);
+	BIND_ENUM_CONSTANT(PARAM_LIMIT_UPPER);
+	BIND_ENUM_CONSTANT(PARAM_LIMIT_LOWER);
+	BIND_ENUM_CONSTANT(PARAM_LIMIT_BIAS);
+	BIND_ENUM_CONSTANT(PARAM_LIMIT_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_LIMIT_RELAXATION);
+	BIND_ENUM_CONSTANT(PARAM_MOTOR_TARGET_VELOCITY);
+	BIND_ENUM_CONSTANT(PARAM_MOTOR_MAX_IMPULSE);
+	BIND_ENUM_CONSTANT(PARAM_MAX);
+
+	BIND_ENUM_CONSTANT(FLAG_USE_LIMIT);
+	BIND_ENUM_CONSTANT(FLAG_ENABLE_MOTOR);
+	BIND_ENUM_CONSTANT(FLAG_MAX);
+}
+
+void HingeJoint3D::set_param(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->hinge_joint_set_param(get_rid(), PhysicsServer3D::HingeJointParam(p_param), p_value);
+	}
+
+	update_gizmos();
+}
+
+real_t HingeJoint3D::get_param(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params[p_param];
+}
+
+void HingeJoint3D::set_flag(Flag p_flag, bool p_value) {
+	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
+	flags[p_flag] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->hinge_joint_set_flag(get_rid(), PhysicsServer3D::HingeJointFlag(p_flag), p_value);
+	}
+
+	update_gizmos();
+}
+
+bool HingeJoint3D::get_flag(Flag p_flag) const {
+	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
+	return flags[p_flag];
+}
+
+void HingeJoint3D::_configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) {
+	Transform3D gt = get_global_transform();
+	Transform3D ainv = body_a->get_global_transform().affine_inverse();
+
+	Transform3D local_a = ainv * gt;
+	local_a.orthonormalize();
+	Transform3D local_b = gt;
+
+	if (body_b) {
+		Transform3D binv = body_b->get_global_transform().affine_inverse();
+		local_b = binv * gt;
+	}
+
+	local_b.orthonormalize();
+
+	PhysicsServer3D::get_singleton()->joint_make_hinge(p_joint, body_a->get_rid(), local_a, body_b ? body_b->get_rid() : RID(), local_b);
+	for (int i = 0; i < PARAM_MAX; i++) {
+		PhysicsServer3D::get_singleton()->hinge_joint_set_param(p_joint, PhysicsServer3D::HingeJointParam(i), params[i]);
+	}
+	for (int i = 0; i < FLAG_MAX; i++) {
+		set_flag(Flag(i), flags[i]);
+		PhysicsServer3D::get_singleton()->hinge_joint_set_flag(p_joint, PhysicsServer3D::HingeJointFlag(i), flags[i]);
+	}
+}
+
+HingeJoint3D::HingeJoint3D() {
+	params[PARAM_BIAS] = 0.3;
+	params[PARAM_LIMIT_UPPER] = Math_PI * 0.5;
+	params[PARAM_LIMIT_LOWER] = -Math_PI * 0.5;
+	params[PARAM_LIMIT_BIAS] = 0.3;
+	params[PARAM_LIMIT_SOFTNESS] = 0.9;
+	params[PARAM_LIMIT_RELAXATION] = 1.0;
+	params[PARAM_MOTOR_TARGET_VELOCITY] = 1;
+	params[PARAM_MOTOR_MAX_IMPULSE] = 1;
+
+	flags[FLAG_USE_LIMIT] = false;
+	flags[FLAG_ENABLE_MOTOR] = false;
+}
diff --git a/scene/3d/physics/joints/hinge_joint_3d.h b/scene/3d/physics/joints/hinge_joint_3d.h
new file mode 100644
index 0000000000..cd19a8771f
--- /dev/null
+++ b/scene/3d/physics/joints/hinge_joint_3d.h
@@ -0,0 +1,77 @@
+/**************************************************************************/
+/*  hinge_joint_3d.h                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef HINGE_JOINT_3D_H
+#define HINGE_JOINT_3D_H
+
+#include "scene/3d/physics/joints/joint_3d.h"
+
+class HingeJoint3D : public Joint3D {
+	GDCLASS(HingeJoint3D, Joint3D);
+
+public:
+	enum Param {
+		PARAM_BIAS = PhysicsServer3D::HINGE_JOINT_BIAS,
+		PARAM_LIMIT_UPPER = PhysicsServer3D::HINGE_JOINT_LIMIT_UPPER,
+		PARAM_LIMIT_LOWER = PhysicsServer3D::HINGE_JOINT_LIMIT_LOWER,
+		PARAM_LIMIT_BIAS = PhysicsServer3D::HINGE_JOINT_LIMIT_BIAS,
+		PARAM_LIMIT_SOFTNESS = PhysicsServer3D::HINGE_JOINT_LIMIT_SOFTNESS,
+		PARAM_LIMIT_RELAXATION = PhysicsServer3D::HINGE_JOINT_LIMIT_RELAXATION,
+		PARAM_MOTOR_TARGET_VELOCITY = PhysicsServer3D::HINGE_JOINT_MOTOR_TARGET_VELOCITY,
+		PARAM_MOTOR_MAX_IMPULSE = PhysicsServer3D::HINGE_JOINT_MOTOR_MAX_IMPULSE,
+		PARAM_MAX = PhysicsServer3D::HINGE_JOINT_MAX
+	};
+
+	enum Flag {
+		FLAG_USE_LIMIT = PhysicsServer3D::HINGE_JOINT_FLAG_USE_LIMIT,
+		FLAG_ENABLE_MOTOR = PhysicsServer3D::HINGE_JOINT_FLAG_ENABLE_MOTOR,
+		FLAG_MAX = PhysicsServer3D::HINGE_JOINT_FLAG_MAX
+	};
+
+protected:
+	real_t params[PARAM_MAX];
+	bool flags[FLAG_MAX];
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_param(Param p_param, real_t p_value);
+	real_t get_param(Param p_param) const;
+
+	void set_flag(Flag p_flag, bool p_value);
+	bool get_flag(Flag p_flag) const;
+
+	HingeJoint3D();
+};
+
+VARIANT_ENUM_CAST(HingeJoint3D::Param);
+VARIANT_ENUM_CAST(HingeJoint3D::Flag);
+
+#endif // HINGE_JOINT_3D_H
diff --git a/scene/3d/physics/joints/joint_3d.cpp b/scene/3d/physics/joints/joint_3d.cpp
new file mode 100644
index 0000000000..a9c2526bd0
--- /dev/null
+++ b/scene/3d/physics/joints/joint_3d.cpp
@@ -0,0 +1,241 @@
+/**************************************************************************/
+/*  joint_3d.cpp                                                          */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "joint_3d.h"
+
+#include "scene/scene_string_names.h"
+
+void Joint3D::_disconnect_signals() {
+	Node *node_a = get_node_or_null(a);
+	PhysicsBody3D *body_a = Object::cast_to<PhysicsBody3D>(node_a);
+	if (body_a) {
+		body_a->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint3D::_body_exit_tree));
+	}
+
+	Node *node_b = get_node_or_null(b);
+	PhysicsBody3D *body_b = Object::cast_to<PhysicsBody3D>(node_b);
+	if (body_b) {
+		body_b->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint3D::_body_exit_tree));
+	}
+}
+
+void Joint3D::_body_exit_tree() {
+	_disconnect_signals();
+	_update_joint(true);
+	update_configuration_warnings();
+}
+
+void Joint3D::_update_joint(bool p_only_free) {
+	if (ba.is_valid() && bb.is_valid()) {
+		PhysicsServer3D::get_singleton()->body_remove_collision_exception(ba, bb);
+		PhysicsServer3D::get_singleton()->body_remove_collision_exception(bb, ba);
+	}
+
+	ba = RID();
+	bb = RID();
+
+	configured = false;
+
+	if (p_only_free || !is_inside_tree()) {
+		PhysicsServer3D::get_singleton()->joint_clear(joint);
+		warning = String();
+		return;
+	}
+
+	Node *node_a = get_node_or_null(a);
+	Node *node_b = get_node_or_null(b);
+
+	PhysicsBody3D *body_a = Object::cast_to<PhysicsBody3D>(node_a);
+	PhysicsBody3D *body_b = Object::cast_to<PhysicsBody3D>(node_b);
+
+	if (node_a && !body_a && node_b && !body_b) {
+		warning = RTR("Node A and Node B must be PhysicsBody3Ds");
+	} else if (node_a && !body_a) {
+		warning = RTR("Node A must be a PhysicsBody3D");
+	} else if (node_b && !body_b) {
+		warning = RTR("Node B must be a PhysicsBody3D");
+	} else if (!body_a && !body_b) {
+		warning = RTR("Joint is not connected to any PhysicsBody3Ds");
+	} else if (body_a == body_b) {
+		warning = RTR("Node A and Node B must be different PhysicsBody3Ds");
+	} else {
+		warning = String();
+	}
+
+	update_configuration_warnings();
+
+	if (!warning.is_empty()) {
+		PhysicsServer3D::get_singleton()->joint_clear(joint);
+		return;
+	}
+
+	configured = true;
+
+	if (body_a) {
+		_configure_joint(joint, body_a, body_b);
+	} else if (body_b) {
+		_configure_joint(joint, body_b, nullptr);
+	}
+
+	PhysicsServer3D::get_singleton()->joint_set_solver_priority(joint, solver_priority);
+
+	if (body_a) {
+		ba = body_a->get_rid();
+		body_a->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint3D::_body_exit_tree));
+	}
+
+	if (body_b) {
+		bb = body_b->get_rid();
+		body_b->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint3D::_body_exit_tree));
+	}
+
+	PhysicsServer3D::get_singleton()->joint_disable_collisions_between_bodies(joint, exclude_from_collision);
+}
+
+void Joint3D::set_node_a(const NodePath &p_node_a) {
+	if (a == p_node_a) {
+		return;
+	}
+
+	if (is_configured()) {
+		_disconnect_signals();
+	}
+
+	a = p_node_a;
+	_update_joint();
+}
+
+NodePath Joint3D::get_node_a() const {
+	return a;
+}
+
+void Joint3D::set_node_b(const NodePath &p_node_b) {
+	if (b == p_node_b) {
+		return;
+	}
+
+	if (is_configured()) {
+		_disconnect_signals();
+	}
+
+	b = p_node_b;
+	_update_joint();
+}
+
+NodePath Joint3D::get_node_b() const {
+	return b;
+}
+
+void Joint3D::set_solver_priority(int p_priority) {
+	solver_priority = p_priority;
+	if (joint.is_valid()) {
+		PhysicsServer3D::get_singleton()->joint_set_solver_priority(joint, solver_priority);
+	}
+}
+
+int Joint3D::get_solver_priority() const {
+	return solver_priority;
+}
+
+void Joint3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_POST_ENTER_TREE: {
+			if (is_configured()) {
+				_disconnect_signals();
+			}
+			_update_joint();
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (is_configured()) {
+				_disconnect_signals();
+			}
+			_update_joint(true);
+		} break;
+	}
+}
+
+void Joint3D::set_exclude_nodes_from_collision(bool p_enable) {
+	if (exclude_from_collision == p_enable) {
+		return;
+	}
+	if (is_configured()) {
+		_disconnect_signals();
+	}
+	_update_joint(true);
+	exclude_from_collision = p_enable;
+	_update_joint();
+}
+
+bool Joint3D::get_exclude_nodes_from_collision() const {
+	return exclude_from_collision;
+}
+
+PackedStringArray Joint3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node3D::get_configuration_warnings();
+
+	if (!warning.is_empty()) {
+		warnings.push_back(warning);
+	}
+
+	return warnings;
+}
+
+void Joint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_node_a", "node"), &Joint3D::set_node_a);
+	ClassDB::bind_method(D_METHOD("get_node_a"), &Joint3D::get_node_a);
+
+	ClassDB::bind_method(D_METHOD("set_node_b", "node"), &Joint3D::set_node_b);
+	ClassDB::bind_method(D_METHOD("get_node_b"), &Joint3D::get_node_b);
+
+	ClassDB::bind_method(D_METHOD("set_solver_priority", "priority"), &Joint3D::set_solver_priority);
+	ClassDB::bind_method(D_METHOD("get_solver_priority"), &Joint3D::get_solver_priority);
+
+	ClassDB::bind_method(D_METHOD("set_exclude_nodes_from_collision", "enable"), &Joint3D::set_exclude_nodes_from_collision);
+	ClassDB::bind_method(D_METHOD("get_exclude_nodes_from_collision"), &Joint3D::get_exclude_nodes_from_collision);
+
+	ClassDB::bind_method(D_METHOD("get_rid"), &Joint3D::get_rid);
+
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_a", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody3D"), "set_node_a", "get_node_a");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_b", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody3D"), "set_node_b", "get_node_b");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "solver_priority", PROPERTY_HINT_RANGE, "1,8,1"), "set_solver_priority", "get_solver_priority");
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "exclude_nodes_from_collision"), "set_exclude_nodes_from_collision", "get_exclude_nodes_from_collision");
+}
+
+Joint3D::Joint3D() {
+	set_notify_transform(true);
+	joint = PhysicsServer3D::get_singleton()->joint_create();
+}
+
+Joint3D::~Joint3D() {
+	ERR_FAIL_NULL(PhysicsServer3D::get_singleton());
+	PhysicsServer3D::get_singleton()->free(joint);
+}
diff --git a/scene/3d/physics/joints/joint_3d.h b/scene/3d/physics/joints/joint_3d.h
new file mode 100644
index 0000000000..ed502ab245
--- /dev/null
+++ b/scene/3d/physics/joints/joint_3d.h
@@ -0,0 +1,85 @@
+/**************************************************************************/
+/*  joint_3d.h                                                            */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JOINT_3D_H
+#define JOINT_3D_H
+
+#include "scene/3d/node_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+
+class Joint3D : public Node3D {
+	GDCLASS(Joint3D, Node3D);
+
+	RID ba, bb;
+
+	RID joint;
+
+	NodePath a;
+	NodePath b;
+
+	int solver_priority = 1;
+	bool exclude_from_collision = true;
+	String warning;
+	bool configured = false;
+
+protected:
+	void _disconnect_signals();
+	void _body_exit_tree();
+	void _update_joint(bool p_only_free = false);
+
+	void _notification(int p_what);
+
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) = 0;
+
+	static void _bind_methods();
+
+	_FORCE_INLINE_ bool is_configured() const { return configured; }
+
+public:
+	virtual PackedStringArray get_configuration_warnings() const override;
+
+	void set_node_a(const NodePath &p_node_a);
+	NodePath get_node_a() const;
+
+	void set_node_b(const NodePath &p_node_b);
+	NodePath get_node_b() const;
+
+	void set_solver_priority(int p_priority);
+	int get_solver_priority() const;
+
+	void set_exclude_nodes_from_collision(bool p_enable);
+	bool get_exclude_nodes_from_collision() const;
+
+	RID get_rid() const { return joint; }
+	Joint3D();
+	~Joint3D();
+};
+
+#endif // JOINT_3D_H
diff --git a/scene/3d/physics/joints/pin_joint_3d.cpp b/scene/3d/physics/joints/pin_joint_3d.cpp
new file mode 100644
index 0000000000..8e367c5ef6
--- /dev/null
+++ b/scene/3d/physics/joints/pin_joint_3d.cpp
@@ -0,0 +1,80 @@
+/**************************************************************************/
+/*  pin_joint_3d.cpp                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "pin_joint_3d.h"
+
+void PinJoint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &PinJoint3D::set_param);
+	ClassDB::bind_method(D_METHOD("get_param", "param"), &PinJoint3D::get_param);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "params/bias", PROPERTY_HINT_RANGE, "0.01,0.99,0.01"), "set_param", "get_param", PARAM_BIAS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "params/damping", PROPERTY_HINT_RANGE, "0.01,8.0,0.01"), "set_param", "get_param", PARAM_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "params/impulse_clamp", PROPERTY_HINT_RANGE, "0.0,64.0,0.01"), "set_param", "get_param", PARAM_IMPULSE_CLAMP);
+
+	BIND_ENUM_CONSTANT(PARAM_BIAS);
+	BIND_ENUM_CONSTANT(PARAM_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_IMPULSE_CLAMP);
+}
+
+void PinJoint3D::set_param(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, 3);
+	params[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer3D::PinJointParam(p_param), p_value);
+	}
+}
+
+real_t PinJoint3D::get_param(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, 3, 0);
+	return params[p_param];
+}
+
+void PinJoint3D::_configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) {
+	Vector3 pinpos = get_global_transform().origin;
+	Vector3 local_a = body_a->to_local(pinpos);
+	Vector3 local_b;
+
+	if (body_b) {
+		local_b = body_b->to_local(pinpos);
+	} else {
+		local_b = pinpos;
+	}
+
+	PhysicsServer3D::get_singleton()->joint_make_pin(p_joint, body_a->get_rid(), local_a, body_b ? body_b->get_rid() : RID(), local_b);
+	for (int i = 0; i < 3; i++) {
+		PhysicsServer3D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer3D::PinJointParam(i), params[i]);
+	}
+}
+
+PinJoint3D::PinJoint3D() {
+	params[PARAM_BIAS] = 0.3;
+	params[PARAM_DAMPING] = 1;
+	params[PARAM_IMPULSE_CLAMP] = 0;
+}
diff --git a/scene/3d/physics/joints/pin_joint_3d.h b/scene/3d/physics/joints/pin_joint_3d.h
new file mode 100644
index 0000000000..34c8db2890
--- /dev/null
+++ b/scene/3d/physics/joints/pin_joint_3d.h
@@ -0,0 +1,60 @@
+/**************************************************************************/
+/*  pin_joint_3d.h                                                        */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef PIN_JOINT_3D_H
+#define PIN_JOINT_3D_H
+
+#include "scene/3d/physics/joints/joint_3d.h"
+
+class PinJoint3D : public Joint3D {
+	GDCLASS(PinJoint3D, Joint3D);
+
+public:
+	enum Param {
+		PARAM_BIAS = PhysicsServer3D::PIN_JOINT_BIAS,
+		PARAM_DAMPING = PhysicsServer3D::PIN_JOINT_DAMPING,
+		PARAM_IMPULSE_CLAMP = PhysicsServer3D::PIN_JOINT_IMPULSE_CLAMP
+	};
+
+protected:
+	real_t params[3];
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_param(Param p_param, real_t p_value);
+	real_t get_param(Param p_param) const;
+
+	PinJoint3D();
+};
+
+VARIANT_ENUM_CAST(PinJoint3D::Param);
+
+#endif // PIN_JOINT_3D_H
diff --git a/scene/3d/physics/joints/slider_joint_3d.cpp b/scene/3d/physics/joints/slider_joint_3d.cpp
new file mode 100644
index 0000000000..2e87ae1e83
--- /dev/null
+++ b/scene/3d/physics/joints/slider_joint_3d.cpp
@@ -0,0 +1,149 @@
+/**************************************************************************/
+/*  slider_joint_3d.cpp                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "slider_joint_3d.h"
+
+#include "scene/scene_string_names.h"
+
+void SliderJoint3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &SliderJoint3D::set_param);
+	ClassDB::bind_method(D_METHOD("get_param", "param"), &SliderJoint3D::get_param);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit/upper_distance", PROPERTY_HINT_RANGE, "-1024,1024,0.01,suffix:m"), "set_param", "get_param", PARAM_LINEAR_LIMIT_UPPER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit/lower_distance", PROPERTY_HINT_RANGE, "-1024,1024,0.01,suffix:m"), "set_param", "get_param", PARAM_LINEAR_LIMIT_LOWER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_LIMIT_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_limit/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_LIMIT_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motion/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_MOTION_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motion/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_MOTION_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_motion/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_MOTION_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_ortho/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_ORTHOGONAL_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_ortho/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_ORTHOGONAL_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_ortho/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_LINEAR_ORTHOGONAL_DAMPING);
+
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/upper_angle", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_ANGULAR_LIMIT_UPPER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/lower_angle", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_param", "get_param", PARAM_ANGULAR_LIMIT_LOWER);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_LIMIT_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_LIMIT_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_limit/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_LIMIT_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motion/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_MOTION_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motion/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_MOTION_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_motion/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_MOTION_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_ortho/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_ORTHOGONAL_SOFTNESS);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_ortho/restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_ORTHOGONAL_RESTITUTION);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_ortho/damping", PROPERTY_HINT_RANGE, "0,16.0,0.01"), "set_param", "get_param", PARAM_ANGULAR_ORTHOGONAL_DAMPING);
+
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_UPPER);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_LOWER);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_LIMIT_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_MOTION_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_MOTION_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_MOTION_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_ORTHOGONAL_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_ORTHOGONAL_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_LINEAR_ORTHOGONAL_DAMPING);
+
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_UPPER);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_LOWER);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_LIMIT_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_MOTION_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_MOTION_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_MOTION_DAMPING);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_ORTHOGONAL_SOFTNESS);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_ORTHOGONAL_RESTITUTION);
+	BIND_ENUM_CONSTANT(PARAM_ANGULAR_ORTHOGONAL_DAMPING);
+
+	BIND_ENUM_CONSTANT(PARAM_MAX);
+}
+
+void SliderJoint3D::set_param(Param p_param, real_t p_value) {
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	params[p_param] = p_value;
+	if (is_configured()) {
+		PhysicsServer3D::get_singleton()->slider_joint_set_param(get_rid(), PhysicsServer3D::SliderJointParam(p_param), p_value);
+	}
+	update_gizmos();
+}
+
+real_t SliderJoint3D::get_param(Param p_param) const {
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
+	return params[p_param];
+}
+
+void SliderJoint3D::_configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) {
+	Transform3D gt = get_global_transform();
+	Transform3D ainv = body_a->get_global_transform().affine_inverse();
+
+	Transform3D local_a = ainv * gt;
+	local_a.orthonormalize();
+	Transform3D local_b = gt;
+
+	if (body_b) {
+		Transform3D binv = body_b->get_global_transform().affine_inverse();
+		local_b = binv * gt;
+	}
+
+	local_b.orthonormalize();
+
+	PhysicsServer3D::get_singleton()->joint_make_slider(p_joint, body_a->get_rid(), local_a, body_b ? body_b->get_rid() : RID(), local_b);
+	for (int i = 0; i < PARAM_MAX; i++) {
+		PhysicsServer3D::get_singleton()->slider_joint_set_param(p_joint, PhysicsServer3D::SliderJointParam(i), params[i]);
+	}
+}
+
+SliderJoint3D::SliderJoint3D() {
+	params[PARAM_LINEAR_LIMIT_UPPER] = 1.0;
+	params[PARAM_LINEAR_LIMIT_LOWER] = -1.0;
+	params[PARAM_LINEAR_LIMIT_SOFTNESS] = 1.0;
+	params[PARAM_LINEAR_LIMIT_RESTITUTION] = 0.7;
+	params[PARAM_LINEAR_LIMIT_DAMPING] = 1.0;
+	params[PARAM_LINEAR_MOTION_SOFTNESS] = 1.0;
+	params[PARAM_LINEAR_MOTION_RESTITUTION] = 0.7;
+	params[PARAM_LINEAR_MOTION_DAMPING] = 0; //1.0;
+	params[PARAM_LINEAR_ORTHOGONAL_SOFTNESS] = 1.0;
+	params[PARAM_LINEAR_ORTHOGONAL_RESTITUTION] = 0.7;
+	params[PARAM_LINEAR_ORTHOGONAL_DAMPING] = 1.0;
+
+	params[PARAM_ANGULAR_LIMIT_UPPER] = 0;
+	params[PARAM_ANGULAR_LIMIT_LOWER] = 0;
+	params[PARAM_ANGULAR_LIMIT_SOFTNESS] = 1.0;
+	params[PARAM_ANGULAR_LIMIT_RESTITUTION] = 0.7;
+	params[PARAM_ANGULAR_LIMIT_DAMPING] = 0; //1.0;
+	params[PARAM_ANGULAR_MOTION_SOFTNESS] = 1.0;
+	params[PARAM_ANGULAR_MOTION_RESTITUTION] = 0.7;
+	params[PARAM_ANGULAR_MOTION_DAMPING] = 1.0;
+	params[PARAM_ANGULAR_ORTHOGONAL_SOFTNESS] = 1.0;
+	params[PARAM_ANGULAR_ORTHOGONAL_RESTITUTION] = 0.7;
+	params[PARAM_ANGULAR_ORTHOGONAL_DAMPING] = 1.0;
+}
diff --git a/scene/3d/physics/joints/slider_joint_3d.h b/scene/3d/physics/joints/slider_joint_3d.h
new file mode 100644
index 0000000000..e0b059e6e3
--- /dev/null
+++ b/scene/3d/physics/joints/slider_joint_3d.h
@@ -0,0 +1,82 @@
+/**************************************************************************/
+/*  slider_joint_3d.h                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef SLIDER_JOINT_3D_H
+#define SLIDER_JOINT_3D_H
+
+#include "scene/3d/physics/joints/joint_3d.h"
+
+class SliderJoint3D : public Joint3D {
+	GDCLASS(SliderJoint3D, Joint3D);
+
+public:
+	enum Param {
+		PARAM_LINEAR_LIMIT_UPPER = PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_UPPER,
+		PARAM_LINEAR_LIMIT_LOWER = PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_LOWER,
+		PARAM_LINEAR_LIMIT_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS,
+		PARAM_LINEAR_LIMIT_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION,
+		PARAM_LINEAR_LIMIT_DAMPING = PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_DAMPING,
+		PARAM_LINEAR_MOTION_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_LINEAR_MOTION_SOFTNESS,
+		PARAM_LINEAR_MOTION_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_LINEAR_MOTION_RESTITUTION,
+		PARAM_LINEAR_MOTION_DAMPING = PhysicsServer3D::SLIDER_JOINT_LINEAR_MOTION_DAMPING,
+		PARAM_LINEAR_ORTHOGONAL_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_LINEAR_ORTHOGONAL_SOFTNESS,
+		PARAM_LINEAR_ORTHOGONAL_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_LINEAR_ORTHOGONAL_RESTITUTION,
+		PARAM_LINEAR_ORTHOGONAL_DAMPING = PhysicsServer3D::SLIDER_JOINT_LINEAR_ORTHOGONAL_DAMPING,
+
+		PARAM_ANGULAR_LIMIT_UPPER = PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_UPPER,
+		PARAM_ANGULAR_LIMIT_LOWER = PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_LOWER,
+		PARAM_ANGULAR_LIMIT_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS,
+		PARAM_ANGULAR_LIMIT_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_RESTITUTION,
+		PARAM_ANGULAR_LIMIT_DAMPING = PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_DAMPING,
+		PARAM_ANGULAR_MOTION_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_ANGULAR_MOTION_SOFTNESS,
+		PARAM_ANGULAR_MOTION_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_ANGULAR_MOTION_RESTITUTION,
+		PARAM_ANGULAR_MOTION_DAMPING = PhysicsServer3D::SLIDER_JOINT_ANGULAR_MOTION_DAMPING,
+		PARAM_ANGULAR_ORTHOGONAL_SOFTNESS = PhysicsServer3D::SLIDER_JOINT_ANGULAR_ORTHOGONAL_SOFTNESS,
+		PARAM_ANGULAR_ORTHOGONAL_RESTITUTION = PhysicsServer3D::SLIDER_JOINT_ANGULAR_ORTHOGONAL_RESTITUTION,
+		PARAM_ANGULAR_ORTHOGONAL_DAMPING = PhysicsServer3D::SLIDER_JOINT_ANGULAR_ORTHOGONAL_DAMPING,
+		PARAM_MAX = PhysicsServer3D::SLIDER_JOINT_MAX
+
+	};
+
+protected:
+	real_t params[PARAM_MAX];
+	virtual void _configure_joint(RID p_joint, PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_param(Param p_param, real_t p_value);
+	real_t get_param(Param p_param) const;
+
+	SliderJoint3D();
+};
+
+VARIANT_ENUM_CAST(SliderJoint3D::Param);
+
+#endif // SLIDER_JOINT_3D_H
diff --git a/scene/3d/physics/kinematic_collision_3d.cpp b/scene/3d/physics/kinematic_collision_3d.cpp
new file mode 100644
index 0000000000..54371425bc
--- /dev/null
+++ b/scene/3d/physics/kinematic_collision_3d.cpp
@@ -0,0 +1,134 @@
+/**************************************************************************/
+/*  kinematic_collision_3d.cpp                                            */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "kinematic_collision_3d.h"
+
+#include "scene/3d/physics/character_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+
+Vector3 KinematicCollision3D::get_travel() const {
+	return result.travel;
+}
+
+Vector3 KinematicCollision3D::get_remainder() const {
+	return result.remainder;
+}
+
+int KinematicCollision3D::get_collision_count() const {
+	return result.collision_count;
+}
+
+real_t KinematicCollision3D::get_depth() const {
+	return result.collision_depth;
+}
+
+Vector3 KinematicCollision3D::get_position(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, Vector3());
+	return result.collisions[p_collision_index].position;
+}
+
+Vector3 KinematicCollision3D::get_normal(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, Vector3());
+	return result.collisions[p_collision_index].normal;
+}
+
+real_t KinematicCollision3D::get_angle(int p_collision_index, const Vector3 &p_up_direction) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, 0.0);
+	ERR_FAIL_COND_V(p_up_direction == Vector3(), 0);
+	return result.collisions[p_collision_index].get_angle(p_up_direction);
+}
+
+Object *KinematicCollision3D::get_local_shape(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, nullptr);
+	if (!owner) {
+		return nullptr;
+	}
+	uint32_t ownerid = owner->shape_find_owner(result.collisions[p_collision_index].local_shape);
+	return owner->shape_owner_get_owner(ownerid);
+}
+
+Object *KinematicCollision3D::get_collider(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, nullptr);
+	if (result.collisions[p_collision_index].collider_id.is_valid()) {
+		return ObjectDB::get_instance(result.collisions[p_collision_index].collider_id);
+	}
+
+	return nullptr;
+}
+
+ObjectID KinematicCollision3D::get_collider_id(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, ObjectID());
+	return result.collisions[p_collision_index].collider_id;
+}
+
+RID KinematicCollision3D::get_collider_rid(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, RID());
+	return result.collisions[p_collision_index].collider;
+}
+
+Object *KinematicCollision3D::get_collider_shape(int p_collision_index) const {
+	Object *collider = get_collider(p_collision_index);
+	if (collider) {
+		CollisionObject3D *obj2d = Object::cast_to<CollisionObject3D>(collider);
+		if (obj2d) {
+			uint32_t ownerid = obj2d->shape_find_owner(result.collisions[p_collision_index].collider_shape);
+			return obj2d->shape_owner_get_owner(ownerid);
+		}
+	}
+
+	return nullptr;
+}
+
+int KinematicCollision3D::get_collider_shape_index(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, 0);
+	return result.collisions[p_collision_index].collider_shape;
+}
+
+Vector3 KinematicCollision3D::get_collider_velocity(int p_collision_index) const {
+	ERR_FAIL_INDEX_V(p_collision_index, result.collision_count, Vector3());
+	return result.collisions[p_collision_index].collider_velocity;
+}
+
+void KinematicCollision3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision3D::get_travel);
+	ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision3D::get_remainder);
+	ClassDB::bind_method(D_METHOD("get_depth"), &KinematicCollision3D::get_depth);
+	ClassDB::bind_method(D_METHOD("get_collision_count"), &KinematicCollision3D::get_collision_count);
+	ClassDB::bind_method(D_METHOD("get_position", "collision_index"), &KinematicCollision3D::get_position, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_normal", "collision_index"), &KinematicCollision3D::get_normal, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_angle", "collision_index", "up_direction"), &KinematicCollision3D::get_angle, DEFVAL(0), DEFVAL(Vector3(0.0, 1.0, 0.0)));
+	ClassDB::bind_method(D_METHOD("get_local_shape", "collision_index"), &KinematicCollision3D::get_local_shape, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider", "collision_index"), &KinematicCollision3D::get_collider, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider_id", "collision_index"), &KinematicCollision3D::get_collider_id, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider_rid", "collision_index"), &KinematicCollision3D::get_collider_rid, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider_shape", "collision_index"), &KinematicCollision3D::get_collider_shape, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider_shape_index", "collision_index"), &KinematicCollision3D::get_collider_shape_index, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_collider_velocity", "collision_index"), &KinematicCollision3D::get_collider_velocity, DEFVAL(0));
+}
diff --git a/scene/3d/physics/kinematic_collision_3d.h b/scene/3d/physics/kinematic_collision_3d.h
new file mode 100644
index 0000000000..656531c82b
--- /dev/null
+++ b/scene/3d/physics/kinematic_collision_3d.h
@@ -0,0 +1,68 @@
+/**************************************************************************/
+/*  kinematic_collision_3d.h                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef KINEMATIC_COLLISION_3D_H
+#define KINEMATIC_COLLISION_3D_H
+
+#include "core/object/ref_counted.h"
+#include "servers/physics_server_3d.h"
+
+class CharacterBody3D;
+class PhysicsBody3D;
+
+class KinematicCollision3D : public RefCounted {
+	GDCLASS(KinematicCollision3D, RefCounted);
+
+	PhysicsBody3D *owner = nullptr;
+	friend class PhysicsBody3D;
+	friend class CharacterBody3D;
+	PhysicsServer3D::MotionResult result;
+
+protected:
+	static void _bind_methods();
+
+public:
+	Vector3 get_travel() const;
+	Vector3 get_remainder() const;
+	int get_collision_count() const;
+	real_t get_depth() const;
+	Vector3 get_position(int p_collision_index = 0) const;
+	Vector3 get_normal(int p_collision_index = 0) const;
+	real_t get_angle(int p_collision_index = 0, const Vector3 &p_up_direction = Vector3(0.0, 1.0, 0.0)) const;
+	Object *get_local_shape(int p_collision_index = 0) const;
+	Object *get_collider(int p_collision_index = 0) const;
+	ObjectID get_collider_id(int p_collision_index = 0) const;
+	RID get_collider_rid(int p_collision_index = 0) const;
+	Object *get_collider_shape(int p_collision_index = 0) const;
+	int get_collider_shape_index(int p_collision_index = 0) const;
+	Vector3 get_collider_velocity(int p_collision_index = 0) const;
+};
+
+#endif // KINEMATIC_COLLISION_3D_H
diff --git a/scene/3d/physics/physical_bone_3d.cpp b/scene/3d/physics/physical_bone_3d.cpp
new file mode 100644
index 0000000000..10c1fceb94
--- /dev/null
+++ b/scene/3d/physics/physical_bone_3d.cpp
@@ -0,0 +1,1346 @@
+/**************************************************************************/
+/*  physical_bone_3d.cpp                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "physical_bone_3d.h"
+
+bool PhysicalBone3D::JointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
+	return false;
+}
+
+bool PhysicalBone3D::JointData::_get(const StringName &p_name, Variant &r_ret) const {
+	return false;
+}
+
+void PhysicalBone3D::JointData::_get_property_list(List<PropertyInfo> *p_list) const {
+}
+
+void PhysicalBone3D::apply_central_impulse(const Vector3 &p_impulse) {
+	PhysicsServer3D::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);
+}
+
+void PhysicalBone3D::apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position) {
+	PhysicsServer3D::get_singleton()->body_apply_impulse(get_rid(), p_impulse, p_position);
+}
+
+void PhysicalBone3D::set_linear_velocity(const Vector3 &p_velocity) {
+	linear_velocity = p_velocity;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
+}
+
+Vector3 PhysicalBone3D::get_linear_velocity() const {
+	return linear_velocity;
+}
+
+void PhysicalBone3D::set_angular_velocity(const Vector3 &p_velocity) {
+	angular_velocity = p_velocity;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
+}
+
+Vector3 PhysicalBone3D::get_angular_velocity() const {
+	return angular_velocity;
+}
+
+void PhysicalBone3D::set_use_custom_integrator(bool p_enable) {
+	if (custom_integrator == p_enable) {
+		return;
+	}
+
+	custom_integrator = p_enable;
+	PhysicsServer3D::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
+}
+
+bool PhysicalBone3D::is_using_custom_integrator() {
+	return custom_integrator;
+}
+
+void PhysicalBone3D::reset_physics_simulation_state() {
+	if (simulate_physics) {
+		_start_physics_simulation();
+	} else {
+		_stop_physics_simulation();
+	}
+}
+
+void PhysicalBone3D::reset_to_rest_position() {
+	if (parent_skeleton) {
+		Transform3D new_transform = parent_skeleton->get_global_transform();
+		if (bone_id == -1) {
+			new_transform *= body_offset;
+		} else {
+			new_transform *= parent_skeleton->get_bone_global_pose(bone_id) * body_offset;
+		}
+		new_transform.orthonormalize();
+		set_global_transform(new_transform);
+	}
+}
+
+bool PhysicalBone3D::PinJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
+	if (JointData::_set(p_name, p_value, j)) {
+		return true;
+	}
+
+	bool is_valid_pin = j.is_valid() && PhysicsServer3D::get_singleton()->joint_get_type(j) == PhysicsServer3D::JOINT_TYPE_PIN;
+	if ("joint_constraints/bias" == p_name) {
+		bias = p_value;
+		if (is_valid_pin) {
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(j, PhysicsServer3D::PIN_JOINT_BIAS, bias);
+		}
+
+	} else if ("joint_constraints/damping" == p_name) {
+		damping = p_value;
+		if (is_valid_pin) {
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(j, PhysicsServer3D::PIN_JOINT_DAMPING, damping);
+		}
+
+	} else if ("joint_constraints/impulse_clamp" == p_name) {
+		impulse_clamp = p_value;
+		if (is_valid_pin) {
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(j, PhysicsServer3D::PIN_JOINT_IMPULSE_CLAMP, impulse_clamp);
+		}
+
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+bool PhysicalBone3D::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 PhysicalBone3D::PinJointData::_get_property_list(List<PropertyInfo> *p_list) const {
+	JointData::_get_property_list(p_list);
+
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/bias"), PROPERTY_HINT_RANGE, "0.01,0.99,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/damping"), PROPERTY_HINT_RANGE, "0.01,8.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/impulse_clamp"), PROPERTY_HINT_RANGE, "0.0,64.0,0.01"));
+}
+
+bool PhysicalBone3D::ConeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
+	if (JointData::_set(p_name, p_value, j)) {
+		return true;
+	}
+
+	bool is_valid_cone = j.is_valid() && PhysicsServer3D::get_singleton()->joint_get_type(j) == PhysicsServer3D::JOINT_TYPE_CONE_TWIST;
+	if ("joint_constraints/swing_span" == p_name) {
+		swing_span = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_cone) {
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(j, PhysicsServer3D::CONE_TWIST_JOINT_SWING_SPAN, swing_span);
+		}
+
+	} else if ("joint_constraints/twist_span" == p_name) {
+		twist_span = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_cone) {
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(j, PhysicsServer3D::CONE_TWIST_JOINT_TWIST_SPAN, twist_span);
+		}
+
+	} else if ("joint_constraints/bias" == p_name) {
+		bias = p_value;
+		if (is_valid_cone) {
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(j, PhysicsServer3D::CONE_TWIST_JOINT_BIAS, bias);
+		}
+
+	} else if ("joint_constraints/softness" == p_name) {
+		softness = p_value;
+		if (is_valid_cone) {
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(j, PhysicsServer3D::CONE_TWIST_JOINT_SOFTNESS, softness);
+		}
+
+	} else if ("joint_constraints/relaxation" == p_name) {
+		relaxation = p_value;
+		if (is_valid_cone) {
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(j, PhysicsServer3D::CONE_TWIST_JOINT_RELAXATION, relaxation);
+		}
+
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+bool PhysicalBone3D::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::rad_to_deg(swing_span);
+	} else if ("joint_constraints/twist_span" == p_name) {
+		r_ret = Math::rad_to_deg(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 PhysicalBone3D::ConeJointData::_get_property_list(List<PropertyInfo> *p_list) const {
+	JointData::_get_property_list(p_list);
+
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/swing_span"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/twist_span"), PROPERTY_HINT_RANGE, "-40000,40000,0.1,or_less,or_greater"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/bias"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/relaxation"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+}
+
+bool PhysicalBone3D::HingeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
+	if (JointData::_set(p_name, p_value, j)) {
+		return true;
+	}
+
+	bool is_valid_hinge = j.is_valid() && PhysicsServer3D::get_singleton()->joint_get_type(j) == PhysicsServer3D::JOINT_TYPE_HINGE;
+	if ("joint_constraints/angular_limit_enabled" == p_name) {
+		angular_limit_enabled = p_value;
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_flag(j, PhysicsServer3D::HINGE_JOINT_FLAG_USE_LIMIT, angular_limit_enabled);
+		}
+
+	} else if ("joint_constraints/angular_limit_upper" == p_name) {
+		angular_limit_upper = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(j, PhysicsServer3D::HINGE_JOINT_LIMIT_UPPER, angular_limit_upper);
+		}
+
+	} else if ("joint_constraints/angular_limit_lower" == p_name) {
+		angular_limit_lower = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(j, PhysicsServer3D::HINGE_JOINT_LIMIT_LOWER, angular_limit_lower);
+		}
+
+	} else if ("joint_constraints/angular_limit_bias" == p_name) {
+		angular_limit_bias = p_value;
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(j, PhysicsServer3D::HINGE_JOINT_LIMIT_BIAS, angular_limit_bias);
+		}
+
+	} else if ("joint_constraints/angular_limit_softness" == p_name) {
+		angular_limit_softness = p_value;
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(j, PhysicsServer3D::HINGE_JOINT_LIMIT_SOFTNESS, angular_limit_softness);
+		}
+
+	} else if ("joint_constraints/angular_limit_relaxation" == p_name) {
+		angular_limit_relaxation = p_value;
+		if (is_valid_hinge) {
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(j, PhysicsServer3D::HINGE_JOINT_LIMIT_RELAXATION, angular_limit_relaxation);
+		}
+
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+bool PhysicalBone3D::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::rad_to_deg(angular_limit_upper);
+	} else if ("joint_constraints/angular_limit_lower" == p_name) {
+		r_ret = Math::rad_to_deg(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 PhysicalBone3D::HingeJointData::_get_property_list(List<PropertyInfo> *p_list) const {
+	JointData::_get_property_list(p_list);
+
+	p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("joint_constraints/angular_limit_enabled")));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_bias"), PROPERTY_HINT_RANGE, "0.01,0.99,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_relaxation"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+}
+
+bool PhysicalBone3D::SliderJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
+	if (JointData::_set(p_name, p_value, j)) {
+		return true;
+	}
+
+	bool is_valid_slider = j.is_valid() && PhysicsServer3D::get_singleton()->joint_get_type(j) == PhysicsServer3D::JOINT_TYPE_SLIDER;
+	if ("joint_constraints/linear_limit_upper" == p_name) {
+		linear_limit_upper = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_UPPER, linear_limit_upper);
+		}
+
+	} else if ("joint_constraints/linear_limit_lower" == p_name) {
+		linear_limit_lower = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_LOWER, linear_limit_lower);
+		}
+
+	} else if ("joint_constraints/linear_limit_softness" == p_name) {
+		linear_limit_softness = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS, linear_limit_softness);
+		}
+
+	} else if ("joint_constraints/linear_limit_restitution" == p_name) {
+		linear_limit_restitution = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION, linear_limit_restitution);
+		}
+
+	} else if ("joint_constraints/linear_limit_damping" == p_name) {
+		linear_limit_damping = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_DAMPING, linear_limit_restitution);
+		}
+
+	} else if ("joint_constraints/angular_limit_upper" == p_name) {
+		angular_limit_upper = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_UPPER, angular_limit_upper);
+		}
+
+	} else if ("joint_constraints/angular_limit_lower" == p_name) {
+		angular_limit_lower = Math::deg_to_rad(real_t(p_value));
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_LOWER, angular_limit_lower);
+		}
+
+	} else if ("joint_constraints/angular_limit_softness" == p_name) {
+		angular_limit_softness = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS, angular_limit_softness);
+		}
+
+	} else if ("joint_constraints/angular_limit_restitution" == p_name) {
+		angular_limit_restitution = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS, angular_limit_softness);
+		}
+
+	} else if ("joint_constraints/angular_limit_damping" == p_name) {
+		angular_limit_damping = p_value;
+		if (is_valid_slider) {
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(j, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_DAMPING, angular_limit_damping);
+		}
+
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+bool PhysicalBone3D::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::rad_to_deg(angular_limit_upper);
+	} else if ("joint_constraints/angular_limit_lower" == p_name) {
+		r_ret = Math::rad_to_deg(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 PhysicalBone3D::SliderJointData::_get_property_list(List<PropertyInfo> *p_list) const {
+	JointData::_get_property_list(p_list);
+
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/linear_limit_upper")));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/linear_limit_lower")));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/linear_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/linear_limit_restitution"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/linear_limit_damping"), PROPERTY_HINT_RANGE, "0,16.0,0.01"));
+
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_restitution"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
+	p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("joint_constraints/angular_limit_damping"), PROPERTY_HINT_RANGE, "0,16.0,0.01"));
+}
+
+bool PhysicalBone3D::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;
+
+	if (!path.begins_with("joint_constraints/")) {
+		return false;
+	}
+
+	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);
+	bool is_valid_6dof = j.is_valid() && PhysicsServer3D::get_singleton()->joint_get_type(j) == PhysicsServer3D::JOINT_TYPE_6DOF;
+	if ("linear_limit_enabled" == var_name) {
+		axis_data[axis].linear_limit_enabled = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS, axis_data[axis].linear_limit_softness);
+		}
+
+	} else if ("linear_spring_enabled" == var_name) {
+		axis_data[axis].linear_spring_enabled = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(j, axis, PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_SPRING, axis_data[axis].linear_spring_enabled);
+		}
+
+	} else if ("linear_spring_stiffness" == var_name) {
+		axis_data[axis].linear_spring_stiffness = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_STIFFNESS, axis_data[axis].linear_spring_stiffness);
+		}
+
+	} else if ("linear_spring_damping" == var_name) {
+		axis_data[axis].linear_spring_damping = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_DAMPING, axis_data[axis].linear_spring_damping);
+		}
+
+	} else if ("linear_equilibrium_point" == var_name) {
+		axis_data[axis].linear_equilibrium_point = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_EQUILIBRIUM_POINT, axis_data[axis].linear_equilibrium_point);
+		}
+
+	} else if ("linear_restitution" == var_name) {
+		axis_data[axis].linear_restitution = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_LINEAR_RESTITUTION, axis_data[axis].linear_restitution);
+		}
+
+	} else if ("linear_damping" == var_name) {
+		axis_data[axis].linear_damping = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(j, axis, PhysicsServer3D::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::deg_to_rad(real_t(p_value));
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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::deg_to_rad(real_t(p_value));
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::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 (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_RESTITUTION, axis_data[axis].angular_restitution);
+		}
+
+	} else if ("angular_damping" == var_name) {
+		axis_data[axis].angular_damping = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_DAMPING, axis_data[axis].angular_damping);
+		}
+
+	} else if ("erp" == var_name) {
+		axis_data[axis].erp = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_ERP, axis_data[axis].erp);
+		}
+
+	} else if ("angular_spring_enabled" == var_name) {
+		axis_data[axis].angular_spring_enabled = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(j, axis, PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_SPRING, axis_data[axis].angular_spring_enabled);
+		}
+
+	} else if ("angular_spring_stiffness" == var_name) {
+		axis_data[axis].angular_spring_stiffness = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_STIFFNESS, axis_data[axis].angular_spring_stiffness);
+		}
+
+	} else if ("angular_spring_damping" == var_name) {
+		axis_data[axis].angular_spring_damping = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_DAMPING, axis_data[axis].angular_spring_damping);
+		}
+
+	} else if ("angular_equilibrium_point" == var_name) {
+		axis_data[axis].angular_equilibrium_point = p_value;
+		if (is_valid_6dof) {
+			PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(j, axis, PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_EQUILIBRIUM_POINT, axis_data[axis].angular_equilibrium_point);
+		}
+
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+bool PhysicalBone3D::SixDOFJointData::_get(const StringName &p_name, Variant &r_ret) const {
+	if (JointData::_get(p_name, r_ret)) {
+		return true;
+	}
+
+	String path = p_name;
+
+	if (!path.begins_with("joint_constraints/")) {
+		return false;
+	}
+
+	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_spring_enabled" == var_name) {
+		r_ret = axis_data[axis].linear_spring_enabled;
+	} else if ("linear_spring_stiffness" == var_name) {
+		r_ret = axis_data[axis].linear_spring_stiffness;
+	} else if ("linear_spring_damping" == var_name) {
+		r_ret = axis_data[axis].linear_spring_damping;
+	} else if ("linear_equilibrium_point" == var_name) {
+		r_ret = axis_data[axis].linear_equilibrium_point;
+	} 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::rad_to_deg(axis_data[axis].angular_limit_upper);
+	} else if ("angular_limit_lower" == var_name) {
+		r_ret = Math::rad_to_deg(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 if ("angular_spring_enabled" == var_name) {
+		r_ret = axis_data[axis].angular_spring_enabled;
+	} else if ("angular_spring_stiffness" == var_name) {
+		r_ret = axis_data[axis].angular_spring_stiffness;
+	} else if ("angular_spring_damping" == var_name) {
+		r_ret = axis_data[axis].angular_spring_damping;
+	} else if ("angular_equilibrium_point" == var_name) {
+		r_ret = axis_data[axis].angular_equilibrium_point;
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+void PhysicalBone3D::SixDOFJointData::_get_property_list(List<PropertyInfo> *p_list) const {
+	const StringName axis_names[] = { PNAME("x"), PNAME("y"), PNAME("z") };
+	for (int i = 0; i < 3; ++i) {
+		const String prefix = vformat("%s/%s/", PNAME("joint_constraints"), axis_names[i]);
+		p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("linear_limit_enabled")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_limit_upper")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_limit_lower")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("linear_spring_enabled")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_spring_stiffness")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_spring_damping")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_equilibrium_point")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_restitution"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("linear_damping"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("angular_limit_enabled")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_restitution"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_damping"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("erp")));
+		p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("angular_spring_enabled")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_spring_stiffness")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_spring_damping")));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, prefix + PNAME("angular_equilibrium_point")));
+	}
+}
+
+bool PhysicalBone3D::_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, joint)) {
+#ifdef TOOLS_ENABLED
+			update_gizmos();
+#endif
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool PhysicalBone3D::_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 PhysicalBone3D::_get_property_list(List<PropertyInfo> *p_list) const {
+	Skeleton3D *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_NAME, PNAME("bone_name"), PROPERTY_HINT_ENUM, names));
+	} else {
+		p_list->push_back(PropertyInfo(Variant::STRING_NAME, PNAME("bone_name")));
+	}
+
+	if (joint_data) {
+		joint_data->_get_property_list(p_list);
+	}
+}
+
+void PhysicalBone3D::_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();
+			if (joint_data) {
+				_reload_joint();
+			}
+			break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (parent_skeleton) {
+				if (-1 != bone_id) {
+					parent_skeleton->unbind_physical_bone_from_bone(bone_id);
+					bone_id = -1;
+				}
+			}
+			parent_skeleton = nullptr;
+			PhysicsServer3D::get_singleton()->joint_clear(joint);
+		} break;
+
+		case NOTIFICATION_TRANSFORM_CHANGED: {
+			if (Engine::get_singleton()->is_editor_hint()) {
+				update_offset();
+			}
+		} break;
+	}
+}
+
+void PhysicalBone3D::_sync_body_state(PhysicsDirectBodyState3D *p_state) {
+	set_ignore_transform_notification(true);
+	set_global_transform(p_state->get_transform());
+	set_ignore_transform_notification(false);
+
+	linear_velocity = p_state->get_linear_velocity();
+	angular_velocity = p_state->get_angular_velocity();
+}
+
+void PhysicalBone3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
+	if (!simulate_physics || !_internal_simulate_physics) {
+		return;
+	}
+
+	if (GDVIRTUAL_IS_OVERRIDDEN(_integrate_forces)) {
+		_sync_body_state(p_state);
+
+		Transform3D old_transform = get_global_transform();
+		GDVIRTUAL_CALL(_integrate_forces, p_state);
+		Transform3D new_transform = get_global_transform();
+
+		if (new_transform != old_transform) {
+			// Update the physics server with the new transform, to prevent it from being overwritten at the sync below.
+			PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_TRANSFORM, new_transform);
+		}
+	}
+
+	_sync_body_state(p_state);
+	_on_transform_changed();
+
+	Transform3D global_transform(p_state->get_transform());
+
+	// Update skeleton
+	if (parent_skeleton) {
+		if (-1 != bone_id) {
+			parent_skeleton->set_bone_global_pose_override(bone_id, parent_skeleton->get_global_transform().affine_inverse() * (global_transform * body_offset_inverse), 1.0, true);
+		}
+	}
+}
+
+void PhysicalBone3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &PhysicalBone3D::apply_central_impulse);
+	ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &PhysicalBone3D::apply_impulse, Vector3());
+
+	ClassDB::bind_method(D_METHOD("set_joint_type", "joint_type"), &PhysicalBone3D::set_joint_type);
+	ClassDB::bind_method(D_METHOD("get_joint_type"), &PhysicalBone3D::get_joint_type);
+
+	ClassDB::bind_method(D_METHOD("set_joint_offset", "offset"), &PhysicalBone3D::set_joint_offset);
+	ClassDB::bind_method(D_METHOD("get_joint_offset"), &PhysicalBone3D::get_joint_offset);
+	ClassDB::bind_method(D_METHOD("set_joint_rotation", "euler"), &PhysicalBone3D::set_joint_rotation);
+	ClassDB::bind_method(D_METHOD("get_joint_rotation"), &PhysicalBone3D::get_joint_rotation);
+
+	ClassDB::bind_method(D_METHOD("set_body_offset", "offset"), &PhysicalBone3D::set_body_offset);
+	ClassDB::bind_method(D_METHOD("get_body_offset"), &PhysicalBone3D::get_body_offset);
+
+	ClassDB::bind_method(D_METHOD("get_simulate_physics"), &PhysicalBone3D::get_simulate_physics);
+
+	ClassDB::bind_method(D_METHOD("is_simulating_physics"), &PhysicalBone3D::is_simulating_physics);
+
+	ClassDB::bind_method(D_METHOD("get_bone_id"), &PhysicalBone3D::get_bone_id);
+
+	ClassDB::bind_method(D_METHOD("set_mass", "mass"), &PhysicalBone3D::set_mass);
+	ClassDB::bind_method(D_METHOD("get_mass"), &PhysicalBone3D::get_mass);
+
+	ClassDB::bind_method(D_METHOD("set_friction", "friction"), &PhysicalBone3D::set_friction);
+	ClassDB::bind_method(D_METHOD("get_friction"), &PhysicalBone3D::get_friction);
+
+	ClassDB::bind_method(D_METHOD("set_bounce", "bounce"), &PhysicalBone3D::set_bounce);
+	ClassDB::bind_method(D_METHOD("get_bounce"), &PhysicalBone3D::get_bounce);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &PhysicalBone3D::set_gravity_scale);
+	ClassDB::bind_method(D_METHOD("get_gravity_scale"), &PhysicalBone3D::get_gravity_scale);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp_mode", "linear_damp_mode"), &PhysicalBone3D::set_linear_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_linear_damp_mode"), &PhysicalBone3D::get_linear_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp_mode", "angular_damp_mode"), &PhysicalBone3D::set_angular_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_angular_damp_mode"), &PhysicalBone3D::get_angular_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &PhysicalBone3D::set_linear_damp);
+	ClassDB::bind_method(D_METHOD("get_linear_damp"), &PhysicalBone3D::get_linear_damp);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &PhysicalBone3D::set_angular_damp);
+	ClassDB::bind_method(D_METHOD("get_angular_damp"), &PhysicalBone3D::get_angular_damp);
+
+	ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &PhysicalBone3D::set_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &PhysicalBone3D::get_linear_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &PhysicalBone3D::set_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_angular_velocity"), &PhysicalBone3D::get_angular_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &PhysicalBone3D::set_use_custom_integrator);
+	ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &PhysicalBone3D::is_using_custom_integrator);
+
+	ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &PhysicalBone3D::set_can_sleep);
+	ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &PhysicalBone3D::is_able_to_sleep);
+
+	GDVIRTUAL_BIND(_integrate_forces, "state");
+
+	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::TRANSFORM3D, "joint_offset", PROPERTY_HINT_NONE, "suffix:m"), "set_joint_offset", "get_joint_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "joint_rotation", PROPERTY_HINT_RANGE, "-360,360,0.01,or_less,or_greater,radians_as_degrees"), "set_joint_rotation", "get_joint_rotation");
+
+	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM3D, "body_offset", PROPERTY_HINT_NONE, "suffix:m"), "set_body_offset", "get_body_offset");
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "mass", PROPERTY_HINT_RANGE, "0.01,1000,0.01,or_greater,exp,suffix:kg"), "set_mass", "get_mass");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "friction", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_friction", "get_friction");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_bounce", "get_bounce");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "gravity_scale", PROPERTY_HINT_RANGE, "-8,8,0.001,or_less,or_greater"), "set_gravity_scale", "get_gravity_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "custom_integrator"), "set_use_custom_integrator", "is_using_custom_integrator");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "linear_damp_mode", PROPERTY_HINT_ENUM, "Combine,Replace"), "set_linear_damp_mode", "get_linear_damp_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "linear_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_linear_damp", "get_linear_damp");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "angular_damp_mode", PROPERTY_HINT_ENUM, "Combine,Replace"), "set_angular_damp_mode", "get_angular_damp_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_angular_damp", "get_angular_damp");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "linear_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_linear_velocity", "get_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_angular_velocity", "get_angular_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "can_sleep"), "set_can_sleep", "is_able_to_sleep");
+
+	BIND_ENUM_CONSTANT(DAMP_MODE_COMBINE);
+	BIND_ENUM_CONSTANT(DAMP_MODE_REPLACE);
+
+	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);
+}
+
+Skeleton3D *PhysicalBone3D::find_skeleton_parent(Node *p_parent) {
+	if (!p_parent) {
+		return nullptr;
+	}
+	Skeleton3D *s = Object::cast_to<Skeleton3D>(p_parent);
+	return s ? s : find_skeleton_parent(p_parent->get_parent());
+}
+
+void PhysicalBone3D::_update_joint_offset() {
+	_fix_joint_offset();
+
+	set_ignore_transform_notification(true);
+	reset_to_rest_position();
+	set_ignore_transform_notification(false);
+
+#ifdef TOOLS_ENABLED
+	update_gizmos();
+#endif
+}
+
+void PhysicalBone3D::_fix_joint_offset() {
+	// Clamp joint origin to bone origin
+	if (parent_skeleton) {
+		joint_offset.origin = body_offset.affine_inverse().origin;
+	}
+}
+
+void PhysicalBone3D::_reload_joint() {
+	if (!parent_skeleton) {
+		PhysicsServer3D::get_singleton()->joint_clear(joint);
+		return;
+	}
+
+	PhysicalBone3D *body_a = parent_skeleton->get_physical_bone_parent(bone_id);
+	if (!body_a) {
+		PhysicsServer3D::get_singleton()->joint_clear(joint);
+		return;
+	}
+
+	Transform3D joint_transf = get_global_transform() * joint_offset;
+	Transform3D local_a = body_a->get_global_transform().affine_inverse() * joint_transf;
+	local_a.orthonormalize();
+
+	switch (get_joint_type()) {
+		case JOINT_TYPE_PIN: {
+			PhysicsServer3D::get_singleton()->joint_make_pin(joint, body_a->get_rid(), local_a.origin, get_rid(), joint_offset.origin);
+			const PinJointData *pjd(static_cast<const PinJointData *>(joint_data));
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(joint, PhysicsServer3D::PIN_JOINT_BIAS, pjd->bias);
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(joint, PhysicsServer3D::PIN_JOINT_DAMPING, pjd->damping);
+			PhysicsServer3D::get_singleton()->pin_joint_set_param(joint, PhysicsServer3D::PIN_JOINT_IMPULSE_CLAMP, pjd->impulse_clamp);
+
+		} break;
+		case JOINT_TYPE_CONE: {
+			PhysicsServer3D::get_singleton()->joint_make_cone_twist(joint, body_a->get_rid(), local_a, get_rid(), joint_offset);
+			const ConeJointData *cjd(static_cast<const ConeJointData *>(joint_data));
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(joint, PhysicsServer3D::CONE_TWIST_JOINT_SWING_SPAN, cjd->swing_span);
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(joint, PhysicsServer3D::CONE_TWIST_JOINT_TWIST_SPAN, cjd->twist_span);
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(joint, PhysicsServer3D::CONE_TWIST_JOINT_BIAS, cjd->bias);
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(joint, PhysicsServer3D::CONE_TWIST_JOINT_SOFTNESS, cjd->softness);
+			PhysicsServer3D::get_singleton()->cone_twist_joint_set_param(joint, PhysicsServer3D::CONE_TWIST_JOINT_RELAXATION, cjd->relaxation);
+
+		} break;
+		case JOINT_TYPE_HINGE: {
+			PhysicsServer3D::get_singleton()->joint_make_hinge(joint, body_a->get_rid(), local_a, get_rid(), joint_offset);
+			const HingeJointData *hjd(static_cast<const HingeJointData *>(joint_data));
+			PhysicsServer3D::get_singleton()->hinge_joint_set_flag(joint, PhysicsServer3D::HINGE_JOINT_FLAG_USE_LIMIT, hjd->angular_limit_enabled);
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(joint, PhysicsServer3D::HINGE_JOINT_LIMIT_UPPER, hjd->angular_limit_upper);
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(joint, PhysicsServer3D::HINGE_JOINT_LIMIT_LOWER, hjd->angular_limit_lower);
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(joint, PhysicsServer3D::HINGE_JOINT_LIMIT_BIAS, hjd->angular_limit_bias);
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(joint, PhysicsServer3D::HINGE_JOINT_LIMIT_SOFTNESS, hjd->angular_limit_softness);
+			PhysicsServer3D::get_singleton()->hinge_joint_set_param(joint, PhysicsServer3D::HINGE_JOINT_LIMIT_RELAXATION, hjd->angular_limit_relaxation);
+
+		} break;
+		case JOINT_TYPE_SLIDER: {
+			PhysicsServer3D::get_singleton()->joint_make_slider(joint, body_a->get_rid(), local_a, get_rid(), joint_offset);
+			const SliderJointData *sjd(static_cast<const SliderJointData *>(joint_data));
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_UPPER, sjd->linear_limit_upper);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_LOWER, sjd->linear_limit_lower);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS, sjd->linear_limit_softness);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION, sjd->linear_limit_restitution);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_DAMPING, sjd->linear_limit_restitution);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_UPPER, sjd->angular_limit_upper);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_LOWER, sjd->angular_limit_lower);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS, sjd->angular_limit_softness);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS, sjd->angular_limit_softness);
+			PhysicsServer3D::get_singleton()->slider_joint_set_param(joint, PhysicsServer3D::SLIDER_JOINT_ANGULAR_LIMIT_DAMPING, sjd->angular_limit_damping);
+
+		} break;
+		case JOINT_TYPE_6DOF: {
+			PhysicsServer3D::get_singleton()->joint_make_generic_6dof(joint, 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) {
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT, g6dofjd->axis_data[axis].linear_limit_enabled);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_UPPER_LIMIT, g6dofjd->axis_data[axis].linear_limit_upper);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_LOWER_LIMIT, g6dofjd->axis_data[axis].linear_limit_lower);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS, g6dofjd->axis_data[axis].linear_limit_softness);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_SPRING, g6dofjd->axis_data[axis].linear_spring_enabled);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_STIFFNESS, g6dofjd->axis_data[axis].linear_spring_stiffness);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_DAMPING, g6dofjd->axis_data[axis].linear_spring_damping);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_SPRING_EQUILIBRIUM_POINT, g6dofjd->axis_data[axis].linear_equilibrium_point);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_RESTITUTION, g6dofjd->axis_data[axis].linear_restitution);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_LINEAR_DAMPING, g6dofjd->axis_data[axis].linear_damping);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT, g6dofjd->axis_data[axis].angular_limit_enabled);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_UPPER_LIMIT, g6dofjd->axis_data[axis].angular_limit_upper);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_LOWER_LIMIT, g6dofjd->axis_data[axis].angular_limit_lower);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS, g6dofjd->axis_data[axis].angular_limit_softness);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_RESTITUTION, g6dofjd->axis_data[axis].angular_restitution);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_DAMPING, g6dofjd->axis_data[axis].angular_damping);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_ERP, g6dofjd->axis_data[axis].erp);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_flag(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_SPRING, g6dofjd->axis_data[axis].angular_spring_enabled);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_STIFFNESS, g6dofjd->axis_data[axis].angular_spring_stiffness);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_DAMPING, g6dofjd->axis_data[axis].angular_spring_damping);
+				PhysicsServer3D::get_singleton()->generic_6dof_joint_set_param(joint, static_cast<Vector3::Axis>(axis), PhysicsServer3D::G6DOF_JOINT_ANGULAR_SPRING_EQUILIBRIUM_POINT, g6dofjd->axis_data[axis].angular_equilibrium_point);
+			}
+
+		} break;
+		case JOINT_TYPE_NONE: {
+		} break;
+	}
+}
+
+void PhysicalBone3D::_on_bone_parent_changed() {
+	_reload_joint();
+}
+
+#ifdef TOOLS_ENABLED
+void PhysicalBone3D::_set_gizmo_move_joint(bool p_move_joint) {
+	gizmo_move_joint = p_move_joint;
+}
+
+Transform3D PhysicalBone3D::get_global_gizmo_transform() const {
+	return gizmo_move_joint ? get_global_transform() * joint_offset : get_global_transform();
+}
+
+Transform3D PhysicalBone3D::get_local_gizmo_transform() const {
+	return gizmo_move_joint ? get_transform() * joint_offset : get_transform();
+}
+#endif
+
+const PhysicalBone3D::JointData *PhysicalBone3D::get_joint_data() const {
+	return joint_data;
+}
+
+Skeleton3D *PhysicalBone3D::find_skeleton_parent() {
+	return find_skeleton_parent(this);
+}
+
+void PhysicalBone3D::set_joint_type(JointType p_joint_type) {
+	if (p_joint_type == get_joint_type()) {
+		return;
+	}
+
+	if (joint_data) {
+		memdelete(joint_data);
+	}
+	joint_data = nullptr;
+	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;
+		case JOINT_TYPE_NONE:
+			break;
+	}
+
+	_reload_joint();
+
+#ifdef TOOLS_ENABLED
+	notify_property_list_changed();
+	update_gizmos();
+#endif
+}
+
+PhysicalBone3D::JointType PhysicalBone3D::get_joint_type() const {
+	return joint_data ? joint_data->get_joint_type() : JOINT_TYPE_NONE;
+}
+
+void PhysicalBone3D::set_joint_offset(const Transform3D &p_offset) {
+	joint_offset = p_offset;
+
+	_update_joint_offset();
+}
+
+const Transform3D &PhysicalBone3D::get_joint_offset() const {
+	return joint_offset;
+}
+
+void PhysicalBone3D::set_joint_rotation(const Vector3 &p_euler_rad) {
+	joint_offset.basis.set_euler_scale(p_euler_rad, joint_offset.basis.get_scale());
+
+	_update_joint_offset();
+}
+
+Vector3 PhysicalBone3D::get_joint_rotation() const {
+	return joint_offset.basis.get_euler_normalized();
+}
+
+const Transform3D &PhysicalBone3D::get_body_offset() const {
+	return body_offset;
+}
+
+void PhysicalBone3D::set_body_offset(const Transform3D &p_offset) {
+	body_offset = p_offset;
+	body_offset_inverse = body_offset.affine_inverse();
+
+	_update_joint_offset();
+}
+
+void PhysicalBone3D::set_simulate_physics(bool p_simulate) {
+	if (simulate_physics == p_simulate) {
+		return;
+	}
+
+	simulate_physics = p_simulate;
+	reset_physics_simulation_state();
+}
+
+bool PhysicalBone3D::get_simulate_physics() {
+	return simulate_physics;
+}
+
+bool PhysicalBone3D::is_simulating_physics() {
+	return _internal_simulate_physics;
+}
+
+void PhysicalBone3D::set_bone_name(const String &p_name) {
+	bone_name = p_name;
+	bone_id = -1;
+
+	update_bone_id();
+	reset_to_rest_position();
+}
+
+const String &PhysicalBone3D::get_bone_name() const {
+	return bone_name;
+}
+
+void PhysicalBone3D::set_mass(real_t p_mass) {
+	ERR_FAIL_COND(p_mass <= 0);
+	mass = p_mass;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_MASS, mass);
+}
+
+real_t PhysicalBone3D::get_mass() const {
+	return mass;
+}
+
+void PhysicalBone3D::set_friction(real_t p_friction) {
+	ERR_FAIL_COND(p_friction < 0 || p_friction > 1);
+
+	friction = p_friction;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, friction);
+}
+
+real_t PhysicalBone3D::get_friction() const {
+	return friction;
+}
+
+void PhysicalBone3D::set_bounce(real_t p_bounce) {
+	ERR_FAIL_COND(p_bounce < 0 || p_bounce > 1);
+
+	bounce = p_bounce;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, bounce);
+}
+
+real_t PhysicalBone3D::get_bounce() const {
+	return bounce;
+}
+
+void PhysicalBone3D::set_gravity_scale(real_t p_gravity_scale) {
+	gravity_scale = p_gravity_scale;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
+}
+
+real_t PhysicalBone3D::get_gravity_scale() const {
+	return gravity_scale;
+}
+
+void PhysicalBone3D::set_linear_damp_mode(DampMode p_mode) {
+	linear_damp_mode = p_mode;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_LINEAR_DAMP_MODE, linear_damp_mode);
+}
+
+PhysicalBone3D::DampMode PhysicalBone3D::get_linear_damp_mode() const {
+	return linear_damp_mode;
+}
+
+void PhysicalBone3D::set_angular_damp_mode(DampMode p_mode) {
+	angular_damp_mode = p_mode;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_ANGULAR_DAMP_MODE, angular_damp_mode);
+}
+
+PhysicalBone3D::DampMode PhysicalBone3D::get_angular_damp_mode() const {
+	return angular_damp_mode;
+}
+
+void PhysicalBone3D::set_linear_damp(real_t p_linear_damp) {
+	ERR_FAIL_COND(p_linear_damp < 0);
+
+	linear_damp = p_linear_damp;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_LINEAR_DAMP, linear_damp);
+}
+
+real_t PhysicalBone3D::get_linear_damp() const {
+	return linear_damp;
+}
+
+void PhysicalBone3D::set_angular_damp(real_t p_angular_damp) {
+	ERR_FAIL_COND(p_angular_damp < 0);
+
+	angular_damp = p_angular_damp;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_ANGULAR_DAMP, angular_damp);
+}
+
+real_t PhysicalBone3D::get_angular_damp() const {
+	return angular_damp;
+}
+
+void PhysicalBone3D::set_can_sleep(bool p_active) {
+	can_sleep = p_active;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_CAN_SLEEP, p_active);
+}
+
+bool PhysicalBone3D::is_able_to_sleep() const {
+	return can_sleep;
+}
+
+PhysicalBone3D::PhysicalBone3D() :
+		PhysicsBody3D(PhysicsServer3D::BODY_MODE_STATIC) {
+	joint = PhysicsServer3D::get_singleton()->joint_create();
+	reset_physics_simulation_state();
+}
+
+PhysicalBone3D::~PhysicalBone3D() {
+	if (joint_data) {
+		memdelete(joint_data);
+	}
+	ERR_FAIL_NULL(PhysicsServer3D::get_singleton());
+	PhysicsServer3D::get_singleton()->free(joint);
+}
+
+void PhysicalBone3D::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);
+		}
+
+		bone_id = new_bone_id;
+
+		parent_skeleton->bind_physical_bone_to_bone(bone_id, this);
+
+		_fix_joint_offset();
+		reset_physics_simulation_state();
+	}
+}
+
+void PhysicalBone3D::update_offset() {
+#ifdef TOOLS_ENABLED
+	if (parent_skeleton) {
+		Transform3D 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 PhysicalBone3D::_start_physics_simulation() {
+	if (_internal_simulate_physics || !parent_skeleton) {
+		return;
+	}
+	reset_to_rest_position();
+	set_body_mode(PhysicsServer3D::BODY_MODE_RIGID);
+	PhysicsServer3D::get_singleton()->body_set_collision_layer(get_rid(), get_collision_layer());
+	PhysicsServer3D::get_singleton()->body_set_collision_mask(get_rid(), get_collision_mask());
+	PhysicsServer3D::get_singleton()->body_set_collision_priority(get_rid(), get_collision_priority());
+	PhysicsServer3D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &PhysicalBone3D::_body_state_changed));
+	set_as_top_level(true);
+	_internal_simulate_physics = true;
+}
+
+void PhysicalBone3D::_stop_physics_simulation() {
+	if (!parent_skeleton) {
+		return;
+	}
+	if (parent_skeleton->get_animate_physical_bones()) {
+		set_body_mode(PhysicsServer3D::BODY_MODE_KINEMATIC);
+		PhysicsServer3D::get_singleton()->body_set_collision_layer(get_rid(), get_collision_layer());
+		PhysicsServer3D::get_singleton()->body_set_collision_mask(get_rid(), get_collision_mask());
+		PhysicsServer3D::get_singleton()->body_set_collision_priority(get_rid(), get_collision_priority());
+	} else {
+		set_body_mode(PhysicsServer3D::BODY_MODE_STATIC);
+		PhysicsServer3D::get_singleton()->body_set_collision_layer(get_rid(), 0);
+		PhysicsServer3D::get_singleton()->body_set_collision_mask(get_rid(), 0);
+		PhysicsServer3D::get_singleton()->body_set_collision_priority(get_rid(), 1.0);
+	}
+	if (_internal_simulate_physics) {
+		PhysicsServer3D::get_singleton()->body_set_state_sync_callback(get_rid(), Callable());
+		parent_skeleton->set_bone_global_pose_override(bone_id, Transform3D(), 0.0, false);
+		set_as_top_level(false);
+		_internal_simulate_physics = false;
+	}
+}
diff --git a/scene/3d/physics/physical_bone_3d.h b/scene/3d/physics/physical_bone_3d.h
new file mode 100644
index 0000000000..953400da2f
--- /dev/null
+++ b/scene/3d/physics/physical_bone_3d.h
@@ -0,0 +1,306 @@
+/**************************************************************************/
+/*  physical_bone_3d.h                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef PHYSICAL_BONE_3D_H
+#define PHYSICAL_BONE_3D_H
+
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/skeleton_3d.h"
+
+class PhysicalBone3D : public PhysicsBody3D {
+	GDCLASS(PhysicalBone3D, PhysicsBody3D);
+
+public:
+	enum DampMode {
+		DAMP_MODE_COMBINE,
+		DAMP_MODE_REPLACE,
+	};
+
+	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 PhysicsServer3D
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j);
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		virtual ~JointData() {}
+	};
+
+	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);
+		virtual bool _get(const StringName &p_name, Variant &r_ret) const;
+		virtual void _get_property_list(List<PropertyInfo> *p_list) const;
+
+		real_t bias = 0.3;
+		real_t damping = 1.0;
+		real_t impulse_clamp = 0.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);
+		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 = Math_PI * 0.25;
+		real_t twist_span = Math_PI;
+		real_t bias = 0.3;
+		real_t softness = 0.8;
+		real_t 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);
+		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 = false;
+		real_t angular_limit_upper = Math_PI * 0.5;
+		real_t angular_limit_lower = -Math_PI * 0.5;
+		real_t angular_limit_bias = 0.3;
+		real_t angular_limit_softness = 0.9;
+		real_t 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);
+		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 = 1.0;
+		real_t linear_limit_lower = -1.0;
+		real_t linear_limit_softness = 1.0;
+		real_t linear_limit_restitution = 0.7;
+		real_t linear_limit_damping = 1.0;
+		real_t angular_limit_upper = 0.0;
+		real_t angular_limit_lower = 0.0;
+		real_t angular_limit_softness = 1.0;
+		real_t angular_limit_restitution = 0.7;
+		real_t angular_limit_damping = 1.0;
+	};
+
+	struct SixDOFJointData : public JointData {
+		struct SixDOFAxisData {
+			bool linear_limit_enabled = true;
+			real_t linear_limit_upper = 0.0;
+			real_t linear_limit_lower = 0.0;
+			real_t linear_limit_softness = 0.7;
+			real_t linear_restitution = 0.5;
+			real_t linear_damping = 1.0;
+			bool linear_spring_enabled = false;
+			real_t linear_spring_stiffness = 0.0;
+			real_t linear_spring_damping = 0.0;
+			real_t linear_equilibrium_point = 0.0;
+			bool angular_limit_enabled = true;
+			real_t angular_limit_upper = 0.0;
+			real_t angular_limit_lower = 0.0;
+			real_t angular_limit_softness = 0.5;
+			real_t angular_restitution = 0.0;
+			real_t angular_damping = 1.0;
+			real_t erp = 0.5;
+			bool angular_spring_enabled = false;
+			real_t angular_spring_stiffness = 0.0;
+			real_t angular_spring_damping = 0.0;
+			real_t angular_equilibrium_point = 0.0;
+		};
+
+		virtual JointType get_joint_type() { return JOINT_TYPE_6DOF; }
+
+		virtual bool _set(const StringName &p_name, const Variant &p_value, RID j);
+		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 = false;
+#endif
+
+	JointData *joint_data = nullptr;
+	Transform3D joint_offset;
+	RID joint;
+
+	Skeleton3D *parent_skeleton = nullptr;
+	Transform3D body_offset;
+	Transform3D body_offset_inverse;
+	bool simulate_physics = false;
+	bool _internal_simulate_physics = false;
+	int bone_id = -1;
+
+	String bone_name;
+	real_t bounce = 0.0;
+	real_t mass = 1.0;
+	real_t friction = 1.0;
+	Vector3 linear_velocity;
+	Vector3 angular_velocity;
+	real_t gravity_scale = 1.0;
+	bool can_sleep = true;
+
+	bool custom_integrator = false;
+
+	DampMode linear_damp_mode = DAMP_MODE_COMBINE;
+	DampMode angular_damp_mode = DAMP_MODE_COMBINE;
+
+	real_t linear_damp = 0.0;
+	real_t angular_damp = 0.0;
+
+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);
+	GDVIRTUAL1(_integrate_forces, PhysicsDirectBodyState3D *)
+	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state);
+	void _body_state_changed(PhysicsDirectBodyState3D *p_state);
+
+	static void _bind_methods();
+
+private:
+	void _sync_body_state(PhysicsDirectBodyState3D *p_state);
+	static Skeleton3D *find_skeleton_parent(Node *p_parent);
+
+	void _update_joint_offset();
+	void _fix_joint_offset();
+	void _reload_joint();
+
+public:
+	void _on_bone_parent_changed();
+
+	void set_linear_velocity(const Vector3 &p_velocity);
+	Vector3 get_linear_velocity() const override;
+
+	void set_angular_velocity(const Vector3 &p_velocity);
+	Vector3 get_angular_velocity() const override;
+
+	void set_use_custom_integrator(bool p_enable);
+	bool is_using_custom_integrator();
+
+#ifdef TOOLS_ENABLED
+	void _set_gizmo_move_joint(bool p_move_joint);
+	virtual Transform3D get_global_gizmo_transform() const override;
+	virtual Transform3D get_local_gizmo_transform() const override;
+#endif
+
+	const JointData *get_joint_data() const;
+	Skeleton3D *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 Transform3D &p_offset);
+	const Transform3D &get_joint_offset() const;
+
+	void set_joint_rotation(const Vector3 &p_euler_rad);
+	Vector3 get_joint_rotation() const;
+
+	void set_body_offset(const Transform3D &p_offset);
+	const Transform3D &get_body_offset() const;
+
+	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_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;
+
+	void set_linear_damp_mode(DampMode p_mode);
+	DampMode get_linear_damp_mode() const;
+
+	void set_angular_damp_mode(DampMode p_mode);
+	DampMode get_angular_damp_mode() const;
+
+	void set_linear_damp(real_t p_linear_damp);
+	real_t get_linear_damp() const;
+
+	void set_angular_damp(real_t p_angular_damp);
+	real_t get_angular_damp() const;
+
+	void set_can_sleep(bool p_active);
+	bool is_able_to_sleep() const;
+
+	void apply_central_impulse(const Vector3 &p_impulse);
+	void apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position = Vector3());
+
+	void reset_physics_simulation_state();
+	void reset_to_rest_position();
+
+	PhysicalBone3D();
+	~PhysicalBone3D();
+
+private:
+	void update_bone_id();
+	void update_offset();
+
+	void _start_physics_simulation();
+	void _stop_physics_simulation();
+};
+
+VARIANT_ENUM_CAST(PhysicalBone3D::JointType);
+VARIANT_ENUM_CAST(PhysicalBone3D::DampMode);
+
+#endif // PHYSICAL_BONE_3D_H
diff --git a/scene/3d/physics/physics_body_3d.cpp b/scene/3d/physics/physics_body_3d.cpp
new file mode 100644
index 0000000000..711ca60a81
--- /dev/null
+++ b/scene/3d/physics/physics_body_3d.cpp
@@ -0,0 +1,228 @@
+/**************************************************************************/
+/*  physics_body_3d.cpp                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "physics_body_3d.h"
+
+#include "scene/scene_string_names.h"
+
+void PhysicsBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("move_and_collide", "motion", "test_only", "safe_margin", "recovery_as_collision", "max_collisions"), &PhysicsBody3D::_move, DEFVAL(false), DEFVAL(0.001), DEFVAL(false), DEFVAL(1));
+	ClassDB::bind_method(D_METHOD("test_move", "from", "motion", "collision", "safe_margin", "recovery_as_collision", "max_collisions"), &PhysicsBody3D::test_move, DEFVAL(Variant()), DEFVAL(0.001), DEFVAL(false), DEFVAL(1));
+	ClassDB::bind_method(D_METHOD("get_gravity"), &PhysicsBody3D::get_gravity);
+
+	ClassDB::bind_method(D_METHOD("set_axis_lock", "axis", "lock"), &PhysicsBody3D::set_axis_lock);
+	ClassDB::bind_method(D_METHOD("get_axis_lock", "axis"), &PhysicsBody3D::get_axis_lock);
+
+	ClassDB::bind_method(D_METHOD("get_collision_exceptions"), &PhysicsBody3D::get_collision_exceptions);
+	ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &PhysicsBody3D::add_collision_exception_with);
+	ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &PhysicsBody3D::remove_collision_exception_with);
+
+	ADD_GROUP("Axis Lock", "axis_lock_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_linear_x"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_LINEAR_X);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_linear_y"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_LINEAR_Y);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_linear_z"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_LINEAR_Z);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_angular_x"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_ANGULAR_X);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_angular_y"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_ANGULAR_Y);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "axis_lock_angular_z"), "set_axis_lock", "get_axis_lock", PhysicsServer3D::BODY_AXIS_ANGULAR_Z);
+}
+
+PhysicsBody3D::PhysicsBody3D(PhysicsServer3D::BodyMode p_mode) :
+		CollisionObject3D(PhysicsServer3D::get_singleton()->body_create(), false) {
+	set_body_mode(p_mode);
+}
+
+PhysicsBody3D::~PhysicsBody3D() {
+	if (motion_cache.is_valid()) {
+		motion_cache->owner = nullptr;
+	}
+}
+
+TypedArray<PhysicsBody3D> PhysicsBody3D::get_collision_exceptions() {
+	List<RID> exceptions;
+	PhysicsServer3D::get_singleton()->body_get_collision_exceptions(get_rid(), &exceptions);
+	Array ret;
+	for (const RID &body : exceptions) {
+		ObjectID instance_id = PhysicsServer3D::get_singleton()->body_get_object_instance_id(body);
+		Object *obj = ObjectDB::get_instance(instance_id);
+		PhysicsBody3D *physics_body = Object::cast_to<PhysicsBody3D>(obj);
+		ret.append(physics_body);
+	}
+	return ret;
+}
+
+void PhysicsBody3D::add_collision_exception_with(Node *p_node) {
+	ERR_FAIL_NULL(p_node);
+	CollisionObject3D *collision_object = Object::cast_to<CollisionObject3D>(p_node);
+	ERR_FAIL_NULL_MSG(collision_object, "Collision exception only works between two nodes that inherit from CollisionObject3D (such as Area3D or PhysicsBody3D).");
+	PhysicsServer3D::get_singleton()->body_add_collision_exception(get_rid(), collision_object->get_rid());
+}
+
+void PhysicsBody3D::remove_collision_exception_with(Node *p_node) {
+	ERR_FAIL_NULL(p_node);
+	CollisionObject3D *collision_object = Object::cast_to<CollisionObject3D>(p_node);
+	ERR_FAIL_NULL_MSG(collision_object, "Collision exception only works between two nodes that inherit from CollisionObject3D (such as Area3D or PhysicsBody3D).");
+	PhysicsServer3D::get_singleton()->body_remove_collision_exception(get_rid(), collision_object->get_rid());
+}
+
+Ref<KinematicCollision3D> PhysicsBody3D::_move(const Vector3 &p_motion, bool p_test_only, real_t p_margin, bool p_recovery_as_collision, int p_max_collisions) {
+	PhysicsServer3D::MotionParameters parameters(get_global_transform(), p_motion, p_margin);
+	parameters.max_collisions = p_max_collisions;
+	parameters.recovery_as_collision = p_recovery_as_collision;
+
+	PhysicsServer3D::MotionResult result;
+
+	if (move_and_collide(parameters, result, p_test_only)) {
+		// Create a new instance when the cached reference is invalid or still in use in script.
+		if (motion_cache.is_null() || motion_cache->get_reference_count() > 1) {
+			motion_cache.instantiate();
+			motion_cache->owner = this;
+		}
+
+		motion_cache->result = result;
+
+		return motion_cache;
+	}
+
+	return Ref<KinematicCollision3D>();
+}
+
+bool PhysicsBody3D::move_and_collide(const PhysicsServer3D::MotionParameters &p_parameters, PhysicsServer3D::MotionResult &r_result, bool p_test_only, bool p_cancel_sliding) {
+	bool colliding = PhysicsServer3D::get_singleton()->body_test_motion(get_rid(), p_parameters, &r_result);
+
+	// Restore direction of motion to be along original motion,
+	// in order to avoid sliding due to recovery,
+	// but only if collision depth is low enough to avoid tunneling.
+	if (p_cancel_sliding) {
+		real_t motion_length = p_parameters.motion.length();
+		real_t precision = 0.001;
+
+		if (colliding) {
+			// Can't just use margin as a threshold because collision depth is calculated on unsafe motion,
+			// so even in normal resting cases the depth can be a bit more than the margin.
+			precision += motion_length * (r_result.collision_unsafe_fraction - r_result.collision_safe_fraction);
+
+			if (r_result.collisions[0].depth > p_parameters.margin + precision) {
+				p_cancel_sliding = false;
+			}
+		}
+
+		if (p_cancel_sliding) {
+			// When motion is null, recovery is the resulting motion.
+			Vector3 motion_normal;
+			if (motion_length > CMP_EPSILON) {
+				motion_normal = p_parameters.motion / motion_length;
+			}
+
+			// Check depth of recovery.
+			real_t projected_length = r_result.travel.dot(motion_normal);
+			Vector3 recovery = r_result.travel - motion_normal * projected_length;
+			real_t recovery_length = recovery.length();
+			// Fixes cases where canceling slide causes the motion to go too deep into the ground,
+			// because we're only taking rest information into account and not general recovery.
+			if (recovery_length < p_parameters.margin + precision) {
+				// Apply adjustment to motion.
+				r_result.travel = motion_normal * projected_length;
+				r_result.remainder = p_parameters.motion - r_result.travel;
+			}
+		}
+	}
+
+	for (int i = 0; i < 3; i++) {
+		if (locked_axis & (1 << i)) {
+			r_result.travel[i] = 0;
+		}
+	}
+
+	if (!p_test_only) {
+		Transform3D gt = p_parameters.from;
+		gt.origin += r_result.travel;
+		set_global_transform(gt);
+	}
+
+	return colliding;
+}
+
+bool PhysicsBody3D::test_move(const Transform3D &p_from, const Vector3 &p_motion, const Ref<KinematicCollision3D> &r_collision, real_t p_margin, bool p_recovery_as_collision, int p_max_collisions) {
+	ERR_FAIL_COND_V(!is_inside_tree(), false);
+
+	PhysicsServer3D::MotionResult *r = nullptr;
+	PhysicsServer3D::MotionResult temp_result;
+	if (r_collision.is_valid()) {
+		// Needs const_cast because method bindings don't support non-const Ref.
+		r = const_cast<PhysicsServer3D::MotionResult *>(&r_collision->result);
+	} else {
+		r = &temp_result;
+	}
+
+	PhysicsServer3D::MotionParameters parameters(p_from, p_motion, p_margin);
+	parameters.recovery_as_collision = p_recovery_as_collision;
+	parameters.max_collisions = p_max_collisions;
+
+	return PhysicsServer3D::get_singleton()->body_test_motion(get_rid(), parameters, r);
+}
+
+Vector3 PhysicsBody3D::get_gravity() const {
+	PhysicsDirectBodyState3D *state = PhysicsServer3D::get_singleton()->body_get_direct_state(get_rid());
+	ERR_FAIL_NULL_V(state, Vector3());
+	return state->get_total_gravity();
+}
+
+void PhysicsBody3D::set_axis_lock(PhysicsServer3D::BodyAxis p_axis, bool p_lock) {
+	if (p_lock) {
+		locked_axis |= p_axis;
+	} else {
+		locked_axis &= (~p_axis);
+	}
+	PhysicsServer3D::get_singleton()->body_set_axis_lock(get_rid(), p_axis, p_lock);
+}
+
+bool PhysicsBody3D::get_axis_lock(PhysicsServer3D::BodyAxis p_axis) const {
+	return (locked_axis & p_axis);
+}
+
+Vector3 PhysicsBody3D::get_linear_velocity() const {
+	return Vector3();
+}
+
+Vector3 PhysicsBody3D::get_angular_velocity() const {
+	return Vector3();
+}
+
+real_t PhysicsBody3D::get_inverse_mass() const {
+	return 0;
+}
+
+///////////////////////////////////////
+
+//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
+
+///////////////////////////////////////
+
+///////////////////////////////////////
diff --git a/scene/3d/physics/physics_body_3d.h b/scene/3d/physics/physics_body_3d.h
new file mode 100644
index 0000000000..92b3850085
--- /dev/null
+++ b/scene/3d/physics/physics_body_3d.h
@@ -0,0 +1,72 @@
+/**************************************************************************/
+/*  physics_body_3d.h                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef PHYSICS_BODY_3D_H
+#define PHYSICS_BODY_3D_H
+
+#include "core/templates/vset.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/3d/physics/kinematic_collision_3d.h"
+#include "scene/resources/physics_material.h"
+#include "servers/physics_server_3d.h"
+
+class PhysicsBody3D : public CollisionObject3D {
+	GDCLASS(PhysicsBody3D, CollisionObject3D);
+
+protected:
+	static void _bind_methods();
+	PhysicsBody3D(PhysicsServer3D::BodyMode p_mode);
+
+	Ref<KinematicCollision3D> motion_cache;
+
+	uint16_t locked_axis = 0;
+
+	Ref<KinematicCollision3D> _move(const Vector3 &p_motion, bool p_test_only = false, real_t p_margin = 0.001, bool p_recovery_as_collision = false, int p_max_collisions = 1);
+
+public:
+	bool move_and_collide(const PhysicsServer3D::MotionParameters &p_parameters, PhysicsServer3D::MotionResult &r_result, bool p_test_only = false, bool p_cancel_sliding = true);
+	bool test_move(const Transform3D &p_from, const Vector3 &p_motion, const Ref<KinematicCollision3D> &r_collision = Ref<KinematicCollision3D>(), real_t p_margin = 0.001, bool p_recovery_as_collision = false, int p_max_collisions = 1);
+	Vector3 get_gravity() const;
+
+	void set_axis_lock(PhysicsServer3D::BodyAxis p_axis, bool p_lock);
+	bool get_axis_lock(PhysicsServer3D::BodyAxis p_axis) const;
+
+	virtual Vector3 get_linear_velocity() const;
+	virtual Vector3 get_angular_velocity() const;
+	virtual real_t get_inverse_mass() const;
+
+	TypedArray<PhysicsBody3D> get_collision_exceptions();
+	void add_collision_exception_with(Node *p_node); //must be physicsbody
+	void remove_collision_exception_with(Node *p_node);
+
+	virtual ~PhysicsBody3D();
+};
+
+#endif // PHYSICS_BODY_3D_H
diff --git a/scene/3d/physics/ray_cast_3d.cpp b/scene/3d/physics/ray_cast_3d.cpp
new file mode 100644
index 0000000000..dc50ecccc0
--- /dev/null
+++ b/scene/3d/physics/ray_cast_3d.cpp
@@ -0,0 +1,548 @@
+/**************************************************************************/
+/*  ray_cast_3d.cpp                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "ray_cast_3d.h"
+
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
+
+void RayCast3D::set_target_position(const Vector3 &p_point) {
+	target_position = p_point;
+	update_gizmos();
+
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (is_inside_tree()) {
+			_update_debug_shape_vertices();
+		}
+	} else if (debug_shape) {
+		_update_debug_shape();
+	}
+}
+
+Vector3 RayCast3D::get_target_position() const {
+	return target_position;
+}
+
+void RayCast3D::set_collision_mask(uint32_t p_mask) {
+	collision_mask = p_mask;
+}
+
+uint32_t RayCast3D::get_collision_mask() const {
+	return collision_mask;
+}
+
+void RayCast3D::set_collision_mask_value(int p_layer_number, bool p_value) {
+	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
+	uint32_t mask = get_collision_mask();
+	if (p_value) {
+		mask |= 1 << (p_layer_number - 1);
+	} else {
+		mask &= ~(1 << (p_layer_number - 1));
+	}
+	set_collision_mask(mask);
+}
+
+bool RayCast3D::get_collision_mask_value(int p_layer_number) const {
+	ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
+	return get_collision_mask() & (1 << (p_layer_number - 1));
+}
+
+bool RayCast3D::is_colliding() const {
+	return collided;
+}
+
+Object *RayCast3D::get_collider() const {
+	if (against.is_null()) {
+		return nullptr;
+	}
+
+	return ObjectDB::get_instance(against);
+}
+
+RID RayCast3D::get_collider_rid() const {
+	return against_rid;
+}
+
+int RayCast3D::get_collider_shape() const {
+	return against_shape;
+}
+
+Vector3 RayCast3D::get_collision_point() const {
+	return collision_point;
+}
+
+Vector3 RayCast3D::get_collision_normal() const {
+	return collision_normal;
+}
+
+int RayCast3D::get_collision_face_index() const {
+	return collision_face_index;
+}
+
+void RayCast3D::set_enabled(bool p_enabled) {
+	enabled = p_enabled;
+	update_gizmos();
+
+	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint()) {
+		set_physics_process_internal(p_enabled);
+	}
+	if (!p_enabled) {
+		collided = false;
+	}
+
+	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint()) {
+		if (p_enabled) {
+			_update_debug_shape();
+		} else {
+			_clear_debug_shape();
+		}
+	}
+}
+
+bool RayCast3D::is_enabled() const {
+	return enabled;
+}
+
+void RayCast3D::set_exclude_parent_body(bool p_exclude_parent_body) {
+	if (exclude_parent_body == p_exclude_parent_body) {
+		return;
+	}
+
+	exclude_parent_body = p_exclude_parent_body;
+
+	if (!is_inside_tree()) {
+		return;
+	}
+
+	if (Object::cast_to<CollisionObject3D>(get_parent())) {
+		if (exclude_parent_body) {
+			exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+		} else {
+			exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+		}
+	}
+}
+
+bool RayCast3D::get_exclude_parent_body() const {
+	return exclude_parent_body;
+}
+
+void RayCast3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			if (Engine::get_singleton()->is_editor_hint()) {
+				_update_debug_shape_vertices();
+			}
+			if (enabled && !Engine::get_singleton()->is_editor_hint()) {
+				set_physics_process_internal(true);
+			} else {
+				set_physics_process_internal(false);
+			}
+
+			if (get_tree()->is_debugging_collisions_hint()) {
+				_update_debug_shape();
+			}
+
+			if (Object::cast_to<CollisionObject3D>(get_parent())) {
+				if (exclude_parent_body) {
+					exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+				} else {
+					exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+				}
+			}
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (enabled) {
+				set_physics_process_internal(false);
+			}
+
+			if (debug_shape) {
+				_clear_debug_shape();
+			}
+		} break;
+
+		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
+			if (!enabled) {
+				break;
+			}
+
+			bool prev_collision_state = collided;
+			_update_raycast_state();
+			if (prev_collision_state != collided && get_tree()->is_debugging_collisions_hint()) {
+				_update_debug_shape_material(true);
+			}
+		} break;
+	}
+}
+
+void RayCast3D::_update_raycast_state() {
+	Ref<World3D> w3d = get_world_3d();
+	ERR_FAIL_COND(w3d.is_null());
+
+	PhysicsDirectSpaceState3D *dss = PhysicsServer3D::get_singleton()->space_get_direct_state(w3d->get_space());
+	ERR_FAIL_NULL(dss);
+
+	Transform3D gt = get_global_transform();
+
+	Vector3 to = target_position;
+	if (to == Vector3()) {
+		to = Vector3(0, 0.01, 0);
+	}
+
+	PhysicsDirectSpaceState3D::RayParameters ray_params;
+	ray_params.from = gt.get_origin();
+	ray_params.to = gt.xform(to);
+	ray_params.exclude = exclude;
+	ray_params.collision_mask = collision_mask;
+	ray_params.collide_with_bodies = collide_with_bodies;
+	ray_params.collide_with_areas = collide_with_areas;
+	ray_params.hit_from_inside = hit_from_inside;
+	ray_params.hit_back_faces = hit_back_faces;
+
+	PhysicsDirectSpaceState3D::RayResult rr;
+	if (dss->intersect_ray(ray_params, rr)) {
+		collided = true;
+		against = rr.collider_id;
+		against_rid = rr.rid;
+		collision_point = rr.position;
+		collision_normal = rr.normal;
+		collision_face_index = rr.face_index;
+		against_shape = rr.shape;
+	} else {
+		collided = false;
+		against = ObjectID();
+		against_rid = RID();
+		against_shape = 0;
+	}
+}
+
+void RayCast3D::force_raycast_update() {
+	_update_raycast_state();
+}
+
+void RayCast3D::add_exception_rid(const RID &p_rid) {
+	exclude.insert(p_rid);
+}
+
+void RayCast3D::add_exception(const CollisionObject3D *p_node) {
+	ERR_FAIL_NULL_MSG(p_node, "The passed Node must be an instance of CollisionObject3D.");
+	add_exception_rid(p_node->get_rid());
+}
+
+void RayCast3D::remove_exception_rid(const RID &p_rid) {
+	exclude.erase(p_rid);
+}
+
+void RayCast3D::remove_exception(const CollisionObject3D *p_node) {
+	ERR_FAIL_NULL_MSG(p_node, "The passed Node must be an instance of CollisionObject3D.");
+	remove_exception_rid(p_node->get_rid());
+}
+
+void RayCast3D::clear_exceptions() {
+	exclude.clear();
+
+	if (exclude_parent_body && is_inside_tree()) {
+		CollisionObject3D *parent = Object::cast_to<CollisionObject3D>(get_parent());
+		if (parent) {
+			exclude.insert(parent->get_rid());
+		}
+	}
+}
+
+void RayCast3D::set_collide_with_areas(bool p_enabled) {
+	collide_with_areas = p_enabled;
+}
+
+bool RayCast3D::is_collide_with_areas_enabled() const {
+	return collide_with_areas;
+}
+
+void RayCast3D::set_collide_with_bodies(bool p_enabled) {
+	collide_with_bodies = p_enabled;
+}
+
+bool RayCast3D::is_collide_with_bodies_enabled() const {
+	return collide_with_bodies;
+}
+
+void RayCast3D::set_hit_from_inside(bool p_enabled) {
+	hit_from_inside = p_enabled;
+}
+
+bool RayCast3D::is_hit_from_inside_enabled() const {
+	return hit_from_inside;
+}
+
+void RayCast3D::set_hit_back_faces(bool p_enabled) {
+	hit_back_faces = p_enabled;
+}
+
+bool RayCast3D::is_hit_back_faces_enabled() const {
+	return hit_back_faces;
+}
+
+void RayCast3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &RayCast3D::set_enabled);
+	ClassDB::bind_method(D_METHOD("is_enabled"), &RayCast3D::is_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_target_position", "local_point"), &RayCast3D::set_target_position);
+	ClassDB::bind_method(D_METHOD("get_target_position"), &RayCast3D::get_target_position);
+
+	ClassDB::bind_method(D_METHOD("is_colliding"), &RayCast3D::is_colliding);
+	ClassDB::bind_method(D_METHOD("force_raycast_update"), &RayCast3D::force_raycast_update);
+
+	ClassDB::bind_method(D_METHOD("get_collider"), &RayCast3D::get_collider);
+	ClassDB::bind_method(D_METHOD("get_collider_rid"), &RayCast3D::get_collider_rid);
+	ClassDB::bind_method(D_METHOD("get_collider_shape"), &RayCast3D::get_collider_shape);
+	ClassDB::bind_method(D_METHOD("get_collision_point"), &RayCast3D::get_collision_point);
+	ClassDB::bind_method(D_METHOD("get_collision_normal"), &RayCast3D::get_collision_normal);
+	ClassDB::bind_method(D_METHOD("get_collision_face_index"), &RayCast3D::get_collision_face_index);
+
+	ClassDB::bind_method(D_METHOD("add_exception_rid", "rid"), &RayCast3D::add_exception_rid);
+	ClassDB::bind_method(D_METHOD("add_exception", "node"), &RayCast3D::add_exception);
+
+	ClassDB::bind_method(D_METHOD("remove_exception_rid", "rid"), &RayCast3D::remove_exception_rid);
+	ClassDB::bind_method(D_METHOD("remove_exception", "node"), &RayCast3D::remove_exception);
+
+	ClassDB::bind_method(D_METHOD("clear_exceptions"), &RayCast3D::clear_exceptions);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &RayCast3D::set_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &RayCast3D::get_collision_mask);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask_value", "layer_number", "value"), &RayCast3D::set_collision_mask_value);
+	ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &RayCast3D::get_collision_mask_value);
+
+	ClassDB::bind_method(D_METHOD("set_exclude_parent_body", "mask"), &RayCast3D::set_exclude_parent_body);
+	ClassDB::bind_method(D_METHOD("get_exclude_parent_body"), &RayCast3D::get_exclude_parent_body);
+
+	ClassDB::bind_method(D_METHOD("set_collide_with_areas", "enable"), &RayCast3D::set_collide_with_areas);
+	ClassDB::bind_method(D_METHOD("is_collide_with_areas_enabled"), &RayCast3D::is_collide_with_areas_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_collide_with_bodies", "enable"), &RayCast3D::set_collide_with_bodies);
+	ClassDB::bind_method(D_METHOD("is_collide_with_bodies_enabled"), &RayCast3D::is_collide_with_bodies_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_hit_from_inside", "enable"), &RayCast3D::set_hit_from_inside);
+	ClassDB::bind_method(D_METHOD("is_hit_from_inside_enabled"), &RayCast3D::is_hit_from_inside_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_hit_back_faces", "enable"), &RayCast3D::set_hit_back_faces);
+	ClassDB::bind_method(D_METHOD("is_hit_back_faces_enabled"), &RayCast3D::is_hit_back_faces_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_debug_shape_custom_color", "debug_shape_custom_color"), &RayCast3D::set_debug_shape_custom_color);
+	ClassDB::bind_method(D_METHOD("get_debug_shape_custom_color"), &RayCast3D::get_debug_shape_custom_color);
+
+	ClassDB::bind_method(D_METHOD("set_debug_shape_thickness", "debug_shape_thickness"), &RayCast3D::set_debug_shape_thickness);
+	ClassDB::bind_method(D_METHOD("get_debug_shape_thickness"), &RayCast3D::get_debug_shape_thickness);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "is_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "exclude_parent"), "set_exclude_parent_body", "get_exclude_parent_body");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "target_position", PROPERTY_HINT_NONE, "suffix:m"), "set_target_position", "get_target_position");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "hit_from_inside"), "set_hit_from_inside", "is_hit_from_inside_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "hit_back_faces"), "set_hit_back_faces", "is_hit_back_faces_enabled");
+
+	ADD_GROUP("Collide With", "collide_with");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_areas", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_areas", "is_collide_with_areas_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_bodies", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_bodies", "is_collide_with_bodies_enabled");
+
+	ADD_GROUP("Debug Shape", "debug_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "debug_shape_custom_color"), "set_debug_shape_custom_color", "get_debug_shape_custom_color");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "debug_shape_thickness", PROPERTY_HINT_RANGE, "1,5"), "set_debug_shape_thickness", "get_debug_shape_thickness");
+}
+
+int RayCast3D::get_debug_shape_thickness() const {
+	return debug_shape_thickness;
+}
+
+void RayCast3D::_update_debug_shape_vertices() {
+	debug_shape_vertices.clear();
+	debug_line_vertices.clear();
+
+	if (target_position == Vector3()) {
+		return;
+	}
+
+	debug_line_vertices.push_back(Vector3());
+	debug_line_vertices.push_back(target_position);
+
+	if (debug_shape_thickness > 1) {
+		float scale_factor = 100.0;
+		Vector3 dir = Vector3(target_position).normalized();
+		// Draw truncated pyramid
+		Vector3 normal = (fabs(dir.x) + fabs(dir.y) > CMP_EPSILON) ? Vector3(-dir.y, dir.x, 0).normalized() : Vector3(0, -dir.z, dir.y).normalized();
+		normal *= debug_shape_thickness / scale_factor;
+		int vertices_strip_order[14] = { 4, 5, 0, 1, 2, 5, 6, 4, 7, 0, 3, 2, 7, 6 };
+		for (int v = 0; v < 14; v++) {
+			Vector3 vertex = vertices_strip_order[v] < 4 ? normal : normal / 3.0 + target_position;
+			debug_shape_vertices.push_back(vertex.rotated(dir, Math_PI * (0.5 * (vertices_strip_order[v] % 4) + 0.25)));
+		}
+	}
+}
+
+void RayCast3D::set_debug_shape_thickness(const int p_debug_shape_thickness) {
+	debug_shape_thickness = p_debug_shape_thickness;
+	update_gizmos();
+
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (is_inside_tree()) {
+			_update_debug_shape_vertices();
+		}
+	} else if (debug_shape) {
+		_update_debug_shape();
+	}
+}
+
+const Vector<Vector3> &RayCast3D::get_debug_shape_vertices() const {
+	return debug_shape_vertices;
+}
+
+const Vector<Vector3> &RayCast3D::get_debug_line_vertices() const {
+	return debug_line_vertices;
+}
+
+void RayCast3D::set_debug_shape_custom_color(const Color &p_color) {
+	debug_shape_custom_color = p_color;
+	if (debug_material.is_valid()) {
+		_update_debug_shape_material();
+	}
+}
+
+Ref<StandardMaterial3D> RayCast3D::get_debug_material() {
+	_update_debug_shape_material();
+	return debug_material;
+}
+
+const Color &RayCast3D::get_debug_shape_custom_color() const {
+	return debug_shape_custom_color;
+}
+
+void RayCast3D::_create_debug_shape() {
+	_update_debug_shape_material();
+
+	Ref<ArrayMesh> mesh = memnew(ArrayMesh);
+
+	MeshInstance3D *mi = memnew(MeshInstance3D);
+	mi->set_mesh(mesh);
+
+	add_child(mi);
+	debug_shape = mi;
+}
+
+void RayCast3D::_update_debug_shape_material(bool p_check_collision) {
+	if (!debug_material.is_valid()) {
+		Ref<StandardMaterial3D> material = memnew(StandardMaterial3D);
+		debug_material = material;
+
+		material->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+		material->set_flag(StandardMaterial3D::FLAG_DISABLE_FOG, true);
+		// Use double-sided rendering so that the RayCast can be seen if the camera is inside.
+		material->set_cull_mode(BaseMaterial3D::CULL_DISABLED);
+		material->set_transparency(BaseMaterial3D::TRANSPARENCY_ALPHA);
+	}
+
+	Color color = debug_shape_custom_color;
+	if (color == Color(0.0, 0.0, 0.0)) {
+		// Use the default debug shape color defined in the Project Settings.
+		color = get_tree()->get_debug_collisions_color();
+	}
+
+	if (p_check_collision && collided) {
+		if ((color.get_h() < 0.055 || color.get_h() > 0.945) && color.get_s() > 0.5 && color.get_v() > 0.5) {
+			// If base color is already quite reddish, highlight collision with green color
+			color = Color(0.0, 1.0, 0.0, color.a);
+		} else {
+			// Else, highlight collision with red color
+			color = Color(1.0, 0, 0, color.a);
+		}
+	}
+
+	Ref<StandardMaterial3D> material = static_cast<Ref<StandardMaterial3D>>(debug_material);
+	material->set_albedo(color);
+}
+
+void RayCast3D::_update_debug_shape() {
+	if (!enabled) {
+		return;
+	}
+
+	if (!debug_shape) {
+		_create_debug_shape();
+	}
+
+	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
+	Ref<ArrayMesh> mesh = mi->get_mesh();
+	if (!mesh.is_valid()) {
+		return;
+	}
+
+	_update_debug_shape_vertices();
+
+	mesh->clear_surfaces();
+
+	Array a;
+	a.resize(Mesh::ARRAY_MAX);
+
+	uint32_t flags = 0;
+	int surface_count = 0;
+
+	if (!debug_line_vertices.is_empty()) {
+		a[Mesh::ARRAY_VERTEX] = debug_line_vertices;
+		mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, a, Array(), Dictionary(), flags);
+		mesh->surface_set_material(surface_count, debug_material);
+		++surface_count;
+	}
+
+	if (!debug_shape_vertices.is_empty()) {
+		a[Mesh::ARRAY_VERTEX] = debug_shape_vertices;
+		mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLE_STRIP, a, Array(), Dictionary(), flags);
+		mesh->surface_set_material(surface_count, debug_material);
+		++surface_count;
+	}
+}
+
+void RayCast3D::_clear_debug_shape() {
+	if (!debug_shape) {
+		return;
+	}
+
+	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
+	if (mi->is_inside_tree()) {
+		mi->queue_free();
+	} else {
+		memdelete(mi);
+	}
+
+	debug_shape = nullptr;
+}
+
+RayCast3D::RayCast3D() {
+}
diff --git a/scene/3d/physics/ray_cast_3d.h b/scene/3d/physics/ray_cast_3d.h
new file mode 100644
index 0000000000..7b7f698114
--- /dev/null
+++ b/scene/3d/physics/ray_cast_3d.h
@@ -0,0 +1,137 @@
+/**************************************************************************/
+/*  ray_cast_3d.h                                                         */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef RAY_CAST_3D_H
+#define RAY_CAST_3D_H
+
+#include "scene/3d/node_3d.h"
+
+class CollisionObject3D;
+
+class RayCast3D : public Node3D {
+	GDCLASS(RayCast3D, Node3D);
+
+	bool enabled = true;
+	bool collided = false;
+	ObjectID against;
+	RID against_rid;
+	int against_shape = 0;
+	Vector3 collision_point;
+	Vector3 collision_normal;
+	int collision_face_index = -1;
+
+	Vector3 target_position = Vector3(0, -1, 0);
+	HashSet<RID> exclude;
+
+	uint32_t collision_mask = 1;
+	bool exclude_parent_body = true;
+
+	Node *debug_shape = nullptr;
+	Ref<Material> debug_material;
+	Color debug_shape_custom_color = Color(0.0, 0.0, 0.0);
+	int debug_shape_thickness = 2;
+	Vector<Vector3> debug_shape_vertices;
+	Vector<Vector3> debug_line_vertices;
+
+	void _create_debug_shape();
+	void _update_debug_shape();
+	void _update_debug_shape_material(bool p_check_collision = false);
+	void _update_debug_shape_vertices();
+	void _clear_debug_shape();
+
+	bool collide_with_areas = false;
+	bool collide_with_bodies = true;
+
+	bool hit_from_inside = false;
+	bool hit_back_faces = true;
+
+protected:
+	void _notification(int p_what);
+	void _update_raycast_state();
+	static void _bind_methods();
+
+public:
+	void set_collide_with_areas(bool p_enabled);
+	bool is_collide_with_areas_enabled() const;
+
+	void set_collide_with_bodies(bool p_enabled);
+	bool is_collide_with_bodies_enabled() const;
+
+	void set_hit_from_inside(bool p_enabled);
+	bool is_hit_from_inside_enabled() const;
+
+	void set_hit_back_faces(bool p_enabled);
+	bool is_hit_back_faces_enabled() const;
+
+	void set_enabled(bool p_enabled);
+	bool is_enabled() const;
+
+	void set_target_position(const Vector3 &p_point);
+	Vector3 get_target_position() const;
+
+	void set_collision_mask(uint32_t p_mask);
+	uint32_t get_collision_mask() const;
+
+	void set_collision_mask_value(int p_layer_number, bool p_value);
+	bool get_collision_mask_value(int p_layer_number) const;
+
+	void set_exclude_parent_body(bool p_exclude_parent_body);
+	bool get_exclude_parent_body() const;
+
+	const Color &get_debug_shape_custom_color() const;
+	void set_debug_shape_custom_color(const Color &p_color);
+
+	const Vector<Vector3> &get_debug_shape_vertices() const;
+	const Vector<Vector3> &get_debug_line_vertices() const;
+
+	Ref<StandardMaterial3D> get_debug_material();
+
+	int get_debug_shape_thickness() const;
+	void set_debug_shape_thickness(const int p_debug_thickness);
+
+	void force_raycast_update();
+	bool is_colliding() const;
+	Object *get_collider() const;
+	RID get_collider_rid() const;
+	int get_collider_shape() const;
+	Vector3 get_collision_point() const;
+	Vector3 get_collision_normal() const;
+	int get_collision_face_index() const;
+
+	void add_exception_rid(const RID &p_rid);
+	void add_exception(const CollisionObject3D *p_node);
+	void remove_exception_rid(const RID &p_rid);
+	void remove_exception(const CollisionObject3D *p_node);
+	void clear_exceptions();
+
+	RayCast3D();
+};
+
+#endif // RAY_CAST_3D_H
diff --git a/scene/3d/physics/rigid_body_3d.cpp b/scene/3d/physics/rigid_body_3d.cpp
new file mode 100644
index 0000000000..54bd1c0d25
--- /dev/null
+++ b/scene/3d/physics/rigid_body_3d.cpp
@@ -0,0 +1,825 @@
+/**************************************************************************/
+/*  rigid_body_3d.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "rigid_body_3d.h"
+
+#include "scene/scene_string_names.h"
+
+void RigidBody3D::_body_enter_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+	ERR_FAIL_NULL(contact_monitor);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(E->value.in_tree);
+
+	E->value.in_tree = true;
+
+	contact_monitor->locked = true;
+
+	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
+
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
+	}
+
+	contact_monitor->locked = false;
+}
+
+void RigidBody3D::_body_exit_tree(ObjectID p_id) {
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = Object::cast_to<Node>(obj);
+	ERR_FAIL_NULL(node);
+	ERR_FAIL_NULL(contact_monitor);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
+
+	contact_monitor->locked = true;
+
+	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
+
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
+	}
+
+	contact_monitor->locked = false;
+}
+
+void RigidBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_local_shape) {
+	bool body_in = p_status == 1;
+	ObjectID objid = p_instance;
+
+	Object *obj = ObjectDB::get_instance(objid);
+	Node *node = Object::cast_to<Node>(obj);
+
+	ERR_FAIL_NULL(contact_monitor);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(objid);
+
+	ERR_FAIL_COND(!body_in && !E);
+
+	if (body_in) {
+		if (!E) {
+			E = contact_monitor->body_map.insert(objid, BodyState());
+			E->value.rid = p_body;
+			//E->value.rc=0;
+			E->value.in_tree = node && node->is_inside_tree();
+			if (node) {
+				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree).bind(objid));
+				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree).bind(objid));
+				if (E->value.in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
+				}
+			}
+		}
+		//E->value.rc++;
+		if (node) {
+			E->value.shapes.insert(ShapePair(p_body_shape, p_local_shape));
+		}
+
+		if (E->value.in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_local_shape);
+		}
+
+	} else {
+		//E->value.rc--;
+
+		if (node) {
+			E->value.shapes.erase(ShapePair(p_body_shape, p_local_shape));
+		}
+
+		bool in_tree = E->value.in_tree;
+
+		if (E->value.shapes.is_empty()) {
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree));
+				if (in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->body_exited, node);
+				}
+			}
+
+			contact_monitor->body_map.remove(E);
+		}
+		if (node && in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, obj, p_body_shape, p_local_shape);
+		}
+	}
+}
+
+struct _RigidBodyInOut {
+	RID rid;
+	ObjectID id;
+	int shape = 0;
+	int local_shape = 0;
+};
+
+void RigidBody3D::_sync_body_state(PhysicsDirectBodyState3D *p_state) {
+	set_ignore_transform_notification(true);
+	set_global_transform(p_state->get_transform());
+	set_ignore_transform_notification(false);
+
+	linear_velocity = p_state->get_linear_velocity();
+	angular_velocity = p_state->get_angular_velocity();
+
+	inverse_inertia_tensor = p_state->get_inverse_inertia_tensor();
+
+	contact_count = p_state->get_contact_count();
+
+	if (sleeping != p_state->is_sleeping()) {
+		sleeping = p_state->is_sleeping();
+		emit_signal(SceneStringNames::get_singleton()->sleeping_state_changed);
+	}
+}
+
+void RigidBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
+	lock_callback();
+
+	if (GDVIRTUAL_IS_OVERRIDDEN(_integrate_forces)) {
+		_sync_body_state(p_state);
+
+		Transform3D old_transform = get_global_transform();
+		GDVIRTUAL_CALL(_integrate_forces, p_state);
+		Transform3D new_transform = get_global_transform();
+
+		if (new_transform != old_transform) {
+			// Update the physics server with the new transform, to prevent it from being overwritten at the sync below.
+			PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_TRANSFORM, new_transform);
+		}
+	}
+
+	_sync_body_state(p_state);
+	_on_transform_changed();
+
+	if (contact_monitor) {
+		contact_monitor->locked = true;
+
+		//untag all
+		int rc = 0;
+		for (KeyValue<ObjectID, BodyState> &E : contact_monitor->body_map) {
+			for (int i = 0; i < E.value.shapes.size(); i++) {
+				E.value.shapes[i].tagged = false;
+				rc++;
+			}
+		}
+
+		_RigidBodyInOut *toadd = (_RigidBodyInOut *)alloca(p_state->get_contact_count() * sizeof(_RigidBodyInOut));
+		int toadd_count = 0;
+		RigidBody3D_RemoveAction *toremove = (RigidBody3D_RemoveAction *)alloca(rc * sizeof(RigidBody3D_RemoveAction));
+		int toremove_count = 0;
+
+		//put the ones to add
+
+		for (int i = 0; i < p_state->get_contact_count(); i++) {
+			RID col_rid = p_state->get_contact_collider(i);
+			ObjectID col_obj = p_state->get_contact_collider_id(i);
+			int local_shape = p_state->get_contact_local_shape(i);
+			int col_shape = p_state->get_contact_collider_shape(i);
+
+			HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(col_obj);
+			if (!E) {
+				toadd[toadd_count].rid = col_rid;
+				toadd[toadd_count].local_shape = local_shape;
+				toadd[toadd_count].id = col_obj;
+				toadd[toadd_count].shape = col_shape;
+				toadd_count++;
+				continue;
+			}
+
+			ShapePair sp(col_shape, local_shape);
+			int idx = E->value.shapes.find(sp);
+			if (idx == -1) {
+				toadd[toadd_count].rid = col_rid;
+				toadd[toadd_count].local_shape = local_shape;
+				toadd[toadd_count].id = col_obj;
+				toadd[toadd_count].shape = col_shape;
+				toadd_count++;
+				continue;
+			}
+
+			E->value.shapes[idx].tagged = true;
+		}
+
+		//put the ones to remove
+
+		for (const KeyValue<ObjectID, BodyState> &E : contact_monitor->body_map) {
+			for (int i = 0; i < E.value.shapes.size(); i++) {
+				if (!E.value.shapes[i].tagged) {
+					toremove[toremove_count].rid = E.value.rid;
+					toremove[toremove_count].body_id = E.key;
+					toremove[toremove_count].pair = E.value.shapes[i];
+					toremove_count++;
+				}
+			}
+		}
+
+		//process removals
+
+		for (int i = 0; i < toremove_count; i++) {
+			_body_inout(0, toremove[i].rid, toremove[i].body_id, toremove[i].pair.body_shape, toremove[i].pair.local_shape);
+		}
+
+		//process additions
+
+		for (int i = 0; i < toadd_count; i++) {
+			_body_inout(1, toremove[i].rid, toadd[i].id, toadd[i].shape, toadd[i].local_shape);
+		}
+
+		contact_monitor->locked = false;
+	}
+
+	unlock_callback();
+}
+
+void RigidBody3D::_notification(int p_what) {
+#ifdef TOOLS_ENABLED
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			if (Engine::get_singleton()->is_editor_hint()) {
+				set_notify_local_transform(true); // Used for warnings and only in editor.
+			}
+		} break;
+
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+			update_configuration_warnings();
+		} break;
+	}
+#endif
+}
+
+void RigidBody3D::_apply_body_mode() {
+	if (freeze) {
+		switch (freeze_mode) {
+			case FREEZE_MODE_STATIC: {
+				set_body_mode(PhysicsServer3D::BODY_MODE_STATIC);
+			} break;
+			case FREEZE_MODE_KINEMATIC: {
+				set_body_mode(PhysicsServer3D::BODY_MODE_KINEMATIC);
+			} break;
+		}
+	} else if (lock_rotation) {
+		set_body_mode(PhysicsServer3D::BODY_MODE_RIGID_LINEAR);
+	} else {
+		set_body_mode(PhysicsServer3D::BODY_MODE_RIGID);
+	}
+}
+
+void RigidBody3D::set_lock_rotation_enabled(bool p_lock_rotation) {
+	if (p_lock_rotation == lock_rotation) {
+		return;
+	}
+
+	lock_rotation = p_lock_rotation;
+	_apply_body_mode();
+}
+
+bool RigidBody3D::is_lock_rotation_enabled() const {
+	return lock_rotation;
+}
+
+void RigidBody3D::set_freeze_enabled(bool p_freeze) {
+	if (p_freeze == freeze) {
+		return;
+	}
+
+	freeze = p_freeze;
+	_apply_body_mode();
+}
+
+bool RigidBody3D::is_freeze_enabled() const {
+	return freeze;
+}
+
+void RigidBody3D::set_freeze_mode(FreezeMode p_freeze_mode) {
+	if (p_freeze_mode == freeze_mode) {
+		return;
+	}
+
+	freeze_mode = p_freeze_mode;
+	_apply_body_mode();
+}
+
+RigidBody3D::FreezeMode RigidBody3D::get_freeze_mode() const {
+	return freeze_mode;
+}
+
+void RigidBody3D::set_mass(real_t p_mass) {
+	ERR_FAIL_COND(p_mass <= 0);
+	mass = p_mass;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_MASS, mass);
+}
+
+real_t RigidBody3D::get_mass() const {
+	return mass;
+}
+
+void RigidBody3D::set_inertia(const Vector3 &p_inertia) {
+	ERR_FAIL_COND(p_inertia.x < 0);
+	ERR_FAIL_COND(p_inertia.y < 0);
+	ERR_FAIL_COND(p_inertia.z < 0);
+
+	inertia = p_inertia;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_INERTIA, inertia);
+}
+
+const Vector3 &RigidBody3D::get_inertia() const {
+	return inertia;
+}
+
+void RigidBody3D::set_center_of_mass_mode(CenterOfMassMode p_mode) {
+	if (center_of_mass_mode == p_mode) {
+		return;
+	}
+
+	center_of_mass_mode = p_mode;
+
+	switch (center_of_mass_mode) {
+		case CENTER_OF_MASS_MODE_AUTO: {
+			center_of_mass = Vector3();
+			PhysicsServer3D::get_singleton()->body_reset_mass_properties(get_rid());
+			if (inertia != Vector3()) {
+				PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_INERTIA, inertia);
+			}
+		} break;
+
+		case CENTER_OF_MASS_MODE_CUSTOM: {
+			PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
+		} break;
+	}
+}
+
+RigidBody3D::CenterOfMassMode RigidBody3D::get_center_of_mass_mode() const {
+	return center_of_mass_mode;
+}
+
+void RigidBody3D::set_center_of_mass(const Vector3 &p_center_of_mass) {
+	if (center_of_mass == p_center_of_mass) {
+		return;
+	}
+
+	ERR_FAIL_COND(center_of_mass_mode != CENTER_OF_MASS_MODE_CUSTOM);
+	center_of_mass = p_center_of_mass;
+
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
+}
+
+const Vector3 &RigidBody3D::get_center_of_mass() const {
+	return center_of_mass;
+}
+
+void RigidBody3D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
+	if (physics_material_override.is_valid()) {
+		physics_material_override->disconnect_changed(callable_mp(this, &RigidBody3D::_reload_physics_characteristics));
+	}
+
+	physics_material_override = p_physics_material_override;
+
+	if (physics_material_override.is_valid()) {
+		physics_material_override->connect_changed(callable_mp(this, &RigidBody3D::_reload_physics_characteristics));
+	}
+	_reload_physics_characteristics();
+}
+
+Ref<PhysicsMaterial> RigidBody3D::get_physics_material_override() const {
+	return physics_material_override;
+}
+
+void RigidBody3D::set_gravity_scale(real_t p_gravity_scale) {
+	gravity_scale = p_gravity_scale;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
+}
+
+real_t RigidBody3D::get_gravity_scale() const {
+	return gravity_scale;
+}
+
+void RigidBody3D::set_linear_damp_mode(DampMode p_mode) {
+	linear_damp_mode = p_mode;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_LINEAR_DAMP_MODE, linear_damp_mode);
+}
+
+RigidBody3D::DampMode RigidBody3D::get_linear_damp_mode() const {
+	return linear_damp_mode;
+}
+
+void RigidBody3D::set_angular_damp_mode(DampMode p_mode) {
+	angular_damp_mode = p_mode;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_ANGULAR_DAMP_MODE, angular_damp_mode);
+}
+
+RigidBody3D::DampMode RigidBody3D::get_angular_damp_mode() const {
+	return angular_damp_mode;
+}
+
+void RigidBody3D::set_linear_damp(real_t p_linear_damp) {
+	ERR_FAIL_COND(p_linear_damp < 0.0);
+	linear_damp = p_linear_damp;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_LINEAR_DAMP, linear_damp);
+}
+
+real_t RigidBody3D::get_linear_damp() const {
+	return linear_damp;
+}
+
+void RigidBody3D::set_angular_damp(real_t p_angular_damp) {
+	ERR_FAIL_COND(p_angular_damp < 0.0);
+	angular_damp = p_angular_damp;
+	PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_ANGULAR_DAMP, angular_damp);
+}
+
+real_t RigidBody3D::get_angular_damp() const {
+	return angular_damp;
+}
+
+void RigidBody3D::set_axis_velocity(const Vector3 &p_axis) {
+	Vector3 axis = p_axis.normalized();
+	linear_velocity -= axis * axis.dot(linear_velocity);
+	linear_velocity += p_axis;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
+}
+
+void RigidBody3D::set_linear_velocity(const Vector3 &p_velocity) {
+	linear_velocity = p_velocity;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
+}
+
+Vector3 RigidBody3D::get_linear_velocity() const {
+	return linear_velocity;
+}
+
+void RigidBody3D::set_angular_velocity(const Vector3 &p_velocity) {
+	angular_velocity = p_velocity;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
+}
+
+Vector3 RigidBody3D::get_angular_velocity() const {
+	return angular_velocity;
+}
+
+Basis RigidBody3D::get_inverse_inertia_tensor() const {
+	return inverse_inertia_tensor;
+}
+
+void RigidBody3D::set_use_custom_integrator(bool p_enable) {
+	if (custom_integrator == p_enable) {
+		return;
+	}
+
+	custom_integrator = p_enable;
+	PhysicsServer3D::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
+}
+
+bool RigidBody3D::is_using_custom_integrator() {
+	return custom_integrator;
+}
+
+void RigidBody3D::set_sleeping(bool p_sleeping) {
+	sleeping = p_sleeping;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_SLEEPING, sleeping);
+}
+
+void RigidBody3D::set_can_sleep(bool p_active) {
+	can_sleep = p_active;
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_CAN_SLEEP, p_active);
+}
+
+bool RigidBody3D::is_able_to_sleep() const {
+	return can_sleep;
+}
+
+bool RigidBody3D::is_sleeping() const {
+	return sleeping;
+}
+
+void RigidBody3D::set_max_contacts_reported(int p_amount) {
+	max_contacts_reported = p_amount;
+	PhysicsServer3D::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
+}
+
+int RigidBody3D::get_max_contacts_reported() const {
+	return max_contacts_reported;
+}
+
+int RigidBody3D::get_contact_count() const {
+	return contact_count;
+}
+
+void RigidBody3D::apply_central_impulse(const Vector3 &p_impulse) {
+	PhysicsServer3D::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);
+}
+
+void RigidBody3D::apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position) {
+	PhysicsServer3D *singleton = PhysicsServer3D::get_singleton();
+	singleton->body_apply_impulse(get_rid(), p_impulse, p_position);
+}
+
+void RigidBody3D::apply_torque_impulse(const Vector3 &p_impulse) {
+	PhysicsServer3D::get_singleton()->body_apply_torque_impulse(get_rid(), p_impulse);
+}
+
+void RigidBody3D::apply_central_force(const Vector3 &p_force) {
+	PhysicsServer3D::get_singleton()->body_apply_central_force(get_rid(), p_force);
+}
+
+void RigidBody3D::apply_force(const Vector3 &p_force, const Vector3 &p_position) {
+	PhysicsServer3D *singleton = PhysicsServer3D::get_singleton();
+	singleton->body_apply_force(get_rid(), p_force, p_position);
+}
+
+void RigidBody3D::apply_torque(const Vector3 &p_torque) {
+	PhysicsServer3D::get_singleton()->body_apply_torque(get_rid(), p_torque);
+}
+
+void RigidBody3D::add_constant_central_force(const Vector3 &p_force) {
+	PhysicsServer3D::get_singleton()->body_add_constant_central_force(get_rid(), p_force);
+}
+
+void RigidBody3D::add_constant_force(const Vector3 &p_force, const Vector3 &p_position) {
+	PhysicsServer3D *singleton = PhysicsServer3D::get_singleton();
+	singleton->body_add_constant_force(get_rid(), p_force, p_position);
+}
+
+void RigidBody3D::add_constant_torque(const Vector3 &p_torque) {
+	PhysicsServer3D::get_singleton()->body_add_constant_torque(get_rid(), p_torque);
+}
+
+void RigidBody3D::set_constant_force(const Vector3 &p_force) {
+	PhysicsServer3D::get_singleton()->body_set_constant_force(get_rid(), p_force);
+}
+
+Vector3 RigidBody3D::get_constant_force() const {
+	return PhysicsServer3D::get_singleton()->body_get_constant_force(get_rid());
+}
+
+void RigidBody3D::set_constant_torque(const Vector3 &p_torque) {
+	PhysicsServer3D::get_singleton()->body_set_constant_torque(get_rid(), p_torque);
+}
+
+Vector3 RigidBody3D::get_constant_torque() const {
+	return PhysicsServer3D::get_singleton()->body_get_constant_torque(get_rid());
+}
+
+void RigidBody3D::set_use_continuous_collision_detection(bool p_enable) {
+	ccd = p_enable;
+	PhysicsServer3D::get_singleton()->body_set_enable_continuous_collision_detection(get_rid(), p_enable);
+}
+
+bool RigidBody3D::is_using_continuous_collision_detection() const {
+	return ccd;
+}
+
+void RigidBody3D::set_contact_monitor(bool p_enabled) {
+	if (p_enabled == is_contact_monitor_enabled()) {
+		return;
+	}
+
+	if (!p_enabled) {
+		ERR_FAIL_COND_MSG(contact_monitor->locked, "Can't disable contact monitoring during in/out callback. Use call_deferred(\"set_contact_monitor\", false) instead.");
+
+		for (const KeyValue<ObjectID, BodyState> &E : contact_monitor->body_map) {
+			//clean up mess
+			Object *obj = ObjectDB::get_instance(E.key);
+			Node *node = Object::cast_to<Node>(obj);
+
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree));
+			}
+		}
+
+		memdelete(contact_monitor);
+		contact_monitor = nullptr;
+	} else {
+		contact_monitor = memnew(ContactMonitor);
+		contact_monitor->locked = false;
+	}
+}
+
+bool RigidBody3D::is_contact_monitor_enabled() const {
+	return contact_monitor != nullptr;
+}
+
+TypedArray<Node3D> RigidBody3D::get_colliding_bodies() const {
+	ERR_FAIL_NULL_V(contact_monitor, TypedArray<Node3D>());
+
+	TypedArray<Node3D> ret;
+	ret.resize(contact_monitor->body_map.size());
+	int idx = 0;
+	for (const KeyValue<ObjectID, BodyState> &E : contact_monitor->body_map) {
+		Object *obj = ObjectDB::get_instance(E.key);
+		if (!obj) {
+			ret.resize(ret.size() - 1); //ops
+		} else {
+			ret[idx++] = obj;
+		}
+	}
+
+	return ret;
+}
+
+void RigidBody3D::_reload_physics_characteristics() {
+	if (physics_material_override.is_null()) {
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, 0);
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, 1);
+	} else {
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
+	}
+}
+
+PackedStringArray RigidBody3D::get_configuration_warnings() const {
+	PackedStringArray warnings = CollisionObject3D::get_configuration_warnings();
+
+	Vector3 scale = get_transform().get_basis().get_scale();
+	if (ABS(scale.x - 1.0) > 0.05 || ABS(scale.y - 1.0) > 0.05 || ABS(scale.z - 1.0) > 0.05) {
+		warnings.push_back(RTR("Scale changes to RigidBody3D will be overridden by the physics engine when running.\nPlease change the size in children collision shapes instead."));
+	}
+
+	return warnings;
+}
+
+void RigidBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_mass", "mass"), &RigidBody3D::set_mass);
+	ClassDB::bind_method(D_METHOD("get_mass"), &RigidBody3D::get_mass);
+
+	ClassDB::bind_method(D_METHOD("set_inertia", "inertia"), &RigidBody3D::set_inertia);
+	ClassDB::bind_method(D_METHOD("get_inertia"), &RigidBody3D::get_inertia);
+
+	ClassDB::bind_method(D_METHOD("set_center_of_mass_mode", "mode"), &RigidBody3D::set_center_of_mass_mode);
+	ClassDB::bind_method(D_METHOD("get_center_of_mass_mode"), &RigidBody3D::get_center_of_mass_mode);
+
+	ClassDB::bind_method(D_METHOD("set_center_of_mass", "center_of_mass"), &RigidBody3D::set_center_of_mass);
+	ClassDB::bind_method(D_METHOD("get_center_of_mass"), &RigidBody3D::get_center_of_mass);
+
+	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody3D::set_physics_material_override);
+	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody3D::get_physics_material_override);
+
+	ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &RigidBody3D::set_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &RigidBody3D::get_linear_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &RigidBody3D::set_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_angular_velocity"), &RigidBody3D::get_angular_velocity);
+
+	ClassDB::bind_method(D_METHOD("get_inverse_inertia_tensor"), &RigidBody3D::get_inverse_inertia_tensor);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &RigidBody3D::set_gravity_scale);
+	ClassDB::bind_method(D_METHOD("get_gravity_scale"), &RigidBody3D::get_gravity_scale);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp_mode", "linear_damp_mode"), &RigidBody3D::set_linear_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_linear_damp_mode"), &RigidBody3D::get_linear_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp_mode", "angular_damp_mode"), &RigidBody3D::set_angular_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_angular_damp_mode"), &RigidBody3D::get_angular_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &RigidBody3D::set_linear_damp);
+	ClassDB::bind_method(D_METHOD("get_linear_damp"), &RigidBody3D::get_linear_damp);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &RigidBody3D::set_angular_damp);
+	ClassDB::bind_method(D_METHOD("get_angular_damp"), &RigidBody3D::get_angular_damp);
+
+	ClassDB::bind_method(D_METHOD("set_max_contacts_reported", "amount"), &RigidBody3D::set_max_contacts_reported);
+	ClassDB::bind_method(D_METHOD("get_max_contacts_reported"), &RigidBody3D::get_max_contacts_reported);
+	ClassDB::bind_method(D_METHOD("get_contact_count"), &RigidBody3D::get_contact_count);
+
+	ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &RigidBody3D::set_use_custom_integrator);
+	ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &RigidBody3D::is_using_custom_integrator);
+
+	ClassDB::bind_method(D_METHOD("set_contact_monitor", "enabled"), &RigidBody3D::set_contact_monitor);
+	ClassDB::bind_method(D_METHOD("is_contact_monitor_enabled"), &RigidBody3D::is_contact_monitor_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_use_continuous_collision_detection", "enable"), &RigidBody3D::set_use_continuous_collision_detection);
+	ClassDB::bind_method(D_METHOD("is_using_continuous_collision_detection"), &RigidBody3D::is_using_continuous_collision_detection);
+
+	ClassDB::bind_method(D_METHOD("set_axis_velocity", "axis_velocity"), &RigidBody3D::set_axis_velocity);
+
+	ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody3D::apply_central_impulse);
+	ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &RigidBody3D::apply_impulse, Vector3());
+	ClassDB::bind_method(D_METHOD("apply_torque_impulse", "impulse"), &RigidBody3D::apply_torque_impulse);
+
+	ClassDB::bind_method(D_METHOD("apply_central_force", "force"), &RigidBody3D::apply_central_force);
+	ClassDB::bind_method(D_METHOD("apply_force", "force", "position"), &RigidBody3D::apply_force, Vector3());
+	ClassDB::bind_method(D_METHOD("apply_torque", "torque"), &RigidBody3D::apply_torque);
+
+	ClassDB::bind_method(D_METHOD("add_constant_central_force", "force"), &RigidBody3D::add_constant_central_force);
+	ClassDB::bind_method(D_METHOD("add_constant_force", "force", "position"), &RigidBody3D::add_constant_force, Vector3());
+	ClassDB::bind_method(D_METHOD("add_constant_torque", "torque"), &RigidBody3D::add_constant_torque);
+
+	ClassDB::bind_method(D_METHOD("set_constant_force", "force"), &RigidBody3D::set_constant_force);
+	ClassDB::bind_method(D_METHOD("get_constant_force"), &RigidBody3D::get_constant_force);
+
+	ClassDB::bind_method(D_METHOD("set_constant_torque", "torque"), &RigidBody3D::set_constant_torque);
+	ClassDB::bind_method(D_METHOD("get_constant_torque"), &RigidBody3D::get_constant_torque);
+
+	ClassDB::bind_method(D_METHOD("set_sleeping", "sleeping"), &RigidBody3D::set_sleeping);
+	ClassDB::bind_method(D_METHOD("is_sleeping"), &RigidBody3D::is_sleeping);
+
+	ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &RigidBody3D::set_can_sleep);
+	ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &RigidBody3D::is_able_to_sleep);
+
+	ClassDB::bind_method(D_METHOD("set_lock_rotation_enabled", "lock_rotation"), &RigidBody3D::set_lock_rotation_enabled);
+	ClassDB::bind_method(D_METHOD("is_lock_rotation_enabled"), &RigidBody3D::is_lock_rotation_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_freeze_enabled", "freeze_mode"), &RigidBody3D::set_freeze_enabled);
+	ClassDB::bind_method(D_METHOD("is_freeze_enabled"), &RigidBody3D::is_freeze_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_freeze_mode", "freeze_mode"), &RigidBody3D::set_freeze_mode);
+	ClassDB::bind_method(D_METHOD("get_freeze_mode"), &RigidBody3D::get_freeze_mode);
+
+	ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidBody3D::get_colliding_bodies);
+
+	GDVIRTUAL_BIND(_integrate_forces, "state");
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "mass", PROPERTY_HINT_RANGE, "0.01,1000,0.01,or_greater,exp,suffix:kg"), "set_mass", "get_mass");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "gravity_scale", PROPERTY_HINT_RANGE, "-8,8,0.001,or_less,or_greater"), "set_gravity_scale", "get_gravity_scale");
+	ADD_GROUP("Mass Distribution", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "center_of_mass_mode", PROPERTY_HINT_ENUM, "Auto,Custom", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_center_of_mass_mode", "get_center_of_mass_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "center_of_mass", PROPERTY_HINT_RANGE, "-10,10,0.01,or_less,or_greater,suffix:m"), "set_center_of_mass", "get_center_of_mass");
+	ADD_LINKED_PROPERTY("center_of_mass_mode", "center_of_mass");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "inertia", PROPERTY_HINT_RANGE, U"0,1000,0.01,or_greater,exp,suffix:kg\u22C5m\u00B2"), "set_inertia", "get_inertia");
+	ADD_GROUP("Deactivation", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sleeping"), "set_sleeping", "is_sleeping");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "can_sleep"), "set_can_sleep", "is_able_to_sleep");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "lock_rotation"), "set_lock_rotation_enabled", "is_lock_rotation_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "freeze"), "set_freeze_enabled", "is_freeze_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "freeze_mode", PROPERTY_HINT_ENUM, "Static,Kinematic"), "set_freeze_mode", "get_freeze_mode");
+	ADD_GROUP("Solver", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "custom_integrator"), "set_use_custom_integrator", "is_using_custom_integrator");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "continuous_cd"), "set_use_continuous_collision_detection", "is_using_continuous_collision_detection");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_contacts_reported", PROPERTY_HINT_RANGE, "0,64,1,or_greater"), "set_max_contacts_reported", "get_max_contacts_reported");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "contact_monitor"), "set_contact_monitor", "is_contact_monitor_enabled");
+	ADD_GROUP("Linear", "linear_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "linear_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_linear_velocity", "get_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "linear_damp_mode", PROPERTY_HINT_ENUM, "Combine,Replace"), "set_linear_damp_mode", "get_linear_damp_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "linear_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_linear_damp", "get_linear_damp");
+	ADD_GROUP("Angular", "angular_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_angular_velocity", "get_angular_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "angular_damp_mode", PROPERTY_HINT_ENUM, "Combine,Replace"), "set_angular_damp_mode", "get_angular_damp_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_damp", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_angular_damp", "get_angular_damp");
+	ADD_GROUP("Constant Forces", "constant_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_force", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m/s\u00B2 (N)"), "set_constant_force", "get_constant_force");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_torque", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m\u00B2/s\u00B2/rad"), "set_constant_torque", "get_constant_torque");
+
+	ADD_SIGNAL(MethodInfo("body_shape_entered", PropertyInfo(Variant::RID, "body_rid"), PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node"), PropertyInfo(Variant::INT, "body_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("body_shape_exited", PropertyInfo(Variant::RID, "body_rid"), PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node"), PropertyInfo(Variant::INT, "body_shape_index"), PropertyInfo(Variant::INT, "local_shape_index")));
+	ADD_SIGNAL(MethodInfo("body_entered", PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node")));
+	ADD_SIGNAL(MethodInfo("body_exited", PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "Node")));
+	ADD_SIGNAL(MethodInfo("sleeping_state_changed"));
+
+	BIND_ENUM_CONSTANT(FREEZE_MODE_STATIC);
+	BIND_ENUM_CONSTANT(FREEZE_MODE_KINEMATIC);
+
+	BIND_ENUM_CONSTANT(CENTER_OF_MASS_MODE_AUTO);
+	BIND_ENUM_CONSTANT(CENTER_OF_MASS_MODE_CUSTOM);
+
+	BIND_ENUM_CONSTANT(DAMP_MODE_COMBINE);
+	BIND_ENUM_CONSTANT(DAMP_MODE_REPLACE);
+}
+
+void RigidBody3D::_validate_property(PropertyInfo &p_property) const {
+	if (center_of_mass_mode != CENTER_OF_MASS_MODE_CUSTOM) {
+		if (p_property.name == "center_of_mass") {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	}
+}
+
+RigidBody3D::RigidBody3D() :
+		PhysicsBody3D(PhysicsServer3D::BODY_MODE_RIGID) {
+	PhysicsServer3D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &RigidBody3D::_body_state_changed));
+}
+
+RigidBody3D::~RigidBody3D() {
+	if (contact_monitor) {
+		memdelete(contact_monitor);
+	}
+}
diff --git a/scene/3d/physics/rigid_body_3d.h b/scene/3d/physics/rigid_body_3d.h
new file mode 100644
index 0000000000..ec051e5e0f
--- /dev/null
+++ b/scene/3d/physics/rigid_body_3d.h
@@ -0,0 +1,248 @@
+/**************************************************************************/
+/*  rigid_body_3d.h                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef RIGID_BODY_3D_H
+#define RIGID_BODY_3D_H
+
+#include "scene/3d/physics/static_body_3d.h"
+
+class RigidBody3D : public PhysicsBody3D {
+	GDCLASS(RigidBody3D, PhysicsBody3D);
+
+public:
+	enum FreezeMode {
+		FREEZE_MODE_STATIC,
+		FREEZE_MODE_KINEMATIC,
+	};
+
+	enum CenterOfMassMode {
+		CENTER_OF_MASS_MODE_AUTO,
+		CENTER_OF_MASS_MODE_CUSTOM,
+	};
+
+	enum DampMode {
+		DAMP_MODE_COMBINE,
+		DAMP_MODE_REPLACE,
+	};
+
+private:
+	bool can_sleep = true;
+	bool lock_rotation = false;
+	bool freeze = false;
+	FreezeMode freeze_mode = FREEZE_MODE_STATIC;
+
+	real_t mass = 1.0;
+	Vector3 inertia;
+	CenterOfMassMode center_of_mass_mode = CENTER_OF_MASS_MODE_AUTO;
+	Vector3 center_of_mass;
+
+	Ref<PhysicsMaterial> physics_material_override;
+
+	Vector3 linear_velocity;
+	Vector3 angular_velocity;
+	Basis inverse_inertia_tensor;
+	real_t gravity_scale = 1.0;
+
+	DampMode linear_damp_mode = DAMP_MODE_COMBINE;
+	DampMode angular_damp_mode = DAMP_MODE_COMBINE;
+
+	real_t linear_damp = 0.0;
+	real_t angular_damp = 0.0;
+
+	bool sleeping = false;
+	bool ccd = false;
+
+	int max_contacts_reported = 0;
+	int contact_count = 0;
+
+	bool custom_integrator = false;
+
+	struct ShapePair {
+		int body_shape = 0;
+		int local_shape = 0;
+		bool tagged = false;
+		bool operator<(const ShapePair &p_sp) const {
+			if (body_shape == p_sp.body_shape) {
+				return local_shape < p_sp.local_shape;
+			} else {
+				return body_shape < p_sp.body_shape;
+			}
+		}
+
+		ShapePair() {}
+		ShapePair(int p_bs, int p_ls) {
+			body_shape = p_bs;
+			local_shape = p_ls;
+			tagged = false;
+		}
+	};
+	struct RigidBody3D_RemoveAction {
+		RID rid;
+		ObjectID body_id;
+		ShapePair pair;
+	};
+	struct BodyState {
+		RID rid;
+		//int rc;
+		bool in_tree = false;
+		VSet<ShapePair> shapes;
+	};
+
+	struct ContactMonitor {
+		bool locked = false;
+		HashMap<ObjectID, BodyState> body_map;
+	};
+
+	ContactMonitor *contact_monitor = nullptr;
+	void _body_enter_tree(ObjectID p_id);
+	void _body_exit_tree(ObjectID p_id);
+
+	void _body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_local_shape);
+	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state);
+
+	void _sync_body_state(PhysicsDirectBodyState3D *p_state);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+	void _validate_property(PropertyInfo &p_property) const;
+
+	GDVIRTUAL1(_integrate_forces, PhysicsDirectBodyState3D *)
+
+	virtual void _body_state_changed(PhysicsDirectBodyState3D *p_state);
+
+	void _apply_body_mode();
+
+public:
+	void set_lock_rotation_enabled(bool p_lock_rotation);
+	bool is_lock_rotation_enabled() const;
+
+	void set_freeze_enabled(bool p_freeze);
+	bool is_freeze_enabled() const;
+
+	void set_freeze_mode(FreezeMode p_freeze_mode);
+	FreezeMode get_freeze_mode() const;
+
+	void set_mass(real_t p_mass);
+	real_t get_mass() const;
+
+	virtual real_t get_inverse_mass() const override { return 1.0 / mass; }
+
+	void set_inertia(const Vector3 &p_inertia);
+	const Vector3 &get_inertia() const;
+
+	void set_center_of_mass_mode(CenterOfMassMode p_mode);
+	CenterOfMassMode get_center_of_mass_mode() const;
+
+	void set_center_of_mass(const Vector3 &p_center_of_mass);
+	const Vector3 &get_center_of_mass() const;
+
+	void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);
+	Ref<PhysicsMaterial> get_physics_material_override() const;
+
+	void set_linear_velocity(const Vector3 &p_velocity);
+	Vector3 get_linear_velocity() const override;
+
+	void set_axis_velocity(const Vector3 &p_axis);
+
+	void set_angular_velocity(const Vector3 &p_velocity);
+	Vector3 get_angular_velocity() const override;
+
+	Basis get_inverse_inertia_tensor() const;
+
+	void set_gravity_scale(real_t p_gravity_scale);
+	real_t get_gravity_scale() const;
+
+	void set_linear_damp_mode(DampMode p_mode);
+	DampMode get_linear_damp_mode() const;
+
+	void set_angular_damp_mode(DampMode p_mode);
+	DampMode get_angular_damp_mode() const;
+
+	void set_linear_damp(real_t p_linear_damp);
+	real_t get_linear_damp() const;
+
+	void set_angular_damp(real_t p_angular_damp);
+	real_t get_angular_damp() const;
+
+	void set_use_custom_integrator(bool p_enable);
+	bool is_using_custom_integrator();
+
+	void set_sleeping(bool p_sleeping);
+	bool is_sleeping() const;
+
+	void set_can_sleep(bool p_active);
+	bool is_able_to_sleep() const;
+
+	void set_contact_monitor(bool p_enabled);
+	bool is_contact_monitor_enabled() const;
+
+	void set_max_contacts_reported(int p_amount);
+	int get_max_contacts_reported() const;
+	int get_contact_count() const;
+
+	void set_use_continuous_collision_detection(bool p_enable);
+	bool is_using_continuous_collision_detection() const;
+
+	TypedArray<Node3D> get_colliding_bodies() const;
+
+	void apply_central_impulse(const Vector3 &p_impulse);
+	void apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position = Vector3());
+	void apply_torque_impulse(const Vector3 &p_impulse);
+
+	void apply_central_force(const Vector3 &p_force);
+	void apply_force(const Vector3 &p_force, const Vector3 &p_position = Vector3());
+	void apply_torque(const Vector3 &p_torque);
+
+	void add_constant_central_force(const Vector3 &p_force);
+	void add_constant_force(const Vector3 &p_force, const Vector3 &p_position = Vector3());
+	void add_constant_torque(const Vector3 &p_torque);
+
+	void set_constant_force(const Vector3 &p_force);
+	Vector3 get_constant_force() const;
+
+	void set_constant_torque(const Vector3 &p_torque);
+	Vector3 get_constant_torque() const;
+
+	virtual PackedStringArray get_configuration_warnings() const override;
+
+	RigidBody3D();
+	~RigidBody3D();
+
+private:
+	void _reload_physics_characteristics();
+};
+
+VARIANT_ENUM_CAST(RigidBody3D::FreezeMode);
+VARIANT_ENUM_CAST(RigidBody3D::CenterOfMassMode);
+VARIANT_ENUM_CAST(RigidBody3D::DampMode);
+
+#endif // RIGID_BODY_3D_H
diff --git a/scene/3d/physics/shape_cast_3d.cpp b/scene/3d/physics/shape_cast_3d.cpp
new file mode 100644
index 0000000000..5e6302cb81
--- /dev/null
+++ b/scene/3d/physics/shape_cast_3d.cpp
@@ -0,0 +1,633 @@
+/**************************************************************************/
+/*  shape_cast_3d.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "shape_cast_3d.h"
+
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/resources/3d/concave_polygon_shape_3d.h"
+
+void ShapeCast3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			if (Engine::get_singleton()->is_editor_hint()) {
+				_update_debug_shape_vertices();
+			}
+			if (enabled && !Engine::get_singleton()->is_editor_hint()) {
+				set_physics_process_internal(true);
+			} else {
+				set_physics_process_internal(false);
+			}
+
+			if (get_tree()->is_debugging_collisions_hint()) {
+				_update_debug_shape();
+			}
+
+			if (Object::cast_to<CollisionObject3D>(get_parent())) {
+				if (exclude_parent_body) {
+					exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+				} else {
+					exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+				}
+			}
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (enabled) {
+				set_physics_process_internal(false);
+			}
+
+			if (debug_shape) {
+				_clear_debug_shape();
+			}
+		} break;
+
+		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
+			if (!enabled) {
+				break;
+			}
+
+			bool prev_collision_state = collided;
+			_update_shapecast_state();
+			if (get_tree()->is_debugging_collisions_hint()) {
+				if (prev_collision_state != collided) {
+					_update_debug_shape_material(true);
+				}
+				if (collided) {
+					_update_debug_shape();
+				}
+				if (prev_collision_state == collided && !collided) {
+					_update_debug_shape();
+				}
+			}
+		} break;
+	}
+}
+
+void ShapeCast3D::_bind_methods() {
+#ifndef DISABLE_DEPRECATED
+	ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &ShapeCast3D::resource_changed);
+#endif
+
+	ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &ShapeCast3D::set_enabled);
+	ClassDB::bind_method(D_METHOD("is_enabled"), &ShapeCast3D::is_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_shape", "shape"), &ShapeCast3D::set_shape);
+	ClassDB::bind_method(D_METHOD("get_shape"), &ShapeCast3D::get_shape);
+
+	ClassDB::bind_method(D_METHOD("set_target_position", "local_point"), &ShapeCast3D::set_target_position);
+	ClassDB::bind_method(D_METHOD("get_target_position"), &ShapeCast3D::get_target_position);
+
+	ClassDB::bind_method(D_METHOD("set_margin", "margin"), &ShapeCast3D::set_margin);
+	ClassDB::bind_method(D_METHOD("get_margin"), &ShapeCast3D::get_margin);
+
+	ClassDB::bind_method(D_METHOD("set_max_results", "max_results"), &ShapeCast3D::set_max_results);
+	ClassDB::bind_method(D_METHOD("get_max_results"), &ShapeCast3D::get_max_results);
+
+	ClassDB::bind_method(D_METHOD("is_colliding"), &ShapeCast3D::is_colliding);
+	ClassDB::bind_method(D_METHOD("get_collision_count"), &ShapeCast3D::get_collision_count);
+
+	ClassDB::bind_method(D_METHOD("force_shapecast_update"), &ShapeCast3D::force_shapecast_update);
+
+	ClassDB::bind_method(D_METHOD("get_collider", "index"), &ShapeCast3D::get_collider);
+	ClassDB::bind_method(D_METHOD("get_collider_rid", "index"), &ShapeCast3D::get_collider_rid);
+	ClassDB::bind_method(D_METHOD("get_collider_shape", "index"), &ShapeCast3D::get_collider_shape);
+	ClassDB::bind_method(D_METHOD("get_collision_point", "index"), &ShapeCast3D::get_collision_point);
+	ClassDB::bind_method(D_METHOD("get_collision_normal", "index"), &ShapeCast3D::get_collision_normal);
+
+	ClassDB::bind_method(D_METHOD("get_closest_collision_safe_fraction"), &ShapeCast3D::get_closest_collision_safe_fraction);
+	ClassDB::bind_method(D_METHOD("get_closest_collision_unsafe_fraction"), &ShapeCast3D::get_closest_collision_unsafe_fraction);
+
+	ClassDB::bind_method(D_METHOD("add_exception_rid", "rid"), &ShapeCast3D::add_exception_rid);
+	ClassDB::bind_method(D_METHOD("add_exception", "node"), &ShapeCast3D::add_exception);
+
+	ClassDB::bind_method(D_METHOD("remove_exception_rid", "rid"), &ShapeCast3D::remove_exception_rid);
+	ClassDB::bind_method(D_METHOD("remove_exception", "node"), &ShapeCast3D::remove_exception);
+
+	ClassDB::bind_method(D_METHOD("clear_exceptions"), &ShapeCast3D::clear_exceptions);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &ShapeCast3D::set_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &ShapeCast3D::get_collision_mask);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask_value", "layer_number", "value"), &ShapeCast3D::set_collision_mask_value);
+	ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &ShapeCast3D::get_collision_mask_value);
+
+	ClassDB::bind_method(D_METHOD("set_exclude_parent_body", "mask"), &ShapeCast3D::set_exclude_parent_body);
+	ClassDB::bind_method(D_METHOD("get_exclude_parent_body"), &ShapeCast3D::get_exclude_parent_body);
+
+	ClassDB::bind_method(D_METHOD("set_collide_with_areas", "enable"), &ShapeCast3D::set_collide_with_areas);
+	ClassDB::bind_method(D_METHOD("is_collide_with_areas_enabled"), &ShapeCast3D::is_collide_with_areas_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_collide_with_bodies", "enable"), &ShapeCast3D::set_collide_with_bodies);
+	ClassDB::bind_method(D_METHOD("is_collide_with_bodies_enabled"), &ShapeCast3D::is_collide_with_bodies_enabled);
+
+	ClassDB::bind_method(D_METHOD("_get_collision_result"), &ShapeCast3D::_get_collision_result);
+
+	ClassDB::bind_method(D_METHOD("set_debug_shape_custom_color", "debug_shape_custom_color"), &ShapeCast3D::set_debug_shape_custom_color);
+	ClassDB::bind_method(D_METHOD("get_debug_shape_custom_color"), &ShapeCast3D::get_debug_shape_custom_color);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "is_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape3D"), "set_shape", "get_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "exclude_parent"), "set_exclude_parent_body", "get_exclude_parent_body");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "target_position", PROPERTY_HINT_NONE, "suffix:m"), "set_target_position", "get_target_position");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "margin", PROPERTY_HINT_RANGE, "0,100,0.01,suffix:m"), "set_margin", "get_margin");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_results"), "set_max_results", "get_max_results");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "collision_result", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "", "_get_collision_result");
+
+	ADD_GROUP("Collide With", "collide_with");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_areas", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_areas", "is_collide_with_areas_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_bodies", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_bodies", "is_collide_with_bodies_enabled");
+
+	ADD_GROUP("Debug Shape", "debug_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "debug_shape_custom_color"), "set_debug_shape_custom_color", "get_debug_shape_custom_color");
+}
+
+PackedStringArray ShapeCast3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node3D::get_configuration_warnings();
+
+	if (shape.is_null()) {
+		warnings.push_back(RTR("This node cannot interact with other objects unless a Shape3D is assigned."));
+	}
+	if (shape.is_valid() && Object::cast_to<ConcavePolygonShape3D>(*shape)) {
+		warnings.push_back(RTR("ShapeCast3D does not support ConcavePolygonShape3Ds. Collisions will not be reported."));
+	}
+	return warnings;
+}
+
+void ShapeCast3D::set_enabled(bool p_enabled) {
+	enabled = p_enabled;
+	update_gizmos();
+
+	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint()) {
+		set_physics_process_internal(p_enabled);
+	}
+	if (!p_enabled) {
+		collided = false;
+	}
+
+	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint()) {
+		if (p_enabled) {
+			_update_debug_shape();
+		} else {
+			_clear_debug_shape();
+		}
+	}
+}
+
+bool ShapeCast3D::is_enabled() const {
+	return enabled;
+}
+
+void ShapeCast3D::set_target_position(const Vector3 &p_point) {
+	target_position = p_point;
+	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint()) {
+		_update_debug_shape();
+	}
+	update_gizmos();
+
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (is_inside_tree()) {
+			_update_debug_shape_vertices();
+		}
+	} else if (debug_shape) {
+		_update_debug_shape();
+	}
+}
+
+Vector3 ShapeCast3D::get_target_position() const {
+	return target_position;
+}
+
+void ShapeCast3D::set_margin(real_t p_margin) {
+	margin = p_margin;
+}
+
+real_t ShapeCast3D::get_margin() const {
+	return margin;
+}
+
+void ShapeCast3D::set_max_results(int p_max_results) {
+	max_results = p_max_results;
+}
+
+int ShapeCast3D::get_max_results() const {
+	return max_results;
+}
+
+void ShapeCast3D::set_collision_mask(uint32_t p_mask) {
+	collision_mask = p_mask;
+}
+
+uint32_t ShapeCast3D::get_collision_mask() const {
+	return collision_mask;
+}
+
+void ShapeCast3D::set_collision_mask_value(int p_layer_number, bool p_value) {
+	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
+	uint32_t mask = get_collision_mask();
+	if (p_value) {
+		mask |= 1 << (p_layer_number - 1);
+	} else {
+		mask &= ~(1 << (p_layer_number - 1));
+	}
+	set_collision_mask(mask);
+}
+
+bool ShapeCast3D::get_collision_mask_value(int p_layer_number) const {
+	ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
+	ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
+	return get_collision_mask() & (1 << (p_layer_number - 1));
+}
+
+int ShapeCast3D::get_collision_count() const {
+	return result.size();
+}
+
+bool ShapeCast3D::is_colliding() const {
+	return collided;
+}
+
+Object *ShapeCast3D::get_collider(int p_idx) const {
+	ERR_FAIL_INDEX_V_MSG(p_idx, result.size(), nullptr, "No collider found.");
+
+	if (result[p_idx].collider_id.is_null()) {
+		return nullptr;
+	}
+	return ObjectDB::get_instance(result[p_idx].collider_id);
+}
+
+RID ShapeCast3D::get_collider_rid(int p_idx) const {
+	ERR_FAIL_INDEX_V_MSG(p_idx, result.size(), RID(), "No collider RID found.");
+	return result[p_idx].rid;
+}
+
+int ShapeCast3D::get_collider_shape(int p_idx) const {
+	ERR_FAIL_INDEX_V_MSG(p_idx, result.size(), -1, "No collider shape found.");
+	return result[p_idx].shape;
+}
+
+Vector3 ShapeCast3D::get_collision_point(int p_idx) const {
+	ERR_FAIL_INDEX_V_MSG(p_idx, result.size(), Vector3(), "No collision point found.");
+	return result[p_idx].point;
+}
+
+Vector3 ShapeCast3D::get_collision_normal(int p_idx) const {
+	ERR_FAIL_INDEX_V_MSG(p_idx, result.size(), Vector3(), "No collision normal found.");
+	return result[p_idx].normal;
+}
+
+real_t ShapeCast3D::get_closest_collision_safe_fraction() const {
+	return collision_safe_fraction;
+}
+
+real_t ShapeCast3D::get_closest_collision_unsafe_fraction() const {
+	return collision_unsafe_fraction;
+}
+
+#ifndef DISABLE_DEPRECATED
+void ShapeCast3D::resource_changed(Ref<Resource> p_res) {
+}
+#endif
+
+void ShapeCast3D::_shape_changed() {
+	update_gizmos();
+	bool is_editor = Engine::get_singleton()->is_editor_hint();
+	if (is_inside_tree() && (is_editor || get_tree()->is_debugging_collisions_hint())) {
+		_update_debug_shape();
+	}
+}
+
+void ShapeCast3D::set_shape(const Ref<Shape3D> &p_shape) {
+	if (p_shape == shape) {
+		return;
+	}
+	if (shape.is_valid()) {
+		shape->disconnect_changed(callable_mp(this, &ShapeCast3D::_shape_changed));
+	}
+	shape = p_shape;
+	if (shape.is_valid()) {
+		shape->connect_changed(callable_mp(this, &ShapeCast3D::_shape_changed));
+		shape_rid = shape->get_rid();
+	}
+
+	bool is_editor = Engine::get_singleton()->is_editor_hint();
+	if (is_inside_tree() && (is_editor || get_tree()->is_debugging_collisions_hint())) {
+		_update_debug_shape();
+	}
+	update_gizmos();
+	update_configuration_warnings();
+}
+
+Ref<Shape3D> ShapeCast3D::get_shape() const {
+	return shape;
+}
+
+void ShapeCast3D::set_exclude_parent_body(bool p_exclude_parent_body) {
+	if (exclude_parent_body == p_exclude_parent_body) {
+		return;
+	}
+	exclude_parent_body = p_exclude_parent_body;
+
+	if (!is_inside_tree()) {
+		return;
+	}
+	if (Object::cast_to<CollisionObject3D>(get_parent())) {
+		if (exclude_parent_body) {
+			exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+		} else {
+			exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+		}
+	}
+}
+
+bool ShapeCast3D::get_exclude_parent_body() const {
+	return exclude_parent_body;
+}
+
+void ShapeCast3D::_update_shapecast_state() {
+	result.clear();
+
+	ERR_FAIL_COND_MSG(shape.is_null(), "Null reference to shape. ShapeCast3D requires a Shape3D to sweep for collisions.");
+
+	Ref<World3D> w3d = get_world_3d();
+	ERR_FAIL_COND(w3d.is_null());
+
+	PhysicsDirectSpaceState3D *dss = PhysicsServer3D::get_singleton()->space_get_direct_state(w3d->get_space());
+	ERR_FAIL_NULL(dss);
+
+	Transform3D gt = get_global_transform();
+
+	PhysicsDirectSpaceState3D::ShapeParameters params;
+	params.shape_rid = shape_rid;
+	params.transform = gt;
+	params.motion = gt.basis.xform(target_position);
+	params.margin = margin;
+	params.exclude = exclude;
+	params.collision_mask = collision_mask;
+	params.collide_with_bodies = collide_with_bodies;
+	params.collide_with_areas = collide_with_areas;
+
+	collision_safe_fraction = 0.0;
+	collision_unsafe_fraction = 0.0;
+
+	if (target_position != Vector3()) {
+		dss->cast_motion(params, collision_safe_fraction, collision_unsafe_fraction);
+		if (collision_unsafe_fraction < 1.0) {
+			// Move shape transform to the point of impact,
+			// so we can collect contact info at that point.
+			gt.set_origin(gt.get_origin() + params.motion * (collision_unsafe_fraction + CMP_EPSILON));
+			params.transform = gt;
+		}
+	}
+	// Regardless of whether the shape is stuck or it's moved along
+	// the motion vector, we'll only consider static collisions from now on.
+	params.motion = Vector3();
+
+	bool intersected = true;
+	while (intersected && result.size() < max_results) {
+		PhysicsDirectSpaceState3D::ShapeRestInfo info;
+		intersected = dss->rest_info(params, &info);
+		if (intersected) {
+			result.push_back(info);
+			params.exclude.insert(info.rid);
+		}
+	}
+	collided = !result.is_empty();
+}
+
+void ShapeCast3D::force_shapecast_update() {
+	_update_shapecast_state();
+}
+
+void ShapeCast3D::add_exception_rid(const RID &p_rid) {
+	exclude.insert(p_rid);
+}
+
+void ShapeCast3D::add_exception(const CollisionObject3D *p_node) {
+	ERR_FAIL_NULL_MSG(p_node, "The passed Node must be an instance of CollisionObject3D.");
+	add_exception_rid(p_node->get_rid());
+}
+
+void ShapeCast3D::remove_exception_rid(const RID &p_rid) {
+	exclude.erase(p_rid);
+}
+
+void ShapeCast3D::remove_exception(const CollisionObject3D *p_node) {
+	ERR_FAIL_NULL_MSG(p_node, "The passed Node must be an instance of CollisionObject3D.");
+	remove_exception_rid(p_node->get_rid());
+}
+
+void ShapeCast3D::clear_exceptions() {
+	exclude.clear();
+}
+
+void ShapeCast3D::set_collide_with_areas(bool p_clip) {
+	collide_with_areas = p_clip;
+}
+
+bool ShapeCast3D::is_collide_with_areas_enabled() const {
+	return collide_with_areas;
+}
+
+void ShapeCast3D::set_collide_with_bodies(bool p_clip) {
+	collide_with_bodies = p_clip;
+}
+
+bool ShapeCast3D::is_collide_with_bodies_enabled() const {
+	return collide_with_bodies;
+}
+
+Array ShapeCast3D::_get_collision_result() const {
+	Array ret;
+
+	for (int i = 0; i < result.size(); ++i) {
+		const PhysicsDirectSpaceState3D::ShapeRestInfo &sri = result[i];
+
+		Dictionary col;
+		col["point"] = sri.point;
+		col["normal"] = sri.normal;
+		col["rid"] = sri.rid;
+		col["collider"] = ObjectDB::get_instance(sri.collider_id);
+		col["collider_id"] = sri.collider_id;
+		col["shape"] = sri.shape;
+		col["linear_velocity"] = sri.linear_velocity;
+
+		ret.push_back(col);
+	}
+	return ret;
+}
+
+void ShapeCast3D::_update_debug_shape_vertices() {
+	debug_shape_vertices.clear();
+	debug_line_vertices.clear();
+
+	if (!shape.is_null()) {
+		debug_shape_vertices.append_array(shape->get_debug_mesh_lines());
+		for (int i = 0; i < debug_shape_vertices.size(); i++) {
+			debug_shape_vertices.set(i, debug_shape_vertices[i] + Vector3(target_position * get_closest_collision_safe_fraction()));
+		}
+	}
+
+	if (target_position == Vector3()) {
+		return;
+	}
+
+	debug_line_vertices.push_back(Vector3());
+	debug_line_vertices.push_back(target_position);
+}
+
+const Vector<Vector3> &ShapeCast3D::get_debug_shape_vertices() const {
+	return debug_shape_vertices;
+}
+
+const Vector<Vector3> &ShapeCast3D::get_debug_line_vertices() const {
+	return debug_line_vertices;
+}
+
+void ShapeCast3D::set_debug_shape_custom_color(const Color &p_color) {
+	debug_shape_custom_color = p_color;
+	if (debug_material.is_valid()) {
+		_update_debug_shape_material();
+	}
+}
+
+Ref<StandardMaterial3D> ShapeCast3D::get_debug_material() {
+	_update_debug_shape_material();
+	return debug_material;
+}
+
+const Color &ShapeCast3D::get_debug_shape_custom_color() const {
+	return debug_shape_custom_color;
+}
+
+void ShapeCast3D::_create_debug_shape() {
+	_update_debug_shape_material();
+
+	Ref<ArrayMesh> mesh = memnew(ArrayMesh);
+
+	MeshInstance3D *mi = memnew(MeshInstance3D);
+	mi->set_mesh(mesh);
+
+	add_child(mi);
+	debug_shape = mi;
+}
+
+void ShapeCast3D::_update_debug_shape_material(bool p_check_collision) {
+	if (!debug_material.is_valid()) {
+		Ref<StandardMaterial3D> material = memnew(StandardMaterial3D);
+		debug_material = material;
+
+		material->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+		material->set_flag(StandardMaterial3D::FLAG_DISABLE_FOG, true);
+		// Use double-sided rendering so that the RayCast can be seen if the camera is inside.
+		material->set_cull_mode(BaseMaterial3D::CULL_DISABLED);
+		material->set_transparency(BaseMaterial3D::TRANSPARENCY_ALPHA);
+	}
+
+	Color color = debug_shape_custom_color;
+	if (color == Color(0.0, 0.0, 0.0)) {
+		// Use the default debug shape color defined in the Project Settings.
+		color = get_tree()->get_debug_collisions_color();
+	}
+
+	if (p_check_collision && collided) {
+		if ((color.get_h() < 0.055 || color.get_h() > 0.945) && color.get_s() > 0.5 && color.get_v() > 0.5) {
+			// If base color is already quite reddish, highlight collision with green color
+			color = Color(0.0, 1.0, 0.0, color.a);
+		} else {
+			// Else, highlight collision with red color
+			color = Color(1.0, 0, 0, color.a);
+		}
+	}
+
+	Ref<StandardMaterial3D> material = static_cast<Ref<StandardMaterial3D>>(debug_material);
+	material->set_albedo(color);
+}
+
+void ShapeCast3D::_update_debug_shape() {
+	if (!enabled) {
+		return;
+	}
+
+	if (!debug_shape) {
+		_create_debug_shape();
+	}
+
+	_update_debug_shape_vertices();
+
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+
+	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
+	Ref<ArrayMesh> mesh = mi->get_mesh();
+	if (!mesh.is_valid()) {
+		return;
+	}
+
+	mesh->clear_surfaces();
+
+	Array a;
+	a.resize(Mesh::ARRAY_MAX);
+
+	uint32_t flags = 0;
+	int surface_count = 0;
+
+	if (!debug_shape_vertices.is_empty()) {
+		a[Mesh::ARRAY_VERTEX] = debug_shape_vertices;
+		mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, a, Array(), Dictionary(), flags);
+		mesh->surface_set_material(surface_count, debug_material);
+		++surface_count;
+	}
+
+	if (!debug_line_vertices.is_empty()) {
+		a[Mesh::ARRAY_VERTEX] = debug_line_vertices;
+		mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, a, Array(), Dictionary(), flags);
+		mesh->surface_set_material(surface_count, debug_material);
+		++surface_count;
+	}
+}
+
+void ShapeCast3D::_clear_debug_shape() {
+	if (!debug_shape) {
+		return;
+	}
+
+	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
+	if (mi->is_inside_tree()) {
+		mi->queue_free();
+	} else {
+		memdelete(mi);
+	}
+
+	debug_shape = nullptr;
+}
diff --git a/scene/3d/physics/shape_cast_3d.h b/scene/3d/physics/shape_cast_3d.h
new file mode 100644
index 0000000000..9052db9046
--- /dev/null
+++ b/scene/3d/physics/shape_cast_3d.h
@@ -0,0 +1,146 @@
+/**************************************************************************/
+/*  shape_cast_3d.h                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef SHAPE_CAST_3D_H
+#define SHAPE_CAST_3D_H
+
+#include "scene/3d/node_3d.h"
+#include "scene/resources/3d/shape_3d.h"
+
+class CollisionObject3D;
+
+class ShapeCast3D : public Node3D {
+	GDCLASS(ShapeCast3D, Node3D);
+
+	bool enabled = true;
+#ifndef DISABLE_DEPRECATED
+	void resource_changed(Ref<Resource> p_res);
+#endif
+
+	Ref<Shape3D> shape;
+	RID shape_rid;
+	Vector3 target_position = Vector3(0, -1, 0);
+
+	HashSet<RID> exclude;
+	real_t margin = 0.0;
+	uint32_t collision_mask = 1;
+	bool exclude_parent_body = true;
+	bool collide_with_areas = false;
+	bool collide_with_bodies = true;
+
+	Node *debug_shape = nullptr;
+	Ref<Material> debug_material;
+	Color debug_shape_custom_color = Color(0.0, 0.0, 0.0);
+	Vector<Vector3> debug_shape_vertices;
+	Vector<Vector3> debug_line_vertices;
+
+	void _create_debug_shape();
+	void _update_debug_shape();
+	void _update_debug_shape_material(bool p_check_collision = false);
+	void _update_debug_shape_vertices();
+	void _clear_debug_shape();
+
+	// Result
+	int max_results = 32;
+	Vector<PhysicsDirectSpaceState3D::ShapeRestInfo> result;
+	bool collided = false;
+	real_t collision_safe_fraction = 1.0;
+	real_t collision_unsafe_fraction = 1.0;
+
+	Array _get_collision_result() const;
+
+protected:
+	void _notification(int p_what);
+	void _update_shapecast_state();
+	void _shape_changed();
+	static void _bind_methods();
+
+public:
+	void set_collide_with_areas(bool p_clip);
+	bool is_collide_with_areas_enabled() const;
+
+	void set_collide_with_bodies(bool p_clip);
+	bool is_collide_with_bodies_enabled() const;
+
+	void set_enabled(bool p_enabled);
+	bool is_enabled() const;
+
+	void set_shape(const Ref<Shape3D> &p_shape);
+	Ref<Shape3D> get_shape() const;
+
+	void set_target_position(const Vector3 &p_point);
+	Vector3 get_target_position() const;
+
+	void set_margin(real_t p_margin);
+	real_t get_margin() const;
+
+	void set_max_results(int p_max_results);
+	int get_max_results() const;
+
+	void set_collision_mask(uint32_t p_mask);
+	uint32_t get_collision_mask() const;
+
+	void set_collision_mask_value(int p_layer_number, bool p_value);
+	bool get_collision_mask_value(int p_layer_number) const;
+
+	void set_exclude_parent_body(bool p_exclude_parent_body);
+	bool get_exclude_parent_body() const;
+
+	const Color &get_debug_shape_custom_color() const;
+	void set_debug_shape_custom_color(const Color &p_color);
+
+	const Vector<Vector3> &get_debug_shape_vertices() const;
+	const Vector<Vector3> &get_debug_line_vertices() const;
+
+	Ref<StandardMaterial3D> get_debug_material();
+
+	int get_collision_count() const;
+	Object *get_collider(int p_idx) const;
+	RID get_collider_rid(int p_idx) const;
+	int get_collider_shape(int p_idx) const;
+	Vector3 get_collision_point(int p_idx) const;
+	Vector3 get_collision_normal(int p_idx) const;
+
+	real_t get_closest_collision_safe_fraction() const;
+	real_t get_closest_collision_unsafe_fraction() const;
+
+	void force_shapecast_update();
+	bool is_colliding() const;
+
+	void add_exception_rid(const RID &p_rid);
+	void add_exception(const CollisionObject3D *p_node);
+	void remove_exception_rid(const RID &p_rid);
+	void remove_exception(const CollisionObject3D *p_node);
+	void clear_exceptions();
+
+	virtual PackedStringArray get_configuration_warnings() const override;
+};
+
+#endif // SHAPE_CAST_3D_H
diff --git a/scene/3d/physics/spring_arm_3d.cpp b/scene/3d/physics/spring_arm_3d.cpp
new file mode 100644
index 0000000000..8d2f10310c
--- /dev/null
+++ b/scene/3d/physics/spring_arm_3d.cpp
@@ -0,0 +1,202 @@
+/**************************************************************************/
+/*  spring_arm_3d.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "spring_arm_3d.h"
+
+#include "scene/3d/camera_3d.h"
+#include "scene/resources/3d/shape_3d.h"
+
+void SpringArm3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			if (!Engine::get_singleton()->is_editor_hint()) {
+				set_physics_process_internal(true);
+			}
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			if (!Engine::get_singleton()->is_editor_hint()) {
+				set_physics_process_internal(false);
+			}
+		} break;
+
+		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
+			process_spring();
+		} break;
+	}
+}
+
+void SpringArm3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_hit_length"), &SpringArm3D::get_hit_length);
+
+	ClassDB::bind_method(D_METHOD("set_length", "length"), &SpringArm3D::set_length);
+	ClassDB::bind_method(D_METHOD("get_length"), &SpringArm3D::get_length);
+
+	ClassDB::bind_method(D_METHOD("set_shape", "shape"), &SpringArm3D::set_shape);
+	ClassDB::bind_method(D_METHOD("get_shape"), &SpringArm3D::get_shape);
+
+	ClassDB::bind_method(D_METHOD("add_excluded_object", "RID"), &SpringArm3D::add_excluded_object);
+	ClassDB::bind_method(D_METHOD("remove_excluded_object", "RID"), &SpringArm3D::remove_excluded_object);
+	ClassDB::bind_method(D_METHOD("clear_excluded_objects"), &SpringArm3D::clear_excluded_objects);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &SpringArm3D::set_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &SpringArm3D::get_mask);
+
+	ClassDB::bind_method(D_METHOD("set_margin", "margin"), &SpringArm3D::set_margin);
+	ClassDB::bind_method(D_METHOD("get_margin"), &SpringArm3D::get_margin);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape3D"), "set_shape", "get_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "spring_length", PROPERTY_HINT_NONE, "suffix:m"), "set_length", "get_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "margin", PROPERTY_HINT_NONE, "suffix:m"), "set_margin", "get_margin");
+}
+
+real_t SpringArm3D::get_length() const {
+	return spring_length;
+}
+
+void SpringArm3D::set_length(real_t p_length) {
+	if (is_inside_tree() && (Engine::get_singleton()->is_editor_hint() || get_tree()->is_debugging_collisions_hint())) {
+		update_gizmos();
+	}
+
+	spring_length = p_length;
+}
+
+void SpringArm3D::set_shape(Ref<Shape3D> p_shape) {
+	shape = p_shape;
+}
+
+Ref<Shape3D> SpringArm3D::get_shape() const {
+	return shape;
+}
+
+void SpringArm3D::set_mask(uint32_t p_mask) {
+	mask = p_mask;
+}
+
+uint32_t SpringArm3D::get_mask() {
+	return mask;
+}
+
+real_t SpringArm3D::get_margin() {
+	return margin;
+}
+
+void SpringArm3D::set_margin(real_t p_margin) {
+	margin = p_margin;
+}
+
+void SpringArm3D::add_excluded_object(RID p_rid) {
+	excluded_objects.insert(p_rid);
+}
+
+bool SpringArm3D::remove_excluded_object(RID p_rid) {
+	return excluded_objects.erase(p_rid);
+}
+
+void SpringArm3D::clear_excluded_objects() {
+	excluded_objects.clear();
+}
+
+real_t SpringArm3D::get_hit_length() {
+	return current_spring_length;
+}
+
+void SpringArm3D::process_spring() {
+	// From
+	real_t motion_delta(1);
+	real_t motion_delta_unsafe(1);
+
+	Vector3 motion;
+	const Vector3 cast_direction(get_global_transform().basis.xform(Vector3(0, 0, 1)));
+
+	motion = Vector3(cast_direction * (spring_length));
+
+	if (shape.is_null()) {
+		Camera3D *camera = nullptr;
+		for (int i = get_child_count() - 1; 0 <= i; --i) {
+			camera = Object::cast_to<Camera3D>(get_child(i));
+			if (camera) {
+				break;
+			}
+		}
+
+		if (camera != nullptr) {
+			//use camera rotation, but spring arm position
+			Transform3D base_transform = camera->get_global_transform();
+			base_transform.origin = get_global_transform().origin;
+
+			PhysicsDirectSpaceState3D::ShapeParameters shape_params;
+			shape_params.shape_rid = camera->get_pyramid_shape_rid();
+			shape_params.transform = base_transform;
+			shape_params.motion = motion;
+			shape_params.exclude = excluded_objects;
+			shape_params.collision_mask = mask;
+
+			get_world_3d()->get_direct_space_state()->cast_motion(shape_params, motion_delta, motion_delta_unsafe);
+		} else {
+			PhysicsDirectSpaceState3D::RayParameters ray_params;
+			ray_params.from = get_global_transform().origin;
+			ray_params.to = get_global_transform().origin + motion;
+			ray_params.exclude = excluded_objects;
+			ray_params.collision_mask = mask;
+
+			PhysicsDirectSpaceState3D::RayResult r;
+			bool intersected = get_world_3d()->get_direct_space_state()->intersect_ray(ray_params, r);
+			if (intersected) {
+				real_t dist = get_global_transform().origin.distance_to(r.position);
+				dist -= margin;
+				motion_delta = dist / (spring_length);
+			}
+		}
+	} else {
+		PhysicsDirectSpaceState3D::ShapeParameters shape_params;
+		shape_params.shape_rid = shape->get_rid();
+		shape_params.transform = get_global_transform();
+		shape_params.motion = motion;
+		shape_params.exclude = excluded_objects;
+		shape_params.collision_mask = mask;
+
+		get_world_3d()->get_direct_space_state()->cast_motion(shape_params, motion_delta, motion_delta_unsafe);
+	}
+
+	current_spring_length = spring_length * motion_delta;
+	Transform3D child_transform;
+	child_transform.origin = get_global_transform().origin + cast_direction * (spring_length * motion_delta);
+
+	for (int i = get_child_count() - 1; 0 <= i; --i) {
+		Node3D *child = Object::cast_to<Node3D>(get_child(i));
+		if (child) {
+			child_transform.basis = child->get_global_transform().basis;
+			child->set_global_transform(child_transform);
+		}
+	}
+}
diff --git a/scene/3d/physics/spring_arm_3d.h b/scene/3d/physics/spring_arm_3d.h
new file mode 100644
index 0000000000..c7e1da35f0
--- /dev/null
+++ b/scene/3d/physics/spring_arm_3d.h
@@ -0,0 +1,71 @@
+/**************************************************************************/
+/*  spring_arm_3d.h                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef SPRING_ARM_3D_H
+#define SPRING_ARM_3D_H
+
+#include "scene/3d/node_3d.h"
+
+class SpringArm3D : public Node3D {
+	GDCLASS(SpringArm3D, Node3D);
+
+	Ref<Shape3D> shape;
+	HashSet<RID> excluded_objects;
+	real_t spring_length = 1.0;
+	real_t current_spring_length = 0.0;
+	bool keep_child_basis = false;
+	uint32_t mask = 1;
+	real_t margin = 0.01;
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void set_length(real_t p_length);
+	real_t get_length() const;
+	void set_shape(Ref<Shape3D> p_shape);
+	Ref<Shape3D> get_shape() const;
+	void set_mask(uint32_t p_mask);
+	uint32_t get_mask();
+	void add_excluded_object(RID p_rid);
+	bool remove_excluded_object(RID p_rid);
+	void clear_excluded_objects();
+	real_t get_hit_length();
+	void set_margin(real_t p_margin);
+	real_t get_margin();
+
+	SpringArm3D() {}
+
+private:
+	void process_spring();
+};
+
+#endif // SPRING_ARM_3D_H
diff --git a/scene/3d/physics/static_body_3d.cpp b/scene/3d/physics/static_body_3d.cpp
new file mode 100644
index 0000000000..30e796f92e
--- /dev/null
+++ b/scene/3d/physics/static_body_3d.cpp
@@ -0,0 +1,96 @@
+/**************************************************************************/
+/*  static_body_3d.cpp                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "static_body_3d.h"
+
+void StaticBody3D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
+	if (physics_material_override.is_valid()) {
+		physics_material_override->disconnect_changed(callable_mp(this, &StaticBody3D::_reload_physics_characteristics));
+	}
+
+	physics_material_override = p_physics_material_override;
+
+	if (physics_material_override.is_valid()) {
+		physics_material_override->connect_changed(callable_mp(this, &StaticBody3D::_reload_physics_characteristics));
+	}
+	_reload_physics_characteristics();
+}
+
+Ref<PhysicsMaterial> StaticBody3D::get_physics_material_override() const {
+	return physics_material_override;
+}
+
+void StaticBody3D::set_constant_linear_velocity(const Vector3 &p_vel) {
+	constant_linear_velocity = p_vel;
+
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, constant_linear_velocity);
+}
+
+void StaticBody3D::set_constant_angular_velocity(const Vector3 &p_vel) {
+	constant_angular_velocity = p_vel;
+
+	PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_ANGULAR_VELOCITY, constant_angular_velocity);
+}
+
+Vector3 StaticBody3D::get_constant_linear_velocity() const {
+	return constant_linear_velocity;
+}
+
+Vector3 StaticBody3D::get_constant_angular_velocity() const {
+	return constant_angular_velocity;
+}
+
+void StaticBody3D::_reload_physics_characteristics() {
+	if (physics_material_override.is_null()) {
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, 0);
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, 1);
+	} else {
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
+	}
+}
+
+void StaticBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_constant_linear_velocity", "vel"), &StaticBody3D::set_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("set_constant_angular_velocity", "vel"), &StaticBody3D::set_constant_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_linear_velocity"), &StaticBody3D::get_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_angular_velocity"), &StaticBody3D::get_constant_angular_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &StaticBody3D::set_physics_material_override);
+	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &StaticBody3D::get_physics_material_override);
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_linear_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_constant_linear_velocity", "get_constant_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_constant_angular_velocity", "get_constant_angular_velocity");
+}
+
+StaticBody3D::StaticBody3D(PhysicsServer3D::BodyMode p_mode) :
+		PhysicsBody3D(p_mode) {
+}
diff --git a/scene/3d/physics/static_body_3d.h b/scene/3d/physics/static_body_3d.h
new file mode 100644
index 0000000000..7d7f7a4acc
--- /dev/null
+++ b/scene/3d/physics/static_body_3d.h
@@ -0,0 +1,64 @@
+/**************************************************************************/
+/*  static_body_3d.h                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef STATIC_BODY_3D_H
+#define STATIC_BODY_3D_H
+
+#include "scene/3d/physics/physics_body_3d.h"
+
+class StaticBody3D : public PhysicsBody3D {
+	GDCLASS(StaticBody3D, PhysicsBody3D);
+
+private:
+	Vector3 constant_linear_velocity;
+	Vector3 constant_angular_velocity;
+
+	Ref<PhysicsMaterial> physics_material_override;
+
+protected:
+	static void _bind_methods();
+
+public:
+	void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);
+	Ref<PhysicsMaterial> get_physics_material_override() const;
+
+	void set_constant_linear_velocity(const Vector3 &p_vel);
+	void set_constant_angular_velocity(const Vector3 &p_vel);
+
+	Vector3 get_constant_linear_velocity() const;
+	Vector3 get_constant_angular_velocity() const;
+
+	StaticBody3D(PhysicsServer3D::BodyMode p_mode = PhysicsServer3D::BODY_MODE_STATIC);
+
+private:
+	void _reload_physics_characteristics();
+};
+
+#endif // STATIC_BODY_3D_H
diff --git a/scene/3d/physics/vehicle_body_3d.cpp b/scene/3d/physics/vehicle_body_3d.cpp
new file mode 100644
index 0000000000..c23032d3b9
--- /dev/null
+++ b/scene/3d/physics/vehicle_body_3d.cpp
@@ -0,0 +1,929 @@
+/**************************************************************************/
+/*  vehicle_body_3d.cpp                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "vehicle_body_3d.h"
+
+#define ROLLING_INFLUENCE_FIX
+
+class btVehicleJacobianEntry {
+public:
+	Vector3 m_linearJointAxis;
+	Vector3 m_aJ;
+	Vector3 m_bJ;
+	Vector3 m_0MinvJt;
+	Vector3 m_1MinvJt;
+	//Optimization: can be stored in the w/last component of one of the vectors
+	real_t m_Adiag = 0.0;
+
+	real_t getDiagonal() const { return m_Adiag; }
+
+	btVehicleJacobianEntry() {}
+	//constraint between two different rigidbodies
+	btVehicleJacobianEntry(
+			const Basis &world2A,
+			const Basis &world2B,
+			const Vector3 &rel_pos1,
+			const Vector3 &rel_pos2,
+			const Vector3 &jointAxis,
+			const Vector3 &inertiaInvA,
+			const real_t massInvA,
+			const Vector3 &inertiaInvB,
+			const real_t massInvB) :
+			m_linearJointAxis(jointAxis) {
+		m_aJ = world2A.xform(rel_pos1.cross(m_linearJointAxis));
+		m_bJ = world2B.xform(rel_pos2.cross(-m_linearJointAxis));
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ) + massInvB + m_1MinvJt.dot(m_bJ);
+
+		//btAssert(m_Adiag > real_t(0.0));
+	}
+
+	real_t getRelativeVelocity(const Vector3 &linvelA, const Vector3 &angvelA, const Vector3 &linvelB, const Vector3 &angvelB) {
+		Vector3 linrel = linvelA - linvelB;
+		Vector3 angvela = angvelA * m_aJ;
+		Vector3 angvelb = angvelB * m_bJ;
+		linrel *= m_linearJointAxis;
+		angvela += angvelb;
+		angvela += linrel;
+		real_t rel_vel2 = angvela[0] + angvela[1] + angvela[2];
+		return rel_vel2 + CMP_EPSILON;
+	}
+};
+
+void VehicleWheel3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			VehicleBody3D *cb = Object::cast_to<VehicleBody3D>(get_parent());
+			if (!cb) {
+				return;
+			}
+			body = cb;
+			local_xform = get_transform();
+			cb->wheels.push_back(this);
+
+			m_chassisConnectionPointCS = get_transform().origin;
+			m_wheelDirectionCS = -get_transform().basis.get_column(Vector3::AXIS_Y).normalized();
+			m_wheelAxleCS = get_transform().basis.get_column(Vector3::AXIS_X).normalized();
+		} break;
+
+		case NOTIFICATION_EXIT_TREE: {
+			VehicleBody3D *cb = Object::cast_to<VehicleBody3D>(get_parent());
+			if (!cb) {
+				return;
+			}
+			cb->wheels.erase(this);
+			body = nullptr;
+		} break;
+	}
+}
+
+PackedStringArray VehicleWheel3D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node::get_configuration_warnings();
+
+	if (!Object::cast_to<VehicleBody3D>(get_parent())) {
+		warnings.push_back(RTR("VehicleWheel3D serves to provide a wheel system to a VehicleBody3D. Please use it as a child of a VehicleBody3D."));
+	}
+
+	return warnings;
+}
+
+void VehicleWheel3D::_update(PhysicsDirectBodyState3D *s) {
+	if (m_raycastInfo.m_isInContact) {
+		real_t project = m_raycastInfo.m_contactNormalWS.dot(m_raycastInfo.m_wheelDirectionWS);
+		Vector3 chassis_velocity_at_contactPoint;
+		Vector3 relpos = m_raycastInfo.m_contactPointWS - s->get_transform().origin;
+
+		chassis_velocity_at_contactPoint = s->get_linear_velocity() +
+				(s->get_angular_velocity()).cross(relpos); // * mPos);
+
+		real_t projVel = m_raycastInfo.m_contactNormalWS.dot(chassis_velocity_at_contactPoint);
+		if (project >= real_t(-0.1)) {
+			m_suspensionRelativeVelocity = real_t(0.0);
+			m_clippedInvContactDotSuspension = real_t(1.0) / real_t(0.1);
+		} else {
+			real_t inv = real_t(-1.) / project;
+			m_suspensionRelativeVelocity = projVel * inv;
+			m_clippedInvContactDotSuspension = inv;
+		}
+	} else { // Not in contact : position wheel in a nice (rest length) position
+		m_raycastInfo.m_suspensionLength = m_suspensionRestLength;
+		m_suspensionRelativeVelocity = real_t(0.0);
+		m_raycastInfo.m_contactNormalWS = -m_raycastInfo.m_wheelDirectionWS;
+		m_clippedInvContactDotSuspension = real_t(1.0);
+	}
+}
+
+void VehicleWheel3D::set_radius(real_t p_radius) {
+	m_wheelRadius = p_radius;
+	update_gizmos();
+}
+
+real_t VehicleWheel3D::get_radius() const {
+	return m_wheelRadius;
+}
+
+void VehicleWheel3D::set_suspension_rest_length(real_t p_length) {
+	m_suspensionRestLength = p_length;
+	update_gizmos();
+}
+
+real_t VehicleWheel3D::get_suspension_rest_length() const {
+	return m_suspensionRestLength;
+}
+
+void VehicleWheel3D::set_suspension_travel(real_t p_length) {
+	m_maxSuspensionTravel = p_length;
+}
+
+real_t VehicleWheel3D::get_suspension_travel() const {
+	return m_maxSuspensionTravel;
+}
+
+void VehicleWheel3D::set_suspension_stiffness(real_t p_value) {
+	m_suspensionStiffness = p_value;
+}
+
+real_t VehicleWheel3D::get_suspension_stiffness() const {
+	return m_suspensionStiffness;
+}
+
+void VehicleWheel3D::set_suspension_max_force(real_t p_value) {
+	m_maxSuspensionForce = p_value;
+}
+
+real_t VehicleWheel3D::get_suspension_max_force() const {
+	return m_maxSuspensionForce;
+}
+
+void VehicleWheel3D::set_damping_compression(real_t p_value) {
+	m_wheelsDampingCompression = p_value;
+}
+
+real_t VehicleWheel3D::get_damping_compression() const {
+	return m_wheelsDampingCompression;
+}
+
+void VehicleWheel3D::set_damping_relaxation(real_t p_value) {
+	m_wheelsDampingRelaxation = p_value;
+}
+
+real_t VehicleWheel3D::get_damping_relaxation() const {
+	return m_wheelsDampingRelaxation;
+}
+
+void VehicleWheel3D::set_friction_slip(real_t p_value) {
+	m_frictionSlip = p_value;
+}
+
+real_t VehicleWheel3D::get_friction_slip() const {
+	return m_frictionSlip;
+}
+
+void VehicleWheel3D::set_roll_influence(real_t p_value) {
+	m_rollInfluence = p_value;
+}
+
+real_t VehicleWheel3D::get_roll_influence() const {
+	return m_rollInfluence;
+}
+
+bool VehicleWheel3D::is_in_contact() const {
+	return m_raycastInfo.m_isInContact;
+}
+
+Node3D *VehicleWheel3D::get_contact_body() const {
+	return m_raycastInfo.m_groundObject;
+}
+
+void VehicleWheel3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_radius", "length"), &VehicleWheel3D::set_radius);
+	ClassDB::bind_method(D_METHOD("get_radius"), &VehicleWheel3D::get_radius);
+
+	ClassDB::bind_method(D_METHOD("set_suspension_rest_length", "length"), &VehicleWheel3D::set_suspension_rest_length);
+	ClassDB::bind_method(D_METHOD("get_suspension_rest_length"), &VehicleWheel3D::get_suspension_rest_length);
+
+	ClassDB::bind_method(D_METHOD("set_suspension_travel", "length"), &VehicleWheel3D::set_suspension_travel);
+	ClassDB::bind_method(D_METHOD("get_suspension_travel"), &VehicleWheel3D::get_suspension_travel);
+
+	ClassDB::bind_method(D_METHOD("set_suspension_stiffness", "length"), &VehicleWheel3D::set_suspension_stiffness);
+	ClassDB::bind_method(D_METHOD("get_suspension_stiffness"), &VehicleWheel3D::get_suspension_stiffness);
+
+	ClassDB::bind_method(D_METHOD("set_suspension_max_force", "length"), &VehicleWheel3D::set_suspension_max_force);
+	ClassDB::bind_method(D_METHOD("get_suspension_max_force"), &VehicleWheel3D::get_suspension_max_force);
+
+	ClassDB::bind_method(D_METHOD("set_damping_compression", "length"), &VehicleWheel3D::set_damping_compression);
+	ClassDB::bind_method(D_METHOD("get_damping_compression"), &VehicleWheel3D::get_damping_compression);
+
+	ClassDB::bind_method(D_METHOD("set_damping_relaxation", "length"), &VehicleWheel3D::set_damping_relaxation);
+	ClassDB::bind_method(D_METHOD("get_damping_relaxation"), &VehicleWheel3D::get_damping_relaxation);
+
+	ClassDB::bind_method(D_METHOD("set_use_as_traction", "enable"), &VehicleWheel3D::set_use_as_traction);
+	ClassDB::bind_method(D_METHOD("is_used_as_traction"), &VehicleWheel3D::is_used_as_traction);
+
+	ClassDB::bind_method(D_METHOD("set_use_as_steering", "enable"), &VehicleWheel3D::set_use_as_steering);
+	ClassDB::bind_method(D_METHOD("is_used_as_steering"), &VehicleWheel3D::is_used_as_steering);
+
+	ClassDB::bind_method(D_METHOD("set_friction_slip", "length"), &VehicleWheel3D::set_friction_slip);
+	ClassDB::bind_method(D_METHOD("get_friction_slip"), &VehicleWheel3D::get_friction_slip);
+
+	ClassDB::bind_method(D_METHOD("is_in_contact"), &VehicleWheel3D::is_in_contact);
+	ClassDB::bind_method(D_METHOD("get_contact_body"), &VehicleWheel3D::get_contact_body);
+
+	ClassDB::bind_method(D_METHOD("set_roll_influence", "roll_influence"), &VehicleWheel3D::set_roll_influence);
+	ClassDB::bind_method(D_METHOD("get_roll_influence"), &VehicleWheel3D::get_roll_influence);
+
+	ClassDB::bind_method(D_METHOD("get_skidinfo"), &VehicleWheel3D::get_skidinfo);
+
+	ClassDB::bind_method(D_METHOD("get_rpm"), &VehicleWheel3D::get_rpm);
+
+	ClassDB::bind_method(D_METHOD("set_engine_force", "engine_force"), &VehicleWheel3D::set_engine_force);
+	ClassDB::bind_method(D_METHOD("get_engine_force"), &VehicleWheel3D::get_engine_force);
+
+	ClassDB::bind_method(D_METHOD("set_brake", "brake"), &VehicleWheel3D::set_brake);
+	ClassDB::bind_method(D_METHOD("get_brake"), &VehicleWheel3D::get_brake);
+
+	ClassDB::bind_method(D_METHOD("set_steering", "steering"), &VehicleWheel3D::set_steering);
+	ClassDB::bind_method(D_METHOD("get_steering"), &VehicleWheel3D::get_steering);
+
+	ADD_GROUP("Per-Wheel Motion", "");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "engine_force", PROPERTY_HINT_RANGE, U"-1024,1024,0.01,or_less,or_greater,suffix:kg\u22C5m/s\u00B2 (N)"), "set_engine_force", "get_engine_force");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "brake", PROPERTY_HINT_RANGE, U"-128,128,0.01,or_less,or_greater,suffix:kg\u22C5m/s\u00B2 (N)"), "set_brake", "get_brake");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "steering", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_steering", "get_steering");
+	ADD_GROUP("VehicleBody3D Motion", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_as_traction"), "set_use_as_traction", "is_used_as_traction");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_as_steering"), "set_use_as_steering", "is_used_as_steering");
+	ADD_GROUP("Wheel", "wheel_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wheel_roll_influence"), "set_roll_influence", "get_roll_influence");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wheel_radius", PROPERTY_HINT_NONE, "suffix:m"), "set_radius", "get_radius");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wheel_rest_length", PROPERTY_HINT_NONE, "suffix:m"), "set_suspension_rest_length", "get_suspension_rest_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "wheel_friction_slip"), "set_friction_slip", "get_friction_slip");
+	ADD_GROUP("Suspension", "suspension_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "suspension_travel", PROPERTY_HINT_NONE, "suffix:m"), "set_suspension_travel", "get_suspension_travel");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "suspension_stiffness"), "set_suspension_stiffness", "get_suspension_stiffness");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "suspension_max_force", PROPERTY_HINT_NONE, U"suffix:kg\u22C5m/s\u00B2 (N)"), "set_suspension_max_force", "get_suspension_max_force");
+	ADD_GROUP("Damping", "damping_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping_compression"), "set_damping_compression", "get_damping_compression");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping_relaxation"), "set_damping_relaxation", "get_damping_relaxation");
+}
+
+void VehicleWheel3D::set_engine_force(real_t p_engine_force) {
+	m_engineForce = p_engine_force;
+}
+
+real_t VehicleWheel3D::get_engine_force() const {
+	return m_engineForce;
+}
+
+void VehicleWheel3D::set_brake(real_t p_brake) {
+	m_brake = p_brake;
+}
+
+real_t VehicleWheel3D::get_brake() const {
+	return m_brake;
+}
+
+void VehicleWheel3D::set_steering(real_t p_steering) {
+	m_steering = p_steering;
+}
+
+real_t VehicleWheel3D::get_steering() const {
+	return m_steering;
+}
+
+void VehicleWheel3D::set_use_as_traction(bool p_enable) {
+	engine_traction = p_enable;
+}
+
+bool VehicleWheel3D::is_used_as_traction() const {
+	return engine_traction;
+}
+
+void VehicleWheel3D::set_use_as_steering(bool p_enabled) {
+	steers = p_enabled;
+}
+
+bool VehicleWheel3D::is_used_as_steering() const {
+	return steers;
+}
+
+real_t VehicleWheel3D::get_skidinfo() const {
+	return m_skidInfo;
+}
+
+real_t VehicleWheel3D::get_rpm() const {
+	return m_rpm;
+}
+
+VehicleWheel3D::VehicleWheel3D() {
+}
+
+void VehicleBody3D::_update_wheel_transform(VehicleWheel3D &wheel, PhysicsDirectBodyState3D *s) {
+	wheel.m_raycastInfo.m_isInContact = false;
+
+	Transform3D chassisTrans = s->get_transform();
+	/*
+	if (interpolatedTransform && (getRigidBody()->getMotionState())) {
+		getRigidBody()->getMotionState()->getWorldTransform(chassisTrans);
+	}
+	*/
+
+	wheel.m_raycastInfo.m_hardPointWS = chassisTrans.xform(wheel.m_chassisConnectionPointCS);
+	//wheel.m_raycastInfo.m_hardPointWS+=s->get_linear_velocity()*s->get_step();
+	wheel.m_raycastInfo.m_wheelDirectionWS = chassisTrans.get_basis().xform(wheel.m_wheelDirectionCS).normalized();
+	wheel.m_raycastInfo.m_wheelAxleWS = chassisTrans.get_basis().xform(wheel.m_wheelAxleCS).normalized();
+}
+
+void VehicleBody3D::_update_wheel(int p_idx, PhysicsDirectBodyState3D *s) {
+	VehicleWheel3D &wheel = *wheels[p_idx];
+	_update_wheel_transform(wheel, s);
+
+	Vector3 up = -wheel.m_raycastInfo.m_wheelDirectionWS;
+	const Vector3 &right = wheel.m_raycastInfo.m_wheelAxleWS;
+	Vector3 fwd = up.cross(right);
+	fwd = fwd.normalized();
+
+	Basis steeringMat(up, wheel.m_steering);
+
+	Basis rotatingMat(right, wheel.m_rotation);
+
+	Basis basis2(
+			right[0], up[0], fwd[0],
+			right[1], up[1], fwd[1],
+			right[2], up[2], fwd[2]);
+
+	wheel.m_worldTransform.set_basis(steeringMat * rotatingMat * basis2);
+	//wheel.m_worldTransform.set_basis(basis2 * (steeringMat * rotatingMat));
+	wheel.m_worldTransform.set_origin(
+			wheel.m_raycastInfo.m_hardPointWS + wheel.m_raycastInfo.m_wheelDirectionWS * wheel.m_raycastInfo.m_suspensionLength);
+}
+
+real_t VehicleBody3D::_ray_cast(int p_idx, PhysicsDirectBodyState3D *s) {
+	VehicleWheel3D &wheel = *wheels[p_idx];
+
+	_update_wheel_transform(wheel, s);
+
+	real_t depth = -1;
+
+	real_t raylen = wheel.m_suspensionRestLength + wheel.m_wheelRadius;
+
+	Vector3 rayvector = wheel.m_raycastInfo.m_wheelDirectionWS * (raylen);
+	Vector3 source = wheel.m_raycastInfo.m_hardPointWS;
+	wheel.m_raycastInfo.m_contactPointWS = source + rayvector;
+	const Vector3 &target = wheel.m_raycastInfo.m_contactPointWS;
+	source -= wheel.m_wheelRadius * wheel.m_raycastInfo.m_wheelDirectionWS;
+
+	real_t param = real_t(0.);
+
+	PhysicsDirectSpaceState3D::RayResult rr;
+
+	PhysicsDirectSpaceState3D *ss = s->get_space_state();
+
+	PhysicsDirectSpaceState3D::RayParameters ray_params;
+	ray_params.from = source;
+	ray_params.to = target;
+	ray_params.exclude = exclude;
+	ray_params.collision_mask = get_collision_mask();
+
+	wheel.m_raycastInfo.m_groundObject = nullptr;
+	bool col = ss->intersect_ray(ray_params, rr);
+
+	if (col) {
+		param = source.distance_to(rr.position) / source.distance_to(target);
+		depth = raylen * param;
+		wheel.m_raycastInfo.m_contactNormalWS = rr.normal;
+
+		wheel.m_raycastInfo.m_isInContact = true;
+		if (rr.collider) {
+			wheel.m_raycastInfo.m_groundObject = Object::cast_to<PhysicsBody3D>(rr.collider);
+		}
+
+		real_t hitDistance = param * raylen;
+		wheel.m_raycastInfo.m_suspensionLength = hitDistance - wheel.m_wheelRadius;
+		//clamp on max suspension travel
+
+		real_t minSuspensionLength = wheel.m_suspensionRestLength - wheel.m_maxSuspensionTravel;
+		real_t maxSuspensionLength = wheel.m_suspensionRestLength + wheel.m_maxSuspensionTravel;
+		if (wheel.m_raycastInfo.m_suspensionLength < minSuspensionLength) {
+			wheel.m_raycastInfo.m_suspensionLength = minSuspensionLength;
+		}
+		if (wheel.m_raycastInfo.m_suspensionLength > maxSuspensionLength) {
+			wheel.m_raycastInfo.m_suspensionLength = maxSuspensionLength;
+		}
+
+		wheel.m_raycastInfo.m_contactPointWS = rr.position;
+
+		real_t denominator = wheel.m_raycastInfo.m_contactNormalWS.dot(wheel.m_raycastInfo.m_wheelDirectionWS);
+
+		Vector3 chassis_velocity_at_contactPoint;
+		//Vector3 relpos = wheel.m_raycastInfo.m_contactPointWS-getRigidBody()->getCenterOfMassPosition();
+
+		//chassis_velocity_at_contactPoint = getRigidBody()->getVelocityInLocalPoint(relpos);
+
+		chassis_velocity_at_contactPoint = s->get_linear_velocity() +
+				(s->get_angular_velocity()).cross(wheel.m_raycastInfo.m_contactPointWS - s->get_transform().origin); // * mPos);
+
+		real_t projVel = wheel.m_raycastInfo.m_contactNormalWS.dot(chassis_velocity_at_contactPoint);
+
+		if (denominator >= real_t(-0.1)) {
+			wheel.m_suspensionRelativeVelocity = real_t(0.0);
+			wheel.m_clippedInvContactDotSuspension = real_t(1.0) / real_t(0.1);
+		} else {
+			real_t inv = real_t(-1.) / denominator;
+			wheel.m_suspensionRelativeVelocity = projVel * inv;
+			wheel.m_clippedInvContactDotSuspension = inv;
+		}
+
+	} else {
+		wheel.m_raycastInfo.m_isInContact = false;
+		//put wheel info as in rest position
+		wheel.m_raycastInfo.m_suspensionLength = wheel.m_suspensionRestLength;
+		wheel.m_suspensionRelativeVelocity = real_t(0.0);
+		wheel.m_raycastInfo.m_contactNormalWS = -wheel.m_raycastInfo.m_wheelDirectionWS;
+		wheel.m_clippedInvContactDotSuspension = real_t(1.0);
+	}
+
+	return depth;
+}
+
+void VehicleBody3D::_update_suspension(PhysicsDirectBodyState3D *s) {
+	real_t chassisMass = get_mass();
+
+	for (int w_it = 0; w_it < wheels.size(); w_it++) {
+		VehicleWheel3D &wheel_info = *wheels[w_it];
+
+		if (wheel_info.m_raycastInfo.m_isInContact) {
+			real_t force;
+			//Spring
+			{
+				real_t susp_length = wheel_info.m_suspensionRestLength;
+				real_t current_length = wheel_info.m_raycastInfo.m_suspensionLength;
+
+				real_t length_diff = (susp_length - current_length);
+
+				force = wheel_info.m_suspensionStiffness * length_diff * wheel_info.m_clippedInvContactDotSuspension;
+			}
+
+			// Damper
+			{
+				real_t projected_rel_vel = wheel_info.m_suspensionRelativeVelocity;
+				{
+					real_t susp_damping;
+					if (projected_rel_vel < real_t(0.0)) {
+						susp_damping = wheel_info.m_wheelsDampingCompression;
+					} else {
+						susp_damping = wheel_info.m_wheelsDampingRelaxation;
+					}
+					force -= susp_damping * projected_rel_vel;
+				}
+			}
+
+			// RESULT
+			wheel_info.m_wheelsSuspensionForce = force * chassisMass;
+			if (wheel_info.m_wheelsSuspensionForce < real_t(0.)) {
+				wheel_info.m_wheelsSuspensionForce = real_t(0.);
+			}
+		} else {
+			wheel_info.m_wheelsSuspensionForce = real_t(0.0);
+		}
+	}
+}
+
+//bilateral constraint between two dynamic objects
+void VehicleBody3D::_resolve_single_bilateral(PhysicsDirectBodyState3D *s, const Vector3 &pos1,
+		PhysicsBody3D *body2, const Vector3 &pos2, const Vector3 &normal, real_t &impulse, const real_t p_rollInfluence) {
+	real_t normalLenSqr = normal.length_squared();
+	//ERR_FAIL_COND( normalLenSqr < real_t(1.1));
+
+	if (normalLenSqr > real_t(1.1)) {
+		impulse = real_t(0.);
+		return;
+	}
+
+	Vector3 rel_pos1 = pos1 - s->get_transform().origin;
+	Vector3 rel_pos2;
+	if (body2) {
+		rel_pos2 = pos2 - body2->get_global_transform().origin;
+	}
+	//this jacobian entry could be re-used for all iterations
+
+	Vector3 vel1 = s->get_linear_velocity() + (s->get_angular_velocity()).cross(rel_pos1); // * mPos);
+	Vector3 vel2;
+
+	if (body2) {
+		vel2 = body2->get_linear_velocity() + body2->get_angular_velocity().cross(rel_pos2);
+	}
+
+	Vector3 vel = vel1 - vel2;
+
+	Basis b2trans;
+	real_t b2invmass = 0;
+	Vector3 b2lv;
+	Vector3 b2av;
+	Vector3 b2invinertia; //todo
+
+	if (body2) {
+		b2trans = body2->get_global_transform().basis.transposed();
+		b2invmass = body2->get_inverse_mass();
+		b2lv = body2->get_linear_velocity();
+		b2av = body2->get_angular_velocity();
+	}
+
+	btVehicleJacobianEntry jac(s->get_transform().basis.transposed(),
+			b2trans,
+			rel_pos1,
+			rel_pos2,
+			normal,
+			s->get_inverse_inertia_tensor().get_main_diagonal(),
+			1.0 / get_mass(),
+			b2invinertia,
+			b2invmass);
+
+	// FIXME: rel_vel assignment here is overwritten by the following assignment.
+	// What seems to be intended in the next assignment is: rel_vel = normal.dot(rel_vel);
+	// Investigate why.
+	real_t rel_vel = jac.getRelativeVelocity(
+			s->get_linear_velocity(),
+			s->get_transform().basis.transposed().xform(s->get_angular_velocity()),
+			b2lv,
+			b2trans.xform(b2av));
+
+	rel_vel = normal.dot(vel);
+
+	// !BAS! We had this set to 0.4, in bullet its 0.2
+	real_t contactDamping = real_t(0.2);
+
+	if (p_rollInfluence > 0.0) {
+		// !BAS! But seeing we apply this frame by frame, makes more sense to me to make this time based
+		// keeping in mind our anti roll factor if it is set
+		contactDamping = MIN(contactDamping, s->get_step() / p_rollInfluence);
+	}
+
+#define ONLY_USE_LINEAR_MASS
+#ifdef ONLY_USE_LINEAR_MASS
+	real_t massTerm = real_t(1.) / ((1.0 / get_mass()) + b2invmass);
+	impulse = -contactDamping * rel_vel * massTerm;
+#else
+	real_t velocityImpulse = -contactDamping * rel_vel * jacDiagABInv;
+	impulse = velocityImpulse;
+#endif
+}
+
+VehicleBody3D::btVehicleWheelContactPoint::btVehicleWheelContactPoint(PhysicsDirectBodyState3D *s, PhysicsBody3D *body1, const Vector3 &frictionPosWorld, const Vector3 &frictionDirectionWorld, real_t maxImpulse) :
+		m_s(s),
+		m_body1(body1),
+		m_frictionPositionWorld(frictionPosWorld),
+		m_frictionDirectionWorld(frictionDirectionWorld),
+		m_maxImpulse(maxImpulse) {
+	real_t denom0 = 0;
+	real_t denom1 = 0;
+
+	{
+		Vector3 r0 = frictionPosWorld - s->get_transform().origin;
+		Vector3 c0 = (r0).cross(frictionDirectionWorld);
+		Vector3 vec = s->get_inverse_inertia_tensor().xform_inv(c0).cross(r0);
+		denom0 = s->get_inverse_mass() + frictionDirectionWorld.dot(vec);
+	}
+
+	/* TODO: Why is this code unused?
+	if (body1) {
+		Vector3 r0 = frictionPosWorld - body1->get_global_transform().origin;
+		Vector3 c0 = (r0).cross(frictionDirectionWorld);
+		Vector3 vec = s->get_inverse_inertia_tensor().xform_inv(c0).cross(r0);
+		//denom1= body1->get_inverse_mass() + frictionDirectionWorld.dot(vec);
+
+	}
+	*/
+
+	real_t relaxation = 1.f;
+	m_jacDiagABInv = relaxation / (denom0 + denom1);
+}
+
+real_t VehicleBody3D::_calc_rolling_friction(btVehicleWheelContactPoint &contactPoint) {
+	real_t j1 = 0.f;
+
+	const Vector3 &contactPosWorld = contactPoint.m_frictionPositionWorld;
+
+	Vector3 rel_pos1 = contactPosWorld - contactPoint.m_s->get_transform().origin;
+	Vector3 rel_pos2;
+	if (contactPoint.m_body1) {
+		rel_pos2 = contactPosWorld - contactPoint.m_body1->get_global_transform().origin;
+	}
+
+	real_t maxImpulse = contactPoint.m_maxImpulse;
+
+	Vector3 vel1 = contactPoint.m_s->get_linear_velocity() + (contactPoint.m_s->get_angular_velocity()).cross(rel_pos1); // * mPos);
+
+	Vector3 vel2;
+	if (contactPoint.m_body1) {
+		vel2 = contactPoint.m_body1->get_linear_velocity() + contactPoint.m_body1->get_angular_velocity().cross(rel_pos2);
+	}
+
+	Vector3 vel = vel1 - vel2;
+
+	real_t vrel = contactPoint.m_frictionDirectionWorld.dot(vel);
+
+	// calculate j that moves us to zero relative velocity
+	j1 = -vrel * contactPoint.m_jacDiagABInv;
+
+	return CLAMP(j1, -maxImpulse, maxImpulse);
+}
+
+static const real_t sideFrictionStiffness2 = real_t(1.0);
+void VehicleBody3D::_update_friction(PhysicsDirectBodyState3D *s) {
+	//calculate the impulse, so that the wheels don't move sidewards
+	int numWheel = wheels.size();
+	if (!numWheel) {
+		return;
+	}
+
+	m_forwardWS.resize(numWheel);
+	m_axle.resize(numWheel);
+	m_forwardImpulse.resize(numWheel);
+	m_sideImpulse.resize(numWheel);
+
+	//collapse all those loops into one!
+	for (int i = 0; i < wheels.size(); i++) {
+		m_sideImpulse.write[i] = real_t(0.);
+		m_forwardImpulse.write[i] = real_t(0.);
+	}
+
+	{
+		for (int i = 0; i < wheels.size(); i++) {
+			VehicleWheel3D &wheelInfo = *wheels[i];
+
+			if (wheelInfo.m_raycastInfo.m_isInContact) {
+				//const btTransform& wheelTrans = getWheelTransformWS( i );
+
+				Basis wheelBasis0 = wheelInfo.m_worldTransform.basis; //get_global_transform().basis;
+
+				m_axle.write[i] = wheelBasis0.get_column(Vector3::AXIS_X);
+				//m_axle[i] = wheelInfo.m_raycastInfo.m_wheelAxleWS;
+
+				const Vector3 &surfNormalWS = wheelInfo.m_raycastInfo.m_contactNormalWS;
+				real_t proj = m_axle[i].dot(surfNormalWS);
+				m_axle.write[i] -= surfNormalWS * proj;
+				m_axle.write[i] = m_axle[i].normalized();
+
+				m_forwardWS.write[i] = surfNormalWS.cross(m_axle[i]);
+				m_forwardWS.write[i].normalize();
+
+				_resolve_single_bilateral(s, wheelInfo.m_raycastInfo.m_contactPointWS,
+						wheelInfo.m_raycastInfo.m_groundObject, wheelInfo.m_raycastInfo.m_contactPointWS,
+						m_axle[i], m_sideImpulse.write[i], wheelInfo.m_rollInfluence);
+
+				m_sideImpulse.write[i] *= sideFrictionStiffness2;
+			}
+		}
+	}
+
+	real_t sideFactor = real_t(1.);
+	real_t fwdFactor = 0.5;
+
+	bool sliding = false;
+	{
+		for (int wheel = 0; wheel < wheels.size(); wheel++) {
+			VehicleWheel3D &wheelInfo = *wheels[wheel];
+
+			//class btRigidBody* groundObject = (class btRigidBody*) wheelInfo.m_raycastInfo.m_groundObject;
+
+			real_t rollingFriction = 0.f;
+
+			if (wheelInfo.m_raycastInfo.m_isInContact) {
+				if (wheelInfo.m_engineForce != 0.f) {
+					rollingFriction = -wheelInfo.m_engineForce * s->get_step();
+				} else {
+					real_t defaultRollingFrictionImpulse = 0.f;
+					real_t maxImpulse = wheelInfo.m_brake ? wheelInfo.m_brake : defaultRollingFrictionImpulse;
+					btVehicleWheelContactPoint contactPt(s, wheelInfo.m_raycastInfo.m_groundObject, wheelInfo.m_raycastInfo.m_contactPointWS, m_forwardWS[wheel], maxImpulse);
+					rollingFriction = _calc_rolling_friction(contactPt);
+				}
+			}
+
+			//switch between active rolling (throttle), braking and non-active rolling friction (no throttle/break)
+
+			m_forwardImpulse.write[wheel] = real_t(0.);
+			wheelInfo.m_skidInfo = real_t(1.);
+
+			if (wheelInfo.m_raycastInfo.m_isInContact) {
+				wheelInfo.m_skidInfo = real_t(1.);
+
+				real_t maximp = wheelInfo.m_wheelsSuspensionForce * s->get_step() * wheelInfo.m_frictionSlip;
+				real_t maximpSide = maximp;
+
+				real_t maximpSquared = maximp * maximpSide;
+
+				m_forwardImpulse.write[wheel] = rollingFriction; //wheelInfo.m_engineForce* timeStep;
+
+				real_t x = (m_forwardImpulse[wheel]) * fwdFactor;
+				real_t y = (m_sideImpulse[wheel]) * sideFactor;
+
+				real_t impulseSquared = (x * x + y * y);
+
+				if (impulseSquared > maximpSquared) {
+					sliding = true;
+
+					real_t factor = maximp / Math::sqrt(impulseSquared);
+
+					wheelInfo.m_skidInfo *= factor;
+				}
+			}
+		}
+	}
+
+	if (sliding) {
+		for (int wheel = 0; wheel < wheels.size(); wheel++) {
+			if (m_sideImpulse[wheel] != real_t(0.)) {
+				if (wheels[wheel]->m_skidInfo < real_t(1.)) {
+					m_forwardImpulse.write[wheel] *= wheels[wheel]->m_skidInfo;
+					m_sideImpulse.write[wheel] *= wheels[wheel]->m_skidInfo;
+				}
+			}
+		}
+	}
+
+	// apply the impulses
+	{
+		for (int wheel = 0; wheel < wheels.size(); wheel++) {
+			VehicleWheel3D &wheelInfo = *wheels[wheel];
+
+			Vector3 rel_pos = wheelInfo.m_raycastInfo.m_contactPointWS -
+					s->get_transform().origin;
+
+			if (m_forwardImpulse[wheel] != real_t(0.)) {
+				s->apply_impulse(m_forwardWS[wheel] * (m_forwardImpulse[wheel]), rel_pos);
+			}
+			if (m_sideImpulse[wheel] != real_t(0.)) {
+				PhysicsBody3D *groundObject = wheelInfo.m_raycastInfo.m_groundObject;
+
+				Vector3 rel_pos2;
+				if (groundObject) {
+					rel_pos2 = wheelInfo.m_raycastInfo.m_contactPointWS - groundObject->get_global_transform().origin;
+				}
+
+				Vector3 sideImp = m_axle[wheel] * m_sideImpulse[wheel];
+
+#if defined ROLLING_INFLUENCE_FIX // fix. It only worked if car's up was along Y - VT.
+				Vector3 vChassisWorldUp = s->get_transform().basis.transposed()[1]; //getRigidBody()->getCenterOfMassTransform3D().getBasis().getColumn(m_indexUpAxis);
+				rel_pos -= vChassisWorldUp * (vChassisWorldUp.dot(rel_pos) * (1.f - wheelInfo.m_rollInfluence));
+#else
+				rel_pos[1] *= wheelInfo.m_rollInfluence; //?
+#endif
+				s->apply_impulse(sideImp, rel_pos);
+
+				//apply friction impulse on the ground
+				//todo
+				//groundObject->applyImpulse(-sideImp,rel_pos2);
+			}
+		}
+	}
+}
+
+void VehicleBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
+	RigidBody3D::_body_state_changed(p_state);
+
+	real_t step = p_state->get_step();
+
+	for (int i = 0; i < wheels.size(); i++) {
+		_update_wheel(i, p_state);
+	}
+
+	for (int i = 0; i < wheels.size(); i++) {
+		_ray_cast(i, p_state);
+		wheels[i]->set_transform(p_state->get_transform().inverse() * wheels[i]->m_worldTransform);
+	}
+
+	_update_suspension(p_state);
+
+	for (int i = 0; i < wheels.size(); i++) {
+		//apply suspension force
+		VehicleWheel3D &wheel = *wheels[i];
+
+		real_t suspensionForce = wheel.m_wheelsSuspensionForce;
+
+		if (suspensionForce > wheel.m_maxSuspensionForce) {
+			suspensionForce = wheel.m_maxSuspensionForce;
+		}
+		Vector3 impulse = wheel.m_raycastInfo.m_contactNormalWS * suspensionForce * step;
+		Vector3 relative_position = wheel.m_raycastInfo.m_contactPointWS - p_state->get_transform().origin;
+
+		p_state->apply_impulse(impulse, relative_position);
+	}
+
+	_update_friction(p_state);
+
+	for (int i = 0; i < wheels.size(); i++) {
+		VehicleWheel3D &wheel = *wheels[i];
+		Vector3 relpos = wheel.m_raycastInfo.m_hardPointWS - p_state->get_transform().origin;
+		Vector3 vel = p_state->get_linear_velocity() + (p_state->get_angular_velocity()).cross(relpos); // * mPos);
+
+		if (wheel.m_raycastInfo.m_isInContact) {
+			const Transform3D &chassisWorldTransform = p_state->get_transform();
+
+			Vector3 fwd(
+					chassisWorldTransform.basis[0][Vector3::AXIS_Z],
+					chassisWorldTransform.basis[1][Vector3::AXIS_Z],
+					chassisWorldTransform.basis[2][Vector3::AXIS_Z]);
+
+			real_t proj = fwd.dot(wheel.m_raycastInfo.m_contactNormalWS);
+			fwd -= wheel.m_raycastInfo.m_contactNormalWS * proj;
+
+			real_t proj2 = fwd.dot(vel);
+
+			wheel.m_deltaRotation = (proj2 * step) / (wheel.m_wheelRadius);
+		}
+
+		wheel.m_rotation += wheel.m_deltaRotation;
+		wheel.m_rpm = ((wheel.m_deltaRotation / step) * 60) / Math_TAU;
+
+		wheel.m_deltaRotation *= real_t(0.99); //damping of rotation when not in contact
+	}
+}
+
+void VehicleBody3D::set_engine_force(real_t p_engine_force) {
+	engine_force = p_engine_force;
+	for (int i = 0; i < wheels.size(); i++) {
+		VehicleWheel3D &wheelInfo = *wheels[i];
+		if (wheelInfo.engine_traction) {
+			wheelInfo.m_engineForce = p_engine_force;
+		}
+	}
+}
+
+real_t VehicleBody3D::get_engine_force() const {
+	return engine_force;
+}
+
+void VehicleBody3D::set_brake(real_t p_brake) {
+	brake = p_brake;
+	for (int i = 0; i < wheels.size(); i++) {
+		VehicleWheel3D &wheelInfo = *wheels[i];
+		wheelInfo.m_brake = p_brake;
+	}
+}
+
+real_t VehicleBody3D::get_brake() const {
+	return brake;
+}
+
+void VehicleBody3D::set_steering(real_t p_steering) {
+	m_steeringValue = p_steering;
+	for (int i = 0; i < wheels.size(); i++) {
+		VehicleWheel3D &wheelInfo = *wheels[i];
+		if (wheelInfo.steers) {
+			wheelInfo.m_steering = p_steering;
+		}
+	}
+}
+
+real_t VehicleBody3D::get_steering() const {
+	return m_steeringValue;
+}
+
+void VehicleBody3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_engine_force", "engine_force"), &VehicleBody3D::set_engine_force);
+	ClassDB::bind_method(D_METHOD("get_engine_force"), &VehicleBody3D::get_engine_force);
+
+	ClassDB::bind_method(D_METHOD("set_brake", "brake"), &VehicleBody3D::set_brake);
+	ClassDB::bind_method(D_METHOD("get_brake"), &VehicleBody3D::get_brake);
+
+	ClassDB::bind_method(D_METHOD("set_steering", "steering"), &VehicleBody3D::set_steering);
+	ClassDB::bind_method(D_METHOD("get_steering"), &VehicleBody3D::get_steering);
+
+	ADD_GROUP("Motion", "");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "engine_force", PROPERTY_HINT_RANGE, U"-1024,1024,0.01,or_less,or_greater,suffix:kg\u22C5m/s\u00B2 (N)"), "set_engine_force", "get_engine_force");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "brake", PROPERTY_HINT_RANGE, U"-128,128,0.01,or_less,or_greater,suffix:kg\u22C5m/s\u00B2 (N)"), "set_brake", "get_brake");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "steering", PROPERTY_HINT_RANGE, "-180,180,0.01,radians_as_degrees"), "set_steering", "get_steering");
+}
+
+VehicleBody3D::VehicleBody3D() {
+	exclude.insert(get_rid());
+	set_mass(40);
+}
diff --git a/scene/3d/physics/vehicle_body_3d.h b/scene/3d/physics/vehicle_body_3d.h
new file mode 100644
index 0000000000..def9984440
--- /dev/null
+++ b/scene/3d/physics/vehicle_body_3d.h
@@ -0,0 +1,214 @@
+/**************************************************************************/
+/*  vehicle_body_3d.h                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef VEHICLE_BODY_3D_H
+#define VEHICLE_BODY_3D_H
+
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/rigid_body_3d.h"
+
+class VehicleBody3D;
+
+class VehicleWheel3D : public Node3D {
+	GDCLASS(VehicleWheel3D, Node3D);
+
+	friend class VehicleBody3D;
+
+	Transform3D m_worldTransform;
+	Transform3D local_xform;
+	bool engine_traction = false;
+	bool steers = false;
+
+	Vector3 m_chassisConnectionPointCS; //const
+	Vector3 m_wheelDirectionCS; //const
+	Vector3 m_wheelAxleCS; // const or modified by steering
+
+	real_t m_suspensionRestLength = 0.15;
+	real_t m_maxSuspensionTravel = 0.2;
+	real_t m_wheelRadius = 0.5;
+
+	real_t m_suspensionStiffness = 5.88;
+	real_t m_wheelsDampingCompression = 0.83;
+	real_t m_wheelsDampingRelaxation = 0.88;
+	real_t m_frictionSlip = 10.5;
+	real_t m_maxSuspensionForce = 6000.0;
+	bool m_bIsFrontWheel = false;
+
+	VehicleBody3D *body = nullptr;
+
+	//btVector3	m_wheelAxleCS; // const or modified by steering ?
+
+	real_t m_steering = 0.0;
+	real_t m_rotation = 0.0;
+	real_t m_deltaRotation = 0.0;
+	real_t m_rpm = 0.0;
+	real_t m_rollInfluence = 0.1;
+	real_t m_engineForce = 0.0;
+	real_t m_brake = 0.0;
+
+	real_t m_clippedInvContactDotSuspension = 1.0;
+	real_t m_suspensionRelativeVelocity = 0.0;
+	//calculated by suspension
+	real_t m_wheelsSuspensionForce = 0.0;
+	real_t m_skidInfo = 0.0;
+
+	struct RaycastInfo {
+		//set by raycaster
+		Vector3 m_contactNormalWS; //contactnormal
+		Vector3 m_contactPointWS; //raycast hitpoint
+		real_t m_suspensionLength = 0.0;
+		Vector3 m_hardPointWS; //raycast starting point
+		Vector3 m_wheelDirectionWS; //direction in worldspace
+		Vector3 m_wheelAxleWS; // axle in worldspace
+		bool m_isInContact = false;
+		PhysicsBody3D *m_groundObject = nullptr; //could be general void* ptr
+	} m_raycastInfo;
+
+	void _update(PhysicsDirectBodyState3D *s);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void set_radius(real_t p_radius);
+	real_t get_radius() const;
+
+	void set_suspension_rest_length(real_t p_length);
+	real_t get_suspension_rest_length() const;
+
+	void set_suspension_travel(real_t p_length);
+	real_t get_suspension_travel() const;
+
+	void set_suspension_stiffness(real_t p_value);
+	real_t get_suspension_stiffness() const;
+
+	void set_suspension_max_force(real_t p_value);
+	real_t get_suspension_max_force() const;
+
+	void set_damping_compression(real_t p_value);
+	real_t get_damping_compression() const;
+
+	void set_damping_relaxation(real_t p_value);
+	real_t get_damping_relaxation() const;
+
+	void set_friction_slip(real_t p_value);
+	real_t get_friction_slip() const;
+
+	void set_use_as_traction(bool p_enable);
+	bool is_used_as_traction() const;
+
+	void set_use_as_steering(bool p_enabled);
+	bool is_used_as_steering() const;
+
+	bool is_in_contact() const;
+
+	Node3D *get_contact_body() const;
+
+	void set_roll_influence(real_t p_value);
+	real_t get_roll_influence() const;
+
+	real_t get_skidinfo() const;
+
+	real_t get_rpm() const;
+
+	void set_engine_force(real_t p_engine_force);
+	real_t get_engine_force() const;
+
+	void set_brake(real_t p_brake);
+	real_t get_brake() const;
+
+	void set_steering(real_t p_steering);
+	real_t get_steering() const;
+
+	PackedStringArray get_configuration_warnings() const override;
+
+	VehicleWheel3D();
+};
+
+class VehicleBody3D : public RigidBody3D {
+	GDCLASS(VehicleBody3D, RigidBody3D);
+
+	real_t engine_force = 0.0;
+	real_t brake = 0.0;
+
+	real_t m_pitchControl = 0.0;
+	real_t m_steeringValue = 0.0;
+	real_t m_currentVehicleSpeedKmHour = 0.0;
+
+	HashSet<RID> exclude;
+
+	Vector<Vector3> m_forwardWS;
+	Vector<Vector3> m_axle;
+	Vector<real_t> m_forwardImpulse;
+	Vector<real_t> m_sideImpulse;
+
+	struct btVehicleWheelContactPoint {
+		PhysicsDirectBodyState3D *m_s = nullptr;
+		PhysicsBody3D *m_body1 = nullptr;
+		Vector3 m_frictionPositionWorld;
+		Vector3 m_frictionDirectionWorld;
+		real_t m_jacDiagABInv = 0.0;
+		real_t m_maxImpulse = 0.0;
+
+		btVehicleWheelContactPoint(PhysicsDirectBodyState3D *s, PhysicsBody3D *body1, const Vector3 &frictionPosWorld, const Vector3 &frictionDirectionWorld, real_t maxImpulse);
+	};
+
+	void _resolve_single_bilateral(PhysicsDirectBodyState3D *s, const Vector3 &pos1, PhysicsBody3D *body2, const Vector3 &pos2, const Vector3 &normal, real_t &impulse, const real_t p_rollInfluence);
+	real_t _calc_rolling_friction(btVehicleWheelContactPoint &contactPoint);
+
+	void _update_friction(PhysicsDirectBodyState3D *s);
+	void _update_suspension(PhysicsDirectBodyState3D *s);
+	real_t _ray_cast(int p_idx, PhysicsDirectBodyState3D *s);
+	void _update_wheel_transform(VehicleWheel3D &wheel, PhysicsDirectBodyState3D *s);
+	void _update_wheel(int p_idx, PhysicsDirectBodyState3D *s);
+
+	friend class VehicleWheel3D;
+	Vector<VehicleWheel3D *> wheels;
+
+	static void _bind_methods();
+
+	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state);
+	virtual void _body_state_changed(PhysicsDirectBodyState3D *p_state) override;
+
+public:
+	void set_engine_force(real_t p_engine_force);
+	real_t get_engine_force() const;
+
+	void set_brake(real_t p_brake);
+	real_t get_brake() const;
+
+	void set_steering(real_t p_steering);
+	real_t get_steering() const;
+
+	VehicleBody3D();
+};
+
+#endif // VEHICLE_BODY_3D_H