1 files changed, 227 insertions, 124 deletions

diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index 05b6c72cbd..1c1f94c986 100644
--- a/scene/animation/animation_tree.cpp
+++ b/scene/animation/animation_tree.cpp
@@ -303,36 +303,21 @@ double AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Stri
 	return p_node->_pre_process(new_path, new_parent, state, p_time, p_seek, p_is_external_seeking, p_connections);
 }
 
-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;
-}
-
 String AnimationNode::get_caption() const {
 	String ret = "Node";
 	GDVIRTUAL_CALL(_get_caption, ret);
 	return ret;
 }
 
-void AnimationNode::add_input(const String &p_name) {
+bool AnimationNode::add_input(const String &p_name) {
 	//root nodes can't add inputs
-	ERR_FAIL_COND(Object::cast_to<AnimationRootNode>(this) != nullptr);
+	ERR_FAIL_COND_V(Object::cast_to<AnimationRootNode>(this) != nullptr, false);
 	Input input;
-	ERR_FAIL_COND(p_name.contains(".") || p_name.contains("/"));
+	ERR_FAIL_COND_V(p_name.contains(".") || p_name.contains("/"), false);
 	input.name = p_name;
 	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.contains(".") || p_name.contains("/"));
-	inputs.write[p_input].name = p_name;
-	emit_changed();
+	return true;
 }
 
 void AnimationNode::remove_input(int p_index) {
@@ -341,6 +326,34 @@ void AnimationNode::remove_input(int p_index) {
 	emit_changed();
 }
 
+bool AnimationNode::set_input_name(int p_input, const String &p_name) {
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), false);
+	ERR_FAIL_COND_V(p_name.contains(".") || p_name.contains("/"), false);
+	inputs.write[p_input].name = p_name;
+	emit_changed();
+	return true;
+}
+
+String AnimationNode::get_input_name(int p_input) const {
+	ERR_FAIL_INDEX_V(p_input, inputs.size(), String());
+	return inputs[p_input].name;
+}
+
+int AnimationNode::get_input_count() const {
+	return inputs.size();
+}
+
+int AnimationNode::find_input(const String &p_name) const {
+	int idx = -1;
+	for (int i = 0; i < inputs.size(); i++) {
+		if (inputs[i].name == p_name) {
+			idx = i;
+			break;
+		}
+	}
+	return idx;
+}
+
 double AnimationNode::process(double p_time, bool p_seek, bool p_is_external_seeking) {
 	double ret = 0;
 	GDVIRTUAL_CALL(_process, p_time, p_seek, p_is_external_seeking, ret);
@@ -404,11 +417,12 @@ Ref<AnimationNode> AnimationNode::get_child_by_name(const StringName &p_name) {
 }
 
 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("add_input", "name"), &AnimationNode::add_input);
 	ClassDB::bind_method(D_METHOD("remove_input", "index"), &AnimationNode::remove_input);
+	ClassDB::bind_method(D_METHOD("set_input_name", "input", "name"), &AnimationNode::set_input_name);
+	ClassDB::bind_method(D_METHOD("get_input_name", "input"), &AnimationNode::get_input_name);
+	ClassDB::bind_method(D_METHOD("get_input_count"), &AnimationNode::get_input_count);
+	ClassDB::bind_method(D_METHOD("find_input", "name"), &AnimationNode::find_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);
@@ -486,13 +500,7 @@ void AnimationTree::set_active(bool p_active) {
 	}
 
 	if (!active && is_inside_tree()) {
-		for (const TrackCache *E : playing_caches) {
-			if (ObjectDB::get_instance(E->object_id)) {
-				E->object->call(SNAME("stop"));
-			}
-		}
-
-		playing_caches.clear();
+		_clear_caches();
 	}
 }
 
@@ -531,6 +539,7 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 	if (!player->has_node(player->get_root())) {
 		ERR_PRINT("AnimationTree: AnimationPlayer root is invalid.");
 		set_active(false);
+		_clear_caches();
 		return false;
 	}
 	Node *parent = player->get_node(player->get_root());
