diff options
Diffstat (limited to 'editor/editor_audio_buses.cpp')
| -rw-r--r-- | editor/editor_audio_buses.cpp | 1192 |
1 files changed, 1192 insertions, 0 deletions
diff --git a/editor/editor_audio_buses.cpp b/editor/editor_audio_buses.cpp new file mode 100644 index 0000000000..6ee18f08d8 --- /dev/null +++ b/editor/editor_audio_buses.cpp @@ -0,0 +1,1192 @@ +#include "editor_audio_buses.h" +#include "editor_node.h" +#include "servers/audio_server.h" +#include "os/keyboard.h" +#include "io/resource_saver.h" +#include "filesystem_dock.h" + +void EditorAudioBus::_notification(int p_what) { + + if (p_what==NOTIFICATION_READY) { + + vu_l->set_under_texture(get_icon("BusVuEmpty","EditorIcons")); + vu_l->set_progress_texture(get_icon("BusVuFull","EditorIcons")); + vu_r->set_under_texture(get_icon("BusVuEmpty","EditorIcons")); + vu_r->set_progress_texture(get_icon("BusVuFull","EditorIcons")); + scale->set_texture( get_icon("BusVuDb","EditorIcons")); + + disabled_vu = get_icon("BusVuFrozen","EditorIcons"); + + prev_active=true; + update_bus(); + set_process(true); + } + + if (p_what==NOTIFICATION_DRAW) { + + if (has_focus()) { + draw_style_box(get_stylebox("focus","Button"),Rect2(Vector2(),get_size())); + } + } + + if (p_what==NOTIFICATION_PROCESS) { + + float real_peak[2]={-100,-100}; + bool activity_found=false; + + int cc; + switch(AudioServer::get_singleton()->get_speaker_mode()) { + case AudioServer::SPEAKER_MODE_STEREO: cc = 1; break; + case AudioServer::SPEAKER_SURROUND_51: cc = 4; break; + case AudioServer::SPEAKER_SURROUND_71: cc = 5; break; + } + + for(int i=0;i<cc;i++) { + if (AudioServer::get_singleton()->is_bus_channel_active(get_index(),i)) { + activity_found=true; + real_peak[0]=MAX(real_peak[0],AudioServer::get_singleton()->get_bus_peak_volume_left_db(get_index(),i)); + real_peak[1]=MAX(real_peak[1],AudioServer::get_singleton()->get_bus_peak_volume_right_db(get_index(),i)); + } + } + + + if (real_peak[0]>peak_l) { + peak_l = real_peak[0]; + } else { + peak_l-=get_process_delta_time()*60.0; + } + + if (real_peak[1]>peak_r) { + peak_r = real_peak[1]; + } else { + peak_r-=get_process_delta_time()*60.0; + + } + + vu_l->set_value(peak_l); + vu_r->set_value(peak_r); + + if (activity_found!=prev_active) { + if (activity_found) { + vu_l->set_over_texture(Ref<Texture>()); + vu_r->set_over_texture(Ref<Texture>()); + } else { + vu_l->set_over_texture(disabled_vu); + vu_r->set_over_texture(disabled_vu); + + } + + prev_active=activity_found; + } + + } + + if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { + + peak_l=-100; + peak_r=-100; + prev_active=true; + + set_process(is_visible_in_tree()); + } + +} + +void EditorAudioBus::update_send() { + + send->clear(); + if (get_index()==0) { + send->set_disabled(true); + send->set_text("Speakers"); + } else { + send->set_disabled(false); + StringName current_send = AudioServer::get_singleton()->get_bus_send(get_index()); + int current_send_index=0; //by default to master + + for(int i=0;i<get_index();i++) { + StringName send_name = AudioServer::get_singleton()->get_bus_name(i); + send->add_item(send_name); + if (send_name==current_send) { + current_send_index=i; + } + } + + send->select(current_send_index); + } +} + +void EditorAudioBus::update_bus() { + + if (updating_bus) + return; + + updating_bus=true; + + int index = get_index(); + + slider->set_value(AudioServer::get_singleton()->get_bus_volume_db(index)); + track_name->set_text(AudioServer::get_singleton()->get_bus_name(index)); + if (get_index()==0) + track_name->set_editable(false); + + solo->set_pressed( AudioServer::get_singleton()->is_bus_solo(index)); + mute->set_pressed( AudioServer::get_singleton()->is_bus_mute(index)); + bypass->set_pressed( AudioServer::get_singleton()->is_bus_bypassing_effects(index)); + // effects.. + effects->clear(); + + TreeItem *root = effects->create_item(); + for(int i=0;i<AudioServer::get_singleton()->get_bus_effect_count(index);i++) { + + Ref<AudioEffect> afx = AudioServer::get_singleton()->get_bus_effect(index,i); + + TreeItem *fx = effects->create_item(root); + fx->set_cell_mode(0,TreeItem::CELL_MODE_CHECK); + fx->set_editable(0,true); + fx->set_checked(0,AudioServer::get_singleton()->is_bus_effect_enabled(index,i)); + fx->set_text(0,afx->get_name()); + fx->set_metadata(0,i); + + } + + TreeItem *add = effects->create_item(root); + add->set_cell_mode(0,TreeItem::CELL_MODE_CUSTOM); + add->set_editable(0,true); + add->set_selectable(0,false); + add->set_text(0,"Add Effect"); + + update_send(); + + updating_bus=false; + +} + + +void EditorAudioBus::_name_changed(const String& p_new_name) { + + if (p_new_name==AudioServer::get_singleton()->get_bus_name(get_index())) + return; + + String attempt=p_new_name; + int attempts=1; + + while(true) { + + bool name_free=true; + for(int i=0;i<AudioServer::get_singleton()->get_bus_count();i++) { + + if (AudioServer::get_singleton()->get_bus_name(i)==attempt) { + name_free=false; + break; + } + } + + if (name_free) { + break; + } + + attempts++; + attempt=p_new_name+" "+itos(attempts); + } + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + StringName current = AudioServer::get_singleton()->get_bus_name(get_index()); + ur->create_action("Rename Audio Bus"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_name",get_index(),attempt); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_name",get_index(),current); + + for(int i=0;i<AudioServer::get_singleton()->get_bus_count();i++) { + if (AudioServer::get_singleton()->get_bus_send(i)==current) { + ur->add_do_method(AudioServer::get_singleton(),"set_bus_send",i,attempt); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_send",i,current); + } + } + + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + + + ur->add_do_method(buses,"_update_sends"); + ur->add_undo_method(buses,"_update_sends"); + ur->commit_action(); + + updating_bus=false; + +} + +void EditorAudioBus::_volume_db_changed(float p_db){ + + if (updating_bus) + return; + + updating_bus=true; + + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Change Audio Bus Volume",UndoRedo::MERGE_ENDS); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_volume_db",get_index(),p_db); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_volume_db",get_index(),AudioServer::get_singleton()->get_bus_volume_db(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; + +} +void EditorAudioBus::_solo_toggled(){ + + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Toggle Audio Bus Solo"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_solo",get_index(),solo->is_pressed()); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_solo",get_index(),AudioServer::get_singleton()->is_bus_solo(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; + +} +void EditorAudioBus::_mute_toggled(){ + + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Toggle Audio Bus Mute"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_mute",get_index(),mute->is_pressed()); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_mute",get_index(),AudioServer::get_singleton()->is_bus_mute(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; + +} +void EditorAudioBus::_bypass_toggled(){ + + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Toggle Audio Bus Bypass Effects"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_bypass_effects",get_index(),bypass->is_pressed()); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_bypass_effects",get_index(),AudioServer::get_singleton()->is_bus_bypassing_effects(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; + + +} + +void EditorAudioBus::_send_selected(int p_which) { + + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Select Audio Bus Send"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_send",get_index(),send->get_item_text(p_which)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_send",get_index(),AudioServer::get_singleton()->get_bus_send(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; +} + +void EditorAudioBus::_effect_selected() { + + TreeItem *effect = effects->get_selected(); + if (!effect) + return; + updating_bus=true; + + if (effect->get_metadata(0)!=Variant()) { + + int index = effect->get_metadata(0); + Ref<AudioEffect> effect = AudioServer::get_singleton()->get_bus_effect(get_index(),index); + if (effect.is_valid()) { + EditorNode::get_singleton()->push_item(effect.ptr()); + } + } + + updating_bus=false; + +} + +void EditorAudioBus::_effect_edited() { + + if (updating_bus) + return; + + TreeItem *effect = effects->get_edited(); + if (!effect) + return; + + if (effect->get_metadata(0)==Variant()) { + Rect2 area = effects->get_item_rect(effect); + + effect_options->set_pos(effects->get_global_pos()+area.pos+Vector2(0,area.size.y)); + effect_options->popup(); + //add effect + } else { + int index = effect->get_metadata(0); + updating_bus=true; + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Select Audio Bus Send"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_effect_enabled",get_index(),index,effect->is_checked(0)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_effect_enabled",get_index(),index,AudioServer::get_singleton()->is_bus_effect_enabled(get_index(),index)); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + updating_bus=false; + + } + +} + +void EditorAudioBus::_effect_add(int p_which) { + + if (updating_bus) + return; + + StringName name = effect_options->get_item_metadata(p_which); + + Object *fx = ClassDB::instance(name); + ERR_FAIL_COND(!fx); + AudioEffect *afx = fx->cast_to<AudioEffect>(); + ERR_FAIL_COND(!afx); + Ref<AudioEffect> afxr = Ref<AudioEffect>(afx); + + afxr->set_name(effect_options->get_item_text(p_which)); + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Add Audio Bus Effect"); + ur->add_do_method(AudioServer::get_singleton(),"add_bus_effect",get_index(),afxr,-1); + ur->add_undo_method(AudioServer::get_singleton(),"remove_bus_effect",get_index(),AudioServer::get_singleton()->get_bus_effect_count(get_index())); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); +} + +void EditorAudioBus::_gui_input(const InputEvent& p_event) { + + if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && !p_event.key.echo) { + accept_event(); + emit_signal("delete_request"); + } + if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==2 && p_event.mouse_button.pressed) { + + Vector2 pos = Vector2(p_event.mouse_button.x,p_event.mouse_button.y); + delete_popup->set_pos(get_global_pos()+pos); + delete_popup->popup(); + } +} + +void EditorAudioBus::_delete_pressed(int p_option) { + + if (p_option==1) { + emit_signal("delete_request"); + } else if (p_option==0) { + //duplicate + emit_signal("duplicate_request",get_index()); + } + +} + + +Variant EditorAudioBus::get_drag_data(const Point2& p_point) { + + if (get_index()==0) { + return Variant(); + } + + Control *c = memnew(Control); + Panel *p = memnew( Panel ); + c->add_child(p); + p->add_style_override("panel",get_stylebox("focus","Button")); + p->set_size(get_size()); + p->set_pos(-p_point); + set_drag_preview(c); + Dictionary d; + d["type"]="move_audio_bus"; + d["index"]=get_index(); + emit_signal("drop_end_request"); + return d; +} + +bool EditorAudioBus::can_drop_data(const Point2& p_point,const Variant& p_data) const { + + if (get_index()==0) + return false; + Dictionary d=p_data; + if (d.has("type") && String(d["type"])=="move_audio_bus") { + return true; + } + + return false; +} +void EditorAudioBus::drop_data(const Point2& p_point,const Variant& p_data) { + + Dictionary d=p_data; + emit_signal("dropped",d["index"],get_index()); + +} + +Variant EditorAudioBus::get_drag_data_fw(const Point2& p_point,Control* p_from) { + + print_line("drag fw"); + TreeItem *item = effects->get_item_at_pos(p_point); + if (!item) { + print_line("no item"); + return Variant(); + } + + Variant md = item->get_metadata(0); + + if (md.get_type()==Variant::INT) { + Dictionary fxd; + fxd["type"]="audio_bus_effect"; + fxd["bus"]=get_index(); + fxd["effect"]=md; + + Label *l = memnew( Label ); + l->set_text(item->get_text(0)); + effects->set_drag_preview(l); + + return fxd; + } + + return Variant(); + +} + +bool EditorAudioBus::can_drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from) const{ + + Dictionary d = p_data; + if (!d.has("type") || String(d["type"])!="audio_bus_effect") + return false; + + TreeItem *item = effects->get_item_at_pos(p_point); + if (!item) + return false; + + effects->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN); + + return true; +} + +void EditorAudioBus::drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from){ + + Dictionary d = p_data; + + TreeItem *item = effects->get_item_at_pos(p_point); + if (!item) + return; + int pos=effects->get_drop_section_at_pos(p_point); + Variant md = item->get_metadata(0); + + int paste_at; + int bus = d["bus"]; + int effect = d["effect"]; + + if (md.get_type()==Variant::INT) { + paste_at=md; + if (pos>0) + paste_at++; + + if (bus==get_index() && paste_at >effect) { + paste_at--; + } + } else { + paste_at=-1; + } + + + bool enabled = AudioServer::get_singleton()->is_bus_effect_enabled(bus,effect); + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Move Bus Effect"); + ur->add_do_method(AudioServer::get_singleton(),"remove_bus_effect",bus,effect); + ur->add_do_method(AudioServer::get_singleton(),"add_bus_effect",get_index(),AudioServer::get_singleton()->get_bus_effect(bus,effect),paste_at); + + if (paste_at==-1) { + paste_at = AudioServer::get_singleton()->get_bus_effect_count(get_index()); + if (bus==get_index()) { + paste_at--; + } + } + if (!enabled) { + ur->add_do_method(AudioServer::get_singleton(),"set_bus_effect_enabled",get_index(),paste_at,false); + } + + ur->add_undo_method(AudioServer::get_singleton(),"remove_bus_effect",get_index(),paste_at); + ur->add_undo_method(AudioServer::get_singleton(),"add_bus_effect",bus,AudioServer::get_singleton()->get_bus_effect(bus,effect),effect); + if (!enabled) { + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_effect_enabled",bus,effect,false); + } + + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + if (get_index()!=bus) { + ur->add_do_method(buses,"_update_bus",bus); + ur->add_undo_method(buses,"_update_bus",bus); + } + ur->commit_action(); + + + +} + +void EditorAudioBus::_delete_effect_pressed(int p_option) { + + TreeItem * item = effects->get_selected(); + if (!item) + return; + + if (item->get_metadata(0).get_type()!=Variant::INT) + return; + + int index = item->get_metadata(0); + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Delete Bus Effect"); + ur->add_do_method(AudioServer::get_singleton(),"remove_bus_effect",get_index(),index); + ur->add_undo_method(AudioServer::get_singleton(),"add_bus_effect",get_index(),AudioServer::get_singleton()->get_bus_effect(get_index(),index),index); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_effect_enabled",get_index(),index,AudioServer::get_singleton()->is_bus_effect_enabled(get_index(),index)); + ur->add_do_method(buses,"_update_bus",get_index()); + ur->add_undo_method(buses,"_update_bus",get_index()); + ur->commit_action(); + + +} + +void EditorAudioBus::_effect_rmb(const Vector2& p_pos) { + + TreeItem * item = effects->get_selected(); + if (!item) + return; + + if (item->get_metadata(0).get_type()!=Variant::INT) + return; + + delete_effect_popup->set_pos(get_global_mouse_pos()); + delete_effect_popup->popup(); +} + +void EditorAudioBus::_bind_methods() { + + ClassDB::bind_method("update_bus",&EditorAudioBus::update_bus); + ClassDB::bind_method("update_send",&EditorAudioBus::update_send); + ClassDB::bind_method("_name_changed",&EditorAudioBus::_name_changed); + ClassDB::bind_method("_volume_db_changed",&EditorAudioBus::_volume_db_changed); + ClassDB::bind_method("_solo_toggled",&EditorAudioBus::_solo_toggled); + ClassDB::bind_method("_mute_toggled",&EditorAudioBus::_mute_toggled); + ClassDB::bind_method("_bypass_toggled",&EditorAudioBus::_bypass_toggled); + ClassDB::bind_method("_name_focus_exit",&EditorAudioBus::_name_focus_exit); + ClassDB::bind_method("_send_selected",&EditorAudioBus::_send_selected); + ClassDB::bind_method("_effect_edited",&EditorAudioBus::_effect_edited); + ClassDB::bind_method("_effect_selected",&EditorAudioBus::_effect_selected); + ClassDB::bind_method("_effect_add",&EditorAudioBus::_effect_add); + ClassDB::bind_method("_gui_input",&EditorAudioBus::_gui_input); + ClassDB::bind_method("_delete_pressed",&EditorAudioBus::_delete_pressed); + ClassDB::bind_method("get_drag_data_fw",&EditorAudioBus::get_drag_data_fw); + ClassDB::bind_method("can_drop_data_fw",&EditorAudioBus::can_drop_data_fw); + ClassDB::bind_method("drop_data_fw",&EditorAudioBus::drop_data_fw); + ClassDB::bind_method("_delete_effect_pressed",&EditorAudioBus::_delete_effect_pressed); + ClassDB::bind_method("_effect_rmb",&EditorAudioBus::_effect_rmb); + + + + ADD_SIGNAL(MethodInfo("duplicate_request")); + ADD_SIGNAL(MethodInfo("delete_request")); + ADD_SIGNAL(MethodInfo("drop_end_request")); + ADD_SIGNAL(MethodInfo("dropped")); + +} + +EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses) { + + buses=p_buses; + updating_bus=false; + + VBoxContainer *vb = memnew( VBoxContainer ); + add_child(vb); + + set_v_size_flags(SIZE_EXPAND_FILL); + + track_name = memnew( LineEdit ); + vb->add_child(track_name); + track_name->connect("text_entered",this,"_name_changed"); + track_name->connect("focus_exited",this,"_name_focus_exit"); + + HBoxContainer *hbc = memnew( HBoxContainer); + vb->add_child(hbc); + hbc->add_spacer(); + solo = memnew( ToolButton ); + solo->set_text("S"); + solo->set_toggle_mode(true); + solo->set_modulate(Color(0.8,1.2,0.8)); + solo->set_focus_mode(FOCUS_NONE); + solo->connect("pressed",this,"_solo_toggled"); + hbc->add_child(solo); + mute = memnew( ToolButton ); + mute->set_text("M"); + mute->set_toggle_mode(true); + mute->set_modulate(Color(1.2,0.8,0.8)); + mute->set_focus_mode(FOCUS_NONE); + mute->connect("pressed",this,"_mute_toggled"); + hbc->add_child(mute); + bypass = memnew( ToolButton ); + bypass->set_text("B"); + bypass->set_toggle_mode(true); + bypass->set_modulate(Color(1.1,1.1,0.8)); + bypass->set_focus_mode(FOCUS_NONE); + bypass->connect("pressed",this,"_bypass_toggled"); + hbc->add_child(bypass); + hbc->add_spacer(); + + HBoxContainer *hb = memnew( HBoxContainer ); + vb->add_child(hb); + slider = memnew( VSlider ); + slider->set_min(-80); + slider->set_max(24); + slider->set_step(0.1); + + slider->connect("value_changed",this,"_volume_db_changed"); + hb->add_child(slider); + vu_l = memnew( TextureProgress ); + vu_l->set_fill_mode(TextureProgress::FILL_BOTTOM_TO_TOP); + hb->add_child(vu_l); + vu_l->set_min(-80); + vu_l->set_max(24); + vu_l->set_step(0.1); + + vu_r = memnew( TextureProgress ); + vu_r->set_fill_mode(TextureProgress::FILL_BOTTOM_TO_TOP); + hb->add_child(vu_r); + vu_r->set_min(-80); + vu_r->set_max(24); + vu_r->set_step(0.1); + + scale = memnew( TextureRect ); + hb->add_child(scale); + + //add_child(hb); + + effects = memnew( Tree ); + effects->set_hide_root(true); + effects->set_custom_minimum_size(Size2(0,90)*EDSCALE); + effects->set_hide_folding(true); + vb->add_child(effects); + effects->connect("item_edited",this,"_effect_edited"); + effects->connect("cell_selected",this,"_effect_selected"); + effects->set_edit_checkbox_cell_only_when_checkbox_is_pressed(true); + effects->set_drag_forwarding(this); + effects->connect("item_rmb_selected",this,"_effect_rmb"); + effects->set_allow_rmb_select(true); + + send = memnew( OptionButton ); + send->set_clip_text(true); + send->connect("item_selected",this,"_send_selected"); + vb->add_child(send); + + set_focus_mode(FOCUS_CLICK); + + effect_options = memnew( PopupMenu ); + effect_options->connect("index_pressed",this,"_effect_add"); + add_child(effect_options); + List<StringName> effects; + ClassDB::get_inheriters_from_class("AudioEffect",&effects); + effects.sort_custom<StringName::AlphCompare>(); + for (List<StringName>::Element *E=effects.front();E;E=E->next()) { + if (!ClassDB::can_instance(E->get())) + continue; + + Ref<Texture> icon; + if (has_icon(E->get(),"EditorIcons")) { + icon = get_icon(E->get(),"EditorIcons"); + } + String name = E->get().operator String().replace("AudioEffect",""); + effect_options->add_item(name); + effect_options->set_item_metadata(effect_options->get_item_count()-1,E->get()); + effect_options->set_item_icon(effect_options->get_item_count()-1,icon); + } + + delete_popup = memnew( PopupMenu ); + delete_popup->add_item("Duplicate"); + delete_popup->add_item("Delete"); + add_child(delete_popup); + delete_popup->connect("index_pressed",this,"_delete_pressed"); + + delete_effect_popup = memnew( PopupMenu ); + delete_effect_popup->add_item("Delete Effect"); + add_child(delete_effect_popup); + delete_effect_popup->connect("index_pressed",this,"_delete_effect_pressed"); + +} + + + +bool EditorAudioBusDrop::can_drop_data(const Point2& p_point,const Variant& p_data) const { + + Dictionary d=p_data; + if (d.has("type") && String(d["type"])=="move_audio_bus") { + return true; + } + + return false; +} +void EditorAudioBusDrop::drop_data(const Point2& p_point,const Variant& p_data){ + + Dictionary d=p_data; + emit_signal("dropped",d["index"],-1); + +} + +void EditorAudioBusDrop::_bind_methods() { + + ADD_SIGNAL(MethodInfo("dropped")); +} + +EditorAudioBusDrop::EditorAudioBusDrop() { + + +} + + +void EditorAudioBuses::_update_buses() { + + while(bus_hb->get_child_count()>0) { + memdelete(bus_hb->get_child(0)); + } + + drop_end=NULL; + + for(int i=0;i<AudioServer::get_singleton()->get_bus_count();i++) { + + EditorAudioBus *audio_bus = memnew( EditorAudioBus(this) ); + if (i==0) { + audio_bus->set_self_modulate(Color(1,0.9,0.9)); + } + bus_hb->add_child(audio_bus); + audio_bus->connect("delete_request",this,"_delete_bus",varray(audio_bus),CONNECT_DEFERRED); + audio_bus->connect("duplicate_request",this,"_duplicate_bus",varray(),CONNECT_DEFERRED); + audio_bus->connect("drop_end_request",this,"_request_drop_end"); + audio_bus->connect("dropped",this,"_drop_at_index",varray(),CONNECT_DEFERRED); + + + + } +} + +EditorAudioBuses *EditorAudioBuses::register_editor() { + + EditorAudioBuses * audio_buses = memnew( EditorAudioBuses ); + EditorNode::get_singleton()->add_bottom_panel_item("Audio",audio_buses); + return audio_buses; +} + +void EditorAudioBuses::_notification(int p_what) { + + if (p_what==NOTIFICATION_READY) { + _update_buses(); + } + + if (p_what==NOTIFICATION_DRAG_END) { + if (drop_end) { + drop_end->queue_delete(); + drop_end=NULL; + } + } + + if (p_what==NOTIFICATION_PROCESS) { + + //check if anything was edited + bool edited = AudioServer::get_singleton()->is_edited(); + for(int i=0;i<AudioServer::get_singleton()->get_bus_count();i++) { + for(int j=0;j<AudioServer::get_singleton()->get_bus_effect_count(i);j++) { + Ref<AudioEffect> effect = AudioServer::get_singleton()->get_bus_effect(i,j); + if (effect->is_edited()) { + edited=true; + effect->set_edited(false); + } + } + } + + AudioServer::get_singleton()->set_edited(false); + + if (edited) { + + save_timer->start(); + } + } + +} + + +void EditorAudioBuses::_add_bus() { + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + //need to simulate new name, so we can undi :( + ur->create_action("Add Audio Bus"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_count",AudioServer::get_singleton()->get_bus_count()+1); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_count",AudioServer::get_singleton()->get_bus_count()); + ur->add_do_method(this,"_update_buses"); + ur->add_undo_method(this,"_update_buses"); + ur->commit_action(); + +} + +void EditorAudioBuses::_update_bus(int p_index) { + + if (p_index>=bus_hb->get_child_count()) + return; + + bus_hb->get_child(p_index)->call("update_bus"); +} + +void EditorAudioBuses::_update_sends() { + + for(int i=0;i<bus_hb->get_child_count();i++) { + bus_hb->get_child(i)->call("update_send"); + } +} + +void EditorAudioBuses::_delete_bus(Object* p_which) { + + EditorAudioBus *bus = p_which->cast_to<EditorAudioBus>(); + int index = bus->get_index(); + if (index==0) { + EditorNode::get_singleton()->show_warning("Master bus can't be deleted!"); + return; + } + + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + ur->create_action("Delete Audio Bus"); + ur->add_do_method(AudioServer::get_singleton(),"remove_bus",index); + ur->add_undo_method(AudioServer::get_singleton(),"add_bus",index); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_name",index,AudioServer::get_singleton()->get_bus_name(index)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_volume_db",index,AudioServer::get_singleton()->get_bus_volume_db(index)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_send",index,AudioServer::get_singleton()->get_bus_send(index)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_solo",index,AudioServer::get_singleton()->is_bus_solo(index)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_mute",index,AudioServer::get_singleton()->is_bus_mute(index)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_bypass_effects",index,AudioServer::get_singleton()->is_bus_bypassing_effects(index)); + for(int i=0;i<AudioServer::get_singleton()->get_bus_effect_count(index);i++) { + + ur->add_undo_method(AudioServer::get_singleton(),"add_bus_effect",index,AudioServer::get_singleton()->get_bus_effect(index,i)); + ur->add_undo_method(AudioServer::get_singleton(),"set_bus_effect_enabled",index,i,AudioServer::get_singleton()->is_bus_effect_enabled(index,i)); + } + ur->add_do_method(this,"_update_buses"); + ur->add_undo_method(this,"_update_buses"); + ur->commit_action(); + +} + + +void EditorAudioBuses::_duplicate_bus(int p_which) { + + int add_at_pos = p_which+1; + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + ur->create_action("Duplicate Audio Bus"); + ur->add_do_method(AudioServer::get_singleton(),"add_bus",add_at_pos); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_name",add_at_pos,AudioServer::get_singleton()->get_bus_name(p_which)+" Copy"); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_volume_db",add_at_pos,AudioServer::get_singleton()->get_bus_volume_db(p_which)); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_send",add_at_pos,AudioServer::get_singleton()->get_bus_send(p_which)); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_solo",add_at_pos,AudioServer::get_singleton()->is_bus_solo(p_which)); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_mute",add_at_pos,AudioServer::get_singleton()->is_bus_mute(p_which)); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_bypass_effects",add_at_pos,AudioServer::get_singleton()->is_bus_bypassing_effects(p_which)); + for(int i=0;i<AudioServer::get_singleton()->get_bus_effect_count(p_which);i++) { + + ur->add_do_method(AudioServer::get_singleton(),"add_bus_effect",add_at_pos,AudioServer::get_singleton()->get_bus_effect(p_which,i)); + ur->add_do_method(AudioServer::get_singleton(),"set_bus_effect_enabled",add_at_pos,i,AudioServer::get_singleton()->is_bus_effect_enabled(p_which,i)); + } + ur->add_undo_method(AudioServer::get_singleton(),"remove_bus",add_at_pos); + ur->add_do_method(this,"_update_buses"); + ur->add_undo_method(this,"_update_buses"); + ur->commit_action(); + +} + +void EditorAudioBuses::_request_drop_end() { + + if (!drop_end && bus_hb->get_child_count()) { + drop_end = memnew( EditorAudioBusDrop ); + + bus_hb->add_child(drop_end); + drop_end->set_custom_minimum_size(bus_hb->get_child(0)->cast_to<Control>()->get_size()); + drop_end->connect("dropped",this,"_drop_at_index",varray(),CONNECT_DEFERRED); + } +} + +void EditorAudioBuses::_drop_at_index(int p_bus,int p_index) { + + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + //need to simulate new name, so we can undi :( + ur->create_action("Move Audio Bus"); + ur->add_do_method(AudioServer::get_singleton(),"move_bus",p_bus,p_index); + int final_pos; + if (p_index==p_bus) { + final_pos=p_bus; + } else if (p_index==-1) { + final_pos = AudioServer::get_singleton()->get_bus_count()-1; + } else if (p_index<p_bus) { + final_pos = p_index; + } else { + final_pos = p_index -1; + } + ur->add_undo_method(AudioServer::get_singleton(),"move_bus",final_pos,p_bus); + + ur->add_do_method(this,"_update_buses"); + ur->add_undo_method(this,"_update_buses"); + ur->commit_action(); +} + +void EditorAudioBuses::_server_save() { + + Ref<AudioBusLayout> state = AudioServer::get_singleton()->generate_bus_layout(); + ResourceSaver::save(edited_path,state); + +} + +void EditorAudioBuses::_select_layout() { + + EditorNode::get_singleton()->get_filesystem_dock()->select_file(edited_path); +} + +void EditorAudioBuses::_save_as_layout() { + + file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE); + file_dialog->set_title(TTR("Save Audio Bus Layout As..")); + file_dialog->set_current_path(edited_path); + file_dialog->popup_centered_ratio(); + new_layout=false; +} + + +void EditorAudioBuses::_new_layout() { + + file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE); + file_dialog->set_title(TTR("Location for New Layout..")); + file_dialog->set_current_path(edited_path); + file_dialog->popup_centered_ratio(); + new_layout=true; +} + +void EditorAudioBuses::_load_layout() { + + file_dialog->set_mode(EditorFileDialog::MODE_OPEN_FILE); + file_dialog->set_title(TTR("Open Audio Bus Layout")); + file_dialog->set_current_path(edited_path); + file_dialog->popup_centered_ratio(); + new_layout=false; +} + + +void EditorAudioBuses::_load_default_layout() { + + + Ref<AudioBusLayout> state = ResourceLoader::load("res://default_bus_layout.tres"); + if (state.is_null()) { + EditorNode::get_singleton()->show_warning("There is no 'res://default_bus_layout.tres' file."); + return; + } + + edited_path="res://default_bus_layout.tres"; + file->set_text(edited_path.get_file()); + AudioServer::get_singleton()->set_bus_layout(state); + _update_buses(); + EditorNode::get_singleton()->get_undo_redo()->clear_history(); + call_deferred("_select_layout"); +} + +void EditorAudioBuses::_file_dialog_callback(const String& p_string) { + + if (file_dialog->get_mode()==EditorFileDialog::MODE_OPEN_FILE) { + Ref<AudioBusLayout> state = ResourceLoader::load(p_string); + if (state.is_null()) { + EditorNode::get_singleton()->show_warning("Invalid file, not an audio bus layout."); + return; + } + + edited_path=p_string; + file->set_text(p_string.get_file()); + AudioServer::get_singleton()->set_bus_layout(state); + _update_buses(); + EditorNode::get_singleton()->get_undo_redo()->clear_history(); + call_deferred("_select_layout"); + + } else if (file_dialog->get_mode()==EditorFileDialog::MODE_SAVE_FILE) { + + if (new_layout) { + Ref<AudioBusLayout> empty_state; + empty_state.instance(); + AudioServer::get_singleton()->set_bus_layout(empty_state); + } + + Error err = ResourceSaver::save(p_string,AudioServer::get_singleton()->generate_bus_layout()); + + if (err!=OK) { + EditorNode::get_singleton()->show_warning("Error saving file: "+p_string); + return; + } + + edited_path=p_string; + file->set_text(p_string.get_file()); + _update_buses(); + EditorNode::get_singleton()->get_undo_redo()->clear_history(); + call_deferred("_select_layout"); + } + +} + +void EditorAudioBuses::_bind_methods() { + + ClassDB::bind_method("_add_bus",&EditorAudioBuses::_add_bus); + ClassDB::bind_method("_update_buses",&EditorAudioBuses::_update_buses); + ClassDB::bind_method("_update_bus",&EditorAudioBuses::_update_bus); + ClassDB::bind_method("_update_sends",&EditorAudioBuses::_update_sends); + ClassDB::bind_method("_delete_bus",&EditorAudioBuses::_delete_bus); + ClassDB::bind_method("_request_drop_end",&EditorAudioBuses::_request_drop_end); + ClassDB::bind_method("_drop_at_index",&EditorAudioBuses::_drop_at_index); + ClassDB::bind_method("_server_save",&EditorAudioBuses::_server_save); + ClassDB::bind_method("_select_layout",&EditorAudioBuses::_select_layout); + ClassDB::bind_method("_save_as_layout",&EditorAudioBuses::_save_as_layout); + ClassDB::bind_method("_load_layout",&EditorAudioBuses::_load_layout); + ClassDB::bind_method("_load_default_layout",&EditorAudioBuses::_load_default_layout); + ClassDB::bind_method("_new_layout",&EditorAudioBuses::_new_layout); + ClassDB::bind_method("_duplicate_bus",&EditorAudioBuses::_duplicate_bus); + + ClassDB::bind_method("_file_dialog_callback",&EditorAudioBuses::_file_dialog_callback); +} + +EditorAudioBuses::EditorAudioBuses() +{ + + drop_end = NULL; + top_hb = memnew( HBoxContainer ); + add_child(top_hb); + + add = memnew( Button ); + top_hb->add_child(add);; + add->set_text(TTR("Add Bus")); + + add->connect("pressed",this,"_add_bus"); + + + + top_hb->add_spacer(); + + file = memnew( ToolButton ); + file->set_text("default_bus_layout.tres"); + top_hb->add_child(file); + file->connect("pressed",this,"_select_layout"); + + load = memnew( Button ); + load->set_text(TTR("Load")); + top_hb->add_child(load); + load->connect("pressed",this,"_load_layout"); + + save_as = memnew( Button ); + save_as->set_text(TTR("Save As")); + top_hb->add_child(save_as); + save_as->connect("pressed",this,"_save_as_layout"); + + _default = memnew( Button ); + _default->set_text(TTR("Default")); + top_hb->add_child(_default); + _default->connect("pressed",this,"_load_default_layout"); + + _new = memnew( Button ); + _new->set_text(TTR("Create")); + top_hb->add_child(_new); + _new->connect("pressed",this,"_new_layout"); + + bus_scroll = memnew( ScrollContainer ); + bus_scroll->set_v_size_flags(SIZE_EXPAND_FILL); + bus_scroll->set_enable_h_scroll(true); + bus_scroll->set_enable_v_scroll(false); + add_child(bus_scroll); + bus_hb = memnew( HBoxContainer ); + bus_scroll->add_child(bus_hb); + + save_timer=memnew(Timer); + save_timer->set_wait_time(0.8); + save_timer->set_one_shot(true); + add_child(save_timer); + save_timer->connect("timeout",this,"_server_save"); + + set_v_size_flags(SIZE_EXPAND_FILL); + + + edited_path = "res://default_bus_layout.tres"; + + file_dialog = memnew( EditorFileDialog ); + List<String> ext; + ResourceLoader::get_recognized_extensions_for_type("AudioServerState",&ext); + for (List<String>::Element *E=ext.front();E;E=E->next()) { + file_dialog->add_filter("*."+E->get()+"; Audio Bus State"); + } + add_child(file_dialog); + file_dialog->connect("file_selected",this,"_file_dialog_callback"); + + set_process(true); + +} +void EditorAudioBuses::open_layout(const String& p_path) { + + EditorNode::get_singleton()->make_bottom_panel_item_visible(this); + + Ref<AudioBusLayout> state = ResourceLoader::load(p_path); + if (state.is_null()) { + EditorNode::get_singleton()->show_warning("Invalid file, not an audio bus layout."); + return; + } + + edited_path=p_path; + file->set_text(p_path.get_file()); + AudioServer::get_singleton()->set_bus_layout(state); + _update_buses(); + EditorNode::get_singleton()->get_undo_redo()->clear_history(); + call_deferred("_select_layout"); +} + +void AudioBusesEditorPlugin::edit(Object *p_node) { + + if (p_node->cast_to<AudioBusLayout>()) { + + String path = p_node->cast_to<AudioBusLayout>()->get_path(); + if (path.is_resource_file()) { + audio_bus_editor->open_layout(path); + } + } +} + +bool AudioBusesEditorPlugin::handles(Object *p_node) const { + + return (p_node->cast_to<AudioBusLayout>()!=NULL); +} + +void AudioBusesEditorPlugin::make_visible(bool p_visible){ + + +} + +AudioBusesEditorPlugin::AudioBusesEditorPlugin(EditorAudioBuses *p_node) { + + audio_bus_editor=p_node; +} + +AudioBusesEditorPlugin::~AudioBusesEditorPlugin() { + +} |