Merge pull request #886 from Spartan322/merge/f128f38HEADmaster

Merge commit godotengine/godot@f128f38

10 files changed, 762 insertions, 17 deletions

diff --git a/scene/3d/camera_3d.cpp b/scene/3d/camera_3d.cpp
index 77665317a8..fb64bead13 100644
--- a/scene/3d/camera_3d.cpp
+++ b/scene/3d/camera_3d.cpp
@@ -531,9 +531,12 @@ Vector3 Camera3D::project_position(const Point2 &p_point, real_t p_z_depth) cons
 	}
 	Size2 viewport_size = get_viewport()->get_visible_rect().size;
 
-	Projection cm = _get_camera_projection(p_z_depth);
+	Projection cm = _get_camera_projection(_near);
 
-	Vector2 vp_he = cm.get_viewport_half_extents();
+	Plane z_slice(Vector3(0, 0, 1), -p_z_depth);
+	Vector3 res;
+	z_slice.intersect_3(cm.get_projection_plane(Projection::Planes::PLANE_RIGHT), cm.get_projection_plane(Projection::Planes::PLANE_TOP), &res);
+	Vector2 vp_he(res.x, res.y);
 
 	Vector2 point;
 	point.x = (p_point.x / viewport_size.x) * 2.0 - 1.0;
