12 files changed, 3907 insertions, 17 deletions

diff --git a/scene/animation/animation_blend_space.cpp b/scene/animation/animation_blend_space.cpp
new file mode 100644
index 0000000000..44b2d980e2
--- /dev/null
+++ b/scene/animation/animation_blend_space.cpp
@@ -0,0 +1,558 @@
+#include "animation_blend_space.h"
+#include "math/delaunay.h"
+
+void AnimationNodeBlendSpace::add_blend_point(const Ref<AnimationRootNode> &p_node, const Vector2 &p_position, int p_at_index) {
+	ERR_FAIL_COND(blend_points_used >= MAX_BLEND_POINTS);
+	ERR_FAIL_COND(p_node.is_null());
+	ERR_FAIL_COND(p_node->get_parent().is_valid());
+	ERR_FAIL_COND(p_at_index < -1 || p_at_index > blend_points_used);
+
+	if (p_at_index == -1 || p_at_index == blend_points_used) {
+		p_at_index = blend_points_used;
+	} else {
+		for (int i = blend_points_used; i > p_at_index; i--) {
+			blend_points[i] = blend_points[i - 1];
+		}
+		for (int i = 0; i < triangles.size(); i++) {
+			for (int j = 0; j < 3; j++) {
+				if (triangles[i].points[j] >= p_at_index) {
+					triangles[i].points[j]++;
+				}
+			}
+		}
+	}
+	blend_points[p_at_index].node = p_node;
+	blend_points[p_at_index].position = p_position;
+
+	blend_points[p_at_index].node->set_parent(this);
+	blend_points[p_at_index].node->set_graph_player(get_graph_player());
+	blend_points_used++;
+
+	if (auto_triangles) {
+		trianges_dirty = true;
+	}
+}
+
+void AnimationNodeBlendSpace::set_blend_point_position(int p_point, const Vector2 &p_position) {
+	ERR_FAIL_INDEX(p_point, blend_points_used);
+	blend_points[p_point].position = p_position;
+	if (auto_triangles) {
+		trianges_dirty = true;
+	}
+}
+void AnimationNodeBlendSpace::set_blend_point_node(int p_point, const Ref<AnimationRootNode> &p_node) {
+	ERR_FAIL_INDEX(p_point, blend_points_used);
+	ERR_FAIL_COND(p_node.is_null());
+
+	if (blend_points[p_point].node.is_valid()) {
+		blend_points[p_point].node->set_parent(NULL);
+		blend_points[p_point].node->set_graph_player(NULL);
+	}
+	blend_points[p_point].node = p_node;
+	blend_points[p_point].node->set_parent(this);
+	blend_points[p_point].node->set_graph_player(get_graph_player());
+}
+Vector2 AnimationNodeBlendSpace::get_blend_point_position(int p_point) const {
+	ERR_FAIL_INDEX_V(p_point, blend_points_used, Vector2());
+	return blend_points[p_point].position;
+}
+Ref<AnimationRootNode> AnimationNodeBlendSpace::get_blend_point_node(int p_point) const {
+	ERR_FAIL_INDEX_V(p_point, blend_points_used, Ref<AnimationRootNode>());
+	return blend_points[p_point].node;
+}
+void AnimationNodeBlendSpace::remove_blend_point(int p_point) {
+	ERR_FAIL_INDEX(p_point, blend_points_used);
+
+	blend_points[p_point].node->set_parent(NULL);
+	blend_points[p_point].node->set_graph_player(NULL);
+
+	for (int i = 0; i < triangles.size(); i++) {
+		bool erase = false;
+		for (int j = 0; j < 3; j++) {
+			if (triangles[i].points[j] == p_point) {
+				erase = true;
+				break;
+			} else if (triangles[i].points[j] > p_point) {
+				triangles[i].points[j]--;
+			}
+		}
+		if (erase) {
+			triangles.remove(i);
+
+			i--;
+		}
+	}
+
+	for (int i = p_point; i < blend_points_used - 1; i++) {
+		blend_points[i] = blend_points[i + 1];
+	}
+	blend_points_used--;
+}
+
+int AnimationNodeBlendSpace::get_blend_point_count() const {
+
+	return blend_points_used;
+}
+
+bool AnimationNodeBlendSpace::has_triangle(int p_x, int p_y, int p_z) const {
+
+	ERR_FAIL_INDEX_V(p_x, blend_points_used, false);
+	ERR_FAIL_INDEX_V(p_y, blend_points_used, false);
+	ERR_FAIL_INDEX_V(p_z, blend_points_used, false);
+
+	BlendTriangle t;
+	t.points[0] = p_x;
+	t.points[1] = p_y;
+	t.points[2] = p_z;
+
+	SortArray<int> sort;
+	sort.sort(t.points, 3);
+
+	for (int i = 0; i < triangles.size(); i++) {
+		bool all_equal = true;
+		for (int j = 0; j < 3; j++) {
+			if (triangles[i].points[j] != t.points[j]) {
+				all_equal = false;
+				break;
+			}
+		}
+		if (all_equal)
+			return true;
+	}
+
+	return false;
+}
+
+void AnimationNodeBlendSpace::add_triangle(int p_x, int p_y, int p_z, int p_at_index) {
+
+	ERR_FAIL_INDEX(p_x, blend_points_used);
+	ERR_FAIL_INDEX(p_y, blend_points_used);
+	ERR_FAIL_INDEX(p_z, blend_points_used);
+
+	_update_triangles();
+
+	BlendTriangle t;
+	t.points[0] = p_x;
+	t.points[1] = p_y;
+	t.points[2] = p_z;
+
+	SortArray<int> sort;
+	sort.sort(t.points, 3);
+
+	for (int i = 0; i < triangles.size(); i++) {
+		bool all_equal = true;
+		for (int j = 0; j < 3; j++) {
+			if (triangles[i].points[j] != t.points[j]) {
+				all_equal = false;
+				break;
+			}
+		}
+		ERR_FAIL_COND(all_equal);
+	}
+
+	if (p_at_index == -1 || p_at_index == triangles.size()) {
+		triangles.push_back(t);
+	} else {
+		triangles.insert(p_at_index, t);
+	}
+}
+int AnimationNodeBlendSpace::get_triangle_point(int p_triangle, int p_point) {
+
+	_update_triangles();
+
+	ERR_FAIL_INDEX_V(p_point, 3, -1);
+	ERR_FAIL_INDEX_V(p_triangle, triangles.size(), -1);
+	return triangles[p_triangle].points[p_point];
+}
+void AnimationNodeBlendSpace::remove_triangle(int p_triangle) {
+	ERR_FAIL_INDEX(p_triangle, triangles.size());
+
+	triangles.remove(p_triangle);
+}
+
+int AnimationNodeBlendSpace::get_triangle_count() const {
+	return triangles.size();
+}
+
+void AnimationNodeBlendSpace::set_min_space(const Vector2 &p_min) {
+
+	min_space = p_min;
+	if (min_space.x >= max_space.x) {
+		min_space.x = max_space.x - 1;
+	}
+	if (min_space.y >= max_space.y) {
+		min_space.y = max_space.y - 1;
+	}
+}
+Vector2 AnimationNodeBlendSpace::get_min_space() const {
+	return min_space;
+}
+
+void AnimationNodeBlendSpace::set_max_space(const Vector2 &p_max) {
+
+	max_space = p_max;
+	if (max_space.x <= min_space.x) {
+		max_space.x = min_space.x + 1;
+	}
+	if (max_space.y <= min_space.y) {
+		max_space.y = min_space.y + 1;
+	}
+}
+Vector2 AnimationNodeBlendSpace::get_max_space() const {
+	return max_space;
+}
+
+void AnimationNodeBlendSpace::set_snap(const Vector2 &p_snap) {
+	snap = p_snap;
+}
+Vector2 AnimationNodeBlendSpace::get_snap() const {
+	return snap;
+}
+
+void AnimationNodeBlendSpace::set_blend_pos(const Vector2 &p_pos) {
+	blend_pos = p_pos;
+}
+Vector2 AnimationNodeBlendSpace::get_blend_pos() const {
+	return blend_pos;
+}
+
+void AnimationNodeBlendSpace::set_x_label(const String &p_label) {
+	x_label = p_label;
+}
+String AnimationNodeBlendSpace::get_x_label() const {
+	return x_label;
+}
+
+void AnimationNodeBlendSpace::set_y_label(const String &p_label) {
+	y_label = p_label;
+}
+String AnimationNodeBlendSpace::get_y_label() const {
+	return y_label;
+}
+
+void AnimationNodeBlendSpace::_add_blend_point(int p_index, const Ref<AnimationRootNode> &p_node) {
+	if (p_index == blend_points_used) {
+		add_blend_point(p_node, Vector2());
+	} else {
+		set_blend_point_node(p_index, p_node);
+	}
+}
+
+void AnimationNodeBlendSpace::_set_triangles(const Vector<int> &p_triangles) {
+
+	if (auto_triangles)
+		return;
+	ERR_FAIL_COND(p_triangles.size() % 3 != 0);
+	for (int i = 0; i < p_triangles.size(); i += 3) {
+		add_triangle(p_triangles[i + 0], p_triangles[i + 1], p_triangles[i + 2]);
+	}
+}
+
+Vector<int> AnimationNodeBlendSpace::_get_triangles() const {
+
+	Vector<int> t;
+	if (auto_triangles && trianges_dirty)
+		return t;
+
+	t.resize(triangles.size() * 3);
+	for (int i = 0; i < triangles.size(); i++) {
+		t[i * 3 + 0] = triangles[i].points[0];
+		t[i * 3 + 1] = triangles[i].points[1];
+		t[i * 3 + 2] = triangles[i].points[2];
+	}
+	return t;
+}
+
+void AnimationNodeBlendSpace::_update_triangles() {
+
+	if (!auto_triangles || !trianges_dirty)
+		return;
+
+	trianges_dirty = false;
+	triangles.clear();
+	if (blend_points_used < 3)
+		return;
+
+	Vector<Vector2> points;
+	points.resize(blend_points_used);
+	for (int i = 0; i < blend_points_used; i++) {
+		points[i] = blend_points[i].position;
+	}
+
+	Vector<Delaunay2D::Triangle> triangles = Delaunay2D::triangulate(points);
+
+	for (int i = 0; i < triangles.size(); i++) {
+		add_triangle(triangles[i].points[0], triangles[i].points[1], triangles[i].points[2]);
+	}
+}
+
+Vector2 AnimationNodeBlendSpace::get_closest_point(const Vector2 &p_point) {
+
+	_update_triangles();
+
+	if (triangles.size() == 0)
+		return Vector2();
+
+	Vector2 best_point;
+	bool first = true;
+
+	for (int i = 0; i < triangles.size(); i++) {
+		Vector2 points[3];
+		for (int j = 0; j < 3; j++) {
+			points[j] = get_blend_point_position(get_triangle_point(i, j));
+		}
+
+		if (Geometry::is_point_in_triangle(p_point, points[0], points[1], points[2])) {
+
+			return p_point;
+		}
+
+		for (int j = 0; j < 3; j++) {
+			Vector2 s[2] = {
+				points[j],
+				points[(j + 1) % 3]
+			};
+			Vector2 closest = Geometry::get_closest_point_to_segment_2d(p_point, s);
+			if (first || closest.distance_to(p_point) < best_point.distance_to(p_point)) {
+				best_point = closest;
+				first = false;
+			}
+		}
+	}
+
+	return best_point;
+}
+
+void AnimationNodeBlendSpace::_blend_triangle(const Vector2 &p_pos, const Vector2 *p_points, float *r_weights) {
+
+	if (p_pos.distance_squared_to(p_points[0]) < CMP_EPSILON2) {
+		r_weights[0] = 1;
+		r_weights[1] = 0;
+		r_weights[2] = 0;
+		return;
+	}
+	if (p_pos.distance_squared_to(p_points[1]) < CMP_EPSILON2) {
+		r_weights[0] = 0;
+		r_weights[1] = 1;
+		r_weights[2] = 0;
+		return;
+	}
+	if (p_pos.distance_squared_to(p_points[2]) < CMP_EPSILON2) {
+		r_weights[0] = 0;
+		r_weights[1] = 0;
+		r_weights[2] = 1;
+		return;
+	}
+
+	Vector2 v0 = p_points[1] - p_points[0];
+	Vector2 v1 = p_points[2] - p_points[0];
+	Vector2 v2 = p_pos - p_points[0];
+
+	float d00 = v0.dot(v0);
+	float d01 = v0.dot(v1);
+	float d11 = v1.dot(v1);
+	float d20 = v2.dot(v0);
+	float d21 = v2.dot(v1);
+	float denom = (d00 * d11 - d01 * d01);
+	if (denom == 0) {
+		r_weights[0] = 1;
+		r_weights[1] = 0;
+		r_weights[2] = 0;
+		return;
+	}
+	float v = (d11 * d20 - d01 * d21) / denom;
+	float w = (d00 * d21 - d01 * d20) / denom;
+	float u = 1.0f - v - w;
+
+	r_weights[0] = u;
+	r_weights[1] = v;
+	r_weights[2] = w;
+}
+
+float AnimationNodeBlendSpace::process(float p_time, bool p_seek) {
+
+	_update_triangles();
+
+	if (triangles.size() == 0)
+		return 0;
+
+	Vector2 best_point;
+	bool first = true;
+	int blend_triangle = -1;
+	float blend_weights[3] = { 0, 0, 0 };
+
+	for (int i = 0; i < triangles.size(); i++) {
+		Vector2 points[3];
+		for (int j = 0; j < 3; j++) {
+			points[j] = get_blend_point_position(get_triangle_point(i, j));
+		}
+
+		if (Geometry::is_point_in_triangle(blend_pos, points[0], points[1], points[2])) {
+
+			blend_triangle = i;
+			_blend_triangle(blend_pos, points, blend_weights);
+			break;
+		}
+
+		for (int j = 0; j < 3; j++) {
+			Vector2 s[2] = {
+				points[j],
+				points[(j + 1) % 3]
+			};
+			Vector2 closest = Geometry::get_closest_point_to_segment_2d(blend_pos, s);
+			if (first || closest.distance_to(blend_pos) < best_point.distance_to(blend_pos)) {
+				best_point = closest;
+				blend_triangle = i;
+				first = false;
+				float d = s[0].distance_to(s[1]);
+				if (d == 0.0) {
+					blend_weights[j] = 1.0;
+					blend_weights[(j + 1) % 3] = 0.0;
+					blend_weights[(j + 2) % 3] = 0.0;
+				} else {
+					float c = s[0].distance_to(closest) / d;
+
+					blend_weights[j] = 1.0 - c;
+					blend_weights[(j + 1) % 3] = c;
+					blend_weights[(j + 2) % 3] = 0.0;
+				}
+			}
+		}
+	}
+
+	ERR_FAIL_COND_V(blend_triangle == -1, 0); //should never reach here
+
+	int triangle_points[3];
+	for (int j = 0; j < 3; j++) {
+		triangle_points[j] = get_triangle_point(blend_triangle, j);
+	}
+
+	first = true;
+	float mind;
+	for (int i = 0; i < blend_points_used; i++) {
+
+		bool found = false;
+		for (int j = 0; j < 3; j++) {
+			if (i == triangle_points[j]) {
+				//blend with the given weight
+				float t = blend_node(blend_points[i].node, p_time, p_seek, blend_weights[j], FILTER_IGNORE, false);
+				if (first || t < mind) {
+					mind = t;
+					first = false;
+				}
+				found = true;
+				break;
+			}
+		}
+
+		if (!found) {
+			//ignore
+			blend_node(blend_points[i].node, p_time, p_seek, 0, FILTER_IGNORE, false);
+		}
+	}
+	return mind;
+}
+
+String AnimationNodeBlendSpace::get_caption() const {
+	return "BlendSpace";
+}
+
+void AnimationNodeBlendSpace::_validate_property(PropertyInfo &property) const {
+	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;
+		}
+	}
+	AnimationRootNode::_validate_property(property);
+}
+
+void AnimationNodeBlendSpace::set_auto_triangles(bool p_enable) {
+	auto_triangles = p_enable;
+	if (auto_triangles) {
+		trianges_dirty = true;
+	}
+}
+
+bool AnimationNodeBlendSpace::get_auto_triangles() const {
+	return auto_triangles;
+}
+
+void AnimationNodeBlendSpace::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("add_blend_point", "node", "pos", "at_index"), &AnimationNodeBlendSpace::add_blend_point, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("set_blend_point_position", "point", "pos"), &AnimationNodeBlendSpace::set_blend_point_position);
+	ClassDB::bind_method(D_METHOD("get_blend_point_position", "point"), &AnimationNodeBlendSpace::get_blend_point_position);
+	ClassDB::bind_method(D_METHOD("set_blend_point_node", "point", "node"), &AnimationNodeBlendSpace::set_blend_point_node);
+	ClassDB::bind_method(D_METHOD("get_blend_point_node", "point"), &AnimationNodeBlendSpace::get_blend_point_node);
+	ClassDB::bind_method(D_METHOD("remove_blend_point", "point"), &AnimationNodeBlendSpace::remove_blend_point);
+	ClassDB::bind_method(D_METHOD("get_blend_point_count"), &AnimationNodeBlendSpace::get_blend_point_count);
+
+	ClassDB::bind_method(D_METHOD("add_triangle", "x", "y", "z", "at_index"), &AnimationNodeBlendSpace::add_triangle, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("get_triangle_point", "triangle", "point"), &AnimationNodeBlendSpace::get_triangle_point);
+	ClassDB::bind_method(D_METHOD("remove_triangle", "triangle"), &AnimationNodeBlendSpace::remove_triangle);
+	ClassDB::bind_method(D_METHOD("get_triangle_count"), &AnimationNodeBlendSpace::get_triangle_count);
+
+	ClassDB::bind_method(D_METHOD("set_min_space", "min_space"), &AnimationNodeBlendSpace::set_min_space);
+	ClassDB::bind_method(D_METHOD("get_min_space"), &AnimationNodeBlendSpace::get_min_space);
+
+	ClassDB::bind_method(D_METHOD("set_max_space", "max_space"), &AnimationNodeBlendSpace::set_max_space);
+	ClassDB::bind_method(D_METHOD("get_max_space"), &AnimationNodeBlendSpace::get_max_space);
+
+	ClassDB::bind_method(D_METHOD("set_snap", "snap"), &AnimationNodeBlendSpace::set_snap);
+	ClassDB::bind_method(D_METHOD("get_snap"), &AnimationNodeBlendSpace::get_snap);
+
+	ClassDB::bind_method(D_METHOD("set_blend_pos", "pos"), &AnimationNodeBlendSpace::set_blend_pos);
+	ClassDB::bind_method(D_METHOD("get_blend_pos"), &AnimationNodeBlendSpace::get_blend_pos);
+
+	ClassDB::bind_method(D_METHOD("set_x_label", "text"), &AnimationNodeBlendSpace::set_x_label);
+	ClassDB::bind_method(D_METHOD("get_x_label"), &AnimationNodeBlendSpace::get_x_label);
+
+	ClassDB::bind_method(D_METHOD("set_y_label", "text"), &AnimationNodeBlendSpace::set_y_label);
+	ClassDB::bind_method(D_METHOD("get_y_label"), &AnimationNodeBlendSpace::get_y_label);
+
+	ClassDB::bind_method(D_METHOD("_add_blend_point", "index", "node"), &AnimationNodeBlendSpace::_add_blend_point);
+
+	ClassDB::bind_method(D_METHOD("_set_triangles", "triangles"), &AnimationNodeBlendSpace::_set_triangles);
+	ClassDB::bind_method(D_METHOD("_get_triangles"), &AnimationNodeBlendSpace::_get_triangles);
+
+	ClassDB::bind_method(D_METHOD("set_auto_triangles", "enable"), &AnimationNodeBlendSpace::set_auto_triangles);
+	ClassDB::bind_method(D_METHOD("get_auto_triangles"), &AnimationNodeBlendSpace::get_auto_triangles);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_triangles", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_auto_triangles", "get_auto_triangles");
+
+	for (int i = 0; i < MAX_BLEND_POINTS; i++) {
+		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "blend_point_" + itos(i) + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationRootNode", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE), "_add_blend_point", "get_blend_point_node", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::VECTOR2, "blend_point_" + itos(i) + "/pos", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "set_blend_point_position", "get_blend_point_position", i);
+	}
+
+	ADD_PROPERTY(PropertyInfo(Variant::POOL_INT_ARRAY, "triangles", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_triangles", "_get_triangles");
+
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "min_space", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_min_space", "get_min_space");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "max_space", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_max_space", "get_max_space");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "snap", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_snap", "get_snap");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "blend_pos", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_blend_pos", "get_blend_pos");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "x_label", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_x_label", "get_x_label");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "y_label", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_y_label", "get_y_label");
+}
+
+AnimationNodeBlendSpace::AnimationNodeBlendSpace() {
+
+	auto_triangles = true;
+	blend_points_used = 0;
+	max_space = Vector2(1, 1);
+	min_space = Vector2(-1, -1);
+	snap = Vector2(0.1, 0.1);
+	x_label = "x";
+	y_label = "y";
+	trianges_dirty = false;
+}
+
+AnimationNodeBlendSpace::~AnimationNodeBlendSpace() {
+
+	for (int i = 0; i < blend_points_used; i++) {
+		blend_points[i].node->set_parent(this);
+		blend_points[i].node->set_graph_player(get_graph_player());
+	}
+}
diff --git a/scene/animation/animation_blend_space.h b/scene/animation/animation_blend_space.h
new file mode 100644
index 0000000000..3eda3d2d39
--- /dev/null
+++ b/scene/animation/animation_blend_space.h
@@ -0,0 +1,94 @@
+#ifndef ANIMATION_BLEND_SPACE_H
+#define ANIMATION_BLEND_SPACE_H
+
+#include "scene/animation/animation_graph_player.h"
+
+class AnimationNodeBlendSpace : public AnimationRootNode {
+	GDCLASS(AnimationNodeBlendSpace, AnimationRootNode)
+
+	enum {
+		MAX_BLEND_POINTS = 64
+	};
+
+	struct BlendPoint {
+		Ref<AnimationRootNode> node;
+		Vector2 position;
+	};
+
+	BlendPoint blend_points[MAX_BLEND_POINTS];
+	int blend_points_used;
+
+	struct BlendTriangle {
+		int points[3];
+	};
+
+	Vector<BlendTriangle> triangles;
+
+	Vector2 blend_pos;
+	Vector2 max_space;
+	Vector2 min_space;
+	Vector2 snap;
+	String x_label;
+	String y_label;
+
+	void _add_blend_point(int p_index, const Ref<AnimationRootNode> &p_node);
+	void _set_triangles(const Vector<int> &p_triangles);
+	Vector<int> _get_triangles() const;
+
+	void _blend_triangle(const Vector2 &p_pos, const Vector2 *p_points, float *r_weights);
+
+	bool auto_triangles;
+	bool trianges_dirty;
+
+	void _update_triangles();
+
+protected:
+	virtual void _validate_property(PropertyInfo &property) const;
+	static void _bind_methods();
+
+public:
+	void add_blend_point(const Ref<AnimationRootNode> &p_node, const Vector2 &p_position, int p_at_index = -1);
+	void set_blend_point_position(int p_point, const Vector2 &p_position);
+	void set_blend_point_node(int p_point, const Ref<AnimationRootNode> &p_node);
+	Vector2 get_blend_point_position(int p_point) const;
+	Ref<AnimationRootNode> get_blend_point_node(int p_point) const;
+	void remove_blend_point(int p_point);
+	int get_blend_point_count() const;
+
+	bool has_triangle(int p_x, int p_y, int p_z) const;
+	void add_triangle(int p_x, int p_y, int p_z, int p_at_index = -1);
+	int get_triangle_point(int p_triangle, int p_point);
+	void remove_triangle(int p_triangle);
+	int get_triangle_count() const;
+
+	void set_min_space(const Vector2 &p_min);
+	Vector2 get_min_space() const;
+
+	void set_max_space(const Vector2 &p_max);
+	Vector2 get_max_space() const;
+
+	void set_snap(const Vector2 &p_snap);
+	Vector2 get_snap() const;
+
+	void set_blend_pos(const Vector2 &p_pos);
+	Vector2 get_blend_pos() const;
+
+	void set_x_label(const String &p_label);
+	String get_x_label() const;
+
+	void set_y_label(const String &p_label);
+	String get_y_label() const;
+
+	float process(float p_time, bool p_seek);
+	String get_caption() const;
+
+	Vector2 get_closest_point(const Vector2 &p_point);
+
+	void set_auto_triangles(bool p_enable);
+	bool get_auto_triangles() const;
+
+	AnimationNodeBlendSpace();
+	~AnimationNodeBlendSpace();
+};
+
+#endif // ANIMATION_BLEND_SPACE_H
diff --git a/scene/animation/animation_blend_tree.cpp b/scene/animation/animation_blend_tree.cpp
new file mode 100644
index 0000000000..ced0cbbbba
--- /dev/null
+++ b/scene/animation/animation_blend_tree.cpp
@@ -0,0 +1,1112 @@
+#include "animation_blend_tree.h"
+#include "scene/scene_string_names.h"
+
+void AnimationNodeAnimation::set_animation(const StringName &p_name) {
+	animation = p_name;
+}
+
+StringName AnimationNodeAnimation::get_animation() const {
+	return animation;
+}
+
+float AnimationNodeAnimation::get_playback_time() const {
+	return time;
+}
+
+void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
+
+	if (property.name == "animation") {
+		AnimationGraphPlayer *gp = get_graph_player();
+		if (gp && gp->has_node(gp->get_animation_player())) {
+			AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(gp->get_node(gp->get_animation_player()));
+			if (ap) {
+				List<StringName> names;
+				ap->get_animation_list(&names);
+				String anims;
+				for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+					if (E != names.front()) {
+						anims += ",";
+					}
+					anims += String(E->get());
+				}
+				if (anims != String()) {
+					property.hint = PROPERTY_HINT_ENUM;
+					property.hint_string = anims;
+				}
+			}
+		}
+	}
+
+	AnimationRootNode::_validate_property(property);
+}
+
+float AnimationNodeAnimation::process(float p_time, bool p_seek) {
+
+	AnimationPlayer *ap = get_player();
+	ERR_FAIL_COND_V(!ap, 0);
+
+	Ref<Animation> anim = ap->get_animation(animation);
+	if (!anim.is_valid()) {
+
+		Ref<AnimationNodeBlendTree> tree = get_parent();
+		if (tree.is_valid()) {
+			String name = tree->get_node_name(Ref<AnimationNodeAnimation>(this));
+			make_invalid(vformat(RTR("On BlendTree node '%s', animation not found: '%s'"), name, animation));
+
+		} else {
+			make_invalid(vformat(RTR("Animation not found: '%s'"), animation));
+		}
+
+		return 0;
+	}
+
+	if (p_seek) {
+		time = p_time;
+		step = 0;
+	} else {
+		time = MAX(0, time + p_time);
+		step = p_time;
+	}
+
+	float anim_size = anim->get_length();
+
+	if (anim->has_loop()) {
+
+		if (anim_size) {
+			time = Math::fposmod(time, anim_size);
+		}
+
+	} else if (time > anim_size) {
+
+		time = anim_size;
+	}
+
+	blend_animation(animation, time, step, p_seek, 1.0);
+
+	return anim_size - time;
+}
+
+String AnimationNodeAnimation::get_caption() const {
+	return "Animation";
+}
+
+void AnimationNodeAnimation::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_animation", "name"), &AnimationNodeAnimation::set_animation);
+	ClassDB::bind_method(D_METHOD("get_animation"), &AnimationNodeAnimation::get_animation);
+
+	ClassDB::bind_method(D_METHOD("get_playback_time"), &AnimationNodeAnimation::get_playback_time);
+
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "animation"), "set_animation", "get_animation");
+}
+
+AnimationNodeAnimation::AnimationNodeAnimation() {
+	last_version = 0;
+	skip = false;
+	time = 0;
+	step = 0;
+}
+
+////////////////////////////////////////////////////////
+
+void AnimationNodeOneShot::set_fadein_time(float p_time) {
+
+	fade_in = p_time;
+}
+
+void AnimationNodeOneShot::set_fadeout_time(float p_time) {
+
+	fade_out = p_time;
+}
+
+float AnimationNodeOneShot::get_fadein_time() const {
+
+	return fade_in;
+}
+float AnimationNodeOneShot::get_fadeout_time() const {
+
+	return fade_out;
+}
+
+void AnimationNodeOneShot::set_autorestart(bool p_active) {
+
+	autorestart = p_active;
+}
+void AnimationNodeOneShot::set_autorestart_delay(float p_time) {
+
+	autorestart_delay = p_time;
+}
+void AnimationNodeOneShot::set_autorestart_random_delay(float p_time) {
+
+	autorestart_random_delay = p_time;
+}
+
+bool AnimationNodeOneShot::has_autorestart() const {
+
+	return autorestart;
+}
+float AnimationNodeOneShot::get_autorestart_delay() const {
+
+	return autorestart_delay;
+}
+float AnimationNodeOneShot::get_autorestart_random_delay() const {
+
+	return autorestart_random_delay;
+}
+
+void AnimationNodeOneShot::set_mix_mode(MixMode p_mix) {
+
+	mix = p_mix;
+}
+AnimationNodeOneShot::MixMode AnimationNodeOneShot::get_mix_mode() const {
+
+	return mix;
+}
+
+void AnimationNodeOneShot::start() {
+	active = true;
+	do_start = true;
+}
+void AnimationNodeOneShot::stop() {
+	active = false;
+}
+bool AnimationNodeOneShot::is_active() const {
+
+	return active;
+}
+
+String AnimationNodeOneShot::get_caption() const {
+	return "OneShot";
+}
+
+bool AnimationNodeOneShot::has_filter() const {
+	return true;
+}
+
+float AnimationNodeOneShot::process(float p_time, bool p_seek) {
+
+	if (!active) {
+		//make it as if this node doesn't exist, pass input 0 by.
+		return blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
+	}
+
+	bool os_seek = p_seek;
+
+	if (p_seek)
+		time = p_time;
+	if (do_start) {
+		time = 0;
+		os_seek = true;
+	}
+
+	float blend;
+
+	if (time < fade_in) {
+
+		if (fade_in > 0)
+			blend = time / fade_in;
+		else
+			blend = 0; //wtf
+
+	} else if (!do_start && remaining < fade_out) {
+
+		if (fade_out)
+			blend = (remaining / fade_out);
+		else
+			blend = 1.0;
+	} else
+		blend = 1.0;
+
+	float main_rem;
+	if (mix == MIX_MODE_ADD) {
+		main_rem = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
+	} else {
+		main_rem = blend_input(0, p_time, p_seek, 1.0 - blend, FILTER_BLEND, !sync);
+	}
+
+	float os_rem = blend_input(1, os_seek ? time : p_time, os_seek, blend, FILTER_PASS, false);
+
+	if (do_start) {
+		remaining = os_rem;
+		do_start = false;
+	}
+
+	if (!p_seek) {
+		time += p_time;
+		remaining = os_rem;
+		if (remaining <= 0)
+			active = false;
+	}
+
+	return MAX(main_rem, remaining);
+}
+void AnimationNodeOneShot::set_use_sync(bool p_sync) {
+
+	sync = p_sync;
+}
+
+bool AnimationNodeOneShot::is_using_sync() const {
+
+	return sync;
+}
+
+void AnimationNodeOneShot::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_fadein_time", "time"), &AnimationNodeOneShot::set_fadein_time);
+	ClassDB::bind_method(D_METHOD("get_fadein_time"), &AnimationNodeOneShot::get_fadein_time);
+
+	ClassDB::bind_method(D_METHOD("set_fadeout_time", "time"), &AnimationNodeOneShot::set_fadeout_time);
+	ClassDB::bind_method(D_METHOD("get_fadeout_time"), &AnimationNodeOneShot::get_fadeout_time);
+
+	ClassDB::bind_method(D_METHOD("set_autorestart", "enable"), &AnimationNodeOneShot::set_autorestart);
+	ClassDB::bind_method(D_METHOD("has_autorestart"), &AnimationNodeOneShot::has_autorestart);
+
+	ClassDB::bind_method(D_METHOD("set_autorestart_delay", "enable"), &AnimationNodeOneShot::set_autorestart_delay);
+	ClassDB::bind_method(D_METHOD("get_autorestart_delay"), &AnimationNodeOneShot::get_autorestart_delay);
+
+	ClassDB::bind_method(D_METHOD("set_autorestart_random_delay", "enable"), &AnimationNodeOneShot::set_autorestart_random_delay);
+	ClassDB::bind_method(D_METHOD("get_autorestart_random_delay"), &AnimationNodeOneShot::get_autorestart_random_delay);
+
+	ClassDB::bind_method(D_METHOD("set_mix_mode", "mode"), &AnimationNodeOneShot::set_mix_mode);
+	ClassDB::bind_method(D_METHOD("get_mix_mode"), &AnimationNodeOneShot::get_mix_mode);
+
+	ClassDB::bind_method(D_METHOD("start"), &AnimationNodeOneShot::start);
+	ClassDB::bind_method(D_METHOD("stop"), &AnimationNodeOneShot::stop);
+	ClassDB::bind_method(D_METHOD("is_active"), &AnimationNodeOneShot::is_active);
+
+	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeOneShot::set_use_sync);
+	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeOneShot::is_using_sync);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "fadein_time", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_fadein_time", "get_fadein_time");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "fadeout_time", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_fadeout_time", "get_fadeout_time");
+
+	ADD_GROUP("autorestart_", "Auto Restart");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "autorestart"), "set_autorestart", "has_autorestart");
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "autorestart_delay", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_autorestart_delay", "get_autorestart_delay");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "autorestart_random_delay", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_autorestart_random_delay", "get_autorestart_random_delay");
+
+	ADD_GROUP("", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
+
+	BIND_CONSTANT(MIX_MODE_BLEND)
+	BIND_CONSTANT(MIX_MODE_ADD)
+}
+
+AnimationNodeOneShot::AnimationNodeOneShot() {
+
+	add_input("in");
+	add_input("shot");
+
+	time = 0;
+	fade_in = 0.1;
+	fade_out = 0.1;
+	autorestart = false;
+	autorestart_delay = 1;
+	autorestart_remaining = 0;
+	mix = MIX_MODE_BLEND;
+	active = false;
+	do_start = false;
+	sync = false;
+}
+
+////////////////////////////////////////////////
+
+void AnimationNodeAdd::set_amount(float p_amount) {
+	amount = p_amount;
+}
+
+float AnimationNodeAdd::get_amount() const {
+	return amount;
+}
+
+String AnimationNodeAdd::get_caption() const {
+	return "Add";
+}
+void AnimationNodeAdd::set_use_sync(bool p_sync) {
+
+	sync = p_sync;
+}
+
+bool AnimationNodeAdd::is_using_sync() const {
+
+	return sync;
+}
+
+bool AnimationNodeAdd::has_filter() const {
+
+	return true;
+}
+
+float AnimationNodeAdd::process(float p_time, bool p_seek) {
+
+	float 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;
+}
+
+void AnimationNodeAdd::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_amount", "amount"), &AnimationNodeAdd::set_amount);
+	ClassDB::bind_method(D_METHOD("get_amount"), &AnimationNodeAdd::get_amount);
+
+	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeAdd::set_use_sync);
+	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeAdd::is_using_sync);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_amount", "get_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
+}
+
+AnimationNodeAdd::AnimationNodeAdd() {
+
+	add_input("in");
+	add_input("add");
+	amount = 0;
+	sync = false;
+}
+
+/////////////////////////////////////////////
+
+void AnimationNodeBlend2::set_amount(float p_amount) {
+	amount = p_amount;
+}
+
+float AnimationNodeBlend2::get_amount() const {
+	return amount;
+}
+String AnimationNodeBlend2::get_caption() const {
+	return "Blend2";
+}
+
+float AnimationNodeBlend2::process(float p_time, bool p_seek) {
+
+	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);
+
+	return amount > 0.5 ? rem1 : rem0; //hacky but good enough
+}
+
+void AnimationNodeBlend2::set_use_sync(bool p_sync) {
+
+	sync = p_sync;
+}
+
+bool AnimationNodeBlend2::is_using_sync() const {
+
+	return sync;
+}
+
+bool AnimationNodeBlend2::has_filter() const {
+
+	return true;
+}
+void AnimationNodeBlend2::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_amount", "amount"), &AnimationNodeBlend2::set_amount);
+	ClassDB::bind_method(D_METHOD("get_amount"), &AnimationNodeBlend2::get_amount);
+
+	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend2::set_use_sync);
+	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend2::is_using_sync);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_amount", "get_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
+}
+AnimationNodeBlend2::AnimationNodeBlend2() {
+	add_input("in");
+	add_input("blend");
+	sync = false;
+
+	amount = 0;
+}
+
+//////////////////////////////////////
+
+void AnimationNodeBlend3::set_amount(float p_amount) {
+	amount = p_amount;
+}
+
+float AnimationNodeBlend3::get_amount() const {
+	return amount;
+}
+
+String AnimationNodeBlend3::get_caption() const {
+	return "Blend3";
+}
+
+void AnimationNodeBlend3::set_use_sync(bool p_sync) {
+
+	sync = p_sync;
+}
+
+bool AnimationNodeBlend3::is_using_sync() const {
+
+	return sync;
+}
+
+float AnimationNodeBlend3::process(float p_time, bool p_seek) {
+
+	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);
+
+	return amount > 0.5 ? rem2 : (amount < -0.5 ? rem0 : rem1); //hacky but good enough
+}
+
+void AnimationNodeBlend3::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_amount", "amount"), &AnimationNodeBlend3::set_amount);
+	ClassDB::bind_method(D_METHOD("get_amount"), &AnimationNodeBlend3::get_amount);
+
+	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend3::set_use_sync);
+	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend3::is_using_sync);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "amount", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_amount", "get_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
+}
+AnimationNodeBlend3::AnimationNodeBlend3() {
+	add_input("-blend");
+	add_input("in");
+	add_input("+blend");
+	sync = false;
+	amount = 0;
+}
+
+/////////////////////////////////
+
+void AnimationNodeTimeScale::set_scale(float p_scale) {
+	scale = p_scale;
+}
+
+float AnimationNodeTimeScale::get_scale() const {
+	return scale;
+}
+
+String AnimationNodeTimeScale::get_caption() const {
+	return "TimeScale";
+}
+
+float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
+
+	if (p_seek) {
+		return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
+	} else {
+		return blend_input(0, p_time * scale, false, 1.0, FILTER_IGNORE, false);
+	}
+}
+
+void AnimationNodeTimeScale::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_scale", "scale"), &AnimationNodeTimeScale::set_scale);
+	ClassDB::bind_method(D_METHOD("get_scale"), &AnimationNodeTimeScale::get_scale);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "scale", PROPERTY_HINT_RANGE, "0,32,0.01,or_greater"), "set_scale", "get_scale");
+}
+AnimationNodeTimeScale::AnimationNodeTimeScale() {
+	add_input("in");
+	scale = 1.0;
+}
+
+////////////////////////////////////
+
+void AnimationNodeTimeSeek::set_seek_pos(float p_seek_pos) {
+	seek_pos = p_seek_pos;
+}
+
+float AnimationNodeTimeSeek::get_seek_pos() const {
+	return seek_pos;
+}
+
+String AnimationNodeTimeSeek::get_caption() const {
+	return "Seek";
+}
+
+float AnimationNodeTimeSeek::process(float p_time, bool p_seek) {
+
+	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);
+		seek_pos = -1;
+		_change_notify("seek_pos");
+		return ret;
+	} else {
+		return blend_input(0, p_time, false, 1.0, FILTER_IGNORE, false);
+	}
+}
+
+void AnimationNodeTimeSeek::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_seek_pos", "seek_pos"), &AnimationNodeTimeSeek::set_seek_pos);
+	ClassDB::bind_method(D_METHOD("get_seek_pos"), &AnimationNodeTimeSeek::get_seek_pos);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "seek_pos", PROPERTY_HINT_RANGE, "-1,3600,0.01,or_greater"), "set_seek_pos", "get_seek_pos");
+}
+AnimationNodeTimeSeek::AnimationNodeTimeSeek() {
+	add_input("in");
+	seek_pos = -1;
+}
+
+/////////////////////////////////////////////////
+
+String AnimationNodeTransition::get_caption() const {
+	return "Transition";
+}
+
+void AnimationNodeTransition::_update_inputs() {
+	while (get_input_count() < enabled_inputs) {
+		add_input(inputs[get_input_count()].name);
+	}
+
+	while (get_input_count() > enabled_inputs) {
+		remove_input(get_input_count() - 1);
+	}
+}
+
+void AnimationNodeTransition::set_enabled_inputs(int p_inputs) {
+	ERR_FAIL_INDEX(p_inputs, MAX_INPUTS);
+	enabled_inputs = p_inputs;
+	_update_inputs();
+}
+
+int AnimationNodeTransition::get_enabled_inputs() {
+	return enabled_inputs;
+}
+
+void AnimationNodeTransition::set_input_as_auto_advance(int p_input, bool p_enable) {
+	ERR_FAIL_INDEX(p_input, MAX_INPUTS);
+	inputs[p_input].auto_advance = p_enable;
+}
+
+bool AnimationNodeTransition::is_input_set_as_auto_advance(int p_input) const {
+	ERR_FAIL_INDEX_V(p_input, MAX_INPUTS, false);
+	return inputs[p_input].auto_advance;
+}
+
+void AnimationNodeTransition::set_input_caption(int p_input, const String &p_name) {
+	ERR_FAIL_INDEX(p_input, MAX_INPUTS);
+	inputs[p_input].name = p_name;
+	set_input_name(p_input, p_name);
+}
+
+String AnimationNodeTransition::get_input_caption(int p_input) const {
+	ERR_FAIL_INDEX_V(p_input, MAX_INPUTS, String());
+	return inputs[p_input].name;
+}
+
+void AnimationNodeTransition::set_current(int p_current) {
+
+	if (current == p_current)
+		return;
+	ERR_FAIL_INDEX(p_current, enabled_inputs);
+
+	Ref<AnimationNodeBlendTree> tree = get_parent();
+
+	if (tree.is_valid() && current >= 0) {
+		prev = current;
+		prev_xfading = xfade;
+		prev_time = time;
+		time = 0;
+		current = p_current;
+		switched = true;
+		_change_notify("current");
+	} else {
+		current = p_current;
+	}
+}
+
+int AnimationNodeTransition::get_current() const {
+	return current;
+}
+void AnimationNodeTransition::set_cross_fade_time(float p_fade) {
+	xfade = p_fade;
+}
+
+float AnimationNodeTransition::get_cross_fade_time() const {
+	return xfade;
+}
+
+float AnimationNodeTransition::process(float p_time, bool p_seek) {
+
+	if (prev < 0) { // process current animation, check for transition
+
+		float rem = blend_input(current, p_time, p_seek, 1.0, FILTER_IGNORE, false);
+
+		if (p_seek)
+			time = p_time;
+		else
+			time += p_time;
+
+		if (inputs[current].auto_advance && rem <= xfade) {
+
+			set_current((current + 1) % enabled_inputs);
+		}
+
+		return rem;
+	} else { // cross-fading from prev to current
+
+		float blend = xfade ? (prev_xfading / xfade) : 1;
+
+		float rem;
+
+		if (!p_seek && switched) { //just switched, seek to start of current
+
+			rem = blend_input(current, 0, true, 1.0 - blend, FILTER_IGNORE, false);
+		} else {
+
+			rem = blend_input(current, p_time, p_seek, 1.0 - blend, FILTER_IGNORE, false);
+		}
+
+		switched = false;
+
+		if (p_seek) { // don't seek prev animation
+			blend_input(prev, 0, false, blend, FILTER_IGNORE, false);
+			time = p_time;
+		} else {
+			blend_input(prev, p_time, false, blend, FILTER_IGNORE, false);
+			time += p_time;
+			prev_xfading -= p_time;
+			if (prev_xfading < 0) {
+				prev = -1;
+			}
+		}
+
+		return rem;
+	}
+}
+
+void AnimationNodeTransition::_validate_property(PropertyInfo &property) const {
+
+	if (property.name == "current" && enabled_inputs > 0) {
+		property.hint = PROPERTY_HINT_ENUM;
+		String anims;
+		for (int i = 0; i < enabled_inputs; i++) {
+			if (i > 0) {
+				anims += ",";
+			}
+			anims += inputs[i].name;
+		}
+		property.hint_string = anims;
+	}
+
+	if (property.name.begins_with("input_")) {
+		String n = property.name.get_slicec('/', 0).get_slicec('_', 1);
+		if (n != "count") {
+			int idx = n.to_int();
+			if (idx >= enabled_inputs) {
+				property.usage = 0;
+			}
+		}
+	}
+
+	AnimationNode::_validate_property(property);
+}
+
+void AnimationNodeTransition::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_enabled_inputs", "amount"), &AnimationNodeTransition::set_enabled_inputs);
+	ClassDB::bind_method(D_METHOD("get_enabled_inputs"), &AnimationNodeTransition::get_enabled_inputs);
+
+	ClassDB::bind_method(D_METHOD("set_input_as_auto_advance", "input", "enable"), &AnimationNodeTransition::set_input_as_auto_advance);
+	ClassDB::bind_method(D_METHOD("is_input_set_as_auto_advance", "input"), &AnimationNodeTransition::is_input_set_as_auto_advance);
+
+	ClassDB::bind_method(D_METHOD("set_input_caption", "input", "caption"), &AnimationNodeTransition::set_input_caption);
+	ClassDB::bind_method(D_METHOD("get_input_caption", "input"), &AnimationNodeTransition::get_input_caption);
+
+	ClassDB::bind_method(D_METHOD("set_current", "index"), &AnimationNodeTransition::set_current);
+	ClassDB::bind_method(D_METHOD("get_current"), &AnimationNodeTransition::get_current);
+
+	ClassDB::bind_method(D_METHOD("set_cross_fade_time", "time"), &AnimationNodeTransition::set_cross_fade_time);
+	ClassDB::bind_method(D_METHOD("get_cross_fade_time"), &AnimationNodeTransition::get_cross_fade_time);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "input_count", PROPERTY_HINT_RANGE, "0,64,1", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_enabled_inputs", "get_enabled_inputs");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "current", PROPERTY_HINT_RANGE, "0,64,1"), "set_current", "get_current");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "xfade_time", PROPERTY_HINT_RANGE, "0,120,0.01"), "set_cross_fade_time", "get_cross_fade_time");
+
+	for (int i = 0; i < MAX_INPUTS; i++) {
+		ADD_PROPERTYI(PropertyInfo(Variant::STRING, "input_" + itos(i) + "/name"), "set_input_caption", "get_input_caption", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "input_" + itos(i) + "/auto_advance"), "set_input_as_auto_advance", "is_input_set_as_auto_advance", i);
+	}
+}
+
+AnimationNodeTransition::AnimationNodeTransition() {
+	enabled_inputs = 0;
+	xfade = 0;
+	current = -1;
+	prev = -1;
+	prev_time = 0;
+	prev_xfading = 0;
+	switched = false;
+	for (int i = 0; i < MAX_INPUTS; i++) {
+		inputs[i].auto_advance = false;
+		inputs[i].name = itos(i + 1);
+	}
+}
+
+/////////////////////
+
+String AnimationNodeOutput::get_caption() const {
+	return "Output";
+}
+
+float AnimationNodeOutput::process(float p_time, bool p_seek) {
+	return blend_input(0, p_time, p_seek, 1.0);
+}
+
+AnimationNodeOutput::AnimationNodeOutput() {
+	add_input("output");
+}
+
+///////////////////////////////////////////////////////
+void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNode> p_node) {
+
+	ERR_FAIL_COND(nodes.has(p_name));
+	ERR_FAIL_COND(p_node.is_null());
+	ERR_FAIL_COND(p_node->get_parent().is_valid());
+	ERR_FAIL_COND(p_node->get_graph_player() != NULL);
+	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
+	ERR_FAIL_COND(String(p_name).find("/") != -1);
+	nodes[p_name] = p_node;
+
+	p_node->set_parent(this);
+	p_node->set_graph_player(get_graph_player());
+
+	emit_changed();
+}
+
+Ref<AnimationNode> AnimationNodeBlendTree::get_node(const StringName &p_name) const {
+
+	ERR_FAIL_COND_V(!nodes.has(p_name), Ref<AnimationNode>());
+
+	return nodes[p_name];
+}
+
+StringName AnimationNodeBlendTree::get_node_name(const Ref<AnimationNode> &p_node) const {
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		if (E->get() == p_node) {
+			return E->key();
+		}
+	}
+
+	ERR_FAIL_V(StringName());
+}
+bool AnimationNodeBlendTree::has_node(const StringName &p_name) const {
+	return nodes.has(p_name);
+}
+void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
+
+	ERR_FAIL_COND(!nodes.has(p_name));
+	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output); //can't delete output
+
+	{
+		//erase node connections
+		Ref<AnimationNode> node = nodes[p_name];
+		for (int i = 0; i < node->get_input_count(); i++) {
+			node->set_input_connection(i, StringName());
+		}
+		node->set_parent(NULL);
+		node->set_graph_player(NULL);
+	}
+
+	nodes.erase(p_name);
+
+	//erase connections to name
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		for (int i = 0; i < node->get_input_count(); i++) {
+			if (node->get_input_connection(i) == p_name) {
+				node->set_input_connection(i, StringName());
+			}
+		}
+	}
+
+	emit_changed();
+}
+
+void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringName &p_new_name) {
+
+	ERR_FAIL_COND(!nodes.has(p_name));
+	ERR_FAIL_COND(nodes.has(p_new_name));
+	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
+	ERR_FAIL_COND(p_new_name == SceneStringNames::get_singleton()->output);
+
+	nodes[p_new_name] = nodes[p_name];
+	nodes.erase(p_name);
+
+	//rename connections
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		for (int i = 0; i < node->get_input_count(); i++) {
+			if (node->get_input_connection(i) == p_name) {
+				node->set_input_connection(i, p_new_name);
+			}
+		}
+	}
+}
+
+void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) {
+
+	ERR_FAIL_COND(!nodes.has(p_output_node));
+	ERR_FAIL_COND(!nodes.has(p_input_node));
+	ERR_FAIL_COND(p_output_node == SceneStringNames::get_singleton()->output);
+	ERR_FAIL_COND(p_input_node == p_output_node);
+
+	Ref<AnimationNode> input = nodes[p_input_node];
+	ERR_FAIL_INDEX(p_input_index, input->get_input_count());
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		for (int i = 0; i < node->get_input_count(); i++) {
+			StringName output = node->get_input_connection(i);
+			ERR_FAIL_COND(output == p_output_node);
+		}
+	}
+
+	input->set_input_connection(p_input_index, p_output_node);
+	emit_changed();
+}
+
+void AnimationNodeBlendTree::disconnect_node(const StringName &p_node, int p_input_index) {
+
+	ERR_FAIL_COND(!nodes.has(p_node));
+
+	Ref<AnimationNode> input = nodes[p_node];
+	ERR_FAIL_INDEX(p_input_index, input->get_input_count());
+
+	input->set_input_connection(p_input_index, StringName());
+}
+
+float AnimationNodeBlendTree::get_connection_activity(const StringName &p_input_node, int p_input_index) const {
+
+	ERR_FAIL_COND_V(!nodes.has(p_input_node), 0);
+
+	Ref<AnimationNode> input = nodes[p_input_node];
+	ERR_FAIL_INDEX_V(p_input_index, input->get_input_count(), 0);
+
+	return input->get_input_activity(p_input_index);
+}
+
+AnimationNodeBlendTree::ConnectionError AnimationNodeBlendTree::can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const {
+
+	if (!nodes.has(p_output_node) || p_output_node == SceneStringNames::get_singleton()->output) {
+		return CONNECTION_ERROR_NO_OUTPUT;
+	}
+
+	if (!nodes.has(p_input_node)) {
+		return CONNECTION_ERROR_NO_INPUT;
+	}
+
+	if (!nodes.has(p_input_node)) {
+		return CONNECTION_ERROR_SAME_NODE;
+	}
+
+	Ref<AnimationNode> input = nodes[p_input_node];
+
+	if (p_input_index < 0 || p_input_index >= input->get_input_count()) {
+		return CONNECTION_ERROR_NO_INPUT_INDEX;
+	}
+
+	if (input->get_input_connection(p_input_index) != StringName()) {
+		return CONNECTION_ERROR_CONNECTION_EXISTS;
+	}
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		for (int i = 0; i < node->get_input_count(); i++) {
+			StringName output = node->get_input_connection(i);
+			if (output == p_output_node) {
+				return CONNECTION_ERROR_CONNECTION_EXISTS;
+			}
+		}
+	}
+	return CONNECTION_OK;
+}
+
+void AnimationNodeBlendTree::get_node_connections(List<NodeConnection> *r_connections) const {
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		for (int i = 0; i < node->get_input_count(); i++) {
+			StringName output = node->get_input_connection(i);
+			if (output != StringName()) {
+				NodeConnection nc;
+				nc.input_node = E->key();
+				nc.input_index = i;
+				nc.output_node = output;
+				r_connections->push_back(nc);
+			}
+		}
+	}
+}
+
+String AnimationNodeBlendTree::get_caption() const {
+	return "BlendTree";
+}
+
+float AnimationNodeBlendTree::process(float p_time, bool p_seek) {
+
+	Ref<AnimationNodeOutput> output = nodes[SceneStringNames::get_singleton()->output];
+	return blend_node(output, p_time, p_seek, 1.0);
+}
+
+void AnimationNodeBlendTree::get_node_list(List<StringName> *r_list) {
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		r_list->push_back(E->key());
+	}
+}
+
+void AnimationNodeBlendTree::set_graph_offset(const Vector2 &p_graph_offset) {
+
+	graph_offset = p_graph_offset;
+}
+
+Vector2 AnimationNodeBlendTree::get_graph_offset() const {
+
+	return graph_offset;
+}
+
+void AnimationNodeBlendTree::set_graph_player(AnimationGraphPlayer *p_player) {
+
+	AnimationNode::set_graph_player(p_player);
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		Ref<AnimationNode> node = E->get();
+		node->set_graph_player(p_player);
+	}
+}
+
+bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_value) {
+
+	String name = p_name;
+	if (name.begins_with("nodes/")) {
+		String node_name = name.get_slicec('/', 1);
+		String what = name.get_slicec('/', 2);
+
+		if (what == "node") {
+			Ref<AnimationNode> anode = p_value;
+			if (anode.is_valid()) {
+				add_node(node_name, p_value);
+			}
+			return true;
+		}
+
+		if (what == "position") {
+
+			if (nodes.has(node_name)) {
+				nodes[node_name]->set_position(p_value);
+			}
+			return true;
+		}
+	} else if (name == "node_connections") {
+
+		Array conns = p_value;
+		ERR_FAIL_COND_V(conns.size() % 3 != 0, false);
+
+		for (int i = 0; i < conns.size(); i += 3) {
+			connect_node(conns[i], conns[i + 1], conns[i + 2]);
+		}
+		return true;
+	}
+
+	return false;
+}
+
+bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) const {
+
+	String name = p_name;
+	if (name.begins_with("nodes/")) {
+		String node_name = name.get_slicec('/', 1);
+		String what = name.get_slicec('/', 2);
+
+		if (what == "node") {
+			if (nodes.has(node_name)) {
+				r_ret = nodes[node_name];
+				return true;
+			}
+		}
+
+		if (what == "position") {
+
+			if (nodes.has(node_name)) {
+				r_ret = nodes[node_name]->get_position();
+				return true;
+			}
+		}
+	} else if (name == "node_connections") {
+		List<NodeConnection> nc;
+		get_node_connections(&nc);
+		Array conns;
+		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;
+			idx++;
+		}
+
+		r_ret = conns;
+		return true;
+	}
+
+	return false;
+}
+void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) const {
+
+	List<StringName> names;
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		names.push_back(E->key());
+	}
+	names.sort_custom<StringName::AlphCompare>();
+
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		String name = E->get();
+		if (name != "output") {
+			p_list->push_back(PropertyInfo(Variant::OBJECT, "nodes/" + name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
+		}
+		p_list->push_back(PropertyInfo(Variant::VECTOR2, "nodes/" + name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+	}
+
+	p_list->push_back(PropertyInfo(Variant::ARRAY, "node_connections", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+}
+
+void AnimationNodeBlendTree::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("add_node", "name", "node"), &AnimationNodeBlendTree::add_node);
+	ClassDB::bind_method(D_METHOD("get_node", "name"), &AnimationNodeBlendTree::get_node);
+	ClassDB::bind_method(D_METHOD("remove_node", "name"), &AnimationNodeBlendTree::remove_node);
+	ClassDB::bind_method(D_METHOD("rename_node", "name", "new_name"), &AnimationNodeBlendTree::rename_node);
+	ClassDB::bind_method(D_METHOD("has_node", "name"), &AnimationNodeBlendTree::has_node);
+	ClassDB::bind_method(D_METHOD("connect_node", "input_node", "input_index", "output_node"), &AnimationNodeBlendTree::connect_node);
+	ClassDB::bind_method(D_METHOD("disconnect_node", "input_node", "input_index"), &AnimationNodeBlendTree::disconnect_node);
+
+	ClassDB::bind_method(D_METHOD("set_graph_offset", "offset"), &AnimationNodeBlendTree::set_graph_offset);
+	ClassDB::bind_method(D_METHOD("get_graph_offset"), &AnimationNodeBlendTree::get_graph_offset);
+
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_graph_offset", "get_graph_offset");
+
+	BIND_CONSTANT(CONNECTION_OK);
+	BIND_CONSTANT(CONNECTION_ERROR_NO_INPUT);
+	BIND_CONSTANT(CONNECTION_ERROR_NO_INPUT_INDEX);
+	BIND_CONSTANT(CONNECTION_ERROR_NO_OUTPUT);
+	BIND_CONSTANT(CONNECTION_ERROR_SAME_NODE);
+	BIND_CONSTANT(CONNECTION_ERROR_CONNECTION_EXISTS);
+}
+
+AnimationNodeBlendTree::AnimationNodeBlendTree() {
+
+	Ref<AnimationNodeOutput> output;
+	output.instance();
+	output->set_position(Vector2(300, 150));
+	output->set_parent(this);
+	nodes["output"] = output;
+}
+
+AnimationNodeBlendTree::~AnimationNodeBlendTree() {
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		E->get()->set_parent(NULL);
+		E->get()->set_graph_player(NULL);
+	}
+}
diff --git a/scene/animation/animation_blend_tree.h b/scene/animation/animation_blend_tree.h
new file mode 100644
index 0000000000..7623fd3e57
--- /dev/null
+++ b/scene/animation/animation_blend_tree.h
@@ -0,0 +1,328 @@
+#ifndef ANIMATION_BLEND_TREE_H
+#define ANIMATION_BLEND_TREE_H
+
+#include "scene/animation/animation_graph_player.h"
+
+class AnimationNodeAnimation : public AnimationRootNode {
+
+	GDCLASS(AnimationNodeAnimation, AnimationRootNode);
+
+	StringName animation;
+
+	uint64_t last_version;
+	float time;
+	float step;
+	bool skip;
+
+protected:
+	void _validate_property(PropertyInfo &property) const;
+
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+	virtual float process(float p_time, bool p_seek);
+
+	void set_animation(const StringName &p_name);
+	StringName get_animation() const;
+
+	float get_playback_time() const;
+
+	AnimationNodeAnimation();
+};
+
+class AnimationNodeOneShot : public AnimationNode {
+	GDCLASS(AnimationNodeOneShot, AnimationNode);
+
+public:
+	enum MixMode {
+		MIX_MODE_BLEND,
+		MIX_MODE_ADD
+	};
+
+private:
+	bool active;
+	bool do_start;
+	float fade_in;
+	float fade_out;
+
+	bool autorestart;
+	float autorestart_delay;
+	float autorestart_random_delay;
+	MixMode mix;
+
+	float time;
+	float remaining;
+	float autorestart_remaining;
+	bool sync;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+
+	void set_fadein_time(float p_time);
+	void set_fadeout_time(float p_time);
+
+	float get_fadein_time() const;
+	float get_fadeout_time() const;
+
+	void set_autorestart(bool p_active);
+	void set_autorestart_delay(float p_time);
+	void set_autorestart_random_delay(float p_time);
+
+	bool has_autorestart() const;
+	float get_autorestart_delay() const;
+	float get_autorestart_random_delay() const;
+
+	void set_mix_mode(MixMode p_mix);
+	MixMode get_mix_mode() const;
+
+	void start();
+	void stop();
+	bool is_active() const;
+
+	void set_use_sync(bool p_sync);
+	bool is_using_sync() const;
+
+	virtual bool has_filter() const;
+	virtual float process(float p_time, bool p_seek);
+
+	AnimationNodeOneShot();
+};
+
+VARIANT_ENUM_CAST(AnimationNodeOneShot::MixMode)
+
+class AnimationNodeAdd : public AnimationNode {
+	GDCLASS(AnimationNodeAdd, AnimationNode);
+
+	float amount;
+	bool sync;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+
+	void set_amount(float p_amount);
+	float get_amount() const;
+
+	void set_use_sync(bool p_sync);
+	bool is_using_sync() const;
+
+	virtual bool has_filter() const;
+	virtual float process(float p_time, bool p_seek);
+
+	AnimationNodeAdd();
+};
+
+class AnimationNodeBlend2 : public AnimationNode {
+	GDCLASS(AnimationNodeBlend2, AnimationNode);
+
+	float amount;
+	bool sync;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+	virtual float process(float p_time, bool p_seek);
+
+	void set_amount(float p_amount);
+	float get_amount() const;
+
+	void set_use_sync(bool p_sync);
+	bool is_using_sync() const;
+
+	virtual bool has_filter() const;
+	AnimationNodeBlend2();
+};
+
+class AnimationNodeBlend3 : public AnimationNode {
+	GDCLASS(AnimationNodeBlend3, AnimationNode);
+
+	float amount;
+	bool sync;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+
+	void set_amount(float p_amount);
+	float get_amount() const;
+
+	void set_use_sync(bool p_sync);
+	bool is_using_sync() const;
+
+	float process(float p_time, bool p_seek);
+	AnimationNodeBlend3();
+};
+
+class AnimationNodeTimeScale : public AnimationNode {
+	GDCLASS(AnimationNodeTimeScale, AnimationNode);
+
+	float scale;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+
+	void set_scale(float p_scale);
+	float get_scale() const;
+
+	float process(float p_time, bool p_seek);
+
+	AnimationNodeTimeScale();
+};
+
+class AnimationNodeTimeSeek : public AnimationNode {
+	GDCLASS(AnimationNodeTimeSeek, AnimationNode);
+
+	float seek_pos;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const;
+
+	void set_seek_pos(float p_sec);
+	float get_seek_pos() const;
+
+	float process(float p_time, bool p_seek);
+
+	AnimationNodeTimeSeek();
+};
+
+class AnimationNodeTransition : public AnimationNode {
+	GDCLASS(AnimationNodeTransition, AnimationNode);
+
+	enum {
+		MAX_INPUTS = 32
+	};
+	struct InputData {
+
+		String name;
+		bool auto_advance;
+		InputData() { auto_advance = false; }
+	};
+
+	InputData inputs[MAX_INPUTS];
+	int enabled_inputs;
+
+	float prev_time;
+	float prev_xfading;
+	int prev;
+	bool switched;
+
+	float time;
+	int current;
+
+	float xfade;
+
+	void _update_inputs();
+
+protected:
+	static void _bind_methods();
+	void _validate_property(PropertyInfo &property) const;
+
+public:
+	virtual String get_caption() const;
+
+	void set_enabled_inputs(int p_inputs);
+	int get_enabled_inputs();
+
+	void set_input_as_auto_advance(int p_input, bool p_enable);
+	bool is_input_set_as_auto_advance(int p_input) const;
+
+	void set_input_caption(int p_input, const String &p_name);
+	String get_input_caption(int p_input) const;
+
+	void set_current(int p_current);
+	int get_current() const;
+
+	void set_cross_fade_time(float p_fade);
+	float get_cross_fade_time() const;
+
+	float process(float p_time, bool p_seek);
+
+	AnimationNodeTransition();
+};
+
+class AnimationNodeOutput : public AnimationNode {
+	GDCLASS(AnimationNodeOutput, AnimationNode)
+public:
+	virtual String get_caption() const;
+	virtual float process(float p_time, bool p_seek);
+	AnimationNodeOutput();
+};
+
+/////
+
+class AnimationNodeBlendTree : public AnimationRootNode {
+	GDCLASS(AnimationNodeBlendTree, AnimationRootNode)
+
+	Map<StringName, Ref<AnimationNode> > nodes;
+
+	Vector2 graph_offset;
+
+protected:
+	static void _bind_methods();
+	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;
+
+public:
+	enum ConnectionError {
+		CONNECTION_OK,
+		CONNECTION_ERROR_NO_INPUT,
+		CONNECTION_ERROR_NO_INPUT_INDEX,
+		CONNECTION_ERROR_NO_OUTPUT,
+		CONNECTION_ERROR_SAME_NODE,
+		CONNECTION_ERROR_CONNECTION_EXISTS,
+		//no need to check for cycles due to tree topology
+	};
+
+	void add_node(const StringName &p_name, Ref<AnimationNode> p_node);
+	Ref<AnimationNode> get_node(const StringName &p_name) const;
+	void remove_node(const StringName &p_name);
+	void rename_node(const StringName &p_name, const StringName &p_new_name);
+	bool has_node(const StringName &p_name) const;
+	StringName get_node_name(const Ref<AnimationNode> &p_node) const;
+
+	void connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node);
+	void disconnect_node(const StringName &p_node, int p_input_index);
+	float get_connection_activity(const StringName &p_input_node, int p_input_index) const;
+
+	struct NodeConnection {
+		StringName input_node;
+		int input_index;
+		StringName output_node;
+	};
+
+	ConnectionError can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const;
+	void get_node_connections(List<NodeConnection> *r_connections) const;
+
+	virtual String get_caption() const;
+	virtual float process(float p_time, bool p_seek);
+
+	void get_node_list(List<StringName> *r_list);
+
+	void set_graph_offset(const Vector2 &p_graph_offset);
+	Vector2 get_graph_offset() const;
+
+	virtual void set_graph_player(AnimationGraphPlayer *p_player);
+	AnimationNodeBlendTree();
+	~AnimationNodeBlendTree();
+};
+
+VARIANT_ENUM_CAST(AnimationNodeBlendTree::ConnectionError)
+
+#endif // ANIMATION_BLEND_TREE_H
diff --git a/scene/animation/animation_graph_player.cpp b/scene/animation/animation_graph_player.cpp
new file mode 100644
index 0000000000..b8efecebe9
--- /dev/null
+++ b/scene/animation/animation_graph_player.cpp
@@ -0,0 +1,1211 @@
+#include "animation_graph_player.h"
+#include "animation_blend_tree.h"
+#include "core/method_bind_ext.gen.inc"
+#include "engine.h"
+#include "scene/scene_string_names.h"
+#include "servers/audio/audio_stream.h"
+
+void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) {
+
+	ERR_FAIL_COND(!state);
+	ERR_FAIL_COND(!state->player->has_animation(p_animation));
+
+	Ref<Animation> animation = state->player->get_animation(p_animation);
+
+	if (animation.is_null()) {
+
+		Ref<AnimationNodeBlendTree> btree = get_parent();
+		if (btree.is_valid()) {
+			String name = btree->get_node_name(Ref<AnimationNodeAnimation>(this));
+			make_invalid(vformat(RTR("In node '%s', invalid animation: '%s'."), name, p_animation));
+		} else {
+			make_invalid(vformat(RTR("Invalid animation: '%s'."), p_animation));
+		}
+		return;
+	}
+
+	ERR_FAIL_COND(!animation.is_valid());
+
+	AnimationState anim_state;
+	anim_state.blend = p_blend;
+	anim_state.track_blends = &blends;
+	anim_state.delta = p_delta;
+	anim_state.time = p_time;
+	anim_state.animation = animation;
+	anim_state.seeked = p_seeked;
+
+	state->animation_states.push_back(anim_state);
+}
+
+float AnimationNode::_pre_process(State *p_state, float p_time, bool p_seek) {
+	state = p_state;
+	float t = process(p_time, p_seek);
+	state = NULL;
+	return t;
+}
+
+void AnimationNode::make_invalid(const String &p_reason) {
+	ERR_FAIL_COND(!state);
+	state->valid = false;
+	if (state->invalid_reasons != String()) {
+		state->invalid_reasons += "\n";
+	}
+	state->invalid_reasons += "- " + p_reason;
+}
+
+float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), 0);
+	ERR_FAIL_COND_V(!state, 0);
+	ERR_FAIL_COND_V(!get_graph_player(), 0); //should not happen, but used to catch bugs
+
+	Ref<AnimationNodeBlendTree> tree = get_parent();
+
+	if (!tree.is_valid() && get_graph_player()->get_graph_root().ptr() != this) {
+		make_invalid(RTR("Can't blend input because node is not in a tree"));
+		return 0;
+	}
+
+	ERR_FAIL_COND_V(!tree.is_valid(), 0); //should not happen
+
+	StringName anim_name = inputs[p_input].connected_to;
+
+	Ref<AnimationNode> node = tree->get_node(anim_name);
+
+	if (node.is_null()) {
+
+		String name = tree->get_node_name(Ref<AnimationNodeAnimation>(this));
+		make_invalid(vformat(RTR("Nothing connected to input '%s' of node '%s'."), get_input_name(p_input), name));
+		return 0;
+	}
+
+	inputs[p_input].last_pass = state->last_pass;
+
+	return _blend_node(node, p_time, p_seek, p_blend, p_filter, p_optimize, &inputs[p_input].activity);
+}
+
+float AnimationNode::blend_node(Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
+
+	return _blend_node(p_node, p_time, p_seek, p_blend, p_filter, p_optimize);
+}
+
+float AnimationNode::_blend_node(Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize, float *r_max) {
+
+	ERR_FAIL_COND_V(!p_node.is_valid(), 0);
+	ERR_FAIL_COND_V(!state, 0);
+
+	int blend_count = blends.size();
+
+	if (p_node->blends.size() != blend_count) {
+		p_node->blends.resize(blend_count);
+	}
+
+	float *blendw = p_node->blends.ptrw();
+	const float *blendr = blends.ptr();
+
+	bool any_valid = false;
+
+	if (has_filter() && is_filter_enabled() && p_filter != FILTER_IGNORE) {
+
+		for (int i = 0; i < blend_count; i++) {
+			blendw[i] = 0.0; //all to zero by default
+		}
+
+		const NodePath *K = NULL;
+		while ((K = filter.next(K))) {
+			if (!state->track_map.has(*K)) {
+				continue;
+			}
+			int idx = state->track_map[*K];
+			blendw[idx] = 1.0; //filtered goes to one
+		}
+
+		switch (p_filter) {
+			case FILTER_IGNORE:
+				break; //will not happen anyway
+			case FILTER_PASS: {
+				//values filtered pass, the rest dont
+				for (int i = 0; i < blend_count; i++) {
+					if (blendw[i] == 0) //not filtered, does not pass
+						continue;
+
+					blendw[i] = blendr[i] * p_blend;
+					if (blendw[i] > CMP_EPSILON) {
+						any_valid = true;
+					}
+				}
+
+			} break;
+			case FILTER_STOP: {
+
+				//values filtered dont pass, the rest are blended
+
+				for (int i = 0; i < blend_count; i++) {
+					if (blendw[i] > 0) //filtered, does not pass
+						continue;
+
+					blendw[i] = blendr[i] * p_blend;
+					if (blendw[i] > CMP_EPSILON) {
+						any_valid = true;
+					}
+				}
+
+			} break;
+			case FILTER_BLEND: {
+
+				//filtered values are blended, the rest are passed without blending
+
+				for (int i = 0; i < blend_count; i++) {
+					if (blendw[i] == 1.0) {
+						blendw[i] = blendr[i] * p_blend; //filtered, blend
+					} else {
+						blendw[i] = blendr[i]; //not filtered, do not blend
+					}
+
+					if (blendw[i] > CMP_EPSILON) {
+						any_valid = true;
+					}
+				}
+
+			} break;
+		}
+	} else {
+		for (int i = 0; i < blend_count; i++) {
+
+			//regular blend
+			blendw[i] = blendr[i] * p_blend;
+			if (blendw[i] > CMP_EPSILON) {
+				any_valid = true;
+			}
+		}
+	}
+
+	if (r_max) {
+		*r_max = 0;
+		for (int i = 0; i < blend_count; i++) {
+			*r_max = MAX(*r_max, blendw[i]);
+		}
+	}
+
+	if (!p_seek && p_optimize && !any_valid) //pointless to go on, all are zero
+		return 0;
+
+	return p_node->_pre_process(state, p_time, p_seek);
+}
+
+int AnimationNode::get_input_count() const {
+
+	return inputs.size();
+}
+String AnimationNode::get_input_name(int p_input) {
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), String());
+	return inputs[p_input].name;
+}
+
+float AnimationNode::get_input_activity(int p_input) const {
+
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), 0);
+	if (!get_graph_player())
+		return 0;
+
+	if (get_graph_player()->get_last_process_pass() != inputs[p_input].last_pass) {
+		return 0;
+	}
+	return inputs[p_input].activity;
+}
+StringName AnimationNode::get_input_connection(int p_input) {
+
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), StringName());
+	return inputs[p_input].connected_to;
+}
+
+void AnimationNode::set_input_connection(int p_input, const StringName &p_connection) {
+
+	ERR_FAIL_INDEX(p_input, inputs.size());
+	inputs[p_input].connected_to = p_connection;
+}
+
+String AnimationNode::get_caption() const {
+	return "Node";
+}
+
+void AnimationNode::add_input(const String &p_name) {
+	//root nodes cant add inputs
+	ERR_FAIL_COND(Object::cast_to<AnimationRootNode>(this) != NULL)
+	Input input;
+	ERR_FAIL_COND(p_name.find(".") != -1 || p_name.find("/") != -1);
+	input.name = p_name;
+	input.activity = 0;
+	input.last_pass = 0;
+	inputs.push_back(input);
+	emit_changed();
+}
+
+void AnimationNode::set_input_name(int p_input, const String &p_name) {
+	ERR_FAIL_INDEX(p_input, inputs.size());
+	ERR_FAIL_COND(p_name.find(".") != -1 || p_name.find("/") != -1);
+	inputs[p_input].name = p_name;
+	emit_changed();
+}
+
+void AnimationNode::remove_input(int p_index) {
+	ERR_FAIL_INDEX(p_index, inputs.size());
+	inputs.remove(p_index);
+	emit_changed();
+}
+
+void AnimationNode::set_parent(AnimationNode *p_parent) {
+	parent = p_parent; //do not use ref because parent contains children
+}
+
+Ref<AnimationNode> AnimationNode::get_parent() const {
+	if (parent) {
+		return Ref<AnimationNode>(parent);
+	}
+
+	return Ref<AnimationNode>();
+}
+
+AnimationGraphPlayer *AnimationNode::get_graph_player() const {
+
+	return player;
+}
+
+AnimationPlayer *AnimationNode::get_player() const {
+	ERR_FAIL_COND_V(!state, NULL);
+	return state->player;
+}
+
+float AnimationNode::process(float p_time, bool p_seek) {
+
+	if (get_script_instance()) {
+		return get_script_instance()->call("process", p_time, p_seek);
+	}
+
+	return 0;
+}
+
+void AnimationNode::set_filter_path(const NodePath &p_path, bool p_enable) {
+	if (p_enable) {
+		filter[p_path] = true;
+	} else {
+		filter.erase(p_path);
+	}
+}
+
+void AnimationNode::set_filter_enabled(bool p_enable) {
+	filter_enabled = p_enable;
+}
+
+bool AnimationNode::is_filter_enabled() const {
+	return filter_enabled;
+}
+
+bool AnimationNode::is_path_filtered(const NodePath &p_path) const {
+	return filter.has(p_path);
+}
+
+bool AnimationNode::has_filter() const {
+	return false;
+}
+
+void AnimationNode::set_position(const Vector2 &p_position) {
+	position = p_position;
+}
+
+Vector2 AnimationNode::get_position() const {
+	return position;
+}
+
+void AnimationNode::set_graph_player(AnimationGraphPlayer *p_player) {
+
+	if (player != NULL && p_player == NULL) {
+		emit_signal("removed_from_graph");
+	}
+	player = p_player;
+}
+
+Array AnimationNode::_get_filters() const {
+
+	Array paths;
+
+	const NodePath *K = NULL;
+	while ((K = filter.next(K))) {
+		paths.push_back(String(*K)); //use strings, so sorting is possible
+	}
+	paths.sort(); //done so every time the scene is saved, it does not change
+
+	return paths;
+}
+void AnimationNode::_set_filters(const Array &p_filters) {
+	filter.clear();
+	for (int i = 0; i < p_filters.size(); i++) {
+		set_filter_path(p_filters[i], true);
+	}
+}
+
+void AnimationNode::_validate_property(PropertyInfo &property) const {
+	if (!has_filter() && (property.name == "filter_enabled" || property.name == "filters")) {
+		property.usage = 0;
+	}
+}
+
+void AnimationNode::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("get_input_count"), &AnimationNode::get_input_count);
+	ClassDB::bind_method(D_METHOD("get_input_name", "input"), &AnimationNode::get_input_name);
+	ClassDB::bind_method(D_METHOD("get_input_connection", "input"), &AnimationNode::get_input_connection);
+	ClassDB::bind_method(D_METHOD("get_input_activity", "input"), &AnimationNode::get_input_activity);
+
+	ClassDB::bind_method(D_METHOD("add_input", "name"), &AnimationNode::add_input);
+	ClassDB::bind_method(D_METHOD("remove_input", "index"), &AnimationNode::remove_input);
+
+	ClassDB::bind_method(D_METHOD("set_filter_path", "path", "enable"), &AnimationNode::set_filter_path);
+	ClassDB::bind_method(D_METHOD("is_path_filtered", "path"), &AnimationNode::is_path_filtered);
+
+	ClassDB::bind_method(D_METHOD("set_filter_enabled", "enable"), &AnimationNode::set_filter_enabled);
+	ClassDB::bind_method(D_METHOD("is_filter_enabled"), &AnimationNode::is_filter_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_position", "position"), &AnimationNode::set_position);
+	ClassDB::bind_method(D_METHOD("get_position"), &AnimationNode::get_position);
+
+	ClassDB::bind_method(D_METHOD("_set_filters", "filters"), &AnimationNode::_set_filters);
+	ClassDB::bind_method(D_METHOD("_get_filters"), &AnimationNode::_get_filters);
+
+	ClassDB::bind_method(D_METHOD("blend_animation", "animation", "time", "delta", "seeked", "blend"), &AnimationNode::blend_animation);
+	ClassDB::bind_method(D_METHOD("blend_node", "node", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_node, DEFVAL(FILTER_IGNORE), DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("blend_input", "input_index", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_input, DEFVAL(FILTER_IGNORE), DEFVAL(true));
+
+	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("process", PropertyInfo(Variant::REAL, "time"), PropertyInfo(Variant::BOOL, "seek")));
+
+	ADD_SIGNAL(MethodInfo("removed_from_graph"));
+	BIND_ENUM_CONSTANT(FILTER_IGNORE);
+	BIND_ENUM_CONSTANT(FILTER_PASS);
+	BIND_ENUM_CONSTANT(FILTER_STOP);
+	BIND_ENUM_CONSTANT(FILTER_BLEND);
+}
+
+AnimationNode::AnimationNode() {
+
+	state = NULL;
+	parent = NULL;
+	player = NULL;
+	set_local_to_scene(true);
+	filter_enabled = false;
+}
+
+////////////////////
+
+void AnimationGraphPlayer::set_graph_root(const Ref<AnimationNode> &p_root) {
+
+	if (root.is_valid()) {
+		root->set_graph_player(NULL);
+	}
+	if (p_root.is_valid()) {
+		ERR_EXPLAIN("root node already set to another player");
+		ERR_FAIL_COND(p_root->player);
+	}
+	root = p_root;
+
+	if (root.is_valid()) {
+		root->set_graph_player(this);
+	}
+
+	update_configuration_warning();
+}
+
+Ref<AnimationNode> AnimationGraphPlayer::get_graph_root() const {
+	return root;
+}
+
+void AnimationGraphPlayer::set_active(bool p_active) {
+
+	if (active == p_active)
+		return;
+
+	active = p_active;
+	started = active;
+
+	if (process_mode == ANIMATION_PROCESS_IDLE) {
+		set_process_internal(active);
+	} else {
+
+		set_physics_process_internal(active);
+	}
+
+	if (!active && is_inside_tree()) {
+		for (Set<TrackCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
+
+			if (ObjectDB::get_instance(E->get()->object_id)) {
+				E->get()->object->call("stop");
+			}
+		}
+
+		playing_caches.clear();
+	}
+}
+
+bool AnimationGraphPlayer::is_active() const {
+
+	return active;
+}
+
+void AnimationGraphPlayer::set_process_mode(AnimationProcessMode p_mode) {
+
+	if (process_mode == p_mode)
+		return;
+
+	bool was_active = is_active();
+	if (was_active) {
+		set_active(false);
+	}
+
+	process_mode = p_mode;
+
+	if (was_active) {
+		set_active(true);
+	}
+}
+
+AnimationGraphPlayer::AnimationProcessMode AnimationGraphPlayer::get_process_mode() const {
+	return process_mode;
+}
+
+void AnimationGraphPlayer::_node_removed(Node *p_node) {
+	cache_valid = false;
+}
+
+bool AnimationGraphPlayer::_update_caches(AnimationPlayer *player) {
+
+	setup_pass++;
+
+	if (!player->has_node(player->get_root())) {
+		ERR_PRINT("AnimationGraphPlayer: AnimationPlayer root is invalid.");
+		set_active(false);
+		return false;
+	}
+	Node *parent = player->get_node(player->get_root());
+
+	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 (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);
+
+			TrackCache *track = NULL;
+			if (track_cache.has(path)) {
+				track = track_cache.get(path);
+			}
+
+			//if not valid, delete track
+			if (track && (track->type != track_type || ObjectDB::get_instance(track->object_id) == NULL)) {
+				playing_caches.erase(track);
+				memdelete(track);
+				track_cache.erase(path);
+				track = NULL;
+			}
+
+			if (!track) {
+
+				RES resource;
+				Vector<StringName> leftover_path;
+				Node *child = parent->get_node_and_resource(path, resource, leftover_path);
+
+				if (!child) {
+					ERR_PRINTS("AnimationGraphPlayer: '" + String(E->get()) + "', couldn't resolve track:  '" + String(path) + "'");
+					continue;
+				}
+
+				if (!child->is_connected("tree_exited", this, "_node_removed")) {
+					child->connect("tree_exited", this, "_node_removed", varray(child));
+				}
+
+				switch (track_type) {
+					case Animation::TYPE_VALUE: {
+
+						TrackCacheValue *track_value = memnew(TrackCacheValue);
+
+						if (resource.is_valid()) {
+							track_value->object = resource.ptr();
+						} else {
+							track_value->object = child;
+						}
+
+						track_value->subpath = leftover_path;
+						track_value->object_id = track_value->object->get_instance_id();
+
+						track = track_value;
+
+					} break;
+					case Animation::TYPE_TRANSFORM: {
+
+						Spatial *spatial = Object::cast_to<Spatial>(child);
+
+						if (!spatial) {
+							ERR_PRINTS("AnimationGraphPlayer: '" + String(E->get()) + "', transform track does not point to spatial:  '" + String(path) + "'");
+							continue;
+						}
+
+						TrackCacheTransform *track_xform = memnew(TrackCacheTransform);
+
+						track_xform->spatial = spatial;
+						track_xform->skeleton = NULL;
+						track_xform->bone_idx = -1;
+
+						if (path.get_subname_count() == 1 && Object::cast_to<Skeleton>(spatial)) {
+
+							Skeleton *sk = Object::cast_to<Skeleton>(spatial);
+							int bone_idx = sk->find_bone(path.get_subname(0));
+							if (bone_idx != -1 && !sk->is_bone_ignore_animation(bone_idx)) {
+
+								track_xform->skeleton = sk;
+								track_xform->bone_idx = bone_idx;
+							}
+						}
+
+						track_xform->object = spatial;
+						track_xform->object_id = track_xform->object->get_instance_id();
+
+						track = track_xform;
+
+					} break;
+					case Animation::TYPE_METHOD: {
+
+						TrackCacheMethod *track_method = memnew(TrackCacheMethod);
+
+						if (resource.is_valid()) {
+							track_method->object = resource.ptr();
+						} else {
+							track_method->object = child;
+						}
+
+						track_method->object_id = track_method->object->get_instance_id();
+
+						track = track_method;
+
+					} break;
+					case Animation::TYPE_BEZIER: {
+
+						TrackCacheBezier *track_bezier = memnew(TrackCacheBezier);
+
+						if (resource.is_valid()) {
+							track_bezier->object = resource.ptr();
+						} else {
+							track_bezier->object = child;
+						}
+
+						track_bezier->subpath = leftover_path;
+						track_bezier->object_id = track_bezier->object->get_instance_id();
+
+						track = track_bezier;
+					} break;
+					case Animation::TYPE_AUDIO: {
+
+						TrackCacheAudio *track_audio = memnew(TrackCacheAudio);
+
+						track_audio->object = child;
+						track_audio->object_id = track_audio->object->get_instance_id();
+
+						track = track_audio;
+
+					} break;
+					case Animation::TYPE_ANIMATION: {
+
+						TrackCacheAnimation *track_animation = memnew(TrackCacheAnimation);
+
+						track_animation->object = child;
+						track_animation->object_id = track_animation->object->get_instance_id();
+
+						track = track_animation;
+
+					} break;
+				}
+
+				track_cache[path] = track;
+			}
+
+			track->setup_pass = setup_pass;
+		}
+	}
+
+	List<NodePath> to_delete;
+
+	const NodePath *K = NULL;
+	while ((K = track_cache.next(K))) {
+		TrackCache *tc = track_cache[*K];
+		if (tc->setup_pass != setup_pass) {
+			to_delete.push_back(*K);
+		}
+	}
+
+	while (to_delete.front()) {
+		NodePath np = to_delete.front()->get();
+		memdelete(track_cache[np]);
+		track_cache.erase(np);
+		to_delete.pop_front();
+	}
+
+	state.track_map.clear();
+
+	K = NULL;
+	int idx = 0;
+	while ((K = track_cache.next(K))) {
+		state.track_map[*K] = idx;
+		idx++;
+	}
+
+	state.track_count = idx;
+
+	cache_valid = true;
+
+	return true;
+}
+
+void AnimationGraphPlayer::_clear_caches() {
+
+	const NodePath *K = NULL;
+	while ((K = track_cache.next(K))) {
+		memdelete(track_cache[*K]);
+	}
+	playing_caches.clear();
+
+	track_cache.clear();
+	cache_valid = false;
+}
+
+void AnimationGraphPlayer::_process_graph(float p_delta) {
+
+	//check all tracks, see if they need modification
+
+	if (!root.is_valid()) {
+		ERR_PRINT("AnimationGraphPlayer: root AnimationNode is not set, disabling playback.");
+		set_active(false);
+		cache_valid = false;
+		return;
+	}
+
+	if (!has_node(animation_player)) {
+		ERR_PRINT("AnimationGraphPlayer: no valid AnimationPlayer path set, disabling playback");
+		set_active(false);
+		cache_valid = false;
+		return;
+	}
+
+	AnimationPlayer *player = Object::cast_to<AnimationPlayer>(get_node(animation_player));
+
+	if (!player) {
+		ERR_PRINT("AnimationGraphPlayer: path points to a node not an AnimationPlayer, disabling playback");
+		set_active(false);
+		cache_valid = false;
+		return;
+	}
+
+	if (!cache_valid) {
+		if (!_update_caches(player)) {
+			return;
+		}
+	}
+
+	{ //setup
+
+		process_pass++;
+
+		state.valid = true;
+		state.invalid_reasons = "";
+		state.animation_states.clear(); //will need to be re-created
+		state.valid = true;
+		state.player = player;
+		state.last_pass = process_pass;
+
+		// root source blends
+
+		root->blends.resize(state.track_count);
+		float *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
+		}
+	}
+
+	//process
+
+	{
+
+		if (started) {
+			//if started, seek
+			root->_pre_process(&state, 0, true);
+			started = false;
+		}
+
+		root->_pre_process(&state, p_delta, false);
+	}
+
+	if (!state.valid) {
+		return; //state is not valid. do nothing.
+	}
+	//apply value/transform/bezier blends to track caches and execute method/audio/animation tracks
+
+	{
+
+		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();
+
+			Ref<Animation> a = as.animation;
+			float time = as.time;
+			float delta = as.delta;
+			bool seeked = as.seeked;
+
+			for (int i = 0; i < a->get_track_count(); i++) {
+
+				NodePath path = a->track_get_path(i);
+				TrackCache *track = track_cache[path];
+				if (track->type != a->track_get_type(i)) {
+					continue; //may happen should not
+				}
+
+				ERR_CONTINUE(!state.track_map.has(path));
+				int blend_idx = state.track_map[path];
+
+				ERR_CONTINUE(blend_idx < 0 || blend_idx >= state.track_count);
+
+				float blend = (*as.track_blends)[blend_idx];
+
+				if (blend < CMP_EPSILON)
+					continue; //nothing to blend
+
+				switch (track->type) {
+
+					case Animation::TYPE_TRANSFORM: {
+
+						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
+
+						Vector3 loc;
+						Quat rot;
+						Vector3 scale;
+
+						Error err = a->transform_track_interpolate(i, time, &loc, &rot, &scale);
+						//ERR_CONTINUE(err!=OK); //used for testing, should be removed
+
+						scale -= Vector3(1.0, 1.0, 1.0); //helps make it work properly with Add nodes
+
+						if (err != OK)
+							continue;
+
+						if (t->process_pass != process_pass) {
+
+							t->process_pass = process_pass;
+							t->loc = Vector3();
+							t->rot = Quat();
+							t->scale = Vector3();
+						}
+
+						t->loc = t->loc.linear_interpolate(loc, blend);
+						t->rot = t->rot.slerp(rot, blend);
+						t->scale = t->scale.linear_interpolate(scale, blend);
+
+					} break;
+					case Animation::TYPE_VALUE: {
+
+						TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
+
+						Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
+
+						if (update_mode == Animation::UPDATE_CONTINUOUS || update_mode == Animation::UPDATE_CAPTURE) { //delta == 0 means seek
+
+							Variant value = a->value_track_interpolate(i, time);
+
+							if (value == Variant())
+								continue;
+
+							if (t->process_pass != process_pass) {
+								Variant::CallError ce;
+								t->value = Variant::construct(value.get_type(), NULL, 0, ce); //reset
+								t->process_pass = process_pass;
+							}
+
+							Variant::interpolate(t->value, value, blend, t->value);
+
+						} else if (delta != 0) {
+
+							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());
+								t->object->set_indexed(t->subpath, value);
+							}
+						}
+
+					} break;
+					case Animation::TYPE_METHOD: {
+
+						if (delta == 0) {
+							continue;
+						}
+						TrackCacheMethod *t = static_cast<TrackCacheMethod *>(track);
+
+						List<int> indices;
+
+						a->method_track_get_key_indices(i, time, 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());
+
+							int s = params.size();
+
+							ERR_CONTINUE(s > VARIANT_ARG_MAX);
+							if (can_call) {
+								t->object->call_deferred(
+										method,
+										s >= 1 ? params[0] : Variant(),
+										s >= 2 ? params[1] : Variant(),
+										s >= 3 ? params[2] : Variant(),
+										s >= 4 ? params[3] : Variant(),
+										s >= 5 ? params[4] : Variant());
+							}
+						}
+
+					} break;
+					case Animation::TYPE_BEZIER: {
+
+						TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
+
+						float bezier = a->bezier_track_interpolate(i, time);
+
+						if (t->process_pass != process_pass) {
+							t->value = 0;
+							t->process_pass = process_pass;
+						}
+
+						t->value = Math::lerp(t->value, bezier, blend);
+
+					} break;
+					case Animation::TYPE_AUDIO: {
+
+						TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
+
+						if (seeked) {
+							//find whathever should be playing
+							int idx = a->track_find_key(i, time);
+							if (idx < 0)
+								continue;
+
+							Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
+							if (!stream.is_valid()) {
+								t->object->call("stop");
+								t->playing = false;
+								playing_caches.erase(t);
+							} else {
+								float 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();
+
+								if (start_ofs > len - end_ofs) {
+									t->object->call("stop");
+									t->playing = false;
+									playing_caches.erase(t);
+									continue;
+								}
+
+								t->object->call("set_stream", stream);
+								t->object->call("play", start_ofs);
+
+								t->playing = true;
+								playing_caches.insert(t);
+								if (len && end_ofs > 0) { //force a end at a time
+									t->len = len - start_ofs - end_ofs;
+								} else {
+									t->len = 0;
+								}
+
+								t->start = time;
+							}
+
+						} else {
+							//find stuff to play
+							List<int> to_play;
+							a->track_get_key_indices_in_range(i, time, delta, &to_play);
+							if (to_play.size()) {
+								int idx = to_play.back()->get();
+
+								Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
+								if (!stream.is_valid()) {
+									t->object->call("stop");
+									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();
+
+									t->object->call("set_stream", stream);
+									t->object->call("play", start_ofs);
+
+									t->playing = true;
+									playing_caches.insert(t);
+									if (len && end_ofs > 0) { //force a end at a time
+										t->len = len - start_ofs - end_ofs;
+									} else {
+										t->len = 0;
+									}
+
+									t->start = time;
+								}
+							} else if (t->playing) {
+								if (t->start > time || (t->len > 0 && time - t->start < t->len)) {
+									//time to stop
+									t->object->call("stop");
+									t->playing = false;
+									playing_caches.erase(t);
+								}
+							}
+						}
+
+					} break;
+					case Animation::TYPE_ANIMATION: {
+
+						TrackCacheAnimation *t = static_cast<TrackCacheAnimation *>(track);
+
+						AnimationPlayer *player = Object::cast_to<AnimationPlayer>(t->object);
+
+						if (!player)
+							continue;
+
+						if (delta == 0 || seeked) {
+							//seek
+							int idx = a->track_find_key(i, time);
+							if (idx < 0)
+								continue;
+
+							float 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))
+								continue;
+
+							Ref<Animation> anim = player->get_animation(anim_name);
+
+							float at_anim_pos;
+
+							if (anim->has_loop()) {
+								at_anim_pos = Math::fposmod(time - pos, anim->get_length()); //seek to loop
+							} else {
+								at_anim_pos = MAX(anim->get_length(), time - pos); //seek to end
+							}
+
+							if (player->is_playing() || seeked) {
+								player->play(anim_name);
+								player->seek(at_anim_pos);
+								t->playing = true;
+								playing_caches.insert(t);
+							} else {
+								player->set_assigned_animation(anim_name);
+								player->seek(at_anim_pos, true);
+							}
+						} else {
+							//find stuff to play
+							List<int> to_play;
+							a->track_get_key_indices_in_range(i, time, delta, &to_play);
+							if (to_play.size()) {
+								int idx = to_play.back()->get();
+
+								StringName anim_name = a->animation_track_get_key_animation(i, idx);
+								if (String(anim_name) == "[stop]" || !player->has_animation(anim_name)) {
+
+									if (playing_caches.has(t)) {
+										playing_caches.erase(t);
+										player->stop();
+										t->playing = false;
+									}
+								} else {
+									player->play(anim_name);
+									t->playing = true;
+									playing_caches.insert(t);
+								}
+							}
+						}
+
+					} break;
+				}
+			}
+		}
+	}
+
+	{
+		// finally, set the tracks
+		const NodePath *K = NULL;
+		while ((K = track_cache.next(K))) {
+			TrackCache *track = track_cache[*K];
+			if (track->process_pass != process_pass)
+				continue; //not processed, ignore
+
+			switch (track->type) {
+
+				case Animation::TYPE_TRANSFORM: {
+
+					TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
+
+					Transform xform;
+					xform.origin = t->loc;
+
+					t->scale += Vector3(1.0, 1.0, 1.0); //helps make it work properly with Add nodes
+
+					xform.basis.set_quat_scale(t->rot, t->scale);
+
+					if (t->skeleton && t->bone_idx >= 0) {
+
+						t->skeleton->set_bone_pose(t->bone_idx, xform);
+
+					} else {
+
+						t->spatial->set_transform(xform);
+					}
+
+				} break;
+				case Animation::TYPE_VALUE: {
+
+					TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
+
+					t->object->set_indexed(t->subpath, t->value);
+
+				} break;
+				case Animation::TYPE_BEZIER: {
+
+					TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
+
+					t->object->set_indexed(t->subpath, t->value);
+
+				} break;
+				default: {} //the rest dont matter
+			}
+		}
+	}
+}
+
+void AnimationGraphPlayer::_notification(int p_what) {
+
+	if (active && p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS && process_mode == ANIMATION_PROCESS_PHYSICS) {
+		_process_graph(get_physics_process_delta_time());
+	}
+
+	if (active && p_what == NOTIFICATION_INTERNAL_PROCESS && process_mode == ANIMATION_PROCESS_IDLE) {
+		_process_graph(get_process_delta_time());
+	}
+
+	if (p_what == NOTIFICATION_EXIT_TREE) {
+		_clear_caches();
+	}
+}
+
+void AnimationGraphPlayer::set_animation_player(const NodePath &p_player) {
+	animation_player = p_player;
+	update_configuration_warning();
+}
+
+NodePath AnimationGraphPlayer::get_animation_player() const {
+	return animation_player;
+}
+
+bool AnimationGraphPlayer::is_state_invalid() const {
+
+	return !state.valid;
+}
+String AnimationGraphPlayer::get_invalid_state_reason() const {
+
+	return state.invalid_reasons;
+}
+
+uint64_t AnimationGraphPlayer::get_last_process_pass() const {
+	return process_pass;
+}
+
+String AnimationGraphPlayer::get_configuration_warning() const {
+
+	String warning = Node::get_configuration_warning();
+
+	if (!root.is_valid()) {
+		if (warning != String()) {
+			warning += "\n";
+		}
+		warning += TTR("A root AnimationNode for the graph is not set.");
+	}
+
+	if (!has_node(animation_player)) {
+
+		if (warning != String()) {
+			warning += "\n";
+		}
+
+		warning += TTR("Path to an AnimationPlayer node containing animations is not set.");
+		return warning;
+	}
+
+	AnimationPlayer *player = Object::cast_to<AnimationPlayer>(get_node(animation_player));
+
+	if (!player) {
+		if (warning != String()) {
+			warning += "\n";
+		}
+
+		warning += TTR("Path set for AnimationPlayer does not lead to an AnimationPlayer node.");
+		return warning;
+	}
+
+	if (!player->has_node(player->get_root())) {
+		if (warning != String()) {
+			warning += "\n";
+		}
+
+		warning += TTR("AnimationPlayer root is not a valid node.");
+		return warning;
+	}
+
+	return warning;
+}
+
+void AnimationGraphPlayer::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_active", "active"), &AnimationGraphPlayer::set_active);
+	ClassDB::bind_method(D_METHOD("is_active"), &AnimationGraphPlayer::is_active);
+
+	ClassDB::bind_method(D_METHOD("set_graph_root", "root"), &AnimationGraphPlayer::set_graph_root);
+	ClassDB::bind_method(D_METHOD("get_graph_root"), &AnimationGraphPlayer::get_graph_root);
+
+	ClassDB::bind_method(D_METHOD("set_process_mode", "mode"), &AnimationGraphPlayer::set_process_mode);
+	ClassDB::bind_method(D_METHOD("get_process_mode"), &AnimationGraphPlayer::get_process_mode);
+
+	ClassDB::bind_method(D_METHOD("set_animation_player", "root"), &AnimationGraphPlayer::set_animation_player);
+	ClassDB::bind_method(D_METHOD("get_animation_player"), &AnimationGraphPlayer::get_animation_player);
+
+	ClassDB::bind_method(D_METHOD("_node_removed"), &AnimationGraphPlayer::_node_removed);
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "graph_root", PROPERTY_HINT_RESOURCE_TYPE, "AnimationRootNode", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE), "set_graph_root", "get_graph_root");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "anim_player"), "set_animation_player", "get_animation_player");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "active"), "set_active", "is_active");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "process_mode", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_process_mode", "get_process_mode");
+}
+
+AnimationGraphPlayer::AnimationGraphPlayer() {
+
+	process_mode = ANIMATION_PROCESS_IDLE;
+	active = false;
+	cache_valid = false;
+	setup_pass = 1;
+	started = true;
+}
+
+AnimationGraphPlayer::~AnimationGraphPlayer() {
+	if (root.is_valid()) {
+		root->player = NULL;
+	}
+}
diff --git a/scene/animation/animation_graph_player.h b/scene/animation/animation_graph_player.h
new file mode 100644
index 0000000000..8952be75c9
--- /dev/null
+++ b/scene/animation/animation_graph_player.h
@@ -0,0 +1,267 @@
+#ifndef ANIMATION_GRAPH_PLAYER_H
+#define ANIMATION_GRAPH_PLAYER_H
+
+#include "animation_player.h"
+#include "scene/3d/skeleton.h"
+#include "scene/3d/spatial.h"
+#include "scene/resources/animation.h"
+
+class AnimationNodeBlendTree;
+class AnimationPlayer;
+class AnimationGraphPlayer;
+
+class AnimationNode : public Resource {
+	GDCLASS(AnimationNode, Resource)
+public:
+	enum FilterAction {
+		FILTER_IGNORE,
+		FILTER_PASS,
+		FILTER_STOP,
+		FILTER_BLEND
+	};
+
+	struct Input {
+
+		String name;
+		StringName connected_to;
+		float activity;
+		uint64_t last_pass;
+	};
+
+	Vector<Input> inputs;
+
+	float process_input(int p_input, float p_time, bool p_seek, float p_blend);
+
+	friend class AnimationGraphPlayer;
+
+	struct AnimationState {
+
+		Ref<Animation> animation;
+		float time;
+		float delta;
+		const Vector<float> *track_blends;
+		float blend;
+		bool seeked;
+	};
+
+	struct State {
+
+		int track_count;
+		HashMap<NodePath, int> track_map;
+		List<AnimationState> animation_states;
+		bool valid;
+		AnimationPlayer *player;
+		String invalid_reasons;
+		uint64_t last_pass;
+	};
+
+	Vector<float> blends;
+	State *state;
+	float _pre_process(State *p_state, float p_time, bool p_seek);
+	void _pre_update_animations(HashMap<NodePath, int> *track_map);
+	Vector2 position;
+
+	AnimationNode *parent;
+	AnimationGraphPlayer *player;
+
+	float _blend_node(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 = NULL);
+
+	HashMap<NodePath, bool> filter;
+	bool filter_enabled;
+
+	Array _get_filters() const;
+	void _set_filters(const Array &p_filters);
+
+protected:
+	void blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend);
+	float blend_node(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 make_invalid(const String &p_reason);
+
+	static void _bind_methods();
+
+	void _validate_property(PropertyInfo &property) const;
+
+public:
+	void set_parent(AnimationNode *p_parent);
+	Ref<AnimationNode> get_parent() const;
+	virtual void set_graph_player(AnimationGraphPlayer *p_player);
+	AnimationGraphPlayer *get_graph_player() const;
+	AnimationPlayer *get_player() const;
+
+	virtual float process(float p_time, bool p_seek);
+	virtual String get_caption() const;
+
+	int get_input_count() const;
+	String get_input_name(int p_input);
+	StringName get_input_connection(int p_input);
+	void set_input_connection(int p_input, const StringName &p_connection);
+	float get_input_activity(int p_input) const;
+
+	void add_input(const String &p_name);
+	void set_input_name(int p_input, const String &p_name);
+	void remove_input(int p_index);
+
+	void set_filter_path(const NodePath &p_path, bool p_enable);
+	bool is_path_filtered(const NodePath &p_path) const;
+
+	void set_filter_enabled(bool p_enable);
+	bool is_filter_enabled() const;
+
+	virtual bool has_filter() const;
+
+	void set_position(const Vector2 &p_position);
+	Vector2 get_position() const;
+
+	AnimationNode();
+};
+
+VARIANT_ENUM_CAST(AnimationNode::FilterAction)
+
+//root node does not allow inputs
+class AnimationRootNode : public AnimationNode {
+	GDCLASS(AnimationRootNode, AnimationNode)
+public:
+	AnimationRootNode() {}
+};
+
+class AnimationGraphPlayer : public Node {
+	GDCLASS(AnimationGraphPlayer, Node)
+public:
+	enum AnimationProcessMode {
+		ANIMATION_PROCESS_PHYSICS,
+		ANIMATION_PROCESS_IDLE,
+	};
+
+private:
+	struct TrackCache {
+		uint64_t setup_pass;
+		uint64_t process_pass;
+		Animation::TrackType type;
+		Object *object;
+		ObjectID object_id;
+
+		TrackCache() {
+			setup_pass = 0;
+			process_pass = 0;
+			object = NULL;
+			object_id = 0;
+		}
+		virtual ~TrackCache() {}
+	};
+
+	struct TrackCacheTransform : public TrackCache {
+		Spatial *spatial;
+		Skeleton *skeleton;
+		int bone_idx;
+		Vector3 loc;
+		Quat rot;
+		Vector3 scale;
+
+		TrackCacheTransform() {
+			type = Animation::TYPE_TRANSFORM;
+			spatial = NULL;
+			bone_idx = -1;
+			skeleton = NULL;
+		}
+	};
+
+	struct TrackCacheValue : public TrackCache {
+
+		Variant value;
+		Vector<StringName> subpath;
+		TrackCacheValue() { type = Animation::TYPE_VALUE; }
+	};
+
+	struct TrackCacheMethod : public TrackCache {
+
+		TrackCacheMethod() { type = Animation::TYPE_METHOD; }
+	};
+
+	struct TrackCacheBezier : public TrackCache {
+
+		float value;
+		Vector<StringName> subpath;
+		TrackCacheBezier() {
+			type = Animation::TYPE_BEZIER;
+			value = 0;
+		}
+	};
+
+	struct TrackCacheAudio : public TrackCache {
+
+		bool playing;
+		float start;
+		float len;
+
+		TrackCacheAudio() {
+			type = Animation::TYPE_AUDIO;
+			playing = false;
+			start = 0;
+			len = 0;
+		}
+	};
+
+	struct TrackCacheAnimation : public TrackCache {
+
+		bool playing;
+
+		TrackCacheAnimation() {
+			type = Animation::TYPE_ANIMATION;
+			playing = false;
+		}
+	};
+
+	HashMap<NodePath, TrackCache *> track_cache;
+	Set<TrackCache *> playing_caches;
+
+	Ref<AnimationNode> root;
+
+	AnimationProcessMode process_mode;
+	bool active;
+	NodePath animation_player;
+
+	AnimationNode::State state;
+	bool cache_valid;
+	void _node_removed(Node *p_node);
+	void _caches_cleared();
+
+	void _clear_caches();
+	bool _update_caches(AnimationPlayer *player);
+	void _process_graph(float p_delta);
+
+	uint64_t setup_pass;
+	uint64_t process_pass;
+
+	bool started;
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void set_graph_root(const Ref<AnimationNode> &p_root);
+	Ref<AnimationNode> get_graph_root() const;
+
+	void set_active(bool p_active);
+	bool is_active() const;
+
+	void set_process_mode(AnimationProcessMode p_mode);
+	AnimationProcessMode get_process_mode() const;
+
+	void set_animation_player(const NodePath &p_player);
+	NodePath get_animation_player() const;
+
+	virtual String get_configuration_warning() const;
+
+	bool is_state_invalid() const;
+	String get_invalid_state_reason() const;
+
+	uint64_t get_last_process_pass() const;
+	AnimationGraphPlayer();
+	~AnimationGraphPlayer();
+};
+
+VARIANT_ENUM_CAST(AnimationGraphPlayer::AnimationProcessMode)
+
+#endif // ANIMATION_GRAPH_PLAYER_H
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index a0e0137863..06aaeddf18 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -33,7 +33,7 @@
 #include "engine.h"
 #include "message_queue.h"
 #include "scene/scene_string_names.h"