@@ -763,6 +772,8 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 						track_audio->object = child;
 						track_audio->object_id = track_audio->object->get_instance_id();
+						track_audio->audio_stream.instantiate();
+						track_audio->audio_stream->set_polyphony(audio_max_polyphony);
 
 						track = track_audio;
 
@@ -860,14 +871,32 @@ void AnimationTree::_animation_player_changed() {
 }
 
 void AnimationTree::_clear_caches() {
+	_clear_audio_streams();
+	_clear_playing_caches();
 	for (KeyValue<NodePath, TrackCache *> &K : track_cache) {
 		memdelete(K.value);
 	}
-	playing_caches.clear();
 	track_cache.clear();
 	cache_valid = false;
 }
 
+void AnimationTree::_clear_audio_streams() {
+	for (int i = 0; i < playing_audio_stream_players.size(); i++) {
+		playing_audio_stream_players[i]->call(SNAME("stop"));
+		playing_audio_stream_players[i]->call(SNAME("set_stream"), Ref<AudioStream>());
+	}
+	playing_audio_stream_players.clear();
+}
+
+void AnimationTree::_clear_playing_caches() {
+	for (const TrackCache *E : playing_caches) {
+		if (ObjectDB::get_instance(E->object_id)) {
+			E->object->call(SNAME("stop"));
+		}
+	}
+	playing_caches.clear();
+}
+
 static void _call_object(Object *p_object, const StringName &p_method, const Vector<Variant> &p_params, bool p_deferred) {
 	// Separate function to use alloca() more efficiently
 	const Variant **argptrs = (const Variant **)alloca(sizeof(const Variant **) * p_params.size());
@@ -1007,6 +1036,13 @@ void AnimationTree::_process_graph(double p_delta) {
 					TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
 					t->value = t->init_value;
 				} break;
+				case Animation::TYPE_AUDIO: {
+					TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
+					for (KeyValue<ObjectID, PlayingAudioTrackInfo> &L : t->playing_streams) {
+						PlayingAudioTrackInfo &track_info = L.value;
+						track_info.volume = 0.0;
+					}
+				} break;
 				default: {
 				} break;
 			}
