Merge pull request #88862 from smix8/split_physics_classes

Split monolithic physics class files

133 files changed, 9747 insertions, 8399 deletions

diff --git a/editor/import/3d/resource_importer_scene.cpp b/editor/import/3d/resource_importer_scene.cpp
index 38977d11e0..ca128968de 100644
--- a/editor/import/3d/resource_importer_scene.cpp
+++ b/editor/import/3d/resource_importer_scene.cpp
@@ -37,14 +37,15 @@
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
 #include "editor/import/3d/scene_import_settings.h"
-#include "scene/3d/area_3d.h"
-#include "scene/3d/collision_shape_3d.h"
 #include "scene/3d/importer_mesh_instance_3d.h"
 #include "scene/3d/mesh_instance_3d.h"
 #include "scene/3d/navigation_region_3d.h"
 #include "scene/3d/occluder_instance_3d.h"
-#include "scene/3d/physics_body_3d.h"
-#include "scene/3d/vehicle_body_3d.h"
+#include "scene/3d/physics/area_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
+#include "scene/3d/physics/vehicle_body_3d.h"
 #include "scene/animation/animation_player.h"
 #include "scene/resources/3d/box_shape_3d.h"
 #include "scene/resources/3d/importer_mesh.h"
diff --git a/editor/plugins/cast_2d_editor_plugin.cpp b/editor/plugins/cast_2d_editor_plugin.cpp
index a6457e38a7..64db19d85e 100644
--- a/editor/plugins/cast_2d_editor_plugin.cpp
+++ b/editor/plugins/cast_2d_editor_plugin.cpp
@@ -33,8 +33,8 @@
 #include "canvas_item_editor_plugin.h"
 #include "editor/editor_node.h"
 #include "editor/editor_undo_redo_manager.h"
