1 files changed, 94 insertions, 107 deletions

diff --git a/scene/3d/skeleton_3d.cpp b/scene/3d/skeleton_3d.cpp
index 973822653a..0ae1c0e3b6 100644
--- a/scene/3d/skeleton_3d.cpp
+++ b/scene/3d/skeleton_3d.cpp
@@ -30,12 +30,13 @@
 
 #include "skeleton_3d.h"
 
-#include "core/engine.h"
-#include "core/message_queue.h"
-#include "core/project_settings.h"
-#include "core/type_info.h"
+#include "core/config/engine.h"
+#include "core/config/project_settings.h"
+#include "core/object/message_queue.h"
+#include "core/variant/type_info.h"
 #include "scene/3d/physics_body_3d.h"
 #include "scene/resources/surface_tool.h"
+#include "scene/scene_string_names.h"
 
 void SkinReference::_skin_changed() {
 	if (skeleton_node) {
@@ -66,40 +67,40 @@ SkinReference::~SkinReference() {
 	RS::get_singleton()->free(skeleton);
 }
 
-bool Skeleton3D::_set(const StringName &p_path, const Variant &p_value) {
+///////////////////////////////////////
 
+bool Skeleton3D::_set(const StringName &p_path, const Variant &p_value) {
 	String path = p_path;
 
-	if (!path.begins_with("bones/"))
+	if (!path.begins_with("bones/")) {
 		return false;
+	}
 
 	int which = path.get_slicec('/', 1).to_int();
 	String what = path.get_slicec('/', 2);
 
 	if (which == bones.size() && what == "name") {
-
 		add_bone(p_value);
 		return true;
 	}
 
 	ERR_FAIL_INDEX_V(which, bones.size(), false);
 
-	if (what == "parent")
+	if (what == "parent") {
 		set_bone_parent(which, p_value);
-	else if (what == "rest")
+	} else if (what == "rest") {
 		set_bone_rest(which, p_value);
-	else if (what == "enabled")
+	} else if (what == "enabled") {
 		set_bone_enabled(which, p_value);
-	else if (what == "pose")
+	} else if (what == "pose") {
 		set_bone_pose(which, p_value);
-	else if (what == "bound_children") {
+	} else if (what == "bound_children") {
 		Array children = p_value;
 
 		if (is_inside_tree()) {
 			bones.write[which].nodes_bound.clear();
 
 			for (int i = 0; i < children.size(); i++) {
-
 				NodePath npath = children[i];
 				ERR_CONTINUE(npath.operator String() == "");
 				Node *node = get_node(npath);
@@ -115,32 +116,31 @@ bool Skeleton3D::_set(const StringName &p_path, const Variant &p_value) {
 }
 
 bool Skeleton3D::_get(const StringName &p_path, Variant &r_ret) const {
-
 	String path = p_path;
 
-	if (!path.begins_with("bones/"))
+	if (!path.begins_with("bones/")) {
 		return false;
+	}
 
 	int which = path.get_slicec('/', 1).to_int();
 	String what = path.get_slicec('/', 2);
 
 	ERR_FAIL_INDEX_V(which, bones.size(), false);
 
-	if (what == "name")
+	if (what == "name") {
 		r_ret = get_bone_name(which);
-	else if (what == "parent")
+	} else if (what == "parent") {
 		r_ret = get_bone_parent(which);
-	else if (what == "rest")
+	} else if (what == "rest") {
 		r_ret = get_bone_rest(which);
-	else if (what == "enabled")
+	} else if (what == "enabled") {
 		r_ret = is_bone_enabled(which);
-	else if (what == "pose")
+	} else if (what == "pose") {
 		r_ret = get_bone_pose(which);
-	else if (what == "bound_children") {
+	} else if (what == "bound_children") {
 		Array children;
 
 		for (const List<ObjectID>::Element *E = bones[which].nodes_bound.front(); E; E = E->next()) {
-
 			Object *obj = ObjectDB::get_instance(E->get());
 			ERR_CONTINUE(!obj);
 			Node *node = Object::cast_to<Node>(obj);
@@ -150,29 +150,29 @@ bool Skeleton3D::_get(const StringName &p_path, Variant &r_ret) const {
 		}
 
 		r_ret = children;
-	} else
+	} else {
 		return false;
+	}
 
 	return true;
 }
-void Skeleton3D::_get_property_list(List<PropertyInfo> *p_list) const {
 
+void Skeleton3D::_get_property_list(List<PropertyInfo> *p_list) const {
 	for (int i = 0; i < bones.size(); i++) {
-
 		String prep = "bones/" + itos(i) + "/";
-		p_list->push_back(PropertyInfo(Variant::STRING, prep + "name"));
-		p_list->push_back(PropertyInfo(Variant::INT, prep + "parent", PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1"));
-		p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "rest"));
-		p_list->push_back(PropertyInfo(Variant::BOOL, prep + "enabled"));
-		p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "pose", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
-		p_list->push_back(PropertyInfo(Variant::ARRAY, prep + "bound_children"));
+		p_list->push_back(PropertyInfo(Variant::STRING, prep + "name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+		p_list->push_back(PropertyInfo(Variant::INT, prep + "parent", PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1", PROPERTY_USAGE_NOEDITOR));
+		p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "rest", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+		p_list->push_back(PropertyInfo(Variant::BOOL, prep + "enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+		p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "pose", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+		p_list->push_back(PropertyInfo(Variant::ARRAY, prep + "bound_children", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
 	}
 }
 
 void Skeleton3D::_update_process_order() {
-
-	if (!process_order_dirty)
+	if (!process_order_dirty) {
 		return;
+	}
 
 	Bone *bonesptr = bones.ptrw();
 	int len = bones.size();
@@ -180,7 +180,6 @@ void Skeleton3D::_update_process_order() {
 	process_order.resize(len);
 	int *order = process_order.ptrw();
 	for (int i = 0; i < len; i++) {
-
 		if (bonesptr[i].parent >= len) {
 			//validate this just in case
 			ERR_PRINT("Bone " + itos(i) + " has invalid parent: " + itos(bonesptr[i].parent));
@@ -197,8 +196,9 @@ void Skeleton3D::_update_process_order() {
 		bool swapped = false;
 		for (int i = 0; i < len; i++) {
 			int parent_idx = bonesptr[order[i]].parent;
-			if (parent_idx < 0)
+			if (parent_idx < 0) {
 				continue; //do nothing because it has no parent
+			}
 			//swap indices
 			int parent_order = bonesptr[parent_idx].sort_index;
 			if (parent_order > i) {
@@ -210,25 +210,23 @@ void Skeleton3D::_update_process_order() {
 			}
 		}
 
-		if (!swapped)
+		if (!swapped) {
 			break;
+		}
 		pass_count++;
 	}
 
 	if (pass_count == len * len) {
-		ERR_PRINT("Skeleton parenthood graph is cyclic");
+		ERR_PRINT("Skeleton3D parenthood graph is cyclic");
 	}
 
 	process_order_dirty = false;
 }
 
 void Skeleton3D::_notification(int p_what) {
-
 	switch (p_what) {
-
 		case NOTIFICATION_UPDATE_SKELETON: {
-
-			RenderingServer *vs = RenderingServer::get_singleton();
+			RenderingServer *rs = RenderingServer::get_singleton();
 			Bone *bonesptr = bones.ptrw();
 			int len = bones.size();
 
@@ -237,7 +235,6 @@ void Skeleton3D::_notification(int p_what) {
 			const int *order = process_order.ptr();
 
 			for (int i = 0; i < len; i++) {
-
 				Bone &b = bonesptr[order[i]];
 
 				if (b.global_pose_override_amount >= 0.999) {
@@ -245,50 +242,38 @@ void Skeleton3D::_notification(int p_what) {
 				} else {
 					if (b.disable_rest) {
 						if (b.enabled) {
-
 							Transform pose = b.pose;
 							if (b.custom_pose_enable) {
 								pose = b.custom_pose * pose;
 							}
 							if (b.parent >= 0) {
-
 								b.pose_global = bonesptr[b.parent].pose_global * pose;
 							} else {
-
 								b.pose_global = pose;
 							}
 						} else {
-
 							if (b.parent >= 0) {
-
 								b.pose_global = bonesptr[b.parent].pose_global;
 							} else {
-
 								b.pose_global = Transform();
 							}
 						}
 
 					} else {
 						if (b.enabled) {
-
 							Transform pose = b.pose;
 							if (b.custom_pose_enable) {
 								pose = b.custom_pose * pose;
 							}
 							if (b.parent >= 0) {
-
 								b.pose_global = bonesptr[b.parent].pose_global * (b.rest * pose);
 							} else {
-
 								b.pose_global = b.rest * pose;
 							}
 						} else {
-
 							if (b.parent >= 0) {
-
 								b.pose_global = bonesptr[b.parent].pose_global * b.rest;
 							} else {
-
 								b.pose_global = b.rest;
 							}
 						}
@@ -304,18 +289,16 @@ void Skeleton3D::_notification(int p_what) {
 				}
 
 				for (List<ObjectID>::Element *E = b.nodes_bound.front(); E; E = E->next()) {
-
 					Object *obj = ObjectDB::get_instance(E->get());
 					ERR_CONTINUE(!obj);
-					Node3D *sp = Object::cast_to<Node3D>(obj);
-					ERR_CONTINUE(!sp);
-					sp->set_transform(b.pose_global);
+					Node3D *node_3d = Object::cast_to<Node3D>(obj);
+					ERR_CONTINUE(!node_3d);
+					node_3d->set_transform(b.pose_global);
 				}
 			}
 
 			//update skins
 			for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
-
 				const Skin *skin = E->get()->skin.operator->();
 				RID skeleton = E->get()->skeleton;
 				uint32_t bind_count = skin->get_bind_count();
@@ -328,7 +311,6 @@ void Skeleton3D::_notification(int p_what) {
 				}
 
 				if (E->get()->skeleton_version != version) {
-
 					for (uint32_t i = 0; i < bind_count; i++) {
 						StringName bind_name = skin->get_bind_name(i);
 
@@ -344,7 +326,7 @@ void Skeleton3D::_notification(int p_what) {
 							}
 
 							if (!found) {
-								ERR_PRINT("Skin bind #" + itos(i) + " contains named bind '" + String(bind_name) + "' but Skeleton has no bone by that name.");
+								ERR_PRINT("Skin bind #" + itos(i) + " contains named bind '" + String(bind_name) + "' but Skeleton3D has no bone by that name.");
 								E->get()->skin_bone_indices_ptrs[i] = 0;
 							}
 						} else if (skin->get_bind_bone(i) >= 0) {
@@ -367,11 +349,16 @@ void Skeleton3D::_notification(int p_what) {
 				for (uint32_t i = 0; i < bind_count; i++) {
 					uint32_t bone_index = E->get()->skin_bone_indices_ptrs[i];
 					ERR_CONTINUE(bone_index >= (uint32_t)len);
-					vs->skeleton_bone_set_transform(skeleton, i, bonesptr[bone_index].pose_global * skin->get_bind_pose(i));
+					rs->skeleton_bone_set_transform(skeleton, i, bonesptr[bone_index].pose_global * skin->get_bind_pose(i));
 				}
 			}
 
 			dirty = false;
+
+#ifdef TOOLS_ENABLED
+			emit_signal(SceneStringNames::get_singleton()->pose_updated);
+#endif // TOOLS_ENABLED
+
 		} break;
 
 #ifndef _3D_DISABLED
@@ -405,7 +392,6 @@ void Skeleton3D::clear_bones_global_pose_override() {
 }
 
 void Skeleton3D::set_bone_global_pose_override(int p_bone, const Transform &p_pose, float p_amount, bool p_persistent) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 	bones.write[p_bone].global_pose_override_amount = p_amount;
 	bones.write[p_bone].global_pose_override = p_pose;
@@ -414,20 +400,18 @@ void Skeleton3D::set_bone_global_pose_override(int p_bone, const Transform &p_po
 }
 
 Transform Skeleton3D::get_bone_global_pose(int p_bone) const {
-
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), Transform());
-	if (dirty)
+	if (dirty) {
 		const_cast<Skeleton3D *>(this)->notification(NOTIFICATION_UPDATE_SKELETON);
+	}
 	return bones[p_bone].pose_global;
 }
 
 // skeleton creation api
 void Skeleton3D::add_bone(const String &p_name) {
-
 	ERR_FAIL_COND(p_name == "" || p_name.find(":") != -1 || p_name.find("/") != -1);
 
 	for (int i = 0; i < bones.size(); i++) {
-
 		ERR_FAIL_COND(bones[i].name == p_name);
 	}
 
@@ -439,43 +423,42 @@ void Skeleton3D::add_bone(const String &p_name) {
 	_make_dirty();
 	update_gizmo();
 }
-int Skeleton3D::find_bone(const String &p_name) const {
 
+int Skeleton3D::find_bone(const String &p_name) const {
 	for (int i = 0; i < bones.size(); i++) {
-
-		if (bones[i].name == p_name)
+		if (bones[i].name == p_name) {
 			return i;
+		}
 	}
 
 	return -1;
 }
-String Skeleton3D::get_bone_name(int p_bone) const {
 
+String Skeleton3D::get_bone_name(int p_bone) const {
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), "");
 
 	return bones[p_bone].name;
 }
 
 bool Skeleton3D::is_bone_parent_of(int p_bone, int p_parent_bone_id) const {
-
 	int parent_of_bone = get_bone_parent(p_bone);
 
-	if (-1 == parent_of_bone)
+	if (-1 == parent_of_bone) {
 		return false;
+	}
 
-	if (parent_of_bone == p_parent_bone_id)
+	if (parent_of_bone == p_parent_bone_id) {
 		return true;
+	}
 
 	return is_bone_parent_of(parent_of_bone, p_parent_bone_id);
 }
 
 int Skeleton3D::get_bone_count() const {
-
 	return bones.size();
 }
 
 void Skeleton3D::set_bone_parent(int p_bone, int p_parent) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 	ERR_FAIL_COND(p_parent != -1 && (p_parent < 0));
 
@@ -485,7 +468,6 @@ void Skeleton3D::set_bone_parent(int p_bone, int p_parent) {
 }
 
 void Skeleton3D::unparent_bone_and_rest(int p_bone) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	_update_process_order();
@@ -503,80 +485,73 @@ void Skeleton3D::unparent_bone_and_rest(int p_bone) {
 }
 
 void Skeleton3D::set_bone_disable_rest(int p_bone, bool p_disable) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 	bones.write[p_bone].disable_rest = p_disable;
 }
 
 bool Skeleton3D::is_bone_rest_disabled(int p_bone) const {
-
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), false);
 	return bones[p_bone].disable_rest;
 }
 
 int Skeleton3D::get_bone_parent(int p_bone) const {
-
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), -1);
 
 	return bones[p_bone].parent;
 }
 
 void Skeleton3D::set_bone_rest(int p_bone, const Transform &p_rest) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	bones.write[p_bone].rest = p_rest;
 	_make_dirty();
 }
-Transform Skeleton3D::get_bone_rest(int p_bone) const {
 
+Transform Skeleton3D::get_bone_rest(int p_bone) const {
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), Transform());
 
 	return bones[p_bone].rest;
 }
 
 void Skeleton3D::set_bone_enabled(int p_bone, bool p_enabled) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	bones.write[p_bone].enabled = p_enabled;
 	_make_dirty();
 }
-bool Skeleton3D::is_bone_enabled(int p_bone) const {
 
+bool Skeleton3D::is_bone_enabled(int p_bone) const {
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), false);
 	return bones[p_bone].enabled;
 }
 
 void Skeleton3D::bind_child_node_to_bone(int p_bone, Node *p_node) {
-
 	ERR_FAIL_NULL(p_node);
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	ObjectID id = p_node->get_instance_id();
 
 	for (const List<ObjectID>::Element *E = bones[p_bone].nodes_bound.front(); E; E = E->next()) {
-
-		if (E->get() == id)
+		if (E->get() == id) {
 			return; // already here
+		}
 	}
 
 	bones.write[p_bone].nodes_bound.push_back(id);
 }
-void Skeleton3D::unbind_child_node_from_bone(int p_bone, Node *p_node) {
 
+void Skeleton3D::unbind_child_node_from_bone(int p_bone, Node *p_node) {
 	ERR_FAIL_NULL(p_node);
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	ObjectID id = p_node->get_instance_id();
 	bones.write[p_bone].nodes_bound.erase(id);
 }
-void Skeleton3D::get_bound_child_nodes_to_bone(int p_bone, List<Node *> *p_bound) const {
 
+void Skeleton3D::get_bound_child_nodes_to_bone(int p_bone, List<Node *> *p_bound) const {
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	for (const List<ObjectID>::Element *E = bones[p_bone].nodes_bound.front(); E; E = E->next()) {
-
 		Object *obj = ObjectDB::get_instance(E->get());
 		ERR_CONTINUE(!obj);
 		p_bound->push_back(Object::cast_to<Node>(obj));
@@ -584,7 +559,6 @@ void Skeleton3D::get_bound_child_nodes_to_bone(int p_bone, List<Node *> *p_bound
 }
 
 void Skeleton3D::clear_bones() {
-
 	bones.clear();
 	process_order_dirty = true;
 	version++;
@@ -594,7 +568,6 @@ void Skeleton3D::clear_bones() {
 // posing api
 
 void Skeleton3D::set_bone_pose(int p_bone, const Transform &p_pose) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 
 	bones.write[p_bone].pose = p_pose;
@@ -602,14 +575,13 @@ void Skeleton3D::set_bone_pose(int p_bone, const Transform &p_pose) {
 		_make_dirty();
 	}
 }
-Transform Skeleton3D::get_bone_pose(int p_bone) const {
 
+Transform Skeleton3D::get_bone_pose(int p_bone) const {
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), Transform());
 	return bones[p_bone].pose;
 }
 
 void Skeleton3D::set_bone_custom_pose(int p_bone, const Transform &p_custom_pose) {
-
 	ERR_FAIL_INDEX(p_bone, bones.size());
 	//ERR_FAIL_COND( !is_inside_scene() );
 
@@ -620,15 +592,14 @@ void Skeleton3D::set_bone_custom_pose(int p_bone, const Transform &p_custom_pose
 }
 
 Transform Skeleton3D::get_bone_custom_pose(int p_bone) const {
-
 	ERR_FAIL_INDEX_V(p_bone, bones.size(), Transform());
 	return bones[p_bone].custom_pose;
 }
 
 void Skeleton3D::_make_dirty() {
-
-	if (dirty)
+	if (dirty) {
 		return;
+	}
 
 	MessageQueue::get_singleton()->push_notification(this, NOTIFICATION_UPDATE_SKELETON);
 	dirty = true;
@@ -640,8 +611,12 @@ int Skeleton3D::get_process_order(int p_idx) {
 	return process_order[p_idx];
 }
 
-void Skeleton3D::localize_rests() {
+Vector<int> Skeleton3D::get_bone_process_orders() {
+	_update_process_order();
+	return process_order;
+}
 
+void Skeleton3D::localize_rests() {
 	_update_process_order();
 
 	for (int i = bones.size() - 1; i >= 0; i--) {
@@ -729,14 +704,14 @@ void Skeleton3D::_rebuild_physical_bones_cache() {
 		PhysicalBone3D *parent_pb = _get_physical_bone_parent(i);
 		if (parent_pb != bones[i].physical_bone) {
 			bones.write[i].cache_parent_physical_bone = parent_pb;
-			if (bones[i].physical_bone)
+			if (bones[i].physical_bone) {
 				bones[i].physical_bone->_on_bone_parent_changed();
+			}
 		}
 	}
 }
 
 void _pb_stop_simulation(Node *p_node) {
-
 	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
 		_pb_stop_simulation(p_node->get_child(i));
 	}
@@ -755,7 +730,6 @@ void Skeleton3D::physical_bones_stop_simulation() {
 }
 
 void _pb_start_simulation(const Skeleton3D *p_skeleton, Node *p_node, const Vector<int> &p_sim_bones) {
-
 	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
 		_pb_start_simulation(p_skeleton, p_node->get_child(i), p_sim_bones);
 	}
@@ -782,8 +756,9 @@ void Skeleton3D::physical_bones_start_simulation_on(const TypedArray<StringName>
 		int c = 0;
 		for (int i = sim_bones.size() - 1; 0 <= i; --i) {
 			int bone_id = find_bone(p_bones[i]);
-			if (bone_id != -1)
+			if (bone_id != -1) {
 				sim_bones.write[c++] = bone_id;
+			}
 		}
 		sim_bones.resize(c);
 	}
@@ -792,7 +767,6 @@ void Skeleton3D::physical_bones_start_simulation_on(const TypedArray<StringName>
 }
 
 void _physical_bones_add_remove_collision_exception(bool p_add, Node *p_node, RID p_exception) {
-
 	for (int i = p_node->get_child_count() - 1; 0 <= i; --i) {
 		_physical_bones_add_remove_collision_exception(p_add, p_node->get_child(i), p_exception);
 	}
@@ -822,7 +796,6 @@ void Skeleton3D::_skin_changed() {
 }
 
 Ref<SkinReference> Skeleton3D::register_skin(const Ref<Skin> &p_skin) {
-
 	for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
 		if (E->get()->skin == p_skin) {
 			return Ref<SkinReference>(E->get());
@@ -882,8 +855,17 @@ Ref<SkinReference> Skeleton3D::register_skin(const Ref<Skin> &p_skin) {
 	return skin_ref;
 }
 
-void Skeleton3D::_bind_methods() {
+// helper functions
+Transform Skeleton3D::bone_transform_to_world_transform(Transform p_bone_transform) {
+	return get_global_transform() * p_bone_transform;
+}
+
+Transform Skeleton3D::world_transform_to_bone_transform(Transform p_world_transform) {
+	return get_global_transform().affine_inverse() * p_world_transform;
+}
 
+void Skeleton3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_bone_process_orders"), &Skeleton3D::get_bone_process_orders);
 	ClassDB::bind_method(D_METHOD("add_bone", "name"), &Skeleton3D::add_bone);
 	ClassDB::bind_method(D_METHOD("find_bone", "name"), &Skeleton3D::find_bone);
 	ClassDB::bind_method(D_METHOD("get_bone_name", "bone_idx"), &Skeleton3D::get_bone_name);
@@ -921,6 +903,9 @@ void Skeleton3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_bone_custom_pose", "bone_idx"), &Skeleton3D::get_bone_custom_pose);
 	ClassDB::bind_method(D_METHOD("set_bone_custom_pose", "bone_idx", "custom_pose"), &Skeleton3D::set_bone_custom_pose);
 
+	ClassDB::bind_method(D_METHOD("bone_transform_to_world_transform", "bone_transform"), &Skeleton3D::bone_transform_to_world_transform);
+	ClassDB::bind_method(D_METHOD("world_transform_to_bone_transform", "world_transform"), &Skeleton3D::world_transform_to_bone_transform);
+
 #ifndef _3D_DISABLED
 
 	ClassDB::bind_method(D_METHOD("set_animate_physical_bones"), &Skeleton3D::set_animate_physical_bones);
@@ -934,11 +919,14 @@ void Skeleton3D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "animate_physical_bones"), "set_animate_physical_bones", "get_animate_physical_bones");
 #endif // _3D_DISABLED
 
+#ifdef TOOLS_ENABLED
+	ADD_SIGNAL(MethodInfo("pose_updated"));
+#endif // TOOLS_ENABLED
+
 	BIND_CONSTANT(NOTIFICATION_UPDATE_SKELETON);
 }
 
 Skeleton3D::Skeleton3D() {
-
 	animate_physical_bones = true;
 	dirty = false;
 	version = 1;
@@ -946,7 +934,6 @@ Skeleton3D::Skeleton3D() {
 }
 
 Skeleton3D::~Skeleton3D() {
-
 	//some skins may remain bound
 	for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
 		E->get()->skeleton_node = nullptr;