-
+#include "servers/audio/audio_stream.h"
 #ifdef TOOLS_ENABLED
 void AnimatedValuesBackup::update_skeletons() {
 
@@ -325,10 +325,27 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
 				p_anim->node_cache[i]->property_anim[a->track_get_path(i).get_concatenated_subnames()] = pa;
 			}
 		}
+
+		if (a->track_get_type(i) == Animation::TYPE_BEZIER && leftover_path.size()) {
+
+			if (!p_anim->node_cache[i]->bezier_anim.has(a->track_get_path(i).get_concatenated_subnames())) {
+
+				TrackNodeCache::BezierAnim ba;
+				String path = leftover_path[leftover_path.size() - 1];
+				Vector<String> index = path.split(".");
+				for (int j = 0; j < index.size(); j++) {
+					ba.bezier_property.push_back(index[j]);
+				}
+				ba.object = resource.is_valid() ? (Object *)resource.ptr() : (Object *)child;
+				ba.owner = p_anim->node_cache[i];
+
+				p_anim->node_cache[i]->bezier_anim[a->track_get_path(i).get_concatenated_subnames()] = ba;
+			}
+		}
 	}
 }
 
-void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float p_time, float p_delta, float p_interp, bool p_allow_discrete) {
+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) {
 
 	_ensure_node_caches(p_anim);
 	ERR_FAIL_COND(p_anim->node_cache.size() != p_anim->animation->get_track_count());
@@ -394,7 +411,39 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 				TrackNodeCache::PropertyAnim *pa = &E->get();
 
-				if (a->value_track_get_update_mode(i) == Animation::UPDATE_CONTINUOUS || (p_delta == 0 && a->value_track_get_update_mode(i) == Animation::UPDATE_DISCRETE)) { //delta == 0 means seek
+				Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
+
+				if (update_mode == Animation::UPDATE_CAPTURE) {
+
+					if (p_started) {
+						pa->capture = pa->object->get_indexed(pa->subpath);
+					}
+
+					if (a->track_get_key_count(i) == 0)
+						continue; //eeh not worth it
+
+					float first_key_time = a->track_get_key_time(i, 0);
+
+					if (p_time < first_key_time) {
+						float c = p_time / first_key_time;
+						Variant first_value = a->track_get_key_value(i, 0);
+						Variant interp_value;
+						Variant::interpolate(pa->capture, first_value, c, interp_value);
+
+						if (pa->accum_pass != accum_pass) {
+							ERR_CONTINUE(cache_update_prop_size >= NODE_CACHE_UPDATE_MAX);
+							cache_update_prop[cache_update_prop_size++] = pa;
+							pa->value_accum = interp_value;
+							pa->accum_pass = accum_pass;
+						} else {
+							Variant::interpolate(pa->value_accum, interp_value, p_interp, pa->value_accum);
+						}
+
+						continue; //handled
+					}
+				}
+
+				if (update_mode == Animation::UPDATE_CONTINUOUS || update_mode == Animation::UPDATE_CAPTURE || (p_delta == 0 && update_mode == Animation::UPDATE_DISCRETE)) { //delta == 0 means seek
 
 					Variant value = a->value_track_interpolate(i, p_time);
 
@@ -415,7 +464,7 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 						Variant::interpolate(pa->value_accum, value, p_interp, pa->value_accum);
 					}
 
-				} else if (p_allow_discrete && p_delta != 0) {
+				} else if (p_is_current && p_delta != 0) {
 
 					List<int> indices;
 					a->value_track_get_key_indices(i, p_time, p_delta, &indices);
@@ -470,9 +519,10 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 				if (!nc->node)
 					continue;
-				if (p_delta == 0)
+				if (p_delta == 0) {
 					continue;
-				if (!p_allow_discrete)
+				}
+				if (!p_is_current)
 					break;
 
 				List<int> indices;
@@ -500,11 +550,180 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 				}
 
 			} break;