-#include "scene/2d/ray_cast_2d.h"
-#include "scene/2d/shape_cast_2d.h"
+#include "scene/2d/physics/ray_cast_2d.h"
+#include "scene/2d/physics/shape_cast_2d.h"
 
 void Cast2DEditor::_notification(int p_what) {
 	switch (p_what) {
diff --git a/editor/plugins/collision_polygon_2d_editor_plugin.h b/editor/plugins/collision_polygon_2d_editor_plugin.h
index 070a01f651..61e6cc3dda 100644
--- a/editor/plugins/collision_polygon_2d_editor_plugin.h
+++ b/editor/plugins/collision_polygon_2d_editor_plugin.h
@@ -32,7 +32,7 @@
 #define COLLISION_POLYGON_2D_EDITOR_PLUGIN_H
 
 #include "editor/plugins/abstract_polygon_2d_editor.h"
-#include "scene/2d/collision_polygon_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
 
 class CollisionPolygon2DEditor : public AbstractPolygon2DEditor {
 	GDCLASS(CollisionPolygon2DEditor, AbstractPolygon2DEditor);
diff --git a/editor/plugins/collision_shape_2d_editor_plugin.h b/editor/plugins/collision_shape_2d_editor_plugin.h
index d58f5d511f..0e454799d6 100644
--- a/editor/plugins/collision_shape_2d_editor_plugin.h
+++ b/editor/plugins/collision_shape_2d_editor_plugin.h
@@ -32,7 +32,7 @@
 #define COLLISION_SHAPE_2D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/2d/collision_shape_2d.h"
+#include "scene/2d/physics/collision_shape_2d.h"
 
 class CanvasItemEditor;
 
diff --git a/editor/plugins/cpu_particles_2d_editor_plugin.h b/editor/plugins/cpu_particles_2d_editor_plugin.h
index 5077827ce8..ffcf53af66 100644
--- a/editor/plugins/cpu_particles_2d_editor_plugin.h
+++ b/editor/plugins/cpu_particles_2d_editor_plugin.h
@@ -32,8 +32,8 @@
 #define CPU_PARTICLES_2D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/2d/collision_polygon_2d.h"
 #include "scene/2d/cpu_particles_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
 #include "scene/gui/box_container.h"
 
 class CheckBox;
diff --git a/editor/plugins/gizmos/collision_object_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/collision_object_3d_gizmo_plugin.cpp
index 63f2883ed7..caac143f23 100644
--- a/editor/plugins/gizmos/collision_object_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/collision_object_3d_gizmo_plugin.cpp
@@ -32,9 +32,9 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/collision_object_3d.h"
-#include "scene/3d/collision_polygon_3d.h"
-#include "scene/3d/collision_shape_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/3d/physics/collision_polygon_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
 #include "scene/resources/surface_tool.h"
 
 CollisionObject3DGizmoPlugin::CollisionObject3DGizmoPlugin() {
diff --git a/editor/plugins/gizmos/collision_polygon_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/collision_polygon_3d_gizmo_plugin.cpp
index 50c10be11d..7d19e8f677 100644
--- a/editor/plugins/gizmos/collision_polygon_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/collision_polygon_3d_gizmo_plugin.cpp
@@ -32,7 +32,7 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/collision_polygon_3d.h"
+#include "scene/3d/physics/collision_polygon_3d.h"
 
 CollisionPolygon3DGizmoPlugin::CollisionPolygon3DGizmoPlugin() {
 	const Color gizmo_color = EDITOR_GET("editors/3d_gizmos/gizmo_colors/shape");
diff --git a/editor/plugins/gizmos/collision_shape_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/collision_shape_3d_gizmo_plugin.cpp
index 3cf9164460..9d4c08ed57 100644
--- a/editor/plugins/gizmos/collision_shape_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/collision_shape_3d_gizmo_plugin.cpp
@@ -36,7 +36,7 @@
 #include "editor/editor_undo_redo_manager.h"
 #include "editor/plugins/gizmos/gizmo_3d_helper.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/collision_shape_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
 #include "scene/resources/3d/box_shape_3d.h"
 #include "scene/resources/3d/capsule_shape_3d.h"
 #include "scene/resources/3d/concave_polygon_shape_3d.h"
diff --git a/editor/plugins/gizmos/joint_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/joint_3d_gizmo_plugin.cpp
index 3a8a0cff96..c15ddef933 100644
--- a/editor/plugins/gizmos/joint_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/joint_3d_gizmo_plugin.cpp
@@ -33,7 +33,11 @@
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/joint_3d.h"
+#include "scene/3d/physics/joints/cone_twist_joint_3d.h"
+#include "scene/3d/physics/joints/generic_6dof_joint_3d.h"
+#include "scene/3d/physics/joints/hinge_joint_3d.h"
+#include "scene/3d/physics/joints/pin_joint_3d.h"
+#include "scene/3d/physics/joints/slider_joint_3d.h"
 
 #define BODY_A_RADIUS 0.25
 #define BODY_B_RADIUS 0.27
diff --git a/editor/plugins/gizmos/physics_bone_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/physics_bone_3d_gizmo_plugin.cpp
index d1511a5f76..b15f9bec3f 100644
--- a/editor/plugins/gizmos/physics_bone_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/physics_bone_3d_gizmo_plugin.cpp
@@ -33,7 +33,8 @@
 #include "editor/editor_settings.h"
 #include "editor/plugins/gizmos/joint_3d_gizmo_plugin.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physical_bone_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 
 PhysicalBone3DGizmoPlugin::PhysicalBone3DGizmoPlugin() {
 	create_material("joint_material", EDITOR_GET("editors/3d_gizmos/gizmo_colors/joint"));
diff --git a/editor/plugins/gizmos/ray_cast_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/ray_cast_3d_gizmo_plugin.cpp
index eb9e54fe1d..d783c4e4a7 100644
--- a/editor/plugins/gizmos/ray_cast_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/ray_cast_3d_gizmo_plugin.cpp
@@ -32,7 +32,7 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/ray_cast_3d.h"
+#include "scene/3d/physics/ray_cast_3d.h"
 
 RayCast3DGizmoPlugin::RayCast3DGizmoPlugin() {
 	const Color gizmo_color = EDITOR_GET("editors/3d_gizmos/gizmo_colors/shape");
diff --git a/editor/plugins/gizmos/shape_cast_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/shape_cast_3d_gizmo_plugin.cpp
index 23a224fc01..909f5b5f9a 100644
--- a/editor/plugins/gizmos/shape_cast_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/shape_cast_3d_gizmo_plugin.cpp
@@ -32,7 +32,7 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/shape_cast_3d.h"
+#include "scene/3d/physics/shape_cast_3d.h"
 
 ShapeCast3DGizmoPlugin::ShapeCast3DGizmoPlugin() {
 	const Color gizmo_color = EDITOR_GET("editors/3d_gizmos/gizmo_colors/shape");
diff --git a/editor/plugins/gizmos/spring_arm_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/spring_arm_3d_gizmo_plugin.cpp
index 69acac5a89..85e2c86947 100644
--- a/editor/plugins/gizmos/spring_arm_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/spring_arm_3d_gizmo_plugin.cpp
@@ -32,7 +32,7 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/spring_arm_3d.h"
+#include "scene/3d/physics/spring_arm_3d.h"
 #include "scene/resources/3d/shape_3d.h"
 
 void SpringArm3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
diff --git a/editor/plugins/gizmos/vehicle_body_3d_gizmo_plugin.cpp b/editor/plugins/gizmos/vehicle_body_3d_gizmo_plugin.cpp
index ef6cd88868..69e87a55c0 100644
--- a/editor/plugins/gizmos/vehicle_body_3d_gizmo_plugin.cpp
+++ b/editor/plugins/gizmos/vehicle_body_3d_gizmo_plugin.cpp
@@ -32,7 +32,7 @@
 
 #include "editor/editor_settings.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
-#include "scene/3d/vehicle_body_3d.h"
+#include "scene/3d/physics/vehicle_body_3d.h"
 
 VehicleWheel3DGizmoPlugin::VehicleWheel3DGizmoPlugin() {
 	Color gizmo_color = EDITOR_GET("editors/3d_gizmos/gizmo_colors/shape");
diff --git a/editor/plugins/gpu_particles_2d_editor_plugin.h b/editor/plugins/gpu_particles_2d_editor_plugin.h
index 237a005ab7..f202179eff 100644
--- a/editor/plugins/gpu_particles_2d_editor_plugin.h
+++ b/editor/plugins/gpu_particles_2d_editor_plugin.h
@@ -32,8 +32,8 @@
 #define GPU_PARTICLES_2D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/2d/collision_polygon_2d.h"
 #include "scene/2d/gpu_particles_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
 #include "scene/gui/box_container.h"
 #include "scene/gui/spin_box.h"
 
diff --git a/editor/plugins/mesh_instance_3d_editor_plugin.cpp b/editor/plugins/mesh_instance_3d_editor_plugin.cpp
index 061b839ee3..d62eddeeea 100644
--- a/editor/plugins/mesh_instance_3d_editor_plugin.cpp
+++ b/editor/plugins/mesh_instance_3d_editor_plugin.cpp
@@ -35,9 +35,10 @@
 #include "editor/editor_undo_redo_manager.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
 #include "editor/themes/editor_scale.h"
-#include "scene/3d/collision_shape_3d.h"
 #include "scene/3d/navigation_region_3d.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
 #include "scene/gui/box_container.h"
 #include "scene/gui/dialogs.h"
 #include "scene/gui/menu_button.h"
diff --git a/editor/plugins/mesh_library_editor_plugin.cpp b/editor/plugins/mesh_library_editor_plugin.cpp
index 4e45714174..8bfd3d0957 100644
--- a/editor/plugins/mesh_library_editor_plugin.cpp
+++ b/editor/plugins/mesh_library_editor_plugin.cpp
@@ -40,7 +40,8 @@
 #include "main/main.h"
 #include "scene/3d/mesh_instance_3d.h"
 #include "scene/3d/navigation_region_3d.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
 #include "scene/gui/menu_button.h"
 #include "scene/main/window.h"
 #include "scene/resources/packed_scene.h"
diff --git a/editor/plugins/navigation_obstacle_3d_editor_plugin.h b/editor/plugins/navigation_obstacle_3d_editor_plugin.h
index 175fc75612..74094dc86f 100644
--- a/editor/plugins/navigation_obstacle_3d_editor_plugin.h
+++ b/editor/plugins/navigation_obstacle_3d_editor_plugin.h
@@ -32,8 +32,8 @@
 #define NAVIGATION_OBSTACLE_3D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/3d/collision_polygon_3d.h"
 #include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/collision_polygon_3d.h"
 #include "scene/gui/box_container.h"
 #include "scene/resources/immediate_mesh.h"
 
diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp
index 26e33f5796..aa0069979c 100644
--- a/editor/plugins/node_3d_editor_plugin.cpp
+++ b/editor/plugins/node_3d_editor_plugin.cpp
@@ -78,11 +78,11 @@
 #include "editor/plugins/node_3d_editor_gizmos.h"
 #include "editor/scene_tree_dock.h"
 #include "scene/3d/camera_3d.h"
-#include "scene/3d/collision_shape_3d.h"
 #include "scene/3d/decal.h"
 #include "scene/3d/light_3d.h"
 #include "scene/3d/mesh_instance_3d.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 #include "scene/3d/visual_instance_3d.h"
 #include "scene/3d/world_environment.h"
 #include "scene/gui/center_container.h"
diff --git a/editor/plugins/physical_bone_3d_editor_plugin.cpp b/editor/plugins/physical_bone_3d_editor_plugin.cpp
index 37092f924e..b7c12ab5c0 100644
--- a/editor/plugins/physical_bone_3d_editor_plugin.cpp
+++ b/editor/plugins/physical_bone_3d_editor_plugin.cpp
@@ -33,6 +33,7 @@
 #include "editor/editor_node.h"
 #include "editor/editor_string_names.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
+#include "scene/3d/physics/physical_bone_3d.h"
 #include "scene/gui/separator.h"
 
 void PhysicalBone3DEditor::_bind_methods() {
diff --git a/editor/plugins/physical_bone_3d_editor_plugin.h b/editor/plugins/physical_bone_3d_editor_plugin.h
index c9799d3faa..5c49e641a5 100644
--- a/editor/plugins/physical_bone_3d_editor_plugin.h
+++ b/editor/plugins/physical_bone_3d_editor_plugin.h
@@ -32,10 +32,11 @@
 #define PHYSICAL_BONE_3D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/3d/physics_body_3d.h"
 #include "scene/gui/box_container.h"
 #include "scene/gui/button.h"
 
+class PhysicalBone3D;
+
 class PhysicalBone3DEditor : public Object {
 	GDCLASS(PhysicalBone3DEditor, Object);
 
diff --git a/editor/plugins/polygon_3d_editor_plugin.h b/editor/plugins/polygon_3d_editor_plugin.h
index 6407e33f48..85cfd807e4 100644
--- a/editor/plugins/polygon_3d_editor_plugin.h
+++ b/editor/plugins/polygon_3d_editor_plugin.h
@@ -32,8 +32,8 @@
 #define POLYGON_3D_EDITOR_PLUGIN_H
 
 #include "editor/editor_plugin.h"
-#include "scene/3d/collision_polygon_3d.h"
 #include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/collision_polygon_3d.h"
 #include "scene/gui/box_container.h"
 #include "scene/resources/immediate_mesh.h"
 
diff --git a/editor/plugins/skeleton_3d_editor_plugin.cpp b/editor/plugins/skeleton_3d_editor_plugin.cpp
index 701e848be1..ffc59a3429 100644
--- a/editor/plugins/skeleton_3d_editor_plugin.cpp
+++ b/editor/plugins/skeleton_3d_editor_plugin.cpp
@@ -40,10 +40,11 @@
 #include "editor/plugins/animation_player_editor_plugin.h"
 #include "editor/plugins/node_3d_editor_plugin.h"
 #include "editor/themes/editor_scale.h"
-#include "scene/3d/collision_shape_3d.h"
-#include "scene/3d/joint_3d.h"
 #include "scene/3d/mesh_instance_3d.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/joints/joint_3d.h"
+#include "scene/3d/physics/physical_bone_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 #include "scene/gui/separator.h"
 #include "scene/gui/texture_rect.h"
 #include "scene/resources/3d/capsule_shape_3d.h"
diff --git a/editor/plugins/sprite_2d_editor_plugin.cpp b/editor/plugins/sprite_2d_editor_plugin.cpp
index 3e98f3d64f..de81264f13 100644
--- a/editor/plugins/sprite_2d_editor_plugin.cpp
+++ b/editor/plugins/sprite_2d_editor_plugin.cpp
@@ -38,9 +38,9 @@
 #include "editor/gui/editor_zoom_widget.h"
 #include "editor/scene_tree_dock.h"
 #include "editor/themes/editor_scale.h"
-#include "scene/2d/collision_polygon_2d.h"
 #include "scene/2d/light_occluder_2d.h"
 #include "scene/2d/mesh_instance_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
 #include "scene/2d/polygon_2d.h"
 #include "scene/gui/box_container.h"
 #include "scene/gui/menu_button.h"
diff --git a/modules/gltf/extensions/physics/gltf_document_extension_physics.cpp b/modules/gltf/extensions/physics/gltf_document_extension_physics.cpp
index a9033de7ae..c6e34cc023 100644
--- a/modules/gltf/extensions/physics/gltf_document_extension_physics.cpp
+++ b/modules/gltf/extensions/physics/gltf_document_extension_physics.cpp
@@ -30,7 +30,8 @@
 
 #include "gltf_document_extension_physics.h"
 
-#include "scene/3d/area_3d.h"
+#include "scene/3d/physics/area_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
 
 // Import process.
 Error GLTFDocumentExtensionPhysics::import_preflight(Ref<GLTFState> p_state, Vector<String> p_extensions) {
diff --git a/modules/gltf/extensions/physics/gltf_physics_body.cpp b/modules/gltf/extensions/physics/gltf_physics_body.cpp
index 271bb9b332..7929b46542 100644
--- a/modules/gltf/extensions/physics/gltf_physics_body.cpp
+++ b/modules/gltf/extensions/physics/gltf_physics_body.cpp
@@ -30,8 +30,11 @@
 
 #include "gltf_physics_body.h"
 
-#include "scene/3d/area_3d.h"
-#include "scene/3d/vehicle_body_3d.h"
+#include "scene/3d/physics/animatable_body_3d.h"
+#include "scene/3d/physics/area_3d.h"
+#include "scene/3d/physics/character_body_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
+#include "scene/3d/physics/vehicle_body_3d.h"
 
 void GLTFPhysicsBody::_bind_methods() {
 	ClassDB::bind_static_method("GLTFPhysicsBody", D_METHOD("from_node", "body_node"), &GLTFPhysicsBody::from_node);
diff --git a/modules/gltf/extensions/physics/gltf_physics_body.h b/modules/gltf/extensions/physics/gltf_physics_body.h
index 6b21639a7b..ec139054ff 100644
--- a/modules/gltf/extensions/physics/gltf_physics_body.h
+++ b/modules/gltf/extensions/physics/gltf_physics_body.h
@@ -31,7 +31,7 @@
 #ifndef GLTF_PHYSICS_BODY_H
 #define GLTF_PHYSICS_BODY_H
 
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 
 // GLTFPhysicsBody is an intermediary between Godot's physics body nodes
 // and the OMI_physics_body extension.
diff --git a/modules/gltf/extensions/physics/gltf_physics_shape.cpp b/modules/gltf/extensions/physics/gltf_physics_shape.cpp
index 467499a03f..35c99adbe5 100644
--- a/modules/gltf/extensions/physics/gltf_physics_shape.cpp
+++ b/modules/gltf/extensions/physics/gltf_physics_shape.cpp
@@ -33,7 +33,7 @@
 #include "../../gltf_state.h"
 
 #include "core/math/convex_hull.h"
-#include "scene/3d/area_3d.h"
+#include "scene/3d/physics/area_3d.h"
 #include "scene/resources/3d/box_shape_3d.h"
 #include "scene/resources/3d/capsule_shape_3d.h"
 #include "scene/resources/3d/concave_polygon_shape_3d.h"
diff --git a/modules/gltf/extensions/physics/gltf_physics_shape.h b/modules/gltf/extensions/physics/gltf_physics_shape.h
index 4f7ac39292..ec0a8931f1 100644
--- a/modules/gltf/extensions/physics/gltf_physics_shape.h
+++ b/modules/gltf/extensions/physics/gltf_physics_shape.h
@@ -33,7 +33,7 @@
 
 #include "../../gltf_defines.h"
 
-#include "scene/3d/collision_shape_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
 
 class ImporterMesh;
 
diff --git a/modules/navigation/2d/nav_mesh_generator_2d.cpp b/modules/navigation/2d/nav_mesh_generator_2d.cpp
index 9fdfb20842..d1ac784103 100644
--- a/modules/navigation/2d/nav_mesh_generator_2d.cpp
+++ b/modules/navigation/2d/nav_mesh_generator_2d.cpp
@@ -35,7 +35,7 @@
 #include "core/config/project_settings.h"
 #include "scene/2d/mesh_instance_2d.h"
 #include "scene/2d/multimesh_instance_2d.h"
-#include "scene/2d/physics_body_2d.h"
+#include "scene/2d/physics/static_body_2d.h"
 #include "scene/2d/polygon_2d.h"
 #include "scene/2d/tile_map.h"
 #include "scene/resources/2d/capsule_shape_2d.h"
diff --git a/modules/navigation/3d/nav_mesh_generator_3d.cpp b/modules/navigation/3d/nav_mesh_generator_3d.cpp
index 4cd4f60edc..e1ed9c51aa 100644
--- a/modules/navigation/3d/nav_mesh_generator_3d.cpp
+++ b/modules/navigation/3d/nav_mesh_generator_3d.cpp
@@ -37,7 +37,7 @@
 #include "core/os/thread.h"
 #include "scene/3d/mesh_instance_3d.h"
 #include "scene/3d/multimesh_instance_3d.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
 #include "scene/resources/3d/box_shape_3d.h"
 #include "scene/resources/3d/capsule_shape_3d.h"
 #include "scene/resources/3d/concave_polygon_shape_3d.h"
diff --git a/scene/2d/SCsub b/scene/2d/SCsub
index fc61250247..94e1ab6c96 100644
--- a/scene/2d/SCsub
+++ b/scene/2d/SCsub
@@ -3,3 +3,6 @@
 Import("env")
 
 env.add_source_files(env.scene_sources, "*.cpp")
+
+# Chain load SCsubs
+SConscript("physics/SCsub")
diff --git a/scene/2d/audio_stream_player_2d.cpp b/scene/2d/audio_stream_player_2d.cpp
index 4762ae28f8..cbd3c244d9 100644
--- a/scene/2d/audio_stream_player_2d.cpp
+++ b/scene/2d/audio_stream_player_2d.cpp
@@ -32,8 +32,8 @@
 #include "audio_stream_player_2d.compat.inc"
 
 #include "core/config/project_settings.h"
-#include "scene/2d/area_2d.h"
 #include "scene/2d/audio_listener_2d.h"
+#include "scene/2d/physics/area_2d.h"
 #include "scene/audio/audio_stream_player_internal.h"
 #include "scene/main/viewport.h"
 #include "scene/resources/world_2d.h"
diff --git a/scene/2d/joint_2d.cpp b/scene/2d/joint_2d.cpp
deleted file mode 100644
index 41b121a482..0000000000
--- a/scene/2d/joint_2d.cpp
+++ /dev/null
@@ -1,564 +0,0 @@
-/**************************************************************************/
-/*  joint_2d.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_2d.h"
-
-#include "physics_body_2d.h"
-#include "scene/scene_string_names.h"
-
-void Joint2D::_disconnect_signals() {
-	Node *node_a = get_node_or_null(a);
-	PhysicsBody2D *body_a = Object::cast_to<PhysicsBody2D>(node_a);
-	if (body_a) {
-		body_a->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
-	}
-
-	Node *node_b = get_node_or_null(b);
-	PhysicsBody2D *body_b = Object::cast_to<PhysicsBody2D>(node_b);
-	if (body_b) {
-		body_b->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
-	}
-}
-
-void Joint2D::_body_exit_tree() {
-	_disconnect_signals();
-	_update_joint(true);
-	update_configuration_warnings();
-}
-
-void Joint2D::_update_joint(bool p_only_free) {
-	if (ba.is_valid() && bb.is_valid() && exclude_from_collision) {
-		PhysicsServer2D::get_singleton()->joint_disable_collisions_between_bodies(joint, false);
-	}
-
-	ba = RID();
-	bb = RID();
-	configured = false;
-
-	if (p_only_free || !is_inside_tree()) {
-		PhysicsServer2D::get_singleton()->joint_clear(joint);
-		warning = String();
-		return;
-	}
-
-	Node *node_a = get_node_or_null(a);
-	Node *node_b = get_node_or_null(b);
-
-	PhysicsBody2D *body_a = Object::cast_to<PhysicsBody2D>(node_a);
-	PhysicsBody2D *body_b = Object::cast_to<PhysicsBody2D>(node_b);
-
-	bool valid = false;
-
-	if (node_a && !body_a && node_b && !body_b) {
-		warning = RTR("Node A and Node B must be PhysicsBody2Ds");
-	} else if (node_a && !body_a) {
-		warning = RTR("Node A must be a PhysicsBody2D");
-	} else if (node_b && !body_b) {
-		warning = RTR("Node B must be a PhysicsBody2D");
-	} else if (!body_a || !body_b) {
-		warning = RTR("Joint is not connected to two PhysicsBody2Ds");
-	} else if (body_a == body_b) {
-		warning = RTR("Node A and Node B must be different PhysicsBody2Ds");
-	} else {
-		warning = String();
-		valid = true;
-	}
-
-	update_configuration_warnings();
-
-	if (!valid) {
-		PhysicsServer2D::get_singleton()->joint_clear(joint);
-		return;
-	}
-
-	if (body_a) {
-		body_a->force_update_transform();
-	}
-
-	if (body_b) {
-		body_b->force_update_transform();
-	}
-
-	configured = true;
-
-	_configure_joint(joint, body_a, body_b);
-
-	ERR_FAIL_COND_MSG(!joint.is_valid(), "Failed to configure the joint.");
-
-	PhysicsServer2D::get_singleton()->joint_set_param(joint, PhysicsServer2D::JOINT_PARAM_BIAS, bias);
-
-	ba = body_a->get_rid();
-	bb = body_b->get_rid();
-
-	body_a->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
-	body_b->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
-
-	PhysicsServer2D::get_singleton()->joint_disable_collisions_between_bodies(joint, exclude_from_collision);
-}
-
-void Joint2D::set_node_a(const NodePath &p_node_a) {
-	if (a == p_node_a) {
-		return;
-	}
-
-	if (is_configured()) {
-		_disconnect_signals();
-	}
-
-	a = p_node_a;
-	if (Engine::get_singleton()->is_editor_hint()) {
-		// When in editor, the setter may be called as a result of node rename.
-		// It happens before the node actually changes its name, which triggers false warning.
-		callable_mp(this, &Joint2D::_update_joint).call_deferred();
-	} else {
-		_update_joint();
-	}
-}
-
-NodePath Joint2D::get_node_a() const {
-	return a;
-}
-
-void Joint2D::set_node_b(const NodePath &p_node_b) {
-	if (b == p_node_b) {
-		return;
-	}
-
-	if (is_configured()) {
-		_disconnect_signals();
-	}
-
-	b = p_node_b;
-	if (Engine::get_singleton()->is_editor_hint()) {
-		callable_mp(this, &Joint2D::_update_joint).call_deferred();
-	} else {
-		_update_joint();
-	}
-}
-
-NodePath Joint2D::get_node_b() const {
-	return b;
-}
-
-void Joint2D::_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 Joint2D::set_bias(real_t p_bias) {
-	bias = p_bias;
-	if (joint.is_valid()) {
-		PhysicsServer2D::get_singleton()->joint_set_param(joint, PhysicsServer2D::JOINT_PARAM_BIAS, bias);
-	}
-}
-
-real_t Joint2D::get_bias() const {
-	return bias;
-}
-
-void Joint2D::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 Joint2D::get_exclude_nodes_from_collision() const {
-	return exclude_from_collision;
-}
-
-PackedStringArray Joint2D::get_configuration_warnings() const {
-	PackedStringArray warnings = Node2D::get_configuration_warnings();
-
-	if (!warning.is_empty()) {
-		warnings.push_back(warning);
-	}
-
-	return warnings;
-}
-
-void Joint2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_node_a", "node"), &Joint2D::set_node_a);
-	ClassDB::bind_method(D_METHOD("get_node_a"), &Joint2D::get_node_a);
-
-	ClassDB::bind_method(D_METHOD("set_node_b", "node"), &Joint2D::set_node_b);
-	ClassDB::bind_method(D_METHOD("get_node_b"), &Joint2D::get_node_b);
-
-	ClassDB::bind_method(D_METHOD("set_bias", "bias"), &Joint2D::set_bias);
-	ClassDB::bind_method(D_METHOD("get_bias"), &Joint2D::get_bias);
-
-	ClassDB::bind_method(D_METHOD("set_exclude_nodes_from_collision", "enable"), &Joint2D::set_exclude_nodes_from_collision);
-	ClassDB::bind_method(D_METHOD("get_exclude_nodes_from_collision"), &Joint2D::get_exclude_nodes_from_collision);
-
-	ClassDB::bind_method(D_METHOD("get_rid"), &Joint2D::get_rid);
-
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_a", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody2D"), "set_node_a", "get_node_a");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_b", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody2D"), "set_node_b", "get_node_b");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bias", PROPERTY_HINT_RANGE, "0,0.9,0.001"), "set_bias", "get_bias");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disable_collision"), "set_exclude_nodes_from_collision", "get_exclude_nodes_from_collision");
-}
-
-Joint2D::Joint2D() {
-	joint = PhysicsServer2D::get_singleton()->joint_create();
-	set_hide_clip_children(true);
-}
-
-Joint2D::~Joint2D() {
-	ERR_FAIL_NULL(PhysicsServer2D::get_singleton());
-	PhysicsServer2D::get_singleton()->free(joint);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-void PinJoint2D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_DRAW: {
-			if (!is_inside_tree()) {
-				break;
-			}
-
-			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
-				break;
-			}
-
-			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(0, -10), Point2(0, +10), Color(0.7, 0.6, 0.0, 0.5), 3);
-		} break;
-	}
-}
-
-void PinJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
-	PhysicsServer2D::get_singleton()->joint_make_pin(p_joint, get_global_position(), body_a->get_rid(), body_b ? body_b->get_rid() : RID());
-	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_SOFTNESS, softness);
-	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_LIMIT_UPPER, angular_limit_upper);
-	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_LIMIT_LOWER, angular_limit_lower);
-	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_MOTOR_TARGET_VELOCITY, motor_target_velocity);
-	PhysicsServer2D::get_singleton()->pin_joint_set_flag(p_joint, PhysicsServer2D::PIN_JOINT_FLAG_MOTOR_ENABLED, motor_enabled);
-	PhysicsServer2D::get_singleton()->pin_joint_set_flag(p_joint, PhysicsServer2D::PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED, angular_limit_enabled);
-}
-
-void PinJoint2D::set_softness(real_t p_softness) {
-	if (softness == p_softness) {
-		return;
-	}
-	softness = p_softness;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_SOFTNESS, p_softness);
-	}
-}
-
-real_t PinJoint2D::get_softness() const {
-	return softness;
-}
-
-void PinJoint2D::set_angular_limit_lower(real_t p_angular_limit_lower) {
-	if (angular_limit_lower == p_angular_limit_lower) {
-		return;
-	}
-	angular_limit_lower = p_angular_limit_lower;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_LIMIT_LOWER, p_angular_limit_lower);
-	}
-}
-
-real_t PinJoint2D::get_angular_limit_lower() const {
-	return angular_limit_lower;
-}
-
-void PinJoint2D::set_angular_limit_upper(real_t p_angular_limit_upper) {
-	if (angular_limit_upper == p_angular_limit_upper) {
-		return;
-	}
-	angular_limit_upper = p_angular_limit_upper;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_LIMIT_UPPER, p_angular_limit_upper);
-	}
-}
-
-real_t PinJoint2D::get_angular_limit_upper() const {
-	return angular_limit_upper;
-}
-
-void PinJoint2D::set_motor_target_velocity(real_t p_motor_target_velocity) {
-	if (motor_target_velocity == p_motor_target_velocity) {
-		return;
-	}
-	motor_target_velocity = p_motor_target_velocity;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_MOTOR_TARGET_VELOCITY, motor_target_velocity);
-	}
-}
-
-real_t PinJoint2D::get_motor_target_velocity() const {
-	return motor_target_velocity;
-}
-
-void PinJoint2D::set_motor_enabled(bool p_motor_enabled) {
-	if (motor_enabled == p_motor_enabled) {
-		return;
-	}
-	motor_enabled = p_motor_enabled;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_flag(get_rid(), PhysicsServer2D::PIN_JOINT_FLAG_MOTOR_ENABLED, motor_enabled);
-	}
-}
-
-bool PinJoint2D::is_motor_enabled() const {
-	return motor_enabled;
-}
-
-void PinJoint2D::set_angular_limit_enabled(bool p_angular_limit_enabled) {
-	if (angular_limit_enabled == p_angular_limit_enabled) {
-		return;
-	}
-	angular_limit_enabled = p_angular_limit_enabled;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->pin_joint_set_flag(get_rid(), PhysicsServer2D::PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED, angular_limit_enabled);
-	}
-}
-
-bool PinJoint2D::is_angular_limit_enabled() const {
-	return angular_limit_enabled;
-}
-
-void PinJoint2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_softness", "softness"), &PinJoint2D::set_softness);
-	ClassDB::bind_method(D_METHOD("get_softness"), &PinJoint2D::get_softness);
-	ClassDB::bind_method(D_METHOD("set_angular_limit_lower", "angular_limit_lower"), &PinJoint2D::set_angular_limit_lower);
-	ClassDB::bind_method(D_METHOD("get_angular_limit_lower"), &PinJoint2D::get_angular_limit_lower);
-	ClassDB::bind_method(D_METHOD("set_angular_limit_upper", "angular_limit_upper"), &PinJoint2D::set_angular_limit_upper);
-	ClassDB::bind_method(D_METHOD("get_angular_limit_upper"), &PinJoint2D::get_angular_limit_upper);
-	ClassDB::bind_method(D_METHOD("set_motor_target_velocity", "motor_target_velocity"), &PinJoint2D::set_motor_target_velocity);
-	ClassDB::bind_method(D_METHOD("get_motor_target_velocity"), &PinJoint2D::get_motor_target_velocity);
-	ClassDB::bind_method(D_METHOD("set_motor_enabled", "enabled"), &PinJoint2D::set_motor_enabled);
-	ClassDB::bind_method(D_METHOD("is_motor_enabled"), &PinJoint2D::is_motor_enabled);
-	ClassDB::bind_method(D_METHOD("set_angular_limit_enabled", "enabled"), &PinJoint2D::set_angular_limit_enabled);
-	ClassDB::bind_method(D_METHOD("is_angular_limit_enabled"), &PinJoint2D::is_angular_limit_enabled);
-
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "softness", PROPERTY_HINT_RANGE, "0.00,16,0.01,exp"), "set_softness", "get_softness");
-	ADD_GROUP("Angular Limit", "angular_limit_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "angular_limit_enabled"), "set_angular_limit_enabled", "is_angular_limit_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_limit_lower", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_angular_limit_lower", "get_angular_limit_lower");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_limit_upper", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_angular_limit_upper", "get_angular_limit_upper");
-	ADD_GROUP("Motor", "motor_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "motor_enabled"), "set_motor_enabled", "is_motor_enabled");
-	ADD_PROPERTY(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_motor_target_velocity", "get_motor_target_velocity");
-}
-
-PinJoint2D::PinJoint2D() {
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-void GrooveJoint2D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_DRAW: {
-			if (!is_inside_tree()) {
-				break;
-			}
-
-			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
-				break;
-			}
-
-			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(-10, initial_offset), Point2(+10, initial_offset), Color(0.8, 0.8, 0.9, 0.5), 5);
-		} break;
-	}
-}
-
-void GrooveJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
-	Transform2D gt = get_global_transform();
-	Vector2 groove_A1 = gt.get_origin();
-	Vector2 groove_A2 = gt.xform(Vector2(0, length));
-	Vector2 anchor_B = gt.xform(Vector2(0, initial_offset));
-
-	PhysicsServer2D::get_singleton()->joint_make_groove(p_joint, groove_A1, groove_A2, anchor_B, body_a->get_rid(), body_b->get_rid());
-}
-
-void GrooveJoint2D::set_length(real_t p_length) {
-	length = p_length;
-	queue_redraw();
-}
-
-real_t GrooveJoint2D::get_length() const {
-	return length;
-}
-
-void GrooveJoint2D::set_initial_offset(real_t p_initial_offset) {
-	initial_offset = p_initial_offset;
-	queue_redraw();
-}
-
-real_t GrooveJoint2D::get_initial_offset() const {
-	return initial_offset;
-}
-
-void GrooveJoint2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_length", "length"), &GrooveJoint2D::set_length);
-	ClassDB::bind_method(D_METHOD("get_length"), &GrooveJoint2D::get_length);
-	ClassDB::bind_method(D_METHOD("set_initial_offset", "offset"), &GrooveJoint2D::set_initial_offset);
-	ClassDB::bind_method(D_METHOD("get_initial_offset"), &GrooveJoint2D::get_initial_offset);
-
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_length", "get_length");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "initial_offset", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_initial_offset", "get_initial_offset");
-}
-
-GrooveJoint2D::GrooveJoint2D() {
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-void DampedSpringJoint2D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_DRAW: {
-			if (!is_inside_tree()) {
-				break;
-			}
-
-			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
-				break;
-			}
-
-			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
-			draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
-		} break;
-	}
-}
-
-void DampedSpringJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
-	Transform2D gt = get_global_transform();
-	Vector2 anchor_A = gt.get_origin();
-	Vector2 anchor_B = gt.xform(Vector2(0, length));
-
-	PhysicsServer2D::get_singleton()->joint_make_damped_spring(p_joint, anchor_A, anchor_B, body_a->get_rid(), body_b->get_rid());
-	if (rest_length) {
-		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_REST_LENGTH, rest_length);
-	}
-	PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_STIFFNESS, stiffness);
-	PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_DAMPING, damping);
-}
-
-void DampedSpringJoint2D::set_length(real_t p_length) {
-	length = p_length;
-	queue_redraw();
-}
-
-real_t DampedSpringJoint2D::get_length() const {
-	return length;
-}
-
-void DampedSpringJoint2D::set_rest_length(real_t p_rest_length) {
-	rest_length = p_rest_length;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_REST_LENGTH, p_rest_length ? p_rest_length : length);
-	}
-}
-
-real_t DampedSpringJoint2D::get_rest_length() const {
-	return rest_length;
-}
-
-void DampedSpringJoint2D::set_stiffness(real_t p_stiffness) {
-	stiffness = p_stiffness;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_STIFFNESS, p_stiffness);
-	}
-}
-
-real_t DampedSpringJoint2D::get_stiffness() const {
-	return stiffness;
-}
-
-void DampedSpringJoint2D::set_damping(real_t p_damping) {
-	damping = p_damping;
-	queue_redraw();
-	if (is_configured()) {
-		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_DAMPING, p_damping);
-	}
-}
-
-real_t DampedSpringJoint2D::get_damping() const {
-	return damping;
-}
-
-void DampedSpringJoint2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_length", "length"), &DampedSpringJoint2D::set_length);
-	ClassDB::bind_method(D_METHOD("get_length"), &DampedSpringJoint2D::get_length);
-	ClassDB::bind_method(D_METHOD("set_rest_length", "rest_length"), &DampedSpringJoint2D::set_rest_length);
-	ClassDB::bind_method(D_METHOD("get_rest_length"), &DampedSpringJoint2D::get_rest_length);
-	ClassDB::bind_method(D_METHOD("set_stiffness", "stiffness"), &DampedSpringJoint2D::set_stiffness);
-	ClassDB::bind_method(D_METHOD("get_stiffness"), &DampedSpringJoint2D::get_stiffness);
-	ClassDB::bind_method(D_METHOD("set_damping", "damping"), &DampedSpringJoint2D::set_damping);
-	ClassDB::bind_method(D_METHOD("get_damping"), &DampedSpringJoint2D::get_damping);
-
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_length", "get_length");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rest_length", PROPERTY_HINT_RANGE, "0,65535,1,exp,suffix:px"), "set_rest_length", "get_rest_length");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "stiffness", PROPERTY_HINT_RANGE, "0.1,64,0.1,exp"), "set_stiffness", "get_stiffness");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping", PROPERTY_HINT_RANGE, "0.01,16,0.01,exp"), "set_damping", "get_damping");
-}
-
-DampedSpringJoint2D::DampedSpringJoint2D() {
-}
diff --git a/scene/2d/joint_2d.h b/scene/2d/joint_2d.h
deleted file mode 100644
index 5ff75a77a1..0000000000
--- a/scene/2d/joint_2d.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/**************************************************************************/
-/*  joint_2d.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_2D_H
-#define JOINT_2D_H
-
-#include "node_2d.h"
-
-class PhysicsBody2D;
-
-class Joint2D : public Node2D {
-	GDCLASS(Joint2D, Node2D);
-
-	RID joint;
-	RID ba, bb;
-
-	NodePath a;
-	NodePath b;
-	real_t bias = 0.0;
-
-	bool exclude_from_collision = true;
-	bool configured = false;
-	String warning;
-
-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, PhysicsBody2D *body_a, PhysicsBody2D *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_bias(real_t p_bias);
-	real_t get_bias() const;
-
-	void set_exclude_nodes_from_collision(bool p_enable);
-	bool get_exclude_nodes_from_collision() const;
-
-	RID get_rid() const { return joint; }
-	Joint2D();
-	~Joint2D();
-};
-
-class PinJoint2D : public Joint2D {
-	GDCLASS(PinJoint2D, Joint2D);
-
-	real_t softness = 0.0;
-	real_t angular_limit_lower = 0.0;
-	real_t angular_limit_upper = 0.0;
-	real_t motor_target_velocity = 0.0;
-	bool motor_enabled = false;
-	bool angular_limit_enabled = false;
-
-protected:
-	void _notification(int p_what);
-	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
-	static void _bind_methods();
-
-public:
-	void set_softness(real_t p_softness);
-	real_t get_softness() const;
-	void set_angular_limit_lower(real_t p_angular_limit_lower);
-	real_t get_angular_limit_lower() const;
-	void set_angular_limit_upper(real_t p_angular_limit_upper);
-	real_t get_angular_limit_upper() const;
-	void set_motor_target_velocity(real_t p_motor_target_velocity);
-	real_t get_motor_target_velocity() const;
-
-	void set_motor_enabled(bool p_motor_enabled);
-	bool is_motor_enabled() const;
-	void set_angular_limit_enabled(bool p_angular_limit_enabled);
-	bool is_angular_limit_enabled() const;
-
-	PinJoint2D();
-};
-
-class GrooveJoint2D : public Joint2D {
-	GDCLASS(GrooveJoint2D, Joint2D);
-
-	real_t length = 50.0;
-	real_t initial_offset = 25.0;
-
-protected:
-	void _notification(int p_what);
-	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
-	static void _bind_methods();
-
-public:
-	void set_length(real_t p_length);
-	real_t get_length() const;
-
-	void set_initial_offset(real_t p_initial_offset);
-	real_t get_initial_offset() const;
-
-	GrooveJoint2D();
-};
-
-class DampedSpringJoint2D : public Joint2D {
-	GDCLASS(DampedSpringJoint2D, Joint2D);
-
-	real_t stiffness = 20.0;
-	real_t damping = 1.0;
-	real_t rest_length = 0.0;
-	real_t length = 50.0;
-
-protected:
-	void _notification(int p_what);
-	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
-	static void _bind_methods();
-
-public:
-	void set_length(real_t p_length);
-	real_t get_length() const;
-
-	void set_rest_length(real_t p_rest_length);
-	real_t get_rest_length() const;
-
-	void set_damping(real_t p_damping);
-	real_t get_damping() const;
-
-	void set_stiffness(real_t p_stiffness);
-	real_t get_stiffness() const;
-
-	DampedSpringJoint2D();
-};
-
-#endif // JOINT_2D_H
diff --git a/scene/2d/physics/SCsub b/scene/2d/physics/SCsub
new file mode 100644
index 0000000000..e7fd3fe643
--- /dev/null
+++ b/scene/2d/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/2d/physics/animatable_body_2d.cpp b/scene/2d/physics/animatable_body_2d.cpp
new file mode 100644
index 0000000000..10e90e708b
--- /dev/null
+++ b/scene/2d/physics/animatable_body_2d.cpp
@@ -0,0 +1,111 @@
+/**************************************************************************/
+/*  animatable_body_2d.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_2d.h"
+
+void AnimatableBody2D::set_sync_to_physics(bool p_enable) {
+	if (sync_to_physics == p_enable) {
+		return;
+	}
+
+	sync_to_physics = p_enable;
+
+	_update_kinematic_motion();
+}
+
+bool AnimatableBody2D::is_sync_to_physics_enabled() const {
+	return sync_to_physics;
+}
+
+void AnimatableBody2D::_update_kinematic_motion() {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+#endif
+
+	if (sync_to_physics) {
+		PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &AnimatableBody2D::_body_state_changed));
+		set_only_update_transform_changes(true);
+		set_notify_local_transform(true);
+	} else {
+		PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), Callable());
+		set_only_update_transform_changes(false);
+		set_notify_local_transform(false);
+	}
+}
+
+void AnimatableBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state) {
+	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);
+}
+
+void AnimatableBody2D::_notification(int p_what) {
+	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...
+			Transform2D new_transform = get_global_transform();
+
+			PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::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);
+		} break;
+	}
+}
+
+void AnimatableBody2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_sync_to_physics", "enable"), &AnimatableBody2D::set_sync_to_physics);
+	ClassDB::bind_method(D_METHOD("is_sync_to_physics_enabled"), &AnimatableBody2D::is_sync_to_physics_enabled);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync_to_physics"), "set_sync_to_physics", "is_sync_to_physics_enabled");
+}
+
+AnimatableBody2D::AnimatableBody2D() :
+		StaticBody2D(PhysicsServer2D::BODY_MODE_KINEMATIC) {
+}
diff --git a/scene/2d/physics/animatable_body_2d.h b/scene/2d/physics/animatable_body_2d.h
new file mode 100644
index 0000000000..e510d5cc9c
--- /dev/null
+++ b/scene/2d/physics/animatable_body_2d.h
@@ -0,0 +1,61 @@
+/**************************************************************************/
+/*  animatable_body_2d.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_2D_H
+#define ANIMATABLE_BODY_2D_H
+
+#include "scene/2d/physics/static_body_2d.h"
+
+class AnimatableBody2D : public StaticBody2D {
+	GDCLASS(AnimatableBody2D, StaticBody2D);
+
+private:
+	bool sync_to_physics = true;
+
+	Transform2D last_valid_transform;
+
+	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState2D *p_state);
+	void _body_state_changed(PhysicsDirectBodyState2D *p_state);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	AnimatableBody2D();
+
+private:
+	void _update_kinematic_motion();
+
+	void set_sync_to_physics(bool p_enable);
+	bool is_sync_to_physics_enabled() const;
+};
+
+#endif // ANIMATABLE_BODY_2D_H
diff --git a/scene/2d/area_2d.cpp b/scene/2d/physics/area_2d.cpp
index b1ff94dda4..b1ff94dda4 100644
--- a/scene/2d/area_2d.cpp
+++ b/scene/2d/physics/area_2d.cpp
diff --git a/scene/2d/area_2d.h b/scene/2d/physics/area_2d.h
index 9d6e04b706..7c59d76e00 100644
--- a/scene/2d/area_2d.h
+++ b/scene/2d/physics/area_2d.h
@@ -32,7 +32,7 @@
 #define AREA_2D_H
 
 #include "core/templates/vset.h"
-#include "scene/2d/collision_object_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
 
 class Area2D : public CollisionObject2D {
 	GDCLASS(Area2D, CollisionObject2D);
diff --git a/scene/2d/physics/character_body_2d.cpp b/scene/2d/physics/character_body_2d.cpp
new file mode 100644
index 0000000000..e5d575a159
--- /dev/null
+++ b/scene/2d/physics/character_body_2d.cpp
@@ -0,0 +1,755 @@
+/**************************************************************************/
+/*  character_body_2d.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_2d.h"
+
+// So, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
+#define FLOOR_ANGLE_THRESHOLD 0.01
+
+bool CharacterBody2D::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();
+
+	Vector2 current_platform_velocity = platform_velocity;
+	Transform2D gt = get_global_transform();
+	previous_position = gt.columns[2];
+
+	if ((on_floor || on_wall) && platform_rid.is_valid()) {
+		bool excluded = false;
+		if (on_floor) {
+			excluded = (platform_floor_layers & platform_layer) == 0;
+		} else if (on_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
+			PhysicsDirectBodyState2D *bs = PhysicsServer2D::get_singleton()->body_get_direct_state(platform_rid);
+			if (bs) {
+				Vector2 local_position = gt.columns[2] - bs->get_transform().columns[2];
+				current_platform_velocity = bs->get_velocity_at_local_position(local_position);
+			} else {
+				// Body is removed or destroyed, invalidate floor.
+				current_platform_velocity = Vector2();
+				platform_rid = RID();
+			}
+		} else {
+			current_platform_velocity = Vector2();
+		}
+	}
+
+	motion_results.clear();
+	last_motion = Vector2();
+
+	bool was_on_floor = on_floor;
+	on_floor = false;
+	on_ceiling = false;
+	on_wall = false;
+
+	if (!current_platform_velocity.is_zero_approx()) {
+		PhysicsServer2D::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);
+		}
+
+		PhysicsServer2D::MotionResult floor_result;
+		if (move_and_collide(parameters, floor_result, false, false)) {
+			motion_results.push_back(floor_result);
+			_set_collision_direction(floor_result);
+		}
+	}
+
+	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 (!on_floor && !on_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 CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_floor) {
+	Vector2 motion = velocity * p_delta;
+	Vector2 motion_slide_up = motion.slide(up_direction);
+
+	Vector2 prev_floor_normal = floor_normal;
+
+	platform_rid = RID();
+	platform_object_id = ObjectID();
+	floor_normal = Vector2();
+	platform_velocity = Vector2();
+
+	// 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;
+	Vector2 last_travel;
+
+	for (int iteration = 0; iteration < max_slides; ++iteration) {
+		PhysicsServer2D::MotionParameters parameters(get_global_transform(), motion, margin);
+		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+
+		Vector2 prev_position = parameters.from.columns[2];
+
+		PhysicsServer2D::MotionResult result;
+		bool collided = move_and_collide(parameters, result, false, !sliding_enabled);
+
+		last_motion = result.travel;
+
+		if (collided) {
+			motion_results.push_back(result);
+			_set_collision_direction(result);
+
+			// If we hit a ceiling platform, we set the vertical velocity to at least the platform one.
+			if (on_ceiling && result.collider_velocity != Vector2() && result.collider_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 || (result.collision_normal + up_direction).length() < 0.01) {
+					apply_ceiling_velocity = true;
+					Vector2 ceiling_vertical_velocity = up_direction * up_direction.dot(result.collider_velocity);
+					Vector2 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 (on_floor && floor_stop_on_slope && (velocity.normalized() + up_direction).length() < 0.01) {
+				Transform2D gt = get_global_transform();
+				if (result.travel.length() <= margin + CMP_EPSILON) {
+					gt.columns[2] -= result.travel;
+				}
+				set_global_transform(gt);
+				velocity = Vector2();
+				last_motion = Vector2();
+				motion = Vector2();
+				break;
+			}
+
+			if (result.remainder.is_zero_approx()) {
+				motion = Vector2();
+				break;
+			}
+
+			// Move on floor only checks.
+			if (floor_block_on_wall && on_wall && motion_slide_up.dot(result.collision_normal) <= 0) {
+				// Avoid to move forward on a wall if floor_block_on_wall is true.
+				if (p_was_on_floor && !on_floor && !vel_dir_facing_up) {
+					// If the movement is large the body can be prevented from reaching the walls.
+					if (result.travel.length() <= margin + CMP_EPSILON) {
+						// Cancels the motion.
+						Transform2D gt = get_global_transform();
+						gt.columns[2] -= result.travel;
+						set_global_transform(gt);
+					}
+					// Determines if you are on the ground.
+					_snap_on_floor(true, false, true);
+					velocity = Vector2();
+					last_motion = Vector2();
+					motion = Vector2();
+					break;
+				}
+				// Prevents the body from being able to climb a slope when it moves forward against the wall.
+				else if (!on_floor) {
+					motion = up_direction * up_direction.dot(result.remainder);
+					motion = motion.slide(result.collision_normal);
+				} else {
+					motion = result.remainder;
+				}
+			}
+			// Constant Speed when the slope is upward.
+			else if (floor_constant_speed && is_on_floor_only() && can_apply_constant_speed && p_was_on_floor && motion.dot(result.collision_normal) < 0) {
+				can_apply_constant_speed = false;
+				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
+				motion = motion_slide_norm * (motion_slide_up.length() - result.travel.slide(up_direction).length() - last_travel.slide(up_direction).length());
+			}
+			// Regular sliding, the last part of the test handle the case when you don't want to slide on the ceiling.
+			else if ((sliding_enabled || !on_floor) && (!on_ceiling || slide_on_ceiling || !vel_dir_facing_up) && !apply_ceiling_velocity) {
+				Vector2 slide_motion = result.remainder.slide(result.collision_normal);
+				if (slide_motion.dot(velocity) > 0.0) {
+					motion = slide_motion;
+				} else {
+					motion = Vector2();
+				}
+				if (slide_on_ceiling && on_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(result.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 (on_ceiling && !slide_on_ceiling && vel_dir_facing_up) {
+					velocity = velocity.slide(up_direction);
+					motion = motion.slide(up_direction);
+				}
+			}
+
+			last_travel = result.travel;
+		}
+		// 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;
+			Transform2D gt = get_global_transform();
+			gt.columns[2] = prev_position;
+			set_global_transform(gt);
+
+			Vector2 motion_slide_norm = motion.slide(prev_floor_normal).normalized();
+			motion = motion_slide_norm * (motion_slide_up.length());
+			collided = true;
+		}
+
+		can_apply_constant_speed = !can_apply_constant_speed && !sliding_enabled;
+		sliding_enabled = true;
+		first_slide = false;
+
+		if (!collided || motion.is_zero_approx()) {
+			break;
+		}
+	}
+
+	_snap_on_floor(p_was_on_floor, vel_dir_facing_up);
+
+	// Scales the horizontal velocity according to the wall slope.
+	if (is_on_wall_only() && motion_slide_up.dot(motion_results.get(0).collision_normal) < 0) {
+		Vector2 slide_motion = velocity.slide(motion_results.get(0).collision_normal);
+		if (motion_slide_up.dot(slide_motion) < 0) {
+			velocity = up_direction * up_direction.dot(velocity);
+		} else {
+			// 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);
+		}
+	}
+
+	// Reset the gravity accumulation when touching the ground.
+	if (on_floor && !vel_dir_facing_up) {
+		velocity = velocity.slide(up_direction);
+	}
+}
+
+void CharacterBody2D::_move_and_slide_floating(double p_delta) {
+	Vector2 motion = velocity * p_delta;
+
+	platform_rid = RID();
+	platform_object_id = ObjectID();
+	floor_normal = Vector2();
+	platform_velocity = Vector2();
+
+	bool first_slide = true;
+	for (int iteration = 0; iteration < max_slides; ++iteration) {
+		PhysicsServer2D::MotionParameters parameters(get_global_transform(), motion, margin);
+		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+
+		PhysicsServer2D::MotionResult result;
+		bool collided = move_and_collide(parameters, result, false, false);
+
+		last_motion = result.travel;
+
+		if (collided) {
+			motion_results.push_back(result);
+			_set_collision_direction(result);
+
+			if (result.remainder.is_zero_approx()) {
+				motion = Vector2();
+				break;
+			}
+
+			if (wall_min_slide_angle != 0 && result.get_angle(-velocity.normalized()) < wall_min_slide_angle + FLOOR_ANGLE_THRESHOLD) {
+				motion = Vector2();
+			} else if (first_slide) {
+				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
+				motion = motion_slide_norm * (motion.length() - result.travel.length());
+			} else {
+				motion = result.remainder.slide(result.collision_normal);
+			}
+
+			if (motion.dot(velocity) <= 0.0) {
+				motion = Vector2();
+			}
+		}
+
+		if (!collided || motion.is_zero_approx()) {
+			break;
+		}
+
+		first_slide = false;
+	}
+}
+void CharacterBody2D::apply_floor_snap() {
+	_apply_floor_snap();
+}
+
+// Method that avoids the p_wall_as_floor parameter for the public method.
+void CharacterBody2D::_apply_floor_snap(bool p_wall_as_floor) {
+	if (on_floor) {
+		return;
+	}
+
+	// Snap by at least collision margin to keep floor state consistent.
+	real_t length = MAX(floor_snap_length, margin);
+
+	PhysicsServer2D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
+	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+	parameters.collide_separation_ray = true;
+
+	PhysicsServer2D::MotionResult result;
+	if (move_and_collide(parameters, result, true, false)) {
+		if ((result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) ||
+				(p_wall_as_floor && result.get_angle(-up_direction) > floor_max_angle + FLOOR_ANGLE_THRESHOLD)) {
+			on_floor = true;
+			floor_normal = result.collision_normal;
+			_set_platform_data(result);
+
+			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 = Vector2();
+				}
+			}
+
+			parameters.from.columns[2] += result.travel;
+			set_global_transform(parameters.from);
+		}
+	}
+}
+
+void CharacterBody2D::_snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up, bool p_wall_as_floor) {
+	if (on_floor || !p_was_on_floor || p_vel_dir_facing_up) {
+		return;
+	}
+
+	_apply_floor_snap(p_wall_as_floor);
+}
+
+bool CharacterBody2D::_on_floor_if_snapped(bool p_was_on_floor, bool p_vel_dir_facing_up) {
+	if (up_direction == Vector2() || on_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);
+
+	PhysicsServer2D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
+	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
+	parameters.collide_separation_ray = true;
+
+	PhysicsServer2D::MotionResult result;
+	if (move_and_collide(parameters, result, true, false)) {
+		if (result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void CharacterBody2D::_set_collision_direction(const PhysicsServer2D::MotionResult &p_result) {
+	if (motion_mode == MOTION_MODE_GROUNDED && p_result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
+		on_floor = true;
+		floor_normal = p_result.collision_normal;
+		_set_platform_data(p_result);
+	} else if (motion_mode == MOTION_MODE_GROUNDED && p_result.get_angle(-up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
+		on_ceiling = true;
+	} else {
+		on_wall = true;
+		wall_normal = p_result.collision_normal;
+		// Don't apply wall velocity when the collider is a CharacterBody2D.
+		if (Object::cast_to<CharacterBody2D>(ObjectDB::get_instance(p_result.collider_id)) == nullptr) {
+			_set_platform_data(p_result);
+		}
+	}
+}
+
+void CharacterBody2D::_set_platform_data(const PhysicsServer2D::MotionResult &p_result) {
+	platform_rid = p_result.collider;
+	platform_object_id = p_result.collider_id;
+	platform_velocity = p_result.collider_velocity;
+	platform_layer = PhysicsServer2D::get_singleton()->body_get_collision_layer(platform_rid);
+}
+
+const Vector2 &CharacterBody2D::get_velocity() const {
+	return velocity;
+}
+
+void CharacterBody2D::set_velocity(const Vector2 &p_velocity) {
+	velocity = p_velocity;
+}
+
+bool CharacterBody2D::is_on_floor() const {
+	return on_floor;
+}
+
+bool CharacterBody2D::is_on_floor_only() const {
+	return on_floor && !on_wall && !on_ceiling;
+}
+
+bool CharacterBody2D::is_on_wall() const {
+	return on_wall;
+}
+
+bool CharacterBody2D::is_on_wall_only() const {
+	return on_wall && !on_floor && !on_ceiling;
+}
+
+bool CharacterBody2D::is_on_ceiling() const {
+	return on_ceiling;
+}
+
+bool CharacterBody2D::is_on_ceiling_only() const {
+	return on_ceiling && !on_floor && !on_wall;
+}
+
+const Vector2 &CharacterBody2D::get_floor_normal() const {
+	return floor_normal;
+}
+
+const Vector2 &CharacterBody2D::get_wall_normal() const {
+	return wall_normal;
+}
+
+const Vector2 &CharacterBody2D::get_last_motion() const {
+	return last_motion;
+}
+
+Vector2 CharacterBody2D::get_position_delta() const {
+	return get_global_transform().columns[2] - previous_position;
+}
+
+const Vector2 &CharacterBody2D::get_real_velocity() const {
+	return real_velocity;
+}
+
+real_t CharacterBody2D::get_floor_angle(const Vector2 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
+	return Math::acos(floor_normal.dot(p_up_direction));
+}
+
+const Vector2 &CharacterBody2D::get_platform_velocity() const {
+	return platform_velocity;
+}
+
+int CharacterBody2D::get_slide_collision_count() const {
+	return motion_results.size();
+}
+
+PhysicsServer2D::MotionResult CharacterBody2D::get_slide_collision(int p_bounce) const {
+	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), PhysicsServer2D::MotionResult());
+	return motion_results[p_bounce];
+}
+
+Ref<KinematicCollision2D> CharacterBody2D::_get_slide_collision(int p_bounce) {
+	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), Ref<KinematicCollision2D>());
+	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<KinematicCollision2D> CharacterBody2D::_get_last_slide_collision() {
+	if (motion_results.size() == 0) {
+		return Ref<KinematicCollision2D>();
+	}
+	return _get_slide_collision(motion_results.size() - 1);
+}
+
+void CharacterBody2D::set_safe_margin(real_t p_margin) {
+	margin = p_margin;
+}
+
+real_t CharacterBody2D::get_safe_margin() const {
+	return margin;
+}
+
+bool CharacterBody2D::is_floor_stop_on_slope_enabled() const {
+	return floor_stop_on_slope;
+}
+
+void CharacterBody2D::set_floor_stop_on_slope_enabled(bool p_enabled) {
+	floor_stop_on_slope = p_enabled;
+}
+
+bool CharacterBody2D::is_floor_constant_speed_enabled() const {
+	return floor_constant_speed;
+}
+
+void CharacterBody2D::set_floor_constant_speed_enabled(bool p_enabled) {
+	floor_constant_speed = p_enabled;
+}
+
+bool CharacterBody2D::is_floor_block_on_wall_enabled() const {
+	return floor_block_on_wall;
+}
+
+void CharacterBody2D::set_floor_block_on_wall_enabled(bool p_enabled) {
+	floor_block_on_wall = p_enabled;
+}
+
+bool CharacterBody2D::is_slide_on_ceiling_enabled() const {
+	return slide_on_ceiling;
+}
+
+void CharacterBody2D::set_slide_on_ceiling_enabled(bool p_enabled) {
+	slide_on_ceiling = p_enabled;
+}
+
+uint32_t CharacterBody2D::get_platform_floor_layers() const {
+	return platform_floor_layers;
+}
+
+void CharacterBody2D::set_platform_floor_layers(uint32_t p_exclude_layers) {
+	platform_floor_layers = p_exclude_layers;
+}
+
+uint32_t CharacterBody2D::get_platform_wall_layers() const {
+	return platform_wall_layers;
+}
+
+void CharacterBody2D::set_platform_wall_layers(uint32_t p_exclude_layers) {
+	platform_wall_layers = p_exclude_layers;
+}
+
+void CharacterBody2D::set_motion_mode(MotionMode p_mode) {
+	motion_mode = p_mode;
+}
+
+CharacterBody2D::MotionMode CharacterBody2D::get_motion_mode() const {
+	return motion_mode;
+}
+
+void CharacterBody2D::set_platform_on_leave(PlatformOnLeave p_on_leave_apply_velocity) {
+	platform_on_leave = p_on_leave_apply_velocity;
+}
+
+CharacterBody2D::PlatformOnLeave CharacterBody2D::get_platform_on_leave() const {
+	return platform_on_leave;
+}
+
+int CharacterBody2D::get_max_slides() const {
+	return max_slides;
+}
+
+void CharacterBody2D::set_max_slides(int p_max_slides) {
+	ERR_FAIL_COND(p_max_slides < 1);
+	max_slides = p_max_slides;
+}
+
+real_t CharacterBody2D::get_floor_max_angle() const {
+	return floor_max_angle;
+}
+
+void CharacterBody2D::set_floor_max_angle(real_t p_radians) {
+	floor_max_angle = p_radians;
+}
+
+real_t CharacterBody2D::get_floor_snap_length() {
+	return floor_snap_length;
+}
+
+void CharacterBody2D::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 CharacterBody2D::get_wall_min_slide_angle() const {
+	return wall_min_slide_angle;
+}
+
+void CharacterBody2D::set_wall_min_slide_angle(real_t p_radians) {
+	wall_min_slide_angle = p_radians;
+}
+
+const Vector2 &CharacterBody2D::get_up_direction() const {
+	return up_direction;
+}
+
+void CharacterBody2D::set_up_direction(const Vector2 &p_up_direction) {
+	ERR_FAIL_COND_MSG(p_up_direction == Vector2(), "up_direction can't be equal to Vector2.ZERO, consider using Floating motion mode instead.");
+	up_direction = p_up_direction.normalized();
+}
+
+void CharacterBody2D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			// Reset move_and_slide() data.
+			on_floor = false;
+			platform_rid = RID();
+			platform_object_id = ObjectID();
+			on_ceiling = false;
+			on_wall = false;
+			motion_results.clear();
+			platform_velocity = Vector2();
+		} break;
+	}
+}
+
+void CharacterBody2D::_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;
+		}
+	} else {
+		if (p_property.name == "wall_min_slide_angle") {
+			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	}
+}
+
+void CharacterBody2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("move_and_slide"), &CharacterBody2D::move_and_slide);
+	ClassDB::bind_method(D_METHOD("apply_floor_snap"), &CharacterBody2D::apply_floor_snap);
+
+	ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &CharacterBody2D::set_velocity);
+	ClassDB::bind_method(D_METHOD("get_velocity"), &CharacterBody2D::get_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_safe_margin", "margin"), &CharacterBody2D::set_safe_margin);
+	ClassDB::bind_method(D_METHOD("get_safe_margin"), &CharacterBody2D::get_safe_margin);
+	ClassDB::bind_method(D_METHOD("is_floor_stop_on_slope_enabled"), &CharacterBody2D::is_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_stop_on_slope_enabled", "enabled"), &CharacterBody2D::set_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_constant_speed_enabled", "enabled"), &CharacterBody2D::set_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_constant_speed_enabled"), &CharacterBody2D::is_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_block_on_wall_enabled", "enabled"), &CharacterBody2D::set_floor_block_on_wall_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_block_on_wall_enabled"), &CharacterBody2D::is_floor_block_on_wall_enabled);
+	ClassDB::bind_method(D_METHOD("set_slide_on_ceiling_enabled", "enabled"), &CharacterBody2D::set_slide_on_ceiling_enabled);
+	ClassDB::bind_method(D_METHOD("is_slide_on_ceiling_enabled"), &CharacterBody2D::is_slide_on_ceiling_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_platform_floor_layers", "exclude_layer"), &CharacterBody2D::set_platform_floor_layers);
+	ClassDB::bind_method(D_METHOD("get_platform_floor_layers"), &CharacterBody2D::get_platform_floor_layers);
+	ClassDB::bind_method(D_METHOD("set_platform_wall_layers", "exclude_layer"), &CharacterBody2D::set_platform_wall_layers);
+	ClassDB::bind_method(D_METHOD("get_platform_wall_layers"), &CharacterBody2D::get_platform_wall_layers);
+
+	ClassDB::bind_method(D_METHOD("get_max_slides"), &CharacterBody2D::get_max_slides);
+	ClassDB::bind_method(D_METHOD("set_max_slides", "max_slides"), &CharacterBody2D::set_max_slides);
+	ClassDB::bind_method(D_METHOD("get_floor_max_angle"), &CharacterBody2D::get_floor_max_angle);
+	ClassDB::bind_method(D_METHOD("set_floor_max_angle", "radians"), &CharacterBody2D::set_floor_max_angle);
+	ClassDB::bind_method(D_METHOD("get_floor_snap_length"), &CharacterBody2D::get_floor_snap_length);
+	ClassDB::bind_method(D_METHOD("set_floor_snap_length", "floor_snap_length"), &CharacterBody2D::set_floor_snap_length);
+	ClassDB::bind_method(D_METHOD("get_wall_min_slide_angle"), &CharacterBody2D::get_wall_min_slide_angle);
+	ClassDB::bind_method(D_METHOD("set_wall_min_slide_angle", "radians"), &CharacterBody2D::set_wall_min_slide_angle);
+	ClassDB::bind_method(D_METHOD("get_up_direction"), &CharacterBody2D::get_up_direction);
+	ClassDB::bind_method(D_METHOD("set_up_direction", "up_direction"), &CharacterBody2D::set_up_direction);
+	ClassDB::bind_method(D_METHOD("set_motion_mode", "mode"), &CharacterBody2D::set_motion_mode);
+	ClassDB::bind_method(D_METHOD("get_motion_mode"), &CharacterBody2D::get_motion_mode);
+	ClassDB::bind_method(D_METHOD("set_platform_on_leave", "on_leave_apply_velocity"), &CharacterBody2D::set_platform_on_leave);
+	ClassDB::bind_method(D_METHOD("get_platform_on_leave"), &CharacterBody2D::get_platform_on_leave);
+
+	ClassDB::bind_method(D_METHOD("is_on_floor"), &CharacterBody2D::is_on_floor);
+	ClassDB::bind_method(D_METHOD("is_on_floor_only"), &CharacterBody2D::is_on_floor_only);
+	ClassDB::bind_method(D_METHOD("is_on_ceiling"), &CharacterBody2D::is_on_ceiling);
+	ClassDB::bind_method(D_METHOD("is_on_ceiling_only"), &CharacterBody2D::is_on_ceiling_only);
+	ClassDB::bind_method(D_METHOD("is_on_wall"), &CharacterBody2D::is_on_wall);
+	ClassDB::bind_method(D_METHOD("is_on_wall_only"), &CharacterBody2D::is_on_wall_only);
+	ClassDB::bind_method(D_METHOD("get_floor_normal"), &CharacterBody2D::get_floor_normal);
+	ClassDB::bind_method(D_METHOD("get_wall_normal"), &CharacterBody2D::get_wall_normal);
+	ClassDB::bind_method(D_METHOD("get_last_motion"), &CharacterBody2D::get_last_motion);
+	ClassDB::bind_method(D_METHOD("get_position_delta"), &CharacterBody2D::get_position_delta);
+	ClassDB::bind_method(D_METHOD("get_real_velocity"), &CharacterBody2D::get_real_velocity);
+	ClassDB::bind_method(D_METHOD("get_floor_angle", "up_direction"), &CharacterBody2D::get_floor_angle, DEFVAL(Vector2(0.0, -1.0)));
+	ClassDB::bind_method(D_METHOD("get_platform_velocity"), &CharacterBody2D::get_platform_velocity);
+	ClassDB::bind_method(D_METHOD("get_slide_collision_count"), &CharacterBody2D::get_slide_collision_count);
+	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &CharacterBody2D::_get_slide_collision);
+	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody2D::_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::VECTOR2, "up_direction"), "set_up_direction", "get_up_direction");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "velocity", PROPERTY_HINT_NONE, "suffix:px/s", PROPERTY_USAGE_NO_EDITOR), "set_velocity", "get_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_ceiling"), "set_slide_on_ceiling_enabled", "is_slide_on_ceiling_enabled");
+	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,32,0.1,or_greater,suffix:px"), "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_2D_PHYSICS), "set_platform_floor_layers", "get_platform_floor_layers");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "platform_wall_layers", PROPERTY_HINT_LAYERS_2D_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:px"), "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);
+}
+
+CharacterBody2D::CharacterBody2D() :
+		PhysicsBody2D(PhysicsServer2D::BODY_MODE_KINEMATIC) {
+}
+
+CharacterBody2D::~CharacterBody2D() {
+	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/2d/physics/character_body_2d.h b/scene/2d/physics/character_body_2d.h
new file mode 100644
index 0000000000..395438a1f1
--- /dev/null
+++ b/scene/2d/physics/character_body_2d.h
@@ -0,0 +1,173 @@
+/**************************************************************************/
+/*  character_body_2d.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_2D_H
+#define CHARACTER_BODY_2D_H
+
+#include "scene/2d/physics/kinematic_collision_2d.h"
+#include "scene/2d/physics/physics_body_2d.h"
+
+class CharacterBody2D : public PhysicsBody2D {
+	GDCLASS(CharacterBody2D, PhysicsBody2D);
+
+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 Vector2 &get_velocity() const;
+	void set_velocity(const Vector2 &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 Vector2 &get_last_motion() const;
+	Vector2 get_position_delta() const;
+	const Vector2 &get_floor_normal() const;
+	const Vector2 &get_wall_normal() const;
+	const Vector2 &get_real_velocity() const;
+
+	real_t get_floor_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
+	const Vector2 &get_platform_velocity() const;
+
+	int get_slide_collision_count() const;
+	PhysicsServer2D::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;
+
+	CharacterBody2D();
+	~CharacterBody2D();
+
+private:
+	real_t margin = 0.08;
+	MotionMode motion_mode = MOTION_MODE_GROUNDED;
+	PlatformOnLeave platform_on_leave = PLATFORM_ON_LEAVE_ADD_VELOCITY;
+
+	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 = 4;
+	int platform_layer = 0;
+	real_t floor_max_angle = Math::deg_to_rad((real_t)45.0);
+	real_t floor_snap_length = 1;
+	real_t wall_min_slide_angle = Math::deg_to_rad((real_t)15.0);
+	Vector2 up_direction = Vector2(0.0, -1.0);
+	uint32_t platform_floor_layers = UINT32_MAX;
+	uint32_t platform_wall_layers = 0;
+	Vector2 velocity;
+
+	Vector2 floor_normal;
+	Vector2 platform_velocity;
+	Vector2 wall_normal;
+	Vector2 last_motion;
+	Vector2 previous_position;
+	Vector2 real_velocity;
+
+	RID platform_rid;
+	ObjectID platform_object_id;
+	bool on_floor = false;
+	bool on_ceiling = false;
+	bool on_wall = false;
+
+	Vector<PhysicsServer2D::MotionResult> motion_results;
+	Vector<Ref<KinematicCollision2D>> slide_colliders;
+
+	void _move_and_slide_floating(double p_delta);
+	void _move_and_slide_grounded(double p_delta, bool p_was_on_floor);
+
+	Ref<KinematicCollision2D> _get_slide_collision(int p_bounce);
+	Ref<KinematicCollision2D> _get_last_slide_collision();
+	const Vector2 &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 Vector2 &p_up_direction);
+	void _set_collision_direction(const PhysicsServer2D::MotionResult &p_result);
+	void _set_platform_data(const PhysicsServer2D::MotionResult &p_result);
+	void _apply_floor_snap(bool p_wall_as_floor = false);
+	void _snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up, bool p_wall_as_floor = false);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+	void _validate_property(PropertyInfo &p_property) const;
+};
+
+VARIANT_ENUM_CAST(CharacterBody2D::MotionMode);
+VARIANT_ENUM_CAST(CharacterBody2D::PlatformOnLeave);
+
+#endif // CHARACTER_BODY_2D_H
diff --git a/scene/2d/collision_object_2d.cpp b/scene/2d/physics/collision_object_2d.cpp
index 4e5852984b..4e5852984b 100644
--- a/scene/2d/collision_object_2d.cpp
+++ b/scene/2d/physics/collision_object_2d.cpp
diff --git a/scene/2d/collision_object_2d.h b/scene/2d/physics/collision_object_2d.h
index 2c8534665c..2c8534665c 100644
--- a/scene/2d/collision_object_2d.h
+++ b/scene/2d/physics/collision_object_2d.h
diff --git a/scene/2d/collision_polygon_2d.cpp b/scene/2d/physics/collision_polygon_2d.cpp
index 3bc5bce8f0..96ef346d23 100644
--- a/scene/2d/collision_polygon_2d.cpp
+++ b/scene/2d/physics/collision_polygon_2d.cpp
@@ -30,9 +30,9 @@
 
 #include "collision_polygon_2d.h"
 
-#include "collision_object_2d.h"
 #include "core/math/geometry_2d.h"
-#include "scene/2d/area_2d.h"
+#include "scene/2d/physics/area_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
 #include "scene/resources/2d/concave_polygon_shape_2d.h"
 #include "scene/resources/2d/convex_polygon_shape_2d.h"
 
diff --git a/scene/2d/collision_polygon_2d.h b/scene/2d/physics/collision_polygon_2d.h
index f1ee30babe..f1ee30babe 100644
--- a/scene/2d/collision_polygon_2d.h
+++ b/scene/2d/physics/collision_polygon_2d.h
diff --git a/scene/2d/collision_shape_2d.cpp b/scene/2d/physics/collision_shape_2d.cpp
index 5539e49135..6fc29ffe63 100644
--- a/scene/2d/collision_shape_2d.cpp
+++ b/scene/2d/physics/collision_shape_2d.cpp
@@ -30,8 +30,8 @@
 
 #include "collision_shape_2d.h"
 
-#include "collision_object_2d.h"
-#include "scene/2d/area_2d.h"
+#include "scene/2d/physics/area_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
 #include "scene/resources/2d/concave_polygon_shape_2d.h"
 #include "scene/resources/2d/convex_polygon_shape_2d.h"
 
diff --git a/scene/2d/collision_shape_2d.h b/scene/2d/physics/collision_shape_2d.h
index 65436f1539..65436f1539 100644
--- a/scene/2d/collision_shape_2d.h
+++ b/scene/2d/physics/collision_shape_2d.h
diff --git a/scene/2d/physics/joints/SCsub b/scene/2d/physics/joints/SCsub
new file mode 100644
index 0000000000..fc61250247
--- /dev/null
+++ b/scene/2d/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/2d/physics/joints/damped_spring_joint_2d.cpp b/scene/2d/physics/joints/damped_spring_joint_2d.cpp
new file mode 100644
index 0000000000..4b210ec0c7
--- /dev/null
+++ b/scene/2d/physics/joints/damped_spring_joint_2d.cpp
@@ -0,0 +1,128 @@
+/**************************************************************************/
+/*  damped_spring_joint_2d.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 "damped_spring_joint_2d.h"
+
+#include "scene/2d/physics/physics_body_2d.h"
+
+void DampedSpringJoint2D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_DRAW: {
+			if (!is_inside_tree()) {
+				break;
+			}
+
+			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
+				break;
+			}
+
+			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
+		} break;
+	}
+}
+
+void DampedSpringJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
+	Transform2D gt = get_global_transform();
+	Vector2 anchor_A = gt.get_origin();
+	Vector2 anchor_B = gt.xform(Vector2(0, length));
+
+	PhysicsServer2D::get_singleton()->joint_make_damped_spring(p_joint, anchor_A, anchor_B, body_a->get_rid(), body_b->get_rid());
+	if (rest_length) {
+		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_REST_LENGTH, rest_length);
+	}
+	PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_STIFFNESS, stiffness);
+	PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(p_joint, PhysicsServer2D::DAMPED_SPRING_DAMPING, damping);
+}
+
+void DampedSpringJoint2D::set_length(real_t p_length) {
+	length = p_length;
+	queue_redraw();
+}
+
+real_t DampedSpringJoint2D::get_length() const {
+	return length;
+}
+
+void DampedSpringJoint2D::set_rest_length(real_t p_rest_length) {
+	rest_length = p_rest_length;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_REST_LENGTH, p_rest_length ? p_rest_length : length);
+	}
+}
+
+real_t DampedSpringJoint2D::get_rest_length() const {
+	return rest_length;
+}
+
+void DampedSpringJoint2D::set_stiffness(real_t p_stiffness) {
+	stiffness = p_stiffness;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_STIFFNESS, p_stiffness);
+	}
+}
+
+real_t DampedSpringJoint2D::get_stiffness() const {
+	return stiffness;
+}
+
+void DampedSpringJoint2D::set_damping(real_t p_damping) {
+	damping = p_damping;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->damped_spring_joint_set_param(get_rid(), PhysicsServer2D::DAMPED_SPRING_DAMPING, p_damping);
+	}
+}
+
+real_t DampedSpringJoint2D::get_damping() const {
+	return damping;
+}
+
+void DampedSpringJoint2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_length", "length"), &DampedSpringJoint2D::set_length);
+	ClassDB::bind_method(D_METHOD("get_length"), &DampedSpringJoint2D::get_length);
+	ClassDB::bind_method(D_METHOD("set_rest_length", "rest_length"), &DampedSpringJoint2D::set_rest_length);
+	ClassDB::bind_method(D_METHOD("get_rest_length"), &DampedSpringJoint2D::get_rest_length);
+	ClassDB::bind_method(D_METHOD("set_stiffness", "stiffness"), &DampedSpringJoint2D::set_stiffness);
+	ClassDB::bind_method(D_METHOD("get_stiffness"), &DampedSpringJoint2D::get_stiffness);
+	ClassDB::bind_method(D_METHOD("set_damping", "damping"), &DampedSpringJoint2D::set_damping);
+	ClassDB::bind_method(D_METHOD("get_damping"), &DampedSpringJoint2D::get_damping);
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_length", "get_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rest_length", PROPERTY_HINT_RANGE, "0,65535,1,exp,suffix:px"), "set_rest_length", "get_rest_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "stiffness", PROPERTY_HINT_RANGE, "0.1,64,0.1,exp"), "set_stiffness", "get_stiffness");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping", PROPERTY_HINT_RANGE, "0.01,16,0.01,exp"), "set_damping", "get_damping");
+}
+
+DampedSpringJoint2D::DampedSpringJoint2D() {
+}
diff --git a/scene/2d/physics/joints/damped_spring_joint_2d.h b/scene/2d/physics/joints/damped_spring_joint_2d.h
new file mode 100644
index 0000000000..de9fda80b9
--- /dev/null
+++ b/scene/2d/physics/joints/damped_spring_joint_2d.h
@@ -0,0 +1,67 @@
+/**************************************************************************/
+/*  damped_spring_joint_2d.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 DAMPED_SPRING_JOINT_2D_H
+#define DAMPED_SPRING_JOINT_2D_H
+
+#include "scene/2d/physics/joints/joint_2d.h"
+
+class PhysicsBody2D;
+
+class DampedSpringJoint2D : public Joint2D {
+	GDCLASS(DampedSpringJoint2D, Joint2D);
+
+	real_t stiffness = 20.0;
+	real_t damping = 1.0;
+	real_t rest_length = 0.0;
+	real_t length = 50.0;
+
+protected:
+	void _notification(int p_what);
+	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_length(real_t p_length);
+	real_t get_length() const;
+
+	void set_rest_length(real_t p_rest_length);
+	real_t get_rest_length() const;
+
+	void set_damping(real_t p_damping);
+	real_t get_damping() const;
+
+	void set_stiffness(real_t p_stiffness);
+	real_t get_stiffness() const;
+
+	DampedSpringJoint2D();
+};
+
+#endif // DAMPED_SPRING_JOINT_2D_H
diff --git a/scene/2d/physics/joints/groove_joint_2d.cpp b/scene/2d/physics/joints/groove_joint_2d.cpp
new file mode 100644
index 0000000000..415a49d8bd
--- /dev/null
+++ b/scene/2d/physics/joints/groove_joint_2d.cpp
@@ -0,0 +1,92 @@
+/**************************************************************************/
+/*  groove_joint_2d.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 "groove_joint_2d.h"
+
+#include "scene/2d/physics/physics_body_2d.h"
+
+void GrooveJoint2D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_DRAW: {
+			if (!is_inside_tree()) {
+				break;
+			}
+
+			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
+				break;
+			}
+
+			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(-10, initial_offset), Point2(+10, initial_offset), Color(0.8, 0.8, 0.9, 0.5), 5);
+		} break;
+	}
+}
+
+void GrooveJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
+	Transform2D gt = get_global_transform();
+	Vector2 groove_A1 = gt.get_origin();
+	Vector2 groove_A2 = gt.xform(Vector2(0, length));
+	Vector2 anchor_B = gt.xform(Vector2(0, initial_offset));
+
+	PhysicsServer2D::get_singleton()->joint_make_groove(p_joint, groove_A1, groove_A2, anchor_B, body_a->get_rid(), body_b->get_rid());
+}
+
+void GrooveJoint2D::set_length(real_t p_length) {
+	length = p_length;
+	queue_redraw();
+}
+
+real_t GrooveJoint2D::get_length() const {
+	return length;
+}
+
+void GrooveJoint2D::set_initial_offset(real_t p_initial_offset) {
+	initial_offset = p_initial_offset;
+	queue_redraw();
+}
+
+real_t GrooveJoint2D::get_initial_offset() const {
+	return initial_offset;
+}
+
+void GrooveJoint2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_length", "length"), &GrooveJoint2D::set_length);
+	ClassDB::bind_method(D_METHOD("get_length"), &GrooveJoint2D::get_length);
+	ClassDB::bind_method(D_METHOD("set_initial_offset", "offset"), &GrooveJoint2D::set_initial_offset);
+	ClassDB::bind_method(D_METHOD("get_initial_offset"), &GrooveJoint2D::get_initial_offset);
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_length", "get_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "initial_offset", PROPERTY_HINT_RANGE, "1,65535,1,exp,suffix:px"), "set_initial_offset", "get_initial_offset");
+}
+
+GrooveJoint2D::GrooveJoint2D() {
+}
diff --git a/scene/2d/physics/joints/groove_joint_2d.h b/scene/2d/physics/joints/groove_joint_2d.h
new file mode 100644
index 0000000000..b04692fbff
--- /dev/null
+++ b/scene/2d/physics/joints/groove_joint_2d.h
@@ -0,0 +1,59 @@
+/**************************************************************************/
+/*  groove_joint_2d.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 GROOVE_JOINT_2D_H
+#define GROOVE_JOINT_2D_H
+
+#include "scene/2d/physics/joints/joint_2d.h"
+
+class PhysicsBody2D;
+
+class GrooveJoint2D : public Joint2D {
+	GDCLASS(GrooveJoint2D, Joint2D);
+
+	real_t length = 50.0;
+	real_t initial_offset = 25.0;
+
+protected:
+	void _notification(int p_what);
+	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_length(real_t p_length);
+	real_t get_length() const;
+
+	void set_initial_offset(real_t p_initial_offset);
+	real_t get_initial_offset() const;
+
+	GrooveJoint2D();
+};
+
+#endif // GROOVE_JOINT_2D_H
diff --git a/scene/2d/physics/joints/joint_2d.cpp b/scene/2d/physics/joints/joint_2d.cpp
new file mode 100644
index 0000000000..dd1697a29c
--- /dev/null
+++ b/scene/2d/physics/joints/joint_2d.cpp
@@ -0,0 +1,254 @@
+/**************************************************************************/
+/*  joint_2d.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_2d.h"
+
+#include "scene/2d/physics/physics_body_2d.h"
+#include "scene/scene_string_names.h"
+
+void Joint2D::_disconnect_signals() {
+	Node *node_a = get_node_or_null(a);
+	PhysicsBody2D *body_a = Object::cast_to<PhysicsBody2D>(node_a);
+	if (body_a) {
+		body_a->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
+	}
+
+	Node *node_b = get_node_or_null(b);
+	PhysicsBody2D *body_b = Object::cast_to<PhysicsBody2D>(node_b);
+	if (body_b) {
+		body_b->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
+	}
+}
+
+void Joint2D::_body_exit_tree() {
+	_disconnect_signals();
+	_update_joint(true);
+	update_configuration_warnings();
+}
+
+void Joint2D::_update_joint(bool p_only_free) {
+	if (ba.is_valid() && bb.is_valid() && exclude_from_collision) {
+		PhysicsServer2D::get_singleton()->joint_disable_collisions_between_bodies(joint, false);
+	}
+
+	ba = RID();
+	bb = RID();
+	configured = false;
+
+	if (p_only_free || !is_inside_tree()) {
+		PhysicsServer2D::get_singleton()->joint_clear(joint);
+		warning = String();
+		return;
+	}
+
+	Node *node_a = get_node_or_null(a);
+	Node *node_b = get_node_or_null(b);
+
+	PhysicsBody2D *body_a = Object::cast_to<PhysicsBody2D>(node_a);
+	PhysicsBody2D *body_b = Object::cast_to<PhysicsBody2D>(node_b);
+
+	bool valid = false;
+
+	if (node_a && !body_a && node_b && !body_b) {
+		warning = RTR("Node A and Node B must be PhysicsBody2Ds");
+	} else if (node_a && !body_a) {
+		warning = RTR("Node A must be a PhysicsBody2D");
+	} else if (node_b && !body_b) {
+		warning = RTR("Node B must be a PhysicsBody2D");
+	} else if (!body_a || !body_b) {
+		warning = RTR("Joint is not connected to two PhysicsBody2Ds");
+	} else if (body_a == body_b) {
+		warning = RTR("Node A and Node B must be different PhysicsBody2Ds");
+	} else {
+		warning = String();
+		valid = true;
+	}
+
+	update_configuration_warnings();
+
+	if (!valid) {
+		PhysicsServer2D::get_singleton()->joint_clear(joint);
+		return;
+	}
+
+	if (body_a) {
+		body_a->force_update_transform();
+	}
+
+	if (body_b) {
+		body_b->force_update_transform();
+	}
+
+	configured = true;
+
+	_configure_joint(joint, body_a, body_b);
+
+	ERR_FAIL_COND_MSG(!joint.is_valid(), "Failed to configure the joint.");
+
+	PhysicsServer2D::get_singleton()->joint_set_param(joint, PhysicsServer2D::JOINT_PARAM_BIAS, bias);
+
+	ba = body_a->get_rid();
+	bb = body_b->get_rid();
+
+	body_a->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
+	body_b->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Joint2D::_body_exit_tree));
+
+	PhysicsServer2D::get_singleton()->joint_disable_collisions_between_bodies(joint, exclude_from_collision);
+}
+
+void Joint2D::set_node_a(const NodePath &p_node_a) {
+	if (a == p_node_a) {
+		return;
+	}
+
+	if (is_configured()) {
+		_disconnect_signals();
+	}
+
+	a = p_node_a;
+	if (Engine::get_singleton()->is_editor_hint()) {
+		// When in editor, the setter may be called as a result of node rename.
+		// It happens before the node actually changes its name, which triggers false warning.
+		callable_mp(this, &Joint2D::_update_joint).call_deferred();
+	} else {
+		_update_joint();
+	}
+}
+
+NodePath Joint2D::get_node_a() const {
+	return a;
+}
+
+void Joint2D::set_node_b(const NodePath &p_node_b) {
+	if (b == p_node_b) {
+		return;
+	}
+
+	if (is_configured()) {
+		_disconnect_signals();
+	}
+
+	b = p_node_b;
+	if (Engine::get_singleton()->is_editor_hint()) {
+		callable_mp(this, &Joint2D::_update_joint).call_deferred();
+	} else {
+		_update_joint();
+	}
+}
+
+NodePath Joint2D::get_node_b() const {
+	return b;
+}
+
+void Joint2D::_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 Joint2D::set_bias(real_t p_bias) {
+	bias = p_bias;
+	if (joint.is_valid()) {
+		PhysicsServer2D::get_singleton()->joint_set_param(joint, PhysicsServer2D::JOINT_PARAM_BIAS, bias);
+	}
+}
+
+real_t Joint2D::get_bias() const {
+	return bias;
+}
+
+void Joint2D::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 Joint2D::get_exclude_nodes_from_collision() const {
+	return exclude_from_collision;
+}
+
+PackedStringArray Joint2D::get_configuration_warnings() const {
+	PackedStringArray warnings = Node2D::get_configuration_warnings();
+
+	if (!warning.is_empty()) {
+		warnings.push_back(warning);
+	}
+
+	return warnings;
+}
+
+void Joint2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_node_a", "node"), &Joint2D::set_node_a);
+	ClassDB::bind_method(D_METHOD("get_node_a"), &Joint2D::get_node_a);
+
+	ClassDB::bind_method(D_METHOD("set_node_b", "node"), &Joint2D::set_node_b);
+	ClassDB::bind_method(D_METHOD("get_node_b"), &Joint2D::get_node_b);
+
+	ClassDB::bind_method(D_METHOD("set_bias", "bias"), &Joint2D::set_bias);
+	ClassDB::bind_method(D_METHOD("get_bias"), &Joint2D::get_bias);
+
+	ClassDB::bind_method(D_METHOD("set_exclude_nodes_from_collision", "enable"), &Joint2D::set_exclude_nodes_from_collision);
+	ClassDB::bind_method(D_METHOD("get_exclude_nodes_from_collision"), &Joint2D::get_exclude_nodes_from_collision);
+
+	ClassDB::bind_method(D_METHOD("get_rid"), &Joint2D::get_rid);
+
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_a", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody2D"), "set_node_a", "get_node_a");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_b", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "PhysicsBody2D"), "set_node_b", "get_node_b");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bias", PROPERTY_HINT_RANGE, "0,0.9,0.001"), "set_bias", "get_bias");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disable_collision"), "set_exclude_nodes_from_collision", "get_exclude_nodes_from_collision");
+}
+
+Joint2D::Joint2D() {
+	joint = PhysicsServer2D::get_singleton()->joint_create();
+	set_hide_clip_children(true);
+}
+
+Joint2D::~Joint2D() {
+	ERR_FAIL_NULL(PhysicsServer2D::get_singleton());
+	PhysicsServer2D::get_singleton()->free(joint);
+}
diff --git a/scene/2d/physics/joints/joint_2d.h b/scene/2d/physics/joints/joint_2d.h
new file mode 100644
index 0000000000..bdd2730bfa
--- /dev/null
+++ b/scene/2d/physics/joints/joint_2d.h
@@ -0,0 +1,84 @@
+/**************************************************************************/
+/*  joint_2d.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_2D_H
+#define JOINT_2D_H
+
+#include "scene/2d/node_2d.h"
+
+class PhysicsBody2D;
+
+class Joint2D : public Node2D {
+	GDCLASS(Joint2D, Node2D);
+
+	RID joint;
+	RID ba, bb;
+
+	NodePath a;
+	NodePath b;
+	real_t bias = 0.0;
+
+	bool exclude_from_collision = true;
+	bool configured = false;
+	String warning;
+
+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, PhysicsBody2D *body_a, PhysicsBody2D *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_bias(real_t p_bias);
+	real_t get_bias() const;
+
+	void set_exclude_nodes_from_collision(bool p_enable);
+	bool get_exclude_nodes_from_collision() const;
+
+	RID get_rid() const { return joint; }
+	Joint2D();
+	~Joint2D();
+};
+
+#endif // JOINT_2D_H
diff --git a/scene/2d/physics/joints/pin_joint_2d.cpp b/scene/2d/physics/joints/pin_joint_2d.cpp
new file mode 100644
index 0000000000..6ff0c485f5
--- /dev/null
+++ b/scene/2d/physics/joints/pin_joint_2d.cpp
@@ -0,0 +1,177 @@
+/**************************************************************************/
+/*  pin_joint_2d.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_2d.h"
+
+#include "scene/2d/physics/physics_body_2d.h"
+
+void PinJoint2D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_DRAW: {
+			if (!is_inside_tree()) {
+				break;
+			}
+
+			if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
+				break;
+			}
+
+			draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
+			draw_line(Point2(0, -10), Point2(0, +10), Color(0.7, 0.6, 0.0, 0.5), 3);
+		} break;
+	}
+}
+
+void PinJoint2D::_configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
+	PhysicsServer2D::get_singleton()->joint_make_pin(p_joint, get_global_position(), body_a->get_rid(), body_b ? body_b->get_rid() : RID());
+	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_SOFTNESS, softness);
+	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_LIMIT_UPPER, angular_limit_upper);
+	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_LIMIT_LOWER, angular_limit_lower);
+	PhysicsServer2D::get_singleton()->pin_joint_set_param(p_joint, PhysicsServer2D::PIN_JOINT_MOTOR_TARGET_VELOCITY, motor_target_velocity);
+	PhysicsServer2D::get_singleton()->pin_joint_set_flag(p_joint, PhysicsServer2D::PIN_JOINT_FLAG_MOTOR_ENABLED, motor_enabled);
+	PhysicsServer2D::get_singleton()->pin_joint_set_flag(p_joint, PhysicsServer2D::PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED, angular_limit_enabled);
+}
+
+void PinJoint2D::set_softness(real_t p_softness) {
+	if (softness == p_softness) {
+		return;
+	}
+	softness = p_softness;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_SOFTNESS, p_softness);
+	}
+}
+
+real_t PinJoint2D::get_softness() const {
+	return softness;
+}
+
+void PinJoint2D::set_angular_limit_lower(real_t p_angular_limit_lower) {
+	if (angular_limit_lower == p_angular_limit_lower) {
+		return;
+	}
+	angular_limit_lower = p_angular_limit_lower;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_LIMIT_LOWER, p_angular_limit_lower);
+	}
+}
+
+real_t PinJoint2D::get_angular_limit_lower() const {
+	return angular_limit_lower;
+}
+
+void PinJoint2D::set_angular_limit_upper(real_t p_angular_limit_upper) {
+	if (angular_limit_upper == p_angular_limit_upper) {
+		return;
+	}
+	angular_limit_upper = p_angular_limit_upper;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_LIMIT_UPPER, p_angular_limit_upper);
+	}
+}
+
+real_t PinJoint2D::get_angular_limit_upper() const {
+	return angular_limit_upper;
+}
+
+void PinJoint2D::set_motor_target_velocity(real_t p_motor_target_velocity) {
+	if (motor_target_velocity == p_motor_target_velocity) {
+		return;
+	}
+	motor_target_velocity = p_motor_target_velocity;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_param(get_rid(), PhysicsServer2D::PIN_JOINT_MOTOR_TARGET_VELOCITY, motor_target_velocity);
+	}
+}
+
+real_t PinJoint2D::get_motor_target_velocity() const {
+	return motor_target_velocity;
+}
+
+void PinJoint2D::set_motor_enabled(bool p_motor_enabled) {
+	if (motor_enabled == p_motor_enabled) {
+		return;
+	}
+	motor_enabled = p_motor_enabled;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_flag(get_rid(), PhysicsServer2D::PIN_JOINT_FLAG_MOTOR_ENABLED, motor_enabled);
+	}
+}
+
+bool PinJoint2D::is_motor_enabled() const {
+	return motor_enabled;
+}
+
+void PinJoint2D::set_angular_limit_enabled(bool p_angular_limit_enabled) {
+	if (angular_limit_enabled == p_angular_limit_enabled) {
+		return;
+	}
+	angular_limit_enabled = p_angular_limit_enabled;
+	queue_redraw();
+	if (is_configured()) {
+		PhysicsServer2D::get_singleton()->pin_joint_set_flag(get_rid(), PhysicsServer2D::PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED, angular_limit_enabled);
+	}
+}
+
+bool PinJoint2D::is_angular_limit_enabled() const {
+	return angular_limit_enabled;
+}
+
+void PinJoint2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_softness", "softness"), &PinJoint2D::set_softness);
+	ClassDB::bind_method(D_METHOD("get_softness"), &PinJoint2D::get_softness);
+	ClassDB::bind_method(D_METHOD("set_angular_limit_lower", "angular_limit_lower"), &PinJoint2D::set_angular_limit_lower);
+	ClassDB::bind_method(D_METHOD("get_angular_limit_lower"), &PinJoint2D::get_angular_limit_lower);
+	ClassDB::bind_method(D_METHOD("set_angular_limit_upper", "angular_limit_upper"), &PinJoint2D::set_angular_limit_upper);
+	ClassDB::bind_method(D_METHOD("get_angular_limit_upper"), &PinJoint2D::get_angular_limit_upper);
+	ClassDB::bind_method(D_METHOD("set_motor_target_velocity", "motor_target_velocity"), &PinJoint2D::set_motor_target_velocity);
+	ClassDB::bind_method(D_METHOD("get_motor_target_velocity"), &PinJoint2D::get_motor_target_velocity);
+	ClassDB::bind_method(D_METHOD("set_motor_enabled", "enabled"), &PinJoint2D::set_motor_enabled);
+	ClassDB::bind_method(D_METHOD("is_motor_enabled"), &PinJoint2D::is_motor_enabled);
+	ClassDB::bind_method(D_METHOD("set_angular_limit_enabled", "enabled"), &PinJoint2D::set_angular_limit_enabled);
+	ClassDB::bind_method(D_METHOD("is_angular_limit_enabled"), &PinJoint2D::is_angular_limit_enabled);
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "softness", PROPERTY_HINT_RANGE, "0.00,16,0.01,exp"), "set_softness", "get_softness");
+	ADD_GROUP("Angular Limit", "angular_limit_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "angular_limit_enabled"), "set_angular_limit_enabled", "is_angular_limit_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_limit_lower", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_angular_limit_lower", "get_angular_limit_lower");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "angular_limit_upper", PROPERTY_HINT_RANGE, "-180,180,0.1,radians_as_degrees"), "set_angular_limit_upper", "get_angular_limit_upper");
+	ADD_GROUP("Motor", "motor_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "motor_enabled"), "set_motor_enabled", "is_motor_enabled");
+	ADD_PROPERTY(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_motor_target_velocity", "get_motor_target_velocity");
+}
+
+PinJoint2D::PinJoint2D() {
+}
diff --git a/scene/2d/physics/joints/pin_joint_2d.h b/scene/2d/physics/joints/pin_joint_2d.h
new file mode 100644
index 0000000000..c2d78ba324
--- /dev/null
+++ b/scene/2d/physics/joints/pin_joint_2d.h
@@ -0,0 +1,71 @@
+/**************************************************************************/
+/*  pin_joint_2d.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_2D_H
+#define PIN_JOINT_2D_H
+
+#include "scene/2d/physics/joints/joint_2d.h"
+
+class PhysicsBody2D;
+
+class PinJoint2D : public Joint2D {
+	GDCLASS(PinJoint2D, Joint2D);
+
+	real_t softness = 0.0;
+	real_t angular_limit_lower = 0.0;
+	real_t angular_limit_upper = 0.0;
+	real_t motor_target_velocity = 0.0;
+	bool motor_enabled = false;
+	bool angular_limit_enabled = false;
+
+protected:
+	void _notification(int p_what);
+	virtual void _configure_joint(RID p_joint, PhysicsBody2D *body_a, PhysicsBody2D *body_b) override;
+	static void _bind_methods();
+
+public:
+	void set_softness(real_t p_softness);
+	real_t get_softness() const;
+	void set_angular_limit_lower(real_t p_angular_limit_lower);
+	real_t get_angular_limit_lower() const;
+	void set_angular_limit_upper(real_t p_angular_limit_upper);
+	real_t get_angular_limit_upper() const;
+	void set_motor_target_velocity(real_t p_motor_target_velocity);
+	real_t get_motor_target_velocity() const;
+
+	void set_motor_enabled(bool p_motor_enabled);
+	bool is_motor_enabled() const;
+	void set_angular_limit_enabled(bool p_angular_limit_enabled);
+	bool is_angular_limit_enabled() const;
+
+	PinJoint2D();
+};
+
+#endif // PIN_JOINT_2D_H
diff --git a/scene/2d/physics/kinematic_collision_2d.cpp b/scene/2d/physics/kinematic_collision_2d.cpp
new file mode 100644
index 0000000000..7e7c33b259
--- /dev/null
+++ b/scene/2d/physics/kinematic_collision_2d.cpp
@@ -0,0 +1,120 @@
+/**************************************************************************/
+/*  kinematic_collision_2d.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_2d.h"
+
+#include "scene/2d/physics/character_body_2d.h"
+#include "scene/2d/physics/physics_body_2d.h"
+
+Vector2 KinematicCollision2D::get_position() const {
+	return result.collision_point;
+}
+
+Vector2 KinematicCollision2D::get_normal() const {
+	return result.collision_normal;
+}
+
+Vector2 KinematicCollision2D::get_travel() const {
+	return result.travel;
+}
+
+Vector2 KinematicCollision2D::get_remainder() const {
+	return result.remainder;
+}
+
+real_t KinematicCollision2D::get_angle(const Vector2 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
+	return result.get_angle(p_up_direction);
+}
+
+real_t KinematicCollision2D::get_depth() const {
+	return result.collision_depth;
+}
+
+Object *KinematicCollision2D::get_local_shape() const {
+	if (!owner) {
+		return nullptr;
+	}
+	uint32_t ownerid = owner->shape_find_owner(result.collision_local_shape);
+	return owner->shape_owner_get_owner(ownerid);
+}
+
+Object *KinematicCollision2D::get_collider() const {
+	if (result.collider_id.is_valid()) {
+		return ObjectDB::get_instance(result.collider_id);
+	}
+
+	return nullptr;
+}
+
+ObjectID KinematicCollision2D::get_collider_id() const {
+	return result.collider_id;
+}
+
+RID KinematicCollision2D::get_collider_rid() const {
+	return result.collider;
+}
+
+Object *KinematicCollision2D::get_collider_shape() const {
+	Object *collider = get_collider();
+	if (collider) {
+		CollisionObject2D *obj2d = Object::cast_to<CollisionObject2D>(collider);
+		if (obj2d) {
+			uint32_t ownerid = obj2d->shape_find_owner(result.collider_shape);
+			return obj2d->shape_owner_get_owner(ownerid);
+		}
+	}
+
+	return nullptr;
+}
+
+int KinematicCollision2D::get_collider_shape_index() const {
+	return result.collider_shape;
+}
+
+Vector2 KinematicCollision2D::get_collider_velocity() const {
+	return result.collider_velocity;
+}
+
+void KinematicCollision2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_position"), &KinematicCollision2D::get_position);
+	ClassDB::bind_method(D_METHOD("get_normal"), &KinematicCollision2D::get_normal);
+	ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision2D::get_travel);
+	ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision2D::get_remainder);
+	ClassDB::bind_method(D_METHOD("get_angle", "up_direction"), &KinematicCollision2D::get_angle, DEFVAL(Vector2(0.0, -1.0)));
+	ClassDB::bind_method(D_METHOD("get_depth"), &KinematicCollision2D::get_depth);
+	ClassDB::bind_method(D_METHOD("get_local_shape"), &KinematicCollision2D::get_local_shape);
+	ClassDB::bind_method(D_METHOD("get_collider"), &KinematicCollision2D::get_collider);
+	ClassDB::bind_method(D_METHOD("get_collider_id"), &KinematicCollision2D::get_collider_id);
+	ClassDB::bind_method(D_METHOD("get_collider_rid"), &KinematicCollision2D::get_collider_rid);
+	ClassDB::bind_method(D_METHOD("get_collider_shape"), &KinematicCollision2D::get_collider_shape);
+	ClassDB::bind_method(D_METHOD("get_collider_shape_index"), &KinematicCollision2D::get_collider_shape_index);
+	ClassDB::bind_method(D_METHOD("get_collider_velocity"), &KinematicCollision2D::get_collider_velocity);
+}
diff --git a/scene/2d/physics/kinematic_collision_2d.h b/scene/2d/physics/kinematic_collision_2d.h
new file mode 100644
index 0000000000..0d187b87a5
--- /dev/null
+++ b/scene/2d/physics/kinematic_collision_2d.h
@@ -0,0 +1,67 @@
+/**************************************************************************/
+/*  kinematic_collision_2d.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_2D_H
+#define KINEMATIC_COLLISION_2D_H
+
+#include "core/object/ref_counted.h"
+#include "servers/physics_server_2d.h"
+
+class CharacterBody2D;
+class PhysicsBody2D;
+
+class KinematicCollision2D : public RefCounted {
+	GDCLASS(KinematicCollision2D, RefCounted);
+
+	PhysicsBody2D *owner = nullptr;
+	friend class PhysicsBody2D;
+	friend class CharacterBody2D;
+	PhysicsServer2D::MotionResult result;
+
+protected:
+	static void _bind_methods();
+
+public:
+	Vector2 get_position() const;
+	Vector2 get_normal() const;
+	Vector2 get_travel() const;
+	Vector2 get_remainder() const;
+	real_t get_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
+	real_t get_depth() const;
+	Object *get_local_shape() const;
+	Object *get_collider() const;
+	ObjectID get_collider_id() const;
+	RID get_collider_rid() const;
+	Object *get_collider_shape() const;
+	int get_collider_shape_index() const;
+	Vector2 get_collider_velocity() const;
+};
+
+#endif // KINEMATIC_COLLISION_2D_H
diff --git a/scene/2d/physical_bone_2d.cpp b/scene/2d/physics/physical_bone_2d.cpp
index 64cf56fa85..77bb8c24b8 100644
--- a/scene/2d/physical_bone_2d.cpp
+++ b/scene/2d/physics/physical_bone_2d.cpp
@@ -30,7 +30,7 @@
 
 #include "physical_bone_2d.h"
 
-#include "scene/2d/joint_2d.h"
+#include "scene/2d/physics/joints/joint_2d.h"
 
 void PhysicalBone2D::_notification(int p_what) {
 	switch (p_what) {
diff --git a/scene/2d/physical_bone_2d.h b/scene/2d/physics/physical_bone_2d.h
index e585f2c0ed..0547469b5e 100644
--- a/scene/2d/physical_bone_2d.h
+++ b/scene/2d/physics/physical_bone_2d.h
@@ -31,7 +31,7 @@
 #ifndef PHYSICAL_BONE_2D_H
 #define PHYSICAL_BONE_2D_H
 
-#include "scene/2d/physics_body_2d.h"
+#include "scene/2d/physics/rigid_body_2d.h"
 #include "scene/2d/skeleton_2d.h"
 
 class Joint2D;
diff --git a/scene/2d/physics/physics_body_2d.cpp b/scene/2d/physics/physics_body_2d.cpp
new file mode 100644
index 0000000000..81120d0b01
--- /dev/null
+++ b/scene/2d/physics/physics_body_2d.cpp
@@ -0,0 +1,180 @@
+/**************************************************************************/
+/*  physics_body_2d.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_2d.h"
+
+#include "scene/scene_string_names.h"
+
+void PhysicsBody2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("move_and_collide", "motion", "test_only", "safe_margin", "recovery_as_collision"), &PhysicsBody2D::_move, DEFVAL(false), DEFVAL(0.08), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("test_move", "from", "motion", "collision", "safe_margin", "recovery_as_collision"), &PhysicsBody2D::test_move, DEFVAL(Variant()), DEFVAL(0.08), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("get_gravity"), &PhysicsBody2D::get_gravity);
+
+	ClassDB::bind_method(D_METHOD("get_collision_exceptions"), &PhysicsBody2D::get_collision_exceptions);
+	ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &PhysicsBody2D::add_collision_exception_with);
+	ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &PhysicsBody2D::remove_collision_exception_with);
+}
+
+PhysicsBody2D::PhysicsBody2D(PhysicsServer2D::BodyMode p_mode) :
+		CollisionObject2D(PhysicsServer2D::get_singleton()->body_create(), false) {
+	set_body_mode(p_mode);
+	set_pickable(false);
+}
+
+PhysicsBody2D::~PhysicsBody2D() {
+	if (motion_cache.is_valid()) {
+		motion_cache->owner = nullptr;
+	}
+}
+
+Ref<KinematicCollision2D> PhysicsBody2D::_move(const Vector2 &p_motion, bool p_test_only, real_t p_margin, bool p_recovery_as_collision) {
+	PhysicsServer2D::MotionParameters parameters(get_global_transform(), p_motion, p_margin);
+	parameters.recovery_as_collision = p_recovery_as_collision;
+
+	PhysicsServer2D::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<KinematicCollision2D>();
+}
+
+bool PhysicsBody2D::move_and_collide(const PhysicsServer2D::MotionParameters &p_parameters, PhysicsServer2D::MotionResult &r_result, bool p_test_only, bool p_cancel_sliding) {
+	if (is_only_update_transform_changes_enabled()) {
+		ERR_PRINT("Move functions do not work together with 'sync to physics' option. See the documentation for details.");
+	}
+
+	bool colliding = PhysicsServer2D::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.collision_depth > p_parameters.margin + precision) {
+				p_cancel_sliding = false;
+			}
+		}
+
+		if (p_cancel_sliding) {
+			// When motion is null, recovery is the resulting motion.
+			Vector2 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);
+			Vector2 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;
+			}
+		}
+	}
+
+	if (!p_test_only) {
+		Transform2D gt = p_parameters.from;
+		gt.columns[2] += r_result.travel;
+		set_global_transform(gt);
+	}
+
+	return colliding;
+}
+
+bool PhysicsBody2D::test_move(const Transform2D &p_from, const Vector2 &p_motion, const Ref<KinematicCollision2D> &r_collision, real_t p_margin, bool p_recovery_as_collision) {
+	ERR_FAIL_COND_V(!is_inside_tree(), false);
+
+	PhysicsServer2D::MotionResult *r = nullptr;
+	PhysicsServer2D::MotionResult temp_result;
+	if (r_collision.is_valid()) {
+		// Needs const_cast because method bindings don't support non-const Ref.
+		r = const_cast<PhysicsServer2D::MotionResult *>(&r_collision->result);
+	} else {
+		r = &temp_result;
+	}
+
+	PhysicsServer2D::MotionParameters parameters(p_from, p_motion, p_margin);
+	parameters.recovery_as_collision = p_recovery_as_collision;
+
+	return PhysicsServer2D::get_singleton()->body_test_motion(get_rid(), parameters, r);
+}
+
+Vector2 PhysicsBody2D::get_gravity() const {
+	PhysicsDirectBodyState2D *state = PhysicsServer2D::get_singleton()->body_get_direct_state(get_rid());
+	ERR_FAIL_NULL_V(state, Vector2());
+	return state->get_total_gravity();
+}
+
+TypedArray<PhysicsBody2D> PhysicsBody2D::get_collision_exceptions() {
+	List<RID> exceptions;
+	PhysicsServer2D::get_singleton()->body_get_collision_exceptions(get_rid(), &exceptions);
+	Array ret;
+	for (const RID &body : exceptions) {
+		ObjectID instance_id = PhysicsServer2D::get_singleton()->body_get_object_instance_id(body);
+		Object *obj = ObjectDB::get_instance(instance_id);
+		PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(obj);
+		ret.append(physics_body);
+	}
+	return ret;
+}
+
+void PhysicsBody2D::add_collision_exception_with(Node *p_node) {
+	ERR_FAIL_NULL(p_node);
+	PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(p_node);
+	ERR_FAIL_NULL_MSG(physics_body, "Collision exception only works between two nodes that inherit from PhysicsBody2D.");
+	PhysicsServer2D::get_singleton()->body_add_collision_exception(get_rid(), physics_body->get_rid());
+}
+
+void PhysicsBody2D::remove_collision_exception_with(Node *p_node) {
+	ERR_FAIL_NULL(p_node);
+	PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(p_node);
+	ERR_FAIL_NULL_MSG(physics_body, "Collision exception only works between two nodes that inherit from PhysicsBody2D.");
+	PhysicsServer2D::get_singleton()->body_remove_collision_exception(get_rid(), physics_body->get_rid());
+}
diff --git a/scene/2d/physics/physics_body_2d.h b/scene/2d/physics/physics_body_2d.h
new file mode 100644
index 0000000000..43bc479881
--- /dev/null
+++ b/scene/2d/physics/physics_body_2d.h
@@ -0,0 +1,63 @@
+/**************************************************************************/
+/*  physics_body_2d.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_2D_H
+#define PHYSICS_BODY_2D_H
+
+#include "core/templates/vset.h"
+#include "scene/2d/physics/collision_object_2d.h"
+#include "scene/2d/physics/kinematic_collision_2d.h"
+#include "scene/resources/physics_material.h"
+#include "servers/physics_server_2d.h"
+
+class PhysicsBody2D : public CollisionObject2D {
+	GDCLASS(PhysicsBody2D, CollisionObject2D);
+
+protected:
+	static void _bind_methods();
+	PhysicsBody2D(PhysicsServer2D::BodyMode p_mode);
+
+	Ref<KinematicCollision2D> motion_cache;
+
+	Ref<KinematicCollision2D> _move(const Vector2 &p_motion, bool p_test_only = false, real_t p_margin = 0.08, bool p_recovery_as_collision = false);
+
+public:
+	bool move_and_collide(const PhysicsServer2D::MotionParameters &p_parameters, PhysicsServer2D::MotionResult &r_result, bool p_test_only = false, bool p_cancel_sliding = true);
+	bool test_move(const Transform2D &p_from, const Vector2 &p_motion, const Ref<KinematicCollision2D> &r_collision = Ref<KinematicCollision2D>(), real_t p_margin = 0.08, bool p_recovery_as_collision = false);
+	Vector2 get_gravity() const;
+
+	TypedArray<PhysicsBody2D> get_collision_exceptions();
+	void add_collision_exception_with(Node *p_node); //must be physicsbody
+	void remove_collision_exception_with(Node *p_node);
+
+	virtual ~PhysicsBody2D();
+};
+
+#endif // PHYSICS_BODY_2D_H
diff --git a/scene/2d/ray_cast_2d.cpp b/scene/2d/physics/ray_cast_2d.cpp
index f27ac169b6..cb9497c14e 100644
--- a/scene/2d/ray_cast_2d.cpp
+++ b/scene/2d/physics/ray_cast_2d.cpp
@@ -30,7 +30,7 @@
 
 #include "ray_cast_2d.h"
 
-#include "collision_object_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
 #include "scene/resources/world_2d.h"
 
 void RayCast2D::set_target_position(const Vector2 &p_point) {
diff --git a/scene/2d/ray_cast_2d.h b/scene/2d/physics/ray_cast_2d.h
index 0a856635da..0a856635da 100644
--- a/scene/2d/ray_cast_2d.h
+++ b/scene/2d/physics/ray_cast_2d.h
diff --git a/scene/2d/physics/rigid_body_2d.cpp b/scene/2d/physics/rigid_body_2d.cpp
new file mode 100644
index 0000000000..12112510a8
--- /dev/null
+++ b/scene/2d/physics/rigid_body_2d.cpp
@@ -0,0 +1,817 @@
+/**************************************************************************/
+/*  rigid_body_2d.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_2d.h"
+
+#include "scene/scene_string_names.h"
+
+void RigidBody2D::_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_scene);
+
+	contact_monitor->locked = true;
+
+	E->value.in_scene = 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 RigidBody2D::_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_scene);
+	E->value.in_scene = 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 RigidBody2D::_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_scene = node && node->is_inside_tree();
+			if (node) {
+				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody2D::_body_enter_tree).bind(objid));
+				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree).bind(objid));
+				if (E->value.in_scene) {
+					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_scene) {
+			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_scene = E->value.in_scene;
+
+		if (E->value.shapes.is_empty()) {
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody2D::_body_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree));
+				if (in_scene) {
+					emit_signal(SceneStringNames::get_singleton()->body_exited, node);
+				}
+			}
+
+			contact_monitor->body_map.remove(E);
+		}
+		if (node && in_scene) {
+			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, node, p_body_shape, p_local_shape);
+		}
+	}
+}
+
+struct _RigidBody2DInOut {
+	RID rid;
+	ObjectID id;
+	int shape = 0;
+	int local_shape = 0;
+};
+
+void RigidBody2D::_sync_body_state(PhysicsDirectBodyState2D *p_state) {
+	if (!freeze || freeze_mode != FREEZE_MODE_KINEMATIC) {
+		set_block_transform_notify(true);
+		set_global_transform(p_state->get_transform());
+		set_block_transform_notify(false);
+	}
+
+	linear_velocity = p_state->get_linear_velocity();
+	angular_velocity = p_state->get_angular_velocity();
+
+	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 RigidBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state) {
+	lock_callback();
+
+	if (GDVIRTUAL_IS_OVERRIDDEN(_integrate_forces)) {
+		_sync_body_state(p_state);
+
+		Transform2D old_transform = get_global_transform();
+		GDVIRTUAL_CALL(_integrate_forces, p_state);
+		Transform2D 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.
+			PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_TRANSFORM, new_transform);
+		}
+	}
+
+	_sync_body_state(p_state);
+
+	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++;
+			}
+		}
+
+		_RigidBody2DInOut *toadd = (_RigidBody2DInOut *)alloca(p_state->get_contact_count() * sizeof(_RigidBody2DInOut));
+		int toadd_count = 0; //state->get_contact_count();
+		RigidBody2D_RemoveAction *toremove = (RigidBody2D_RemoveAction *)alloca(rc * sizeof(RigidBody2D_RemoveAction));
+		int toremove_count = 0;
+
+		//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, toadd[i].rid, toadd[i].id, toadd[i].shape, toadd[i].local_shape);
+		}
+
+		contact_monitor->locked = false;
+	}
+
+	unlock_callback();
+}
+
+void RigidBody2D::_apply_body_mode() {
+	if (freeze) {
+		switch (freeze_mode) {
+			case FREEZE_MODE_STATIC: {
+				set_body_mode(PhysicsServer2D::BODY_MODE_STATIC);
+			} break;
+			case FREEZE_MODE_KINEMATIC: {
+				set_body_mode(PhysicsServer2D::BODY_MODE_KINEMATIC);
+			} break;
+		}
+	} else if (lock_rotation) {
+		set_body_mode(PhysicsServer2D::BODY_MODE_RIGID_LINEAR);
+	} else {
+		set_body_mode(PhysicsServer2D::BODY_MODE_RIGID);
+	}
+}
+
+void RigidBody2D::set_lock_rotation_enabled(bool p_lock_rotation) {
+	if (p_lock_rotation == lock_rotation) {
+		return;
+	}
+
+	lock_rotation = p_lock_rotation;
+	_apply_body_mode();
+}
+
+bool RigidBody2D::is_lock_rotation_enabled() const {
+	return lock_rotation;
+}
+
+void RigidBody2D::set_freeze_enabled(bool p_freeze) {
+	if (p_freeze == freeze) {
+		return;
+	}
+
+	freeze = p_freeze;
+	_apply_body_mode();
+}
+
+bool RigidBody2D::is_freeze_enabled() const {
+	return freeze;
+}
+
+void RigidBody2D::set_freeze_mode(FreezeMode p_freeze_mode) {
+	if (p_freeze_mode == freeze_mode) {
+		return;
+	}
+
+	freeze_mode = p_freeze_mode;
+	_apply_body_mode();
+}
+
+RigidBody2D::FreezeMode RigidBody2D::get_freeze_mode() const {
+	return freeze_mode;
+}
+
+void RigidBody2D::set_mass(real_t p_mass) {
+	ERR_FAIL_COND(p_mass <= 0);
+	mass = p_mass;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_MASS, mass);
+}
+
+real_t RigidBody2D::get_mass() const {
+	return mass;
+}
+
+void RigidBody2D::set_inertia(real_t p_inertia) {
+	ERR_FAIL_COND(p_inertia < 0);
+	inertia = p_inertia;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_INERTIA, inertia);
+}
+
+real_t RigidBody2D::get_inertia() const {
+	return inertia;
+}
+
+void RigidBody2D::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 = Vector2();
+			PhysicsServer2D::get_singleton()->body_reset_mass_properties(get_rid());
+			if (inertia != 0.0) {
+				PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_INERTIA, inertia);
+			}
+		} break;
+
+		case CENTER_OF_MASS_MODE_CUSTOM: {
+			PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
+		} break;
+	}
+}
+
+RigidBody2D::CenterOfMassMode RigidBody2D::get_center_of_mass_mode() const {
+	return center_of_mass_mode;
+}
+
+void RigidBody2D::set_center_of_mass(const Vector2 &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;
+
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
+}
+
+const Vector2 &RigidBody2D::get_center_of_mass() const {
+	return center_of_mass;
+}
+
+void RigidBody2D::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, &RigidBody2D::_reload_physics_characteristics));
+	}
+
+	physics_material_override = p_physics_material_override;
+
+	if (physics_material_override.is_valid()) {
+		physics_material_override->connect_changed(callable_mp(this, &RigidBody2D::_reload_physics_characteristics));
+	}
+	_reload_physics_characteristics();
+}
+
+Ref<PhysicsMaterial> RigidBody2D::get_physics_material_override() const {
+	return physics_material_override;
+}
+
+void RigidBody2D::set_gravity_scale(real_t p_gravity_scale) {
+	gravity_scale = p_gravity_scale;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
+}
+
+real_t RigidBody2D::get_gravity_scale() const {
+	return gravity_scale;
+}
+
+void RigidBody2D::set_linear_damp_mode(DampMode p_mode) {
+	linear_damp_mode = p_mode;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_LINEAR_DAMP_MODE, linear_damp_mode);
+}
+
+RigidBody2D::DampMode RigidBody2D::get_linear_damp_mode() const {
+	return linear_damp_mode;
+}
+
+void RigidBody2D::set_angular_damp_mode(DampMode p_mode) {
+	angular_damp_mode = p_mode;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_ANGULAR_DAMP_MODE, angular_damp_mode);
+}
+
+RigidBody2D::DampMode RigidBody2D::get_angular_damp_mode() const {
+	return angular_damp_mode;
+}
+
+void RigidBody2D::set_linear_damp(real_t p_linear_damp) {
+	ERR_FAIL_COND(p_linear_damp < -1);
+	linear_damp = p_linear_damp;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_LINEAR_DAMP, linear_damp);
+}
+
+real_t RigidBody2D::get_linear_damp() const {
+	return linear_damp;
+}
+
+void RigidBody2D::set_angular_damp(real_t p_angular_damp) {
+	ERR_FAIL_COND(p_angular_damp < -1);
+	angular_damp = p_angular_damp;
+	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_ANGULAR_DAMP, angular_damp);
+}
+
+real_t RigidBody2D::get_angular_damp() const {
+	return angular_damp;
+}
+
+void RigidBody2D::set_axis_velocity(const Vector2 &p_axis) {
+	Vector2 axis = p_axis.normalized();
+	linear_velocity -= axis * axis.dot(linear_velocity);
+	linear_velocity += p_axis;
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
+}
+
+void RigidBody2D::set_linear_velocity(const Vector2 &p_velocity) {
+	linear_velocity = p_velocity;
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
+}
+
+Vector2 RigidBody2D::get_linear_velocity() const {
+	return linear_velocity;
+}
+
+void RigidBody2D::set_angular_velocity(real_t p_velocity) {
+	angular_velocity = p_velocity;
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
+}
+
+real_t RigidBody2D::get_angular_velocity() const {
+	return angular_velocity;
+}
+
+void RigidBody2D::set_use_custom_integrator(bool p_enable) {
+	if (custom_integrator == p_enable) {
+		return;
+	}
+
+	custom_integrator = p_enable;
+	PhysicsServer2D::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
+}
+
+bool RigidBody2D::is_using_custom_integrator() {
+	return custom_integrator;
+}
+
+void RigidBody2D::set_sleeping(bool p_sleeping) {
+	sleeping = p_sleeping;
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_SLEEPING, sleeping);
+}
+
+void RigidBody2D::set_can_sleep(bool p_active) {
+	can_sleep = p_active;
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_CAN_SLEEP, p_active);
+}
+
+bool RigidBody2D::is_able_to_sleep() const {
+	return can_sleep;
+}
+
+bool RigidBody2D::is_sleeping() const {
+	return sleeping;
+}
+
+void RigidBody2D::set_max_contacts_reported(int p_amount) {
+	max_contacts_reported = p_amount;
+	PhysicsServer2D::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
+}
+
+int RigidBody2D::get_max_contacts_reported() const {
+	return max_contacts_reported;
+}
+
+int RigidBody2D::get_contact_count() const {
+	return contact_count;
+}
+
+void RigidBody2D::apply_central_impulse(const Vector2 &p_impulse) {
+	PhysicsServer2D::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);
+}
+
+void RigidBody2D::apply_impulse(const Vector2 &p_impulse, const Vector2 &p_position) {
+	PhysicsServer2D::get_singleton()->body_apply_impulse(get_rid(), p_impulse, p_position);
+}
+
+void RigidBody2D::apply_torque_impulse(real_t p_torque) {
+	PhysicsServer2D::get_singleton()->body_apply_torque_impulse(get_rid(), p_torque);
+}
+
+void RigidBody2D::apply_central_force(const Vector2 &p_force) {
+	PhysicsServer2D::get_singleton()->body_apply_central_force(get_rid(), p_force);
+}
+
+void RigidBody2D::apply_force(const Vector2 &p_force, const Vector2 &p_position) {
+	PhysicsServer2D::get_singleton()->body_apply_force(get_rid(), p_force, p_position);
+}
+
+void RigidBody2D::apply_torque(real_t p_torque) {
+	PhysicsServer2D::get_singleton()->body_apply_torque(get_rid(), p_torque);
+}
+
+void RigidBody2D::add_constant_central_force(const Vector2 &p_force) {
+	PhysicsServer2D::get_singleton()->body_add_constant_central_force(get_rid(), p_force);
+}
+
+void RigidBody2D::add_constant_force(const Vector2 &p_force, const Vector2 &p_position) {
+	PhysicsServer2D::get_singleton()->body_add_constant_force(get_rid(), p_force, p_position);
+}
+
+void RigidBody2D::add_constant_torque(const real_t p_torque) {
+	PhysicsServer2D::get_singleton()->body_add_constant_torque(get_rid(), p_torque);
+}
+
+void RigidBody2D::set_constant_force(const Vector2 &p_force) {
+	PhysicsServer2D::get_singleton()->body_set_constant_force(get_rid(), p_force);
+}
+
+Vector2 RigidBody2D::get_constant_force() const {
+	return PhysicsServer2D::get_singleton()->body_get_constant_force(get_rid());
+}
+
+void RigidBody2D::set_constant_torque(real_t p_torque) {
+	PhysicsServer2D::get_singleton()->body_set_constant_torque(get_rid(), p_torque);
+}
+
+real_t RigidBody2D::get_constant_torque() const {
+	return PhysicsServer2D::get_singleton()->body_get_constant_torque(get_rid());
+}
+
+void RigidBody2D::set_continuous_collision_detection_mode(CCDMode p_mode) {
+	ccd_mode = p_mode;
+	PhysicsServer2D::get_singleton()->body_set_continuous_collision_detection_mode(get_rid(), PhysicsServer2D::CCDMode(p_mode));
+}
+
+RigidBody2D::CCDMode RigidBody2D::get_continuous_collision_detection_mode() const {
+	return ccd_mode;
+}
+
+TypedArray<Node2D> RigidBody2D::get_colliding_bodies() const {
+	ERR_FAIL_NULL_V(contact_monitor, TypedArray<Node2D>());
+
+	TypedArray<Node2D> 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 RigidBody2D::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, &RigidBody2D::_body_enter_tree));
+				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree));
+			}
+		}
+
+		memdelete(contact_monitor);
+		contact_monitor = nullptr;
+	} else {
+		contact_monitor = memnew(ContactMonitor);
+		contact_monitor->locked = false;
+	}
+}
+
+bool RigidBody2D::is_contact_monitor_enabled() const {
+	return contact_monitor != nullptr;
+}
+
+void RigidBody2D::_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
+}
+
+PackedStringArray RigidBody2D::get_configuration_warnings() const {
+	Transform2D t = get_transform();
+
+	PackedStringArray warnings = CollisionObject2D::get_configuration_warnings();
+
+	if (ABS(t.columns[0].length() - 1.0) > 0.05 || ABS(t.columns[1].length() - 1.0) > 0.05) {
+		warnings.push_back(RTR("Size changes to RigidBody2D will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
+	}
+
+	return warnings;
+}
+
+void RigidBody2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_mass", "mass"), &RigidBody2D::set_mass);
+	ClassDB::bind_method(D_METHOD("get_mass"), &RigidBody2D::get_mass);
+
+	ClassDB::bind_method(D_METHOD("get_inertia"), &RigidBody2D::get_inertia);
+	ClassDB::bind_method(D_METHOD("set_inertia", "inertia"), &RigidBody2D::set_inertia);
+
+	ClassDB::bind_method(D_METHOD("set_center_of_mass_mode", "mode"), &RigidBody2D::set_center_of_mass_mode);
+	ClassDB::bind_method(D_METHOD("get_center_of_mass_mode"), &RigidBody2D::get_center_of_mass_mode);
+
+	ClassDB::bind_method(D_METHOD("set_center_of_mass", "center_of_mass"), &RigidBody2D::set_center_of_mass);
+	ClassDB::bind_method(D_METHOD("get_center_of_mass"), &RigidBody2D::get_center_of_mass);
+
+	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody2D::set_physics_material_override);
+	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody2D::get_physics_material_override);
+
+	ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &RigidBody2D::set_gravity_scale);
+	ClassDB::bind_method(D_METHOD("get_gravity_scale"), &RigidBody2D::get_gravity_scale);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp_mode", "linear_damp_mode"), &RigidBody2D::set_linear_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_linear_damp_mode"), &RigidBody2D::get_linear_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp_mode", "angular_damp_mode"), &RigidBody2D::set_angular_damp_mode);
+	ClassDB::bind_method(D_METHOD("get_angular_damp_mode"), &RigidBody2D::get_angular_damp_mode);
+
+	ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &RigidBody2D::set_linear_damp);
+	ClassDB::bind_method(D_METHOD("get_linear_damp"), &RigidBody2D::get_linear_damp);
+
+	ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &RigidBody2D::set_angular_damp);
+	ClassDB::bind_method(D_METHOD("get_angular_damp"), &RigidBody2D::get_angular_damp);
+
+	ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &RigidBody2D::set_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &RigidBody2D::get_linear_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &RigidBody2D::set_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_angular_velocity"), &RigidBody2D::get_angular_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_max_contacts_reported", "amount"), &RigidBody2D::set_max_contacts_reported);
+	ClassDB::bind_method(D_METHOD("get_max_contacts_reported"), &RigidBody2D::get_max_contacts_reported);
+	ClassDB::bind_method(D_METHOD("get_contact_count"), &RigidBody2D::get_contact_count);
+
+	ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &RigidBody2D::set_use_custom_integrator);
+	ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &RigidBody2D::is_using_custom_integrator);
+
+	ClassDB::bind_method(D_METHOD("set_contact_monitor", "enabled"), &RigidBody2D::set_contact_monitor);
+	ClassDB::bind_method(D_METHOD("is_contact_monitor_enabled"), &RigidBody2D::is_contact_monitor_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_continuous_collision_detection_mode", "mode"), &RigidBody2D::set_continuous_collision_detection_mode);
+	ClassDB::bind_method(D_METHOD("get_continuous_collision_detection_mode"), &RigidBody2D::get_continuous_collision_detection_mode);
+
+	ClassDB::bind_method(D_METHOD("set_axis_velocity", "axis_velocity"), &RigidBody2D::set_axis_velocity);
+	ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody2D::apply_central_impulse, Vector2());
+	ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &RigidBody2D::apply_impulse, Vector2());
+	ClassDB::bind_method(D_METHOD("apply_torque_impulse", "torque"), &RigidBody2D::apply_torque_impulse);
+
+	ClassDB::bind_method(D_METHOD("apply_central_force", "force"), &RigidBody2D::apply_central_force);
+	ClassDB::bind_method(D_METHOD("apply_force", "force", "position"), &RigidBody2D::apply_force, Vector2());
+	ClassDB::bind_method(D_METHOD("apply_torque", "torque"), &RigidBody2D::apply_torque);
+
+	ClassDB::bind_method(D_METHOD("add_constant_central_force", "force"), &RigidBody2D::add_constant_central_force);
+	ClassDB::bind_method(D_METHOD("add_constant_force", "force", "position"), &RigidBody2D::add_constant_force, Vector2());
+	ClassDB::bind_method(D_METHOD("add_constant_torque", "torque"), &RigidBody2D::add_constant_torque);
+
+	ClassDB::bind_method(D_METHOD("set_constant_force", "force"), &RigidBody2D::set_constant_force);
+	ClassDB::bind_method(D_METHOD("get_constant_force"), &RigidBody2D::get_constant_force);
+
+	ClassDB::bind_method(D_METHOD("set_constant_torque", "torque"), &RigidBody2D::set_constant_torque);
+	ClassDB::bind_method(D_METHOD("get_constant_torque"), &RigidBody2D::get_constant_torque);
+
+	ClassDB::bind_method(D_METHOD("set_sleeping", "sleeping"), &RigidBody2D::set_sleeping);
+	ClassDB::bind_method(D_METHOD("is_sleeping"), &RigidBody2D::is_sleeping);
+
+	ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &RigidBody2D::set_can_sleep);
+	ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &RigidBody2D::is_able_to_sleep);
+
+	ClassDB::bind_method(D_METHOD("set_lock_rotation_enabled", "lock_rotation"), &RigidBody2D::set_lock_rotation_enabled);
+	ClassDB::bind_method(D_METHOD("is_lock_rotation_enabled"), &RigidBody2D::is_lock_rotation_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_freeze_enabled", "freeze_mode"), &RigidBody2D::set_freeze_enabled);
+	ClassDB::bind_method(D_METHOD("is_freeze_enabled"), &RigidBody2D::is_freeze_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_freeze_mode", "freeze_mode"), &RigidBody2D::set_freeze_mode);
+	ClassDB::bind_method(D_METHOD("get_freeze_mode"), &RigidBody2D::get_freeze_mode);
+
+	ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidBody2D::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::VECTOR2, "center_of_mass", PROPERTY_HINT_RANGE, "-10,10,0.01,or_less,or_greater,suffix:px"), "set_center_of_mass", "get_center_of_mass");
+	ADD_LINKED_PROPERTY("center_of_mass_mode", "center_of_mass");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "inertia", PROPERTY_HINT_RANGE, U"0,1000,0.01,or_greater,exp,suffix:kg\u22C5px\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::INT, "continuous_cd", PROPERTY_HINT_ENUM, "Disabled,Cast Ray,Cast Shape"), "set_continuous_collision_detection_mode", "get_continuous_collision_detection_mode");
+	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::VECTOR2, "linear_velocity", PROPERTY_HINT_NONE, "suffix:px/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, "-1,100,0.001,or_greater"), "set_linear_damp", "get_linear_damp");
+	ADD_GROUP("Angular", "angular_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "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, "-1,100,0.001,or_greater"), "set_angular_damp", "get_angular_damp");
+	ADD_GROUP("Constant Forces", "constant_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "constant_force", PROPERTY_HINT_NONE, U"suffix:kg\u22C5px/s\u00B2"), "set_constant_force", "get_constant_force");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "constant_torque", PROPERTY_HINT_NONE, U"suffix:kg\u22C5px\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);
+
+	BIND_ENUM_CONSTANT(CCD_MODE_DISABLED);
+	BIND_ENUM_CONSTANT(CCD_MODE_CAST_RAY);
+	BIND_ENUM_CONSTANT(CCD_MODE_CAST_SHAPE);
+}
+
+void RigidBody2D::_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;
+		}
+	}
+}
+
+RigidBody2D::RigidBody2D() :
+		PhysicsBody2D(PhysicsServer2D::BODY_MODE_RIGID) {
+	PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &RigidBody2D::_body_state_changed));
+}
+
+RigidBody2D::~RigidBody2D() {
+	if (contact_monitor) {
+		memdelete(contact_monitor);
+	}
+}
+
+void RigidBody2D::_reload_physics_characteristics() {
+	if (physics_material_override.is_null()) {
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, 0);
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, 1);
+	} else {
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
+	}
+}
diff --git a/scene/2d/physics/rigid_body_2d.h b/scene/2d/physics/rigid_body_2d.h
new file mode 100644
index 0000000000..40af66f28d
--- /dev/null
+++ b/scene/2d/physics/rigid_body_2d.h
@@ -0,0 +1,249 @@
+/**************************************************************************/
+/*  rigid_body_2d.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_2D_H
+#define RIGID_BODY_2D_H
+
+#include "scene/2d/physics/static_body_2d.h"
+
+class RigidBody2D : public PhysicsBody2D {
+	GDCLASS(RigidBody2D, PhysicsBody2D);
+
+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,
+	};
+
+	enum CCDMode {
+		CCD_MODE_DISABLED,
+		CCD_MODE_CAST_RAY,
+		CCD_MODE_CAST_SHAPE,
+	};
+
+private:
+	bool can_sleep = true;
+	bool lock_rotation = false;
+	bool freeze = false;
+	FreezeMode freeze_mode = FREEZE_MODE_STATIC;
+
+	real_t mass = 1.0;
+	real_t inertia = 0.0;
+	CenterOfMassMode center_of_mass_mode = CENTER_OF_MASS_MODE_AUTO;
+	Vector2 center_of_mass;
+
+	Ref<PhysicsMaterial> physics_material_override;
+	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;
+
+	Vector2 linear_velocity;
+	real_t angular_velocity = 0.0;
+	bool sleeping = false;
+
+	int max_contacts_reported = 0;
+	int contact_count = 0;
+
+	bool custom_integrator = false;
+
+	CCDMode ccd_mode = CCD_MODE_DISABLED;
+
+	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;
+			}
+
+			return body_shape < p_sp.body_shape;
+		}
+
+		ShapePair() {}
+		ShapePair(int p_bs, int p_ls) {
+			body_shape = p_bs;
+			local_shape = p_ls;
+		}
+	};
+	struct RigidBody2D_RemoveAction {
+		RID rid;
+		ObjectID body_id;
+		ShapePair pair;
+	};
+	struct BodyState {
+		RID rid;
+		//int rc;
+		bool in_scene = 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, PhysicsDirectBodyState2D *p_state);
+	void _body_state_changed(PhysicsDirectBodyState2D *p_state);
+
+	void _sync_body_state(PhysicsDirectBodyState2D *p_state);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+	void _validate_property(PropertyInfo &p_property) const;
+
+	GDVIRTUAL1(_integrate_forces, PhysicsDirectBodyState2D *)
+
+	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;
+
+	void set_inertia(real_t p_inertia);
+	real_t 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 Vector2 &p_center_of_mass);
+	const Vector2 &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_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_linear_velocity(const Vector2 &p_velocity);
+	Vector2 get_linear_velocity() const;
+
+	void set_axis_velocity(const Vector2 &p_axis);
+
+	void set_angular_velocity(real_t p_velocity);
+	real_t get_angular_velocity() 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_continuous_collision_detection_mode(CCDMode p_mode);
+	CCDMode get_continuous_collision_detection_mode() const;
+
+	void apply_central_impulse(const Vector2 &p_impulse);
+	void apply_impulse(const Vector2 &p_impulse, const Vector2 &p_position = Vector2());
+	void apply_torque_impulse(real_t p_torque);
+
+	void apply_central_force(const Vector2 &p_force);
+	void apply_force(const Vector2 &p_force, const Vector2 &p_position = Vector2());
+	void apply_torque(real_t p_torque);
+
+	void add_constant_central_force(const Vector2 &p_force);
+	void add_constant_force(const Vector2 &p_force, const Vector2 &p_position = Vector2());
+	void add_constant_torque(real_t p_torque);
+
+	void set_constant_force(const Vector2 &p_force);
+	Vector2 get_constant_force() const;
+
+	void set_constant_torque(real_t p_torque);
+	real_t get_constant_torque() const;
+
+	TypedArray<Node2D> get_colliding_bodies() const; //function for script
+
+	virtual PackedStringArray get_configuration_warnings() const override;
+
+	RigidBody2D();
+	~RigidBody2D();
+
+private:
+	void _reload_physics_characteristics();
+};
+
+VARIANT_ENUM_CAST(RigidBody2D::FreezeMode);
+VARIANT_ENUM_CAST(RigidBody2D::CenterOfMassMode);
+VARIANT_ENUM_CAST(RigidBody2D::DampMode);
+VARIANT_ENUM_CAST(RigidBody2D::CCDMode);
+
+#endif // RIGID_BODY_2D_H
diff --git a/scene/2d/shape_cast_2d.cpp b/scene/2d/physics/shape_cast_2d.cpp
index 38e3b3180b..00be84b622 100644
--- a/scene/2d/shape_cast_2d.cpp
+++ b/scene/2d/physics/shape_cast_2d.cpp
@@ -31,8 +31,8 @@
 #include "shape_cast_2d.h"
 
 #include "core/config/engine.h"
-#include "scene/2d/collision_object_2d.h"
-#include "scene/2d/physics_body_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
+#include "scene/2d/physics/physics_body_2d.h"
 #include "scene/resources/2d/circle_shape_2d.h"
 #include "servers/physics_2d/godot_physics_server_2d.h"
 
diff --git a/scene/2d/shape_cast_2d.h b/scene/2d/physics/shape_cast_2d.h
index 6b8fd5b798..6b8fd5b798 100644
--- a/scene/2d/shape_cast_2d.h
+++ b/scene/2d/physics/shape_cast_2d.h
diff --git a/scene/2d/physics/static_body_2d.cpp b/scene/2d/physics/static_body_2d.cpp
new file mode 100644
index 0000000000..3c5af73c1e
--- /dev/null
+++ b/scene/2d/physics/static_body_2d.cpp
@@ -0,0 +1,96 @@
+/**************************************************************************/
+/*  static_body_2d.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_2d.h"
+
+void StaticBody2D::set_constant_linear_velocity(const Vector2 &p_vel) {
+	constant_linear_velocity = p_vel;
+
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, constant_linear_velocity);
+}
+
+void StaticBody2D::set_constant_angular_velocity(real_t p_vel) {
+	constant_angular_velocity = p_vel;
+
+	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_ANGULAR_VELOCITY, constant_angular_velocity);
+}
+
+Vector2 StaticBody2D::get_constant_linear_velocity() const {
+	return constant_linear_velocity;
+}
+
+real_t StaticBody2D::get_constant_angular_velocity() const {
+	return constant_angular_velocity;
+}
+
+void StaticBody2D::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, &StaticBody2D::_reload_physics_characteristics));
+	}
+
+	physics_material_override = p_physics_material_override;
+
+	if (physics_material_override.is_valid()) {
+		physics_material_override->connect_changed(callable_mp(this, &StaticBody2D::_reload_physics_characteristics));
+	}
+	_reload_physics_characteristics();
+}
+
+Ref<PhysicsMaterial> StaticBody2D::get_physics_material_override() const {
+	return physics_material_override;
+}
+
+void StaticBody2D::_reload_physics_characteristics() {
+	if (physics_material_override.is_null()) {
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, 0);
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, 1);
+	} else {
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
+	}
+}
+
+void StaticBody2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_constant_linear_velocity", "vel"), &StaticBody2D::set_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("set_constant_angular_velocity", "vel"), &StaticBody2D::set_constant_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_linear_velocity"), &StaticBody2D::get_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_angular_velocity"), &StaticBody2D::get_constant_angular_velocity);
+
+	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &StaticBody2D::set_physics_material_override);
+	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &StaticBody2D::get_physics_material_override);
+
+	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::VECTOR2, "constant_linear_velocity", PROPERTY_HINT_NONE, "suffix:px/s"), "set_constant_linear_velocity", "get_constant_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "constant_angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_constant_angular_velocity", "get_constant_angular_velocity");
+}
+
+StaticBody2D::StaticBody2D(PhysicsServer2D::BodyMode p_mode) :
+		PhysicsBody2D(p_mode) {
+}
diff --git a/scene/2d/physics/static_body_2d.h b/scene/2d/physics/static_body_2d.h
new file mode 100644
index 0000000000..ce05596d94
--- /dev/null
+++ b/scene/2d/physics/static_body_2d.h
@@ -0,0 +1,64 @@
+/**************************************************************************/
+/*  static_body_2d.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_2D_H
+#define STATIC_BODY_2D_H
+
+#include "scene/2d/physics/physics_body_2d.h"
+
+class StaticBody2D : public PhysicsBody2D {
+	GDCLASS(StaticBody2D, PhysicsBody2D);
+
+private:
+	Vector2 constant_linear_velocity;
+	real_t constant_angular_velocity = 0.0;
+
+	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 Vector2 &p_vel);
+	void set_constant_angular_velocity(real_t p_vel);
+
+	Vector2 get_constant_linear_velocity() const;
+	real_t get_constant_angular_velocity() const;
+
+	StaticBody2D(PhysicsServer2D::BodyMode p_mode = PhysicsServer2D::BODY_MODE_STATIC);
+
+private:
+	void _reload_physics_characteristics();
+};
+
+#endif // STATIC_BODY_2D_H
diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
deleted file mode 100644
index 92af3fa3f0..0000000000
--- a/scene/2d/physics_body_2d.cpp
+++ /dev/null
@@ -1,1923 +0,0 @@
-/**************************************************************************/
-/*  physics_body_2d.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_2d.h"
-
-#include "scene/scene_string_names.h"
-
-void PhysicsBody2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("move_and_collide", "motion", "test_only", "safe_margin", "recovery_as_collision"), &PhysicsBody2D::_move, DEFVAL(false), DEFVAL(0.08), DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("test_move", "from", "motion", "collision", "safe_margin", "recovery_as_collision"), &PhysicsBody2D::test_move, DEFVAL(Variant()), DEFVAL(0.08), DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("get_gravity"), &PhysicsBody2D::get_gravity);
-
-	ClassDB::bind_method(D_METHOD("get_collision_exceptions"), &PhysicsBody2D::get_collision_exceptions);
-	ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &PhysicsBody2D::add_collision_exception_with);
-	ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &PhysicsBody2D::remove_collision_exception_with);
-}
-
-PhysicsBody2D::PhysicsBody2D(PhysicsServer2D::BodyMode p_mode) :
-		CollisionObject2D(PhysicsServer2D::get_singleton()->body_create(), false) {
-	set_body_mode(p_mode);
-	set_pickable(false);
-}
-
-PhysicsBody2D::~PhysicsBody2D() {
-	if (motion_cache.is_valid()) {
-		motion_cache->owner = nullptr;
-	}
-}
-
-Ref<KinematicCollision2D> PhysicsBody2D::_move(const Vector2 &p_motion, bool p_test_only, real_t p_margin, bool p_recovery_as_collision) {
-	PhysicsServer2D::MotionParameters parameters(get_global_transform(), p_motion, p_margin);
-	parameters.recovery_as_collision = p_recovery_as_collision;
-
-	PhysicsServer2D::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<KinematicCollision2D>();
-}
-
-bool PhysicsBody2D::move_and_collide(const PhysicsServer2D::MotionParameters &p_parameters, PhysicsServer2D::MotionResult &r_result, bool p_test_only, bool p_cancel_sliding) {
-	if (is_only_update_transform_changes_enabled()) {
-		ERR_PRINT("Move functions do not work together with 'sync to physics' option. See the documentation for details.");
-	}
-
-	bool colliding = PhysicsServer2D::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.collision_depth > p_parameters.margin + precision) {
-				p_cancel_sliding = false;
-			}
-		}
-
-		if (p_cancel_sliding) {
-			// When motion is null, recovery is the resulting motion.
-			Vector2 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);
-			Vector2 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;
-			}
-		}
-	}
-
-	if (!p_test_only) {
-		Transform2D gt = p_parameters.from;
-		gt.columns[2] += r_result.travel;
-		set_global_transform(gt);
-	}
-
-	return colliding;
-}
-
-bool PhysicsBody2D::test_move(const Transform2D &p_from, const Vector2 &p_motion, const Ref<KinematicCollision2D> &r_collision, real_t p_margin, bool p_recovery_as_collision) {
-	ERR_FAIL_COND_V(!is_inside_tree(), false);
-
-	PhysicsServer2D::MotionResult *r = nullptr;
-	PhysicsServer2D::MotionResult temp_result;
-	if (r_collision.is_valid()) {
-		// Needs const_cast because method bindings don't support non-const Ref.
-		r = const_cast<PhysicsServer2D::MotionResult *>(&r_collision->result);
-	} else {
-		r = &temp_result;
-	}
-
-	PhysicsServer2D::MotionParameters parameters(p_from, p_motion, p_margin);
-	parameters.recovery_as_collision = p_recovery_as_collision;
-
-	return PhysicsServer2D::get_singleton()->body_test_motion(get_rid(), parameters, r);
-}
-
-Vector2 PhysicsBody2D::get_gravity() const {
-	PhysicsDirectBodyState2D *state = PhysicsServer2D::get_singleton()->body_get_direct_state(get_rid());
-	ERR_FAIL_NULL_V(state, Vector2());
-	return state->get_total_gravity();
-}
-
-TypedArray<PhysicsBody2D> PhysicsBody2D::get_collision_exceptions() {
-	List<RID> exceptions;
-	PhysicsServer2D::get_singleton()->body_get_collision_exceptions(get_rid(), &exceptions);
-	Array ret;
-	for (const RID &body : exceptions) {
-		ObjectID instance_id = PhysicsServer2D::get_singleton()->body_get_object_instance_id(body);
-		Object *obj = ObjectDB::get_instance(instance_id);
-		PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(obj);
-		ret.append(physics_body);
-	}
-	return ret;
-}
-
-void PhysicsBody2D::add_collision_exception_with(Node *p_node) {
-	ERR_FAIL_NULL(p_node);
-	PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(p_node);
-	ERR_FAIL_NULL_MSG(physics_body, "Collision exception only works between two nodes that inherit from PhysicsBody2D.");
-	PhysicsServer2D::get_singleton()->body_add_collision_exception(get_rid(), physics_body->get_rid());
-}
-
-void PhysicsBody2D::remove_collision_exception_with(Node *p_node) {
-	ERR_FAIL_NULL(p_node);
-	PhysicsBody2D *physics_body = Object::cast_to<PhysicsBody2D>(p_node);
-	ERR_FAIL_NULL_MSG(physics_body, "Collision exception only works between two nodes that inherit from PhysicsBody2D.");
-	PhysicsServer2D::get_singleton()->body_remove_collision_exception(get_rid(), physics_body->get_rid());
-}
-
-void StaticBody2D::set_constant_linear_velocity(const Vector2 &p_vel) {
-	constant_linear_velocity = p_vel;
-
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, constant_linear_velocity);
-}
-
-void StaticBody2D::set_constant_angular_velocity(real_t p_vel) {
-	constant_angular_velocity = p_vel;
-
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_ANGULAR_VELOCITY, constant_angular_velocity);
-}
-
-Vector2 StaticBody2D::get_constant_linear_velocity() const {
-	return constant_linear_velocity;
-}
-
-real_t StaticBody2D::get_constant_angular_velocity() const {
-	return constant_angular_velocity;
-}
-
-void StaticBody2D::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, &StaticBody2D::_reload_physics_characteristics));
-	}
-
-	physics_material_override = p_physics_material_override;
-
-	if (physics_material_override.is_valid()) {
-		physics_material_override->connect_changed(callable_mp(this, &StaticBody2D::_reload_physics_characteristics));
-	}
-	_reload_physics_characteristics();
-}
-
-Ref<PhysicsMaterial> StaticBody2D::get_physics_material_override() const {
-	return physics_material_override;
-}
-
-void StaticBody2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant_linear_velocity", "vel"), &StaticBody2D::set_constant_linear_velocity);
-	ClassDB::bind_method(D_METHOD("set_constant_angular_velocity", "vel"), &StaticBody2D::set_constant_angular_velocity);
-	ClassDB::bind_method(D_METHOD("get_constant_linear_velocity"), &StaticBody2D::get_constant_linear_velocity);
-	ClassDB::bind_method(D_METHOD("get_constant_angular_velocity"), &StaticBody2D::get_constant_angular_velocity);
-
-	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &StaticBody2D::set_physics_material_override);
-	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &StaticBody2D::get_physics_material_override);
-
-	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::VECTOR2, "constant_linear_velocity", PROPERTY_HINT_NONE, "suffix:px/s"), "set_constant_linear_velocity", "get_constant_linear_velocity");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "constant_angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_constant_angular_velocity", "get_constant_angular_velocity");
-}
-
-StaticBody2D::StaticBody2D(PhysicsServer2D::BodyMode p_mode) :
-		PhysicsBody2D(p_mode) {
-}
-
-void StaticBody2D::_reload_physics_characteristics() {
-	if (physics_material_override.is_null()) {
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, 0);
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, 1);
-	} else {
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
-	}
-}
-
-void AnimatableBody2D::set_sync_to_physics(bool p_enable) {
-	if (sync_to_physics == p_enable) {
-		return;
-	}
-
-	sync_to_physics = p_enable;
-
-	_update_kinematic_motion();
-}
-
-bool AnimatableBody2D::is_sync_to_physics_enabled() const {
-	return sync_to_physics;
-}
-
-void AnimatableBody2D::_update_kinematic_motion() {
-#ifdef TOOLS_ENABLED
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
-	}
-#endif
-
-	if (sync_to_physics) {
-		PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &AnimatableBody2D::_body_state_changed));
-		set_only_update_transform_changes(true);
-		set_notify_local_transform(true);
-	} else {
-		PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), Callable());
-		set_only_update_transform_changes(false);
-		set_notify_local_transform(false);
-	}
-}
-
-void AnimatableBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state) {
-	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);
-}
-
-void AnimatableBody2D::_notification(int p_what) {
-	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...
-			Transform2D new_transform = get_global_transform();
-
-			PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::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);
-		} break;
-	}
-}
-
-void AnimatableBody2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_sync_to_physics", "enable"), &AnimatableBody2D::set_sync_to_physics);
-	ClassDB::bind_method(D_METHOD("is_sync_to_physics_enabled"), &AnimatableBody2D::is_sync_to_physics_enabled);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync_to_physics"), "set_sync_to_physics", "is_sync_to_physics_enabled");
-}
-
-AnimatableBody2D::AnimatableBody2D() :
-		StaticBody2D(PhysicsServer2D::BODY_MODE_KINEMATIC) {
-}
-
-void RigidBody2D::_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_scene);
-
-	contact_monitor->locked = true;
-
-	E->value.in_scene = 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 RigidBody2D::_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_scene);
-	E->value.in_scene = 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 RigidBody2D::_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_scene = node && node->is_inside_tree();
-			if (node) {
-				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody2D::_body_enter_tree).bind(objid));
-				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree).bind(objid));
-				if (E->value.in_scene) {
-					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_scene) {
-			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_scene = E->value.in_scene;
-
-		if (E->value.shapes.is_empty()) {
-			if (node) {
-				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody2D::_body_enter_tree));
-				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree));
-				if (in_scene) {
-					emit_signal(SceneStringNames::get_singleton()->body_exited, node);
-				}
-			}
-
-			contact_monitor->body_map.remove(E);
-		}
-		if (node && in_scene) {
-			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, node, p_body_shape, p_local_shape);
-		}
-	}
-}
-
-struct _RigidBody2DInOut {
-	RID rid;
-	ObjectID id;
-	int shape = 0;
-	int local_shape = 0;
-};
-
-void RigidBody2D::_sync_body_state(PhysicsDirectBodyState2D *p_state) {
-	if (!freeze || freeze_mode != FREEZE_MODE_KINEMATIC) {
-		set_block_transform_notify(true);
-		set_global_transform(p_state->get_transform());
-		set_block_transform_notify(false);
-	}
-
-	linear_velocity = p_state->get_linear_velocity();
-	angular_velocity = p_state->get_angular_velocity();
-
-	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 RigidBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state) {
-	lock_callback();
-
-	if (GDVIRTUAL_IS_OVERRIDDEN(_integrate_forces)) {
-		_sync_body_state(p_state);
-
-		Transform2D old_transform = get_global_transform();
-		GDVIRTUAL_CALL(_integrate_forces, p_state);
-		Transform2D 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.
-			PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_TRANSFORM, new_transform);
-		}
-	}
-
-	_sync_body_state(p_state);
-
-	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++;
-			}
-		}
-
-		_RigidBody2DInOut *toadd = (_RigidBody2DInOut *)alloca(p_state->get_contact_count() * sizeof(_RigidBody2DInOut));
-		int toadd_count = 0; //state->get_contact_count();
-		RigidBody2D_RemoveAction *toremove = (RigidBody2D_RemoveAction *)alloca(rc * sizeof(RigidBody2D_RemoveAction));
-		int toremove_count = 0;
-
-		//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, toadd[i].rid, toadd[i].id, toadd[i].shape, toadd[i].local_shape);
-		}
-
-		contact_monitor->locked = false;
-	}
-
-	unlock_callback();
-}
-
-void RigidBody2D::_apply_body_mode() {
-	if (freeze) {
-		switch (freeze_mode) {
-			case FREEZE_MODE_STATIC: {
-				set_body_mode(PhysicsServer2D::BODY_MODE_STATIC);
-			} break;
-			case FREEZE_MODE_KINEMATIC: {
-				set_body_mode(PhysicsServer2D::BODY_MODE_KINEMATIC);
-			} break;
-		}
-	} else if (lock_rotation) {
-		set_body_mode(PhysicsServer2D::BODY_MODE_RIGID_LINEAR);
-	} else {
-		set_body_mode(PhysicsServer2D::BODY_MODE_RIGID);
-	}
-}
-
-void RigidBody2D::set_lock_rotation_enabled(bool p_lock_rotation) {
-	if (p_lock_rotation == lock_rotation) {
-		return;
-	}
-
-	lock_rotation = p_lock_rotation;
-	_apply_body_mode();
-}
-
-bool RigidBody2D::is_lock_rotation_enabled() const {
-	return lock_rotation;
-}
-
-void RigidBody2D::set_freeze_enabled(bool p_freeze) {
-	if (p_freeze == freeze) {
-		return;
-	}
-
-	freeze = p_freeze;
-	_apply_body_mode();
-}
-
-bool RigidBody2D::is_freeze_enabled() const {
-	return freeze;
-}
-
-void RigidBody2D::set_freeze_mode(FreezeMode p_freeze_mode) {
-	if (p_freeze_mode == freeze_mode) {
-		return;
-	}
-
-	freeze_mode = p_freeze_mode;
-	_apply_body_mode();
-}
-
-RigidBody2D::FreezeMode RigidBody2D::get_freeze_mode() const {
-	return freeze_mode;
-}
-
-void RigidBody2D::set_mass(real_t p_mass) {
-	ERR_FAIL_COND(p_mass <= 0);
-	mass = p_mass;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_MASS, mass);
-}
-
-real_t RigidBody2D::get_mass() const {
-	return mass;
-}
-
-void RigidBody2D::set_inertia(real_t p_inertia) {
-	ERR_FAIL_COND(p_inertia < 0);
-	inertia = p_inertia;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_INERTIA, inertia);
-}
-
-real_t RigidBody2D::get_inertia() const {
-	return inertia;
-}
-
-void RigidBody2D::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 = Vector2();
-			PhysicsServer2D::get_singleton()->body_reset_mass_properties(get_rid());
-			if (inertia != 0.0) {
-				PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_INERTIA, inertia);
-			}
-		} break;
-
-		case CENTER_OF_MASS_MODE_CUSTOM: {
-			PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
-		} break;
-	}
-}
-
-RigidBody2D::CenterOfMassMode RigidBody2D::get_center_of_mass_mode() const {
-	return center_of_mass_mode;
-}
-
-void RigidBody2D::set_center_of_mass(const Vector2 &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;
-
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
-}
-
-const Vector2 &RigidBody2D::get_center_of_mass() const {
-	return center_of_mass;
-}
-
-void RigidBody2D::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, &RigidBody2D::_reload_physics_characteristics));
-	}
-
-	physics_material_override = p_physics_material_override;
-
-	if (physics_material_override.is_valid()) {
-		physics_material_override->connect_changed(callable_mp(this, &RigidBody2D::_reload_physics_characteristics));
-	}
-	_reload_physics_characteristics();
-}
-
-Ref<PhysicsMaterial> RigidBody2D::get_physics_material_override() const {
-	return physics_material_override;
-}
-
-void RigidBody2D::set_gravity_scale(real_t p_gravity_scale) {
-	gravity_scale = p_gravity_scale;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
-}
-
-real_t RigidBody2D::get_gravity_scale() const {
-	return gravity_scale;
-}
-
-void RigidBody2D::set_linear_damp_mode(DampMode p_mode) {
-	linear_damp_mode = p_mode;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_LINEAR_DAMP_MODE, linear_damp_mode);
-}
-
-RigidBody2D::DampMode RigidBody2D::get_linear_damp_mode() const {
-	return linear_damp_mode;
-}
-
-void RigidBody2D::set_angular_damp_mode(DampMode p_mode) {
-	angular_damp_mode = p_mode;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_ANGULAR_DAMP_MODE, angular_damp_mode);
-}
-
-RigidBody2D::DampMode RigidBody2D::get_angular_damp_mode() const {
-	return angular_damp_mode;
-}
-
-void RigidBody2D::set_linear_damp(real_t p_linear_damp) {
-	ERR_FAIL_COND(p_linear_damp < -1);
-	linear_damp = p_linear_damp;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_LINEAR_DAMP, linear_damp);
-}
-
-real_t RigidBody2D::get_linear_damp() const {
-	return linear_damp;
-}
-
-void RigidBody2D::set_angular_damp(real_t p_angular_damp) {
-	ERR_FAIL_COND(p_angular_damp < -1);
-	angular_damp = p_angular_damp;
-	PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_ANGULAR_DAMP, angular_damp);
-}
-
-real_t RigidBody2D::get_angular_damp() const {
-	return angular_damp;
-}
-
-void RigidBody2D::set_axis_velocity(const Vector2 &p_axis) {
-	Vector2 axis = p_axis.normalized();
-	linear_velocity -= axis * axis.dot(linear_velocity);
-	linear_velocity += p_axis;
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
-}
-
-void RigidBody2D::set_linear_velocity(const Vector2 &p_velocity) {
-	linear_velocity = p_velocity;
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
-}
-
-Vector2 RigidBody2D::get_linear_velocity() const {
-	return linear_velocity;
-}
-
-void RigidBody2D::set_angular_velocity(real_t p_velocity) {
-	angular_velocity = p_velocity;
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
-}
-
-real_t RigidBody2D::get_angular_velocity() const {
-	return angular_velocity;
-}
-
-void RigidBody2D::set_use_custom_integrator(bool p_enable) {
-	if (custom_integrator == p_enable) {
-		return;
-	}
-
-	custom_integrator = p_enable;
-	PhysicsServer2D::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
-}
-
-bool RigidBody2D::is_using_custom_integrator() {
-	return custom_integrator;
-}
-
-void RigidBody2D::set_sleeping(bool p_sleeping) {
-	sleeping = p_sleeping;
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_SLEEPING, sleeping);
-}
-
-void RigidBody2D::set_can_sleep(bool p_active) {
-	can_sleep = p_active;
-	PhysicsServer2D::get_singleton()->body_set_state(get_rid(), PhysicsServer2D::BODY_STATE_CAN_SLEEP, p_active);
-}
-
-bool RigidBody2D::is_able_to_sleep() const {
-	return can_sleep;
-}
-
-bool RigidBody2D::is_sleeping() const {
-	return sleeping;
-}
-
-void RigidBody2D::set_max_contacts_reported(int p_amount) {
-	max_contacts_reported = p_amount;
-	PhysicsServer2D::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
-}
-
-int RigidBody2D::get_max_contacts_reported() const {
-	return max_contacts_reported;
-}
-
-int RigidBody2D::get_contact_count() const {
-	return contact_count;
-}
-
-void RigidBody2D::apply_central_impulse(const Vector2 &p_impulse) {
-	PhysicsServer2D::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);
-}
-
-void RigidBody2D::apply_impulse(const Vector2 &p_impulse, const Vector2 &p_position) {
-	PhysicsServer2D::get_singleton()->body_apply_impulse(get_rid(), p_impulse, p_position);
-}
-
-void RigidBody2D::apply_torque_impulse(real_t p_torque) {
-	PhysicsServer2D::get_singleton()->body_apply_torque_impulse(get_rid(), p_torque);
-}
-
-void RigidBody2D::apply_central_force(const Vector2 &p_force) {
-	PhysicsServer2D::get_singleton()->body_apply_central_force(get_rid(), p_force);
-}
-
-void RigidBody2D::apply_force(const Vector2 &p_force, const Vector2 &p_position) {
-	PhysicsServer2D::get_singleton()->body_apply_force(get_rid(), p_force, p_position);
-}
-
-void RigidBody2D::apply_torque(real_t p_torque) {
-	PhysicsServer2D::get_singleton()->body_apply_torque(get_rid(), p_torque);
-}
-
-void RigidBody2D::add_constant_central_force(const Vector2 &p_force) {
-	PhysicsServer2D::get_singleton()->body_add_constant_central_force(get_rid(), p_force);
-}
-
-void RigidBody2D::add_constant_force(const Vector2 &p_force, const Vector2 &p_position) {
-	PhysicsServer2D::get_singleton()->body_add_constant_force(get_rid(), p_force, p_position);
-}
-
-void RigidBody2D::add_constant_torque(const real_t p_torque) {
-	PhysicsServer2D::get_singleton()->body_add_constant_torque(get_rid(), p_torque);
-}
-
-void RigidBody2D::set_constant_force(const Vector2 &p_force) {
-	PhysicsServer2D::get_singleton()->body_set_constant_force(get_rid(), p_force);
-}
-
-Vector2 RigidBody2D::get_constant_force() const {
-	return PhysicsServer2D::get_singleton()->body_get_constant_force(get_rid());
-}
-
-void RigidBody2D::set_constant_torque(real_t p_torque) {
-	PhysicsServer2D::get_singleton()->body_set_constant_torque(get_rid(), p_torque);
-}
-
-real_t RigidBody2D::get_constant_torque() const {
-	return PhysicsServer2D::get_singleton()->body_get_constant_torque(get_rid());
-}
-
-void RigidBody2D::set_continuous_collision_detection_mode(CCDMode p_mode) {
-	ccd_mode = p_mode;
-	PhysicsServer2D::get_singleton()->body_set_continuous_collision_detection_mode(get_rid(), PhysicsServer2D::CCDMode(p_mode));
-}
-
-RigidBody2D::CCDMode RigidBody2D::get_continuous_collision_detection_mode() const {
-	return ccd_mode;
-}
-
-TypedArray<Node2D> RigidBody2D::get_colliding_bodies() const {
-	ERR_FAIL_NULL_V(contact_monitor, TypedArray<Node2D>());
-
-	TypedArray<Node2D> 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 RigidBody2D::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, &RigidBody2D::_body_enter_tree));
-				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody2D::_body_exit_tree));
-			}
-		}
-
-		memdelete(contact_monitor);
-		contact_monitor = nullptr;
-	} else {
-		contact_monitor = memnew(ContactMonitor);
-		contact_monitor->locked = false;
-	}
-}
-
-bool RigidBody2D::is_contact_monitor_enabled() const {
-	return contact_monitor != nullptr;
-}
-
-void RigidBody2D::_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
-}
-
-PackedStringArray RigidBody2D::get_configuration_warnings() const {
-	Transform2D t = get_transform();
-
-	PackedStringArray warnings = CollisionObject2D::get_configuration_warnings();
-
-	if (ABS(t.columns[0].length() - 1.0) > 0.05 || ABS(t.columns[1].length() - 1.0) > 0.05) {
-		warnings.push_back(RTR("Size changes to RigidBody2D will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
-	}
-
-	return warnings;
-}
-
-void RigidBody2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_mass", "mass"), &RigidBody2D::set_mass);
-	ClassDB::bind_method(D_METHOD("get_mass"), &RigidBody2D::get_mass);
-
-	ClassDB::bind_method(D_METHOD("get_inertia"), &RigidBody2D::get_inertia);
-	ClassDB::bind_method(D_METHOD("set_inertia", "inertia"), &RigidBody2D::set_inertia);
-
-	ClassDB::bind_method(D_METHOD("set_center_of_mass_mode", "mode"), &RigidBody2D::set_center_of_mass_mode);
-	ClassDB::bind_method(D_METHOD("get_center_of_mass_mode"), &RigidBody2D::get_center_of_mass_mode);
-
-	ClassDB::bind_method(D_METHOD("set_center_of_mass", "center_of_mass"), &RigidBody2D::set_center_of_mass);
-	ClassDB::bind_method(D_METHOD("get_center_of_mass"), &RigidBody2D::get_center_of_mass);
-
-	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody2D::set_physics_material_override);
-	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody2D::get_physics_material_override);
-
-	ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &RigidBody2D::set_gravity_scale);
-	ClassDB::bind_method(D_METHOD("get_gravity_scale"), &RigidBody2D::get_gravity_scale);
-
-	ClassDB::bind_method(D_METHOD("set_linear_damp_mode", "linear_damp_mode"), &RigidBody2D::set_linear_damp_mode);
-	ClassDB::bind_method(D_METHOD("get_linear_damp_mode"), &RigidBody2D::get_linear_damp_mode);
-
-	ClassDB::bind_method(D_METHOD("set_angular_damp_mode", "angular_damp_mode"), &RigidBody2D::set_angular_damp_mode);
-	ClassDB::bind_method(D_METHOD("get_angular_damp_mode"), &RigidBody2D::get_angular_damp_mode);
-
-	ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &RigidBody2D::set_linear_damp);
-	ClassDB::bind_method(D_METHOD("get_linear_damp"), &RigidBody2D::get_linear_damp);
-
-	ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &RigidBody2D::set_angular_damp);
-	ClassDB::bind_method(D_METHOD("get_angular_damp"), &RigidBody2D::get_angular_damp);
-
-	ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &RigidBody2D::set_linear_velocity);
-	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &RigidBody2D::get_linear_velocity);
-
-	ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &RigidBody2D::set_angular_velocity);
-	ClassDB::bind_method(D_METHOD("get_angular_velocity"), &RigidBody2D::get_angular_velocity);
-
-	ClassDB::bind_method(D_METHOD("set_max_contacts_reported", "amount"), &RigidBody2D::set_max_contacts_reported);
-	ClassDB::bind_method(D_METHOD("get_max_contacts_reported"), &RigidBody2D::get_max_contacts_reported);
-	ClassDB::bind_method(D_METHOD("get_contact_count"), &RigidBody2D::get_contact_count);
-
-	ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &RigidBody2D::set_use_custom_integrator);
-	ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &RigidBody2D::is_using_custom_integrator);
-
-	ClassDB::bind_method(D_METHOD("set_contact_monitor", "enabled"), &RigidBody2D::set_contact_monitor);
-	ClassDB::bind_method(D_METHOD("is_contact_monitor_enabled"), &RigidBody2D::is_contact_monitor_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_continuous_collision_detection_mode", "mode"), &RigidBody2D::set_continuous_collision_detection_mode);
-	ClassDB::bind_method(D_METHOD("get_continuous_collision_detection_mode"), &RigidBody2D::get_continuous_collision_detection_mode);
-
-	ClassDB::bind_method(D_METHOD("set_axis_velocity", "axis_velocity"), &RigidBody2D::set_axis_velocity);
-	ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody2D::apply_central_impulse, Vector2());
-	ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &RigidBody2D::apply_impulse, Vector2());
-	ClassDB::bind_method(D_METHOD("apply_torque_impulse", "torque"), &RigidBody2D::apply_torque_impulse);
-
-	ClassDB::bind_method(D_METHOD("apply_central_force", "force"), &RigidBody2D::apply_central_force);
-	ClassDB::bind_method(D_METHOD("apply_force", "force", "position"), &RigidBody2D::apply_force, Vector2());
-	ClassDB::bind_method(D_METHOD("apply_torque", "torque"), &RigidBody2D::apply_torque);
-
-	ClassDB::bind_method(D_METHOD("add_constant_central_force", "force"), &RigidBody2D::add_constant_central_force);
-	ClassDB::bind_method(D_METHOD("add_constant_force", "force", "position"), &RigidBody2D::add_constant_force, Vector2());
-	ClassDB::bind_method(D_METHOD("add_constant_torque", "torque"), &RigidBody2D::add_constant_torque);
-
-	ClassDB::bind_method(D_METHOD("set_constant_force", "force"), &RigidBody2D::set_constant_force);
-	ClassDB::bind_method(D_METHOD("get_constant_force"), &RigidBody2D::get_constant_force);
-
-	ClassDB::bind_method(D_METHOD("set_constant_torque", "torque"), &RigidBody2D::set_constant_torque);
-	ClassDB::bind_method(D_METHOD("get_constant_torque"), &RigidBody2D::get_constant_torque);
-
-	ClassDB::bind_method(D_METHOD("set_sleeping", "sleeping"), &RigidBody2D::set_sleeping);
-	ClassDB::bind_method(D_METHOD("is_sleeping"), &RigidBody2D::is_sleeping);
-
-	ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &RigidBody2D::set_can_sleep);
-	ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &RigidBody2D::is_able_to_sleep);
-
-	ClassDB::bind_method(D_METHOD("set_lock_rotation_enabled", "lock_rotation"), &RigidBody2D::set_lock_rotation_enabled);
-	ClassDB::bind_method(D_METHOD("is_lock_rotation_enabled"), &RigidBody2D::is_lock_rotation_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_freeze_enabled", "freeze_mode"), &RigidBody2D::set_freeze_enabled);
-	ClassDB::bind_method(D_METHOD("is_freeze_enabled"), &RigidBody2D::is_freeze_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_freeze_mode", "freeze_mode"), &RigidBody2D::set_freeze_mode);
-	ClassDB::bind_method(D_METHOD("get_freeze_mode"), &RigidBody2D::get_freeze_mode);
-
-	ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidBody2D::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::VECTOR2, "center_of_mass", PROPERTY_HINT_RANGE, "-10,10,0.01,or_less,or_greater,suffix:px"), "set_center_of_mass", "get_center_of_mass");
-	ADD_LINKED_PROPERTY("center_of_mass_mode", "center_of_mass");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "inertia", PROPERTY_HINT_RANGE, U"0,1000,0.01,or_greater,exp,suffix:kg\u22C5px\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::INT, "continuous_cd", PROPERTY_HINT_ENUM, "Disabled,Cast Ray,Cast Shape"), "set_continuous_collision_detection_mode", "get_continuous_collision_detection_mode");
-	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::VECTOR2, "linear_velocity", PROPERTY_HINT_NONE, "suffix:px/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, "-1,100,0.001,or_greater"), "set_linear_damp", "get_linear_damp");
-	ADD_GROUP("Angular", "angular_");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "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, "-1,100,0.001,or_greater"), "set_angular_damp", "get_angular_damp");
-	ADD_GROUP("Constant Forces", "constant_");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "constant_force", PROPERTY_HINT_NONE, U"suffix:kg\u22C5px/s\u00B2"), "set_constant_force", "get_constant_force");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "constant_torque", PROPERTY_HINT_NONE, U"suffix:kg\u22C5px\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);
-
-	BIND_ENUM_CONSTANT(CCD_MODE_DISABLED);
-	BIND_ENUM_CONSTANT(CCD_MODE_CAST_RAY);
-	BIND_ENUM_CONSTANT(CCD_MODE_CAST_SHAPE);
-}
-
-void RigidBody2D::_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;
-		}
-	}
-}
-
-RigidBody2D::RigidBody2D() :
-		PhysicsBody2D(PhysicsServer2D::BODY_MODE_RIGID) {
-	PhysicsServer2D::get_singleton()->body_set_state_sync_callback(get_rid(), callable_mp(this, &RigidBody2D::_body_state_changed));
-}
-
-RigidBody2D::~RigidBody2D() {
-	if (contact_monitor) {
-		memdelete(contact_monitor);
-	}
-}
-
-void RigidBody2D::_reload_physics_characteristics() {
-	if (physics_material_override.is_null()) {
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, 0);
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, 1);
-	} else {
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
-		PhysicsServer2D::get_singleton()->body_set_param(get_rid(), PhysicsServer2D::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
-	}
-}
-
-//////////////////////////
-
-// So, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
-#define FLOOR_ANGLE_THRESHOLD 0.01
-
-bool CharacterBody2D::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();
-
-	Vector2 current_platform_velocity = platform_velocity;
-	Transform2D gt = get_global_transform();
-	previous_position = gt.columns[2];
-
-	if ((on_floor || on_wall) && platform_rid.is_valid()) {
-		bool excluded = false;
-		if (on_floor) {
-			excluded = (platform_floor_layers & platform_layer) == 0;
-		} else if (on_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
-			PhysicsDirectBodyState2D *bs = PhysicsServer2D::get_singleton()->body_get_direct_state(platform_rid);
-			if (bs) {
-				Vector2 local_position = gt.columns[2] - bs->get_transform().columns[2];
-				current_platform_velocity = bs->get_velocity_at_local_position(local_position);
-			} else {
-				// Body is removed or destroyed, invalidate floor.
-				current_platform_velocity = Vector2();
-				platform_rid = RID();
-			}
-		} else {
-			current_platform_velocity = Vector2();
-		}
-	}
-
-	motion_results.clear();
-	last_motion = Vector2();
-
-	bool was_on_floor = on_floor;
-	on_floor = false;
-	on_ceiling = false;
-	on_wall = false;
-
-	if (!current_platform_velocity.is_zero_approx()) {
-		PhysicsServer2D::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);
-		}
-
-		PhysicsServer2D::MotionResult floor_result;
-		if (move_and_collide(parameters, floor_result, false, false)) {
-			motion_results.push_back(floor_result);
-			_set_collision_direction(floor_result);
-		}
-	}
-
-	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 (!on_floor && !on_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 CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_floor) {
-	Vector2 motion = velocity * p_delta;
-	Vector2 motion_slide_up = motion.slide(up_direction);
-
-	Vector2 prev_floor_normal = floor_normal;
-
-	platform_rid = RID();
-	platform_object_id = ObjectID();
-	floor_normal = Vector2();
-	platform_velocity = Vector2();
-
-	// 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;
-	Vector2 last_travel;
-
-	for (int iteration = 0; iteration < max_slides; ++iteration) {
-		PhysicsServer2D::MotionParameters parameters(get_global_transform(), motion, margin);
-		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
-
-		Vector2 prev_position = parameters.from.columns[2];
-
-		PhysicsServer2D::MotionResult result;
-		bool collided = move_and_collide(parameters, result, false, !sliding_enabled);
-
-		last_motion = result.travel;
-
-		if (collided) {
-			motion_results.push_back(result);
-			_set_collision_direction(result);
-
-			// If we hit a ceiling platform, we set the vertical velocity to at least the platform one.
-			if (on_ceiling && result.collider_velocity != Vector2() && result.collider_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 || (result.collision_normal + up_direction).length() < 0.01) {
-					apply_ceiling_velocity = true;
-					Vector2 ceiling_vertical_velocity = up_direction * up_direction.dot(result.collider_velocity);
-					Vector2 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 (on_floor && floor_stop_on_slope && (velocity.normalized() + up_direction).length() < 0.01) {
-				Transform2D gt = get_global_transform();
-				if (result.travel.length() <= margin + CMP_EPSILON) {
-					gt.columns[2] -= result.travel;
-				}
-				set_global_transform(gt);
-				velocity = Vector2();
-				last_motion = Vector2();
-				motion = Vector2();
-				break;
-			}
-
-			if (result.remainder.is_zero_approx()) {
-				motion = Vector2();
-				break;
-			}
-
-			// Move on floor only checks.
-			if (floor_block_on_wall && on_wall && motion_slide_up.dot(result.collision_normal) <= 0) {
-				// Avoid to move forward on a wall if floor_block_on_wall is true.
-				if (p_was_on_floor && !on_floor && !vel_dir_facing_up) {
-					// If the movement is large the body can be prevented from reaching the walls.
-					if (result.travel.length() <= margin + CMP_EPSILON) {
-						// Cancels the motion.
-						Transform2D gt = get_global_transform();
-						gt.columns[2] -= result.travel;
-						set_global_transform(gt);
-					}
-					// Determines if you are on the ground.
-					_snap_on_floor(true, false, true);
-					velocity = Vector2();
-					last_motion = Vector2();
-					motion = Vector2();
-					break;
-				}
-				// Prevents the body from being able to climb a slope when it moves forward against the wall.
-				else if (!on_floor) {
-					motion = up_direction * up_direction.dot(result.remainder);
-					motion = motion.slide(result.collision_normal);
-				} else {
-					motion = result.remainder;
-				}
-			}
-			// Constant Speed when the slope is upward.
-			else if (floor_constant_speed && is_on_floor_only() && can_apply_constant_speed && p_was_on_floor && motion.dot(result.collision_normal) < 0) {
-				can_apply_constant_speed = false;
-				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
-				motion = motion_slide_norm * (motion_slide_up.length() - result.travel.slide(up_direction).length() - last_travel.slide(up_direction).length());
-			}
-			// Regular sliding, the last part of the test handle the case when you don't want to slide on the ceiling.
-			else if ((sliding_enabled || !on_floor) && (!on_ceiling || slide_on_ceiling || !vel_dir_facing_up) && !apply_ceiling_velocity) {
-				Vector2 slide_motion = result.remainder.slide(result.collision_normal);
-				if (slide_motion.dot(velocity) > 0.0) {
-					motion = slide_motion;
-				} else {
-					motion = Vector2();
-				}
-				if (slide_on_ceiling && on_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(result.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 (on_ceiling && !slide_on_ceiling && vel_dir_facing_up) {
-					velocity = velocity.slide(up_direction);
-					motion = motion.slide(up_direction);
-				}
-			}
-
-			last_travel = result.travel;
-		}
-		// 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;
-			Transform2D gt = get_global_transform();
-			gt.columns[2] = prev_position;
-			set_global_transform(gt);
-
-			Vector2 motion_slide_norm = motion.slide(prev_floor_normal).normalized();
-			motion = motion_slide_norm * (motion_slide_up.length());
-			collided = true;
-		}
-
-		can_apply_constant_speed = !can_apply_constant_speed && !sliding_enabled;
-		sliding_enabled = true;
-		first_slide = false;
-
-		if (!collided || motion.is_zero_approx()) {
-			break;
-		}
-	}
-
-	_snap_on_floor(p_was_on_floor, vel_dir_facing_up);
-
-	// Scales the horizontal velocity according to the wall slope.
-	if (is_on_wall_only() && motion_slide_up.dot(motion_results.get(0).collision_normal) < 0) {
-		Vector2 slide_motion = velocity.slide(motion_results.get(0).collision_normal);
-		if (motion_slide_up.dot(slide_motion) < 0) {
-			velocity = up_direction * up_direction.dot(velocity);
-		} else {
-			// 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);
-		}
-	}
-
-	// Reset the gravity accumulation when touching the ground.
-	if (on_floor && !vel_dir_facing_up) {
-		velocity = velocity.slide(up_direction);
-	}
-}
-
-void CharacterBody2D::_move_and_slide_floating(double p_delta) {
-	Vector2 motion = velocity * p_delta;
-
-	platform_rid = RID();
-	platform_object_id = ObjectID();
-	floor_normal = Vector2();
-	platform_velocity = Vector2();
-
-	bool first_slide = true;
-	for (int iteration = 0; iteration < max_slides; ++iteration) {
-		PhysicsServer2D::MotionParameters parameters(get_global_transform(), motion, margin);
-		parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
-
-		PhysicsServer2D::MotionResult result;
-		bool collided = move_and_collide(parameters, result, false, false);
-
-		last_motion = result.travel;
-
-		if (collided) {
-			motion_results.push_back(result);
-			_set_collision_direction(result);
-
-			if (result.remainder.is_zero_approx()) {
-				motion = Vector2();
-				break;
-			}
-
-			if (wall_min_slide_angle != 0 && result.get_angle(-velocity.normalized()) < wall_min_slide_angle + FLOOR_ANGLE_THRESHOLD) {
-				motion = Vector2();
-			} else if (first_slide) {
-				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
-				motion = motion_slide_norm * (motion.length() - result.travel.length());
-			} else {
-				motion = result.remainder.slide(result.collision_normal);
-			}
-
-			if (motion.dot(velocity) <= 0.0) {
-				motion = Vector2();
-			}
-		}
-
-		if (!collided || motion.is_zero_approx()) {
-			break;
-		}
-
-		first_slide = false;
-	}
-}
-void CharacterBody2D::apply_floor_snap() {
-	_apply_floor_snap();
-}
-
-// Method that avoids the p_wall_as_floor parameter for the public method.
-void CharacterBody2D::_apply_floor_snap(bool p_wall_as_floor) {
-	if (on_floor) {
-		return;
-	}
-
-	// Snap by at least collision margin to keep floor state consistent.
-	real_t length = MAX(floor_snap_length, margin);
-
-	PhysicsServer2D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
-	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
-	parameters.collide_separation_ray = true;
-
-	PhysicsServer2D::MotionResult result;
-	if (move_and_collide(parameters, result, true, false)) {
-		if ((result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) ||
-				(p_wall_as_floor && result.get_angle(-up_direction) > floor_max_angle + FLOOR_ANGLE_THRESHOLD)) {
-			on_floor = true;
-			floor_normal = result.collision_normal;
-			_set_platform_data(result);
-
-			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 = Vector2();
-				}
-			}
-
-			parameters.from.columns[2] += result.travel;
-			set_global_transform(parameters.from);
-		}
-	}
-}
-
-void CharacterBody2D::_snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up, bool p_wall_as_floor) {
-	if (on_floor || !p_was_on_floor || p_vel_dir_facing_up) {
-		return;
-	}
-
-	_apply_floor_snap(p_wall_as_floor);
-}
-
-bool CharacterBody2D::_on_floor_if_snapped(bool p_was_on_floor, bool p_vel_dir_facing_up) {
-	if (up_direction == Vector2() || on_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);
-
-	PhysicsServer2D::MotionParameters parameters(get_global_transform(), -up_direction * length, margin);
-	parameters.recovery_as_collision = true; // Also report collisions generated only from recovery.
-	parameters.collide_separation_ray = true;
-
-	PhysicsServer2D::MotionResult result;
-	if (move_and_collide(parameters, result, true, false)) {
-		if (result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-void CharacterBody2D::_set_collision_direction(const PhysicsServer2D::MotionResult &p_result) {
-	if (motion_mode == MOTION_MODE_GROUNDED && p_result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
-		on_floor = true;
-		floor_normal = p_result.collision_normal;
-		_set_platform_data(p_result);
-	} else if (motion_mode == MOTION_MODE_GROUNDED && p_result.get_angle(-up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
-		on_ceiling = true;
-	} else {
-		on_wall = true;
-		wall_normal = p_result.collision_normal;
-		// Don't apply wall velocity when the collider is a CharacterBody2D.
-		if (Object::cast_to<CharacterBody2D>(ObjectDB::get_instance(p_result.collider_id)) == nullptr) {
-			_set_platform_data(p_result);
-		}
-	}
-}
-
-void CharacterBody2D::_set_platform_data(const PhysicsServer2D::MotionResult &p_result) {
-	platform_rid = p_result.collider;
-	platform_object_id = p_result.collider_id;
-	platform_velocity = p_result.collider_velocity;
-	platform_layer = PhysicsServer2D::get_singleton()->body_get_collision_layer(platform_rid);
-}
-
-const Vector2 &CharacterBody2D::get_velocity() const {
-	return velocity;
-}
-
-void CharacterBody2D::set_velocity(const Vector2 &p_velocity) {
-	velocity = p_velocity;
-}
-
-bool CharacterBody2D::is_on_floor() const {
-	return on_floor;
-}
-
-bool CharacterBody2D::is_on_floor_only() const {
-	return on_floor && !on_wall && !on_ceiling;
-}
-
-bool CharacterBody2D::is_on_wall() const {
-	return on_wall;
-}
-
-bool CharacterBody2D::is_on_wall_only() const {
-	return on_wall && !on_floor && !on_ceiling;
-}
-
-bool CharacterBody2D::is_on_ceiling() const {
-	return on_ceiling;
-}
-
-bool CharacterBody2D::is_on_ceiling_only() const {
-	return on_ceiling && !on_floor && !on_wall;
-}
-
-const Vector2 &CharacterBody2D::get_floor_normal() const {
-	return floor_normal;
-}
-
-const Vector2 &CharacterBody2D::get_wall_normal() const {
-	return wall_normal;
-}
-
-const Vector2 &CharacterBody2D::get_last_motion() const {
-	return last_motion;
-}
-
-Vector2 CharacterBody2D::get_position_delta() const {
-	return get_global_transform().columns[2] - previous_position;
-}
-
-const Vector2 &CharacterBody2D::get_real_velocity() const {
-	return real_velocity;
-}
-
-real_t CharacterBody2D::get_floor_angle(const Vector2 &p_up_direction) const {
-	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
-	return Math::acos(floor_normal.dot(p_up_direction));
-}
-
-const Vector2 &CharacterBody2D::get_platform_velocity() const {
-	return platform_velocity;
-}
-
-int CharacterBody2D::get_slide_collision_count() const {
-	return motion_results.size();
-}
-
-PhysicsServer2D::MotionResult CharacterBody2D::get_slide_collision(int p_bounce) const {
-	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), PhysicsServer2D::MotionResult());
-	return motion_results[p_bounce];
-}
-
-Ref<KinematicCollision2D> CharacterBody2D::_get_slide_collision(int p_bounce) {
-	ERR_FAIL_INDEX_V(p_bounce, motion_results.size(), Ref<KinematicCollision2D>());
-	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<KinematicCollision2D> CharacterBody2D::_get_last_slide_collision() {
-	if (motion_results.size() == 0) {
-		return Ref<KinematicCollision2D>();
-	}
-	return _get_slide_collision(motion_results.size() - 1);
-}
-
-void CharacterBody2D::set_safe_margin(real_t p_margin) {
-	margin = p_margin;
-}
-
-real_t CharacterBody2D::get_safe_margin() const {
-	return margin;
-}
-
-bool CharacterBody2D::is_floor_stop_on_slope_enabled() const {
-	return floor_stop_on_slope;
-}
-
-void CharacterBody2D::set_floor_stop_on_slope_enabled(bool p_enabled) {
-	floor_stop_on_slope = p_enabled;
-}
-
-bool CharacterBody2D::is_floor_constant_speed_enabled() const {
-	return floor_constant_speed;
-}
-
-void CharacterBody2D::set_floor_constant_speed_enabled(bool p_enabled) {
-	floor_constant_speed = p_enabled;
-}
-
-bool CharacterBody2D::is_floor_block_on_wall_enabled() const {
-	return floor_block_on_wall;
-}
-
-void CharacterBody2D::set_floor_block_on_wall_enabled(bool p_enabled) {
-	floor_block_on_wall = p_enabled;
-}
-
-bool CharacterBody2D::is_slide_on_ceiling_enabled() const {
-	return slide_on_ceiling;
-}
-
-void CharacterBody2D::set_slide_on_ceiling_enabled(bool p_enabled) {
-	slide_on_ceiling = p_enabled;
-}
-
-uint32_t CharacterBody2D::get_platform_floor_layers() const {
-	return platform_floor_layers;
-}
-
-void CharacterBody2D::set_platform_floor_layers(uint32_t p_exclude_layers) {
-	platform_floor_layers = p_exclude_layers;
-}
-
-uint32_t CharacterBody2D::get_platform_wall_layers() const {
-	return platform_wall_layers;
-}
-
-void CharacterBody2D::set_platform_wall_layers(uint32_t p_exclude_layers) {
-	platform_wall_layers = p_exclude_layers;
-}
-
-void CharacterBody2D::set_motion_mode(MotionMode p_mode) {
-	motion_mode = p_mode;
-}
-
-CharacterBody2D::MotionMode CharacterBody2D::get_motion_mode() const {
-	return motion_mode;
-}
-
-void CharacterBody2D::set_platform_on_leave(PlatformOnLeave p_on_leave_apply_velocity) {
-	platform_on_leave = p_on_leave_apply_velocity;
-}
-
-CharacterBody2D::PlatformOnLeave CharacterBody2D::get_platform_on_leave() const {
-	return platform_on_leave;
-}
-
-int CharacterBody2D::get_max_slides() const {
-	return max_slides;
-}
-
-void CharacterBody2D::set_max_slides(int p_max_slides) {
-	ERR_FAIL_COND(p_max_slides < 1);
-	max_slides = p_max_slides;
-}
-
-real_t CharacterBody2D::get_floor_max_angle() const {
-	return floor_max_angle;
-}
-
-void CharacterBody2D::set_floor_max_angle(real_t p_radians) {
-	floor_max_angle = p_radians;
-}
-
-real_t CharacterBody2D::get_floor_snap_length() {
-	return floor_snap_length;
-}
-
-void CharacterBody2D::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 CharacterBody2D::get_wall_min_slide_angle() const {
-	return wall_min_slide_angle;
-}
-
-void CharacterBody2D::set_wall_min_slide_angle(real_t p_radians) {
-	wall_min_slide_angle = p_radians;
-}
-
-const Vector2 &CharacterBody2D::get_up_direction() const {
-	return up_direction;
-}
-
-void CharacterBody2D::set_up_direction(const Vector2 &p_up_direction) {
-	ERR_FAIL_COND_MSG(p_up_direction == Vector2(), "up_direction can't be equal to Vector2.ZERO, consider using Floating motion mode instead.");
-	up_direction = p_up_direction.normalized();
-}
-
-void CharacterBody2D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			// Reset move_and_slide() data.
-			on_floor = false;
-			platform_rid = RID();
-			platform_object_id = ObjectID();
-			on_ceiling = false;
-			on_wall = false;
-			motion_results.clear();
-			platform_velocity = Vector2();
-		} break;
-	}
-}
-
-void CharacterBody2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("move_and_slide"), &CharacterBody2D::move_and_slide);
-	ClassDB::bind_method(D_METHOD("apply_floor_snap"), &CharacterBody2D::apply_floor_snap);
-
-	ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &CharacterBody2D::set_velocity);
-	ClassDB::bind_method(D_METHOD("get_velocity"), &CharacterBody2D::get_velocity);
-
-	ClassDB::bind_method(D_METHOD("set_safe_margin", "margin"), &CharacterBody2D::set_safe_margin);
-	ClassDB::bind_method(D_METHOD("get_safe_margin"), &CharacterBody2D::get_safe_margin);
-	ClassDB::bind_method(D_METHOD("is_floor_stop_on_slope_enabled"), &CharacterBody2D::is_floor_stop_on_slope_enabled);
-	ClassDB::bind_method(D_METHOD("set_floor_stop_on_slope_enabled", "enabled"), &CharacterBody2D::set_floor_stop_on_slope_enabled);
-	ClassDB::bind_method(D_METHOD("set_floor_constant_speed_enabled", "enabled"), &CharacterBody2D::set_floor_constant_speed_enabled);
-	ClassDB::bind_method(D_METHOD("is_floor_constant_speed_enabled"), &CharacterBody2D::is_floor_constant_speed_enabled);
-	ClassDB::bind_method(D_METHOD("set_floor_block_on_wall_enabled", "enabled"), &CharacterBody2D::set_floor_block_on_wall_enabled);
-	ClassDB::bind_method(D_METHOD("is_floor_block_on_wall_enabled"), &CharacterBody2D::is_floor_block_on_wall_enabled);
-	ClassDB::bind_method(D_METHOD("set_slide_on_ceiling_enabled", "enabled"), &CharacterBody2D::set_slide_on_ceiling_enabled);
-	ClassDB::bind_method(D_METHOD("is_slide_on_ceiling_enabled"), &CharacterBody2D::is_slide_on_ceiling_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_platform_floor_layers", "exclude_layer"), &CharacterBody2D::set_platform_floor_layers);
-	ClassDB::bind_method(D_METHOD("get_platform_floor_layers"), &CharacterBody2D::get_platform_floor_layers);
-	ClassDB::bind_method(D_METHOD("set_platform_wall_layers", "exclude_layer"), &CharacterBody2D::set_platform_wall_layers);
-	ClassDB::bind_method(D_METHOD("get_platform_wall_layers"), &CharacterBody2D::get_platform_wall_layers);
-
-	ClassDB::bind_method(D_METHOD("get_max_slides"), &CharacterBody2D::get_max_slides);
-	ClassDB::bind_method(D_METHOD("set_max_slides", "max_slides"), &CharacterBody2D::set_max_slides);
-	ClassDB::bind_method(D_METHOD("get_floor_max_angle"), &CharacterBody2D::get_floor_max_angle);
-	ClassDB::bind_method(D_METHOD("set_floor_max_angle", "radians"), &CharacterBody2D::set_floor_max_angle);
-	ClassDB::bind_method(D_METHOD("get_floor_snap_length"), &CharacterBody2D::get_floor_snap_length);
-	ClassDB::bind_method(D_METHOD("set_floor_snap_length", "floor_snap_length"), &CharacterBody2D::set_floor_snap_length);
-	ClassDB::bind_method(D_METHOD("get_wall_min_slide_angle"), &CharacterBody2D::get_wall_min_slide_angle);
-	ClassDB::bind_method(D_METHOD("set_wall_min_slide_angle", "radians"), &CharacterBody2D::set_wall_min_slide_angle);
-	ClassDB::bind_method(D_METHOD("get_up_direction"), &CharacterBody2D::get_up_direction);
-	ClassDB::bind_method(D_METHOD("set_up_direction", "up_direction"), &CharacterBody2D::set_up_direction);
-	ClassDB::bind_method(D_METHOD("set_motion_mode", "mode"), &CharacterBody2D::set_motion_mode);
-	ClassDB::bind_method(D_METHOD("get_motion_mode"), &CharacterBody2D::get_motion_mode);
-	ClassDB::bind_method(D_METHOD("set_platform_on_leave", "on_leave_apply_velocity"), &CharacterBody2D::set_platform_on_leave);
-	ClassDB::bind_method(D_METHOD("get_platform_on_leave"), &CharacterBody2D::get_platform_on_leave);
-
-	ClassDB::bind_method(D_METHOD("is_on_floor"), &CharacterBody2D::is_on_floor);
-	ClassDB::bind_method(D_METHOD("is_on_floor_only"), &CharacterBody2D::is_on_floor_only);
-	ClassDB::bind_method(D_METHOD("is_on_ceiling"), &CharacterBody2D::is_on_ceiling);
-	ClassDB::bind_method(D_METHOD("is_on_ceiling_only"), &CharacterBody2D::is_on_ceiling_only);
-	ClassDB::bind_method(D_METHOD("is_on_wall"), &CharacterBody2D::is_on_wall);
-	ClassDB::bind_method(D_METHOD("is_on_wall_only"), &CharacterBody2D::is_on_wall_only);
-	ClassDB::bind_method(D_METHOD("get_floor_normal"), &CharacterBody2D::get_floor_normal);
-	ClassDB::bind_method(D_METHOD("get_wall_normal"), &CharacterBody2D::get_wall_normal);
-	ClassDB::bind_method(D_METHOD("get_last_motion"), &CharacterBody2D::get_last_motion);
-	ClassDB::bind_method(D_METHOD("get_position_delta"), &CharacterBody2D::get_position_delta);
-	ClassDB::bind_method(D_METHOD("get_real_velocity"), &CharacterBody2D::get_real_velocity);
-	ClassDB::bind_method(D_METHOD("get_floor_angle", "up_direction"), &CharacterBody2D::get_floor_angle, DEFVAL(Vector2(0.0, -1.0)));
-	ClassDB::bind_method(D_METHOD("get_platform_velocity"), &CharacterBody2D::get_platform_velocity);
-	ClassDB::bind_method(D_METHOD("get_slide_collision_count"), &CharacterBody2D::get_slide_collision_count);
-	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &CharacterBody2D::_get_slide_collision);
-	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody2D::_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::VECTOR2, "up_direction"), "set_up_direction", "get_up_direction");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "velocity", PROPERTY_HINT_NONE, "suffix:px/s", PROPERTY_USAGE_NO_EDITOR), "set_velocity", "get_velocity");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_ceiling"), "set_slide_on_ceiling_enabled", "is_slide_on_ceiling_enabled");
-	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,32,0.1,or_greater,suffix:px"), "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_2D_PHYSICS), "set_platform_floor_layers", "get_platform_floor_layers");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "platform_wall_layers", PROPERTY_HINT_LAYERS_2D_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:px"), "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 CharacterBody2D::_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;
-		}
-	} else {
-		if (p_property.name == "wall_min_slide_angle") {
-			p_property.usage = PROPERTY_USAGE_NO_EDITOR;
-		}
-	}
-}
-
-CharacterBody2D::CharacterBody2D() :
-		PhysicsBody2D(PhysicsServer2D::BODY_MODE_KINEMATIC) {
-}
-
-CharacterBody2D::~CharacterBody2D() {
-	for (int i = 0; i < slide_colliders.size(); i++) {
-		if (slide_colliders[i].is_valid()) {
-			slide_colliders.write[i]->owner = nullptr;
-		}
-	}
-}
-
-////////////////////////
-
-Vector2 KinematicCollision2D::get_position() const {
-	return result.collision_point;
-}
-
-Vector2 KinematicCollision2D::get_normal() const {
-	return result.collision_normal;
-}
-
-Vector2 KinematicCollision2D::get_travel() const {
-	return result.travel;
-}
-
-Vector2 KinematicCollision2D::get_remainder() const {
-	return result.remainder;
-}
-
-real_t KinematicCollision2D::get_angle(const Vector2 &p_up_direction) const {
-	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
-	return result.get_angle(p_up_direction);
-}
-
-real_t KinematicCollision2D::get_depth() const {
-	return result.collision_depth;
-}
-
-Object *KinematicCollision2D::get_local_shape() const {
-	if (!owner) {
-		return nullptr;
-	}
-	uint32_t ownerid = owner->shape_find_owner(result.collision_local_shape);
-	return owner->shape_owner_get_owner(ownerid);
-}
-
-Object *KinematicCollision2D::get_collider() const {
-	if (result.collider_id.is_valid()) {
-		return ObjectDB::get_instance(result.collider_id);
-	}
-
-	return nullptr;
-}
-
-ObjectID KinematicCollision2D::get_collider_id() const {
-	return result.collider_id;
-}
-
-RID KinematicCollision2D::get_collider_rid() const {
-	return result.collider;
-}
-
-Object *KinematicCollision2D::get_collider_shape() const {
-	Object *collider = get_collider();
-	if (collider) {
-		CollisionObject2D *obj2d = Object::cast_to<CollisionObject2D>(collider);
-		if (obj2d) {
-			uint32_t ownerid = obj2d->shape_find_owner(result.collider_shape);
-			return obj2d->shape_owner_get_owner(ownerid);
-		}
-	}
-
-	return nullptr;
-}
-
-int KinematicCollision2D::get_collider_shape_index() const {
-	return result.collider_shape;
-}
-
-Vector2 KinematicCollision2D::get_collider_velocity() const {
-	return result.collider_velocity;
-}
-
-void KinematicCollision2D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("get_position"), &KinematicCollision2D::get_position);
-	ClassDB::bind_method(D_METHOD("get_normal"), &KinematicCollision2D::get_normal);
-	ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision2D::get_travel);
-	ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision2D::get_remainder);
-	ClassDB::bind_method(D_METHOD("get_angle", "up_direction"), &KinematicCollision2D::get_angle, DEFVAL(Vector2(0.0, -1.0)));
-	ClassDB::bind_method(D_METHOD("get_depth"), &KinematicCollision2D::get_depth);
-	ClassDB::bind_method(D_METHOD("get_local_shape"), &KinematicCollision2D::get_local_shape);
-	ClassDB::bind_method(D_METHOD("get_collider"), &KinematicCollision2D::get_collider);
-	ClassDB::bind_method(D_METHOD("get_collider_id"), &KinematicCollision2D::get_collider_id);
-	ClassDB::bind_method(D_METHOD("get_collider_rid"), &KinematicCollision2D::get_collider_rid);
-	ClassDB::bind_method(D_METHOD("get_collider_shape"), &KinematicCollision2D::get_collider_shape);
-	ClassDB::bind_method(D_METHOD("get_collider_shape_index"), &KinematicCollision2D::get_collider_shape_index);
-	ClassDB::bind_method(D_METHOD("get_collider_velocity"), &KinematicCollision2D::get_collider_velocity);
-}
diff --git a/scene/2d/physics_body_2d.h b/scene/2d/physics_body_2d.h
deleted file mode 100644
index 88161e284a..0000000000
--- a/scene/2d/physics_body_2d.h
+++ /dev/null
@@ -1,493 +0,0 @@
-/**************************************************************************/
-/*  physics_body_2d.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_2D_H
-#define PHYSICS_BODY_2D_H
-
-#include "core/templates/vset.h"
-#include "scene/2d/collision_object_2d.h"
-#include "scene/resources/physics_material.h"
-#include "servers/physics_server_2d.h"
-
-class KinematicCollision2D;
-
-class PhysicsBody2D : public CollisionObject2D {
-	GDCLASS(PhysicsBody2D, CollisionObject2D);
-
-protected:
-	static void _bind_methods();
-	PhysicsBody2D(PhysicsServer2D::BodyMode p_mode);
-
-	Ref<KinematicCollision2D> motion_cache;
-
-	Ref<KinematicCollision2D> _move(const Vector2 &p_motion, bool p_test_only = false, real_t p_margin = 0.08, bool p_recovery_as_collision = false);
-
-public:
-	bool move_and_collide(const PhysicsServer2D::MotionParameters &p_parameters, PhysicsServer2D::MotionResult &r_result, bool p_test_only = false, bool p_cancel_sliding = true);
-	bool test_move(const Transform2D &p_from, const Vector2 &p_motion, const Ref<KinematicCollision2D> &r_collision = Ref<KinematicCollision2D>(), real_t p_margin = 0.08, bool p_recovery_as_collision = false);
-	Vector2 get_gravity() const;
-
-	TypedArray<PhysicsBody2D> get_collision_exceptions();
-	void add_collision_exception_with(Node *p_node); //must be physicsbody
-	void remove_collision_exception_with(Node *p_node);
-
-	virtual ~PhysicsBody2D();
-};
-
-class StaticBody2D : public PhysicsBody2D {
-	GDCLASS(StaticBody2D, PhysicsBody2D);
-
-private:
-	Vector2 constant_linear_velocity;
-	real_t constant_angular_velocity = 0.0;
-
-	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 Vector2 &p_vel);
-	void set_constant_angular_velocity(real_t p_vel);
-
-	Vector2 get_constant_linear_velocity() const;
-	real_t get_constant_angular_velocity() const;
-
-	StaticBody2D(PhysicsServer2D::BodyMode p_mode = PhysicsServer2D::BODY_MODE_STATIC);
-
-private:
-	void _reload_physics_characteristics();
-};
-
-class AnimatableBody2D : public StaticBody2D {
-	GDCLASS(AnimatableBody2D, StaticBody2D);
-
-private:
-	bool sync_to_physics = true;
-
-	Transform2D last_valid_transform;
-
-	static void _body_state_changed_callback(void *p_instance, PhysicsDirectBodyState2D *p_state);
-	void _body_state_changed(PhysicsDirectBodyState2D *p_state);
-
-protected:
-	void _notification(int p_what);
-	static void _bind_methods();
-
-public:
-	AnimatableBody2D();
-
-private:
-	void _update_kinematic_motion();
-
-	void set_sync_to_physics(bool p_enable);
-	bool is_sync_to_physics_enabled() const;
-};
-
-class RigidBody2D : public PhysicsBody2D {
-	GDCLASS(RigidBody2D, PhysicsBody2D);
-
-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,
-	};
-
-	enum CCDMode {
-		CCD_MODE_DISABLED,
-		CCD_MODE_CAST_RAY,
-		CCD_MODE_CAST_SHAPE,
-	};
-
-private:
-	bool can_sleep = true;
-	bool lock_rotation = false;
-	bool freeze = false;
-	FreezeMode freeze_mode = FREEZE_MODE_STATIC;
-
-	real_t mass = 1.0;
-	real_t inertia = 0.0;
-	CenterOfMassMode center_of_mass_mode = CENTER_OF_MASS_MODE_AUTO;
-	Vector2 center_of_mass;
-
-	Ref<PhysicsMaterial> physics_material_override;
-	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;
-
-	Vector2 linear_velocity;
-	real_t angular_velocity = 0.0;
-	bool sleeping = false;
-
-	int max_contacts_reported = 0;
-	int contact_count = 0;
-
-	bool custom_integrator = false;
-
-	CCDMode ccd_mode = CCD_MODE_DISABLED;
-
-	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;
-			}
-
-			return body_shape < p_sp.body_shape;
-		}
-
-		ShapePair() {}
-		ShapePair(int p_bs, int p_ls) {
-			body_shape = p_bs;
-			local_shape = p_ls;
-		}
-	};
-	struct RigidBody2D_RemoveAction {
-		RID rid;
-		ObjectID body_id;
-		ShapePair pair;
-	};
-	struct BodyState {
-		RID rid;
-		//int rc;
-		bool in_scene = 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, PhysicsDirectBodyState2D *p_state);
-	void _body_state_changed(PhysicsDirectBodyState2D *p_state);
-
-	void _sync_body_state(PhysicsDirectBodyState2D *p_state);
-
-protected:
-	void _notification(int p_what);
-	static void _bind_methods();
-
-	void _validate_property(PropertyInfo &p_property) const;
-
-	GDVIRTUAL1(_integrate_forces, PhysicsDirectBodyState2D *)
-
-	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;
-
-	void set_inertia(real_t p_inertia);
-	real_t 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 Vector2 &p_center_of_mass);
-	const Vector2 &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_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_linear_velocity(const Vector2 &p_velocity);
-	Vector2 get_linear_velocity() const;
-
-	void set_axis_velocity(const Vector2 &p_axis);
-
-	void set_angular_velocity(real_t p_velocity);
-	real_t get_angular_velocity() 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_continuous_collision_detection_mode(CCDMode p_mode);
-	CCDMode get_continuous_collision_detection_mode() const;
-
-	void apply_central_impulse(const Vector2 &p_impulse);
-	void apply_impulse(const Vector2 &p_impulse, const Vector2 &p_position = Vector2());
-	void apply_torque_impulse(real_t p_torque);
-
-	void apply_central_force(const Vector2 &p_force);
-	void apply_force(const Vector2 &p_force, const Vector2 &p_position = Vector2());
-	void apply_torque(real_t p_torque);
-
-	void add_constant_central_force(const Vector2 &p_force);
-	void add_constant_force(const Vector2 &p_force, const Vector2 &p_position = Vector2());
-	void add_constant_torque(real_t p_torque);
-
-	void set_constant_force(const Vector2 &p_force);
-	Vector2 get_constant_force() const;
-
-	void set_constant_torque(real_t p_torque);
-	real_t get_constant_torque() const;
-
-	TypedArray<Node2D> get_colliding_bodies() const; //function for script
-
-	virtual PackedStringArray get_configuration_warnings() const override;
-
-	RigidBody2D();
-	~RigidBody2D();
-
-private:
-	void _reload_physics_characteristics();
-};
-
-VARIANT_ENUM_CAST(RigidBody2D::FreezeMode);
-VARIANT_ENUM_CAST(RigidBody2D::CenterOfMassMode);
-VARIANT_ENUM_CAST(RigidBody2D::DampMode);
-VARIANT_ENUM_CAST(RigidBody2D::CCDMode);
-
-class CharacterBody2D : public PhysicsBody2D {
-	GDCLASS(CharacterBody2D, PhysicsBody2D);
-
-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 Vector2 &get_velocity() const;
-	void set_velocity(const Vector2 &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 Vector2 &get_last_motion() const;
-	Vector2 get_position_delta() const;
-	const Vector2 &get_floor_normal() const;
-	const Vector2 &get_wall_normal() const;
-	const Vector2 &get_real_velocity() const;
-
-	real_t get_floor_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
-	const Vector2 &get_platform_velocity() const;
-
-	int get_slide_collision_count() const;
-	PhysicsServer2D::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;
-
-	CharacterBody2D();
-	~CharacterBody2D();
-
-private:
-	real_t margin = 0.08;
-	MotionMode motion_mode = MOTION_MODE_GROUNDED;
-	PlatformOnLeave platform_on_leave = PLATFORM_ON_LEAVE_ADD_VELOCITY;
-
-	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 = 4;
-	int platform_layer = 0;
-	real_t floor_max_angle = Math::deg_to_rad((real_t)45.0);
-	real_t floor_snap_length = 1;
-	real_t wall_min_slide_angle = Math::deg_to_rad((real_t)15.0);
-	Vector2 up_direction = Vector2(0.0, -1.0);
-	uint32_t platform_floor_layers = UINT32_MAX;
-	uint32_t platform_wall_layers = 0;
-	Vector2 velocity;
-
-	Vector2 floor_normal;
-	Vector2 platform_velocity;
-	Vector2 wall_normal;
-	Vector2 last_motion;
-	Vector2 previous_position;
-	Vector2 real_velocity;
-
-	RID platform_rid;
-	ObjectID platform_object_id;
-	bool on_floor = false;
-	bool on_ceiling = false;
-	bool on_wall = false;
-
-	Vector<PhysicsServer2D::MotionResult> motion_results;
-	Vector<Ref<KinematicCollision2D>> slide_colliders;
-
-	void _move_and_slide_floating(double p_delta);
-	void _move_and_slide_grounded(double p_delta, bool p_was_on_floor);
-
-	Ref<KinematicCollision2D> _get_slide_collision(int p_bounce);
-	Ref<KinematicCollision2D> _get_last_slide_collision();
-	const Vector2 &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 Vector2 &p_up_direction);
-	void _set_collision_direction(const PhysicsServer2D::MotionResult &p_result);
-	void _set_platform_data(const PhysicsServer2D::MotionResult &p_result);
-	void _apply_floor_snap(bool p_wall_as_floor = false);
-	void _snap_on_floor(bool p_was_on_floor, bool p_vel_dir_facing_up, bool p_wall_as_floor = false);
-
-protected:
-	void _notification(int p_what);
-	static void _bind_methods();
-	void _validate_property(PropertyInfo &p_property) const;
-};
-
-VARIANT_ENUM_CAST(CharacterBody2D::MotionMode);
-VARIANT_ENUM_CAST(CharacterBody2D::PlatformOnLeave);
-
-class KinematicCollision2D : public RefCounted {
-	GDCLASS(KinematicCollision2D, RefCounted);
-
-	PhysicsBody2D *owner = nullptr;
-	friend class PhysicsBody2D;
-	friend class CharacterBody2D;
-	PhysicsServer2D::MotionResult result;
-
-protected:
-	static void _bind_methods();
-
-public:
-	Vector2 get_position() const;
-	Vector2 get_normal() const;
-	Vector2 get_travel() const;
-	Vector2 get_remainder() const;
-	real_t get_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
-	real_t get_depth() const;
-	Object *get_local_shape() const;
-	Object *get_collider() const;
-	ObjectID get_collider_id() const;
-	RID get_collider_rid() const;
-	Object *get_collider_shape() const;
-	int get_collider_shape_index() const;
-	Vector2 get_collider_velocity() const;
-};
-
-#endif // PHYSICS_BODY_2D_H
diff --git a/scene/3d/SCsub b/scene/3d/SCsub
index fc61250247..94e1ab6c96 100644
--- a/scene/3d/SCsub
+++ b/scene/3d/SCsub
@@ -3,3 +3,6 @@
 Import("env")
 
 env.add_source_files(env.scene_sources, "*.cpp")
+
+# Chain load SCsubs
+SConscript("physics/SCsub")
diff --git a/scene/3d/audio_stream_player_3d.cpp b/scene/3d/audio_stream_player_3d.cpp
index 2bb376c9ab..f1f9a04ea0 100644
--- a/scene/3d/audio_stream_player_3d.cpp
+++ b/scene/3d/audio_stream_player_3d.cpp
@@ -32,9 +32,9 @@
 #include "audio_stream_player_3d.compat.inc"
 
 #include "core/config/project_settings.h"
-#include "scene/3d/area_3d.h"
 #include "scene/3d/audio_listener_3d.h"
 #include "scene/3d/camera_3d.h"
+#include "scene/3d/physics/area_3d.h"
 #include "scene/3d/velocity_tracker_3d.h"
 #include "scene/audio/audio_stream_player_internal.h"
 #include "scene/main/viewport.h"
diff --git a/scene/3d/camera_3d.cpp b/scene/3d/camera_3d.cpp
index a44aa54c17..e8bd498e1f 100644
--- a/scene/3d/camera_3d.cpp
+++ b/scene/3d/camera_3d.cpp
@@ -30,7 +30,6 @@
 
 #include "camera_3d.h"
 
-#include "collision_object_3d.h"
 #include "core/math/projection.h"
 #include "scene/main/viewport.h"
 
diff --git a/scene/3d/joint_3d.h b/scene/3d/joint_3d.h
deleted file mode 100644
index 527aed4079..0000000000
--- a/scene/3d/joint_3d.h
+++ /dev/null
@@ -1,301 +0,0 @@
-/**************************************************************************/
-/*  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_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();
-};
-
-///////////////////////////////////////////
-
-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);
-
-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);
-
-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);
-
-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);
-
-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 // JOINT_3D_H
diff --git a/scene/3d/mesh_instance_3d.cpp b/scene/3d/mesh_instance_3d.cpp
index eeb41573f7..8635240655 100644
--- a/scene/3d/mesh_instance_3d.cpp
+++ b/scene/3d/mesh_instance_3d.cpp
@@ -30,8 +30,9 @@
 
 #include "mesh_instance_3d.h"
 
-#include "collision_shape_3d.h"
-#include "physics_body_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
+#include "scene/3d/skeleton_3d.h"
 #include "scene/resources/3d/concave_polygon_shape_3d.h"
 #include "scene/resources/3d/convex_polygon_shape_3d.h"
 
diff --git a/scene/3d/navigation_obstacle_3d.cpp b/scene/3d/navigation_obstacle_3d.cpp
index 98cd5efef2..82450927d3 100644
--- a/scene/3d/navigation_obstacle_3d.cpp
+++ b/scene/3d/navigation_obstacle_3d.cpp
@@ -31,8 +31,6 @@
 #include "navigation_obstacle_3d.h"
 
 #include "core/math/geometry_2d.h"
-#include "scene/3d/collision_shape_3d.h"
-#include "scene/3d/physics_body_3d.h"
 #include "servers/navigation_server_3d.h"
 
 void NavigationObstacle3D::_bind_methods() {
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/area_3d.cpp b/scene/3d/physics/area_3d.cpp
index 014c33cad0..014c33cad0 100644
--- a/scene/3d/area_3d.cpp
+++ b/scene/3d/physics/area_3d.cpp
diff --git a/scene/3d/area_3d.h b/scene/3d/physics/area_3d.h
index 05c558e8f0..41382b6128 100644
--- a/scene/3d/area_3d.h
+++ b/scene/3d/physics/area_3d.h
@@ -32,7 +32,7 @@
 #define AREA_3D_H
 
 #include "core/templates/vset.h"
-#include "scene/3d/collision_object_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
 #include "scene/scene_string_names.h"
 
 class Area3D : public CollisionObject3D {
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/collision_object_3d.cpp b/scene/3d/physics/collision_object_3d.cpp
index bbd2ef2fb8..bbd2ef2fb8 100644
--- a/scene/3d/collision_object_3d.cpp
+++ b/scene/3d/physics/collision_object_3d.cpp
diff --git a/scene/3d/collision_object_3d.h b/scene/3d/physics/collision_object_3d.h
index b51423f021..b51423f021 100644
--- a/scene/3d/collision_object_3d.h
+++ b/scene/3d/physics/collision_object_3d.h
diff --git a/scene/3d/collision_polygon_3d.cpp b/scene/3d/physics/collision_polygon_3d.cpp
index abde05778d..76cd4db779 100644
--- a/scene/3d/collision_polygon_3d.cpp
+++ b/scene/3d/physics/collision_polygon_3d.cpp
@@ -30,8 +30,8 @@
 
 #include "collision_polygon_3d.h"
 
-#include "collision_object_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() {
diff --git a/scene/3d/collision_polygon_3d.h b/scene/3d/physics/collision_polygon_3d.h
index fe4cf40ee3..fe4cf40ee3 100644
--- a/scene/3d/collision_polygon_3d.h
+++ b/scene/3d/physics/collision_polygon_3d.h
diff --git a/scene/3d/collision_shape_3d.cpp b/scene/3d/physics/collision_shape_3d.cpp
index 08fc62ae4f..f3492a3cf3 100644
--- a/scene/3d/collision_shape_3d.cpp
+++ b/scene/3d/physics/collision_shape_3d.cpp
@@ -30,12 +30,13 @@
 
 #include "collision_shape_3d.h"
 
-#include "mesh_instance_3d.h"
-#include "physics_body_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"
-#include "vehicle_body_3d.h"
 
 void CollisionShape3D::make_convex_from_siblings() {
 	Node *p = get_parent();
diff --git a/scene/3d/collision_shape_3d.h b/scene/3d/physics/collision_shape_3d.h
index 15f6ef73cb..15f6ef73cb 100644
--- a/scene/3d/collision_shape_3d.h
+++ b/scene/3d/physics/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/joint_3d.cpp b/scene/3d/physics/joints/generic_6dof_joint_3d.cpp
index 1e4e50182c..9f440b65cc 100644
--- a/scene/3d/joint_3d.cpp
+++ b/scene/3d/physics/joints/generic_6dof_joint_3d.cpp
@@ -1,5 +1,5 @@
 /**************************************************************************/
-/*  joint_3d.cpp                                                          */
+/*  generic_6dof_joint_3d.cpp                                             */
 /**************************************************************************/
 /*                         This file is part of:                          */
 /*                             GODOT ENGINE                               */
@@ -28,562 +28,7 @@
 /* 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);
-}
-
-///////////////////////////////////
-
-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;
-}
-
-/////////////////////////////////////////////////
-
-///////////////////////////////////
-
-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;
-}
-
-/////////////////////////////////////////////////
-
-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;
-}
-
-//////////////////////////////////
-
-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;
-}
-
-/////////////////////////////////////////////////////////////////////
+#include "generic_6dof_joint_3d.h"
 
 void Generic6DOFJoint3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_param_x", "param", "value"), &Generic6DOFJoint3D::set_param_x);
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/ray_cast_3d.cpp b/scene/3d/physics/ray_cast_3d.cpp
index b821181d29..dc50ecccc0 100644
--- a/scene/3d/ray_cast_3d.cpp
+++ b/scene/3d/physics/ray_cast_3d.cpp
@@ -30,8 +30,8 @@
 
 #include "ray_cast_3d.h"
 
-#include "collision_object_3d.h"
-#include "mesh_instance_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;
diff --git a/scene/3d/ray_cast_3d.h b/scene/3d/physics/ray_cast_3d.h
index 7b7f698114..7b7f698114 100644
--- a/scene/3d/ray_cast_3d.h
+++ b/scene/3d/physics/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/shape_cast_3d.cpp b/scene/3d/physics/shape_cast_3d.cpp
index 2da5f52928..5e6302cb81 100644
--- a/scene/3d/shape_cast_3d.cpp
+++ b/scene/3d/physics/shape_cast_3d.cpp
@@ -30,8 +30,8 @@
 
 #include "shape_cast_3d.h"
 
-#include "scene/3d/collision_object_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) {
diff --git a/scene/3d/shape_cast_3d.h b/scene/3d/physics/shape_cast_3d.h
index 9052db9046..9052db9046 100644
--- a/scene/3d/shape_cast_3d.h
+++ b/scene/3d/physics/shape_cast_3d.h
diff --git a/scene/3d/spring_arm_3d.cpp b/scene/3d/physics/spring_arm_3d.cpp
index 8d2f10310c..8d2f10310c 100644
--- a/scene/3d/spring_arm_3d.cpp
+++ b/scene/3d/physics/spring_arm_3d.cpp
diff --git a/scene/3d/spring_arm_3d.h b/scene/3d/physics/spring_arm_3d.h
index c7e1da35f0..c7e1da35f0 100644
--- a/scene/3d/spring_arm_3d.h
+++ b/scene/3d/physics/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/vehicle_body_3d.cpp b/scene/3d/physics/vehicle_body_3d.cpp
index c23032d3b9..c23032d3b9 100644
--- a/scene/3d/vehicle_body_3d.cpp
+++ b/scene/3d/physics/vehicle_body_3d.cpp
diff --git a/scene/3d/vehicle_body_3d.h b/scene/3d/physics/vehicle_body_3d.h
index ce913f152d..def9984440 100644
--- a/scene/3d/vehicle_body_3d.h
+++ b/scene/3d/physics/vehicle_body_3d.h
@@ -31,7 +31,8 @@
 #ifndef VEHICLE_BODY_3D_H
 #define VEHICLE_BODY_3D_H
 
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/rigid_body_3d.h"
 
 class VehicleBody3D;
 
diff --git a/scene/3d/physics_body_3d.cpp b/scene/3d/physics_body_3d.cpp
deleted file mode 100644
index 67a7f76d7d..0000000000
--- a/scene/3d/physics_body_3d.cpp
+++ /dev/null
@@ -1,3503 +0,0 @@
-/**************************************************************************/
-/*  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;
-}
-
-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::_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) {
-}
-
-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());
-	}
-}
-
-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));
-}
-
-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;
-}
-
-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);
-	}
-}
-
-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());
-	}
-}
-
-///////////////////////////////////////
-
-//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;
-		}
-	}
-}
-
-///////////////////////////////////////
-
-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));
-}
-
-///////////////////////////////////////
-
-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_body_3d.h b/scene/3d/physics_body_3d.h
deleted file mode 100644
index b84b7c4f02..0000000000
--- a/scene/3d/physics_body_3d.h
+++ /dev/null
@@ -1,797 +0,0 @@
-/**************************************************************************/
-/*  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/collision_object_3d.h"
-#include "scene/resources/physics_material.h"
-#include "servers/physics_server_3d.h"
-#include "skeleton_3d.h"
-
-class KinematicCollision3D;
-
-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();
-};
-
-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();
-};
-
-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;
-};
-
-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);
-
-class KinematicCollision3D;
-
-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);
-
-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;
-};
-
-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 // PHYSICS_BODY_3D_H
diff --git a/scene/3d/skeleton_3d.cpp b/scene/3d/skeleton_3d.cpp
index f448d1c6e2..f0ffb7b2d5 100644
--- a/scene/3d/skeleton_3d.cpp
+++ b/scene/3d/skeleton_3d.cpp
@@ -32,7 +32,8 @@
 #include "skeleton_3d.compat.inc"
 
 #include "core/variant/type_info.h"
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physical_bone_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 #include "scene/resources/surface_tool.h"
 #include "scene/scene_string_names.h"
 
diff --git a/scene/3d/soft_body_3d.cpp b/scene/3d/soft_body_3d.cpp
index bd03a97a36..f02cd9b700 100644
--- a/scene/3d/soft_body_3d.cpp
+++ b/scene/3d/soft_body_3d.cpp
@@ -30,7 +30,7 @@
 
 #include "soft_body_3d.h"
 
-#include "scene/3d/physics_body_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
 
 SoftBodyRenderingServerHandler::SoftBodyRenderingServerHandler() {}
 
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index 0bb2688fea..1dcf9acda3 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -37,11 +37,11 @@
 #include "core/templates/sort_array.h"
 #include "scene/2d/audio_listener_2d.h"
 #include "scene/2d/camera_2d.h"
-#include "scene/2d/collision_object_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
 #ifndef _3D_DISABLED
 #include "scene/3d/audio_listener_3d.h"
 #include "scene/3d/camera_3d.h"
-#include "scene/3d/collision_object_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
 #include "scene/3d/world_environment.h"
 #endif // _3D_DISABLED
 #include "scene/gui/control.h"
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index b156cd0422..f1c94f53da 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -34,18 +34,14 @@
 #include "core/object/class_db.h"
 #include "core/os/os.h"
 #include "scene/2d/animated_sprite_2d.h"
-#include "scene/2d/area_2d.h"
 #include "scene/2d/audio_listener_2d.h"
 #include "scene/2d/audio_stream_player_2d.h"
 #include "scene/2d/back_buffer_copy.h"
 #include "scene/2d/camera_2d.h"
 #include "scene/2d/canvas_group.h"
 #include "scene/2d/canvas_modulate.h"
-#include "scene/2d/collision_polygon_2d.h"
-#include "scene/2d/collision_shape_2d.h"
 #include "scene/2d/cpu_particles_2d.h"
 #include "scene/2d/gpu_particles_2d.h"
-#include "scene/2d/joint_2d.h"
 #include "scene/2d/light_2d.h"
 #include "scene/2d/light_occluder_2d.h"
 #include "scene/2d/line_2d.h"
@@ -59,12 +55,24 @@
 #include "scene/2d/parallax_background.h"
 #include "scene/2d/parallax_layer.h"
 #include "scene/2d/path_2d.h"
-#include "scene/2d/physical_bone_2d.h"
-#include "scene/2d/physics_body_2d.h"
+#include "scene/2d/physics/animatable_body_2d.h"
+#include "scene/2d/physics/area_2d.h"
+#include "scene/2d/physics/character_body_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
+#include "scene/2d/physics/collision_shape_2d.h"
+#include "scene/2d/physics/joints/damped_spring_joint_2d.h"
+#include "scene/2d/physics/joints/groove_joint_2d.h"
+#include "scene/2d/physics/joints/joint_2d.h"
+#include "scene/2d/physics/joints/pin_joint_2d.h"
+#include "scene/2d/physics/kinematic_collision_2d.h"
+#include "scene/2d/physics/physical_bone_2d.h"
+#include "scene/2d/physics/physics_body_2d.h"
+#include "scene/2d/physics/ray_cast_2d.h"
+#include "scene/2d/physics/rigid_body_2d.h"
+#include "scene/2d/physics/shape_cast_2d.h"
+#include "scene/2d/physics/static_body_2d.h"
 #include "scene/2d/polygon_2d.h"
-#include "scene/2d/ray_cast_2d.h"
 #include "scene/2d/remote_transform_2d.h"
-#include "scene/2d/shape_cast_2d.h"
 #include "scene/2d/skeleton_2d.h"
 #include "scene/2d/sprite_2d.h"
 #include "scene/2d/tile_map.h"
@@ -218,20 +226,16 @@
 #include "scene/main/shader_globals_override.h"
 
 #ifndef _3D_DISABLED
-#include "scene/3d/area_3d.h"
 #include "scene/3d/audio_listener_3d.h"
 #include "scene/3d/audio_stream_player_3d.h"
 #include "scene/3d/bone_attachment_3d.h"
 #include "scene/3d/camera_3d.h"
-#include "scene/3d/collision_polygon_3d.h"
-#include "scene/3d/collision_shape_3d.h"
 #include "scene/3d/cpu_particles_3d.h"
 #include "scene/3d/decal.h"
 #include "scene/3d/fog_volume.h"
 #include "scene/3d/gpu_particles_3d.h"
 #include "scene/3d/gpu_particles_collision_3d.h"
 #include "scene/3d/importer_mesh_instance_3d.h"
-#include "scene/3d/joint_3d.h"
 #include "scene/3d/label_3d.h"
 #include "scene/3d/light_3d.h"
 #include "scene/3d/lightmap_gi.h"
@@ -246,17 +250,32 @@
 #include "scene/3d/node_3d.h"
 #include "scene/3d/occluder_instance_3d.h"
 #include "scene/3d/path_3d.h"
-#include "scene/3d/physics_body_3d.h"
-#include "scene/3d/ray_cast_3d.h"
+#include "scene/3d/physics/animatable_body_3d.h"
+#include "scene/3d/physics/area_3d.h"
+#include "scene/3d/physics/character_body_3d.h"
+#include "scene/3d/physics/collision_polygon_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/physics/joints/cone_twist_joint_3d.h"
+#include "scene/3d/physics/joints/generic_6dof_joint_3d.h"
+#include "scene/3d/physics/joints/hinge_joint_3d.h"
+#include "scene/3d/physics/joints/joint_3d.h"
+#include "scene/3d/physics/joints/pin_joint_3d.h"
+#include "scene/3d/physics/joints/slider_joint_3d.h"
+#include "scene/3d/physics/kinematic_collision_3d.h"
+#include "scene/3d/physics/physical_bone_3d.h"
+#include "scene/3d/physics/physics_body_3d.h"
+#include "scene/3d/physics/ray_cast_3d.h"
+#include "scene/3d/physics/rigid_body_3d.h"
+#include "scene/3d/physics/shape_cast_3d.h"
+#include "scene/3d/physics/spring_arm_3d.h"
+#include "scene/3d/physics/static_body_3d.h"
+#include "scene/3d/physics/vehicle_body_3d.h"
 #include "scene/3d/reflection_probe.h"
 #include "scene/3d/remote_transform_3d.h"
-#include "scene/3d/shape_cast_3d.h"
 #include "scene/3d/skeleton_3d.h"
 #include "scene/3d/skeleton_ik_3d.h"
 #include "scene/3d/soft_body_3d.h"
-#include "scene/3d/spring_arm_3d.h"
 #include "scene/3d/sprite_3d.h"
-#include "scene/3d/vehicle_body_3d.h"
 #include "scene/3d/visible_on_screen_notifier_3d.h"
 #include "scene/3d/voxel_gi.h"
 #include "scene/3d/world_environment.h"
diff --git a/scene/resources/2d/skeleton/skeleton_modification_2d.cpp b/scene/resources/2d/skeleton/skeleton_modification_2d.cpp
index 88a0f7b92d..4e7563fdc3 100644
--- a/scene/resources/2d/skeleton/skeleton_modification_2d.cpp
+++ b/scene/resources/2d/skeleton/skeleton_modification_2d.cpp
@@ -31,9 +31,9 @@
 #include "skeleton_modification_2d.h"
 #include "scene/2d/skeleton_2d.h"
 
-#include "scene/2d/collision_object_2d.h"
-#include "scene/2d/collision_shape_2d.h"
-#include "scene/2d/physical_bone_2d.h"
+#include "scene/2d/physics/collision_object_2d.h"
+#include "scene/2d/physics/collision_shape_2d.h"
+#include "scene/2d/physics/physical_bone_2d.h"
 
 #ifdef TOOLS_ENABLED
 #include "editor/editor_settings.h"
diff --git a/scene/resources/2d/skeleton/skeleton_modification_2d_physicalbones.cpp b/scene/resources/2d/skeleton/skeleton_modification_2d_physicalbones.cpp
index e000e947cd..61e5aed150 100644
--- a/scene/resources/2d/skeleton/skeleton_modification_2d_physicalbones.cpp
+++ b/scene/resources/2d/skeleton/skeleton_modification_2d_physicalbones.cpp
@@ -29,7 +29,7 @@
 /**************************************************************************/
 
 #include "skeleton_modification_2d_physicalbones.h"
-#include "scene/2d/physical_bone_2d.h"
+#include "scene/2d/physics/physical_bone_2d.h"
 #include "scene/2d/skeleton_2d.h"
 
 bool SkeletonModification2DPhysicalBones::_set(const StringName &p_path, const Variant &p_value) {
diff --git a/scu_builders.py b/scu_builders.py
index 1a75f19b30..2579398ad6 100644
--- a/scu_builders.py
+++ b/scu_builders.py
@@ -310,7 +310,11 @@ def generate_scu_files(max_includes_per_scu):
     process_folder(["modules/gdscript/language_server"])
 
     process_folder(["scene/2d"])
+    process_folder(["scene/2d/physics"])
+    process_folder(["scene/2d/physics/joints"])
     process_folder(["scene/3d"])
+    process_folder(["scene/3d/physics"])
+    process_folder(["scene/3d/physics/joints"])
     process_folder(["scene/animation"])
     process_folder(["scene/gui"])
     process_folder(["scene/main"])
diff --git a/tests/scene/test_viewport.h b/tests/scene/test_viewport.h
index e15b01ae9f..66b0f438cc 100644
--- a/tests/scene/test_viewport.h
+++ b/tests/scene/test_viewport.h
@@ -31,8 +31,8 @@
 #ifndef TEST_VIEWPORT_H
 #define TEST_VIEWPORT_H
 
-#include "scene/2d/area_2d.h"
-#include "scene/2d/collision_shape_2d.h"
+#include "scene/2d/physics/area_2d.h"
+#include "scene/2d/physics/collision_shape_2d.h"
 #include "scene/gui/control.h"
 #include "scene/gui/subviewport_container.h"
 #include "scene/main/canvas_layer.h"