New and improved IK system for Skeleton2D

This PR and commit adds a new IK system for 2D with the Skeleton2D node
that adds several new IK solvers, a way to control bones in a Skeleton2D
node similar to that in Skeleton3D. It also adds additional changes
and functionality.

This work was sponsored by GSoC 2020 and TwistedTwigleg.

Full list of changes:
* Adds a SkeletonModifier2D resource
  * This resource is the base where all IK code is written and executed
  * Has a function for clamping angles, since it is so commonly used
  * Modifiers are unique when duplicated so it works with instancing
* Adds a SkeletonModifierStack2D resource
  * This resource manages a series of SkeletonModification2Ds
  * This is what the Skeleton2D directly interfaces with to make IK possible
* Adds SkeletonModifier2D resources for LookAt, CCDIK, FABRIK, Jiggle, and TwoBoneIK
  * Each modification is in its own file
  * There is also a SkeletonModifier2D resource that acts as a stack for using multiple stacks together
* Adds a PhysicalBone2D node
  * Works similar to the PhysicalBone3D node, but uses a RigidBody2D node
* Changes to Skeleton2D listed below:
  * Skeleton2D now holds a single SkeletonModificationStack2D for IK
  * Skeleton2D now has a local_pose_override, which overrides the Bone2D position similar to how the overrides work in Skeleton3D
* Changes to Bone2D listed below:
  * The default_length property has been changed to length. Length is the length of the bone to its child bone node
  * New bone_angle property, which is the angle the bone has to its first child bone node
  * Bone2D caches its transform when not modified by IK for IK interpolation purposes
  * Bone2D draws its own editor gizmo, though this is stated to change in the future
* Changes to CanvasItemEditor listed below:
  * Bone2D gizmo drawing code removed
  * The 2D IK code is removed. Now Bone2D is the only bone system for 2D
* Transform2D now has a looking_at function for rotating to face a position
* Two new node notifications: NOTIFICATION_EDITOR_PRE_SAVE and NOTIFICATION_EDITOR_POST_SAVE
  * These notifications only are called in the editor right before and after saving a scene
  * Needed for not saving the IK position when executing IK in the editor
* Documentation for all the changes listed above.

4 files changed, 965 insertions, 10 deletions