+			case Animation::TYPE_BEZIER: {
+
+				if (!nc->node)
+					continue;
+
+				Map<StringName, TrackNodeCache::BezierAnim>::Element *E = nc->bezier_anim.find(a->track_get_path(i).get_concatenated_subnames());
+				ERR_CONTINUE(!E); //should it continue, or create a new one?
+
+				TrackNodeCache::BezierAnim *ba = &E->get();
+
+				float bezier = a->bezier_track_interpolate(i, p_time);
+				if (ba->accum_pass != accum_pass) {
+					ERR_CONTINUE(cache_update_bezier_size >= NODE_CACHE_UPDATE_MAX);
+					cache_update_bezier[cache_update_bezier_size++] = ba;
+					ba->bezier_accum = bezier;
+					ba->accum_pass = accum_pass;
+				} else {
+					ba->bezier_accum = Math::lerp(ba->bezier_accum, bezier, p_interp);
+				}
+
+			} break;
+			case Animation::TYPE_AUDIO: {
+
+				if (!nc->node)
+					continue;
+				if (p_delta == 0) {
+					continue;
+				}
+
+				if (p_seeked) {
+					//find whathever should be playing
+					int idx = a->track_find_key(i, p_time);
+					if (idx < 0)
+						continue;
+
+					Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
+					if (!stream.is_valid()) {
+						nc->node->call("stop");
+						nc->audio_playing = false;
+						playing_caches.erase(nc);
+					} else {
+						float start_ofs = a->audio_track_get_key_start_offset(i, idx);
+						start_ofs += p_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();
+
+						if (start_ofs > len - end_ofs) {
+							nc->node->call("stop");
+							nc->audio_playing = false;
+							playing_caches.erase(nc);
+							continue;
+						}
+
+						nc->node->call("set_stream", stream);
+						nc->node->call("play", start_ofs);
+
+						nc->audio_playing = true;
+						playing_caches.insert(nc);
+						if (len && end_ofs > 0) { //force a end at a time
+							nc->audio_len = len - start_ofs - end_ofs;
+						} else {
+							nc->audio_len = 0;
+						}
+
+						nc->audio_start = p_time;
+					}
+
+				} else {
+					//find stuff to play
+					List<int> to_play;
+					a->track_get_key_indices_in_range(i, p_time, p_delta, &to_play);
+					if (to_play.size()) {
+						int idx = to_play.back()->get();
+
+						Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
+						if (!stream.is_valid()) {
+							nc->node->call("stop");
+							nc->audio_playing = false;
+							playing_caches.erase(nc);
+						} 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();
+
+							nc->node->call("set_stream", stream);
+							nc->node->call("play", start_ofs);
+
+							nc->audio_playing = true;
+							playing_caches.insert(nc);
+							if (len && end_ofs > 0) { //force a end at a time
+								nc->audio_len = len - start_ofs - end_ofs;
+							} else {
+								nc->audio_len = 0;
+							}
+
+							nc->audio_start = p_time;
+						}
+					} else if (nc->audio_playing) {
+						if (nc->audio_start > p_time || (nc->audio_len > 0 && p_time - nc->audio_start < nc->audio_len)) {
+							//time to stop
+							nc->node->call("stop");
+							nc->audio_playing = false;
+							playing_caches.erase(nc);
+						}
+					}
+				}
+
+			} break;
+			case Animation::TYPE_ANIMATION: {
+
+				AnimationPlayer *player = Object::cast_to<AnimationPlayer>(nc->node);
+				if (!player)
+					continue;
+
+				if (p_delta == 0 || p_seeked) {
+					//seek
+					int idx = a->track_find_key(i, p_time);
+					if (idx < 0)
+						continue;
+
+					float 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))
+						continue;
+
+					Ref<Animation> anim = player->get_animation(anim_name);
+
+					float at_anim_pos;
+
+					if (anim->has_loop()) {
+						at_anim_pos = Math::fposmod(p_time - pos, anim->get_length()); //seek to loop
+					} else {
+						at_anim_pos = MAX(anim->get_length(), p_time - pos); //seek to end
+					}
+
+					if (player->is_playing() || p_seeked) {
+						player->play(anim_name);
+						player->seek(at_anim_pos);
+						nc->animation_playing = true;
+						playing_caches.insert(nc);
+					} else {
+						player->set_assigned_animation(anim_name);
+						player->seek(at_anim_pos, true);
+					}
+				} else {
+					//find stuff to play
+					List<int> to_play;
+					a->track_get_key_indices_in_range(i, p_time, p_delta, &to_play);
+					if (to_play.size()) {
+						int idx = to_play.back()->get();
+
+						StringName anim_name = a->animation_track_get_key_animation(i, idx);
+						if (String(anim_name) == "[stop]" || !player->has_animation(anim_name)) {
+
+							if (playing_caches.has(nc)) {
+								playing_caches.erase(nc);
+								player->stop();
+								nc->animation_playing = false;
+							}
+						} else {
+							player->play(anim_name);
+							nc->animation_playing = true;
+							playing_caches.insert(nc);
+						}
+					}
+				}
+
+			} break;
 		}
 	}
 }
 
