18 files changed, 1209 insertions, 1986 deletions
diff --git a/scene/animation/animation_blend_space_1d.cpp b/scene/animation/animation_blend_space_1d.cpp
index 15f562242f..0167992baf 100644
--- a/scene/animation/animation_blend_space_1d.cpp
+++ b/scene/animation/animation_blend_space_1d.cpp
@@ -47,14 +47,14 @@ void AnimationNodeBlendSpace1D::_validate_property(PropertyInfo &property) const
 		String left = property.name.get_slicec('/', 0);
 		int idx = left.get_slicec('_', 2).to_int();
 		if (idx >= blend_points_used) {
-			property.usage = 0;
+			property.usage = PROPERTY_USAGE_NONE;
 		}
 	}
 	AnimationRootNode::_validate_property(property);
 }
 
 void AnimationNodeBlendSpace1D::_tree_changed() {
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendSpace1D::_bind_methods() {
@@ -120,7 +120,7 @@ void AnimationNodeBlendSpace1D::add_blend_point(const Ref<AnimationRootNode> &p_
 	blend_points[p_at_index].node->connect("tree_changed", callable_mp(this, &AnimationNodeBlendSpace1D::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 
 	blend_points_used++;
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendSpace1D::set_blend_point_position(int p_point, float p_position) {
@@ -140,7 +140,7 @@ void AnimationNodeBlendSpace1D::set_blend_point_node(int p_point, const Ref<Anim
 	blend_points[p_point].node = p_node;
 	blend_points[p_point].node->connect("tree_changed", callable_mp(this, &AnimationNodeBlendSpace1D::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 float AnimationNodeBlendSpace1D::get_blend_point_position(int p_point) const {
@@ -164,7 +164,7 @@ void AnimationNodeBlendSpace1D::remove_blend_point(int p_point) {
 	}
 
 	blend_points_used--;
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 int AnimationNodeBlendSpace1D::get_blend_point_count() const {
@@ -219,7 +219,7 @@ void AnimationNodeBlendSpace1D::_add_blend_point(int p_index, const Ref<Animatio
 	}
 }
 
-float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
+double AnimationNodeBlendSpace1D::process(double p_time, bool p_seek) {
 	if (blend_points_used == 0) {
 		return 0.0;
 	}
@@ -229,7 +229,7 @@ float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
 		return blend_node(blend_points[0].name, blend_points[0].node, p_time, p_seek, 1.0, FILTER_IGNORE, false);
 	}
 
-	float blend_pos = get_parameter(blend_position);
+	double blend_pos = get_parameter(blend_position);
 
 	float weights[MAX_BLEND_POINTS] = {};
 
diff --git a/scene/animation/animation_blend_space_1d.h b/scene/animation/animation_blend_space_1d.h
index 8886e6c679..6730c09fd4 100644
--- a/scene/animation/animation_blend_space_1d.h
+++ b/scene/animation/animation_blend_space_1d.h
@@ -93,7 +93,7 @@ public:
 	void set_value_label(const String &p_label);
 	String get_value_label() const;
 
-	float process(float p_time, bool p_seek) override;
+	double process(double p_time, bool p_seek) override;
 	String get_caption() const override;
 
 	Ref<AnimationNode> get_child_by_name(const StringName &p_name) override;
diff --git a/scene/animation/animation_blend_space_2d.cpp b/scene/animation/animation_blend_space_2d.cpp
index 9c4bc107dd..145e7c605b 100644
--- a/scene/animation/animation_blend_space_2d.cpp
+++ b/scene/animation/animation_blend_space_2d.cpp
@@ -34,8 +34,8 @@
 
 void AnimationNodeBlendSpace2D::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::VECTOR2, blend_position));
-	r_list->push_back(PropertyInfo(Variant::INT, closest, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, length_internal, PROPERTY_HINT_NONE, "", 0));
+	r_list->push_back(PropertyInfo(Variant::INT, closest, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, length_internal, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
 }
 
 Variant AnimationNodeBlendSpace2D::get_parameter_default_value(const StringName &p_parameter) const {
@@ -84,7 +84,7 @@ void AnimationNodeBlendSpace2D::add_blend_point(const Ref<AnimationRootNode> &p_
 
 	_queue_auto_triangles();
 
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendSpace2D::set_blend_point_position(int p_point, const Vector2 &p_position) {
@@ -103,7 +103,7 @@ void AnimationNodeBlendSpace2D::set_blend_point_node(int p_point, const Ref<Anim
 	blend_points[p_point].node = p_node;
 	blend_points[p_point].node->connect("tree_changed", callable_mp(this, &AnimationNodeBlendSpace2D::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 Vector2 AnimationNodeBlendSpace2D::get_blend_point_position(int p_point) const {
@@ -143,7 +143,7 @@ void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) {
 		blend_points[i] = blend_points[i + 1];
 	}
 	blend_points_used--;
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 int AnimationNodeBlendSpace2D::get_blend_point_count() const {
@@ -321,7 +321,7 @@ void AnimationNodeBlendSpace2D::_queue_auto_triangles() {
 	}
 
 	trianges_dirty = true;
-	call_deferred("_update_triangles");
+	call_deferred(SNAME("_update_triangles"));
 }
 
 void AnimationNodeBlendSpace2D::_update_triangles() {
@@ -332,7 +332,7 @@ void AnimationNodeBlendSpace2D::_update_triangles() {
 	trianges_dirty = false;
 	triangles.clear();
 	if (blend_points_used < 3) {
-		emit_signal("triangles_updated");
+		emit_signal(SNAME("triangles_updated"));
 		return;
 	}
 
@@ -347,7 +347,7 @@ void AnimationNodeBlendSpace2D::_update_triangles() {
 	for (int i = 0; i < triangles.size(); i++) {
 		add_triangle(triangles[i].points[0], triangles[i].points[1], triangles[i].points[2]);
 	}
-	emit_signal("triangles_updated");
+	emit_signal(SNAME("triangles_updated"));
 }
 
 Vector2 AnimationNodeBlendSpace2D::get_closest_point(const Vector2 &p_point) {
@@ -387,19 +387,19 @@ Vector2 AnimationNodeBlendSpace2D::get_closest_point(const Vector2 &p_point) {
 }
 
 void AnimationNodeBlendSpace2D::_blend_triangle(const Vector2 &p_pos, const Vector2 *p_points, float *r_weights) {
-	if (p_pos.distance_squared_to(p_points[0]) < CMP_EPSILON2) {
+	if (p_pos.is_equal_approx(p_points[0])) {
 		r_weights[0] = 1;
 		r_weights[1] = 0;
 		r_weights[2] = 0;
 		return;
 	}
-	if (p_pos.distance_squared_to(p_points[1]) < CMP_EPSILON2) {
+	if (p_pos.is_equal_approx(p_points[1])) {
 		r_weights[0] = 0;
 		r_weights[1] = 1;
 		r_weights[2] = 0;
 		return;
 	}
-	if (p_pos.distance_squared_to(p_points[2]) < CMP_EPSILON2) {
+	if (p_pos.is_equal_approx(p_points[2])) {
 		r_weights[0] = 0;
 		r_weights[1] = 0;
 		r_weights[2] = 1;
@@ -431,12 +431,12 @@ void AnimationNodeBlendSpace2D::_blend_triangle(const Vector2 &p_pos, const Vect
 	r_weights[2] = w;
 }
 
-float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
+double AnimationNodeBlendSpace2D::process(double p_time, bool p_seek) {
 	_update_triangles();
 
 	Vector2 blend_pos = get_parameter(blend_position);
 	int closest = get_parameter(this->closest);
-	float length_internal = get_parameter(this->length_internal);
+	double length_internal = get_parameter(this->length_internal);
 	float mind = 0.0; //time of min distance point
 
 	if (blend_mode == BLEND_MODE_INTERPOLATED) {
@@ -532,10 +532,10 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
 			float from = 0.0;
 			if (blend_mode == BLEND_MODE_DISCRETE_CARRY && closest != -1) {
 				//see how much animation remains
-				from = blend_node(blend_points[closest].name, blend_points[closest].node, p_time, true, 0.0, FILTER_IGNORE, false) - length_internal;
+				from = length_internal - blend_node(blend_points[closest].name, blend_points[closest].node, p_time, false, 0.0, FILTER_IGNORE, false);
 			}
 
-			mind = blend_node(blend_points[new_closest].name, blend_points[new_closest].node, from, true, 1.0, FILTER_IGNORE, false) + from;
+			mind = blend_node(blend_points[new_closest].name, blend_points[new_closest].node, from, true, 1.0, FILTER_IGNORE, false);
 			length_internal = from + mind;
 
 			closest = new_closest;
@@ -556,13 +556,13 @@ String AnimationNodeBlendSpace2D::get_caption() const {
 
 void AnimationNodeBlendSpace2D::_validate_property(PropertyInfo &property) const {
 	if (auto_triangles && property.name == "triangles") {
-		property.usage = 0;
+		property.usage = PROPERTY_USAGE_NONE;
 	}
 	if (property.name.begins_with("blend_point_")) {
 		String left = property.name.get_slicec('/', 0);
 		int idx = left.get_slicec('_', 2).to_int();
 		if (idx >= blend_points_used) {
-			property.usage = 0;
+			property.usage = PROPERTY_USAGE_NONE;
 		}
 	}
 	AnimationRootNode::_validate_property(property);
@@ -586,7 +586,7 @@ Ref<AnimationNode> AnimationNodeBlendSpace2D::get_child_by_name(const StringName
 }
 
 void AnimationNodeBlendSpace2D::_tree_changed() {
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendSpace2D::set_blend_mode(BlendMode p_blend_mode) {
diff --git a/scene/animation/animation_blend_space_2d.h b/scene/animation/animation_blend_space_2d.h
index 65d09a550d..a919fff1d2 100644
--- a/scene/animation/animation_blend_space_2d.h
+++ b/scene/animation/animation_blend_space_2d.h
@@ -126,7 +126,7 @@ public:
 	void set_y_label(const String &p_label);
 	String get_y_label() const;
 
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 	virtual String get_caption() const override;
 
 	Vector2 get_closest_point(const Vector2 &p_point);
diff --git a/scene/animation/animation_blend_tree.cpp b/scene/animation/animation_blend_tree.cpp
index 79a1dc1ac0..d11387902a 100644
--- a/scene/animation/animation_blend_tree.cpp
+++ b/scene/animation/animation_blend_tree.cpp
@@ -43,7 +43,7 @@ StringName AnimationNodeAnimation::get_animation() const {
 Vector<String> (*AnimationNodeAnimation::get_editable_animation_list)() = nullptr;
 
 void AnimationNodeAnimation::get_parameter_list(List<PropertyInfo> *r_list) const {
-	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", 0));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
 }
 
 void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
@@ -63,11 +63,11 @@ void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
 	}
 }
 
-float AnimationNodeAnimation::process(float p_time, bool p_seek) {
+double AnimationNodeAnimation::process(double p_time, bool p_seek) {
 	AnimationPlayer *ap = state->player;
 	ERR_FAIL_COND_V(!ap, 0);
 
-	float time = get_parameter(this->time);
+	double time = get_parameter(this->time);
 
 	if (!ap->has_animation(animation)) {
 		AnimationNodeBlendTree *tree = Object::cast_to<AnimationNodeBlendTree>(parent);
@@ -84,7 +84,7 @@ float AnimationNodeAnimation::process(float p_time, bool p_seek) {
 
 	Ref<Animation> anim = ap->get_animation(animation);
 
-	float step;
+	double step;
 
 	if (p_seek) {
 		time = p_time;
@@ -94,7 +94,7 @@ float AnimationNodeAnimation::process(float p_time, bool p_seek) {
 		step = p_time;
 	}
 
-	float anim_size = anim->get_length();
+	double anim_size = anim->get_length();
 
 	if (anim->has_loop()) {
 		if (anim_size) {
@@ -130,10 +130,10 @@ AnimationNodeAnimation::AnimationNodeAnimation() {
 
 void AnimationNodeOneShot::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::BOOL, active));
-	r_list->push_back(PropertyInfo(Variant::BOOL, prev_active, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, remaining, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, time_to_restart, PROPERTY_HINT_NONE, "", 0));
+	r_list->push_back(PropertyInfo(Variant::BOOL, prev_active, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, remaining, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, time_to_restart, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
 }
 
 Variant AnimationNodeOneShot::get_parameter_default_value(const StringName &p_parameter) const {
@@ -202,12 +202,12 @@ bool AnimationNodeOneShot::has_filter() const {
 	return true;
 }
 
-float AnimationNodeOneShot::process(float p_time, bool p_seek) {
+double AnimationNodeOneShot::process(double p_time, bool p_seek) {
 	bool active = get_parameter(this->active);
 	bool prev_active = get_parameter(this->prev_active);
-	float time = get_parameter(this->time);
-	float remaining = get_parameter(this->remaining);
-	float time_to_restart = get_parameter(this->time_to_restart);
+	double time = get_parameter(this->time);
+	double remaining = get_parameter(this->remaining);
+	double time_to_restart = get_parameter(this->time_to_restart);
 
 	if (!active) {
 		//make it as if this node doesn't exist, pass input 0 by.
@@ -370,9 +370,9 @@ bool AnimationNodeAdd2::has_filter() const {
 	return true;
 }
 
-float AnimationNodeAdd2::process(float p_time, bool p_seek) {
-	float amount = get_parameter(add_amount);
-	float rem0 = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
+double AnimationNodeAdd2::process(double p_time, bool p_seek) {
+	double amount = get_parameter(add_amount);
+	double rem0 = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
 	blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
 
 	return rem0;
@@ -416,10 +416,10 @@ bool AnimationNodeAdd3::has_filter() const {
 	return true;
 }
 
-float AnimationNodeAdd3::process(float p_time, bool p_seek) {
-	float amount = get_parameter(add_amount);
+double AnimationNodeAdd3::process(double p_time, bool p_seek) {
+	double amount = get_parameter(add_amount);
 	blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_PASS, !sync);
-	float rem0 = blend_input(1, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
+	double rem0 = blend_input(1, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
 	blend_input(2, p_time, p_seek, MAX(0, amount), FILTER_PASS, !sync);
 
 	return rem0;
@@ -452,11 +452,11 @@ String AnimationNodeBlend2::get_caption() const {
 	return "Blend2";
 }
 
-float AnimationNodeBlend2::process(float p_time, bool p_seek) {
-	float amount = get_parameter(blend_amount);
+double AnimationNodeBlend2::process(double p_time, bool p_seek) {
+	double amount = get_parameter(blend_amount);
 
-	float rem0 = blend_input(0, p_time, p_seek, 1.0 - amount, FILTER_BLEND, !sync);
-	float rem1 = blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
+	double rem0 = blend_input(0, p_time, p_seek, 1.0 - amount, FILTER_BLEND, !sync);
+	double rem1 = blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
 
 	return amount > 0.5 ? rem1 : rem0; //hacky but good enough
 }
@@ -507,11 +507,11 @@ bool AnimationNodeBlend3::is_using_sync() const {
 	return sync;
 }
 
-float AnimationNodeBlend3::process(float p_time, bool p_seek) {
-	float amount = get_parameter(blend_amount);
-	float rem0 = blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_IGNORE, !sync);
-	float rem1 = blend_input(1, p_time, p_seek, 1.0 - ABS(amount), FILTER_IGNORE, !sync);
-	float rem2 = blend_input(2, p_time, p_seek, MAX(0, amount), FILTER_IGNORE, !sync);
+double AnimationNodeBlend3::process(double p_time, bool p_seek) {
+	double amount = get_parameter(blend_amount);
+	double rem0 = blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_IGNORE, !sync);
+	double rem1 = blend_input(1, p_time, p_seek, 1.0 - ABS(amount), FILTER_IGNORE, !sync);
+	double rem2 = blend_input(2, p_time, p_seek, MAX(0, amount), FILTER_IGNORE, !sync);
 
 	return amount > 0.5 ? rem2 : (amount < -0.5 ? rem0 : rem1); //hacky but good enough
 }
@@ -545,8 +545,8 @@ String AnimationNodeTimeScale::get_caption() const {
 	return "TimeScale";
 }
 
-float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
-	float scale = get_parameter(this->scale);
+double AnimationNodeTimeScale::process(double p_time, bool p_seek) {
+	double scale = get_parameter(this->scale);
 	if (p_seek) {
 		return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
 	} else {
@@ -575,12 +575,12 @@ String AnimationNodeTimeSeek::get_caption() const {
 	return "Seek";
 }
 
-float AnimationNodeTimeSeek::process(float p_time, bool p_seek) {
-	float seek_pos = get_parameter(this->seek_pos);
+double AnimationNodeTimeSeek::process(double p_time, bool p_seek) {
+	double seek_pos = get_parameter(this->seek_pos);
 	if (p_seek) {
 		return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
 	} else if (seek_pos >= 0) {
-		float ret = blend_input(0, seek_pos, true, 1.0, FILTER_IGNORE, false);
+		double ret = blend_input(0, seek_pos, true, 1.0, FILTER_IGNORE, false);
 		set_parameter(this->seek_pos, -1.0); //reset
 		return ret;
 	} else {
@@ -607,10 +607,10 @@ void AnimationNodeTransition::get_parameter_list(List<PropertyInfo> *r_list) con
 	}
 
 	r_list->push_back(PropertyInfo(Variant::INT, current, PROPERTY_HINT_ENUM, anims));
-	r_list->push_back(PropertyInfo(Variant::INT, prev_current, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::INT, prev, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", 0));
-	r_list->push_back(PropertyInfo(Variant::FLOAT, prev_xfading, PROPERTY_HINT_NONE, "", 0));
+	r_list->push_back(PropertyInfo(Variant::INT, prev_current, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::INT, prev, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
+	r_list->push_back(PropertyInfo(Variant::FLOAT, prev_xfading, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE));
 }
 
 Variant AnimationNodeTransition::get_parameter_default_value(const StringName &p_parameter) const {
@@ -676,13 +676,13 @@ float AnimationNodeTransition::get_cross_fade_time() const {
 	return xfade;
 }
 
-float AnimationNodeTransition::process(float p_time, bool p_seek) {
+double AnimationNodeTransition::process(double p_time, bool p_seek) {
 	int current = get_parameter(this->current);
 	int prev = get_parameter(this->prev);
 	int prev_current = get_parameter(this->prev_current);
 
-	float time = get_parameter(this->time);
-	float prev_xfading = get_parameter(this->prev_xfading);
+	double time = get_parameter(this->time);
+	double prev_xfading = get_parameter(this->prev_xfading);
 
 	bool switched = current != prev_current;
 
@@ -752,7 +752,7 @@ void AnimationNodeTransition::_validate_property(PropertyInfo &property) const {
 		if (n != "count") {
 			int idx = n.to_int();
 			if (idx >= enabled_inputs) {
-				property.usage = 0;
+				property.usage = PROPERTY_USAGE_NONE;
 			}
 		}
 	}
@@ -794,7 +794,7 @@ String AnimationNodeOutput::get_caption() const {
 	return "Output";
 }
 
-float AnimationNodeOutput::process(float p_time, bool p_seek) {
+double AnimationNodeOutput::process(double p_time, bool p_seek) {
 	return blend_input(0, p_time, p_seek, 1.0);
 }
 
@@ -816,7 +816,7 @@ void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNod
 	nodes[p_name] = n;
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 
 	p_node->connect("tree_changed", callable_mp(this, &AnimationNodeBlendTree::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 	p_node->connect("changed", callable_mp(this, &AnimationNodeBlendTree::_node_changed), varray(p_name), CONNECT_REFERENCE_COUNTED);
@@ -896,7 +896,7 @@ void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
 	}
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringName &p_new_name) {
@@ -921,7 +921,7 @@ void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringN
 	//connection must be done with new name
 	nodes[p_new_name].node->connect("changed", callable_mp(this, &AnimationNodeBlendTree::_node_changed), varray(p_new_name), CONNECT_REFERENCE_COUNTED);
 
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) {
@@ -1007,7 +1007,7 @@ String AnimationNodeBlendTree::get_caption() const {
 	return "BlendTree";
 }
 
-float AnimationNodeBlendTree::process(float p_time, bool p_seek) {
+double AnimationNodeBlendTree::process(double p_time, bool p_seek) {
 	Ref<AnimationNodeOutput> output = nodes[SceneStringNames::get_singleton()->output].node;
 	return _blend_node("output", nodes[SceneStringNames::get_singleton()->output].connections, this, output, p_time, p_seek, 1.0);
 }
@@ -1089,10 +1089,10 @@ bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) cons
 		conns.resize(nc.size() * 3);
 
 		int idx = 0;
-		for (List<NodeConnection>::Element *E = nc.front(); E; E = E->next()) {
-			conns[idx * 3 + 0] = E->get().input_node;
-			conns[idx * 3 + 1] = E->get().input_index;
-			conns[idx * 3 + 2] = E->get().output_node;
+		for (const NodeConnection &E : nc) {
+			conns[idx * 3 + 0] = E.input_node;
+			conns[idx * 3 + 1] = E.input_index;
+			conns[idx * 3 + 2] = E.output_node;
 			idx++;
 		}
 
@@ -1110,8 +1110,8 @@ void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) cons
 	}
 	names.sort_custom<StringName::AlphCompare>();
 
-	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
-		String name = E->get();
+	for (const StringName &E : names) {
+		String name = E;
 		if (name != "output") {
 			p_list->push_back(PropertyInfo(Variant::OBJECT, "nodes/" + name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode", PROPERTY_USAGE_NOEDITOR));
 		}
@@ -1124,12 +1124,13 @@ void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) cons
 void AnimationNodeBlendTree::reset_state() {
 	graph_offset = Vector2();
 	nodes.clear();
+	_initialize_node_tree();
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendTree::_tree_changed() {
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeBlendTree::_node_changed(const StringName &p_node) {
@@ -1162,9 +1163,9 @@ void AnimationNodeBlendTree::_bind_methods() {
 	BIND_CONSTANT(CONNECTION_ERROR_CONNECTION_EXISTS);
 }
 
-AnimationNodeBlendTree::AnimationNodeBlendTree() {
+void AnimationNodeBlendTree::_initialize_node_tree() {
 	Ref<AnimationNodeOutput> output;
-	output.instance();
+	output.instantiate();
 	Node n;
 	n.node = output;
 	n.position = Vector2(300, 150);
@@ -1172,5 +1173,9 @@ AnimationNodeBlendTree::AnimationNodeBlendTree() {
 	nodes["output"] = n;
 }
 
+AnimationNodeBlendTree::AnimationNodeBlendTree() {
+	_initialize_node_tree();
+}
+
 AnimationNodeBlendTree::~AnimationNodeBlendTree() {
 }
diff --git a/scene/animation/animation_blend_tree.h b/scene/animation/animation_blend_tree.h
index d82658c8c2..258443a999 100644
--- a/scene/animation/animation_blend_tree.h
+++ b/scene/animation/animation_blend_tree.h
@@ -53,7 +53,7 @@ public:
 	static Vector<String> (*get_editable_animation_list)();
 
 	virtual String get_caption() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	void set_animation(const StringName &p_name);
 	StringName get_animation() const;
@@ -122,7 +122,7 @@ public:
 	bool is_using_sync() const;
 
 	virtual bool has_filter() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	AnimationNodeOneShot();
 };
@@ -148,7 +148,7 @@ public:
 	bool is_using_sync() const;
 
 	virtual bool has_filter() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	AnimationNodeAdd2();
 };
@@ -172,7 +172,7 @@ public:
 	bool is_using_sync() const;
 
 	virtual bool has_filter() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	AnimationNodeAdd3();
 };
@@ -191,7 +191,7 @@ public:
 	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
 
 	virtual String get_caption() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	void set_use_sync(bool p_sync);
 	bool is_using_sync() const;
@@ -218,7 +218,7 @@ public:
 	void set_use_sync(bool p_sync);
 	bool is_using_sync() const;
 
-	float process(float p_time, bool p_seek) override;
+	double process(double p_time, bool p_seek) override;
 	AnimationNodeBlend3();
 };
 
@@ -236,7 +236,7 @@ public:
 
 	virtual String get_caption() const override;
 
-	float process(float p_time, bool p_seek) override;
+	double process(double p_time, bool p_seek) override;
 
 	AnimationNodeTimeScale();
 };
@@ -255,7 +255,7 @@ public:
 
 	virtual String get_caption() const override;
 
-	float process(float p_time, bool p_seek) override;
+	double process(double p_time, bool p_seek) override;
 
 	AnimationNodeTimeSeek();
 };
@@ -313,7 +313,7 @@ public:
 	void set_cross_fade_time(float p_fade);
 	float get_cross_fade_time() const;
 
-	float process(float p_time, bool p_seek) override;
+	double process(double p_time, bool p_seek) override;
 
 	AnimationNodeTransition();
 };
@@ -323,7 +323,7 @@ class AnimationNodeOutput : public AnimationNode {
 
 public:
 	virtual String get_caption() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 	AnimationNodeOutput();
 };
 
@@ -345,6 +345,8 @@ class AnimationNodeBlendTree : public AnimationRootNode {
 	void _tree_changed();
 	void _node_changed(const StringName &p_node);
 
+	void _initialize_node_tree();
+
 protected:
 	static void _bind_methods();
 	bool _set(const StringName &p_name, const Variant &p_value);
@@ -390,7 +392,7 @@ public:
 	void get_node_connections(List<NodeConnection> *r_connections) const;
 
 	virtual String get_caption() const override;
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 
 	void get_node_list(List<StringName> *r_list);
 
diff --git a/scene/animation/animation_cache.cpp b/scene/animation/animation_cache.cpp
index 689acdd57b..56743007e4 100644
--- a/scene/animation/animation_cache.cpp
+++ b/scene/animation/animation_cache.cpp
@@ -80,10 +80,11 @@ void AnimationCache::_update_cache() {
 
 		Ref<Resource> res;
 
-		if (animation->track_get_type(i) == Animation::TYPE_TRANSFORM) {
+		if (animation->track_get_type(i) == Animation::TYPE_TRANSFORM3D) {
+#ifndef _3D_DISABLED
 			if (np.get_subname_count() > 1) {
 				path_cache.push_back(Path());
-				ERR_CONTINUE_MSG(animation->track_get_type(i) == Animation::TYPE_TRANSFORM, "Transform tracks can't have a subpath '" + np + "'.");
+				ERR_CONTINUE_MSG(animation->track_get_type(i) == Animation::TYPE_TRANSFORM3D, "Transform tracks can't have a subpath '" + np + "'.");
 			}
 
 			Node3D *sp = Object::cast_to<Node3D>(node);
@@ -113,8 +114,8 @@ void AnimationCache::_update_cache() {
 				path.skeleton = sk;
 			}
 
-			path.spatial = sp;
-
+			path.node_3d = sp;
+#endif // _3D_DISABLED
 		} else {
 			if (np.get_subname_count() > 0) {
 				RES res2;
@@ -167,7 +168,7 @@ void AnimationCache::_update_cache() {
 	cache_valid = true;
 }
 
-void AnimationCache::set_track_transform(int p_idx, const Transform &p_transform) {
+void AnimationCache::set_track_transform(int p_idx, const Transform3D &p_transform) {
 	if (cache_dirty) {
 		_update_cache();
 	}
@@ -179,14 +180,16 @@ void AnimationCache::set_track_transform(int p_idx, const Transform &p_transform
 		return;
 	}
 
+#ifndef _3D_DISABLED
 	ERR_FAIL_COND(!p.node);
-	ERR_FAIL_COND(!p.spatial);
+	ERR_FAIL_COND(!p.node_3d);
 
 	if (p.skeleton) {
 		p.skeleton->set_bone_pose(p.bone_idx, p_transform);
 	} else {
-		p.spatial->set_transform(p_transform);
+		p.node_3d->set_transform(p_transform);
 	}
+#endif // _3D_DISABLED
 }
 
 void AnimationCache::set_track_value(int p_idx, const Variant &p_value) {
@@ -231,11 +234,11 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 	int tc = animation->get_track_count();
 	for (int i = 0; i < tc; i++) {
 		switch (animation->track_get_type(i)) {
-			case Animation::TYPE_TRANSFORM: {
+			case Animation::TYPE_TRANSFORM3D: {
 				Vector3 loc, scale;
-				Quat rot;
+				Quaternion rot;
 				animation->transform_track_interpolate(i, p_time, &loc, &rot, &scale);
-				Transform tr(Basis(rot), loc);
+				Transform3D tr(Basis(rot), loc);
 				tr.basis.scale(scale);
 
 				set_track_transform(i, tr);
@@ -249,8 +252,8 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 					List<int> indices;
 					animation->value_track_get_key_indices(i, p_time, p_delta, &indices);
 
-					for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-						Variant v = animation->track_get_key_value(i, E->get());
+					for (int &E : indices) {
+						Variant v = animation->track_get_key_value(i, E);
 						set_track_value(i, v);
 					}
 				}
@@ -260,9 +263,9 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 				List<int> indices;
 				animation->method_track_get_key_indices(i, p_time, p_delta, &indices);
 
-				for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-					Vector<Variant> args = animation->method_track_get_params(i, E->get());
-					StringName name = animation->method_track_get_name(i, E->get());
+				for (int &E : indices) {
+					Vector<Variant> args = animation->method_track_get_params(i, E);
+					StringName name = animation->method_track_get_name(i, E);
 					Callable::CallError err;
 
 					if (!args.size()) {
diff --git a/scene/animation/animation_cache.h b/scene/animation/animation_cache.h
index 07c9d09ae0..c856e644f7 100644
--- a/scene/animation/animation_cache.h
+++ b/scene/animation/animation_cache.h
@@ -40,9 +40,11 @@ class AnimationCache : public Object {
 	struct Path {
 		RES resource;
 		Object *object = nullptr;
-		Skeleton3D *skeleton = nullptr; // haxor
+#ifndef _3D_DISABLED
+		Skeleton3D *skeleton = nullptr;
+		Node3D *node_3d = nullptr;
+#endif // _3D_DISABLED
 		Node *node = nullptr;
-		Node3D *spatial = nullptr;
 
 		int bone_idx = -1;
 		Vector<StringName> subpath;
@@ -67,7 +69,7 @@ protected:
 	static void _bind_methods();
 
 public:
-	void set_track_transform(int p_idx, const Transform &p_transform);
+	void set_track_transform(int p_idx, const Transform3D &p_transform);
 	void set_track_value(int p_idx, const Variant &p_value);
 	void call_track(int p_idx, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
 
diff --git a/scene/animation/animation_node_state_machine.cpp b/scene/animation/animation_node_state_machine.cpp
index 65918a2989..9fc1dbd0c6 100644
--- a/scene/animation/animation_node_state_machine.cpp
+++ b/scene/animation/animation_node_state_machine.cpp
@@ -57,7 +57,7 @@ void AnimationNodeStateMachineTransition::set_advance_condition(const StringName
 	} else {
 		advance_condition_name = StringName();
 	}
-	emit_signal("advance_condition_changed");
+	emit_signal(SNAME("advance_condition_changed"));
 }
 
 StringName AnimationNodeStateMachineTransition::get_advance_condition() const {
@@ -286,7 +286,7 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 	return true;
 }
 
-float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, float p_time, bool p_seek) {
+double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, double p_time, bool p_seek) {
 	//if not playing and it can restart, then restart
 	if (!playing && start_request == StringName()) {
 		if (!stop_request && p_state_machine->start_node) {
@@ -496,7 +496,7 @@ void AnimationNodeStateMachinePlayback::_bind_methods() {
 }
 
 AnimationNodeStateMachinePlayback::AnimationNodeStateMachinePlayback() {
-	set_local_to_scene(true); //only one per instanced scene
+	set_local_to_scene(true); //only one per instantiated scene
 }
 
 ///////////////////////////////////////////////////////
@@ -512,15 +512,15 @@ void AnimationNodeStateMachine::get_parameter_list(List<PropertyInfo> *r_list) c
 	}
 
 	advance_conditions.sort_custom<StringName::AlphCompare>();
-	for (List<StringName>::Element *E = advance_conditions.front(); E; E = E->next()) {
-		r_list->push_back(PropertyInfo(Variant::BOOL, E->get()));
+	for (const StringName &E : advance_conditions) {
+		r_list->push_back(PropertyInfo(Variant::BOOL, E));
 	}
 }
 
 Variant AnimationNodeStateMachine::get_parameter_default_value(const StringName &p_parameter) const {
 	if (p_parameter == playback) {
 		Ref<AnimationNodeStateMachinePlayback> p;
-		p.instance();
+		p.instantiate();
 		return p;
 	} else {
 		return false; //advance condition
@@ -539,7 +539,7 @@ void AnimationNodeStateMachine::add_node(const StringName &p_name, Ref<Animation
 	states[p_name] = state;
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 
 	p_node->connect("tree_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 }
@@ -559,7 +559,7 @@ void AnimationNodeStateMachine::replace_node(const StringName &p_name, Ref<Anima
 	states[p_name].node = p_node;
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 
 	p_node->connect("tree_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 }
@@ -636,7 +636,7 @@ void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 	}*/
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeStateMachine::rename_node(const StringName &p_name, const StringName &p_new_name) {
@@ -669,7 +669,7 @@ void AnimationNodeStateMachine::rename_node(const StringName &p_name, const Stri
 	}*/
 
 	//path.clear(); //clear path
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
@@ -679,8 +679,8 @@ void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
 	}
 	nodes.sort_custom<StringName::AlphCompare>();
 
-	for (List<StringName>::Element *E = nodes.front(); E; E = E->next()) {
-		r_nodes->push_back(E->get());
+	for (const StringName &E : nodes) {
+		r_nodes->push_back(E);
 	}
 }
 
@@ -790,7 +790,7 @@ Vector2 AnimationNodeStateMachine::get_graph_offset() const {
 	return graph_offset;
 }
 
-float AnimationNodeStateMachine::process(float p_time, bool p_seek) {
+double AnimationNodeStateMachine::process(double p_time, bool p_seek) {
 	Ref<AnimationNodeStateMachinePlayback> playback = get_parameter(this->playback);
 	ERR_FAIL_COND_V(playback.is_null(), 0.0);
 
@@ -902,8 +902,7 @@ void AnimationNodeStateMachine::_get_property_list(List<PropertyInfo> *p_list) c
 	}
 	names.sort_custom<StringName::AlphCompare>();
 
-	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
-		String name = E->get();
+	for (const StringName &name : names) {
 		p_list->push_back(PropertyInfo(Variant::OBJECT, "states/" + name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode", PROPERTY_USAGE_NOEDITOR));
 		p_list->push_back(PropertyInfo(Variant::VECTOR2, "states/" + name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
 	}
@@ -923,7 +922,7 @@ void AnimationNodeStateMachine::reset_state() {
 	graph_offset = Vector2();
 
 	emit_changed();
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeStateMachine::set_node_position(const StringName &p_name, const Vector2 &p_position) {
@@ -937,7 +936,7 @@ Vector2 AnimationNodeStateMachine::get_node_position(const StringName &p_name) c
 }
 
 void AnimationNodeStateMachine::_tree_changed() {
-	emit_signal("tree_changed");
+	emit_signal(SNAME("tree_changed"));
 }
 
 void AnimationNodeStateMachine::_bind_methods() {
diff --git a/scene/animation/animation_node_state_machine.h b/scene/animation/animation_node_state_machine.h
index 9c1bca63c3..6f0e3107fd 100644
--- a/scene/animation/animation_node_state_machine.h
+++ b/scene/animation/animation_node_state_machine.h
@@ -114,7 +114,7 @@ class AnimationNodeStateMachinePlayback : public Resource {
 
 	bool _travel(AnimationNodeStateMachine *p_state_machine, const StringName &p_travel);
 
-	float process(AnimationNodeStateMachine *p_state_machine, float p_time, bool p_seek);
+	double process(AnimationNodeStateMachine *p_state_machine, double p_time, bool p_seek);
 
 protected:
 	static void _bind_methods();
@@ -210,7 +210,7 @@ public:
 	void set_graph_offset(const Vector2 &p_offset);
 	Vector2 get_graph_offset() const;
 
-	virtual float process(float p_time, bool p_seek) override;
+	virtual double process(double p_time, bool p_seek) override;
 	virtual String get_caption() const override;
 
 	virtual Ref<AnimationNode> get_child_by_name(const StringName &p_name) override;
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 0c1798a876..5825a35030 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -176,8 +176,8 @@ void AnimationPlayer::_get_property_list(List<PropertyInfo> *p_list) const {
 
 	anim_names.sort();
 
-	for (List<PropertyInfo>::Element *E = anim_names.front(); E; E = E->next()) {
-		p_list->push_back(E->get());
+	for (const PropertyInfo &E : anim_names) {
+		p_list->push_back(E);
 	}
 
 	p_list->push_back(PropertyInfo(Variant::ARRAY, "blend_times", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
@@ -252,6 +252,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 		ObjectID id = resource.is_valid() ? resource->get_instance_id() : child->get_instance_id();
 		int bone_idx = -1;
 
+#ifndef _3D_DISABLED
 		if (a->track_get_path(i).get_subname_count() == 1 && Object::cast_to<Skeleton3D>(child)) {
 			Skeleton3D *sk = Object::cast_to<Skeleton3D>(child);
 			bone_idx = sk->find_bone(a->track_get_path(i).get_subname(0));
@@ -259,6 +260,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 				continue;
 			}
 		}
+#endif // _3D_DISABLED
 
 		{
 			if (!child->is_connected("tree_exiting", callable_mp(this, &AnimationPlayer::_node_removed))) {
@@ -279,11 +281,12 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 		p_anim->node_cache[i]->node = child;
 		p_anim->node_cache[i]->resource = resource;
 		p_anim->node_cache[i]->node_2d = Object::cast_to<Node2D>(child);
-		if (a->track_get_type(i) == Animation::TYPE_TRANSFORM) {
+#ifndef _3D_DISABLED
+		if (a->track_get_type(i) == Animation::TYPE_TRANSFORM3D) {
 			// special cases and caches for transform tracks
 
-			// cache spatial
-			p_anim->node_cache[i]->spatial = Object::cast_to<Node3D>(child);
+			// cache node_3d
+			p_anim->node_cache[i]->node_3d = Object::cast_to<Node3D>(child);
 			// cache skeleton
 			p_anim->node_cache[i]->skeleton = Object::cast_to<Skeleton3D>(child);
 			if (p_anim->node_cache[i]->skeleton) {
@@ -294,7 +297,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 					if (p_anim->node_cache[i]->bone_idx < 0) {
 						// broken track (nonexistent bone)
 						p_anim->node_cache[i]->skeleton = nullptr;
-						p_anim->node_cache[i]->spatial = nullptr;
+						p_anim->node_cache[i]->node_3d = nullptr;
 						ERR_CONTINUE(p_anim->node_cache[i]->bone_idx < 0);
 					}
 				} else {
@@ -303,6 +306,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 				}
 			}
 		}
+#endif // _3D_DISABLED
 
 		if (a->track_get_type(i) == Animation::TYPE_VALUE) {
 			if (!p_anim->node_cache[i]->property_anim.has(a->track_get_path(i).get_concatenated_subnames())) {
@@ -337,7 +341,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 	}
 }
 
-void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float p_time, float p_delta, float p_interp, bool p_is_current, bool p_seeked, bool p_started) {
+void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, double p_time, double p_delta, float p_interp, bool p_is_current, bool p_seeked, bool p_started) {
 	_ensure_node_caches(p_anim);
 	ERR_FAIL_COND(p_anim->node_cache.size() != p_anim->animation->get_track_count());
 
@@ -366,13 +370,14 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 		}
 
 		switch (a->track_get_type(i)) {
-			case Animation::TYPE_TRANSFORM: {
-				if (!nc->spatial) {
+			case Animation::TYPE_TRANSFORM3D: {
+#ifndef _3D_DISABLED
+				if (!nc->node_3d) {
 					continue;
 				}
 
 				Vector3 loc;
-				Quat rot;
+				Quaternion rot;
 				Vector3 scale;
 
 				Error err = a->transform_track_interpolate(i, p_time, &loc, &rot, &scale);
@@ -395,7 +400,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 					nc->rot_accum = nc->rot_accum.slerp(rot, p_interp);
 					nc->scale_accum = nc->scale_accum.lerp(scale, p_interp);
 				}
-
+#endif // _3D_DISABLED
 			} break;
 			case Animation::TYPE_VALUE: {
 				if (!nc->node) {
@@ -480,8 +485,8 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 					List<int> indices;
 					a->value_track_get_key_indices(i, p_time, p_delta, &indices);
 
-					for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-						Variant value = a->track_get_key_value(i, F->get());
+					for (int &F : indices) {
+						Variant value = a->track_get_key_value(i, F);
 						switch (pa->special) {
 							case SP_NONE: {
 								bool valid;
@@ -508,7 +513,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 								}
 #endif
 
-								static_cast<Node2D *>(pa->object)->set_rotation(Math::deg2rad((double)value));
+								static_cast<Node2D *>(pa->object)->set_rotation((double)value);
 							} break;
 							case SP_NODE2D_SCALE: {
 #ifdef DEBUG_ENABLED
@@ -539,9 +544,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 				a->method_track_get_key_indices(i, p_time, p_delta, &indices);
 
-				for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-					StringName method = a->method_track_get_name(i, E->get());
-					Vector<Variant> params = a->method_track_get_params(i, E->get());
+				for (int &E : indices) {
+					StringName method = a->method_track_get_name(i, E);
+					Vector<Variant> params = a->method_track_get_params(i, E);
 
 					int s = params.size();
 
@@ -552,6 +557,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 					}
 #endif
 
+					static_assert(VARIANT_ARG_MAX == 8, "This code needs to be updated if VARIANT_ARG_MAX != 8");
 					if (can_call) {
 						if (method_call_mode == ANIMATION_METHOD_CALL_DEFERRED) {
 							MessageQueue::get_singleton()->push_call(
@@ -561,7 +567,10 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 									s >= 2 ? params[1] : Variant(),
 									s >= 3 ? params[2] : Variant(),
 									s >= 4 ? params[3] : Variant(),
-									s >= 5 ? params[4] : Variant());
+									s >= 5 ? params[4] : Variant(),
+									s >= 6 ? params[5] : Variant(),
+									s >= 7 ? params[6] : Variant(),
+									s >= 8 ? params[7] : Variant());
 						} else {
 							nc->node->call(
 									method,
@@ -569,7 +578,10 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 									s >= 2 ? params[1] : Variant(),
 									s >= 3 ? params[2] : Variant(),
 									s >= 4 ? params[3] : Variant(),
-									s >= 5 ? params[4] : Variant());
+									s >= 5 ? params[4] : Variant(),
+									s >= 6 ? params[5] : Variant(),
+									s >= 7 ? params[6] : Variant(),
+									s >= 8 ? params[7] : Variant());
 						}
 					}
 				}
@@ -711,7 +723,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 						continue;
 					}
 
-					float pos = a->track_get_key_time(i, idx);
+					double pos = a->track_get_key_time(i, idx);
 
 					StringName anim_name = a->animation_track_get_key_animation(i, idx);
 					if (String(anim_name) == "[stop]" || !player->has_animation(anim_name)) {
@@ -720,12 +732,12 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 					Ref<Animation> anim = player->get_animation(anim_name);
 
-					float at_anim_pos;
+					double at_anim_pos;
 
 					if (anim->has_loop()) {
-						at_anim_pos = Math::fposmod(p_time - pos, anim->get_length()); //seek to loop
+						at_anim_pos = Math::fposmod(p_time - pos, (double)anim->get_length()); //seek to loop
 					} else {
-						at_anim_pos = MAX(anim->get_length(), p_time - pos); //seek to end
+						at_anim_pos = MIN((double)anim->get_length(), p_time - pos); //seek to end
 					}
 
 					if (player->is_playing() || p_seeked) {
@@ -753,6 +765,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 							}
 						} else {
 							player->play(anim_name);
+							player->seek(0.0, true);
 							nc->animation_playing = true;
 							playing_caches.insert(nc);
 						}
@@ -764,11 +777,11 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 	}
 }
 
-void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, float p_blend, bool p_seeked, bool p_started) {
-	float delta = p_delta * speed_scale * cd.speed_scale;
-	float next_pos = cd.pos + delta;
+void AnimationPlayer::_animation_process_data(PlaybackData &cd, double p_delta, float p_blend, bool p_seeked, bool p_started) {
+	double delta = p_delta * speed_scale * cd.speed_scale;
+	double next_pos = cd.pos + delta;
 
-	float len = cd.from->animation->get_length();
+	real_t len = cd.from->animation->get_length();
 	bool loop = cd.from->animation->has_loop();
 
 	if (!loop) {
@@ -796,7 +809,7 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 		}
 
 	} else {
-		float looped_next_pos = Math::fposmod(next_pos, len);
+		double looped_next_pos = Math::fposmod(next_pos, (double)len);
 		if (looped_next_pos == 0 && next_pos != 0) {
 			// Loop multiples of the length to it, rather than 0
 			// so state at time=length is previewable in the editor
@@ -811,7 +824,7 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 	_animation_process_animation(cd.from, cd.pos, delta, p_blend, &cd == &playback.current, p_seeked, p_started);
 }
 
-void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
+void AnimationPlayer::_animation_process2(double p_delta, bool p_started) {
 	Playback &c = playback;
 
 	accum_pass++;
@@ -838,20 +851,21 @@ void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 
 void AnimationPlayer::_animation_update_transforms() {
 	{
-		Transform t;
+		Transform3D t;
 		for (int i = 0; i < cache_update_size; i++) {
 			TrackNodeCache *nc = cache_update[i];
 
 			ERR_CONTINUE(nc->accum_pass != accum_pass);
 
 			t.origin = nc->loc_accum;
-			t.basis.set_quat_scale(nc->rot_accum, nc->scale_accum);
+			t.basis.set_quaternion_scale(nc->rot_accum, nc->scale_accum);
+#ifndef _3D_DISABLED
 			if (nc->skeleton && nc->bone_idx >= 0) {
 				nc->skeleton->set_bone_pose(nc->bone_idx, t);
-
-			} else if (nc->spatial) {
-				nc->spatial->set_transform(t);
+			} else if (nc->node_3d) {
+				nc->node_3d->set_transform(t);
 			}
+#endif // _3D_DISABLED
 		}
 	}
 
@@ -914,7 +928,7 @@ void AnimationPlayer::_animation_update_transforms() {
 	cache_update_bezier_size = 0;
 }
 
-void AnimationPlayer::_animation_process(float p_delta) {
+void AnimationPlayer::_animation_process(double p_delta) {
 	if (playback.current.from) {
 		end_reached = false;
 		end_notify = false;
@@ -1063,8 +1077,8 @@ void AnimationPlayer::get_animation_list(List<StringName> *p_animations) const {
 
 	anims.sort();
 
-	for (List<String>::Element *E = anims.front(); E; E = E->next()) {
-		p_animations->push_back(E->get());
+	for (const String &E : anims) {
+		p_animations->push_back(E);
 	}
 }
 
@@ -1105,8 +1119,8 @@ void AnimationPlayer::queue(const StringName &p_name) {
 
 Vector<String> AnimationPlayer::get_queue() {
 	Vector<String> ret;
-	for (List<StringName>::Element *E = queued.front(); E; E = E->next()) {
-		ret.push_back(E->get());
+	for (const StringName &E : queued) {
+		ret.push_back(E);
 	}
 
 	return ret;
@@ -1270,7 +1284,7 @@ float AnimationPlayer::get_playing_speed() const {
 	return speed_scale * playback.current.speed_scale;
 }
 
-void AnimationPlayer::seek(float p_time, bool p_update) {
+void AnimationPlayer::seek(double p_time, bool p_update) {
 	if (!playback.current.from) {
 		if (playback.assigned) {
 			ERR_FAIL_COND(!animation_set.has(playback.assigned));
@@ -1286,7 +1300,7 @@ void AnimationPlayer::seek(float p_time, bool p_update) {
 	}
 }
 
-void AnimationPlayer::seek_delta(float p_time, float p_delta) {
+void AnimationPlayer::seek_delta(double p_time, float p_delta) {
 	if (!playback.current.from) {
 		if (playback.assigned) {
 			ERR_FAIL_COND(!animation_set.has(playback.assigned));
@@ -1319,7 +1333,7 @@ float AnimationPlayer::get_current_animation_length() const {
 
 void AnimationPlayer::_animation_changed() {
 	clear_caches();
-	emit_signal("caches_cleared");
+	emit_signal(SNAME("caches_cleared"));
 	if (is_playing()) {
 		playback.seeked = true; //need to restart stuff, like audio
 	}
@@ -1480,7 +1494,7 @@ NodePath AnimationPlayer::get_root() const {
 
 void AnimationPlayer::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
 #ifdef TOOLS_ENABLED
-	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", 0) ? "'" : "\"";
+	const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
 #else
 	const String quote_style = "\"";
 #endif
@@ -1489,8 +1503,8 @@ void AnimationPlayer::get_argument_options(const StringName &p_function, int p_i
 	if (p_idx == 0 && (p_function == "play" || p_function == "play_backwards" || p_function == "remove_animation" || p_function == "has_animation" || p_function == "queue")) {
 		List<StringName> al;
 		get_animation_list(&al);
-		for (List<StringName>::Element *E = al.front(); E; E = E->next()) {
-			r_options->push_back(quote_style + String(E->get()) + quote_style);
+		for (const StringName &name : al) {
+			r_options->push_back(String(name).quote(quote_style));
 		}
 	}
 	Node::get_argument_options(p_function, p_idx, r_options);
@@ -1505,7 +1519,7 @@ Ref<AnimatedValuesBackup> AnimationPlayer::backup_animated_values(Node *p_root_o
 
 	_ensure_node_caches(playback.current.from, p_root_override);
 
-	backup.instance();
+	backup.instantiate();
 	for (int i = 0; i < playback.current.from->node_cache.size(); i++) {
 		TrackNodeCache *nc = playback.current.from->node_cache[i];
 		if (!nc) {
@@ -1523,11 +1537,11 @@ Ref<AnimatedValuesBackup> AnimationPlayer::backup_animated_values(Node *p_root_o
 			entry.value = nc->skeleton->get_bone_pose(nc->bone_idx);
 			backup->entries.push_back(entry);
 		} else {
-			if (nc->spatial) {
+			if (nc->node_3d) {
 				AnimatedValuesBackup::Entry entry;
-				entry.object = nc->spatial;
+				entry.object = nc->node_3d;
 				entry.subpath.push_back("transform");
-				entry.value = nc->spatial->get_transform();
+				entry.value = nc->node_3d->get_transform();
 				entry.bone_idx = -1;
 				backup->entries.push_back(entry);
 			} else {
@@ -1651,16 +1665,16 @@ void AnimationPlayer::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "root_node"), "set_root", "get_root");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "current_animation", PROPERTY_HINT_ENUM, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ANIMATE_AS_TRIGGER), "set_current_animation", "get_current_animation");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "assigned_animation", PROPERTY_HINT_NONE, "", 0), "set_assigned_animation", "get_assigned_animation");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "assigned_animation", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE), "set_assigned_animation", "get_assigned_animation");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "autoplay", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_autoplay", "get_autoplay");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "reset_on_save", PROPERTY_HINT_NONE, ""), "set_reset_on_save_enabled", "is_reset_on_save_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "current_animation_length", PROPERTY_HINT_NONE, "", 0), "", "get_current_animation_length");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "current_animation_position", PROPERTY_HINT_NONE, "", 0), "", "get_current_animation_position");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "current_animation_length", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE), "", "get_current_animation_length");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "current_animation_position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE), "", "get_current_animation_position");
 
 	ADD_GROUP("Playback Options", "playback_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "playback_process_mode", PROPERTY_HINT_ENUM, "Physics,Idle,Manual"), "set_process_callback", "get_process_callback");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "playback_default_blend_time", PROPERTY_HINT_RANGE, "0,4096,0.01"), "set_default_blend_time", "get_default_blend_time");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "playback_active", PROPERTY_HINT_NONE, "", 0), "set_active", "is_active");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "playback_active", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE), "set_active", "is_active");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "playback_speed", PROPERTY_HINT_RANGE, "-64,64,0.01"), "set_speed_scale", "get_speed_scale");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "method_call_mode", PROPERTY_HINT_ENUM, "Deferred,Immediate"), "set_method_call_mode", "get_method_call_mode");
 
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index 2a1821c215..b693e29bdf 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -37,8 +37,8 @@
 #include "scene/resources/animation.h"
 
 #ifdef TOOLS_ENABLED
-class AnimatedValuesBackup : public Reference {
-	GDCLASS(AnimatedValuesBackup, Reference);
+class AnimatedValuesBackup : public RefCounted {
+	GDCLASS(AnimatedValuesBackup, RefCounted);
 
 	struct Entry {
 		Object *object = nullptr;
@@ -93,14 +93,16 @@ private:
 		uint32_t id = 0;
 		RES resource;
 		Node *node = nullptr;
-		Node3D *spatial = nullptr;
 		Node2D *node_2d = nullptr;
+#ifndef _3D_DISABLED
+		Node3D *node_3d = nullptr;
 		Skeleton3D *skeleton = nullptr;
+#endif // _3D_DISABLED
 		int bone_idx = -1;
 		// accumulated transforms
 
 		Vector3 loc_accum;
-		Quat rot_accum;
+		Quaternion rot_accum;
 		Vector3 scale_accum;
 		uint64_t accum_pass = 0;
 
@@ -213,13 +215,13 @@ private:
 
 	NodePath root;
 
-	void _animation_process_animation(AnimationData *p_anim, float p_time, float p_delta, float p_interp, bool p_is_current = true, bool p_seeked = false, bool p_started = false);
+	void _animation_process_animation(AnimationData *p_anim, double p_time, double p_delta, float p_interp, bool p_is_current = true, bool p_seeked = false, bool p_started = false);
 
 	void _ensure_node_caches(AnimationData *p_anim, Node *p_root_override = nullptr);
-	void _animation_process_data(PlaybackData &cd, float p_delta, float p_blend, bool p_seeked, bool p_started);
-	void _animation_process2(float p_delta, bool p_started);
+	void _animation_process_data(PlaybackData &cd, double p_delta, float p_blend, bool p_seeked, bool p_started);
+	void _animation_process2(double p_delta, bool p_started);
 	void _animation_update_transforms();
-	void _animation_process(float p_delta);
+	void _animation_process(double p_delta);
 
 	void _node_removed(Node *p_node);
 	void _stop_playing_caches();
@@ -304,8 +306,8 @@ public:
 	void set_method_call_mode(AnimationMethodCallMode p_mode);
 	AnimationMethodCallMode get_method_call_mode() const;
 
-	void seek(float p_time, bool p_update = false);
-	void seek_delta(float p_time, float p_delta);
+	void seek(double p_time, bool p_update = false);
+	void seek_delta(double p_time, float p_delta);
 	float get_current_animation_position() const;
 	float get_current_animation_length() const;
 
diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index 2ad871ba61..88fb960164 100644
--- a/scene/animation/animation_tree.cpp
+++ b/scene/animation/animation_tree.cpp
@@ -36,8 +36,9 @@
 #include "servers/audio/audio_stream.h"
 
 void AnimationNode::get_parameter_list(List<PropertyInfo> *r_list) const {
-	if (get_script_instance()) {
-		Array parameters = get_script_instance()->call("get_parameter_list");
+	Array parameters;
+
+	if (GDVIRTUAL_CALL(_get_parameter_list, parameters)) {
 		for (int i = 0; i < parameters.size(); i++) {
 			Dictionary d = parameters[i];
 			ERR_CONTINUE(d.is_empty());
@@ -47,8 +48,9 @@ void AnimationNode::get_parameter_list(List<PropertyInfo> *r_list) const {
 }
 
 Variant AnimationNode::get_parameter_default_value(const StringName &p_parameter) const {
-	if (get_script_instance()) {
-		return get_script_instance()->call("get_parameter_default_value", p_parameter);
+	Variant ret;
+	if (GDVIRTUAL_CALL(_get_parameter_default_value, p_parameter, ret)) {
+		return ret;
 	}
 	return Variant();
 }
@@ -72,20 +74,20 @@ Variant AnimationNode::get_parameter(const StringName &p_name) const {
 }
 
 void AnimationNode::get_child_nodes(List<ChildNode> *r_child_nodes) {
-	if (get_script_instance()) {
-		Dictionary cn = get_script_instance()->call("get_child_nodes");
+	Dictionary cn;
+	if (GDVIRTUAL_CALL(_get_child_nodes, cn)) {
 		List<Variant> keys;
 		cn.get_key_list(&keys);
-		for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+		for (const Variant &E : keys) {
 			ChildNode child;
-			child.name = E->get();
-			child.node = cn[E->get()];
+			child.name = E;
+			child.node = cn[E];
 			r_child_nodes->push_back(child);
 		}
 	}
 }
 
-void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) {
+void AnimationNode::blend_animation(const StringName &p_animation, real_t p_time, real_t p_delta, bool p_seeked, real_t p_blend) {
 	ERR_FAIL_COND(!state);
 	ERR_FAIL_COND(!state->player->has_animation(p_animation));
 
@@ -115,13 +117,13 @@ void AnimationNode::blend_animation(const StringName &p_animation, float p_time,
 	state->animation_states.push_back(anim_state);
 }
 
-float AnimationNode::_pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, float p_time, bool p_seek, const Vector<StringName> &p_connections) {
+real_t AnimationNode::_pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, real_t p_time, bool p_seek, const Vector<StringName> &p_connections) {
 	base_path = p_base_path;
 	parent = p_parent;
 	connections = p_connections;
 	state = p_state;
 
-	float t = process(p_time, p_seek);
+	real_t t = process(p_time, p_seek);
 
 	state = nullptr;
 	parent = nullptr;
@@ -137,10 +139,10 @@ void AnimationNode::make_invalid(const String &p_reason) {
 	if (state->invalid_reasons != String()) {
 		state->invalid_reasons += "\n";
 	}
-	state->invalid_reasons += "- " + p_reason;
+	state->invalid_reasons += String::utf8("•  ") + p_reason;
 }
 
-float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
+real_t AnimationNode::blend_input(int p_input, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter, bool p_optimize) {
 	ERR_FAIL_INDEX_V(p_input, inputs.size(), 0);
 	ERR_FAIL_COND_V(!state, 0);
 
@@ -158,8 +160,8 @@ float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p
 	Ref<AnimationNode> node = blend_tree->get_node(node_name);
 
 	//inputs.write[p_input].last_pass = state->last_pass;
-	float activity = 0.0;
-	float ret = _blend_node(node_name, blend_tree->get_node_connection_array(node_name), nullptr, node, p_time, p_seek, p_blend, p_filter, p_optimize, &activity);
+	real_t activity = 0.0;
+	real_t ret = _blend_node(node_name, blend_tree->get_node_connection_array(node_name), nullptr, node, p_time, p_seek, p_blend, p_filter, p_optimize, &activity);
 
 	Vector<AnimationTree::Activity> *activity_ptr = state->tree->input_activity_map.getptr(base_path);
 
@@ -170,11 +172,11 @@ float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p
 	return ret;
 }
 
-float AnimationNode::blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
+real_t AnimationNode::blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter, bool p_optimize) {
 	return _blend_node(p_sub_path, Vector<StringName>(), this, p_node, p_time, p_seek, p_blend, p_filter, p_optimize);
 }
 
-float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize, float *r_max) {
+real_t AnimationNode::_blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter, bool p_optimize, real_t *r_max) {
 	ERR_FAIL_COND_V(!p_node.is_valid(), 0);
 	ERR_FAIL_COND_V(!state, 0);
 
@@ -184,8 +186,8 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 		p_node->blends.resize(blend_count);
 	}
 
-	float *blendw = p_node->blends.ptrw();
-	const float *blendr = blends.ptr();
+	real_t *blendw = p_node->blends.ptrw();
+	const real_t *blendr = blends.ptr();
 
 	bool any_valid = false;
 
@@ -298,8 +300,9 @@ String AnimationNode::get_input_name(int p_input) {
 }
 
 String AnimationNode::get_caption() const {
-	if (get_script_instance()) {
-		return get_script_instance()->call("get_caption");
+	String ret;
+	if (GDVIRTUAL_CALL(_get_caption, ret)) {
+		return ret;
 	}
 
 	return "Node";
@@ -328,9 +331,10 @@ void AnimationNode::remove_input(int p_index) {
 	emit_changed();
 }
 
-float AnimationNode::process(float p_time, bool p_seek) {
-	if (get_script_instance()) {
-		return get_script_instance()->call("process", p_time, p_seek);
+double AnimationNode::process(double p_time, bool p_seek) {
+	double ret;
+	if (GDVIRTUAL_CALL(_process, p_time, p_seek, ret)) {
+		return ret;
 	}
 
 	return 0;
@@ -357,6 +361,11 @@ bool AnimationNode::is_path_filtered(const NodePath &p_path) const {
 }
 
 bool AnimationNode::has_filter() const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_has_filter, ret)) {
+		return ret;
+	}
+
 	return false;
 }
 
@@ -381,13 +390,14 @@ void AnimationNode::_set_filters(const Array &p_filters) {
 
 void AnimationNode::_validate_property(PropertyInfo &property) const {
 	if (!has_filter() && (property.name == "filter_enabled" || property.name == "filters")) {
-		property.usage = 0;
+		property.usage = PROPERTY_USAGE_NONE;
 	}
 }
 
 Ref<AnimationNode> AnimationNode::get_child_by_name(const StringName &p_name) {
-	if (get_script_instance()) {
-		return get_script_instance()->call("get_child_by_name", p_name);
+	Ref<AnimationNode> ret;
+	if (GDVIRTUAL_CALL(_get_child_by_name, p_name, ret)) {
+		return ret;
 	}
 	return Ref<AnimationNode>();
 }
@@ -418,17 +428,13 @@ void AnimationNode::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "filter_enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_filter_enabled", "is_filter_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "filters", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_filters", "_get_filters");
 
-	BIND_VMETHOD(MethodInfo(Variant::DICTIONARY, "get_child_nodes"));
-	BIND_VMETHOD(MethodInfo(Variant::ARRAY, "get_parameter_list"));
-	BIND_VMETHOD(MethodInfo(Variant::OBJECT, "get_child_by_name", PropertyInfo(Variant::STRING, "name")));
-	{
-		MethodInfo mi = MethodInfo(Variant::NIL, "get_parameter_default_value", PropertyInfo(Variant::STRING_NAME, "name"));
-		mi.return_val.usage = PROPERTY_USAGE_NIL_IS_VARIANT;
-		BIND_VMETHOD(mi);
-	}
-	BIND_VMETHOD(MethodInfo("process", PropertyInfo(Variant::FLOAT, "time"), PropertyInfo(Variant::BOOL, "seek")));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "get_caption"));
-	BIND_VMETHOD(MethodInfo(Variant::BOOL, "has_filter"));
+	GDVIRTUAL_BIND(_get_child_nodes);
+	GDVIRTUAL_BIND(_get_parameter_list);
+	GDVIRTUAL_BIND(_get_child_by_name, "name");
+	GDVIRTUAL_BIND(_get_parameter_default_value, "parameter");
+	GDVIRTUAL_BIND(_process, "time", "seek");
+	GDVIRTUAL_BIND(_get_caption);
+	GDVIRTUAL_BIND(_has_filter);
 
 	ADD_SIGNAL(MethodInfo("removed_from_graph"));
 
@@ -532,8 +538,8 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 	List<StringName> sname;
 	player->get_animation_list(&sname);
 
-	for (List<StringName>::Element *E = sname.front(); E; E = E->next()) {
-		Ref<Animation> anim = player->get_animation(E->get());
+	for (const StringName &E : sname) {
+		Ref<Animation> anim = player->get_animation(E);
 		for (int i = 0; i < anim->get_track_count(); i++) {
 			NodePath path = anim->track_get_path(i);
 			Animation::TrackType track_type = anim->track_get_type(i);
@@ -557,7 +563,7 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 				Node *child = parent->get_node_and_resource(path, resource, leftover_path);
 
 				if (!child) {
-					ERR_PRINT("AnimationTree: '" + String(E->get()) + "', couldn't resolve track:  '" + String(path) + "'");
+					ERR_PRINT("AnimationTree: '" + String(E) + "', couldn't resolve track:  '" + String(path) + "'");
 					continue;
 				}
 
@@ -581,22 +587,23 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 						track = track_value;
 
 					} break;
-					case Animation::TYPE_TRANSFORM: {
-						Node3D *spatial = Object::cast_to<Node3D>(child);
+					case Animation::TYPE_TRANSFORM3D: {
+#ifndef _3D_DISABLED
+						Node3D *node_3d = Object::cast_to<Node3D>(child);
 
-						if (!spatial) {
-							ERR_PRINT("AnimationTree: '" + String(E->get()) + "', transform track does not point to spatial:  '" + String(path) + "'");
+						if (!node_3d) {
+							ERR_PRINT("AnimationTree: '" + String(E) + "', transform track does not point to Node3D:  '" + String(path) + "'");
 							continue;
 						}
 
 						TrackCacheTransform *track_xform = memnew(TrackCacheTransform);
 
-						track_xform->spatial = spatial;
+						track_xform->node_3d = node_3d;
 						track_xform->skeleton = nullptr;
 						track_xform->bone_idx = -1;
 
-						if (path.get_subname_count() == 1 && Object::cast_to<Skeleton3D>(spatial)) {
-							Skeleton3D *sk = Object::cast_to<Skeleton3D>(spatial);
+						if (path.get_subname_count() == 1 && Object::cast_to<Skeleton3D>(node_3d)) {
+							Skeleton3D *sk = Object::cast_to<Skeleton3D>(node_3d);
 							track_xform->skeleton = sk;
 							int bone_idx = sk->find_bone(path.get_subname(0));
 							if (bone_idx != -1) {
@@ -604,11 +611,11 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 							}
 						}
 
-						track_xform->object = spatial;
+						track_xform->object = node_3d;
 						track_xform->object_id = track_xform->object->get_instance_id();
 
 						track = track_xform;
-
+#endif // _3D_DISABLED
 					} break;
 					case Animation::TYPE_METHOD: {
 						TrackCacheMethod *track_method = memnew(TrackCacheMethod);
@@ -713,12 +720,12 @@ void AnimationTree::_clear_caches() {
 	cache_valid = false;
 }
 
-void AnimationTree::_process_graph(float p_delta) {
+void AnimationTree::_process_graph(real_t p_delta) {
 	_update_properties(); //if properties need updating, update them
 
 	//check all tracks, see if they need modification
 
-	root_motion_transform = Transform();
+	root_motion_transform = Transform3D();
 
 	if (!root.is_valid()) {
 		ERR_PRINT("AnimationTree: root AnimationNode is not set, disabling playback.");
@@ -785,7 +792,7 @@ void AnimationTree::_process_graph(float p_delta) {
 		// root source blends
 
 		root->blends.resize(state.track_count);
-		float *src_blendsw = root->blends.ptrw();
+		real_t *src_blendsw = root->blends.ptrw();
 		for (int i = 0; i < state.track_count; i++) {
 			src_blendsw[i] = 1.0; //by default all go to 1 for the root input
 		}
@@ -811,13 +818,11 @@ void AnimationTree::_process_graph(float p_delta) {
 	{
 		bool can_call = is_inside_tree() && !Engine::get_singleton()->is_editor_hint();
 
-		for (List<AnimationNode::AnimationState>::Element *E = state.animation_states.front(); E; E = E->next()) {
-			const AnimationNode::AnimationState &as = E->get();
-
+		for (const AnimationNode::AnimationState &as : state.animation_states) {
 			Ref<Animation> a = as.animation;
-			float time = as.time;
-			float delta = as.delta;
-			float weight = as.blend;
+			double time = as.time;
+			double delta = as.delta;
+			real_t weight = as.blend;
 			bool seeked = as.seeked;
 
 			for (int i = 0; i < a->get_track_count(); i++) {
@@ -837,26 +842,27 @@ void AnimationTree::_process_graph(float p_delta) {
 
 				ERR_CONTINUE(blend_idx < 0 || blend_idx >= state.track_count);
 
-				float blend = (*as.track_blends)[blend_idx] * weight;
+				real_t blend = (*as.track_blends)[blend_idx] * weight;
 
 				if (blend < CMP_EPSILON) {
 					continue; //nothing to blend
 				}
 
 				switch (track->type) {
-					case Animation::TYPE_TRANSFORM: {
+					case Animation::TYPE_TRANSFORM3D: {
+#ifndef _3D_DISABLED
 						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 
 						if (track->root_motion) {
 							if (t->process_pass != process_pass) {
 								t->process_pass = process_pass;
 								t->loc = Vector3();
-								t->rot = Quat();
+								t->rot = Quaternion();
 								t->rot_blend_accum = 0;
 								t->scale = Vector3(1, 1, 1);
 							}
 
-							float prev_time = time - delta;
+							real_t prev_time = time - delta;
 							if (prev_time < 0) {
 								if (!a->has_loop()) {
 									prev_time = 0;
@@ -866,7 +872,7 @@ void AnimationTree::_process_graph(float p_delta) {
 							}
 
 							Vector3 loc[2];
-							Quat rot[2];
+							Quaternion rot[2];
 							Vector3 scale[2];
 
 							if (prev_time > time) {
@@ -879,7 +885,7 @@ void AnimationTree::_process_graph(float p_delta) {
 
 								t->loc += (loc[1] - loc[0]) * blend;
 								t->scale += (scale[1] - scale[0]) * blend;
-								Quat q = Quat().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
+								Quaternion q = Quaternion().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
 								t->rot = (t->rot * q).normalized();
 
 								prev_time = 0;
@@ -894,14 +900,14 @@ void AnimationTree::_process_graph(float p_delta) {
 
 							t->loc += (loc[1] - loc[0]) * blend;
 							t->scale += (scale[1] - scale[0]) * blend;
-							Quat q = Quat().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
+							Quaternion q = Quaternion().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
 							t->rot = (t->rot * q).normalized();
 
 							prev_time = 0;
 
 						} else {
 							Vector3 loc;
-							Quat rot;
+							Quaternion rot;
 							Vector3 scale;
 
 							Error err = a->transform_track_interpolate(i, time, &loc, &rot, &scale);
@@ -924,13 +930,13 @@ void AnimationTree::_process_graph(float p_delta) {
 								t->rot = rot;
 								t->rot_blend_accum = blend;
 							} else {
-								float rot_total = t->rot_blend_accum + blend;
+								real_t rot_total = t->rot_blend_accum + blend;
 								t->rot = rot.slerp(t->rot, t->rot_blend_accum / rot_total).normalized();
 								t->rot_blend_accum = rot_total;
 							}
 							t->scale = t->scale.lerp(scale, blend);
 						}
-
+#endif // _3D_DISABLED
 					} break;
 					case Animation::TYPE_VALUE: {
 						TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
@@ -956,8 +962,8 @@ void AnimationTree::_process_graph(float p_delta) {
 							List<int> indices;
 							a->value_track_get_key_indices(i, time, delta, &indices);
 
-							for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-								Variant value = a->track_get_key_value(i, F->get());
+							for (int &F : indices) {
+								Variant value = a->track_get_key_value(i, F);
 								t->object->set_indexed(t->subpath, value);
 							}
 						}
@@ -973,12 +979,13 @@ void AnimationTree::_process_graph(float p_delta) {
 
 						a->method_track_get_key_indices(i, time, delta, &indices);
 
-						for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-							StringName method = a->method_track_get_name(i, F->get());
-							Vector<Variant> params = a->method_track_get_params(i, F->get());
+						for (int &F : indices) {
+							StringName method = a->method_track_get_name(i, F);
+							Vector<Variant> params = a->method_track_get_params(i, F);
 
 							int s = params.size();
 
+							static_assert(VARIANT_ARG_MAX == 8, "This code needs to be updated if VARIANT_ARG_MAX != 8");
 							ERR_CONTINUE(s > VARIANT_ARG_MAX);
 							if (can_call) {
 								t->object->call_deferred(
@@ -987,7 +994,10 @@ void AnimationTree::_process_graph(float p_delta) {
 										s >= 2 ? params[1] : Variant(),
 										s >= 3 ? params[2] : Variant(),
 										s >= 4 ? params[3] : Variant(),
-										s >= 5 ? params[4] : Variant());
+										s >= 5 ? params[4] : Variant(),
+										s >= 6 ? params[5] : Variant(),
+										s >= 7 ? params[6] : Variant(),
+										s >= 8 ? params[7] : Variant());
 							}
 						}
 
@@ -995,7 +1005,7 @@ void AnimationTree::_process_graph(float p_delta) {
 					case Animation::TYPE_BEZIER: {
 						TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
 
-						float bezier = a->bezier_track_interpolate(i, time);
+						real_t bezier = a->bezier_track_interpolate(i, time);
 
 						if (t->process_pass != process_pass) {
 							t->value = bezier;
@@ -1021,10 +1031,10 @@ void AnimationTree::_process_graph(float p_delta) {
 								t->playing = false;
 								playing_caches.erase(t);
 							} else {
-								float start_ofs = a->audio_track_get_key_start_offset(i, idx);
+								real_t start_ofs = a->audio_track_get_key_start_offset(i, idx);
 								start_ofs += time - a->track_get_key_time(i, idx);
-								float end_ofs = a->audio_track_get_key_end_offset(i, idx);
-								float len = stream->get_length();
+								real_t end_ofs = a->audio_track_get_key_end_offset(i, idx);
+								real_t len = stream->get_length();
 
 								if (start_ofs > len - end_ofs) {
 									t->object->call("stop");
@@ -1060,9 +1070,9 @@ void AnimationTree::_process_graph(float p_delta) {
 									t->playing = false;
 									playing_caches.erase(t);
 								} else {
-									float start_ofs = a->audio_track_get_key_start_offset(i, idx);
-									float end_ofs = a->audio_track_get_key_end_offset(i, idx);
-									float len = stream->get_length();
+									real_t start_ofs = a->audio_track_get_key_start_offset(i, idx);
+									real_t end_ofs = a->audio_track_get_key_end_offset(i, idx);
+									real_t len = stream->get_length();
 
 									t->object->call("set_stream", stream);
 									t->object->call("play", start_ofs);
@@ -1085,7 +1095,7 @@ void AnimationTree::_process_graph(float p_delta) {
 								if (!loop && time < t->start) {
 									stop = true;
 								} else if (t->len > 0) {
-									float len = t->start > time ? (a->get_length() - t->start) + time : time - t->start;
+									real_t len = t->start > time ? (a->get_length() - t->start) + time : time - t->start;
 
 									if (len > t->len) {
 										stop = true;
@@ -1101,7 +1111,7 @@ void AnimationTree::_process_graph(float p_delta) {
 							}
 						}
 
-						float db = Math::linear2db(MAX(blend, 0.00001));
+						real_t db = Math::linear2db(MAX(blend, 0.00001));
 						if (t->object->has_method("set_unit_db")) {
 							t->object->call("set_unit_db", db);
 						} else {
@@ -1124,7 +1134,7 @@ void AnimationTree::_process_graph(float p_delta) {
 								continue;
 							}
 
-							float pos = a->track_get_key_time(i, idx);
+							double pos = a->track_get_key_time(i, idx);
 
 							StringName anim_name = a->animation_track_get_key_animation(i, idx);
 							if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name)) {
@@ -1133,10 +1143,10 @@ void AnimationTree::_process_graph(float p_delta) {
 
 							Ref<Animation> anim = player2->get_animation(anim_name);
 
-							float at_anim_pos;
+							real_t at_anim_pos;
 
 							if (anim->has_loop()) {
-								at_anim_pos = Math::fposmod(time - pos, anim->get_length()); //seek to loop
+								at_anim_pos = Math::fposmod(time - pos, (double)anim->get_length()); //seek to loop
 							} else {
 								at_anim_pos = MAX(anim->get_length(), time - pos); //seek to end
 							}
@@ -1188,13 +1198,14 @@ void AnimationTree::_process_graph(float p_delta) {
 			}
 
 			switch (track->type) {
-				case Animation::TYPE_TRANSFORM: {
+				case Animation::TYPE_TRANSFORM3D: {
+#ifndef _3D_DISABLED
 					TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 
-					Transform xform;
+					Transform3D xform;
 					xform.origin = t->loc;
 
-					xform.basis.set_quat_scale(t->rot, t->scale);
+					xform.basis.set_quaternion_scale(t->rot, t->scale);
 
 					if (t->root_motion) {
 						root_motion_transform = xform;
@@ -1206,9 +1217,9 @@ void AnimationTree::_process_graph(float p_delta) {
 						t->skeleton->set_bone_pose(t->bone_idx, xform);
 
 					} else if (!t->skeleton) {
-						t->spatial->set_transform(xform);
+						t->node_3d->set_transform(xform);
 					}
-
+#endif // _3D_DISABLED
 				} break;
 				case Animation::TYPE_VALUE: {
 					TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
@@ -1229,7 +1240,7 @@ void AnimationTree::_process_graph(float p_delta) {
 	}
 }
 
-void AnimationTree::advance(float p_time) {
+void AnimationTree::advance(real_t p_time) {
 	_process_graph(p_time);
 }
 
@@ -1311,7 +1322,7 @@ NodePath AnimationTree::get_root_motion_track() const {
 	return root_motion_track;
 }
 
-Transform AnimationTree::get_root_motion_transform() const {
+Transform3D AnimationTree::get_root_motion_transform() const {
 	return root_motion_transform;
 }
 
@@ -1320,7 +1331,7 @@ void AnimationTree::_tree_changed() {
 		return;
 	}
 
-	call_deferred("_update_properties");
+	call_deferred(SNAME("_update_properties"));
 	properties_dirty = true;
 }
 
@@ -1344,9 +1355,7 @@ void AnimationTree::_update_properties_for_node(const String &p_base_path, Ref<A
 
 	List<PropertyInfo> plist;
 	node->get_parameter_list(&plist);
-	for (List<PropertyInfo>::Element *E = plist.front(); E; E = E->next()) {
-		PropertyInfo pinfo = E->get();
-
+	for (PropertyInfo &pinfo : plist) {
 		StringName key = pinfo.name;
 
 		if (!property_map.has(p_base_path + key)) {
@@ -1362,8 +1371,8 @@ void AnimationTree::_update_properties_for_node(const String &p_base_path, Ref<A
 	List<AnimationNode::ChildNode> children;
 	node->get_child_nodes(&children);
 
-	for (List<AnimationNode::ChildNode>::Element *E = children.front(); E; E = E->next()) {
-		_update_properties_for_node(p_base_path + E->get().name + "/", E->get().node);
+	for (const AnimationNode::ChildNode &E : children) {
+		_update_properties_for_node(p_base_path + E.name + "/", E.node);
 	}
 }
 
@@ -1417,17 +1426,17 @@ void AnimationTree::_get_property_list(List<PropertyInfo> *p_list) const {
 		const_cast<AnimationTree *>(this)->_update_properties();
 	}
 
-	for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
-		p_list->push_back(E->get());
+	for (const PropertyInfo &E : properties) {
+		p_list->push_back(E);
 	}
 }
 
 void AnimationTree::rename_parameter(const String &p_base, const String &p_new_base) {
 	//rename values first
-	for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
-		if (E->get().name.begins_with(p_base)) {
-			String new_name = E->get().name.replace_first(p_base, p_new_base);
-			property_map[new_name] = property_map[E->get().name];
+	for (const PropertyInfo &E : properties) {
+		if (E.name.begins_with(p_base)) {
+			String new_name = E.name.replace_first(p_base, p_new_base);
+			property_map[new_name] = property_map[E.name];
 		}
 	}
 
@@ -1436,7 +1445,7 @@ void AnimationTree::rename_parameter(const String &p_base, const String &p_new_b
 	_update_properties();
 }
 
-float AnimationTree::get_connection_activity(const StringName &p_path, int p_connection) const {
+real_t AnimationTree::get_connection_activity(const StringName &p_path, int p_connection) const {
 	if (!input_activity_map_get.has(p_path)) {
 		return 0;
 	}
diff --git a/scene/animation/animation_tree.h b/scene/animation/animation_tree.h
index 700ff1cb5b..1e0267682e 100644
--- a/scene/animation/animation_tree.h
+++ b/scene/animation/animation_tree.h
@@ -57,16 +57,16 @@ public:
 
 	Vector<Input> inputs;
 
-	float process_input(int p_input, float p_time, bool p_seek, float p_blend);
+	real_t process_input(int p_input, real_t p_time, bool p_seek, real_t p_blend);
 
 	friend class AnimationTree;
 
 	struct AnimationState {
 		Ref<Animation> animation;
-		float time = 0.0;
-		float delta = 0.0;
-		const Vector<float> *track_blends = nullptr;
-		float blend = 0.0;
+		double time = 0.0;
+		double delta = 0.0;
+		const Vector<real_t> *track_blends = nullptr;
+		real_t blend = 0.0;
 		bool seeked = false;
 	};
 
@@ -81,10 +81,10 @@ public:
 		uint64_t last_pass = 0;
 	};
 
-	Vector<float> blends;
+	Vector<real_t> blends;
 	State *state = nullptr;
 
-	float _pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, float p_time, bool p_seek, const Vector<StringName> &p_connections);
+	real_t _pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, real_t p_time, bool p_seek, const Vector<StringName> &p_connections);
 	void _pre_update_animations(HashMap<NodePath, int> *track_map);
 
 	//all this is temporary
@@ -98,12 +98,12 @@ public:
 	Array _get_filters() const;
 	void _set_filters(const Array &p_filters);
 	friend class AnimationNodeBlendTree;
-	float _blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true, float *r_max = nullptr);
+	real_t _blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true, real_t *r_max = nullptr);
 
 protected:
-	void blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend);
-	float blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true);
-	float blend_input(int p_input, float p_time, bool p_seek, float p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true);
+	void blend_animation(const StringName &p_animation, real_t p_time, real_t p_delta, bool p_seeked, real_t p_blend);
+	real_t blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true);
+	real_t blend_input(int p_input, real_t p_time, bool p_seek, real_t p_blend, FilterAction p_filter = FILTER_IGNORE, bool p_optimize = true);
 	void make_invalid(const String &p_reason);
 
 	static void _bind_methods();
@@ -112,6 +112,14 @@ protected:
 
 	void _set_parent(Object *p_parent);
 
+	GDVIRTUAL0RC(Dictionary, _get_child_nodes)
+	GDVIRTUAL0RC(Array, _get_parameter_list)
+	GDVIRTUAL1RC(Ref<AnimationNode>, _get_child_by_name, StringName)
+	GDVIRTUAL1RC(Variant, _get_parameter_default_value, StringName)
+	GDVIRTUAL2RC(double, _process, double, bool)
+	GDVIRTUAL0RC(String, _get_caption)
+	GDVIRTUAL0RC(bool, _has_filter)
+
 public:
 	virtual void get_parameter_list(List<PropertyInfo> *r_list) const;
 	virtual Variant get_parameter_default_value(const StringName &p_parameter) const;
@@ -126,7 +134,7 @@ public:
 
 	virtual void get_child_nodes(List<ChildNode> *r_child_nodes);
 
-	virtual float process(float p_time, bool p_seek);
+	virtual double process(double p_time, bool p_seek);
 	virtual String get_caption() const;
 
 	int get_input_count() const;
@@ -184,16 +192,18 @@ private:
 	};
 
 	struct TrackCacheTransform : public TrackCache {
-		Node3D *spatial = nullptr;
+#ifndef _3D_DISABLED
+		Node3D *node_3d = nullptr;
 		Skeleton3D *skeleton = nullptr;
+#endif // _3D_DISABLED
 		int bone_idx = -1;
 		Vector3 loc;
-		Quat rot;
-		float rot_blend_accum = 0.0;
+		Quaternion rot;
+		real_t rot_blend_accum = 0.0;
 		Vector3 scale;
 
 		TrackCacheTransform() {
-			type = Animation::TYPE_TRANSFORM;
+			type = Animation::TYPE_TRANSFORM3D;
 		}
 	};
 
@@ -208,7 +218,7 @@ private:
 	};
 
 	struct TrackCacheBezier : public TrackCache {
-		float value = 0.0;
+		real_t value = 0.0;
 		Vector<StringName> subpath;
 		TrackCacheBezier() {
 			type = Animation::TYPE_BEZIER;
@@ -217,8 +227,8 @@ private:
 
 	struct TrackCacheAudio : public TrackCache {
 		bool playing = false;
-		float start = 0.0;
-		float len = 0.0;
+		real_t start = 0.0;
+		real_t len = 0.0;
 
 		TrackCacheAudio() {
 			type = Animation::TYPE_AUDIO;
@@ -249,7 +259,7 @@ private:
 
 	void _clear_caches();
 	bool _update_caches(AnimationPlayer *player);
-	void _process_graph(float p_delta);
+	void _process_graph(real_t p_delta);
 
 	uint64_t setup_pass = 1;
 	uint64_t process_pass = 1;
@@ -257,7 +267,7 @@ private:
 	bool started = true;
 
 	NodePath root_motion_track;
-	Transform root_motion_transform;
+	Transform3D root_motion_transform;
 
 	friend class AnimationNode;
 	bool properties_dirty = true;
@@ -269,7 +279,7 @@ private:
 
 	struct Activity {
 		uint64_t last_pass = 0;
-		float activity = 0.0;
+		real_t activity = 0.0;
 	};
 
 	HashMap<StringName, Vector<Activity>> input_activity_map;
@@ -308,10 +318,10 @@ public:
 	void set_root_motion_track(const NodePath &p_track);
 	NodePath get_root_motion_track() const;
 
-	Transform get_root_motion_transform() const;
+	Transform3D get_root_motion_transform() const;
 
-	float get_connection_activity(const StringName &p_path, int p_connection) const;
-	void advance(float p_time);
+	real_t get_connection_activity(const StringName &p_path, int p_connection) const;
+	void advance(real_t p_time);
 
 	void rename_parameter(const String &p_base, const String &p_new_base);
 
diff --git a/scene/animation/root_motion_view.cpp b/scene/animation/root_motion_view.cpp
index 9ee1f32581..770996820d 100644
--- a/scene/animation/root_motion_view.cpp
+++ b/scene/animation/root_motion_view.cpp
@@ -77,12 +77,12 @@ bool RootMotionView::get_zero_y() const {
 
 void RootMotionView::_notification(int p_what) {
 	if (p_what == NOTIFICATION_ENTER_TREE) {
-		RS::get_singleton()->immediate_set_material(immediate, StandardMaterial3D::get_material_rid_for_2d(false, true, false, false, false));
+		immediate_material = StandardMaterial3D::get_material_for_2d(false, true, false, false, false);
 		first = true;
 	}
 
 	if (p_what == NOTIFICATION_INTERNAL_PROCESS || p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS) {
-		Transform transform;
+		Transform3D transform;
 
 		if (has_node(path)) {
 			Node *node = get_node(path);
@@ -103,7 +103,7 @@ void RootMotionView::_notification(int p_what) {
 			}
 		}
 
-		if (!first && transform == Transform()) {
+		if (!first && transform == Transform3D()) {
 			return;
 		}
 
@@ -119,11 +119,12 @@ void RootMotionView::_notification(int p_what) {
 		}
 		accumulated.origin.z = Math::fposmod(accumulated.origin.z, cell_size);
 
-		RS::get_singleton()->immediate_clear(immediate);
+		immediate->clear_surfaces();
 
 		int cells_in_radius = int((radius / cell_size) + 1.0);
 
-		RS::get_singleton()->immediate_begin(immediate, RS::PRIMITIVE_LINES);
+		immediate->surface_begin(Mesh::PRIMITIVE_LINES, immediate_material);
+
 		for (int i = -cells_in_radius; i < cells_in_radius; i++) {
 			for (int j = -cells_in_radius; j < cells_in_radius; j++) {
 				Vector3 from(i * cell_size, 0, j * cell_size);
@@ -138,21 +139,21 @@ void RootMotionView::_notification(int p_what) {
 				c_i.a *= MAX(0, 1.0 - from_i.length() / radius);
 				c_j.a *= MAX(0, 1.0 - from_j.length() / radius);
 
-				RS::get_singleton()->immediate_color(immediate, c);
-				RS::get_singleton()->immediate_vertex(immediate, from);
+				immediate->surface_set_color(c);
+				immediate->surface_add_vertex(from);
 
-				RS::get_singleton()->immediate_color(immediate, c_i);
-				RS::get_singleton()->immediate_vertex(immediate, from_i);
+				immediate->surface_set_color(c_i);
+				immediate->surface_add_vertex(from_i);
 
-				RS::get_singleton()->immediate_color(immediate, c);
-				RS::get_singleton()->immediate_vertex(immediate, from);
+				immediate->surface_set_color(c);
+				immediate->surface_add_vertex(from);
 
-				RS::get_singleton()->immediate_color(immediate, c_j);
-				RS::get_singleton()->immediate_vertex(immediate, from_j);
+				immediate->surface_set_color(c_j);
+				immediate->surface_add_vertex(from_j);
 			}
 		}
 
-		RS::get_singleton()->immediate_end(immediate);
+		immediate->surface_end();
 	}
 }
 
@@ -188,12 +189,13 @@ void RootMotionView::_bind_methods() {
 }
 
 RootMotionView::RootMotionView() {
-	set_process_internal(true);
-	immediate = RenderingServer::get_singleton()->immediate_create();
-	set_base(immediate);
+	if (Engine::get_singleton()->is_editor_hint()) {
+		set_process_internal(true);
+	}
+	immediate.instantiate();
+	set_base(immediate->get_rid());
 }
 
 RootMotionView::~RootMotionView() {
 	set_base(RID());
-	RenderingServer::get_singleton()->free(immediate);
 }
diff --git a/scene/animation/root_motion_view.h b/scene/animation/root_motion_view.h
index afcff6137f..d64c8bc675 100644
--- a/scene/animation/root_motion_view.h
+++ b/scene/animation/root_motion_view.h
@@ -32,21 +32,23 @@
 #define ROOT_MOTION_VIEW_H
 
 #include "scene/3d/visual_instance_3d.h"
-
+#include "scene/resources/immediate_mesh.h"
 class RootMotionView : public VisualInstance3D {
 	GDCLASS(RootMotionView, VisualInstance3D);
 
 public:
-	RID immediate;
+	Ref<ImmediateMesh> immediate;
 	NodePath path;
-	float cell_size = 1.0;
-	float radius = 10.0;
+	real_t cell_size = 1.0;
+	real_t radius = 10.0;
 	bool use_in_game = false;
 	Color color = Color(0.5, 0.5, 1.0);
 	bool first = true;
 	bool zero_y = true;
 
-	Transform accumulated;
+	Ref<Material> immediate_material;
+
+	Transform3D accumulated;
 
 private:
 	void _notification(int p_what);
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index 2030808724..3018fd3ae6 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -30,535 +30,420 @@
 
 #include "tween.h"
 
-void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5, const Variant &p_arg6, const Variant &p_arg7, const Variant &p_arg8, const Variant &p_arg9, const Variant &p_arg10) {
-	// Add a new pending command and reference it
-	pending_commands.push_back(PendingCommand());
-	PendingCommand &cmd = pending_commands.back()->get();
-
-	// Update the command with the target key
-	cmd.key = p_key;
-
-	// Determine command argument count
-	int &count = cmd.args;
-	if (p_arg10.get_type() != Variant::NIL) {
-		count = 10;
-	} else if (p_arg9.get_type() != Variant::NIL) {
-		count = 9;
-	} else if (p_arg8.get_type() != Variant::NIL) {
-		count = 8;
-	} else if (p_arg7.get_type() != Variant::NIL) {
-		count = 7;
-	} else if (p_arg6.get_type() != Variant::NIL) {
-		count = 6;
-	} else if (p_arg5.get_type() != Variant::NIL) {
-		count = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		count = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		count = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		count = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		count = 1;
-	} else {
-		count = 0;
-	}
+#include "scene/main/node.h"
 
-	// Add the specified arguments to the command
-	if (count > 0) {
-		cmd.arg[0] = p_arg1;
-	}
-	if (count > 1) {
-		cmd.arg[1] = p_arg2;
-	}
-	if (count > 2) {
-		cmd.arg[2] = p_arg3;
-	}
-	if (count > 3) {
-		cmd.arg[3] = p_arg4;
-	}
-	if (count > 4) {
-		cmd.arg[4] = p_arg5;
-	}
-	if (count > 5) {
-		cmd.arg[5] = p_arg6;
-	}
-	if (count > 6) {
-		cmd.arg[6] = p_arg7;
-	}
-	if (count > 7) {
-		cmd.arg[7] = p_arg8;
-	}
-	if (count > 8) {
-		cmd.arg[8] = p_arg9;
+void Tweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+}
+
+void Tweener::clear_tween() {
+	tween.unref();
+}
+
+void Tweener::_bind_methods() {
+	ADD_SIGNAL(MethodInfo("finished"));
+}
+
+void Tween::start_tweeners() {
+	if (tweeners.is_empty()) {
+		dead = true;
+		ERR_FAIL_MSG("Tween without commands, aborting.");
 	}
-	if (count > 9) {
-		cmd.arg[9] = p_arg10;
+
+	for (Ref<Tweener> &tweener : tweeners.write[current_step]) {
+		tweener->start();
 	}
 }
 
-void Tween::_process_pending_commands() {
-	// For each pending command...
-	for (List<PendingCommand>::Element *E = pending_commands.front(); E; E = E->next()) {
-		// Get the command
-		PendingCommand &cmd = E->get();
-		Callable::CallError err;
-
-		// Grab all of the arguments for the command
-		Variant *arg[10] = {
-			&cmd.arg[0],
-			&cmd.arg[1],
-			&cmd.arg[2],
-			&cmd.arg[3],
-			&cmd.arg[4],
-			&cmd.arg[5],
-			&cmd.arg[6],
-			&cmd.arg[7],
-			&cmd.arg[8],
-			&cmd.arg[9],
-		};
-
-		// Execute the command (and retrieve any errors)
-		this->call(cmd.key, (const Variant **)arg, cmd.args, err);
-	}
+Ref<PropertyTweener> Tween::tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
+	ERR_FAIL_NULL_V(p_target, nullptr);
+	ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	// Clear the pending commands
-	pending_commands.clear();
+	Ref<PropertyTweener> tweener = memnew(PropertyTweener(p_target, p_property, p_to, p_duration));
+	append(tweener);
+	return tweener;
 }
 
-bool Tween::_set(const StringName &p_name, const Variant &p_value) {
-	// Set the correct attribute based on the given name
-	String name = p_name;
-	if (name == "playback/speed" || name == "speed") { // Backwards compatibility
-		set_speed_scale(p_value);
-		return true;
+Ref<IntervalTweener> Tween::tween_interval(float p_time) {
+	ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	} else if (name == "playback/active") {
-		set_active(p_value);
-		return true;
+	Ref<IntervalTweener> tweener = memnew(IntervalTweener(p_time));
+	append(tweener);
+	return tweener;
+}
 
-	} else if (name == "playback/repeat") {
-		set_repeat(p_value);
-		return true;
-	}
-	return false;
+Ref<CallbackTweener> Tween::tween_callback(Callable p_callback) {
+	ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
+
+	Ref<CallbackTweener> tweener = memnew(CallbackTweener(p_callback));
+	append(tweener);
+	return tweener;
 }
 
-bool Tween::_get(const StringName &p_name, Variant &r_ret) const {
-	// Get the correct attribute based on the given name
-	String name = p_name;
-	if (name == "playback/speed") { // Backwards compatibility
-		r_ret = speed_scale;
-		return true;
+Ref<MethodTweener> Tween::tween_method(Callable p_callback, float p_from, float p_to, float p_duration) {
+	ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	} else if (name == "playback/active") {
-		r_ret = is_active();
-		return true;
+	Ref<MethodTweener> tweener = memnew(MethodTweener(p_callback, p_from, p_to, p_duration));
+	append(tweener);
+	return tweener;
+}
 
-	} else if (name == "playback/repeat") {
-		r_ret = is_repeat();
-		return true;
+void Tween::append(Ref<Tweener> p_tweener) {
+	p_tweener->set_tween(this);
+
+	if (parallel_enabled) {
+		current_step = MAX(current_step, 0);
+	} else {
+		current_step++;
 	}
-	return false;
-}
-
-void Tween::_get_property_list(List<PropertyInfo> *p_list) const {
-	// Add the property info for the Tween object
-	p_list->push_back(PropertyInfo(Variant::BOOL, "playback/active", PROPERTY_HINT_NONE, ""));
-	p_list->push_back(PropertyInfo(Variant::BOOL, "playback/repeat", PROPERTY_HINT_NONE, ""));
-	p_list->push_back(PropertyInfo(Variant::FLOAT, "playback/speed", PROPERTY_HINT_RANGE, "-64,64,0.01"));
-}
-
-void Tween::_notification(int p_what) {
-	// What notification did we receive?
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			// Are we not already active?
-			if (!is_active()) {
-				// Make sure that a previous process state was not saved
-				// Only process if "processing" is set
-				set_physics_process_internal(false);
-				set_process_internal(false);
-			}
-		} break;
+	parallel_enabled = default_parallel;
 
-		case NOTIFICATION_READY: {
-			// Do nothing
-		} break;
+	tweeners.resize(current_step + 1);
+	tweeners.write[current_step].push_back(p_tweener);
+}
 
-		case NOTIFICATION_INTERNAL_PROCESS: {
-			// Are we processing during physics time?
-			if (tween_process_mode == TWEEN_PROCESS_PHYSICS) {
-				// Do nothing since we aren't aligned with physics when we should be
-				break;
-			}
+void Tween::stop() {
+	started = false;
+	running = false;
+	dead = false;
+}
 
-			// Should we update?
-			if (is_active()) {
-				// Update the tweens
-				_tween_process(get_process_delta_time());
-			}
-		} break;
+void Tween::pause() {
+	running = false;
+}
 
-		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
-			// Are we processing during 'regular' time?
-			if (tween_process_mode == TWEEN_PROCESS_IDLE) {
-				// Do nothing since we would only process during idle time
-				break;
-			}
+void Tween::play() {
+	ERR_FAIL_COND_MSG(!valid, "Tween invalid. Either finished or created outside scene tree.");
+	ERR_FAIL_COND_MSG(dead, "Can't play finished Tween, use stop() first to reset its state.");
+	running = true;
+}
 
-			// Should we update?
-			if (is_active()) {
-				// Update the tweens
-				_tween_process(get_physics_process_delta_time());
-			}
-		} break;
+void Tween::kill() {
+	running = false; // For the sake of is_running().
+	dead = true;
+}
 
-		case NOTIFICATION_EXIT_TREE: {
-			// We've left the tree. Stop all tweens
-			stop_all();
-		} break;
+bool Tween::is_running() {
+	return running;
+}
+
+void Tween::set_valid(bool p_valid) {
+	valid = p_valid;
+}
+
+bool Tween::is_valid() {
+	return valid;
+}
+
+void Tween::clear() {
+	valid = false;
+
+	for (List<Ref<Tweener>> &step : tweeners) {
+		for (Ref<Tweener> &tweener : step) {
+			tweener->clear_tween();
+		}
 	}
+	tweeners.clear();
 }
 
-void Tween::_bind_methods() {
-	// Bind getters and setters
-	ClassDB::bind_method(D_METHOD("is_active"), &Tween::is_active);
-	ClassDB::bind_method(D_METHOD("set_active", "active"), &Tween::set_active);
+Ref<Tween> Tween::bind_node(Node *p_node) {
+	ERR_FAIL_NULL_V(p_node, this);
 
-	ClassDB::bind_method(D_METHOD("is_repeat"), &Tween::is_repeat);
-	ClassDB::bind_method(D_METHOD("set_repeat", "repeat"), &Tween::set_repeat);
+	bound_node = p_node->get_instance_id();
+	is_bound = true;
+	return this;
+}
 
-	ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale);
-	ClassDB::bind_method(D_METHOD("get_speed_scale"), &Tween::get_speed_scale);
-
-	ClassDB::bind_method(D_METHOD("set_tween_process_mode", "mode"), &Tween::set_tween_process_mode);
-	ClassDB::bind_method(D_METHOD("get_tween_process_mode"), &Tween::get_tween_process_mode);
-
-	// Bind the various Tween control methods
-	ClassDB::bind_method(D_METHOD("start"), &Tween::start);
-	ClassDB::bind_method(D_METHOD("reset", "object", "key"), &Tween::reset, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("reset_all"), &Tween::reset_all);
-	ClassDB::bind_method(D_METHOD("stop", "object", "key"), &Tween::stop, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("stop_all"), &Tween::stop_all);
-	ClassDB::bind_method(D_METHOD("resume", "object", "key"), &Tween::resume, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("resume_all"), &Tween::resume_all);
-	ClassDB::bind_method(D_METHOD("remove", "object", "key"), &Tween::remove, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("_remove_by_uid", "uid"), &Tween::_remove_by_uid);
-	ClassDB::bind_method(D_METHOD("remove_all"), &Tween::remove_all);
-	ClassDB::bind_method(D_METHOD("seek", "time"), &Tween::seek);
-	ClassDB::bind_method(D_METHOD("tell"), &Tween::tell);
-	ClassDB::bind_method(D_METHOD("get_runtime"), &Tween::get_runtime);
-
-	// Bind interpolation and follow methods
-	ClassDB::bind_method(D_METHOD("interpolate_property", "object", "property", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("interpolate_method", "object", "method", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("interpolate_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("interpolate_deferred_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_deferred_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("follow_property", "object", "property", "initial_val", "target", "target_property", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("follow_method", "object", "method", "initial_val", "target", "target_method", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("targeting_property", "object", "property", "initial", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("targeting_method", "object", "method", "initial", "initial_method", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-
-	// Add the Tween signals
-	ADD_SIGNAL(MethodInfo("tween_started", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key")));
-	ADD_SIGNAL(MethodInfo("tween_step", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key"), PropertyInfo(Variant::FLOAT, "elapsed"), PropertyInfo(Variant::OBJECT, "value")));
-	ADD_SIGNAL(MethodInfo("tween_completed", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key")));
-	ADD_SIGNAL(MethodInfo("tween_all_completed"));
-
-	// Add the properties and tie them to the getters and setters
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "repeat"), "set_repeat", "is_repeat");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "playback_process_mode", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_tween_process_mode", "get_tween_process_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "playback_speed", PROPERTY_HINT_RANGE, "-64,64,0.01"), "set_speed_scale", "get_speed_scale");
-
-	// Bind Idle vs Physics process
-	BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
-	BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
+Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {
+	process_mode = p_mode;
+	return this;
+}
 
-	// Bind the Transition type constants
-	BIND_ENUM_CONSTANT(TRANS_LINEAR);
-	BIND_ENUM_CONSTANT(TRANS_SINE);
-	BIND_ENUM_CONSTANT(TRANS_QUINT);
-	BIND_ENUM_CONSTANT(TRANS_QUART);
-	BIND_ENUM_CONSTANT(TRANS_QUAD);
-	BIND_ENUM_CONSTANT(TRANS_EXPO);
-	BIND_ENUM_CONSTANT(TRANS_ELASTIC);
-	BIND_ENUM_CONSTANT(TRANS_CUBIC);
-	BIND_ENUM_CONSTANT(TRANS_CIRC);
-	BIND_ENUM_CONSTANT(TRANS_BOUNCE);
-	BIND_ENUM_CONSTANT(TRANS_BACK);
+Tween::TweenProcessMode Tween::get_process_mode() {
+	return process_mode;
+}
 
-	// Bind the easing constants
-	BIND_ENUM_CONSTANT(EASE_IN);
-	BIND_ENUM_CONSTANT(EASE_OUT);
-	BIND_ENUM_CONSTANT(EASE_IN_OUT);
-	BIND_ENUM_CONSTANT(EASE_OUT_IN);
+Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {
+	pause_mode = p_mode;
+	return this;
 }
 
-Variant Tween::_get_initial_val(const InterpolateData &p_data) const {
-	// What type of data are we interpolating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case INTER_METHOD:
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD:
-			// Simply use the given initial value
-			return p_data.initial_val;
-
-		case TARGETING_PROPERTY:
-		case TARGETING_METHOD: {
-			// Get the object that is being targeted
-			Object *object = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(object == nullptr, p_data.initial_val);
-
-			// Are we targeting a property or a method?
-			Variant initial_val;
-			if (p_data.type == TARGETING_PROPERTY) {
-				// Get the property from the target object
-				bool valid = false;
-				initial_val = object->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// Call the method and get the initial value from it
-				Callable::CallError error;
-				initial_val = object->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
-			return initial_val;
-		}
+Tween::TweenPauseMode Tween::get_pause_mode() {
+	return pause_mode;
+}
+
+Ref<Tween> Tween::set_parallel(bool p_parallel) {
+	default_parallel = p_parallel;
+	parallel_enabled = p_parallel;
+	return this;
+}
+
+Ref<Tween> Tween::set_loops(int p_loops) {
+	loops = p_loops;
+	return this;
+}
+
+Ref<Tween> Tween::set_speed_scale(float p_speed) {
+	speed_scale = p_speed;
+	return this;
+}
+
+Ref<Tween> Tween::set_trans(TransitionType p_trans) {
+	default_transition = p_trans;
+	return this;
+}
+
+Tween::TransitionType Tween::get_trans() {
+	return default_transition;
+}
+
+Ref<Tween> Tween::set_ease(EaseType p_ease) {
+	default_ease = p_ease;
+	return this;
+}
+
+Tween::EaseType Tween::get_ease() {
+	return default_ease;
+}
+
+Ref<Tween> Tween::parallel() {
+	parallel_enabled = true;
+	return this;
+}
+
+Ref<Tween> Tween::chain() {
+	parallel_enabled = false;
+	return this;
+}
+
+bool Tween::custom_step(float p_delta) {
+	bool r = running;
+	running = true;
+	bool ret = step(p_delta);
+	running = running && r; // Running might turn false when Tween finished.
+	return ret;
+}
+
+bool Tween::step(float p_delta) {
+	ERR_FAIL_COND_V_MSG(tweeners.is_empty(), false, "Tween started, but has no Tweeners.");
 
-		case INTER_CALLBACK:
-			// Callback does not have a special initial value
-			break;
+	if (dead) {
+		return false;
 	}
-	// If we've made it here, just return the delta value as the initial value
-	return p_data.delta_val;
-}
-
-Variant Tween::_get_final_val(const InterpolateData &p_data) const {
-	switch (p_data.type) {
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD: {
-			// Get the object that is being followed
-			Object *target = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(target == nullptr, p_data.initial_val);
-
-			// We want to figure out the final value
-			Variant final_val;
-			if (p_data.type == FOLLOW_PROPERTY) {
-				// Read the property as-is
-				bool valid = false;
-				final_val = target->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// We're looking at a method. Call the method on the target object
-				Callable::CallError error;
-				final_val = target->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) {
-				final_val = final_val.operator real_t();
-			}
+	if (!running) {
+		return true;
+	}
 
-			return final_val;
-		}
-		default: {
-			// If we're not following a final value/method, use the final value from the data
-			return p_data.final_val;
+	if (is_bound) {
+		Object *bound_instance = ObjectDB::get_instance(bound_node);
+		if (bound_instance) {
+			Node *bound_node = Object::cast_to<Node>(bound_instance);
+			// This can't by anything else than Node, so we can omit checking if casting succeeded.
+			if (!bound_node->is_inside_tree()) {
+				return true;
+			}
+		} else {
+			return false;
 		}
 	}
-}
 
-Variant &Tween::_get_delta_val(InterpolateData &p_data) {
-	// What kind of data are we interpolating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case INTER_METHOD:
-			// Simply return the given delta value
-			return p_data.delta_val;
-
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD: {
-			// We're following an object, so grab that instance
-			Object *target = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(target == nullptr, p_data.initial_val);
-
-			// We want to figure out the final value
-			Variant final_val;
-			if (p_data.type == FOLLOW_PROPERTY) {
-				// Read the property as-is
-				bool valid = false;
-				final_val = target->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// We're looking at a method. Call the method on the target object
-				Callable::CallError error;
-				final_val = target->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
+	if (!started) {
+		current_step = 0;
+		loops_done = 0;
+		start_tweeners();
+		started = true;
+	}
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) {
-				final_val = final_val.operator real_t();
-			}
+	float rem_delta = p_delta * speed_scale;
+	bool step_active = false;
+
+	while (rem_delta > 0 && running) {
+		float step_delta = rem_delta;
+		step_active = false;
 
-			// Calculate the delta based on the initial value and the final value
-			_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
-			return p_data.delta_val;
+		for (Ref<Tweener> &tweener : tweeners.write[current_step]) {
+			// Modified inside Tweener.step().
+			float temp_delta = rem_delta;
+			// Turns to true if any Tweener returns true (i.e. is still not finished).
+			step_active = tweener->step(temp_delta) || step_active;
+			step_delta = MIN(temp_delta, rem_delta);
 		}
 
-		case TARGETING_PROPERTY:
-		case TARGETING_METHOD: {
-			// Grab the initial value from the data to calculate delta
-			Variant initial_val = _get_initial_val(p_data);
+		rem_delta = step_delta;
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (initial_val.get_type() == Variant::INT) {
-				initial_val = initial_val.operator real_t();
-			}
+		if (!step_active) {
+			emit_signal(SNAME("step_finished"), current_step);
+			current_step++;
 
-			// Calculate the delta based on the initial value and the final value
-			_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
-			return p_data.delta_val;
+			if (current_step == tweeners.size()) {
+				loops_done++;
+				if (loops_done == loops) {
+					running = false;
+					dead = true;
+					emit_signal(SNAME("finished"));
+				} else {
+					emit_signal(SNAME("loop_finished"), loops_done);
+					current_step = 0;
+					start_tweeners();
+				}
+			} else {
+				start_tweeners();
+			}
 		}
+	}
 
-		case INTER_CALLBACK:
-			// Callbacks have no special delta
-			break;
+	return true;
+}
+
+bool Tween::should_pause() {
+	if (is_bound && pause_mode == TWEEN_PAUSE_BOUND) {
+		Object *bound_instance = ObjectDB::get_instance(bound_node);
+		if (bound_instance) {
+			Node *bound_node = Object::cast_to<Node>(bound_instance);
+			return !bound_node->can_process();
+		}
 	}
-	// If we've made it here, use the initial value as the delta
-	return p_data.initial_val;
+
+	return pause_mode != TWEEN_PAUSE_PROCESS;
 }
 
-Variant Tween::_run_equation(InterpolateData &p_data) {
-	// Get the initial and delta values from the data
-	Variant initial_val = _get_initial_val(p_data);
-	Variant &delta_val = _get_delta_val(p_data);
-	Variant result;
+Variant Tween::interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, TransitionType p_trans, EaseType p_ease) {
+	ERR_FAIL_INDEX_V(p_trans, TransitionType::TRANS_MAX, Variant());
+	ERR_FAIL_INDEX_V(p_ease, EaseType::EASE_MAX, Variant());
 
+// Helper macro to run equation on sub-elements of the value (e.g. x and y of Vector2).
 #define APPLY_EQUATION(element) \
-	r.element = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, i.element, d.element, p_data.duration);
+	r.element = run_equation(p_trans, p_ease, p_time, i.element, d.element, p_duration);
 
-	// What type of data are we interpolating?
-	switch (initial_val.get_type()) {
-		case Variant::BOOL:
-			// Run the boolean specific equation (checking if it is at least 0.5)
-			result = (_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, initial_val, delta_val, p_data.duration)) >= 0.5;
-			break;
+	switch (p_initial_val.get_type()) {
+		case Variant::BOOL: {
+			return (run_equation(p_trans, p_ease, p_time, p_initial_val, p_delta_val, p_duration)) >= 0.5;
+		}
 
-		case Variant::INT:
-			// Run the integer specific equation
-			result = (int)_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (int)initial_val, (int)delta_val, p_data.duration);
-			break;
+		case Variant::INT: {
+			return (int)run_equation(p_trans, p_ease, p_time, (int)p_initial_val, (int)p_delta_val, p_duration);
+		}
 
-		case Variant::FLOAT:
-			// Run the FLOAT specific equation
-			result = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (real_t)initial_val, (real_t)delta_val, p_data.duration);
-			break;
+		case Variant::FLOAT: {
+			return run_equation(p_trans, p_ease, p_time, (real_t)p_initial_val, (real_t)p_delta_val, p_duration);
+		}
 
 		case Variant::VECTOR2: {
-			// Get vectors for initial and delta values
-			Vector2 i = initial_val;
-			Vector2 d = delta_val;
+			Vector2 i = p_initial_val;
+			Vector2 d = p_delta_val;
 			Vector2 r;
 
-			// Execute the equation and mutate the r vector
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::VECTOR2I: {
+			Vector2i i = p_initial_val;
+			Vector2i d = p_delta_val;
+			Vector2i r;
+
+			APPLY_EQUATION(x);
+			APPLY_EQUATION(y);
+			return r;
+		}
 
 		case Variant::RECT2: {
-			// Get the Rect2 for initial and delta value
-			Rect2 i = initial_val;
-			Rect2 d = delta_val;
+			Rect2 i = p_initial_val;
+			Rect2 d = p_delta_val;
 			Rect2 r;
 
-			// Execute the equation for the position and size of Rect2
 			APPLY_EQUATION(position.x);
 			APPLY_EQUATION(position.y);
 			APPLY_EQUATION(size.x);
 			APPLY_EQUATION(size.y);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::RECT2I: {
+			Rect2i i = p_initial_val;
+			Rect2i d = p_delta_val;
+			Rect2i r;
+
+			APPLY_EQUATION(position.x);
+			APPLY_EQUATION(position.y);
+			APPLY_EQUATION(size.x);
+			APPLY_EQUATION(size.y);
+			return r;
+		}
 
 		case Variant::VECTOR3: {
-			// Get vectors for initial and delta values
-			Vector3 i = initial_val;
-			Vector3 d = delta_val;
+			Vector3 i = p_initial_val;
+			Vector3 d = p_delta_val;
 			Vector3 r;
 
-			// Execute the equation and mutate the r vector
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
 			APPLY_EQUATION(z);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::VECTOR3I: {
+			Vector3i i = p_initial_val;
+			Vector3i d = p_delta_val;
+			Vector3i r;
+
+			APPLY_EQUATION(x);
+			APPLY_EQUATION(y);
+			APPLY_EQUATION(z);
+			return r;
+		}
 
 		case Variant::TRANSFORM2D: {
-			// Get the transforms for initial and delta values
-			Transform2D i = initial_val;
-			Transform2D d = delta_val;
+			Transform2D i = p_initial_val;
+			Transform2D d = p_delta_val;
 			Transform2D r;
 
-			// Execute the equation on the transforms and mutate the r transform
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(elements[0][0]);
 			APPLY_EQUATION(elements[0][1]);
 			APPLY_EQUATION(elements[1][0]);
 			APPLY_EQUATION(elements[1][1]);
 			APPLY_EQUATION(elements[2][0]);
 			APPLY_EQUATION(elements[2][1]);
-			result = r;
-		} break;
+			return r;
+		}
 
-		case Variant::QUAT: {
-			// Get the quaternian for the initial and delta values
-			Quat i = initial_val;
-			Quat d = delta_val;
-			Quat r;
+		case Variant::QUATERNION: {
+			Quaternion i = p_initial_val;
+			Quaternion d = p_delta_val;
+			Quaternion r;
 
-			// Execute the equation on the quaternian values and mutate the r quaternian
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
 			APPLY_EQUATION(z);
 			APPLY_EQUATION(w);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::AABB: {
-			// Get the AABB's for the initial and delta values
-			AABB i = initial_val;
-			AABB d = delta_val;
+			AABB i = p_initial_val;
+			AABB d = p_delta_val;
 			AABB r;
 
-			// Execute the equation for the position and size of the AABB's and mutate the r AABB
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(position.x);
 			APPLY_EQUATION(position.y);
 			APPLY_EQUATION(position.z);
 			APPLY_EQUATION(size.x);
 			APPLY_EQUATION(size.y);
 			APPLY_EQUATION(size.z);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::BASIS: {
-			// Get the basis for initial and delta values
-			Basis i = initial_val;
-			Basis d = delta_val;
+			Basis i = p_initial_val;
+			Basis d = p_delta_val;
 			Basis r;
 
-			// Execute the equation on all the basis and mutate the r basis
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(elements[0][0]);
 			APPLY_EQUATION(elements[0][1]);
 			APPLY_EQUATION(elements[0][2]);
@@ -568,17 +453,14 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 			APPLY_EQUATION(elements[2][0]);
 			APPLY_EQUATION(elements[2][1]);
 			APPLY_EQUATION(elements[2][2]);
-			result = r;
-		} break;
+			return r;
+		}
 
-		case Variant::TRANSFORM: {
-			// Get the transforms for the initial and delta values
-			Transform i = initial_val;
-			Transform d = delta_val;
-			Transform r;
+		case Variant::TRANSFORM3D: {
+			Transform3D i = p_initial_val;
+			Transform3D d = p_delta_val;
+			Transform3D r;
 
-			// Execute the equation for each of the transforms and their origin and mutate the r transform
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(basis.elements[0][0]);
 			APPLY_EQUATION(basis.elements[0][1]);
 			APPLY_EQUATION(basis.elements[0][2]);
@@ -591,634 +473,67 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 			APPLY_EQUATION(origin.x);
 			APPLY_EQUATION(origin.y);
 			APPLY_EQUATION(origin.z);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::COLOR: {
-			// Get the Color for initial and delta value
-			Color i = initial_val;
-			Color d = delta_val;
+			Color i = p_initial_val;
+			Color d = p_delta_val;
 			Color r;
 
-			// Apply the equation on the Color RGBA, and mutate the r color
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(r);
 			APPLY_EQUATION(g);
 			APPLY_EQUATION(b);
 			APPLY_EQUATION(a);
-			result = r;
-		} break;
-
-		default: {
-			// If unknown, just return the initial value
-			result = initial_val;
-		} break;
-	};
-#undef APPLY_EQUATION
-	// Return the result that was computed
-	return result;
-}
-
-bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) {
-	// Get the object we want to apply the new value to
-	Object *object = ObjectDB::get_instance(p_data.id);
-	ERR_FAIL_COND_V(object == nullptr, false);
-
-	// What kind of data are we mutating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case FOLLOW_PROPERTY:
-		case TARGETING_PROPERTY: {
-			// Simply set the property on the object
-			bool valid = false;
-			object->set_indexed(p_data.key, value, &valid);
-			return valid;
+			return r;
 		}
 
-		case INTER_METHOD:
-		case FOLLOW_METHOD:
-		case TARGETING_METHOD: {
-			// We want to call the method on the target object
-			Callable::CallError error;
-
-			// Do we have a non-nil value passed in?
-			if (value.get_type() != Variant::NIL) {
-				// Pass it as an argument to the function call
-				Variant *arg[1] = { &value };
-				object->call(p_data.key[0], (const Variant **)arg, 1, error);
-			} else {
-				// Don't pass any argument
-				object->call(p_data.key[0], nullptr, 0, error);
-			}
-
-			// Did we get an error from the function call?
-			return error.error == Callable::CallError::CALL_OK;
+		default: {
+			return p_initial_val;
 		}
-
-		case INTER_CALLBACK:
-			// Nothing to apply for a callback
-			break;
 	};
-	// No issues found!
-	return true;
-}
-
-void Tween::_tween_process(float p_delta) {
-	// Process all of the pending commands
-	_process_pending_commands();
-
-	// If the scale is 0, make no progress on the tweens
-	if (speed_scale == 0) {
-		return;
-	}
-
-	// Update the delta and whether we are pending an update
-	p_delta *= speed_scale;
-	pending_update++;
-
-	// Are we repeating the interpolations?
-	if (repeat) {
-		// For each interpolation...
-		bool repeats_finished = true;
-		for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-			// Get the data from it
-			InterpolateData &data = E->get();
-
-			// Is not finished?
-			if (!data.finish) {
-				// We aren't finished yet, no need to check the rest
-				repeats_finished = false;
-				break;
-			}
-		}
-
-		// If we are all finished, we can reset all of the tweens
-		if (repeats_finished) {
-			reset_all();
-		}
-	}
-
-	// Are all of the tweens complete?
-	int any_unfinished = 0;
-
-	// For each tween we wish to interpolate...
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the data from it
-		InterpolateData &data = E->get();
-
-		// Is the data not active or already finished? No need to go any further
-		if (!data.active || data.finish) {
-			continue;
-		}
-
-		// Track if we hit one that isn't finished yet
-		any_unfinished++;
-
-		// Get the target object for this interpolation
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Are we still delaying this tween?
-		bool prev_delaying = data.elapsed <= data.delay;
-		data.elapsed += p_delta;
-		if (data.elapsed < data.delay) {
-			continue;
-		} else if (prev_delaying) {
-			// We can apply the tween's value to the data and emit that the tween has started
-			_apply_tween_value(data, data.initial_val);
-			emit_signal("tween_started", object, NodePath(Vector<StringName>(), data.key, false));
-		}
-
-		// Are we at the end of the tween?
-		if (data.elapsed > (data.delay + data.duration)) {
-			// Set the elapsed time to the end and mark this one as finished
-			data.elapsed = data.delay + data.duration;
-			data.finish = true;
-		}
-
-		// Are we interpolating a callback?
-		if (data.type == INTER_CALLBACK) {
-			// Is the tween completed?
-			if (data.finish) {
-				// Are we calling this callback deferred or immediately?
-				if (data.call_deferred) {
-					// Run the deferred function callback, applying the correct number of arguments
-					switch (data.args) {
-						case 0:
-							object->call_deferred(data.key[0]);
-							break;
-						case 1:
-							object->call_deferred(data.key[0], data.arg[0]);
-							break;
-						case 2:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1]);
-							break;
-						case 3:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2]);
-							break;
-						case 4:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3]);
-							break;
-						case 5:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3], data.arg[4]);
-							break;
-					}
-				} else {
-					// Call the function directly with the arguments
-					Callable::CallError error;
-					Variant *arg[5] = {
-						&data.arg[0],
-						&data.arg[1],
-						&data.arg[2],
-						&data.arg[3],
-						&data.arg[4],
-					};
-					object->call(data.key[0], (const Variant **)arg, data.args, error);
-				}
-			}
-		} else {
-			// We can apply the value directly
-			Variant result = _run_equation(data);
-			_apply_tween_value(data, result);
-
-			// Emit that the tween has taken a step
-			emit_signal("tween_step", object, NodePath(Vector<StringName>(), data.key, false), data.elapsed, result);
-		}
-
-		// Is the tween now finished?
-		if (data.finish) {
-			// Set it to the final value directly
-			Variant final_val = _get_final_val(data);
-			_apply_tween_value(data, final_val);
-
-			// Mark the tween as completed and emit the signal
-			data.elapsed = 0;
-			emit_signal("tween_completed", object, NodePath(Vector<StringName>(), data.key, false));
-
-			// If we are not repeating the tween, remove it
-			if (!repeat) {
-				call_deferred("_remove_by_uid", data.uid);
-				any_unfinished--;
-			}
-		}
-	}
-	// One less update left to go
-	pending_update--;
-
-	// If all tweens are completed, we no longer need to be active
-	if (any_unfinished == 0) {
-		set_active(false);
-		emit_signal("tween_all_completed");
-	}
-}
-
-void Tween::set_tween_process_mode(TweenProcessMode p_mode) {
-	tween_process_mode = p_mode;
-}
-
-Tween::TweenProcessMode Tween::get_tween_process_mode() const {
-	return tween_process_mode;
-}
-
-bool Tween::is_active() const {
-	return is_processing_internal() || is_physics_processing_internal();
-}
-
-void Tween::set_active(bool p_active) {
-	// Do nothing if it's the same active mode that we currently are
-	if (is_active() == p_active) {
-		return;
-	}
-
-	// Depending on physics or idle, set processing
-	switch (tween_process_mode) {
-		case TWEEN_PROCESS_IDLE:
-			set_process_internal(p_active);
-			break;
-		case TWEEN_PROCESS_PHYSICS:
-			set_physics_process_internal(p_active);
-			break;
-	}
-}
-
-bool Tween::is_repeat() const {
-	return repeat;
-}
-
-void Tween::set_repeat(bool p_repeat) {
-	repeat = p_repeat;
-}
-
-void Tween::set_speed_scale(float p_speed) {
-	speed_scale = p_speed;
-}
-
-float Tween::get_speed_scale() const {
-	return speed_scale;
-}
-
-void Tween::start() {
-	ERR_FAIL_COND_MSG(!is_inside_tree(), "Tween was not added to the SceneTree!");
-
-	// Are there any pending updates?
-	if (pending_update != 0) {
-		// Start the tweens after deferring
-		call_deferred("start");
-		return;
-	}
-
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		InterpolateData &data = E->get();
-		data.active = true;
-	}
-	pending_update--;
-
-	// We want to be activated
-	set_active(true);
-
-	// Don't resume from current position if stop_all() function has been used
-	if (was_stopped) {
-		seek(0);
-	}
-	was_stopped = false;
-}
-
-void Tween::reset(Object *p_object, StringName p_key) {
-	// Find all interpolations that use the same object and target string
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Do we have the correct object and key?
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			// Reset the tween to the initial state
-			data.elapsed = 0;
-			data.finish = false;
-
-			// Also apply the initial state if there isn't a delay
-			if (data.delay == 0) {
-				_apply_tween_value(data, data.initial_val);
-			}
-		}
-	}
-	pending_update--;
-}
-
-void Tween::reset_all() {
-	// Go through all interpolations
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target data and set it back to the initial state
-		InterpolateData &data = E->get();
-		data.elapsed = 0;
-		data.finish = false;
-
-		// If there isn't a delay, apply the value to the object
-		if (data.delay == 0) {
-			_apply_tween_value(data, data.initial_val);
-		}
-	}
-	pending_update--;
-}
-
-void Tween::stop(Object *p_object, StringName p_key) {
-	// Find the tween that has the given target object and string key
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the object the tween is targeting
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Is this the correct object and does it have the given key?
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			// Disable the tween
-			data.active = false;
-		}
-	}
-	pending_update--;
-}
-
-void Tween::stop_all() {
-	// We no longer need to be active since all tweens have been stopped
-	set_active(false);
-	was_stopped = true;
-	// For each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Simply set it inactive
-		InterpolateData &data = E->get();
-		data.active = false;
-	}
-	pending_update--;
-}
-
-void Tween::resume(Object *p_object, StringName p_key) {
-	// We need to be activated
-	// TODO: What if no tween is found??
-	set_active(true);
-
-	// Find the tween that uses the given target object and string key
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Grab the object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// If the object and string key match, activate it
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			data.active = true;
-		}
-	}
-	pending_update--;
-}
-
-void Tween::resume_all() {
-	// Set ourselves active so we can process tweens
-	// TODO: What if there are no tweens? We get set to active for no reason!
-	set_active(true);
-
-	// For each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Simply grab it and set it to active
-		InterpolateData &data = E->get();
-		data.active = true;
-	}
-	pending_update--;
-}
-
-void Tween::remove(Object *p_object, StringName p_key) {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("remove", p_object, p_key);
-		return;
-	}
-
-	// For each interpolation...
-	List<List<InterpolateData>::Element *> for_removal;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// If the target object and string key match, queue it for removal
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			for_removal.push_back(E);
-		}
-	}
-
-	// For each interpolation we wish to remove...
-	for (List<List<InterpolateData>::Element *>::Element *E = for_removal.front(); E; E = E->next()) {
-		// Erase it
-		interpolates.erase(E->get());
-	}
-}
-
-void Tween::_remove_by_uid(int uid) {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("_remove_by_uid", uid);
-		return;
-	}
-
-	// Find the interpolation that matches the given UID
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		if (uid == E->get().uid) {
-			// It matches, erase it and stop looking
-			E->erase();
-			break;
-		}
-	}
-}
-
-void Tween::_push_interpolate_data(InterpolateData &p_data) {
-	pending_update++;
-
-	// Add the new interpolation
-	p_data.uid = ++uid;
-	interpolates.push_back(p_data);
-
-	pending_update--;
+#undef APPLY_EQUATION
 }
 
-void Tween::remove_all() {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("remove_all");
-		return;
-	}
-	// We no longer need to be active
-	set_active(false);
-
-	// Clear out all interpolations and reset the uid
-	interpolates.clear();
-	uid = 0;
-}
-
-void Tween::seek(real_t p_time) {
-	// Go through each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target data
-		InterpolateData &data = E->get();
-
-		// Update the elapsed data to be set to the target time
-		data.elapsed = p_time;
-
-		// Are we at the end?
-		if (data.elapsed < data.delay) {
-			// There is still time left to go
-			data.finish = false;
-			continue;
-		} else if (data.elapsed >= (data.delay + data.duration)) {
-			// We are past the end of it, set the elapsed time to the end and mark as finished
-			data.elapsed = (data.delay + data.duration);
-			data.finish = true;
-		} else {
-			// We are not finished with this interpolation yet
-			data.finish = false;
-		}
-
-		// If we are a callback, do nothing special
-		if (data.type == INTER_CALLBACK) {
-			continue;
+Variant Tween::calculate_delta_value(Variant p_intial_val, Variant p_final_val) {
+	switch (p_intial_val.get_type()) {
+		case Variant::BOOL: {
+			return (int)p_final_val - (int)p_intial_val;
 		}
 
-		// Run the equation on the data and apply the value
-		Variant result = _run_equation(data);
-		_apply_tween_value(data, result);
-	}
-	pending_update--;
-}
-
-real_t Tween::tell() const {
-	// We want to grab the position of the furthest along tween
-	pending_update++;
-	real_t pos = 0.0;
-
-	// For each interpolation...
-	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the data and figure out if its position is further along than the previous ones
-		const InterpolateData &data = E->get();
-		if (data.elapsed > pos) {
-			// Save it if so
-			pos = data.elapsed;
+		case Variant::RECT2: {
+			Rect2 i = p_intial_val;
+			Rect2 f = p_final_val;
+			return Rect2(f.position - i.position, f.size - i.size);
 		}
-	}
-	pending_update--;
-	return pos;
-}
-
-real_t Tween::get_runtime() const {
-	// If the tween isn't moving, it'll last forever
-	if (speed_scale == 0) {
-		return INFINITY;
-	}
 
-	pending_update++;
-
-	// For each interpolation...
-	real_t runtime = 0.0;
-	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the tween data and see if it's runtime is greater than the previous tweens
-		const InterpolateData &data = E->get();
-		real_t t = data.delay + data.duration;
-		if (t > runtime) {
-			// This is the longest running tween
-			runtime = t;
+		case Variant::RECT2I: {
+			Rect2i i = p_intial_val;
+			Rect2i f = p_final_val;
+			return Rect2i(f.position - i.position, f.size - i.size);
 		}
-	}
-	pending_update--;
-
-	// Adjust the runtime for the current speed scale
-	return runtime / speed_scale;
-}
-
-bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {
-	// Get the initial, final, and delta values
-	const Variant &initial_val = p_initial_val;
-	const Variant &final_val = p_final_val;
-	Variant &delta_val = p_delta_val;
-
-	// What kind of data are we interpolating?
-	switch (initial_val.get_type()) {
-		case Variant::BOOL:
-			// We'll treat booleans just like integers
-		case Variant::INT:
-			// Compute the integer delta
-			delta_val = (int)final_val - (int)initial_val;
-			break;
-
-		case Variant::FLOAT:
-			// Convert to FLOAT and find the delta
-			delta_val = (real_t)final_val - (real_t)initial_val;
-			break;
-
-		case Variant::VECTOR2:
-			// Convert to Vectors and find the delta
-			delta_val = final_val.operator Vector2() - initial_val.operator Vector2();
-			break;
-
-		case Variant::RECT2: {
-			// Build a new Rect2 and use the new position and sizes to make a delta
-			Rect2 i = initial_val;
-			Rect2 f = final_val;
-			delta_val = Rect2(f.position - i.position, f.size - i.size);
-		} break;
-
-		case Variant::VECTOR3:
-			// Convert to Vectors and find the delta
-			delta_val = final_val.operator Vector3() - initial_val.operator Vector3();
-			break;
 
 		case Variant::TRANSFORM2D: {
-			// Build a new transform which is the difference between the initial and final values
-			Transform2D i = initial_val;
-			Transform2D f = final_val;
-			Transform2D d = Transform2D();
-			d[0][0] = f.elements[0][0] - i.elements[0][0];
-			d[0][1] = f.elements[0][1] - i.elements[0][1];
-			d[1][0] = f.elements[1][0] - i.elements[1][0];
-			d[1][1] = f.elements[1][1] - i.elements[1][1];
-			d[2][0] = f.elements[2][0] - i.elements[2][0];
-			d[2][1] = f.elements[2][1] - i.elements[2][1];
-			delta_val = d;
-		} break;
-
-		case Variant::QUAT:
-			// Convert to quaternianls and find the delta
-			delta_val = final_val.operator Quat() - initial_val.operator Quat();
-			break;
+			Transform2D i = p_intial_val;
+			Transform2D f = p_final_val;
+			return Transform2D(f.elements[0][0] - i.elements[0][0],
+					f.elements[0][1] - i.elements[0][1],
+					f.elements[1][0] - i.elements[1][0],
+					f.elements[1][1] - i.elements[1][1],
+					f.elements[2][0] - i.elements[2][0],
+					f.elements[2][1] - i.elements[2][1]);
+		}
 
 		case Variant::AABB: {
-			// Build a new AABB and use the new position and sizes to make a delta
-			AABB i = initial_val;
-			AABB f = final_val;
-			delta_val = AABB(f.position - i.position, f.size - i.size);
-		} break;
+			AABB i = p_intial_val;
+			AABB f = p_final_val;
+			return AABB(f.position - i.position, f.size - i.size);
+		}
 
 		case Variant::BASIS: {
-			// Build a new basis which is the delta between the initial and final values
-			Basis i = initial_val;
-			Basis f = final_val;
-			delta_val = Basis(f.elements[0][0] - i.elements[0][0],
+			Basis i = p_intial_val;
+			Basis f = p_final_val;
+			return Basis(f.elements[0][0] - i.elements[0][0],
 					f.elements[0][1] - i.elements[0][1],
 					f.elements[0][2] - i.elements[0][2],
 					f.elements[1][0] - i.elements[1][0],
@@ -1227,14 +542,12 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 					f.elements[2][0] - i.elements[2][0],
 					f.elements[2][1] - i.elements[2][1],
 					f.elements[2][2] - i.elements[2][2]);
-		} break;
-
-		case Variant::TRANSFORM: {
-			// Build a new transform which is the difference between the initial and final values
-			Transform i = initial_val;
-			Transform f = final_val;
-			Transform d;
-			d.set(f.basis.elements[0][0] - i.basis.elements[0][0],
+		}
+
+		case Variant::TRANSFORM3D: {
+			Transform3D i = p_intial_val;
+			Transform3D f = p_final_val;
+			return Transform3D(f.basis.elements[0][0] - i.basis.elements[0][0],
 					f.basis.elements[0][1] - i.basis.elements[0][1],
 					f.basis.elements[0][2] - i.basis.elements[0][2],
 					f.basis.elements[1][0] - i.basis.elements[1][0],
@@ -1246,569 +559,342 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 					f.origin.x - i.origin.x,
 					f.origin.y - i.origin.y,
 					f.origin.z - i.origin.z);
-
-			delta_val = d;
-		} break;
-
-		case Variant::COLOR: {
-			// Make a new color which is the difference between each the color's RGBA attributes
-			Color i = initial_val;
-			Color f = final_val;
-			delta_val = Color(f.r - i.r, f.g - i.g, f.b - i.b, f.a - i.a);
-		} break;
+		}
 
 		default: {
-			static Variant::Type supported_types[] = {
-				Variant::BOOL,
-				Variant::INT,
-				Variant::FLOAT,
-				Variant::VECTOR2,
-				Variant::RECT2,
-				Variant::VECTOR3,
-				Variant::TRANSFORM2D,
-				Variant::QUAT,
-				Variant::AABB,
-				Variant::BASIS,
-				Variant::TRANSFORM,
-				Variant::COLOR,
-			};
-
-			int length = *(&supported_types + 1) - supported_types;
-			String error_msg = "Invalid parameter type. Supported types are: ";
-			for (int i = 0; i < length; i++) {
-				if (i != 0) {
-					error_msg += ", ";
-				}
-				error_msg += Variant::get_type_name(supported_types[i]);
-			}
-			error_msg += ".";
-			ERR_PRINT(error_msg);
-			return false;
+			return Variant::evaluate(Variant::OP_SUBTRACT, p_final_val, p_intial_val);
 		}
 	};
-	return true;
 }
 
-void Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// TODO: Add initialization+implementation for remaining interpolation types
-	// TODO: Fix this method's organization to take advantage of the type
-
-	// Make a new interpolation data
-	InterpolateData data;
-	data.active = true;
-	data.type = p_interpolation_type;
-	data.finish = false;
-	data.elapsed = 0;
+void Tween::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("tween_property", "object", "property", "final_val", "duration"), &Tween::tween_property);
+	ClassDB::bind_method(D_METHOD("tween_interval", "time"), &Tween::tween_interval);
+	ClassDB::bind_method(D_METHOD("tween_callback", "callback"), &Tween::tween_callback);
+	ClassDB::bind_method(D_METHOD("tween_method", "method", "from", "to", "duration"), &Tween::tween_method);
+
+	ClassDB::bind_method(D_METHOD("custom_step", "delta"), &Tween::custom_step);
+	ClassDB::bind_method(D_METHOD("stop"), &Tween::stop);
+	ClassDB::bind_method(D_METHOD("pause"), &Tween::pause);
+	ClassDB::bind_method(D_METHOD("play"), &Tween::play);
+	ClassDB::bind_method(D_METHOD("kill"), &Tween::kill);
+
+	ClassDB::bind_method(D_METHOD("is_running"), &Tween::is_running);
+	ClassDB::bind_method(D_METHOD("is_valid"), &Tween::is_valid);
+	ClassDB::bind_method(D_METHOD("bind_node", "node"), &Tween::bind_node);
+	ClassDB::bind_method(D_METHOD("set_process_mode", "mode"), &Tween::set_process_mode);
+	ClassDB::bind_method(D_METHOD("set_pause_mode", "mode"), &Tween::set_pause_mode);
+
+	ClassDB::bind_method(D_METHOD("set_parallel", "parallel"), &Tween::set_parallel, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("set_loops", "loops"), &Tween::set_loops, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &Tween::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &Tween::set_ease);
 
-	// Validate and apply interpolation data
+	ClassDB::bind_method(D_METHOD("parallel"), &Tween::parallel);
+	ClassDB::bind_method(D_METHOD("chain"), &Tween::chain);
 
-	// Give it the object
-	ERR_FAIL_COND_MSG(p_object == nullptr, "Invalid object provided to Tween.");
-	data.id = p_object->get_instance_id();
+	ClassDB::bind_method(D_METHOD("interpolate_value", "trans_type", "ease_type", "elapsed_time", "initial_value", "delta_value", "duration"), &Tween::interpolate_variant);
 
-	// Validate the initial and final values
-	ERR_FAIL_COND_MSG(p_initial_val.get_type() != p_final_val.get_type(), "Initial value type '" + Variant::get_type_name(p_initial_val.get_type()) + "' does not match final value type '" + Variant::get_type_name(p_final_val.get_type()) + "'.");
-	data.initial_val = p_initial_val;
-	data.final_val = p_final_val;
+	ADD_SIGNAL(MethodInfo("step_finished", PropertyInfo(Variant::INT, "idx")));
+	ADD_SIGNAL(MethodInfo("loop_finished", PropertyInfo(Variant::INT, "loop_count")));
+	ADD_SIGNAL(MethodInfo("finished"));
 
-	// Check the Duration
-	ERR_FAIL_COND_MSG(p_duration < 0, "Only non-negative duration values allowed in Tweens.");
-	data.duration = p_duration;
+	BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
+	BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
 
-	// Tween Delay
-	ERR_FAIL_COND_MSG(p_delay < 0, "Only non-negative delay values allowed in Tweens.");
-	data.delay = p_delay;
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_BOUND);
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_STOP);
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_PROCESS);
 
-	// Transition type
-	ERR_FAIL_COND_MSG(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, "Invalid transition type provided to Tween.");
-	data.trans_type = p_trans_type;
+	BIND_ENUM_CONSTANT(TRANS_LINEAR);
+	BIND_ENUM_CONSTANT(TRANS_SINE);
+	BIND_ENUM_CONSTANT(TRANS_QUINT);
+	BIND_ENUM_CONSTANT(TRANS_QUART);
+	BIND_ENUM_CONSTANT(TRANS_QUAD);
+	BIND_ENUM_CONSTANT(TRANS_EXPO);
+	BIND_ENUM_CONSTANT(TRANS_ELASTIC);
+	BIND_ENUM_CONSTANT(TRANS_CUBIC);
+	BIND_ENUM_CONSTANT(TRANS_CIRC);
+	BIND_ENUM_CONSTANT(TRANS_BOUNCE);
+	BIND_ENUM_CONSTANT(TRANS_BACK);
 
-	// Easing type
-	ERR_FAIL_COND_MSG(p_ease_type < 0 || p_ease_type >= EASE_COUNT, "Invalid easing type provided to Tween.");
-	data.ease_type = p_ease_type;
+	BIND_ENUM_CONSTANT(EASE_IN);
+	BIND_ENUM_CONSTANT(EASE_OUT);
+	BIND_ENUM_CONSTANT(EASE_IN_OUT);
+	BIND_ENUM_CONSTANT(EASE_OUT_IN);
+}
 
-	// Is the property defined?
-	if (p_property) {
-		// Check that the object actually contains the given property
-		bool prop_valid = false;
-		p_object->get_indexed(p_property->get_subnames(), &prop_valid);
-		ERR_FAIL_COND_MSG(!prop_valid, "Tween target object has no property named: " + p_property->get_concatenated_subnames() + ".");
+Ref<PropertyTweener> PropertyTweener::from(Variant p_value) {
+	initial_val = p_value;
+	do_continue = false;
+	return this;
+}
 
-		data.key = p_property->get_subnames();
-		data.concatenated_key = p_property->get_concatenated_subnames();
-	}
+Ref<PropertyTweener> PropertyTweener::from_current() {
+	do_continue = false;
+	return this;
+}
 
-	// Is the method defined?
-	if (p_method) {
-		// Does the object even have the requested method?
-		ERR_FAIL_COND_MSG(!p_object->has_method(*p_method), "Tween target object has no method named: " + *p_method + ".");
+Ref<PropertyTweener> PropertyTweener::as_relative() {
+	relative = true;
+	return this;
+}
 
-		data.key.push_back(*p_method);
-		data.concatenated_key = *p_method;
-	}
+Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {
+	trans_type = p_trans;
+	return this;
+}
 
-	// Is there not a valid delta?
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
-	}
+Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {
+	ease_type = p_ease;
+	return this;
+}
 
-	// Add this interpolation to the total
-	_push_interpolate_data(data);
+Ref<PropertyTweener> PropertyTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
 }
 
-void Tween::interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are busy updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_property", p_object, p_property, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
+void PropertyTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+
+	Object *target_instance = ObjectDB::get_instance(target);
+	if (!target_instance) {
+		WARN_PRINT("Target object freed before starting, aborting Tweener.");
 		return;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND_MSG(p_object == nullptr, vformat("The Tween \"%s\"'s target node is `null`. Is the node reference correct?", get_name()));
-
-	// Get the property from the node path
-	p_property = p_property.get_as_property_path();
-
-	// If no initial value given, grab the initial value from the object
-	// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
-	if (p_initial_val.get_type() == Variant::NIL) {
-		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	if (do_continue) {
+		initial_val = target_instance->get_indexed(property);
 	}
 
-	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
-	}
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+	if (relative) {
+		final_val = Variant::evaluate(Variant::Operator::OP_ADD, initial_val, base_final_val);
 	}
 
-	// Build the interpolation data
-	_build_interpolation(INTER_PROPERTY, p_object, &p_property, nullptr, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
+	delta_val = tween->calculate_delta_value(initial_val, final_val);
 }
 
-void Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are busy updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_method", p_object, p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
+bool PropertyTweener::step(float &r_delta) {
+	if (finished) {
+		// This is needed in case there's a parallel Tweener with longer duration.
+		return false;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND_MSG(p_object == nullptr, vformat("The Tween \"%s\"'s target node is `null`. Is the node reference correct?", get_name()));
-
-	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
+	Object *target_instance = ObjectDB::get_instance(target);
+	if (!target_instance) {
+		return false;
 	}
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
-	}
-
-	// Build the interpolation data
-	_build_interpolation(INTER_METHOD, p_object, nullptr, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-}
+	elapsed_time += r_delta;
 
-void Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
-		return;
+	if (elapsed_time < delay) {
+		r_delta = 0;
+		return true;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND(p_object == nullptr);
-
-	// Duration cannot be negative
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Check whether the object even has the callback
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_callback), "Object has no callback named: " + p_callback + ".");
-
-	// Build a new InterpolationData
-	InterpolateData data;
-	data.active = true;
-	data.type = INTER_CALLBACK;
-	data.finish = false;
-	data.call_deferred = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_callback);
-	data.concatenated_key = p_callback;
-	data.duration = p_duration;
-	data.delay = 0;
-
-	// Add arguments to the interpolation
-	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL) {
-		args = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		args = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		args = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		args = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		args = 1;
+	float time = MIN(elapsed_time - delay, duration);
+	target_instance->set_indexed(property, tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type));
+
+	if (time < duration) {
+		r_delta = 0;
+		return true;
 	} else {
-		args = 0;
+		finished = true;
+		r_delta = elapsed_time - delay - duration;
+		emit_signal(SNAME("finished"));
+		return false;
 	}
-
-	data.args = args;
-	data.arg[0] = p_arg1;
-	data.arg[1] = p_arg2;
-	data.arg[2] = p_arg3;
-	data.arg[3] = p_arg4;
-	data.arg[4] = p_arg5;
-
-	// Add the new interpolation
-	_push_interpolate_data(data);
 }
 
-void Tween::interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_deferred_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
-		return;
+void PropertyTweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+	if (trans_type == Tween::TRANS_MAX) {
+		trans_type = tween->get_trans();
 	}
-
-	// Check that the target object is valid
-	ERR_FAIL_COND(p_object == nullptr);
-
-	// No negative durations allowed
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Confirm the callback exists on the object
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_callback), "Object has no callback named: " + p_callback + ".");
-
-	// Create a new InterpolateData for the callback
-	InterpolateData data;
-	data.active = true;
-	data.type = INTER_CALLBACK;
-	data.finish = false;
-	data.call_deferred = true;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_callback);
-	data.concatenated_key = p_callback;
-	data.duration = p_duration;
-	data.delay = 0;
-
-	// Collect arguments for the callback
-	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL) {
-		args = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		args = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		args = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		args = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		args = 1;
-	} else {
-		args = 0;
+	if (ease_type == Tween::EASE_MAX) {
+		ease_type = tween->get_ease();
 	}
+}
 
-	data.args = args;
-	data.arg[0] = p_arg1;
-	data.arg[1] = p_arg2;
-	data.arg[2] = p_arg3;
-	data.arg[3] = p_arg4;
-	data.arg[4] = p_arg5;
+void PropertyTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("from", "value"), &PropertyTweener::from);
+	ClassDB::bind_method(D_METHOD("from_current"), &PropertyTweener::from_current);
+	ClassDB::bind_method(D_METHOD("as_relative"), &PropertyTweener::as_relative);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &PropertyTweener::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &PropertyTweener::set_ease);
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &PropertyTweener::set_delay);
+}
 
-	// Add the new interpolation
-	_push_interpolate_data(data);
+PropertyTweener::PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
+	target = p_target->get_instance_id();
+	property = p_property.get_as_property_path().get_subnames();
+	initial_val = p_target->get_indexed(property);
+	base_final_val = p_to;
+	final_val = base_final_val;
+	duration = p_duration;
 }
 
-void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("follow_property", p_object, p_property, p_initial_val, p_target, p_target_property, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
+PropertyTweener::PropertyTweener() {
+	ERR_FAIL_MSG("Can't create empty PropertyTweener. Use get_tree().tween_property() or tween_property() instead.");
+}
 
-	// Get the two properties from their paths
-	p_property = p_property.get_as_property_path();
-	p_target_property = p_target_property.get_as_property_path();
+void IntervalTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// If no initial value is given, grab it from the source object
-	// TODO: Is this documented? It's really helpful for decluttering tweens
-	if (p_initial_val.get_type() == Variant::NIL) {
-		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+bool IntervalTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
 	}
 
-	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
+	elapsed_time += r_delta;
+
+	if (elapsed_time < duration) {
+		r_delta = 0;
+		return true;
+	} else {
+		finished = true;
+		r_delta = elapsed_time - duration;
+		emit_signal(SNAME("finished"));
+		return false;
 	}
+}
 
-	// Confirm the source and target objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_target == nullptr);
+IntervalTweener::IntervalTweener(float p_time) {
+	duration = p_time;
+}
 
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
+IntervalTweener::IntervalTweener() {
+	ERR_FAIL_MSG("Can't create empty IntervalTweener. Use get_tree().tween_interval() instead.");
+}
 
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
+Ref<CallbackTweener> CallbackTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
+}
 
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
+void CallbackTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// Confirm the source and target objects have the desired properties
-	bool prop_valid = false;
-	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
-	ERR_FAIL_COND(!prop_valid);
+bool CallbackTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
+	}
 
-	bool target_prop_valid = false;
-	Variant target_val = p_target->get_indexed(p_target_property.get_subnames(), &target_prop_valid);
-	ERR_FAIL_COND(!target_prop_valid);
+	elapsed_time += r_delta;
+	if (elapsed_time >= delay) {
+		Variant result;
+		Callable::CallError ce;
+		callback.call(nullptr, 0, result, ce);
+		if (ce.error != Callable::CallError::CALL_OK) {
+			ERR_FAIL_V_MSG(false, "Error calling method from CallbackTweener: " + Variant::get_call_error_text(this, callback.get_method(), nullptr, 0, ce));
+		}
 
-	// Convert target INT to FLOAT since it is better for interpolation
-	if (target_val.get_type() == Variant::INT) {
-		target_val = target_val.operator real_t();
+		finished = true;
+		r_delta = elapsed_time - delay;
+		emit_signal(SNAME("finished"));
+		return false;
 	}
 
-	// Verify that the target value and initial value are the same type
-	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
-
-	// Create a new InterpolateData
-	InterpolateData data;
-	data.active = true;
-	data.type = FOLLOW_PROPERTY;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the InterpolateData it's configuration
-	data.id = p_object->get_instance_id();
-	data.key = p_property.get_subnames();
-	data.concatenated_key = p_property.get_concatenated_subnames();
-	data.initial_val = p_initial_val;
-	data.target_id = p_target->get_instance_id();
-	data.target_key = p_target_property.get_subnames();
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Add the interpolation
-	_push_interpolate_data(data);
-}
-
-void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("follow_method", p_object, p_method, p_initial_val, p_target, p_target_method, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
-	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
-	}
+	r_delta = 0;
+	return true;
+}
 
-	// Verify the source and target objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_target == nullptr);
+void CallbackTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &CallbackTweener::set_delay);
+}
 
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
+CallbackTweener::CallbackTweener(Callable p_callback) {
+	callback = p_callback;
+}
 
-	// Ensure that the transition and ease types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
+CallbackTweener::CallbackTweener() {
+	ERR_FAIL_MSG("Can't create empty CallbackTweener. Use get_tree().tween_callback() instead.");
+}
 
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
+Ref<MethodTweener> MethodTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
+}
 
-	// Confirm both objects have the target methods
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_method), "Object has no method named: " + p_method + ".");
-	ERR_FAIL_COND_MSG(!p_target->has_method(p_target_method), "Target has no method named: " + p_target_method + ".");
+Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {
+	trans_type = p_trans;
+	return this;
+}
 
-	// Call the method to get the target value
-	Callable::CallError error;
-	Variant target_val = p_target->call(p_target_method, nullptr, 0, error);
-	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
+Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {
+	ease_type = p_ease;
+	return this;
+}
 
-	// Convert target INT values to FLOAT as they are better for interpolation
-	if (target_val.get_type() == Variant::INT) {
-		target_val = target_val.operator real_t();
-	}
-	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
-
-	// Make the new InterpolateData for the method follow
-	InterpolateData data;
-	data.active = true;
-	data.type = FOLLOW_METHOD;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_method);
-	data.concatenated_key = p_method;
-	data.initial_val = p_initial_val;
-	data.target_id = p_target->get_instance_id();
-	data.target_key.push_back(p_target_method);
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Add the new interpolation
-	_push_interpolate_data(data);
-}
-
-void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("targeting_property", p_object, p_property, p_initial, p_initial_property, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
-	// Grab the target property and the target property
-	p_property = p_property.get_as_property_path();
-	p_initial_property = p_initial_property.get_as_property_path();
+void MethodTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// Convert the initial INT values to FLOAT as they are better for Interpolation
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+bool MethodTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
 	}
 
-	// Verify both objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_initial == nullptr);
-
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
-
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
+	elapsed_time += r_delta;
 
-	// Ensure the initial and target properties exist on their objects
-	bool prop_valid = false;
-	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
-	ERR_FAIL_COND(!prop_valid);
-
-	bool initial_prop_valid = false;
-	Variant initial_val = p_initial->get_indexed(p_initial_property.get_subnames(), &initial_prop_valid);
-	ERR_FAIL_COND(!initial_prop_valid);
-
-	// Convert the initial INT value to FLOAT as it is better for interpolation
-	if (initial_val.get_type() == Variant::INT) {
-		initial_val = initial_val.operator real_t();
-	}
-	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
-
-	// Build the InterpolateData object
-	InterpolateData data;
-	data.active = true;
-	data.type = TARGETING_PROPERTY;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key = p_property.get_subnames();
-	data.concatenated_key = p_property.get_concatenated_subnames();
-	data.target_id = p_initial->get_instance_id();
-	data.target_key = p_initial_property.get_subnames();
-	data.initial_val = initial_val;
-	data.final_val = p_final_val;
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Ensure there is a valid delta
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
+	if (elapsed_time < delay) {
+		r_delta = 0;
+		return true;
 	}
 
-	// Add the interpolation
-	_push_interpolate_data(data);
-}
+	float time = MIN(elapsed_time - delay, duration);
+	Variant current_val = tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type);
+	const Variant **argptr = (const Variant **)alloca(sizeof(Variant *));
+	argptr[0] = &current_val;
 
-void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("targeting_method", p_object, p_method, p_initial, p_initial_method, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
+	Variant result;
+	Callable::CallError ce;
+	callback.call(argptr, 1, result, ce);
+	if (ce.error != Callable::CallError::CALL_OK) {
+		ERR_FAIL_V_MSG(false, "Error calling method from MethodTweener: " + Variant::get_call_error_text(this, callback.get_method(), argptr, 1, ce));
 	}
 
-	// Convert final INT values to FLOAT as they are better for interpolation
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+	if (time < duration) {
+		r_delta = 0;
+		return true;
+	} else {
+		finished = true;
+		r_delta = elapsed_time - delay - duration;
+		emit_signal(SNAME("finished"));
+		return false;
 	}
+}
 
-	// Make sure the given objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_initial == nullptr);
-
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
-
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
-
-	// Make sure both objects have the given method
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_method), "Object has no method named: " + p_method + ".");
-	ERR_FAIL_COND_MSG(!p_initial->has_method(p_initial_method), "Initial Object has no method named: " + p_initial_method + ".");
-
-	// Call the method to get the initial value
-	Callable::CallError error;
-	Variant initial_val = p_initial->call(p_initial_method, nullptr, 0, error);
-	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
-
-	// Convert initial INT values to FLOAT as they aer better for interpolation
-	if (initial_val.get_type() == Variant::INT) {
-		initial_val = initial_val.operator real_t();
+void MethodTweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+	if (trans_type == Tween::TRANS_MAX) {
+		trans_type = tween->get_trans();
 	}
-	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
-
-	// Build the new InterpolateData object
-	InterpolateData data;
-	data.active = true;
-	data.type = TARGETING_METHOD;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Configure the data
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_method);
-	data.concatenated_key = p_method;
-	data.target_id = p_initial->get_instance_id();
-	data.target_key.push_back(p_initial_method);
-	data.initial_val = initial_val;
-	data.final_val = p_final_val;
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Ensure there is a valid delta
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
+	if (ease_type == Tween::EASE_MAX) {
+		ease_type = tween->get_ease();
 	}
+}
 
-	// Add the interpolation
-	_push_interpolate_data(data);
+void MethodTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &MethodTweener::set_delay);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &MethodTweener::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &MethodTweener::set_ease);
 }
 
-Tween::Tween() {
+MethodTweener::MethodTweener(Callable p_callback, float p_from, float p_to, float p_duration) {
+	callback = p_callback;
+	initial_val = p_from;
+	delta_val = tween->calculate_delta_value(p_from, p_to);
+	duration = p_duration;
 }
 
-Tween::~Tween() {
+MethodTweener::MethodTweener() {
+	ERR_FAIL_MSG("Can't create empty MethodTweener. Use get_tree().tween_method() instead.");
 }
diff --git a/scene/animation/tween.h b/scene/animation/tween.h
index 142c0c65e0..953d573539 100644
--- a/scene/animation/tween.h
+++ b/scene/animation/tween.h
@@ -31,10 +31,34 @@
 #ifndef TWEEN_H
 #define TWEEN_H
 
-#include "scene/main/node.h"
+#include "core/object/ref_counted.h"
 
-class Tween : public Node {
-	GDCLASS(Tween, Node);
+class Tween;
+class Node;
+
+class Tweener : public RefCounted {
+	GDCLASS(Tweener, RefCounted);
+
+public:
+	virtual void set_tween(Ref<Tween> p_tween);
+	virtual void start() = 0;
+	virtual bool step(float &r_delta) = 0;
+	void clear_tween();
+
+protected:
+	static void _bind_methods();
+	Ref<Tween> tween;
+	float elapsed_time = 0;
+	bool finished = false;
+};
+
+class PropertyTweener;
+class IntervalTweener;
+class CallbackTweener;
+class MethodTweener;
+
+class Tween : public RefCounted {
+	GDCLASS(Tween, RefCounted);
 
 public:
 	enum TweenProcessMode {
@@ -42,6 +66,12 @@ public:
 		TWEEN_PROCESS_IDLE,
 	};
 
+	enum TweenPauseMode {
+		TWEEN_PAUSE_BOUND,
+		TWEEN_PAUSE_STOP,
+		TWEEN_PAUSE_PROCESS,
+	};
+
 	enum TransitionType {
 		TRANS_LINEAR,
 		TRANS_SINE,
@@ -54,8 +84,7 @@ public:
 		TRANS_CIRC,
 		TRANS_BOUNCE,
 		TRANS_BACK,
-
-		TRANS_COUNT,
+		TRANS_MAX
 	};
 
 	enum EaseType {
@@ -63,130 +92,188 @@ public:
 		EASE_OUT,
 		EASE_IN_OUT,
 		EASE_OUT_IN,
-
-		EASE_COUNT,
+		EASE_MAX
 	};
 
 private:
-	enum InterpolateType {
-		INTER_PROPERTY,
-		INTER_METHOD,
-		FOLLOW_PROPERTY,
-		FOLLOW_METHOD,
-		TARGETING_PROPERTY,
-		TARGETING_METHOD,
-		INTER_CALLBACK,
-	};
+	TweenProcessMode process_mode = TweenProcessMode::TWEEN_PROCESS_IDLE;
+	TweenPauseMode pause_mode = TweenPauseMode::TWEEN_PAUSE_STOP;
+	TransitionType default_transition = TransitionType::TRANS_LINEAR;
+	EaseType default_ease = EaseType::EASE_IN_OUT;
+	ObjectID bound_node;
 
-	struct InterpolateData {
-		bool active = false;
-		InterpolateType type = INTER_CALLBACK;
-		bool finish = false;
-		bool call_deferred = false;
-		real_t elapsed = 0.0;
-		ObjectID id;
-		Vector<StringName> key;
-		StringName concatenated_key;
-		Variant initial_val;
-		Variant delta_val;
-		Variant final_val;
-		ObjectID target_id;
-		Vector<StringName> target_key;
-		real_t duration = 0.0;
-		TransitionType trans_type = TransitionType::TRANS_BACK;
-		EaseType ease_type = EaseType::EASE_COUNT;
-		real_t delay = 0.0;
-		int args = 0;
-		Variant arg[5];
-		int uid = 0;
-	};
+	Vector<List<Ref<Tweener>>> tweeners;
+	int current_step = -1;
+	int loops = 1;
+	int loops_done = 0;
+	float speed_scale = 1;
 
-	String autoplay;
-	TweenProcessMode tween_process_mode = TWEEN_PROCESS_IDLE;
-	bool repeat = false;
-	float speed_scale = 1.0;
-	mutable int pending_update = 0;
-	int uid = 0;
-	bool was_stopped = false;
+	bool is_bound = false;
+	bool started = false;
+	bool running = true;
+	bool dead = false;
+	bool valid = false;
+	bool default_parallel = false;
+	bool parallel_enabled = false;
 
-	List<InterpolateData> interpolates;
+	typedef real_t (*interpolater)(real_t t, real_t b, real_t c, real_t d);
+	static interpolater interpolaters[TRANS_MAX][EASE_MAX];
 
-	struct PendingCommand {
-		StringName key;
-		int args = 0;
-		Variant arg[10];
-	};
-	List<PendingCommand> pending_commands;
+	void start_tweeners();
 
-	void _add_pending_command(StringName p_key, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant(), const Variant &p_arg6 = Variant(), const Variant &p_arg7 = Variant(), const Variant &p_arg8 = Variant(), const Variant &p_arg9 = Variant(), const Variant &p_arg10 = Variant());
-	void _process_pending_commands();
+protected:
+	static void _bind_methods();
 
-	typedef real_t (*interpolater)(real_t t, real_t b, real_t c, real_t d);
-	static interpolater interpolaters[TRANS_COUNT][EASE_COUNT];
+public:
+	Ref<PropertyTweener> tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
+	Ref<IntervalTweener> tween_interval(float p_time);
+	Ref<CallbackTweener> tween_callback(Callable p_callback);
+	Ref<MethodTweener> tween_method(Callable p_callback, float p_from, float p_to, float p_duration);
+	void append(Ref<Tweener> p_tweener);
 
-	real_t _run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
-	Variant &_get_delta_val(InterpolateData &p_data);
-	Variant _get_initial_val(const InterpolateData &p_data) const;
-	Variant _get_final_val(const InterpolateData &p_data) const;
-	Variant _run_equation(InterpolateData &p_data);
-	bool _calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val);
-	bool _apply_tween_value(InterpolateData &p_data, Variant &value);
+	bool custom_step(float p_delta);
+	void stop();
+	void pause();
+	void play();
+	void kill();
 
-	void _tween_process(float p_delta);
-	void _remove_by_uid(int uid);
-	void _push_interpolate_data(InterpolateData &p_data);
-	void _build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay);
+	bool is_running();
+	void set_valid(bool p_valid);
+	bool is_valid();
+	void clear();
 
-protected:
-	bool _set(const StringName &p_name, const Variant &p_value);
-	bool _get(const StringName &p_name, Variant &r_ret) const;
-	void _get_property_list(List<PropertyInfo> *p_list) const;
-	void _notification(int p_what);
+	Ref<Tween> bind_node(Node *p_node);
+	Ref<Tween> set_process_mode(TweenProcessMode p_mode);
+	TweenProcessMode get_process_mode();
+	Ref<Tween> set_pause_mode(TweenPauseMode p_mode);
+	TweenPauseMode get_pause_mode();
 
-	static void _bind_methods();
+	Ref<Tween> set_parallel(bool p_parallel);
+	Ref<Tween> set_loops(int p_loops);
+	Ref<Tween> set_speed_scale(float p_speed);
+	Ref<Tween> set_trans(TransitionType p_trans);
+	TransitionType get_trans();
+	Ref<Tween> set_ease(EaseType p_ease);
+	EaseType get_ease();
 
-public:
-	bool is_active() const;
-	void set_active(bool p_active);
-
-	bool is_repeat() const;
-	void set_repeat(bool p_repeat);
-
-	void set_tween_process_mode(TweenProcessMode p_mode);
-	TweenProcessMode get_tween_process_mode() const;
-
-	void set_speed_scale(float p_speed);
-	float get_speed_scale() const;
-
-	void start();
-	void reset(Object *p_object, StringName p_key);
-	void reset_all();
-	void stop(Object *p_object, StringName p_key);
-	void stop_all();
-	void resume(Object *p_object, StringName p_key);
-	void resume_all();
-	void remove(Object *p_object, StringName p_key);
-	void remove_all();
-
-	void seek(real_t p_time);
-	real_t tell() const;
-	real_t get_runtime() const;
-
-	void interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
-	void interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
-	void follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-
-	Tween();
-	~Tween();
+	Ref<Tween> parallel();
+	Ref<Tween> chain();
+
+	real_t run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
+	Variant interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, Tween::TransitionType p_trans, Tween::EaseType p_ease);
+	Variant calculate_delta_value(Variant p_intial_val, Variant p_final_val);
+
+	bool step(float p_delta);
+	bool should_pause();
+
+	Tween() {}
 };
 
+VARIANT_ENUM_CAST(Tween::TweenPauseMode);
 VARIANT_ENUM_CAST(Tween::TweenProcessMode);
 VARIANT_ENUM_CAST(Tween::TransitionType);
 VARIANT_ENUM_CAST(Tween::EaseType);
 
+class PropertyTweener : public Tweener {
+	GDCLASS(PropertyTweener, Tweener);
+
+public:
+	Ref<PropertyTweener> from(Variant p_value);
+	Ref<PropertyTweener> from_current();
+	Ref<PropertyTweener> as_relative();
+	Ref<PropertyTweener> set_trans(Tween::TransitionType p_trans);
+	Ref<PropertyTweener> set_ease(Tween::EaseType p_ease);
+	Ref<PropertyTweener> set_delay(float p_delay);
+
+	void set_tween(Ref<Tween> p_tween) override;
+	void start() override;
+	bool step(float &r_delta) override;
+
+	PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
+	PropertyTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	ObjectID target;
+	Vector<StringName> property;
+	Variant initial_val;
+	Variant base_final_val;
+	Variant final_val;
+	Variant delta_val;
+
+	float duration = 0;
+	Tween::TransitionType trans_type = Tween::TRANS_MAX; // This is set inside set_tween();
+	Tween::EaseType ease_type = Tween::EASE_MAX;
+
+	float delay = 0;
+	bool do_continue = true;
+	bool relative = false;
+};
+
+class IntervalTweener : public Tweener {
+	GDCLASS(IntervalTweener, Tweener);
+
+public:
+	void start() override;
+	bool step(float &r_delta) override;
+
+	IntervalTweener(float p_time);
+	IntervalTweener();
+
+private:
+	float duration = 0;
+};
+
+class CallbackTweener : public Tweener {
+	GDCLASS(CallbackTweener, Tweener);
+
+public:
+	Ref<CallbackTweener> set_delay(float p_delay);
+
+	void start() override;
+	bool step(float &r_delta) override;
+
+	CallbackTweener(Callable p_callback);
+	CallbackTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	Callable callback;
+	float delay = 0;
+};
+
+class MethodTweener : public Tweener {
+	GDCLASS(MethodTweener, Tweener);
+
+public:
+	Ref<MethodTweener> set_trans(Tween::TransitionType p_trans);
+	Ref<MethodTweener> set_ease(Tween::EaseType p_ease);
+	Ref<MethodTweener> set_delay(float p_delay);
+
+	void set_tween(Ref<Tween> p_tween) override;
+	void start() override;
+	bool step(float &r_delta) override;
+
+	MethodTweener(Callable p_callback, float p_from, float p_to, float p_duration);
+	MethodTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	float duration = 0;
+	float delay = 0;
+	Tween::TransitionType trans_type = Tween::TRANS_MAX;
+	Tween::EaseType ease_type = Tween::EASE_MAX;
+
+	Ref<Tween> tween;
+	Variant initial_val;
+	Variant delta_val;
+	Callable callback;
+};
+
 #endif