diff --git a/scene/2d/physical_bone_2d.cpp b/scene/2d/physical_bone_2d.cpp
new file mode 100644
index 0000000000..0c1be16174
--- /dev/null
+++ b/scene/2d/physical_bone_2d.cpp
@@ -0,0 +1,303 @@
+/*************************************************************************/
+/*  physical_bone_2d.cpp                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* 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_2d.h"
+
+void PhysicalBone2D::_notification(int p_what) {
+	if (p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS) {
+		// Position the RigidBody in the correct position
+		if (follow_bone_when_simulating) {
+			_position_at_bone2d();
+		}
+
+		// Keep the child joint in the correct position.
+		if (child_joint && auto_configure_joint) {
+			child_joint->set_global_position(get_global_position());
+		}
+	} else if (p_what == NOTIFICATION_READY) {
+		_find_skeleton_parent();
+		_find_joint_child();
+
+		// Configure joint
+		if (child_joint && auto_configure_joint) {
+			_auto_configure_joint();
+		}
+
+		// Simulate physics if set
+		if (simulate_physics) {
+			_start_physics_simulation();
+		} else {
+			_stop_physics_simulation();
+		}
+
+		set_physics_process_internal(true);
+	}
+}
+
+void PhysicalBone2D::_position_at_bone2d() {
+	// Reset to Bone2D position
+	if (parent_skeleton) {
+		Bone2D *bone_to_use = parent_skeleton->get_bone(bone2d_index);
+		ERR_FAIL_COND_MSG(bone_to_use == nullptr, "It's not possible to position the bone with ID: " + itos(bone2d_index));
+		set_global_transform(bone_to_use->get_global_transform());
+	}
+}
+
+void PhysicalBone2D::_find_skeleton_parent() {
+	Node *current_parent = get_parent();
+
+	while (current_parent != nullptr) {
+		Skeleton2D *potential_skeleton = Object::cast_to<Skeleton2D>(current_parent);
+		if (potential_skeleton) {
+			parent_skeleton = potential_skeleton;
+			break;
+		} else {
+			PhysicalBone2D *potential_parent_bone = Object::cast_to<PhysicalBone2D>(current_parent);
+			if (potential_parent_bone) {
+				current_parent = potential_parent_bone->get_parent();
+			} else {
+				current_parent = nullptr;
+			}
+		}
+	}
+}
+
+void PhysicalBone2D::_find_joint_child() {
+	for (int i = 0; i < get_child_count(); i++) {
+		Node *child_node = get_child(i);
+		Joint2D *potential_joint = Object::cast_to<Joint2D>(child_node);
+		if (potential_joint) {
+			child_joint = potential_joint;
+			break;
+		}
+	}
+}
+
+TypedArray<String> PhysicalBone2D::get_configuration_warnings() const {
+	TypedArray<String> warnings = Node::get_configuration_warnings();
+
+	if (!parent_skeleton) {
+		warnings.push_back(TTR("A PhysicalBone2D only works with a Skeleton2D or another PhysicalBone2D as a parent node!"));
+	}
+	if (parent_skeleton && bone2d_index <= -1) {
+		warnings.push_back(TTR("A PhysicalBone2D needs to be assigned to a Bone2D node in order to function! Please set a Bone2D node in the inspector."));
+	}
+	if (!child_joint) {
+		PhysicalBone2D *parent_bone = Object::cast_to<PhysicalBone2D>(get_parent());
+		if (parent_bone) {
+			warnings.push_back(TTR("A PhysicalBone2D node should have a Joint2D-based child node to keep bones connected! Please add a Joint2D-based node as a child to this node!"));
+		}
+	}
+
+	return warnings;
+}
+
+void PhysicalBone2D::_auto_configure_joint() {
+	if (!auto_configure_joint) {
+		return;
+	}
+
+	if (child_joint) {
+		// Node A = parent | Node B = this node
+		Node *parent_node = get_parent();
+		PhysicalBone2D *potential_parent_bone = Object::cast_to<PhysicalBone2D>(parent_node);
+
+		if (potential_parent_bone) {
+			child_joint->set_node_a(child_joint->get_path_to(potential_parent_bone));
+			child_joint->set_node_b(child_joint->get_path_to(this));
+		} else {
+			WARN_PRINT("Cannot setup joint without a parent PhysicalBone2D node.");
+		}
+
+		// Place the child joint at this node's position.
+		child_joint->set_global_position(get_global_position());
+	}
+}
+
+void PhysicalBone2D::_start_physics_simulation() {
+	if (_internal_simulate_physics) {
+		return;
+	}
+
+	// Reset to Bone2D position
+	_position_at_bone2d();
+
+	// Apply the layers and masks
+	PhysicsServer2D::get_singleton()->body_set_collision_layer(get_rid(), get_collision_layer());
+	PhysicsServer2D::get_singleton()->body_set_collision_mask(get_rid(), get_collision_mask());
+
+	// Apply the correct mode
+	RigidBody2D::Mode rigid_mode = get_mode();
+	if (rigid_mode == RigidBody2D::MODE_STATIC) {
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_STATIC);
+	} else if (rigid_mode == RigidBody2D::MODE_DYNAMIC) {
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_DYNAMIC);
+	} else if (rigid_mode == RigidBody2D::MODE_KINEMATIC) {
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_KINEMATIC);
+	} else if (rigid_mode == RigidBody2D::MODE_DYNAMIC_LOCKED) {
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_DYNAMIC_LOCKED);
+	} else {
+		// Default to Rigid
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_DYNAMIC);
+	}
+
+	_internal_simulate_physics = true;
+	set_physics_process_internal(true);
+}
+
+void PhysicalBone2D::_stop_physics_simulation() {
+	if (_internal_simulate_physics) {
+		_internal_simulate_physics = false;
+
+		// Reset to Bone2D position
+		_position_at_bone2d();
+
+		set_physics_process_internal(false);
+		PhysicsServer2D::get_singleton()->body_set_collision_layer(get_rid(), 0);
+		PhysicsServer2D::get_singleton()->body_set_collision_mask(get_rid(), 0);
+		PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_STATIC);
+	}
+}
+
+Joint2D *PhysicalBone2D::get_joint() const {
+	return child_joint;
+}
+
+bool PhysicalBone2D::get_auto_configure_joint() const {
+	return auto_configure_joint;
+}
+
+void PhysicalBone2D::set_auto_configure_joint(bool p_auto_configure) {
+	auto_configure_joint = p_auto_configure;
+	_auto_configure_joint();
+}
+
+void PhysicalBone2D::set_simulate_physics(bool p_simulate) {
+	if (p_simulate == simulate_physics) {
+		return;
+	}
+	simulate_physics = p_simulate;
+
+	if (simulate_physics) {
+		_start_physics_simulation();
+	} else {
+		_stop_physics_simulation();
+	}
+}
+
+bool PhysicalBone2D::get_simulate_physics() const {
+	return simulate_physics;
+}
+
+bool PhysicalBone2D::is_simulating_physics() const {
+	return _internal_simulate_physics;
+}
+
+void PhysicalBone2D::set_bone2d_nodepath(const NodePath &p_nodepath) {
+	bone2d_nodepath = p_nodepath;
+	notify_property_list_changed();
+}
+
+NodePath PhysicalBone2D::get_bone2d_nodepath() const {
+	return bone2d_nodepath;
+}
+
+void PhysicalBone2D::set_bone2d_index(int p_bone_idx) {
+	ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
+
+	if (!is_inside_tree()) {
+		bone2d_index = p_bone_idx;
+		return;
+	}
+
+	if (parent_skeleton) {
+		ERR_FAIL_INDEX_MSG(p_bone_idx, parent_skeleton->get_bone_count(), "Passed-in Bone index is out of range!");
+		bone2d_index = p_bone_idx;
+
+		bone2d_nodepath = get_path_to(parent_skeleton->get_bone(bone2d_index));
+	} else {
+		WARN_PRINT("Cannot verify bone index...");
+		bone2d_index = p_bone_idx;
+	}
+
+	notify_property_list_changed();
+}
+
+int PhysicalBone2D::get_bone2d_index() const {
+	return bone2d_index;
+}
+
+void PhysicalBone2D::set_follow_bone_when_simulating(bool p_follow_bone) {
+	follow_bone_when_simulating = p_follow_bone;
+
+	if (_internal_simulate_physics) {
+		_stop_physics_simulation();
+		_start_physics_simulation();
+	}
+}
+
+bool PhysicalBone2D::get_follow_bone_when_simulating() const {
+	return follow_bone_when_simulating;
+}
+
+void PhysicalBone2D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_joint"), &PhysicalBone2D::get_joint);
+	ClassDB::bind_method(D_METHOD("get_auto_configure_joint"), &PhysicalBone2D::get_auto_configure_joint);
+	ClassDB::bind_method(D_METHOD("set_auto_configure_joint", "auto_configure_joint"), &PhysicalBone2D::set_auto_configure_joint);
+
+	ClassDB::bind_method(D_METHOD("set_simulate_physics", "simulate_physics"), &PhysicalBone2D::set_simulate_physics);
+	ClassDB::bind_method(D_METHOD("get_simulate_physics"), &PhysicalBone2D::get_simulate_physics);
+	ClassDB::bind_method(D_METHOD("is_simulating_physics"), &PhysicalBone2D::is_simulating_physics);
+
+	ClassDB::bind_method(D_METHOD("set_bone2d_nodepath", "nodepath"), &PhysicalBone2D::set_bone2d_nodepath);
+	ClassDB::bind_method(D_METHOD("get_bone2d_nodepath"), &PhysicalBone2D::get_bone2d_nodepath);
+	ClassDB::bind_method(D_METHOD("set_bone2d_index", "bone_index"), &PhysicalBone2D::set_bone2d_index);
+	ClassDB::bind_method(D_METHOD("get_bone2d_index"), &PhysicalBone2D::get_bone2d_index);
+	ClassDB::bind_method(D_METHOD("set_follow_bone_when_simulating", "follow_bone"), &PhysicalBone2D::set_follow_bone_when_simulating);
+	ClassDB::bind_method(D_METHOD("get_follow_bone_when_simulating"), &PhysicalBone2D::get_follow_bone_when_simulating);
+
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "bone2d_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Bone2D"), "set_bone2d_nodepath", "get_bone2d_nodepath");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "bone2d_index", PROPERTY_HINT_RANGE, "-1, 1000, 1"), "set_bone2d_index", "get_bone2d_index");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_configure_joint"), "set_auto_configure_joint", "get_auto_configure_joint");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "simulate_physics"), "set_simulate_physics", "get_simulate_physics");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "follow_bone_when_simulating"), "set_follow_bone_when_simulating", "get_follow_bone_when_simulating");
+}
+
+PhysicalBone2D::PhysicalBone2D() {
+	// Stop the RigidBody from executing its force integration.
+	PhysicsServer2D::get_singleton()->body_set_collision_layer(get_rid(), 0);
+	PhysicsServer2D::get_singleton()->body_set_collision_mask(get_rid(), 0);
+	PhysicsServer2D::get_singleton()->body_set_mode(get_rid(), PhysicsServer2D::BodyMode::BODY_MODE_STATIC);
+
+	child_joint = nullptr;
+}
+
+PhysicalBone2D::~PhysicalBone2D() {
+}
diff --git a/scene/2d/physical_bone_2d.h b/scene/2d/physical_bone_2d.h
new file mode 100644
index 0000000000..d650a0426f
--- /dev/null
+++ b/scene/2d/physical_bone_2d.h
@@ -0,0 +1,88 @@
+/*************************************************************************/
+/*  physical_bone_2d.h                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* 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_2D_H
+#define PHYSICAL_BONE_2D_H
+
+#include "scene/2d/joints_2d.h"
+#include "scene/2d/physics_body_2d.h"
+
+#include "scene/2d/skeleton_2d.h"
+
+class PhysicalBone2D : public RigidBody2D {
+	GDCLASS(PhysicalBone2D, RigidBody2D);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+private:
+	Skeleton2D *parent_skeleton;
+	int bone2d_index = -1;
+	NodePath bone2d_nodepath;
+	bool follow_bone_when_simulating = false;
+
+	Joint2D *child_joint;
+	bool auto_configure_joint = true;
+
+	bool simulate_physics = false;
+	bool _internal_simulate_physics = false;
+
+	void _find_skeleton_parent();
+	void _find_joint_child();
+	void _auto_configure_joint();
+
+	void _start_physics_simulation();
+	void _stop_physics_simulation();
+	void _position_at_bone2d();
+
+public:
+	Joint2D *get_joint() const;
+	bool get_auto_configure_joint() const;
+	void set_auto_configure_joint(bool p_auto_configure);
+
+	void set_simulate_physics(bool p_simulate);
+	bool get_simulate_physics() const;
+	bool is_simulating_physics() const;
+
+	void set_bone2d_nodepath(const NodePath &p_nodepath);
+	NodePath get_bone2d_nodepath() const;
+	void set_bone2d_index(int p_bone_idx);
+	int get_bone2d_index() const;
+	void set_follow_bone_when_simulating(bool p_follow);
+	bool get_follow_bone_when_simulating() const;
+
+	TypedArray<String> get_configuration_warnings() const override;
+
+	PhysicalBone2D();
+	~PhysicalBone2D();
+};
+
+#endif // PHYSICAL_BONE_2D_H
diff --git a/scene/2d/skeleton_2d.cpp b/scene/2d/skeleton_2d.cpp
index 22180797f0..c5ad3dde39 100644
--- a/scene/2d/skeleton_2d.cpp
+++ b/scene/2d/skeleton_2d.cpp
@@ -30,6 +30,69 @@
 
 #include "skeleton_2d.h"
 
+#include "scene/resources/skeleton_modification_2d.h"
+
+#ifdef TOOLS_ENABLED
+#include "editor/editor_settings.h"
+#include "editor/plugins/canvas_item_editor_plugin.h"
+#endif //TOOLS_ENABLED
+
+bool Bone2D::_set(const StringName &p_path, const Variant &p_value) {
+	String path = p_path;
+
+	if (path.begins_with("auto_calculate_length_and_angle")) {
+		set_autocalculate_length_and_angle(p_value);
+	} else if (path.begins_with("length")) {
+		set_length(p_value);
+	} else if (path.begins_with("bone_angle")) {
+		set_bone_angle(Math::deg2rad(float(p_value)));
+	} else if (path.begins_with("default_length")) {
+		set_length(p_value);
+	}
+
+#ifdef TOOLS_ENABLED
+	if (path.begins_with("editor_settings/show_bone_gizmo")) {
+		_editor_set_show_bone_gizmo(p_value);
+	}
+#endif // TOOLS_ENABLED
+
+	return true;
+}
+
+bool Bone2D::_get(const StringName &p_path, Variant &r_ret) const {
+	String path = p_path;
+
+	if (path.begins_with("auto_calculate_length_and_angle")) {
+		r_ret = get_autocalculate_length_and_angle();
+	} else if (path.begins_with("length")) {
+		r_ret = get_length();
+	} else if (path.begins_with("bone_angle")) {
+		r_ret = Math::rad2deg(get_bone_angle());
+	} else if (path.begins_with("default_length")) {
+		r_ret = get_length();
+	}
+
+#ifdef TOOLS_ENABLED
+	if (path.begins_with("editor_settings/show_bone_gizmo")) {
+		r_ret = _editor_get_show_bone_gizmo();
+	}
+#endif // TOOLS_ENABLED
+
+	return true;
+}
+
+void Bone2D::_get_property_list(List<PropertyInfo> *p_list) const {
+	p_list->push_back(PropertyInfo(Variant::BOOL, "auto_calculate_length_and_angle", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
+	if (!autocalculate_length_and_angle) {
+		p_list->push_back(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "1, 1024, 1", PROPERTY_USAGE_DEFAULT));
+		p_list->push_back(PropertyInfo(Variant::FLOAT, "bone_angle", PROPERTY_HINT_RANGE, "-360, 360, 0.01", PROPERTY_USAGE_DEFAULT));
+	}
+
+#ifdef TOOLS_ENABLED
+	p_list->push_back(PropertyInfo(Variant::BOOL, "editor_settings/show_bone_gizmo", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
+#endif // TOOLS_ENABLED
+}
+
 void Bone2D::_notification(int p_what) {
 	if (p_what == NOTIFICATION_ENTER_TREE) {
 		Node *parent = get_parent();
@@ -53,19 +116,54 @@ void Bone2D::_notification(int p_what) {
 			skeleton->bones.push_back(bone);
 			skeleton->_make_bone_setup_dirty();
 		}
+
+		cache_transform = get_transform();
+		copy_transform_to_cache = true;
+
+#ifdef TOOLS_ENABLED
+		// Only draw the gizmo in the editor!
+		if (Engine::get_singleton()->is_editor_hint() == false) {
+			return;
+		}
+
+		update();
+#endif // TOOLS_ENABLED
 	}
-	if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {
+
+	else if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {
 		if (skeleton) {
 			skeleton->_make_transform_dirty();
 		}
+		if (copy_transform_to_cache) {
+			cache_transform = get_transform();
+		}
+#ifdef TOOLS_ENABLED
+		// Only draw the gizmo in the editor!
+		if (Engine::get_singleton()->is_editor_hint() == false) {
+			return;
+		}
+
+		update();
+
+		if (get_parent()) {
+			Bone2D *parent_bone = Object::cast_to<Bone2D>(get_parent());
+			if (parent_bone) {
+				parent_bone->update();
+			}
+		}
+#endif // TOOLS_ENABLED
 	}
-	if (p_what == NOTIFICATION_MOVED_IN_PARENT) {
+
+	else if (p_what == NOTIFICATION_MOVED_IN_PARENT) {
 		if (skeleton) {
 			skeleton->_make_bone_setup_dirty();
 		}
+		if (copy_transform_to_cache) {
+			cache_transform = get_transform();
+		}
 	}
 
-	if (p_what == NOTIFICATION_EXIT_TREE) {
+	else if (p_what == NOTIFICATION_EXIT_TREE) {
 		if (skeleton) {
 			for (int i = 0; i < skeleton->bones.size(); i++) {
 				if (skeleton->bones[i].bone == this) {
@@ -77,9 +175,200 @@ void Bone2D::_notification(int p_what) {
 			skeleton = nullptr;
 		}
 		parent_bone = nullptr;
+		set_transform(cache_transform);
 	}
+
+	else if (p_what == NOTIFICATION_READY) {
+		if (autocalculate_length_and_angle) {
+			calculate_length_and_rotation();
+		}
+	}
+#ifdef TOOLS_ENABLED
+	else if (p_what == NOTIFICATION_EDITOR_PRE_SAVE || p_what == NOTIFICATION_EDITOR_POST_SAVE) {
+		Transform2D tmp_trans = get_transform();
+		set_transform(cache_transform);
+		cache_transform = tmp_trans;
+	}
+	// Bone2D Editor gizmo drawing:
+#ifndef _MSC_VER
+#warning TODO Bone2D gizmo drawing needs to be moved to an editor plugin
+#endif
+	else if (p_what == NOTIFICATION_DRAW) {
+		// Only draw the gizmo in the editor!
+		if (Engine::get_singleton()->is_editor_hint() == false) {
+			return;
+		}
+
+		if (editor_gizmo_rid.is_null()) {
+			editor_gizmo_rid = RenderingServer::get_singleton()->canvas_item_create();
+			RenderingServer::get_singleton()->canvas_item_set_parent(editor_gizmo_rid, get_canvas_item());
+			RenderingServer::get_singleton()->canvas_item_set_z_as_relative_to_parent(editor_gizmo_rid, true);
+			RenderingServer::get_singleton()->canvas_item_set_z_index(editor_gizmo_rid, 10);
+		}
+		RenderingServer::get_singleton()->canvas_item_clear(editor_gizmo_rid);
+
+		if (!_editor_show_bone_gizmo) {
+			return;
+		}
+
+		// Undo scaling
+		Transform2D editor_gizmo_trans = Transform2D();
+		editor_gizmo_trans.set_scale(Vector2(1, 1) / get_global_scale());
+		RenderingServer::get_singleton()->canvas_item_set_transform(editor_gizmo_rid, editor_gizmo_trans);
+
+		Color bone_color1 = EditorSettings::get_singleton()->get("editors/2d/bone_color1");
+		Color bone_color2 = EditorSettings::get_singleton()->get("editors/2d/bone_color2");
+		Color bone_ik_color = EditorSettings::get_singleton()->get("editors/2d/bone_ik_color");
+		Color bone_outline_color = EditorSettings::get_singleton()->get("editors/2d/bone_outline_color");
+		Color bone_selected_color = EditorSettings::get_singleton()->get("editors/2d/bone_selected_color");
+
+		bool Bone2D_found = false;
+		for (int i = 0; i < get_child_count(); i++) {
+			Bone2D *child_node = nullptr;
+			child_node = Object::cast_to<Bone2D>(get_child(i));
+			if (!child_node) {
+				continue;
+			}
+			Bone2D_found = true;
+
+			Vector<Vector2> bone_shape;
+			Vector<Vector2> bone_shape_outline;
+
+			_editor_get_bone_shape(&bone_shape, &bone_shape_outline, child_node);
+
+			Vector<Color> colors;
+			if (has_meta("_local_pose_override_enabled_")) {
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+			} else {
+				colors.push_back(bone_color1);
+				colors.push_back(bone_color2);
+				colors.push_back(bone_color1);
+				colors.push_back(bone_color2);
+			}
+
+			Vector<Color> outline_colors;
+			if (CanvasItemEditor::get_singleton()->editor_selection->is_selected(this)) {
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+			} else {
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+			}
+
+			RenderingServer::get_singleton()->canvas_item_add_polygon(editor_gizmo_rid, bone_shape_outline, outline_colors);
+			RenderingServer::get_singleton()->canvas_item_add_polygon(editor_gizmo_rid, bone_shape, colors);
+		}
+
+		if (!Bone2D_found) {
+			Vector<Vector2> bone_shape;
+			Vector<Vector2> bone_shape_outline;
+
+			_editor_get_bone_shape(&bone_shape, &bone_shape_outline, nullptr);
+
+			Vector<Color> colors;
+			if (has_meta("_local_pose_override_enabled_")) {
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+				colors.push_back(bone_ik_color);
+			} else {
+				colors.push_back(bone_color1);
+				colors.push_back(bone_color2);
+				colors.push_back(bone_color1);
+				colors.push_back(bone_color2);
+			}
+
+			Vector<Color> outline_colors;
+			if (CanvasItemEditor::get_singleton()->editor_selection->is_selected(this)) {
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+				outline_colors.push_back(bone_selected_color);
+			} else {
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+				outline_colors.push_back(bone_outline_color);
+			}
+
+			RenderingServer::get_singleton()->canvas_item_add_polygon(editor_gizmo_rid, bone_shape_outline, outline_colors);
+			RenderingServer::get_singleton()->canvas_item_add_polygon(editor_gizmo_rid, bone_shape, colors);
+		}
+	}
+#endif // TOOLS_ENALBED
 }
 
+#ifdef TOOLS_ENABLED
+bool Bone2D::_editor_get_bone_shape(Vector<Vector2> *p_shape, Vector<Vector2> *p_outline_shape, Bone2D *p_other_bone) {
+	int bone_width = EditorSettings::get_singleton()->get("editors/2d/bone_width");
+	int bone_outline_width = EditorSettings::get_singleton()->get("editors/2d/bone_outline_size");
+
+	if (!is_inside_tree()) {
+		return false; //may have been removed
+	}
+	if (!p_other_bone && length <= 0) {
+		return false;
+	}
+
+	Vector2 rel;
+	if (p_other_bone) {
+		rel = (p_other_bone->get_global_transform().get_origin() - get_global_transform().get_origin());
+		rel = rel.rotated(-get_global_rotation()); // Undo Bone2D node's rotation so its drawn correctly regardless of the node's rotation
+	} else {
+		float angle_to_use = get_rotation() + bone_angle;
+		rel = Vector2(cos(angle_to_use), sin(angle_to_use)) * (length * MIN(get_global_scale().x, get_global_scale().y));
+		rel = rel.rotated(-get_rotation()); // Undo Bone2D node's rotation so its drawn correctly regardless of the node's rotation
+	}
+
+	Vector2 relt = rel.rotated(Math_PI * 0.5).normalized() * bone_width;
+	Vector2 reln = rel.normalized();
+	Vector2 reltn = relt.normalized();
+
+	if (p_shape) {
+		p_shape->clear();
+		p_shape->push_back(Vector2(0, 0));
+		p_shape->push_back(rel * 0.2 + relt);
+		p_shape->push_back(rel);
+		p_shape->push_back(rel * 0.2 - relt);
+	}
+
+	if (p_outline_shape) {
+		p_outline_shape->clear();
+		p_outline_shape->push_back((-reln - reltn) * bone_outline_width);
+		p_outline_shape->push_back((-reln + reltn) * bone_outline_width);
+		p_outline_shape->push_back(rel * 0.2 + relt + reltn * bone_outline_width);
+		p_outline_shape->push_back(rel + (reln + reltn) * bone_outline_width);
+		p_outline_shape->push_back(rel + (reln - reltn) * bone_outline_width);
+		p_outline_shape->push_back(rel * 0.2 - relt - reltn * bone_outline_width);
+	}
+	return true;
+}
+
+void Bone2D::_editor_set_show_bone_gizmo(bool p_show_gizmo) {
+	_editor_show_bone_gizmo = p_show_gizmo;
+	update();
+}
+
+bool Bone2D::_editor_get_show_bone_gizmo() const {
+	return _editor_show_bone_gizmo;
+}
+#endif // TOOLS_ENABLED
+
 void Bone2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_rest", "rest"), &Bone2D::set_rest);
 	ClassDB::bind_method(D_METHOD("get_rest"), &Bone2D::get_rest);
@@ -90,8 +379,14 @@ void Bone2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_default_length", "default_length"), &Bone2D::set_default_length);
 	ClassDB::bind_method(D_METHOD("get_default_length"), &Bone2D::get_default_length);
 
+	ClassDB::bind_method(D_METHOD("set_autocalculate_length_and_angle", "auto_calculate"), &Bone2D::set_autocalculate_length_and_angle);
+	ClassDB::bind_method(D_METHOD("get_autocalculate_length_and_angle"), &Bone2D::get_autocalculate_length_and_angle);
+	ClassDB::bind_method(D_METHOD("set_length", "length"), &Bone2D::set_length);
+	ClassDB::bind_method(D_METHOD("get_length"), &Bone2D::get_length);
+	ClassDB::bind_method(D_METHOD("set_bone_angle", "angle"), &Bone2D::set_bone_angle);
+	ClassDB::bind_method(D_METHOD("get_bone_angle"), &Bone2D::get_bone_angle);
+
 	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM2D, "rest"), "set_rest", "get_rest");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "default_length", PROPERTY_HINT_RANGE, "1,1024,1"), "set_default_length", "get_default_length");
 }
 
 void Bone2D::set_rest(const Transform2D &p_rest) {
@@ -119,12 +414,14 @@ void Bone2D::apply_rest() {
 	set_transform(rest);
 }
 
-void Bone2D::set_default_length(real_t p_length) {
-	default_length = p_length;
+void Bone2D::set_default_length(float p_length) {
+	WARN_DEPRECATED_MSG("set_default_length is deprecated. Please use set_length instead!");
+	set_length(p_length);
 }
 
-real_t Bone2D::get_default_length() const {
-	return default_length;
+float Bone2D::get_default_length() const {
+	WARN_DEPRECATED_MSG("get_default_length is deprecated. Please use get_length instead!");
+	return get_length();
 }
 
 int Bone2D::get_index_in_skeleton() const {
@@ -150,16 +447,121 @@ TypedArray<String> Bone2D::get_configuration_warnings() const {
 	return warnings;
 }
 
+void Bone2D::calculate_length_and_rotation() {
+	// if there is at least a single child Bone2D node, we can calculate
+	// the length and direction. We will always just use the first Bone2D for this.
+	bool calculated = false;
+	int child_count = get_child_count();
+	if (child_count > 0) {
+		for (int i = 0; i < child_count; i++) {
+			Bone2D *child = Object::cast_to<Bone2D>(get_child(i));
+			if (child) {
+				Vector2 child_local_pos = to_local(child->get_global_transform().get_origin());
+				length = child_local_pos.length();
+				bone_angle = Math::atan2(child_local_pos.normalized().y, child_local_pos.normalized().x);
+				calculated = true;
+				break;
+			}
+		}
+	}
+	if (calculated) {
+		return; // Finished!
+	} else {
+		WARN_PRINT("No Bone2D children of node " + get_name() + ". Cannot calculate bone length or angle reliably.\nUsing transform rotation for bone angle");
+		bone_angle = get_transform().get_rotation();
+		return;
+	}
+}
+
+void Bone2D::set_autocalculate_length_and_angle(bool p_autocalculate) {
+	autocalculate_length_and_angle = p_autocalculate;
+	if (autocalculate_length_and_angle) {
+		calculate_length_and_rotation();
+	}
+	notify_property_list_changed();
+}
+
+bool Bone2D::get_autocalculate_length_and_angle() const {
+	return autocalculate_length_and_angle;
+}
+
+void Bone2D::set_length(float p_length) {
+	length = p_length;
+
+#ifdef TOOLS_ENABLED
+	update();
+#endif // TOOLS_ENABLED
+}
+
+float Bone2D::get_length() const {
+	return length;
+}
+
+void Bone2D::set_bone_angle(float p_angle) {
+	bone_angle = p_angle;
+
+#ifdef TOOLS_ENABLED
+	update();
+#endif // TOOLS_ENABLED
+}
+
+float Bone2D::get_bone_angle() const {
+	return bone_angle;
+}
+
 Bone2D::Bone2D() {
+	skeleton = nullptr;
+	parent_bone = nullptr;
+	skeleton_index = -1;
+	length = 16;
+	bone_angle = 0;
+	autocalculate_length_and_angle = true;
 	set_notify_local_transform(true);
 	//this is a clever hack so the bone knows no rest has been set yet, allowing to show an error.
 	for (int i = 0; i < 3; i++) {
 		rest[i] = Vector2(0, 0);
 	}
+	copy_transform_to_cache = true;
+}
+
+Bone2D::~Bone2D() {
+#ifdef TOOLS_ENABLED
+	if (!editor_gizmo_rid.is_null()) {
+		RenderingServer::get_singleton()->free(editor_gizmo_rid);
+	}
+#endif // TOOLS_ENABLED
 }
 
 //////////////////////////////////////
 
+bool Skeleton2D::_set(const StringName &p_path, const Variant &p_value) {
+	String path = p_path;
+
+	if (path.begins_with("modification_stack")) {
+		set_modification_stack(p_value);
+		return true;
+	}
+	return true;
+}
+
+bool Skeleton2D::_get(const StringName &p_path, Variant &r_ret) const {
+	String path = p_path;
+
+	if (path.begins_with("modification_stack")) {
+		r_ret = get_modification_stack();
+		return true;
+	}
+	return true;
+}
+
+void Skeleton2D::_get_property_list(List<PropertyInfo> *p_list) const {
+	p_list->push_back(
+			PropertyInfo(Variant::OBJECT, "modification_stack",
+					PROPERTY_HINT_RESOURCE_TYPE,
+					"SkeletonModificationStack2D",
+					PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
+}
+
 void Skeleton2D::_make_bone_setup_dirty() {
 	if (bone_setup_dirty) {
 		return;
@@ -189,6 +591,8 @@ void Skeleton2D::_update_bone_setup() {
 		} else {
 			bones.write[i].parent_index = -1;
 		}
+
+		bones.write[i].local_pose_override = bones[i].bone->get_skeleton_rest();
 	}
 
 	transform_dirty = true;
@@ -257,19 +661,121 @@ void Skeleton2D::_notification(int p_what) {
 		if (transform_dirty) {
 			_update_transform();
 		}
-
 		request_ready();
 	}
 
 	if (p_what == NOTIFICATION_TRANSFORM_CHANGED) {
 		RS::get_singleton()->skeleton_set_base_transform_2d(skeleton, get_global_transform());
+	} else if (p_what == NOTIFICATION_INTERNAL_PROCESS) {
+		if (modification_stack.is_valid()) {
+			execute_modifications(get_process_delta_time(), SkeletonModificationStack2D::EXECUTION_MODE::execution_mode_process);
+		}
+	} else if (p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS) {
+		if (modification_stack.is_valid()) {
+			execute_modifications(get_physics_process_delta_time(), SkeletonModificationStack2D::EXECUTION_MODE::execution_mode_physics_process);
+		}
 	}
+#ifdef TOOLS_ENABLED
+	else if (p_what == NOTIFICATION_DRAW) {
+		if (Engine::get_singleton()->is_editor_hint()) {
+			if (modification_stack.is_valid()) {
+				modification_stack->draw_editor_gizmos();
+			}
+		}
+	}
+#endif // TOOLS_ENABLED
 }
 
 RID Skeleton2D::get_skeleton() const {
 	return skeleton;
 }
 
+void Skeleton2D::set_bone_local_pose_override(int p_bone_idx, Transform2D p_override, float p_amount, bool p_persistent) {
+	ERR_FAIL_INDEX_MSG(p_bone_idx, bones.size(), "Bone index is out of range!");
+	bones.write[p_bone_idx].local_pose_override = p_override;
+	bones.write[p_bone_idx].local_pose_override_amount = p_amount;
+	bones.write[p_bone_idx].local_pose_override_persistent = p_persistent;
+}
+
+Transform2D Skeleton2D::get_bone_local_pose_override(int p_bone_idx) {
+	ERR_FAIL_INDEX_V_MSG(p_bone_idx, bones.size(), Transform2D(), "Bone index is out of range!");
+	return bones[p_bone_idx].local_pose_override;
+}
+
+void Skeleton2D::set_modification_stack(Ref<SkeletonModificationStack2D> p_stack) {
+	if (modification_stack.is_valid()) {
+		modification_stack->is_setup = false;
+		modification_stack->set_skeleton(nullptr);
+
+		set_process_internal(false);
+		set_physics_process_internal(false);
+	}
+	modification_stack = p_stack;
+	if (modification_stack.is_valid()) {
+		modification_stack->set_skeleton(this);
+		modification_stack->setup();
+
+		set_process_internal(true);
+		set_physics_process_internal(true);
+
+#ifdef TOOLS_ENABLED
+		modification_stack->set_editor_gizmos_dirty(true);
+#endif // TOOLS_ENABLED
+	}
+}
+
+Ref<SkeletonModificationStack2D> Skeleton2D::get_modification_stack() const {
+	return modification_stack;
+}
+
+void Skeleton2D::execute_modifications(float p_delta, int p_execution_mode) {
+	if (!modification_stack.is_valid()) {
+		return;
+	}
+
+	// Do not cache the transform changes caused by the modifications!
+	for (int i = 0; i < bones.size(); i++) {
+		bones[i].bone->copy_transform_to_cache = false;
+	}
+
+	if (modification_stack->skeleton != this) {
+		modification_stack->set_skeleton(this);
+	}
+
+	modification_stack->execute(p_delta, p_execution_mode);
+
+	// Only apply the local pose override on _process. Otherwise, just calculate the local_pose_override and reset the transform.
+	if (p_execution_mode == SkeletonModificationStack2D::EXECUTION_MODE::execution_mode_process) {
+		for (int i = 0; i < bones.size(); i++) {
+			if (bones[i].local_pose_override_amount > 0) {
+				bones[i].bone->set_meta("_local_pose_override_enabled_", true);
+
+				Transform2D final_trans = bones[i].bone->cache_transform;
+				final_trans = final_trans.interpolate_with(bones[i].local_pose_override, bones[i].local_pose_override_amount);
+				bones[i].bone->set_transform(final_trans);
+				bones[i].bone->propagate_call("force_update_transform");
+
+				if (bones[i].local_pose_override_persistent) {
+					bones.write[i].local_pose_override_amount = 0.0;
+				}
+			} else {
+				// TODO: see if there is a way to undo the override without having to resort to setting every bone's transform.
+				bones[i].bone->remove_meta("_local_pose_override_enabled_");
+				bones[i].bone->set_transform(bones[i].bone->cache_transform);
+			}
+		}
+	}
+
+	// Cache any future transform changes
+	for (int i = 0; i < bones.size(); i++) {
+		bones[i].bone->copy_transform_to_cache = true;
+	}
+
+#ifdef TOOLS_ENABLED
+	modification_stack->set_editor_gizmos_dirty(true);
+#endif // TOOLS_ENABLED
+}
+
 void Skeleton2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_update_bone_setup"), &Skeleton2D::_update_bone_setup);
 	ClassDB::bind_method(D_METHOD("_update_transform"), &Skeleton2D::_update_transform);
@@ -279,6 +785,13 @@ void Skeleton2D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("get_skeleton"), &Skeleton2D::get_skeleton);
 
+	ClassDB::bind_method(D_METHOD("set_modification_stack", "modification_stack"), &Skeleton2D::set_modification_stack);
+	ClassDB::bind_method(D_METHOD("get_modification_stack"), &Skeleton2D::get_modification_stack);
+	ClassDB::bind_method(D_METHOD("execute_modifications", "execution_mode", "execution_mode"), &Skeleton2D::execute_modifications);
+
+	ClassDB::bind_method(D_METHOD("set_bone_local_pose_override", "bone_idx", "override_pose", "strength", "persistent"), &Skeleton2D::set_bone_local_pose_override);
+	ClassDB::bind_method(D_METHOD("get_bone_local_pose_override", "bone_idx"), &Skeleton2D::get_bone_local_pose_override);
+
 	ADD_SIGNAL(MethodInfo("bone_setup_changed"));
 }
 
diff --git a/scene/2d/skeleton_2d.h b/scene/2d/skeleton_2d.h
index fd62b87bde..59bd711960 100644
--- a/scene/2d/skeleton_2d.h
+++ b/scene/2d/skeleton_2d.h
@@ -32,6 +32,7 @@
 #define SKELETON_2D_H
 
 #include "scene/2d/node_2d.h"
+#include "scene/resources/skeleton_modification_2d.h"
 
 class Skeleton2D;
 
@@ -46,15 +47,32 @@ class Bone2D : public Node2D {
 	Bone2D *parent_bone = nullptr;
 	Skeleton2D *skeleton = nullptr;
 	Transform2D rest;
-	real_t default_length = 16.0;
+
+	bool autocalculate_length_and_angle = true;
+	float length = 16;
+	float bone_angle = 0;
 
 	int skeleton_index = -1;
 
+	void calculate_length_and_rotation();
+
+#ifdef TOOLS_ENABLED
+	RID editor_gizmo_rid;
+	bool _editor_get_bone_shape(Vector<Vector2> *p_shape, Vector<Vector2> *p_outline_shape, Bone2D *p_other_bone);
+	bool _editor_show_bone_gizmo = true;
+#endif // TOOLS ENABLED
+
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
+	bool _set(const StringName &p_path, const Variant &p_value);
+	bool _get(const StringName &p_path, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 public:
+	Transform2D cache_transform;
+	bool copy_transform_to_cache = true;
+
 	void set_rest(const Transform2D &p_rest);
 	Transform2D get_rest() const;
 	void apply_rest();
@@ -65,11 +83,26 @@ public:
 	void set_default_length(real_t p_length);
 	real_t get_default_length() const;
 
+	void set_autocalculate_length_and_angle(bool p_autocalculate);
+	bool get_autocalculate_length_and_angle() const;
+	void set_length(float p_length);
+	float get_length() const;
+	void set_bone_angle(float p_angle);
+	float get_bone_angle() const;
+
 	int get_index_in_skeleton() const;
 
+#ifdef TOOLS_ENABLED
+	void _editor_set_show_bone_gizmo(bool p_show_gizmo);
+	bool _editor_get_show_bone_gizmo() const;
+#endif // TOOLS_ENABLED
+
 	Bone2D();
+	~Bone2D();
 };
 
+class SkeletonModificationStack2D;
+
 class Skeleton2D : public Node2D {
 	GDCLASS(Skeleton2D, Node2D);
 
@@ -86,6 +119,11 @@ class Skeleton2D : public Node2D {
 		int parent_index = 0;
 		Transform2D accum_transform;
 		Transform2D rest_inverse;
+
+		//Transform2D local_pose_cache;
+		Transform2D local_pose_override;
+		float local_pose_override_amount = 0;
+		bool local_pose_override_persistent = false;
 	};
 
 	Vector<Bone> bones;
@@ -100,15 +138,28 @@ class Skeleton2D : public Node2D {
 
 	RID skeleton;
 
+	Ref<SkeletonModificationStack2D> modification_stack;
+
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
+	bool _set(const StringName &p_path, const Variant &p_value);
+	bool _get(const StringName &p_path, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 public:
 	int get_bone_count() const;
 	Bone2D *get_bone(int p_idx);
 
 	RID get_skeleton() const;
+
+	void set_bone_local_pose_override(int p_bone_idx, Transform2D p_override, float p_amount, bool p_persistent = true);
+	Transform2D get_bone_local_pose_override(int p_bone_idx);
+
+	Ref<SkeletonModificationStack2D> get_modification_stack() const;
+	void set_modification_stack(Ref<SkeletonModificationStack2D> p_stack);
+	void execute_modifications(float p_delta, int p_execution_mode);
+
 	Skeleton2D();
 	~Skeleton2D();
 };