-void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, float p_blend) {
+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;
@@ -553,22 +772,25 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 
 	cd.pos = next_pos;
 
-	_animation_process_animation(cd.from, cd.pos, delta, p_blend, &cd == &playback.current);
+	_animation_process_animation(cd.from, cd.pos, delta, p_blend, &cd == &playback.current, p_seeked, p_started);
 }
-void AnimationPlayer::_animation_process2(float p_delta) {
+void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 
 	Playback &c = playback;
 
 	accum_pass++;
 
-	_animation_process_data(c.current, p_delta, 1.0f);
+	_animation_process_data(c.current, p_delta, 1.0f, c.seeked && p_delta != 0, p_started);
+	if (p_delta != 0) {
+		c.seeked = false;
+	}
 
 	List<Blend>::Element *prev = NULL;
 	for (List<Blend>::Element *E = c.blend.back(); E; E = prev) {
 
 		Blend &b = E->get();
 		float blend = b.blend_left / b.blend_time;
-		_animation_process_data(b.data, p_delta, blend);
+		_animation_process_data(b.data, p_delta, blend, false, false);
 
 		b.blend_left -= Math::absf(speed_scale * p_delta);
 
@@ -652,6 +874,16 @@ void AnimationPlayer::_animation_update_transforms() {
 	}
 
 	cache_update_prop_size = 0;
+
+	for (int i = 0; i < cache_update_bezier_size; i++) {
+
+		TrackNodeCache::BezierAnim *ba = cache_update_bezier[i];
+
+		ERR_CONTINUE(ba->accum_pass != accum_pass);
+		ba->object->set_indexed(ba->bezier_property, ba->bezier_accum);
+	}
+
+	cache_update_bezier_size = 0;
 }
 
 void AnimationPlayer::_animation_process(float p_delta) {
@@ -660,7 +892,12 @@ void AnimationPlayer::_animation_process(float p_delta) {
 
 		end_reached = false;
 		end_notify = false;
-		_animation_process2(p_delta);
+		_animation_process2(p_delta, playback.started);
+
+		if (playback.started) {
+			playback.started = false;
+		}
+
 		_animation_update_transforms();
 		if (end_reached) {
 			if (queued.size()) {
@@ -865,7 +1102,7 @@ void AnimationPlayer::queue(const StringName &p_name) {
 
 void AnimationPlayer::clear_queue() {
 	queued.clear();
-};
+}
 
 void AnimationPlayer::play_backwards(const StringName &p_name, float p_custom_blend) {
 
@@ -930,10 +1167,14 @@ void AnimationPlayer::play(const StringName &p_name, float p_custom_blend, float
 		}
 	}
 
+	_stop_playing_caches();
+
 	c.current.from = &animation_set[name];
 	c.current.pos = p_from_end ? c.current.from->animation->get_length() : 0;
 	c.current.speed_scale = p_custom_scale;
 	c.assigned = p_name;
+	c.seeked = false;
+	c.started = true;
 
 	if (!end_reached)
 		queued.clear();
@@ -1004,6 +1245,7 @@ String AnimationPlayer::get_assigned_animation() const {
 
 void AnimationPlayer::stop(bool p_reset) {
 
+	_stop_playing_caches();
 	Playback &c = playback;
 	c.blend.clear();
 	if (p_reset) {
@@ -1042,6 +1284,7 @@ void AnimationPlayer::seek(float p_time, bool p_update) {
 	}
 
 	playback.current.pos = p_time;
+	playback.seeked = true;
 	if (p_update) {
 		_animation_process(0);
 	}
@@ -1084,6 +1327,25 @@ float AnimationPlayer::get_current_animation_length() const {
 void AnimationPlayer::_animation_changed() {
 
 	clear_caches();
+	emit_signal("caches_cleared");
+}
+
+void AnimationPlayer::_stop_playing_caches() {
+
+	for (Set<TrackNodeCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
+
+		if (E->get()->node && E->get()->audio_playing) {
+			E->get()->node->call("stop");
+		}
+		if (E->get()->node && E->get()->animation_playing) {
+			AnimationPlayer *player = Object::cast_to<AnimationPlayer>(E->get()->node);
+			if (!player)
+				continue;
+			player->stop();
+		}
+	}
+
+	playing_caches.clear();
 }
 
 void AnimationPlayer::_node_removed(Node *p_node) {
@@ -1093,6 +1355,8 @@ void AnimationPlayer::_node_removed(Node *p_node) {
 
 void AnimationPlayer::clear_caches() {
 
+	_stop_playing_caches();
+
 	node_cache_map.clear();
 
 	for (Map<StringName, AnimationData>::Element *E = animation_set.front(); E; E = E->next()) {
@@ -1102,6 +1366,7 @@ void AnimationPlayer::clear_caches() {
 
 	cache_update_size = 0;
 	cache_update_prop_size = 0;
+	cache_update_bezier_size = 0;
 }
 
 void AnimationPlayer::set_active(bool p_active) {
@@ -1358,6 +1623,7 @@ void AnimationPlayer::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("animation_finished", PropertyInfo(Variant::STRING, "anim_name")));
 	ADD_SIGNAL(MethodInfo("animation_changed", PropertyInfo(Variant::STRING, "old_name"), PropertyInfo(Variant::STRING, "new_name")));
 	ADD_SIGNAL(MethodInfo("animation_started", PropertyInfo(Variant::STRING, "anim_name")));
+	ADD_SIGNAL(MethodInfo("caches_cleared"));
 
 	BIND_ENUM_CONSTANT(ANIMATION_PROCESS_PHYSICS);
 	BIND_ENUM_CONSTANT(ANIMATION_PROCESS_IDLE);
@@ -1368,6 +1634,7 @@ AnimationPlayer::AnimationPlayer() {
 	accum_pass = 1;
 	cache_update_size = 0;
 	cache_update_prop_size = 0;
+	cache_update_bezier_size = 0;
 	speed_scale = 1;
 	end_reached = false;
 	end_notify = false;
@@ -1377,6 +1644,8 @@ AnimationPlayer::AnimationPlayer() {
 	root = SceneStringNames::get_singleton()->path_pp;
 	playing = false;
 	active = true;
+	playback.seeked = false;
+	playback.started = false;
 }
 
 AnimationPlayer::~AnimationPlayer() {
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index af2022ddac..49c73e54ad 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -98,6 +98,12 @@ private:
 		Vector3 scale_accum;
 		uint64_t accum_pass;
 
+		bool audio_playing;
+		float audio_start;
+		float audio_len;
+
+		bool animation_playing;
+
 		struct PropertyAnim {
 
 			TrackNodeCache *owner;
@@ -106,6 +112,7 @@ private:
 			Object *object;
 			Variant value_accum;
 			uint64_t accum_pass;
+			Variant capture;
 			PropertyAnim() {
 				accum_pass = 0;
 				object = NULL;
@@ -114,6 +121,22 @@ private:
 
 		Map<StringName, PropertyAnim> property_anim;
 
+		struct BezierAnim {
+
+			Vector<StringName> bezier_property;
+			TrackNodeCache *owner;
+			float bezier_accum;
+			Object *object;
+			uint64_t accum_pass;
+			BezierAnim() {
+				accum_pass = 0;
+				bezier_accum = 0;
+				object = NULL;
+			}
+		};
+
+		Map<StringName, BezierAnim> bezier_anim;
+
 		TrackNodeCache() {
 			skeleton = NULL;
 			spatial = NULL;
@@ -121,6 +144,8 @@ private:
 			accum_pass = 0;
 			bone_idx = -1;
 			node_2d = NULL;
+			audio_playing = false;
+			animation_playing = false;
 		}
 	};
 
@@ -146,6 +171,10 @@ private:
 	int cache_update_size;
 	TrackNodeCache::PropertyAnim *cache_update_prop[NODE_CACHE_UPDATE_MAX];
 	int cache_update_prop_size;
+	TrackNodeCache::BezierAnim *cache_update_bezier[NODE_CACHE_UPDATE_MAX];
+	int cache_update_bezier_size;
+	Set<TrackNodeCache *> playing_caches;
+
 	Map<Ref<Animation>, int> used_anims;
 
 	uint64_t accum_pass;
@@ -202,6 +231,8 @@ private:
 		List<Blend> blend;
 		PlaybackData current;
 		StringName assigned;
+		bool seeked;
+		bool started;
 	} playback;
 
 	List<StringName> queued;
@@ -216,15 +247,16 @@ private:
 
 	NodePath root;
 
-	void _animation_process_animation(AnimationData *p_anim, float p_time, float p_delta, float p_interp, bool p_allow_discrete = true);
+	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 _ensure_node_caches(AnimationData *p_anim);
-	void _animation_process_data(PlaybackData &cd, float p_delta, float p_blend);
-	void _animation_process2(float p_delta);
+	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_update_transforms();
 	void _animation_process(float p_delta);
 
 	void _node_removed(Node *p_node);
+	void _stop_playing_caches();
 
 	// bind helpers
 	PoolVector<String> _get_animation_list() const {
diff --git a/scene/animation/animation_tree_player.cpp b/scene/animation/animation_tree_player.cpp
index ce5b372d72..143684bdf9 100644
--- a/scene/animation/animation_tree_player.cpp
+++ b/scene/animation/animation_tree_player.cpp
@@ -1216,6 +1216,12 @@ String AnimationTreePlayer::animation_node_get_master_animation(const StringName
 	return n->from;
 }
 
+float AnimationTreePlayer::animation_node_get_position(const StringName &p_node) const {
+
+	GET_NODE_V(NODE_ANIMATION, AnimationNode, 0);
+	return n->time;
+}
+
 bool AnimationTreePlayer::animation_node_is_path_filtered(const StringName &p_node, const NodePath &p_path) const {
 
 	GET_NODE_V(NODE_ANIMATION, AnimationNode, 0);
@@ -1724,6 +1730,7 @@ void AnimationTreePlayer::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("animation_node_set_master_animation", "id", "source"), &AnimationTreePlayer::animation_node_set_master_animation);
 	ClassDB::bind_method(D_METHOD("animation_node_get_master_animation", "id"), &AnimationTreePlayer::animation_node_get_master_animation);
+	ClassDB::bind_method(D_METHOD("animation_node_get_position", "id"), &AnimationTreePlayer::animation_node_get_position);
 	ClassDB::bind_method(D_METHOD("animation_node_set_filter_path", "id", "path", "enable"), &AnimationTreePlayer::animation_node_set_filter_path);
 
 	ClassDB::bind_method(D_METHOD("oneshot_node_set_fadein_time", "id", "time_sec"), &AnimationTreePlayer::oneshot_node_set_fadein_time);
diff --git a/scene/animation/animation_tree_player.h b/scene/animation/animation_tree_player.h
index 09d6f6fcb4..d2d7b1c9ec 100644
--- a/scene/animation/animation_tree_player.h
+++ b/scene/animation/animation_tree_player.h
@@ -348,6 +348,7 @@ public:
 	Ref<Animation> animation_node_get_animation(const StringName &p_node) const;
 	void animation_node_set_master_animation(const StringName &p_node, const String &p_master_animation);
 	String animation_node_get_master_animation(const StringName &p_node) const;
+	float animation_node_get_position(const StringName &p_node) const;
 
 	void animation_node_set_filter_path(const StringName &p_node, const NodePath &p_track_path, bool p_filter);
 	void animation_node_set_get_filtered_paths(const StringName &p_node, List<NodePath> *r_paths) const;
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index 49013b160a..9f7503577b 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -201,6 +201,7 @@ void Tween::_bind_methods() {
 	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("is_stopped"), &Tween::is_stopped);
 	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(""));
@@ -743,6 +744,10 @@ bool Tween::stop(Object *p_object, StringName p_key) {
 	return true;
 }
 
+bool Tween::is_stopped() const {
+	return tell() >= get_runtime();
+}
+
 bool Tween::stop_all() {
 
 	set_active(false);
@@ -886,6 +891,10 @@ real_t Tween::tell() const {
 
 real_t Tween::get_runtime() const {
 
+	if (speed_scale == 0) {
+		return INFINITY;
+	}
+
 	pending_update++;
 	real_t runtime = 0;
 	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
@@ -896,7 +905,8 @@ real_t Tween::get_runtime() const {
 			runtime = t;
 	}
 	pending_update--;
-	return runtime;
+
+	return runtime / speed_scale;
 }
 
 bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {
diff --git a/scene/animation/tween.h b/scene/animation/tween.h
index 757d80e90a..36094bf294 100644
--- a/scene/animation/tween.h
+++ b/scene/animation/tween.h
@@ -162,6 +162,7 @@ public:
 	bool reset_all();
 	bool stop(Object *p_object, StringName p_key);
 	bool stop_all();
+	bool is_stopped() const;
 	bool resume(Object *p_object, StringName p_key);
 	bool resume_all();
 	bool remove(Object *p_object, StringName p_key);