@@ -1026,8 +1062,8 @@ void AnimationTree::_process_graph(double p_delta) {
 			bool seeked = as.seeked;
 			Animation::LoopedFlag looped_flag = as.looped_flag;
 			bool is_external_seeking = as.is_external_seeking;
+			bool backward = signbit(delta); // This flag is used by the root motion calculates or detecting the end of audio stream.
 #ifndef _3D_DISABLED
-			bool backward = signbit(delta); // This flag is required only for the root motion since it calculates the difference between the previous and current frames.
 			bool calc_root = !seeked || is_external_seeking;
 #endif // _3D_DISABLED
 
@@ -1046,9 +1082,6 @@ void AnimationTree::_process_graph(double p_delta) {
 				int blend_idx = state.track_map[path];
 				ERR_CONTINUE(blend_idx < 0 || blend_idx >= state.track_count);
 				real_t blend = (*as.track_blends)[blend_idx] * weight;
-				if (Math::is_zero_approx(blend)) {
-					continue; // Nothing to blend.
-				}
 
 				Animation::TrackType ttype = a->track_get_type(i);
 				if (ttype != Animation::TYPE_POSITION_3D && ttype != Animation::TYPE_ROTATION_3D && ttype != Animation::TYPE_SCALE_3D && track->type != ttype) {
@@ -1060,6 +1093,9 @@ void AnimationTree::_process_graph(double p_delta) {
 				switch (ttype) {
 					case Animation::TYPE_POSITION_3D: {
 #ifndef _3D_DISABLED
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 						if (track->root_motion && calc_root) {
 							double prev_time = time - delta;
@@ -1151,6 +1187,9 @@ void AnimationTree::_process_graph(double p_delta) {
 					} break;
 					case Animation::TYPE_ROTATION_3D: {
 #ifndef _3D_DISABLED
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 						if (track->root_motion && calc_root) {
 							double prev_time = time - delta;
@@ -1241,6 +1280,9 @@ void AnimationTree::_process_graph(double p_delta) {
 					} break;
 					case Animation::TYPE_SCALE_3D: {
 #ifndef _3D_DISABLED
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 						if (track->root_motion && calc_root) {
 							double prev_time = time - delta;
@@ -1332,6 +1374,9 @@ void AnimationTree::_process_graph(double p_delta) {
 					} break;
 					case Animation::TYPE_BLEND_SHAPE: {
 #ifndef _3D_DISABLED
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheBlendShape *t = static_cast<TrackCacheBlendShape *>(track);
 
 						float value;
@@ -1348,6 +1393,9 @@ void AnimationTree::_process_graph(double p_delta) {
 #endif // _3D_DISABLED
 					} break;
 					case Animation::TYPE_VALUE: {
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
 
 						Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
@@ -1414,6 +1462,9 @@ void AnimationTree::_process_graph(double p_delta) {
 							continue;
 						}
 #endif // TOOLS_ENABLED
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheMethod *t = static_cast<TrackCacheMethod *>(track);
 
 						if (seeked) {
@@ -1435,6 +1486,9 @@ void AnimationTree::_process_graph(double p_delta) {
 						}
 					} break;
 					case Animation::TYPE_BEZIER: {
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
 
 						real_t bezier = a->bezier_track_interpolate(i, time);
@@ -1445,110 +1499,87 @@ void AnimationTree::_process_graph(double p_delta) {
 					case Animation::TYPE_AUDIO: {
 						TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
 
-						if (seeked) {
-							int idx = a->track_find_key(i, time, is_external_seeking ? Animation::FIND_MODE_NEAREST : Animation::FIND_MODE_EXACT);
-							if (idx < 0) {
-								continue;
-							}
-
-							Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
-							if (!stream.is_valid()) {
-								t->object->call(SNAME("stop"));
-								t->playing = false;
-								playing_caches.erase(t);
-							} else {
-								double start_ofs = a->audio_track_get_key_start_offset(i, idx);
-								start_ofs += time - a->track_get_key_time(i, idx);
-								double end_ofs = a->audio_track_get_key_end_offset(i, idx);
-								double len = stream->get_length();
-
-								if (start_ofs > len - end_ofs) {
-									t->object->call(SNAME("stop"));
-									t->playing = false;
-									playing_caches.erase(t);
-									continue;
-								}
-
-								t->object->call(SNAME("set_stream"), stream);
-								t->object->call(SNAME("play"), start_ofs);
-
-								t->playing = true;
-								playing_caches.insert(t);
-								if (len && end_ofs > 0) { //force an end at a time
-									t->len = len - start_ofs - end_ofs;
-								} else {
-									t->len = 0;
-								}
+						Node *asp = Object::cast_to<Node>(t->object);
+						if (!asp) {
+							t->playing_streams.clear();
+							continue;
+						}
 
-								t->start = time;
+						ObjectID oid = a->get_instance_id();
+						if (!t->playing_streams.has(oid)) {
+							t->playing_streams[oid] = PlayingAudioTrackInfo();
+						}
+						// The end of audio should be observed even if the blend value is 0, build up the information and store to the cache for that.
+						PlayingAudioTrackInfo &track_info = t->playing_streams[oid];
+						track_info.length = a->get_length();
+						track_info.time = time;
+						track_info.volume += blend;
+						track_info.loop = a->get_loop_mode() != Animation::LOOP_NONE;
+						track_info.backward = backward;
+						track_info.use_blend = a->audio_track_is_use_blend(i);
+
+						HashMap<int, PlayingAudioStreamInfo> &map = track_info.stream_info;
+						// Find stream.
+						int idx = -1;
+						if (seeked) {
+							idx = a->track_find_key(i, time, is_external_seeking ? Animation::FIND_MODE_NEAREST : Animation::FIND_MODE_EXACT);
+							// Discard previous stream when seeking.
+							if (map.has(idx)) {
+								t->audio_stream_playback->stop_stream(map[idx].index);
+								map.erase(idx);
 							}
-
 						} else {
-							//find stuff to play
 							List<int> to_play;
 							a->track_get_key_indices_in_range(i, time, delta, &to_play, looped_flag);
 							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(SNAME("stop"));
-									t->playing = false;
-									playing_caches.erase(t);
-								} else {
-									double start_ofs = a->audio_track_get_key_start_offset(i, idx);
-									double end_ofs = a->audio_track_get_key_end_offset(i, idx);
-									double len = stream->get_length();
-
-									t->object->call(SNAME("set_stream"), stream);
-									t->object->call(SNAME("play"), start_ofs);
-
-									t->playing = true;
-									playing_caches.insert(t);
-									if (len && end_ofs > 0) { //force an end at a time
-										t->len = len - start_ofs - end_ofs;
-									} else {
-										t->len = 0;
-									}
-
-									t->start = time;
-								}
-							} else if (t->playing) {
-								bool loop = a->get_loop_mode() != Animation::LOOP_NONE;
-
-								bool stop = false;
-
-								if (!loop) {
-									if (delta > 0) {
-										if (time < t->start) {
-											stop = true;
-										}
-									} else if (delta < 0) {
-										if (time > t->start) {
-											stop = true;
-										}
-									}
-								} else if (t->len > 0) {
-									double len = t->start > time ? (a->get_length() - t->start) + time : time - t->start;
+								idx = to_play.back()->get();
+							}
+						}
+						if (idx < 0) {
+							continue;
+						}
 
-									if (len > t->len) {
-										stop = true;
-									}
+						// Play stream.
+						Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
+						if (stream.is_valid()) {
+							double start_ofs = a->audio_track_get_key_start_offset(i, idx);
+							double end_ofs = a->audio_track_get_key_end_offset(i, idx);
+							double len = stream->get_length();
+
+							if (t->object->call(SNAME("get_stream")) != t->audio_stream) {
+								t->object->call(SNAME("set_stream"), t->audio_stream);
+								t->audio_stream_playback.unref();
+								if (!playing_audio_stream_players.has(asp)) {
+									playing_audio_stream_players.push_back(asp);
 								}
+							}
+							if (!t->object->call(SNAME("is_playing"))) {
+								t->object->call(SNAME("play"));
+							}
+							if (!t->object->call(SNAME("has_stream_playback"))) {
+								t->audio_stream_playback.unref();
+								continue;
+							}
+							if (t->audio_stream_playback.is_null()) {
+								t->audio_stream_playback = t->object->call(SNAME("get_stream_playback"));
+							}
 
-								if (stop) {
-									//time to stop
-									t->object->call(SNAME("stop"));
-									t->playing = false;
-									playing_caches.erase(t);
-								}
+							PlayingAudioStreamInfo pasi;
+							pasi.index = t->audio_stream_playback->play_stream(stream, start_ofs);
+							pasi.start = time;
+							if (len && end_ofs > 0) { // Force an end at a time.
+								pasi.len = len - start_ofs - end_ofs;
+							} else {
+								pasi.len = 0;
 							}
+							map[idx] = pasi;
 						}
 
-						real_t db = Math::linear_to_db(MAX(blend, 0.00001));
-						t->object->call(SNAME("set_volume_db"), db);
 					} break;
 					case Animation::TYPE_ANIMATION: {
+						if (Math::is_zero_approx(blend)) {
+							continue; // Nothing to blend.
+						}
 						TrackCacheAnimation *t = static_cast<TrackCacheAnimation *>(track);
 
 						AnimationPlayer *player2 = Object::cast_to<AnimationPlayer>(t->object);
@@ -1694,6 +1725,64 @@ void AnimationTree::_process_graph(double p_delta) {
 					t->object->set_indexed(t->subpath, t->value);
 
 				} break;
+				case Animation::TYPE_AUDIO: {
+					TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
+
+					// Audio ending process.
+					LocalVector<ObjectID> erase_maps;
+					for (KeyValue<ObjectID, PlayingAudioTrackInfo> &L : t->playing_streams) {
+						PlayingAudioTrackInfo &track_info = L.value;
+						float db = Math::linear_to_db(track_info.use_blend ? track_info.volume : 1.0);
+						LocalVector<int> erase_streams;
+						HashMap<int, PlayingAudioStreamInfo> &map = track_info.stream_info;
+						for (const KeyValue<int, PlayingAudioStreamInfo> &M : map) {
+							PlayingAudioStreamInfo pasi = M.value;
+
+							bool stop = false;
+							if (!t->audio_stream_playback->is_stream_playing(pasi.index)) {
+								stop = true;
+							}
+							if (!track_info.loop) {
+								if (!track_info.backward) {
+									if (track_info.time < pasi.start) {
+										stop = true;
+									}
+								} else if (track_info.backward) {
+									if (track_info.time > pasi.start) {
+										stop = true;
+									}
+								}
+							}
+							if (pasi.len > 0) {
+								double len = 0.0;
+								if (!track_info.backward) {
+									len = pasi.start > track_info.time ? (track_info.length - pasi.start) + track_info.time : track_info.time - pasi.start;
+								} else {
+									len = pasi.start < track_info.time ? (track_info.length - track_info.time) + pasi.start : pasi.start - track_info.time;
+								}
+								if (len > pasi.len) {
+									stop = true;
+								}
+							}
+							if (stop) {
+								// Time to stop.
+								t->audio_stream_playback->stop_stream(pasi.index);
+								erase_streams.push_back(M.key);
+							} else {
+								t->audio_stream_playback->set_stream_volume(pasi.index, db);
+							}
+						}
+						for (uint32_t erase_idx = 0; erase_idx < erase_streams.size(); erase_idx++) {
+							map.erase(erase_streams[erase_idx]);
+						}
+						if (map.size() == 0) {
+							erase_maps.push_back(L.key);
+						}
+					}
+					for (uint32_t erase_idx = 0; erase_idx < erase_maps.size(); erase_idx++) {
+						t->playing_streams.erase(erase_maps[erase_idx]);
+					}
+				} break;
 				default: {
 				} //the rest don't matter
 			}
@@ -1819,6 +1908,15 @@ NodePath AnimationTree::get_advance_expression_base_node() const {
 	return advance_expression_base_node;
 }
 
+void AnimationTree::set_audio_max_polyphony(int p_audio_max_polyphony) {
+	ERR_FAIL_COND(p_audio_max_polyphony < 0 || p_audio_max_polyphony > 128);
+	audio_max_polyphony = p_audio_max_polyphony;
+}
+
+int AnimationTree::get_audio_max_polyphony() const {
+	return audio_max_polyphony;
+}
+
 bool AnimationTree::is_state_invalid() const {
 	return !state.valid;
 }
@@ -2034,6 +2132,9 @@ void AnimationTree::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_root_motion_track", "path"), &AnimationTree::set_root_motion_track);
 	ClassDB::bind_method(D_METHOD("get_root_motion_track"), &AnimationTree::get_root_motion_track);
 
+	ClassDB::bind_method(D_METHOD("set_audio_max_polyphony", "max_polyphony"), &AnimationTree::set_audio_max_polyphony);
+	ClassDB::bind_method(D_METHOD("get_audio_max_polyphony"), &AnimationTree::get_audio_max_polyphony);
+
 	ClassDB::bind_method(D_METHOD("get_root_motion_position"), &AnimationTree::get_root_motion_position);
 	ClassDB::bind_method(D_METHOD("get_root_motion_rotation"), &AnimationTree::get_root_motion_rotation);
 	ClassDB::bind_method(D_METHOD("get_root_motion_scale"), &AnimationTree::get_root_motion_scale);
@@ -2052,6 +2153,8 @@ void AnimationTree::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "active"), "set_active", "is_active");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "process_callback", PROPERTY_HINT_ENUM, "Physics,Idle,Manual"), "set_process_callback", "get_process_callback");
+	ADD_GROUP("Audio", "audio_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "audio_max_polyphony", PROPERTY_HINT_RANGE, "1,127,1"), "set_audio_max_polyphony", "get_audio_max_polyphony");
 	ADD_GROUP("Root Motion", "root_motion_");
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "root_motion_track"), "set_root_motion_track", "get_root_motion_track");