|
|
@@ -351,100 +351,372 @@ AudioStreamPlaybackMicrophone::AudioStreamPlaybackMicrophone() {
|
|
|
|
|
|
////////////////////////////////
|
|
|
|
|
|
-void AudioStreamRandomPitch::set_audio_stream(const Ref<AudioStream> &p_audio_stream) {
|
|
|
- audio_stream = p_audio_stream;
|
|
|
- if (audio_stream.is_valid()) {
|
|
|
- for (Set<AudioStreamPlaybackRandomPitch *>::Element *E = playbacks.front(); E; E = E->next()) {
|
|
|
- E->get()->playback = audio_stream->instance_playback();
|
|
|
- }
|
|
|
+void AudioStreamRandomizer::add_stream(int p_index) {
|
|
|
+ if (p_index < 0) {
|
|
|
+ p_index = audio_stream_pool.size();
|
|
|
+ }
|
|
|
+ ERR_FAIL_COND(p_index > audio_stream_pool.size());
|
|
|
+ PoolEntry entry{ nullptr, 1.0f };
|
|
|
+ audio_stream_pool.insert(p_index, entry);
|
|
|
+ emit_signal(SNAME("changed"));
|
|
|
+ notify_property_list_changed();
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::move_stream(int p_index_from, int p_index_to) {
|
|
|
+ ERR_FAIL_COND(p_index_from < 0);
|
|
|
+ ERR_FAIL_COND(p_index_from >= audio_stream_pool.size());
|
|
|
+ ERR_FAIL_COND(p_index_to < 0);
|
|
|
+ ERR_FAIL_COND(p_index_to > audio_stream_pool.size());
|
|
|
+ audio_stream_pool.insert(p_index_to, audio_stream_pool[p_index_from]);
|
|
|
+ // If 'from' is strictly after 'to' we need to increment the index by one because of the insertion.
|
|
|
+ if (p_index_from > p_index_to) {
|
|
|
+ p_index_from++;
|
|
|
}
|
|
|
+ audio_stream_pool.remove_at(p_index_from);
|
|
|
+ emit_signal(SNAME("changed"));
|
|
|
+ notify_property_list_changed();
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::remove_stream(int p_index) {
|
|
|
+ ERR_FAIL_COND(p_index < 0);
|
|
|
+ ERR_FAIL_COND(p_index >= audio_stream_pool.size());
|
|
|
+ audio_stream_pool.remove_at(p_index);
|
|
|
+ emit_signal(SNAME("changed"));
|
|
|
+ notify_property_list_changed();
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::set_stream(int p_index, Ref<AudioStream> p_stream) {
|
|
|
+ ERR_FAIL_COND(p_index < 0);
|
|
|
+ ERR_FAIL_COND(p_index >= audio_stream_pool.size());
|
|
|
+ audio_stream_pool.write[p_index].stream = p_stream;
|
|
|
+ emit_signal(SNAME("changed"));
|
|
|
}
|
|
|
|
|
|
-Ref<AudioStream> AudioStreamRandomPitch::get_audio_stream() const {
|
|
|
- return audio_stream;
|
|
|
+Ref<AudioStream> AudioStreamRandomizer::get_stream(int p_index) const {
|
|
|
+ ERR_FAIL_COND_V(p_index < 0, nullptr);
|
|
|
+ ERR_FAIL_COND_V(p_index >= audio_stream_pool.size(), nullptr);
|
|
|
+ return audio_stream_pool[p_index].stream;
|
|
|
}
|
|
|
|
|
|
-void AudioStreamRandomPitch::set_random_pitch(float p_pitch) {
|
|
|
+void AudioStreamRandomizer::set_stream_probability_weight(int p_index, float p_weight) {
|
|
|
+ ERR_FAIL_COND(p_index < 0);
|
|
|
+ ERR_FAIL_COND(p_index >= audio_stream_pool.size());
|
|
|
+ audio_stream_pool.write[p_index].weight = p_weight;
|
|
|
+ emit_signal(SNAME("changed"));
|
|
|
+}
|
|
|
+
|
|
|
+float AudioStreamRandomizer::get_stream_probability_weight(int p_index) const {
|
|
|
+ ERR_FAIL_COND_V(p_index < 0, 0);
|
|
|
+ ERR_FAIL_COND_V(p_index >= audio_stream_pool.size(), 0);
|
|
|
+ return audio_stream_pool[p_index].weight;
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::set_streams_count(int p_count) {
|
|
|
+ audio_stream_pool.resize(p_count);
|
|
|
+}
|
|
|
+
|
|
|
+int AudioStreamRandomizer::get_streams_count() const {
|
|
|
+ return audio_stream_pool.size();
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::set_random_pitch(float p_pitch) {
|
|
|
if (p_pitch < 1) {
|
|
|
p_pitch = 1;
|
|
|
}
|
|
|
- random_pitch = p_pitch;
|
|
|
+ random_pitch_scale = p_pitch;
|
|
|
+}
|
|
|
+
|
|
|
+float AudioStreamRandomizer::get_random_pitch() const {
|
|
|
+ return random_pitch_scale;
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::set_random_volume_offset_db(float p_volume_offset_db) {
|
|
|
+ if (p_volume_offset_db < 0) {
|
|
|
+ p_volume_offset_db = 0;
|
|
|
+ }
|
|
|
+ random_volume_offset_db = p_volume_offset_db;
|
|
|
+}
|
|
|
+
|
|
|
+float AudioStreamRandomizer::get_random_volume_offset_db() const {
|
|
|
+ return random_volume_offset_db;
|
|
|
}
|
|
|
|
|
|
-float AudioStreamRandomPitch::get_random_pitch() const {
|
|
|
- return random_pitch;
|
|
|
+void AudioStreamRandomizer::set_playback_mode(PlaybackMode p_playback_mode) {
|
|
|
+ playback_mode = p_playback_mode;
|
|
|
}
|
|
|
|
|
|
-Ref<AudioStreamPlayback> AudioStreamRandomPitch::instance_playback() {
|
|
|
- Ref<AudioStreamPlaybackRandomPitch> playback;
|
|
|
+AudioStreamRandomizer::PlaybackMode AudioStreamRandomizer::get_playback_mode() const {
|
|
|
+ return playback_mode;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AudioStreamPlayback> AudioStreamRandomizer::instance_playback_random() {
|
|
|
+ Ref<AudioStreamPlaybackRandomizer> playback;
|
|
|
playback.instantiate();
|
|
|
- if (audio_stream.is_valid()) {
|
|
|
- playback->playback = audio_stream->instance_playback();
|
|
|
+ playbacks.insert(playback.ptr());
|
|
|
+ playback->randomizer = Ref<AudioStreamRandomizer>((AudioStreamRandomizer *)this);
|
|
|
+
|
|
|
+ double total_weight = 0;
|
|
|
+ Vector<PoolEntry> local_pool;
|
|
|
+ for (const PoolEntry &entry : audio_stream_pool) {
|
|
|
+ if (entry.stream.is_valid() && entry.weight > 0) {
|
|
|
+ local_pool.push_back(entry);
|
|
|
+ total_weight += entry.weight;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (local_pool.is_empty()) {
|
|
|
+ return playback;
|
|
|
}
|
|
|
+ double chosen_cumulative_weight = Math::random(0.0, total_weight);
|
|
|
+ double cumulative_weight = 0;
|
|
|
+ for (PoolEntry &entry : local_pool) {
|
|
|
+ cumulative_weight += entry.weight;
|
|
|
+ if (cumulative_weight > chosen_cumulative_weight) {
|
|
|
+ playback->playback = entry.stream->instance_playback();
|
|
|
+ last_playback = entry.stream;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (playback->playback.is_null()) {
|
|
|
+ // This indicates a floating point error. Take the last element.
|
|
|
+ last_playback = local_pool[local_pool.size() - 1].stream;
|
|
|
+ playback->playback = local_pool.write[local_pool.size() - 1].stream->instance_playback();
|
|
|
+ }
|
|
|
+ return playback;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AudioStreamPlayback> AudioStreamRandomizer::instance_playback_no_repeats() {
|
|
|
+ Ref<AudioStreamPlaybackRandomizer> playback;
|
|
|
|
|
|
+ double total_weight = 0;
|
|
|
+ Vector<PoolEntry> local_pool;
|
|
|
+ for (const PoolEntry &entry : audio_stream_pool) {
|
|
|
+ if (entry.stream == last_playback) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (entry.stream.is_valid() && entry.weight > 0) {
|
|
|
+ local_pool.push_back(entry);
|
|
|
+ total_weight += entry.weight;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (local_pool.is_empty()) {
|
|
|
+ playback = instance_playback_random();
|
|
|
+ WARN_PRINT("Playback stream pool is too small to prevent repeats.");
|
|
|
+ return playback;
|
|
|
+ }
|
|
|
+
|
|
|
+ playback.instantiate();
|
|
|
playbacks.insert(playback.ptr());
|
|
|
- playback->random_pitch = Ref<AudioStreamRandomPitch>((AudioStreamRandomPitch *)this);
|
|
|
+ playback->randomizer = Ref<AudioStreamRandomizer>((AudioStreamRandomizer *)this);
|
|
|
+ double chosen_cumulative_weight = Math::random(0.0, total_weight);
|
|
|
+ double cumulative_weight = 0;
|
|
|
+ for (PoolEntry &entry : local_pool) {
|
|
|
+ cumulative_weight += entry.weight;
|
|
|
+ if (cumulative_weight > chosen_cumulative_weight) {
|
|
|
+ last_playback = entry.stream;
|
|
|
+ playback->playback = entry.stream->instance_playback();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (playback->playback.is_null()) {
|
|
|
+ // This indicates a floating point error. Take the last element.
|
|
|
+ last_playback = local_pool[local_pool.size() - 1].stream;
|
|
|
+ playback->playback = local_pool.write[local_pool.size() - 1].stream->instance_playback();
|
|
|
+ }
|
|
|
return playback;
|
|
|
}
|
|
|
|
|
|
-String AudioStreamRandomPitch::get_stream_name() const {
|
|
|
- if (audio_stream.is_valid()) {
|
|
|
- return "Random: " + audio_stream->get_name();
|
|
|
+Ref<AudioStreamPlayback> AudioStreamRandomizer::instance_playback_sequential() {
|
|
|
+ Ref<AudioStreamPlaybackRandomizer> playback;
|
|
|
+ playback.instantiate();
|
|
|
+ playbacks.insert(playback.ptr());
|
|
|
+ playback->randomizer = Ref<AudioStreamRandomizer>((AudioStreamRandomizer *)this);
|
|
|
+
|
|
|
+ Vector<Ref<AudioStream>> local_pool;
|
|
|
+ for (const PoolEntry &entry : audio_stream_pool) {
|
|
|
+ if (entry.stream.is_null()) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (local_pool.find(entry.stream) != -1) {
|
|
|
+ WARN_PRINT("Duplicate stream in sequential playback pool");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ local_pool.push_back(entry.stream);
|
|
|
+ }
|
|
|
+ if (local_pool.is_empty()) {
|
|
|
+ return playback;
|
|
|
}
|
|
|
- return "RandomPitch";
|
|
|
+ bool found_last_stream = false;
|
|
|
+ for (Ref<AudioStream> &entry : local_pool) {
|
|
|
+ if (found_last_stream) {
|
|
|
+ last_playback = entry;
|
|
|
+ playback->playback = entry->instance_playback();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (entry == last_playback) {
|
|
|
+ found_last_stream = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (playback->playback.is_null()) {
|
|
|
+ // Wrap around
|
|
|
+ last_playback = local_pool[0];
|
|
|
+ playback->playback = local_pool.write[0]->instance_playback();
|
|
|
+ }
|
|
|
+ return playback;
|
|
|
}
|
|
|
|
|
|
-float AudioStreamRandomPitch::get_length() const {
|
|
|
- if (audio_stream.is_valid()) {
|
|
|
- return audio_stream->get_length();
|
|
|
+Ref<AudioStreamPlayback> AudioStreamRandomizer::instance_playback() {
|
|
|
+ switch (playback_mode) {
|
|
|
+ case PLAYBACK_RANDOM:
|
|
|
+ return instance_playback_random();
|
|
|
+ case PLAYBACK_RANDOM_NO_REPEATS:
|
|
|
+ return instance_playback_no_repeats();
|
|
|
+ case PLAYBACK_SEQUENTIAL:
|
|
|
+ return instance_playback_sequential();
|
|
|
+ default:
|
|
|
+ ERR_FAIL_V_MSG(nullptr, "Unhandled playback mode.");
|
|
|
}
|
|
|
+}
|
|
|
|
|
|
+String AudioStreamRandomizer::get_stream_name() const {
|
|
|
+ return "Randomizer";
|
|
|
+}
|
|
|
+
|
|
|
+float AudioStreamRandomizer::get_length() const {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-bool AudioStreamRandomPitch::is_monophonic() const {
|
|
|
- if (audio_stream.is_valid()) {
|
|
|
- return audio_stream->is_monophonic();
|
|
|
+bool AudioStreamRandomizer::is_monophonic() const {
|
|
|
+ for (const PoolEntry &entry : audio_stream_pool) {
|
|
|
+ if (entry.stream.is_valid() && entry.stream->is_monophonic()) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+bool AudioStreamRandomizer::_get(const StringName &p_name, Variant &r_ret) const {
|
|
|
+ if (AudioStream::_get(p_name, r_ret)) {
|
|
|
+ return true;
|
|
|
}
|
|
|
+ Vector<String> components = String(p_name).split("/", true, 2);
|
|
|
+ if (components.size() == 2 && components[0].begins_with("stream_") && components[0].trim_prefix("stream_").is_valid_int()) {
|
|
|
+ int index = components[0].trim_prefix("stream_").to_int();
|
|
|
+ if (index < 0 || index >= (int)audio_stream_pool.size()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
|
|
|
- return true; // It doesn't really matter what we return here, but no sense instancing a many playbacks of a null stream.
|
|
|
+ if (components[1] == "stream") {
|
|
|
+ r_ret = get_stream(index);
|
|
|
+ return true;
|
|
|
+ } else if (components[1] == "weight") {
|
|
|
+ r_ret = get_stream_probability_weight(index);
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+bool AudioStreamRandomizer::_set(const StringName &p_name, const Variant &p_value) {
|
|
|
+ if (AudioStream::_set(p_name, p_value)) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ Vector<String> components = String(p_name).split("/", true, 2);
|
|
|
+ if (components.size() == 2 && components[0].begins_with("stream_") && components[0].trim_prefix("stream_").is_valid_int()) {
|
|
|
+ int index = components[0].trim_prefix("stream_").to_int();
|
|
|
+ if (index < 0 || index >= (int)audio_stream_pool.size()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (components[1] == "stream") {
|
|
|
+ set_stream(index, p_value);
|
|
|
+ return true;
|
|
|
+ } else if (components[1] == "weight") {
|
|
|
+ set_stream_probability_weight(index, p_value);
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+void AudioStreamRandomizer::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
+ AudioStream::_get_property_list(p_list); // Define the trivial scalar properties.
|
|
|
+ p_list->push_back(PropertyInfo(Variant::NIL, "Streams", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
|
|
|
+ for (int i = 0; i < audio_stream_pool.size(); i++) {
|
|
|
+ p_list->push_back(PropertyInfo(Variant::OBJECT, vformat("stream_%d/stream", i), PROPERTY_HINT_RESOURCE_TYPE, "AudioStream"));
|
|
|
+ p_list->push_back(PropertyInfo(Variant::FLOAT, vformat("stream_%d/weight", i), PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"));
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-void AudioStreamRandomPitch::_bind_methods() {
|
|
|
- ClassDB::bind_method(D_METHOD("set_audio_stream", "stream"), &AudioStreamRandomPitch::set_audio_stream);
|
|
|
- ClassDB::bind_method(D_METHOD("get_audio_stream"), &AudioStreamRandomPitch::get_audio_stream);
|
|
|
+void AudioStreamRandomizer::_bind_methods() {
|
|
|
+ ClassDB::bind_method(D_METHOD("add_stream", "index"), &AudioStreamRandomizer::add_stream);
|
|
|
+ ClassDB::bind_method(D_METHOD("move_stream", "index_from", "index_to"), &AudioStreamRandomizer::move_stream);
|
|
|
+ ClassDB::bind_method(D_METHOD("remove_stream", "index"), &AudioStreamRandomizer::remove_stream);
|
|
|
+
|
|
|
+ ClassDB::bind_method(D_METHOD("set_stream", "index", "stream"), &AudioStreamRandomizer::set_stream);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_stream", "index"), &AudioStreamRandomizer::get_stream);
|
|
|
+ ClassDB::bind_method(D_METHOD("set_stream_probability_weight", "index", "weight"), &AudioStreamRandomizer::set_stream_probability_weight);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_stream_probability_weight", "index"), &AudioStreamRandomizer::get_stream_probability_weight);
|
|
|
+
|
|
|
+ ClassDB::bind_method(D_METHOD("set_streams_count", "count"), &AudioStreamRandomizer::set_streams_count);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_streams_count"), &AudioStreamRandomizer::get_streams_count);
|
|
|
+
|
|
|
+ ClassDB::bind_method(D_METHOD("set_random_pitch", "scale"), &AudioStreamRandomizer::set_random_pitch);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_random_pitch"), &AudioStreamRandomizer::get_random_pitch);
|
|
|
|
|
|
- ClassDB::bind_method(D_METHOD("set_random_pitch", "scale"), &AudioStreamRandomPitch::set_random_pitch);
|
|
|
- ClassDB::bind_method(D_METHOD("get_random_pitch"), &AudioStreamRandomPitch::get_random_pitch);
|
|
|
+ ClassDB::bind_method(D_METHOD("set_random_volume_offset_db", "db_offset"), &AudioStreamRandomizer::set_random_volume_offset_db);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_random_volume_offset_db"), &AudioStreamRandomizer::get_random_volume_offset_db);
|
|
|
|
|
|
- ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "audio_stream", PROPERTY_HINT_RESOURCE_TYPE, "AudioStream"), "set_audio_stream", "get_audio_stream");
|
|
|
+ ClassDB::bind_method(D_METHOD("set_playback_mode", "mode"), &AudioStreamRandomizer::set_playback_mode);
|
|
|
+ ClassDB::bind_method(D_METHOD("get_playback_mode"), &AudioStreamRandomizer::get_playback_mode);
|
|
|
+
|
|
|
+ ADD_ARRAY("streams", "stream_");
|
|
|
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "streams_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_streams_count", "get_streams_count");
|
|
|
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "playback_mode", PROPERTY_HINT_ENUM, "Random (Avoid Repeats),Random,Sequential"), "set_playback_mode", "get_playback_mode");
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "random_pitch", PROPERTY_HINT_RANGE, "1,16,0.01"), "set_random_pitch", "get_random_pitch");
|
|
|
+ ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "random_volume_offset_db", PROPERTY_HINT_RANGE, "0,40,0"), "set_random_volume_offset_db", "get_random_volume_offset_db");
|
|
|
+
|
|
|
+ BIND_ENUM_CONSTANT(PLAYBACK_RANDOM_NO_REPEATS);
|
|
|
+ BIND_ENUM_CONSTANT(PLAYBACK_RANDOM);
|
|
|
+ BIND_ENUM_CONSTANT(PLAYBACK_SEQUENTIAL);
|
|
|
}
|
|
|
|
|
|
-AudioStreamRandomPitch::AudioStreamRandomPitch() {
|
|
|
- random_pitch = 1.1;
|
|
|
+AudioStreamRandomizer::AudioStreamRandomizer() {
|
|
|
+ random_pitch_scale = 1.1;
|
|
|
+ random_volume_offset_db = 5;
|
|
|
}
|
|
|
|
|
|
-void AudioStreamPlaybackRandomPitch::start(float p_from_pos) {
|
|
|
+void AudioStreamPlaybackRandomizer::start(float p_from_pos) {
|
|
|
playing = playback;
|
|
|
- float range_from = 1.0 / random_pitch->random_pitch;
|
|
|
- float range_to = random_pitch->random_pitch;
|
|
|
+ {
|
|
|
+ float range_from = 1.0 / randomizer->random_pitch_scale;
|
|
|
+ float range_to = randomizer->random_pitch_scale;
|
|
|
|
|
|
- pitch_scale = range_from + Math::randf() * (range_to - range_from);
|
|
|
+ pitch_scale = range_from + Math::randf() * (range_to - range_from);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ float range_from = -randomizer->random_volume_offset_db;
|
|
|
+ float range_to = randomizer->random_volume_offset_db;
|
|
|
+
|
|
|
+ float volume_offset_db = range_from + Math::randf() * (range_to - range_from);
|
|
|
+ volume_scale = Math::db2linear(volume_offset_db);
|
|
|
+ }
|
|
|
|
|
|
if (playing.is_valid()) {
|
|
|
playing->start(p_from_pos);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void AudioStreamPlaybackRandomPitch::stop() {
|
|
|
+void AudioStreamPlaybackRandomizer::stop() {
|
|
|
if (playing.is_valid()) {
|
|
|
playing->stop();
|
|
|
- ;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-bool AudioStreamPlaybackRandomPitch::is_playing() const {
|
|
|
+bool AudioStreamPlaybackRandomizer::is_playing() const {
|
|
|
if (playing.is_valid()) {
|
|
|
return playing->is_playing();
|
|
|
}
|
|
|
@@ -452,7 +724,7 @@ bool AudioStreamPlaybackRandomPitch::is_playing() const {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
-int AudioStreamPlaybackRandomPitch::get_loop_count() const {
|
|
|
+int AudioStreamPlaybackRandomizer::get_loop_count() const {
|
|
|
if (playing.is_valid()) {
|
|
|
return playing->get_loop_count();
|
|
|
}
|
|
|
@@ -460,7 +732,7 @@ int AudioStreamPlaybackRandomPitch::get_loop_count() const {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-float AudioStreamPlaybackRandomPitch::get_playback_position() const {
|
|
|
+float AudioStreamPlaybackRandomizer::get_playback_position() const {
|
|
|
if (playing.is_valid()) {
|
|
|
return playing->get_playback_position();
|
|
|
}
|
|
|
@@ -468,13 +740,13 @@ float AudioStreamPlaybackRandomPitch::get_playback_position() const {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-void AudioStreamPlaybackRandomPitch::seek(float p_time) {
|
|
|
+void AudioStreamPlaybackRandomizer::seek(float p_time) {
|
|
|
if (playing.is_valid()) {
|
|
|
playing->seek(p_time);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-int AudioStreamPlaybackRandomPitch::mix(AudioFrame *p_buffer, float p_rate_scale, int p_frames) {
|
|
|
+int AudioStreamPlaybackRandomizer::mix(AudioFrame *p_buffer, float p_rate_scale, int p_frames) {
|
|
|
if (playing.is_valid()) {
|
|
|
return playing->mix(p_buffer, p_rate_scale * pitch_scale, p_frames);
|
|
|
} else {
|
|
|
@@ -485,7 +757,7 @@ int AudioStreamPlaybackRandomPitch::mix(AudioFrame *p_buffer, float p_rate_scale
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-AudioStreamPlaybackRandomPitch::~AudioStreamPlaybackRandomPitch() {
|
|
|
- random_pitch->playbacks.erase(this);
|
|
|
+AudioStreamPlaybackRandomizer::~AudioStreamPlaybackRandomizer() {
|
|
|
+ randomizer->playbacks.erase(this);
|
|
|
}
|
|
|
/////////////////////////////////////////////
|
Ellen Poe