diff --git a/scene/3d/look_at_modifier_3d.cpp b/scene/3d/look_at_modifier_3d.cpp
index a251f5a78c..e1ed24273b 100644
--- a/scene/3d/look_at_modifier_3d.cpp
+++ b/scene/3d/look_at_modifier_3d.cpp
@@ -35,7 +35,7 @@
 void LookAtModifier3D::_validate_property(PropertyInfo &p_property) const {
 	SkeletonModifier3D::_validate_property(p_property);
 
-	if (p_property.name == "bone" || p_property.name == "origin_bone") {
+	if (p_property.name == "bone_name" || p_property.name == "origin_bone_name") {
 		Skeleton3D *skeleton = get_skeleton();
 		if (skeleton) {
 			p_property.hint = PROPERTY_HINT_ENUM;
@@ -51,11 +51,11 @@ void LookAtModifier3D::_validate_property(PropertyInfo &p_property) const {
 			p_property.usage = PROPERTY_USAGE_NONE;
 		}
 	} else if (origin_from == ORIGIN_FROM_EXTERNAL_NODE) {
-		if (p_property.name == "origin_bone") {
+		if (p_property.name == "origin_bone" || p_property.name == "origin_bone_name") {
 			p_property.usage = PROPERTY_USAGE_NONE;
 		}
 	} else {
-		if (p_property.name == "origin_external_node" || p_property.name == "origin_bone") {
+		if (p_property.name == "origin_external_node" || p_property.name == "origin_bone" || p_property.name == "origin_bone_name") {
 			p_property.usage = PROPERTY_USAGE_NONE;
 		}
 	}
@@ -77,8 +77,29 @@ PackedStringArray LookAtModifier3D::get_configuration_warnings() const {
 	return warnings;
 }
 
+void LookAtModifier3D::set_bone_name(const String &p_bone_name) {
+	bone_name = p_bone_name;
+	Skeleton3D *sk = get_skeleton();
+	if (sk) {
+		set_bone(sk->find_bone(bone_name));
+	}
+}
+
+String LookAtModifier3D::get_bone_name() const {
+	return bone_name;
+}
+
 void LookAtModifier3D::set_bone(int p_bone) {
 	bone = p_bone;
+	Skeleton3D *sk = get_skeleton();
+	if (sk) {
+		if (bone <= -1 || bone >= sk->get_bone_count()) {
+			WARN_PRINT("Bone index out of range!");
+			bone = -1;
+		} else {
+			bone_name = sk->get_bone_name(bone);
+		}
+	}
 }
 
 int LookAtModifier3D::get_bone() const {
@@ -134,8 +155,29 @@ LookAtModifier3D::OriginFrom LookAtModifier3D::get_origin_from() const {
 	return origin_from;
 }
 
+void LookAtModifier3D::set_origin_bone_name(const String &p_bone_name) {
+	origin_bone_name = p_bone_name;
+	Skeleton3D *sk = get_skeleton();
+	if (sk) {
+		set_origin_bone(sk->find_bone(origin_bone_name));
+	}
+}
+
+String LookAtModifier3D::get_origin_bone_name() const {
+	return origin_bone_name;
+}
+
 void LookAtModifier3D::set_origin_bone(int p_bone) {
 	origin_bone = p_bone;
+	Skeleton3D *sk = get_skeleton();
+	if (sk) {
+		if (origin_bone <= -1 || origin_bone >= sk->get_bone_count()) {
+			WARN_PRINT("Bone index out of range!");
+			origin_bone = -1;
+		} else {
+			origin_bone_name = sk->get_bone_name(origin_bone);
+		}
+	}
 }
 
 int LookAtModifier3D::get_origin_bone() const {
@@ -332,6 +374,8 @@ void LookAtModifier3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_target_node", "target_node"), &LookAtModifier3D::set_target_node);
 	ClassDB::bind_method(D_METHOD("get_target_node"), &LookAtModifier3D::get_target_node);
 
+	ClassDB::bind_method(D_METHOD("set_bone_name", "bone_name"), &LookAtModifier3D::set_bone_name);
+	ClassDB::bind_method(D_METHOD("get_bone_name"), &LookAtModifier3D::get_bone_name);
 	ClassDB::bind_method(D_METHOD("set_bone", "bone"), &LookAtModifier3D::set_bone);
 	ClassDB::bind_method(D_METHOD("get_bone"), &LookAtModifier3D::get_bone);
 	ClassDB::bind_method(D_METHOD("set_forward_axis", "forward_axis"), &LookAtModifier3D::set_forward_axis);
@@ -345,6 +389,8 @@ void LookAtModifier3D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_origin_from", "origin_from"), &LookAtModifier3D::set_origin_from);
 	ClassDB::bind_method(D_METHOD("get_origin_from"), &LookAtModifier3D::get_origin_from);
+	ClassDB::bind_method(D_METHOD("set_origin_bone_name", "bone_name"), &LookAtModifier3D::set_origin_bone_name);
+	ClassDB::bind_method(D_METHOD("get_origin_bone_name"), &LookAtModifier3D::get_origin_bone_name);
 	ClassDB::bind_method(D_METHOD("set_origin_bone", "bone"), &LookAtModifier3D::set_origin_bone);
 	ClassDB::bind_method(D_METHOD("get_origin_bone"), &LookAtModifier3D::get_origin_bone);
 	ClassDB::bind_method(D_METHOD("set_origin_external_node", "external_node"), &LookAtModifier3D::set_origin_external_node);
@@ -399,14 +445,16 @@ void LookAtModifier3D::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_node", PROPERTY_HINT_NODE_TYPE, "Node3D"), "set_target_node", "get_target_node");
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "bone", PROPERTY_HINT_ENUM, ""), "set_bone", "get_bone");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "bone_name", PROPERTY_HINT_ENUM_SUGGESTION, ""), "set_bone_name", "get_bone_name");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "bone", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_bone", "get_bone");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "forward_axis", PROPERTY_HINT_ENUM, "+X,-X,+Y,-Y,+Z,-Z"), "set_forward_axis", "get_forward_axis");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "primary_rotation_axis", PROPERTY_HINT_ENUM, "X,Y,Z"), "set_primary_rotation_axis", "get_primary_rotation_axis");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_secondary_rotation"), "set_use_secondary_rotation", "is_using_secondary_rotation");
 
 	ADD_GROUP("Origin Settings", "origin_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "origin_from", PROPERTY_HINT_ENUM, "Self,SpecificBone,ExternalNode"), "set_origin_from", "get_origin_from");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "origin_bone", PROPERTY_HINT_ENUM, ""), "set_origin_bone", "get_origin_bone");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "origin_bone_name", PROPERTY_HINT_ENUM_SUGGESTION, ""), "set_origin_bone_name", "get_origin_bone_name");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "origin_bone", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_origin_bone", "get_origin_bone");
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "origin_external_node", PROPERTY_HINT_NODE_TYPE, "Node3D"), "set_origin_external_node", "get_origin_external_node");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "origin_offset"), "set_origin_offset", "get_origin_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "origin_safe_margin", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater,suffix:m"), "set_origin_safe_margin", "get_origin_safe_margin");
@@ -476,7 +524,7 @@ void LookAtModifier3D::_process_modification() {
 		destination = skeleton->get_bone_pose_rotation(bone);
 	} else {
 		Transform3D origin_tr;
-		if (origin_from == ORIGIN_FROM_SPECIFIC_BONE && origin_bone < skeleton->get_bone_count()) {
+		if (origin_from == ORIGIN_FROM_SPECIFIC_BONE && origin_bone >= 0 && origin_bone < skeleton->get_bone_count()) {
 			origin_tr = skeleton->get_global_transform() * skeleton->get_bone_global_pose(origin_bone);
 		} else if (origin_from == ORIGIN_FROM_EXTERNAL_NODE) {
 			Node3D *origin_src = Object::cast_to<Node3D>(get_node_or_null(origin_external_node));
@@ -488,7 +536,7 @@ void LookAtModifier3D::_process_modification() {
 		} else {
 			origin_tr = bone_rest_space;
 		}
-		forward_vector = bone_rest_space.basis.xform_inv((target->get_global_position() - origin_tr.translated_local(origin_offset).origin));
+		forward_vector = bone_rest_space.orthonormalized().basis.xform_inv((target->get_global_position() - origin_tr.translated_local(origin_offset).origin));
 		forward_vector_nrm = forward_vector.normalized();
 		if (forward_vector_nrm.abs().is_equal_approx(get_vector_from_axis(primary_rotation_axis))) {
 			destination = skeleton->get_bone_pose_rotation(bone);
@@ -499,6 +547,8 @@ void LookAtModifier3D::_process_modification() {
 	}
 
 	// Detect flipping.
+	bool is_not_max_influence = influence < 1.0;
+	bool is_flippable = use_angle_limitation || is_not_max_influence;
 	Vector3::Axis current_forward_axis = get_axis_from_bone_axis(forward_axis);
 	if (is_intersecting_axis(prev_forward_vector, forward_vector, current_forward_axis, secondary_rotation_axis) ||
 			is_intersecting_axis(prev_forward_vector, forward_vector, primary_rotation_axis, primary_rotation_axis, true) ||
@@ -506,16 +556,20 @@ void LookAtModifier3D::_process_modification() {
 			(prev_forward_vector != Vector3(0, 0, 0) && forward_vector == Vector3(0, 0, 0)) ||
 			(prev_forward_vector == Vector3(0, 0, 0) && forward_vector != Vector3(0, 0, 0))) {
 		init_transition();
-	} else if (use_angle_limitation && signbit(prev_forward_vector[secondary_rotation_axis]) != signbit(forward_vector[secondary_rotation_axis])) {
+	} else if (is_flippable && signbit(prev_forward_vector[secondary_rotation_axis]) != signbit(forward_vector[secondary_rotation_axis])) {
 		// Flipping by angle_limitation can be detected by sign of secondary rotation axes during forward_vector is rotated more than 90 degree from forward_axis (means dot production is negative).
 		Vector3 prev_forward_vector_nrm = forward_vector.normalized();
 		Vector3 rest_forward_vector = get_vector_from_bone_axis(forward_axis);
 		if (symmetry_limitation) {
-			if (!Math::is_equal_approx(primary_limit_angle, (float)Math_TAU) && prev_forward_vector_nrm.dot(rest_forward_vector) < 0 && forward_vector_nrm.dot(rest_forward_vector) < 0) {
+			if ((is_not_max_influence || !Math::is_equal_approx(primary_limit_angle, (float)Math_TAU)) &&
+					prev_forward_vector_nrm.dot(rest_forward_vector) < 0 &&
+					forward_vector_nrm.dot(rest_forward_vector) < 0) {
 				init_transition();
 			}
 		} else {
-			if (!Math::is_equal_approx(primary_positive_limit_angle + primary_negative_limit_angle, (float)Math_TAU) && prev_forward_vector_nrm.dot(rest_forward_vector) < 0 && forward_vector_nrm.dot(rest_forward_vector) < 0) {
+			if ((is_not_max_influence || !Math::is_equal_approx(primary_positive_limit_angle + primary_negative_limit_angle, (float)Math_TAU)) &&
+					prev_forward_vector_nrm.dot(rest_forward_vector) < 0 &&
+					forward_vector_nrm.dot(rest_forward_vector) < 0) {
 				init_transition();
 			}
 		}
@@ -530,7 +584,7 @@ void LookAtModifier3D::_process_modification() {
 			delta = get_physics_process_delta_time();
 		}
 		remaining = MAX(0, remaining - time_step * delta);
-		if (use_angle_limitation) {
+		if (is_flippable) {
 			// Interpolate through the rest same as AnimationTree blending for preventing to penetrate the bone into the body.
 			Quaternion rest = skeleton->get_bone_rest(bone).basis.get_rotation_quaternion();
 			float weight = Tween::run_equation(transition_type, ease_type, 1 - remaining, 0.0, 1.0, 1.0);
diff --git a/scene/3d/look_at_modifier_3d.h b/scene/3d/look_at_modifier_3d.h
index f4bdc381ad..b793152ec9 100644
--- a/scene/3d/look_at_modifier_3d.h
+++ b/scene/3d/look_at_modifier_3d.h
@@ -56,7 +56,8 @@ public:
 	};
 
 private:
-	int bone = 0;
+	String bone_name;
+	int bone = -1;
 
 	Vector3 forward_vector;
 	Vector3 forward_vector_nrm;
@@ -66,6 +67,7 @@ private:
 	bool use_secondary_rotation = true;
 
 	OriginFrom origin_from = ORIGIN_FROM_SELF;
+	String origin_bone_name;
 	int origin_bone = -1;
 	NodePath origin_external_node;
 
@@ -125,6 +127,8 @@ protected:
 	virtual void _process_modification() override;
 
 public:
+	void set_bone_name(const String &p_bone_name);
+	String get_bone_name() const;
 	void set_bone(int p_bone);
 	int get_bone() const;
 
@@ -137,6 +141,8 @@ public:
 
 	void set_origin_from(OriginFrom p_origin_from);
 	OriginFrom get_origin_from() const;
+	void set_origin_bone_name(const String &p_bone_name);
+	String get_origin_bone_name() const;
 	void set_origin_bone(int p_bone);
 	int get_origin_bone() const;
 	void set_origin_external_node(const NodePath &p_external_node);
diff --git a/scene/3d/node_3d.cpp b/scene/3d/node_3d.cpp
index 91edd49177..9e27b49c72 100644
--- a/scene/3d/node_3d.cpp
+++ b/scene/3d/node_3d.cpp
@@ -843,10 +843,10 @@ void Node3D::reparent(Node *p_parent, bool p_keep_global_transform) {
 	ERR_THREAD_GUARD;
 	if (p_keep_global_transform) {
 		Transform3D temp = get_global_transform();
-		Node::reparent(p_parent);
+		Node::reparent(p_parent, p_keep_global_transform);
 		set_global_transform(temp);
 	} else {
-		Node::reparent(p_parent);
+		Node::reparent(p_parent, p_keep_global_transform);
 	}
 }
 
diff --git a/scene/3d/physics/collision_shape_3d.cpp b/scene/3d/physics/collision_shape_3d.cpp
index c169045701..84dd03d353 100644
--- a/scene/3d/physics/collision_shape_3d.cpp
+++ b/scene/3d/physics/collision_shape_3d.cpp
@@ -83,12 +83,19 @@ void CollisionShape3D::_update_in_shape_owner(bool p_xform_only) {
 void CollisionShape3D::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_PARENTED: {
+#ifdef DEBUG_ENABLED
+			if (debug_color == get_placeholder_default_color()) {
+				debug_color = SceneTree::get_singleton()->get_debug_collisions_color();
+			}
+#endif // DEBUG_ENABLED
+
 			collision_object = Object::cast_to<CollisionObject3D>(get_parent());
 			if (collision_object) {
 				owner_id = collision_object->create_shape_owner(this);
 				if (shape.is_valid()) {
 					collision_object->shape_owner_add_shape(owner_id, shape);
 				}
+
 				_update_in_shape_owner();
 			}
 		} break;
@@ -168,11 +175,26 @@ void CollisionShape3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_shape"), &CollisionShape3D::get_shape);
 	ClassDB::bind_method(D_METHOD("set_disabled", "enable"), &CollisionShape3D::set_disabled);
 	ClassDB::bind_method(D_METHOD("is_disabled"), &CollisionShape3D::is_disabled);
+
 	ClassDB::bind_method(D_METHOD("make_convex_from_siblings"), &CollisionShape3D::make_convex_from_siblings);
 	ClassDB::set_method_flags("CollisionShape3D", "make_convex_from_siblings", METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
 
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape3D"), "set_shape", "get_shape");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
+
+#ifdef DEBUG_ENABLED
+	ClassDB::bind_method(D_METHOD("set_debug_color", "color"), &CollisionShape3D::set_debug_color);
+	ClassDB::bind_method(D_METHOD("get_debug_color"), &CollisionShape3D::get_debug_color);
+
+	ClassDB::bind_method(D_METHOD("set_enable_debug_fill", "enable"), &CollisionShape3D::set_debug_fill_enabled);
+	ClassDB::bind_method(D_METHOD("get_enable_debug_fill"), &CollisionShape3D::get_debug_fill_enabled);
+
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "debug_color"), "set_debug_color", "get_debug_color");
+	// Default value depends on a project setting, override for doc generation purposes.
+	ADD_PROPERTY_DEFAULT("debug_color", get_placeholder_default_color());
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug_fill"), "set_enable_debug_fill", "get_enable_debug_fill");
+#endif // DEBUG_ENABLED
 }
 
 void CollisionShape3D::set_shape(const Ref<Shape3D> &p_shape) {
@@ -180,11 +202,27 @@ void CollisionShape3D::set_shape(const Ref<Shape3D> &p_shape) {
 		return;
 	}
 	if (shape.is_valid()) {
+		shape->disconnect_changed(callable_mp(this, &CollisionShape3D::shape_changed));
 		shape->disconnect_changed(callable_mp((Node3D *)this, &Node3D::update_gizmos));
 	}
 	shape = p_shape;
 	if (shape.is_valid()) {
+#ifdef DEBUG_ENABLED
+		if (shape->get_debug_color() != get_placeholder_default_color()) {
+			set_debug_color(shape->get_debug_color());
+			set_debug_fill_enabled(shape->get_debug_fill());
+		} else if (get_debug_color() != get_placeholder_default_color()) {
+			shape->set_debug_color(debug_color);
+			shape->set_debug_fill(debug_fill);
+		} else {
+			set_debug_color(SceneTree::get_singleton()->get_debug_collisions_color());
+			shape->set_debug_color(SceneTree::get_singleton()->get_debug_collisions_color());
+			shape->set_debug_fill(debug_fill);
+		}
+#endif // DEBUG_ENABLED
+
 		shape->connect_changed(callable_mp((Node3D *)this, &Node3D::update_gizmos));
+		shape->connect_changed(callable_mp(this, &CollisionShape3D::shape_changed));
 	}
 	update_gizmos();
 	if (collision_object) {
@@ -217,6 +255,66 @@ bool CollisionShape3D::is_disabled() const {
 	return disabled;
 }
 
+#ifdef DEBUG_ENABLED
+void CollisionShape3D::set_debug_color(const Color &p_color) {
+	if (p_color == get_placeholder_default_color()) {
+		debug_color = SceneTree::get_singleton()->get_debug_collisions_color();
+	} else if (debug_color != p_color) {
+		debug_color = p_color;
+
+		if (shape.is_valid()) {
+			shape->set_debug_color(p_color);
+		}
+	}
+}
+
+Color CollisionShape3D::get_debug_color() const {
+	return debug_color;
+}
+
+void CollisionShape3D::set_debug_fill_enabled(bool p_enable) {
+	if (debug_fill == p_enable) {
+		return;
+	}
+
+	debug_fill = p_enable;
+
+	if (shape.is_valid()) {
+		shape->set_debug_fill(p_enable);
+	}
+}
+
+bool CollisionShape3D::get_debug_fill_enabled() const {
+	return debug_fill;
+}
+
+bool CollisionShape3D::_property_can_revert(const StringName &p_name) const {
+	if (p_name == "debug_color") {
+		return true;
+	}
+	return false;
+}
+
+bool CollisionShape3D::_property_get_revert(const StringName &p_name, Variant &r_property) const {
+	if (p_name == "debug_color") {
+		r_property = SceneTree::get_singleton()->get_debug_collisions_color();
+		return true;
+	}
+	return false;
+}
+#endif // DEBUG_ENABLED
+
+void CollisionShape3D::shape_changed() {
+#ifdef DEBUG_ENABLED
+	if (shape->get_debug_color() != debug_color) {
+		set_debug_color(shape->get_debug_color());
+	}
+	if (shape->get_debug_fill() != debug_fill) {
+		set_debug_fill_enabled(shape->get_debug_fill());
+	}
+#endif // DEBUG_ENABLED
+}
+
 CollisionShape3D::CollisionShape3D() {
 	//indicator = RenderingServer::get_singleton()->mesh_create();
 	set_notify_local_transform(true);
diff --git a/scene/3d/physics/collision_shape_3d.h b/scene/3d/physics/collision_shape_3d.h
index 74f7c16d33..56544806da 100644
--- a/scene/3d/physics/collision_shape_3d.h
+++ b/scene/3d/physics/collision_shape_3d.h
@@ -45,6 +45,13 @@ class CollisionShape3D : public Node3D {
 	uint32_t owner_id = 0;
 	CollisionObject3D *collision_object = nullptr;
 
+#ifdef DEBUG_ENABLED
+	Color debug_color = get_placeholder_default_color();
+	bool debug_fill = true;
+
+	static const Color get_placeholder_default_color() { return Color(0.0, 0.0, 0.0, 0.0); }
+#endif // DEBUG_ENABLED
+
 #ifndef DISABLE_DEPRECATED
 	void resource_changed(Ref<Resource> res);
 #endif
@@ -57,6 +64,13 @@ protected:
 	void _notification(int p_what);
 	static void _bind_methods();
 
+#ifdef DEBUG_ENABLED
+	bool _property_can_revert(const StringName &p_name) const;
+	bool _property_get_revert(const StringName &p_name, Variant &r_property) const;
+#endif // DEBUG_ENABLED
+
+	void shape_changed();
+
 public:
 	void make_convex_from_siblings();
 
@@ -66,6 +80,14 @@ public:
 	void set_disabled(bool p_disabled);
 	bool is_disabled() const;
 
+#ifdef DEBUG_ENABLED
+	void set_debug_color(const Color &p_color);
+	Color get_debug_color() const;
+
+	void set_debug_fill_enabled(bool p_enable);
+	bool get_debug_fill_enabled() const;
+#endif // DEBUG_ENABLED
+
 	PackedStringArray get_configuration_warnings() const override;
 
 	CollisionShape3D();
diff --git a/scene/3d/retarget_modifier_3d.cpp b/scene/3d/retarget_modifier_3d.cpp
new file mode 100644
index 0000000000..7e2462faf8
--- /dev/null
+++ b/scene/3d/retarget_modifier_3d.cpp
@@ -0,0 +1,443 @@
+/**************************************************************************/
+/*  retarget_modifier_3d.cpp                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             REDOT ENGINE                               */
+/*                        https://redotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2024-present Redot Engine contributors                   */
+/*                                          (see REDOT_AUTHORS.md)        */
+/* 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 "retarget_modifier_3d.h"
+
+PackedStringArray RetargetModifier3D::get_configuration_warnings() const {
+	PackedStringArray warnings = SkeletonModifier3D::get_configuration_warnings();
+	if (child_skeletons.is_empty()) {
+		warnings.push_back(RTR("There is no child Skeleton3D!"));
+	}
+	return warnings;
+}
+
+/// Caching
+
+void RetargetModifier3D::_profile_changed(Ref<SkeletonProfile> p_old, Ref<SkeletonProfile> p_new) {
+	if (p_old.is_valid() && p_old->is_connected(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset))) {
+		p_old->disconnect(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset));
+	}
+	profile = p_new;
+	if (p_new.is_valid() && !p_new->is_connected(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset))) {
+		p_new->connect(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset));
+	}
+	cache_rests_with_reset();
+}
+
+void RetargetModifier3D::_skeleton_changed(Skeleton3D *p_old, Skeleton3D *p_new) {
+	if (p_old && p_old->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests))) {
+		p_old->disconnect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests));
+	}
+	if (p_new && !p_new->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests))) {
+		p_new->connect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests));
+	}
+	cache_rests();
+}
+
+void RetargetModifier3D::cache_rests_with_reset() {
+	_reset_child_skeleton_poses();
+	cache_rests();
+}
+
+void RetargetModifier3D::cache_rests() {
+	source_bone_ids.clear();
+
+	Skeleton3D *source_skeleton = get_skeleton();
+	if (profile.is_null() || !source_skeleton) {
+		return;
+	}
+
+	PackedStringArray bone_names = profile->get_bone_names();
+	for (const String &E : bone_names) {
+		source_bone_ids.push_back(source_skeleton->find_bone(E));
+	}
+
+	for (int i = 0; i < child_skeletons.size(); i++) {
+		_update_child_skeleton_rests(i);
+	}
+}
+
+Vector<RetargetModifier3D::RetargetBoneInfo> RetargetModifier3D::cache_bone_global_rests(Skeleton3D *p_skeleton) {
+	// Retarget global pose in model space:
+	// tgt_global_pose.basis = src_global_pose.basis * src_rest.basis.inv * src_parent_global_rest.basis.inv * tgt_parent_global_rest.basis * tgt_rest.basis
+	// tgt_global_pose.origin = src_global_pose.origin
+	Skeleton3D *source_skeleton = get_skeleton();
+	Vector<RetargetBoneInfo> bone_rests;
+	if (profile.is_null() || !source_skeleton) {
+		return bone_rests;
+	}
+	PackedStringArray bone_names = profile->get_bone_names();
+	for (const String &E : bone_names) {
+		RetargetBoneInfo rbi;
+		int source_bone_id = source_skeleton->find_bone(E);
+		if (source_bone_id >= 0) {
+			Transform3D parent_global_rest;
+			int bone_parent = source_skeleton->get_bone_parent(source_bone_id);
+			if (bone_parent >= 0) {
+				parent_global_rest = source_skeleton->get_bone_global_rest(bone_parent);
+			}
+			rbi.post_basis = source_skeleton->get_bone_rest(source_bone_id).basis.inverse() * parent_global_rest.basis.inverse();
+		}
+		int target_bone_id = p_skeleton->find_bone(E);
+		rbi.bone_id = target_bone_id;
+		if (target_bone_id >= 0) {
+			Transform3D parent_global_rest;
+			int bone_parent = p_skeleton->get_bone_parent(target_bone_id);
+			if (bone_parent >= 0) {
+				parent_global_rest = p_skeleton->get_bone_global_rest(bone_parent);
+			}
+			rbi.post_basis = rbi.post_basis * parent_global_rest.basis * p_skeleton->get_bone_rest(target_bone_id).basis;
+		}
+		bone_rests.push_back(rbi);
+	}
+	return bone_rests;
+}
+
+Vector<RetargetModifier3D::RetargetBoneInfo> RetargetModifier3D::cache_bone_rests(Skeleton3D *p_skeleton) {
+	// Retarget pose in model space:
+	// tgt_pose.basis = tgt_parent_global_rest.basis.inv * src_parent_global_rest.basis * src_pose.basis * src_rest.basis.inv * src_parent_global_rest.basis.inv * tgt_parent_global_rest.basis * tgt_rest.basis
+	// tgt_pose.origin = tgt_parent_global_rest.basis.inv.xform(src_parent_global_rest.basis.xform(src_pose.origin - src_rest.origin)) + tgt_rest.origin
+	Skeleton3D *source_skeleton = get_skeleton();
+	Vector<RetargetBoneInfo> bone_rests;
+	if (profile.is_null() || !source_skeleton) {
+		return bone_rests;
+	}
+	PackedStringArray bone_names = profile->get_bone_names();
+	for (const String &E : bone_names) {
+		RetargetBoneInfo rbi;
+		int source_bone_id = source_skeleton->find_bone(E);
+		if (source_bone_id >= 0) {
+			Transform3D parent_global_rest;
+			int bone_parent = source_skeleton->get_bone_parent(source_bone_id);
+			if (bone_parent >= 0) {
+				parent_global_rest = source_skeleton->get_bone_global_rest(bone_parent);
+			}
+			rbi.pre_basis = parent_global_rest.basis;
+			rbi.post_basis = source_skeleton->get_bone_rest(source_bone_id).basis.inverse() * parent_global_rest.basis.inverse();
+		}
+
+		int target_bone_id = p_skeleton->find_bone(E);
+		rbi.bone_id = target_bone_id;
+		if (target_bone_id >= 0) {
+			Transform3D parent_global_rest;
+			int bone_parent = p_skeleton->get_bone_parent(target_bone_id);
+			if (bone_parent >= 0) {
+				parent_global_rest = p_skeleton->get_bone_global_rest(bone_parent);
+			}
+			rbi.pre_basis = parent_global_rest.basis.inverse() * rbi.pre_basis;
+			rbi.post_basis = rbi.post_basis * parent_global_rest.basis * p_skeleton->get_bone_rest(target_bone_id).basis;
+		}
+		bone_rests.push_back(rbi);
+	}
+	return bone_rests;
+}
+
+void RetargetModifier3D::_update_child_skeleton_rests(int p_child_skeleton_idx) {
+	ERR_FAIL_INDEX(p_child_skeleton_idx, child_skeletons.size());
+	Skeleton3D *c = Object::cast_to<Skeleton3D>(ObjectDB::get_instance(child_skeletons[p_child_skeleton_idx].skeleton_id));
+	if (!c) {
+		return;
+	}
+	if (use_global_pose) {
+		child_skeletons.write[p_child_skeleton_idx].humanoid_bone_rests = cache_bone_global_rests(c);
+	} else {
+		child_skeletons.write[p_child_skeleton_idx].humanoid_bone_rests = cache_bone_rests(c);
+	}
+}
+
+void RetargetModifier3D::_update_child_skeletons() {
+	_reset_child_skeletons();
+
+	for (int i = 0; i < get_child_count(); i++) {
+		RetargetInfo ri;
+		Skeleton3D *c = Object::cast_to<Skeleton3D>(get_child(i));
+		if (c) {
+			int id = child_skeletons.size();
+			ri.skeleton_id = c->get_instance_id();
+			child_skeletons.push_back(ri);
+			c->connect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests).bind(id));
+		}
+	}
+
+	cache_rests();
+	update_configuration_warnings();
+}
+
+void RetargetModifier3D::_reset_child_skeleton_poses() {
+	for (const RetargetInfo &E : child_skeletons) {
+		Skeleton3D *c = Object::cast_to<Skeleton3D>(ObjectDB::get_instance(E.skeleton_id));
+		if (!c) {
+			continue;
+		}
+		if (c->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests))) {
+			c->disconnect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests));
+		}
+		for (const RetargetBoneInfo &F : E.humanoid_bone_rests) {
+			if (F.bone_id < 0) {
+				continue;
+			}
+			c->reset_bone_pose(F.bone_id);
+		}
+	}
+}
+
+void RetargetModifier3D::_reset_child_skeletons() {
+	_reset_child_skeleton_poses();
+	child_skeletons.clear();
+}
+
+/// General functions
+
+void RetargetModifier3D::add_child_notify(Node *p_child) {
+	if (Object::cast_to<Skeleton3D>(p_child)) {
+		_update_child_skeletons();
+	}
+}
+
+void RetargetModifier3D::move_child_notify(Node *p_child) {
+	if (Object::cast_to<Skeleton3D>(p_child)) {
+		_update_child_skeletons();
+	}
+}
+
+void RetargetModifier3D::remove_child_notify(Node *p_child) {
+	if (Object::cast_to<Skeleton3D>(p_child)) {
+		// Reset after process.
+		callable_mp(this, &RetargetModifier3D::_update_child_skeletons).call_deferred();
+	}
+}
+
+void RetargetModifier3D::_validate_property(PropertyInfo &p_property) const {
+	if (use_global_pose) {
+		if (p_property.name == "position_enabled" || p_property.name == "rotation_enabled" || p_property.name == "scale_enabled") {
+			p_property.usage = PROPERTY_USAGE_NONE;
+		}
+	}
+}
+
+void RetargetModifier3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_profile", "profile"), &RetargetModifier3D::set_profile);
+	ClassDB::bind_method(D_METHOD("get_profile"), &RetargetModifier3D::get_profile);
+	ClassDB::bind_method(D_METHOD("set_use_global_pose", "use_global_pose"), &RetargetModifier3D::set_use_global_pose);
+	ClassDB::bind_method(D_METHOD("is_using_global_pose"), &RetargetModifier3D::is_using_global_pose);
+	ClassDB::bind_method(D_METHOD("set_position_enabled", "enabled"), &RetargetModifier3D::set_position_enabled);
+	ClassDB::bind_method(D_METHOD("is_position_enabled"), &RetargetModifier3D::is_position_enabled);
+	ClassDB::bind_method(D_METHOD("set_rotation_enabled", "enabled"), &RetargetModifier3D::set_rotation_enabled);
+	ClassDB::bind_method(D_METHOD("is_rotation_enabled"), &RetargetModifier3D::is_rotation_enabled);
+	ClassDB::bind_method(D_METHOD("set_scale_enabled", "enabled"), &RetargetModifier3D::set_scale_enabled);
+	ClassDB::bind_method(D_METHOD("is_scale_enabled"), &RetargetModifier3D::is_scale_enabled);
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "profile", PROPERTY_HINT_RESOURCE_TYPE, "SkeletonProfile"), "set_profile", "get_profile");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_global_pose"), "set_use_global_pose", "is_using_global_pose");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "position_enabled"), "set_position_enabled", "is_position_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "rotation_enabled"), "set_rotation_enabled", "is_rotation_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "scale_enabled"), "set_scale_enabled", "is_scale_enabled");
+}
+
+void RetargetModifier3D::_set_active(bool p_active) {
+	if (!p_active) {
+		_reset_child_skeleton_poses();
+	}
+}
+
+void RetargetModifier3D::_retarget_global_pose() {
+	Skeleton3D *source_skeleton = get_skeleton();
+	if (profile.is_null() || !source_skeleton) {
+		return;
+	}
+
+	LocalVector<Transform3D> source_poses;
+	if (influence < 1.0) {
+		for (int source_bone_id : source_bone_ids) {
+			source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_global_rest(source_bone_id).interpolate_with(source_skeleton->get_bone_global_pose(source_bone_id), influence));
+		}
+	} else {
+		for (int source_bone_id : source_bone_ids) {
+			source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_global_pose(source_bone_id));
+		}
+	}
+
+	for (const RetargetInfo &E : child_skeletons) {
+		Skeleton3D *target_skeleton = Object::cast_to<Skeleton3D>(ObjectDB::get_instance(E.skeleton_id));
+		if (!target_skeleton) {
+			continue;
+		}
+		for (int i = 0; i < source_bone_ids.size(); i++) {
+			int target_bone_id = E.humanoid_bone_rests[i].bone_id;
+			if (target_bone_id < 0) {
+				continue;
+			}
+			Transform3D retarget_pose = source_poses[i];
+			retarget_pose.basis = retarget_pose.basis * E.humanoid_bone_rests[i].post_basis;
+			target_skeleton->set_bone_global_pose(target_bone_id, retarget_pose);
+		}
+	}
+}
+
+void RetargetModifier3D::_retarget_pose() {
+	Skeleton3D *source_skeleton = get_skeleton();
+	if (profile.is_null() || !source_skeleton) {
+		return;
+	}
+
+	LocalVector<Transform3D> source_poses;
+	if (influence < 1.0) {
+		for (int source_bone_id : source_bone_ids) {
+			source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_rest(source_bone_id).interpolate_with(source_skeleton->get_bone_pose(source_bone_id), influence));
+		}
+	} else {
+		for (int source_bone_id : source_bone_ids) {
+			source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_pose(source_bone_id));
+		}
+	}
+
+	for (const RetargetInfo &E : child_skeletons) {
+		Skeleton3D *target_skeleton = Object::cast_to<Skeleton3D>(ObjectDB::get_instance(E.skeleton_id));
+		if (!target_skeleton) {
+			continue;
+		}
+		float motion_scale_ratio = target_skeleton->get_motion_scale() / source_skeleton->get_motion_scale();
+		for (int i = 0; i < source_bone_ids.size(); i++) {
+			int target_bone_id = E.humanoid_bone_rests[i].bone_id;
+			if (target_bone_id < 0) {
+				continue;
+			}
+			int source_bone_id = source_bone_ids[i];
+			if (source_bone_id < 0) {
+				continue;
+			}
+
+			Transform3D extracted_transform = source_poses[i];
+			extracted_transform.basis = E.humanoid_bone_rests[i].pre_basis * extracted_transform.basis * E.humanoid_bone_rests[i].post_basis;
+			extracted_transform.origin = E.humanoid_bone_rests[i].pre_basis.xform((extracted_transform.origin - source_skeleton->get_bone_rest(source_bone_id).origin) * motion_scale_ratio) + target_skeleton->get_bone_rest(target_bone_id).origin;
+
+			Transform3D retarget_pose = target_skeleton->get_bone_pose(target_bone_id);
+			if (enable_position) {
+				retarget_pose.origin = extracted_transform.origin;
+			}
+			if (enable_rotation) {
+				retarget_pose.basis = extracted_transform.basis.get_rotation_quaternion();
+			}
+			if (enable_scale) {
+				retarget_pose.basis.scale_local(extracted_transform.basis.get_scale());
+			}
+			target_skeleton->set_bone_pose(target_bone_id, retarget_pose);
+		}
+	}
+}
+
+void RetargetModifier3D::_process_modification() {
+	if (use_global_pose) {
+		_retarget_global_pose();
+	} else {
+		_retarget_pose();
+	}
+}
+
+void RetargetModifier3D::set_profile(Ref<SkeletonProfile> p_profile) {
+	if (profile == p_profile) {
+		return;
+	}
+	_profile_changed(profile, p_profile);
+}
+
+Ref<SkeletonProfile> RetargetModifier3D::get_profile() const {
+	return profile;
+}
+
+void RetargetModifier3D::set_use_global_pose(bool p_use_global_pose) {
+	if (use_global_pose == p_use_global_pose) {
+		return;
+	}
+
+	use_global_pose = p_use_global_pose;
+	cache_rests_with_reset();
+
+	notify_property_list_changed();
+}
+
+bool RetargetModifier3D::is_using_global_pose() const {
+	return use_global_pose;
+}
+
+void RetargetModifier3D::set_position_enabled(bool p_enabled) {
+	if (enable_position != p_enabled) {
+		_reset_child_skeleton_poses();
+	}
+	enable_position = p_enabled;
+}
+
+bool RetargetModifier3D::is_position_enabled() const {
+	return enable_position;
+}
+
+void RetargetModifier3D::set_rotation_enabled(bool p_enabled) {
+	if (enable_rotation != p_enabled) {
+		_reset_child_skeleton_poses();
+	}
+	enable_rotation = p_enabled;
+}
+
+bool RetargetModifier3D::is_rotation_enabled() const {
+	return enable_rotation;
+}
+
+void RetargetModifier3D::set_scale_enabled(bool p_enabled) {
+	if (enable_scale != p_enabled) {
+		_reset_child_skeleton_poses();
+	}
+	enable_scale = p_enabled;
+}
+
+bool RetargetModifier3D::is_scale_enabled() const {
+	return enable_scale;
+}
+
+void RetargetModifier3D::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			_update_child_skeletons();
+		} break;
+		case NOTIFICATION_EDITOR_PRE_SAVE: {
+			_reset_child_skeleton_poses();
+		} break;
+		case NOTIFICATION_EXIT_TREE: {
+			_reset_child_skeletons();
+		} break;
+	}
+}
+
+RetargetModifier3D::RetargetModifier3D() {
+}
+
+RetargetModifier3D::~RetargetModifier3D() {
+}
diff --git a/scene/3d/retarget_modifier_3d.h b/scene/3d/retarget_modifier_3d.h
new file mode 100644
index 0000000000..b6b5735bc2
--- /dev/null
+++ b/scene/3d/retarget_modifier_3d.h
@@ -0,0 +1,112 @@
+/**************************************************************************/
+/*  retarget_modifier_3d.h                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             REDOT ENGINE                               */
+/*                        https://redotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2024-present Redot Engine contributors                   */
+/*                                          (see REDOT_AUTHORS.md)        */
+/* 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 RETARGET_MODIFIER_3D_H
+#define RETARGET_MODIFIER_3D_H
+
+#include "scene/3d/skeleton_modifier_3d.h"
+#include "scene/resources/skeleton_profile.h"
+
+class RetargetModifier3D : public SkeletonModifier3D {
+	GDCLASS(RetargetModifier3D, SkeletonModifier3D);
+
+	Ref<SkeletonProfile> profile;
+
+	bool use_global_pose = false;
+	bool enable_position = true;
+	bool enable_rotation = true;
+	bool enable_scale = true;
+
+	struct RetargetBoneInfo {
+		int bone_id = -1;
+		Basis pre_basis;
+		Basis post_basis;
+	};
+
+	struct RetargetInfo {
+		ObjectID skeleton_id;
+		Vector<RetargetBoneInfo> humanoid_bone_rests;
+	};
+
+	Vector<RetargetInfo> child_skeletons;
+	Vector<int> source_bone_ids;
+
+	void _update_child_skeleton_rests(int p_child_skeleton_idx);
+	void _update_child_skeletons();
+	void _reset_child_skeleton_poses();
+	void _reset_child_skeletons();
+
+	void cache_rests_with_reset();
+	void cache_rests();
+	Vector<RetargetBoneInfo> cache_bone_global_rests(Skeleton3D *p_skeleton);
+	Vector<RetargetBoneInfo> cache_bone_rests(Skeleton3D *p_skeleton);
+	Vector<RetargetBoneInfo> get_humanoid_bone_rests(Skeleton3D *p_skeleton);
+
+	void _retarget_global_pose();
+	void _retarget_pose();
+
+protected:
+	virtual void _skeleton_changed(Skeleton3D *p_old, Skeleton3D *p_new) override;
+	void _profile_changed(Ref<SkeletonProfile> p_old, Ref<SkeletonProfile> p_new);
+
+	void _validate_property(PropertyInfo &p_property) const;
+
+	static void _bind_methods();
+	virtual void _notification(int p_what);
+
+	virtual void add_child_notify(Node *p_child) override;
+	virtual void move_child_notify(Node *p_child) override;
+	virtual void remove_child_notify(Node *p_child) override;
+
+	virtual void _set_active(bool p_active) override;
+	virtual void _process_modification() override;
+
+public:
+	virtual PackedStringArray get_configuration_warnings() const override;
+
+	void set_use_global_pose(bool p_use_global_pose);
+	bool is_using_global_pose() const;
+	void set_position_enabled(bool p_enabled);
+	bool is_position_enabled() const;
+	void set_rotation_enabled(bool p_enabled);
+	bool is_rotation_enabled() const;
+	void set_scale_enabled(bool p_enabled);
+	bool is_scale_enabled() const;
+
+	void set_profile(Ref<SkeletonProfile> p_profile);
+	Ref<SkeletonProfile> get_profile() const;
+
+	RetargetModifier3D();
+	virtual ~RetargetModifier3D();
+};
+
+#endif // RETARGET_MODIFIER_3D_H
diff --git a/scene/3d/skeleton_3d.cpp b/scene/3d/skeleton_3d.cpp
index 89212503ca..273b68d277 100644
--- a/scene/3d/skeleton_3d.cpp
+++ b/scene/3d/skeleton_3d.cpp
@@ -1050,7 +1050,12 @@ void Skeleton3D::force_update_all_bone_transforms() {
 	for (int i = 0; i < parentless_bones.size(); i++) {
 		force_update_bone_children_transforms(parentless_bones[i]);
 	}
-	rest_dirty = false;
+	if (rest_dirty) {
+		rest_dirty = false;
+		emit_signal(SNAME("rest_updated"));
+	} else {
+		rest_dirty = false;
+	}
 	dirty = false;
 	if (updating) {
 		return;
@@ -1260,6 +1265,7 @@ void Skeleton3D::_bind_methods() {
 	ADD_GROUP("Modifier", "modifier_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "modifier_callback_mode_process", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_modifier_callback_mode_process", "get_modifier_callback_mode_process");
 
+	ADD_SIGNAL(MethodInfo("rest_updated"));
 	ADD_SIGNAL(MethodInfo("pose_updated"));
 	ADD_SIGNAL(MethodInfo("skeleton_updated"));
 	ADD_SIGNAL(MethodInfo("bone_enabled_changed", PropertyInfo(Variant::INT, "bone_idx")));
diff --git a/scene/3d/skeleton_3d.h b/scene/3d/skeleton_3d.h
index 2abf989560..7df102a301 100644
--- a/scene/3d/skeleton_3d.h
+++ b/scene/3d/skeleton_3d.h
@@ -224,6 +224,7 @@ public:
 	// Skeleton creation API
 	uint64_t get_version() const;
 	int add_bone(const String &p_name);
+	void remove_bone(int p_bone);
 	int find_bone(const String &p_name) const;
 	String get_bone_name(int p_bone) const;
 	void set_bone_name(int p_bone, const String &p_name);