-Added AnimationGraphPlayer (still missing features)

-Added ability to edit resources from built-in inspector (wip, needs testing and feedback)

5 files changed, 2890 insertions, 0 deletions

diff --git a/scene/animation/animation_blend_tree.cpp b/scene/animation/animation_blend_tree.cpp
new file mode 100644
index 0000000000..a266e69bcb
--- /dev/null
+++ b/scene/animation/animation_blend_tree.cpp
@@ -0,0 +1,1105 @@
+#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;
+				}
+			}
+		}
+	}
+}
+
+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()) {
+
+		if (get_tree().is_valid()) {
+			String name = get_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);
+
+	if (get_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;
+			}
+		}
+	}
+}
+
+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->tree != NULL);
+	ERR_FAIL_COND(p_node->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->tree = this;
+	p_node->player = 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->tree = NULL;
+		node->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->tree = this;
+	nodes["output"] = output;
+}
+
+AnimationNodeBlendTree::~AnimationNodeBlendTree() {
+
+	for (Map<StringName, Ref<AnimationNode> >::Element *E = nodes.front(); E; E = E->next()) {
+		E->get()->tree = NULL;
+		E->get()->player = NULL;
+	}
+}
diff --git a/scene/animation/animation_blend_tree.h b/scene/animation/animation_blend_tree.h
new file mode 100644
index 0000000000..68afdf04b3
--- /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 AnimationNode {
+
+	GDCLASS(AnimationNodeAnimation, AnimationNode);
+
+	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 AnimationNode {
+	GDCLASS(AnimationNodeBlendTree, AnimationNode)
+
+	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..ee9621dc1a
--- /dev/null
+++ b/scene/animation/animation_graph_player.cpp
@@ -0,0 +1,1194 @@
+#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()) {
+
+		String name = get_tree()->get_node_name(Ref<AnimationNodeAnimation>(this));
+		make_invalid(vformat(RTR("In node '%s', invalid animation: '%s'."), name, 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
+
+	if (!tree && 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, 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 = get_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) {
+	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();
+}
+
+Ref<AnimationNodeBlendTree> AnimationNode::get_tree() const {
+	if (tree) {
+		return Ref<AnimationNodeBlendTree>(tree);
+	}
+
+	return Ref<AnimationNodeBlendTree>();
+}
+
+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) {
+
+	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")));
+
+	BIND_ENUM_CONSTANT(FILTER_IGNORE);
+	BIND_ENUM_CONSTANT(FILTER_PASS);
+	BIND_ENUM_CONSTANT(FILTER_STOP);
+	BIND_ENUM_CONSTANT(FILTER_BLEND);
+}
+
+AnimationNode::AnimationNode() {
+
+	state = NULL;
+	tree = 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, "AnimationNodeBlendTree", 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..6487a48f34
--- /dev/null
+++ b/scene/animation/animation_graph_player.h
@@ -0,0 +1,261 @@
+#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;
+
+	friend class AnimationNodeBlendTree;
+	AnimationNodeBlendTree *tree;
+	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:
+	Ref<AnimationNodeBlendTree> get_tree() 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);
+
+	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);
+
+	virtual String get_caption() const;
+
+	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)
+
+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 0aabc3b38c..06aaeddf18 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -1327,6 +1327,7 @@ float AnimationPlayer::get_current_animation_length() const {
 void AnimationPlayer::_animation_changed() {
 
 	clear_caches();
+	emit_signal("caches_cleared");
 }
 
 void AnimationPlayer::_stop_playing_caches() {
@@ -1622,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);