/*************************************************************************/ /* animation_player_editor_plugin.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* http://www.godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "animation_player_editor_plugin.h" #include "globals.h" #include "io/resource_loader.h" #include "io/resource_saver.h" #include "os/keyboard.h" #include "tools/editor/editor_settings.h" #include "tools/editor/animation_editor.h" void AnimationPlayerEditor::_node_removed(Node *p_node) { if (player && player == p_node) { player=NULL; set_process(false); key_editor->set_animation(Ref()); key_editor->set_root(NULL); key_editor->show_select_node_warning(true); _update_player(); //editor->animation_editor_make_visible(false); } } void AnimationPlayerEditor::_gui_input(InputEvent p_event) { } void AnimationPlayerEditor::_notification(int p_what) { if (p_what==NOTIFICATION_PROCESS) { if (!player) return; updating = true; if (player->is_playing()) { { String animname=player->get_current_animation(); if (player->has_animation(animname)) { Ref anim = player->get_animation(animname); if (!anim.is_null()) { frame->set_max(anim->get_length()); } } } frame->set_value(player->get_current_animation_pos()); key_editor->set_anim_pos(player->get_current_animation_pos()); EditorNode::get_singleton()->get_property_editor()->refresh(); } else if (last_active) { //need the last frame after it stopped frame->set_value(player->get_current_animation_pos()); } last_active=player->is_playing(); //seek->set_val(player->get_pos()); updating = false; } if (p_what==NOTIFICATION_ENTER_TREE) { // editor->connect("hide_animation_player_editors",this,"_hide_anim_editors"); add_anim->set_icon( get_icon("New","EditorIcons") ); rename_anim->set_icon( get_icon("Rename","EditorIcons") ); duplicate_anim->set_icon( get_icon("Duplicate","EditorIcons") ); autoplay->set_icon( get_icon("AutoPlay","EditorIcons") ); load_anim->set_icon( get_icon("Folder","EditorIcons") ); save_anim->set_icon(get_icon("Save", "EditorIcons")); save_anim->get_popup()->connect("id_pressed", this, "_animation_save_menu"); remove_anim->set_icon( get_icon("Remove","EditorIcons") ); blend_anim->set_icon( get_icon("Blend","EditorIcons") ); play->set_icon( get_icon("PlayStart","EditorIcons") ); play_from->set_icon( get_icon("Play","EditorIcons") ); play_bw->set_icon( get_icon("PlayStartBackwards","EditorIcons") ); play_bw_from->set_icon( get_icon("PlayBackwards","EditorIcons") ); autoplay_icon=get_icon("AutoPlay","EditorIcons"); stop->set_icon( get_icon("Stop","EditorIcons") ); resource_edit_anim->set_icon( get_icon("EditResource","EditorIcons") ); pin->set_icon(get_icon("Pin","EditorIcons") ); tool_anim->set_icon(get_icon("Tools","EditorIcons")); tool_anim->get_popup()->connect("id_pressed",this,"_animation_tool_menu"); blend_editor.next->connect("item_selected", this, "_blend_editor_next_changed"); nodename->set_icon(get_icon("AnimationPlayer","EditorIcons")); /* anim_editor_load->set_normal_texture( get_icon("AnimGet","EditorIcons")); anim_editor_store->set_normal_texture( get_icon("AnimSet","EditorIcons")); anim_editor_load->set_pressed_texture( get_icon("AnimGet","EditorIcons")); anim_editor_store->set_pressed_texture( get_icon("AnimSet","EditorIcons")); anim_editor_load->set_hover_texture( get_icon("AnimGetHl","EditorIcons")); anim_editor_store->set_hover_texture( get_icon("AnimSetHl","EditorIcons")); */ get_tree()->connect("node_removed",this,"_node_removed"); } } void AnimationPlayerEditor::_autoplay_pressed() { if (updating) return; if (animation->get_item_count()==0) { return; } String current = animation->get_item_text( animation->get_selected() ); if (player->get_autoplay()==current) { //unset undo_redo->create_action(TTR("Toggle Autoplay")); undo_redo->add_do_method(player,"set_autoplay",""); undo_redo->add_undo_method(player,"set_autoplay",player->get_autoplay()); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); } else { //set undo_redo->create_action(TTR("Toggle Autoplay")); undo_redo->add_do_method(player,"set_autoplay",current); undo_redo->add_undo_method(player,"set_autoplay",player->get_autoplay()); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); } } void AnimationPlayerEditor::_play_pressed() { String current; if (animation->get_selected()>=0 && animation->get_selected()get_item_count()) { current = animation->get_item_text( animation->get_selected() ); } if (current!="") { if (current==player->get_current_animation()) player->stop(); //so it wont blend with itself player->play(current ); } //unstop stop->set_pressed(false); //unpause //pause->set_pressed(false); } void AnimationPlayerEditor::_play_from_pressed() { String current; if (animation->get_selected()>=0 && animation->get_selected()get_item_count()) { current = animation->get_item_text( animation->get_selected() ); } if (current!="") { float time = player->get_current_animation_pos(); if (current==player->get_current_animation() && player->is_playing()) { player->stop(); //so it wont blend with itself } player->play( current ); player->seek(time); } //unstop stop->set_pressed(false); //unpause //pause->set_pressed(false); } void AnimationPlayerEditor::_play_bw_pressed() { String current; if (animation->get_selected()>=0 && animation->get_selected()get_item_count()) { current = animation->get_item_text( animation->get_selected() ); } if (current!="") { if (current==player->get_current_animation()) player->stop(); //so it wont blend with itself player->play(current,-1,-1,true); } //unstop stop->set_pressed(false); //unpause //pause->set_pressed(false); } void AnimationPlayerEditor::_play_bw_from_pressed() { String current; if (animation->get_selected()>=0 && animation->get_selected()get_item_count()) { current = animation->get_item_text( animation->get_selected() ); } if (current!="") { float time = player->get_current_animation_pos(); if (current==player->get_current_animation()) player->stop(); //so it wont blend with itself player->play(current,-1,-1,true); player->seek(time); } //unstop stop->set_pressed(false); //unpause //pause->set_pressed(false); } void AnimationPlayerEditor::_stop_pressed() { player->stop(false); play->set_pressed(false); stop->set_pressed(true); //pause->set_pressed(false); //player->set_pause(false); } void AnimationPlayerEditor::_pause_pressed() { //player->set_pause( pause->is_pressed() ); } void AnimationPlayerEditor::_animation_selected(int p_which) { if (updating) return; // when selecting an animation, the idea is that the only interesting behavior // ui-wise is that it should play/blend the next one if currently playing String current; if (animation->get_selected()>=0 && animation->get_selected()get_item_count()) { current = animation->get_item_text( animation->get_selected() ); } if (current!="") { player->set_current_animation( current ); Ref anim = player->get_animation(current); { key_editor->set_animation(anim); Node *root = player->get_node(player->get_root()); if (root) { key_editor->set_root(root); } } frame->set_max(anim->get_length()); if (anim->get_step()) frame->set_step(anim->get_step()); else frame->set_step(0.00001); } else { key_editor->set_animation(Ref()); key_editor->set_root(NULL); } autoplay->set_pressed(current==player->get_autoplay()); } void AnimationPlayerEditor::_animation_new() { renaming=false; name_title->set_text(TTR("New Animation Name:")); int count=1; String base=TTR("New Anim"); while(true) { String attempt = base; if (count>1) attempt+=" ("+itos(count)+")"; if (player->has_animation(attempt)) { count++; continue; } base=attempt; break; } name->set_text(base); name_dialog->popup_centered(Size2(300,90)); name->select_all(); name->grab_focus(); } void AnimationPlayerEditor::_animation_rename() { if (animation->get_item_count()==0) return; int selected = animation->get_selected(); String selected_name = animation->get_item_text(selected); name_title->set_text(TTR("Change Animation Name:")); name->set_text(selected_name); renaming=true; name_dialog->popup_centered(Size2(300,90)); name->select_all(); name->grab_focus(); } void AnimationPlayerEditor::_animation_load() { ERR_FAIL_COND(!player); file->set_mode( EditorFileDialog::MODE_OPEN_FILE ); file->clear_filters(); List extensions; ResourceLoader::get_recognized_extensions_for_type("Animation",&extensions); for (List::Element *E=extensions.front();E;E=E->next()) { file->add_filter("*."+E->get()+" ; "+E->get().to_upper() ); } file->popup_centered_ratio(); current_option = RESOURCE_LOAD; } void AnimationPlayerEditor::_animation_save_in_path(const Ref& p_resource, const String& p_path) { int flg = 0; if (EditorSettings::get_singleton()->get("filesystem/on_save/compress_binary_resources")) flg |= ResourceSaver::FLAG_COMPRESS; //if (EditorSettings::get_singleton()->get("filesystem/on_save/save_paths_as_relative")) // flg |= ResourceSaver::FLAG_RELATIVE_PATHS; String path = GlobalConfig::get_singleton()->localize_path(p_path); Error err = ResourceSaver::save(path, p_resource, flg | ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS); if (err != OK) { accept->set_text(TTR("Error saving resource!")); accept->popup_centered_minsize(); return; } // EditorFileSystem::get_singleton()->update_file(path,p_resource->get_type()); ((Resource*)p_resource.ptr())->set_path(path); editor->emit_signal("resource_saved", p_resource); } void AnimationPlayerEditor::_animation_save(const Ref& p_resource) { if (p_resource->get_path().is_resource_file()) { _animation_save_in_path(p_resource, p_resource->get_path()); } else { _animation_save_as(p_resource); } } void AnimationPlayerEditor::_animation_save_as(const Ref& p_resource) { file->set_mode(EditorFileDialog::MODE_SAVE_FILE); List extensions; ResourceSaver::get_recognized_extensions(p_resource, &extensions); file->clear_filters(); for (int i = 0; iadd_filter("*." + extensions[i] + " ; " + extensions[i].to_upper()); } //file->set_current_path(current_path); if (p_resource->get_path() != "") { file->set_current_path(p_resource->get_path()); if (extensions.size()) { String ext = p_resource->get_path().extension().to_lower(); if (extensions.find(ext) == NULL) { file->set_current_path(p_resource->get_path().replacen("." + ext, "." + extensions.front()->get())); } } } else { String existing; if (extensions.size()) { existing = "new_" + p_resource->get_class().to_lower() + "." + extensions.front()->get().to_lower(); } file->set_current_path(existing); } file->popup_centered_ratio(); file->set_title(TTR("Save Resource As..")); current_option = RESOURCE_SAVE; } void AnimationPlayerEditor::_animation_remove() { if (animation->get_item_count()==0) return; String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); undo_redo->create_action(TTR("Remove Animation")); undo_redo->add_do_method(player,"remove_animation",current); undo_redo->add_undo_method(player,"add_animation",current,anim); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); } void AnimationPlayerEditor::_select_anim_by_name(const String& p_anim) { int idx=-1; for(int i=0;iget_item_count();i++) { if (animation->get_item_text(i)==p_anim) { idx=i; break; } } ERR_FAIL_COND(idx==-1); animation->select(idx); _animation_selected(idx); } void AnimationPlayerEditor::_animation_name_edited() { player->stop(); String new_name = name->get_text(); if (new_name=="" || new_name.find(":")!=-1 || new_name.find("/")!=-1) { error_dialog->set_text(TTR("ERROR: Invalid animation name!")); error_dialog->popup_centered_minsize(); return; } if (renaming && animation->get_item_count()>0 && animation->get_item_text(animation->get_selected())==new_name) { name_dialog->hide(); return; } if (player->has_animation(new_name)) { error_dialog->set_text(TTR("ERROR: Animation name already exists!")); error_dialog->popup_centered_minsize(); return; } if (renaming) { String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); undo_redo->create_action(TTR("Rename Animation")); undo_redo->add_do_method(player,"rename_animation",current,new_name); undo_redo->add_do_method(anim.ptr(),"set_name",new_name); undo_redo->add_undo_method(player,"rename_animation",new_name,current); undo_redo->add_undo_method(anim.ptr(),"set_name",current); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); _select_anim_by_name(new_name); } else { Ref new_anim = Ref(memnew( Animation )); new_anim->set_name(new_name); undo_redo->create_action(TTR("Add Animation")); undo_redo->add_do_method(player,"add_animation",new_name,new_anim); undo_redo->add_undo_method(player,"remove_animation",new_name); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); _select_anim_by_name(new_name); } name_dialog->hide(); } void AnimationPlayerEditor::_blend_editor_next_changed(const int p_idx) { if (animation->get_item_count()==0) return; String current = animation->get_item_text(animation->get_selected()); undo_redo->create_action(TTR("Blend Next Changed")); undo_redo->add_do_method(player,"animation_set_next",current,blend_editor.next->get_item_text(p_idx)); undo_redo->add_undo_method(player,"animation_set_next",current,player->animation_get_next(current)); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); } void AnimationPlayerEditor::_animation_blend() { if (updating_blends) return; blend_editor.tree->clear(); if (animation->get_item_count()==0) return; String current = animation->get_item_text(animation->get_selected()); blend_editor.dialog->popup_centered(Size2(400,400)); blend_editor.tree->set_hide_root(true); blend_editor.tree->set_column_min_width(0,10); blend_editor.tree->set_column_min_width(1,3); List anims; player->get_animation_list(&anims); TreeItem *root = blend_editor.tree->create_item(); updating_blends=true; int i = 0; bool anim_found = false; blend_editor.next->clear(); blend_editor.next->add_item("", i); for(List::Element *E=anims.front();E;E=E->next()) { String to=E->get(); TreeItem *blend=blend_editor.tree->create_item(root); blend->set_editable(0,false); blend->set_editable(1,true); blend->set_text(0,to); blend->set_cell_mode(1,TreeItem::CELL_MODE_RANGE); blend->set_range_config(1,0,3600,0.001); blend->set_range(1,player->get_blend_time(current,to)); i++; blend_editor.next->add_item(to, i); if (to == player->animation_get_next(current)) { blend_editor.next->select(i); anim_found = true; } } // make sure we reset it else it becomes out of sync and could contain a deleted animation if (!anim_found) { blend_editor.next->select(0); player->animation_set_next(current, blend_editor.next->get_item_text(0)); } updating_blends=false; } void AnimationPlayerEditor::_blend_edited() { if (updating_blends) return; if (animation->get_item_count()==0) return; String current = animation->get_item_text(animation->get_selected()); TreeItem *selected = blend_editor.tree->get_edited(); if (!selected) return; updating_blends=true; String to=selected->get_text(0); float blend_time = selected->get_range(1); float prev_blend_time = player->get_blend_time(current,to); undo_redo->create_action(TTR("Change Blend Time")); undo_redo->add_do_method(player,"set_blend_time",current,to,blend_time); undo_redo->add_undo_method(player,"set_blend_time",current,to,prev_blend_time); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); updating_blends=false; } void AnimationPlayerEditor::ensure_visibility() { if (player && pin->is_pressed()) return; // another player is pinned, don't reset _animation_edit(); } Dictionary AnimationPlayerEditor::get_state() const { Dictionary d; d["visible"]=is_visible(); if (EditorNode::get_singleton()->get_edited_scene() && is_visible() && player) { d["player"]=EditorNode::get_singleton()->get_edited_scene()->get_path_to(player); d["animation"]=player->get_current_animation(); } return d; } void AnimationPlayerEditor::set_state(const Dictionary& p_state) { if (p_state.has("visible") && p_state["visible"]) { if (!EditorNode::get_singleton()->get_edited_scene()) return; Node *n = EditorNode::get_singleton()->get_edited_scene()->get_node(p_state["player"]); if (n && n->cast_to() && EditorNode::get_singleton()->get_editor_selection()->is_selected(n)) { player=n->cast_to(); _update_player(); show(); set_process(true); ensure_visibility(); // EditorNode::get_singleton()->animation_panel_make_visible(true); if (p_state.has("animation")) { String anim = p_state["animation"]; _select_anim_by_name(anim); _animation_edit(); } } } } void AnimationPlayerEditor::_animation_resource_edit() { if (animation->get_item_count()) { String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); editor->edit_resource(anim); } } void AnimationPlayerEditor::_animation_edit() { if (animation->get_item_count()) { String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); key_editor->set_animation(anim); Node *root = player->get_node(player->get_root()); if (root) { key_editor->set_root(root); } } else { key_editor->set_animation(Ref()); key_editor->set_root(NULL); } } void AnimationPlayerEditor::_dialog_action(String p_file) { switch (current_option) { case RESOURCE_LOAD: { ERR_FAIL_COND(!player); Ref res = ResourceLoader::load(p_file, "Animation"); ERR_FAIL_COND(res.is_null()); ERR_FAIL_COND(!res->is_class("Animation")); if (p_file.find_last("/") != -1) { p_file = p_file.substr(p_file.find_last("/") + 1, p_file.length()); } if (p_file.find_last("\\") != -1) { p_file = p_file.substr(p_file.find_last("\\") + 1, p_file.length()); } if (p_file.find(".") != -1) p_file = p_file.substr(0, p_file.find(".")); undo_redo->create_action(TTR("Load Animation")); undo_redo->add_do_method(player, "add_animation", p_file, res); undo_redo->add_undo_method(player, "remove_animation", p_file); if (player->has_animation(p_file)) { undo_redo->add_undo_method(player, "add_animation", p_file, player->get_animation(p_file)); } undo_redo->add_do_method(this, "_animation_player_changed", player); undo_redo->add_undo_method(this, "_animation_player_changed", player); undo_redo->commit_action(); break; } case RESOURCE_SAVE: { String current = animation->get_item_text(animation->get_selected()); if (current != "") { Ref anim = player->get_animation(current); ERR_FAIL_COND(!anim->cast_to()) RES current_res = RES(anim->cast_to()); _animation_save_in_path(current_res, p_file); } } } } void AnimationPlayerEditor::_scale_changed(const String& p_scale) { player->set_speed(p_scale.to_double()); } void AnimationPlayerEditor::_update_animation() { // the purpose of _update_animation is to reflect the current state // of the animation player in the current editor.. updating=true; if (player->is_playing()) { play->set_pressed(true); stop->set_pressed(false); } else { play->set_pressed(false); stop->set_pressed(true); } scale->set_text( String::num(player->get_speed(),2) ); String current=player->get_current_animation(); for (int i=0;iget_item_count();i++) { if (animation->get_item_text(i)==current) { animation->select(i); break; } } updating=false; } void AnimationPlayerEditor::_update_player() { updating=true; List animlist; if (player) player->get_animation_list(&animlist); animation->clear(); if (player) nodename->set_text(player->get_name()); else nodename->set_text(""); add_anim->set_disabled(player==NULL); load_anim->set_disabled(player==NULL); stop->set_disabled(animlist.size()==0); play->set_disabled(animlist.size()==0); play_bw->set_disabled(animlist.size()==0); play_bw_from->set_disabled(animlist.size()==0); play_from->set_disabled(animlist.size()==0); autoplay->set_disabled(animlist.size()==0); duplicate_anim->set_disabled(animlist.size()==0); rename_anim->set_disabled(animlist.size()==0); blend_anim->set_disabled(animlist.size()==0); remove_anim->set_disabled(animlist.size()==0); resource_edit_anim->set_disabled(animlist.size()==0); save_anim->set_disabled(animlist.size() == 0); tool_anim->set_disabled(player==NULL); int active_idx=-1; for (List::Element *E=animlist.front();E;E=E->next()) { if (player->get_autoplay()==E->get()) animation->add_icon_item(autoplay_icon,E->get()); else animation->add_item(E->get()); if (player->get_current_animation()==E->get()) active_idx=animation->get_item_count()-1; } if (!player) return; updating=false; if (active_idx!=-1) { animation->select(active_idx); autoplay->set_pressed(animation->get_item_text(active_idx)==player->get_autoplay()); _animation_selected(active_idx); } else if (animation->get_item_count()>0){ animation->select(0); autoplay->set_pressed(animation->get_item_text(0)==player->get_autoplay()); _animation_selected(0); } //pause->set_pressed(player->is_paused()); if (animation->get_item_count()) { String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); key_editor->set_animation(anim); Node *root = player->get_node(player->get_root()); if (root) { key_editor->set_root(root); } } _update_animation(); } void AnimationPlayerEditor::edit(AnimationPlayer *p_player) { if (player && pin->is_pressed()) return; //ignore, pinned player=p_player; if (player) { _update_player(); key_editor->show_select_node_warning(false); } else { key_editor->show_select_node_warning(true); // hide(); } } void AnimationPlayerEditor::_animation_duplicate() { if (!animation->get_item_count()) return; String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); if (!anim.is_valid()) return; Ref new_anim = memnew( Animation ); List plist; anim->get_property_list(&plist); for (List::Element *E=plist.front();E;E=E->next()) { if (E->get().usage&PROPERTY_USAGE_STORAGE) { new_anim->set(E->get().name, anim->get(E->get().name)); } } new_anim->set_path(""); String new_name = current; while(player->has_animation(new_name)) { new_name=new_name+" (copy)"; } undo_redo->create_action(TTR("Duplicate Animation")); undo_redo->add_do_method(player,"add_animation",new_name,new_anim); undo_redo->add_undo_method(player,"remove_animation",new_name); undo_redo->add_do_method(player,"animation_set_next",new_name,player->animation_get_next(current)); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); for(int i=0;iget_item_count();i++) { if (animation->get_item_text(i)==new_name) { animation->select(i); _animation_selected(i); return; } } } void AnimationPlayerEditor::_seek_value_changed(float p_value,bool p_set) { if (updating || !player || player->is_playing()) { return; }; updating=true; String current=player->get_current_animation(); //animation->get_item_text( animation->get_selected() ); if (current == "" || !player->has_animation(current)) { updating=false; current=""; return; }; Ref anim; anim=player->get_animation(current); float pos = anim->get_length() * (p_value / frame->get_max()); float step = anim->get_step(); if (step) { pos=Math::stepify(pos, step); if (pos<0) pos=0; if (pos>=anim->get_length()) pos=anim->get_length(); } if (player->is_valid() && !p_set) { float cpos = player->get_current_animation_pos(); player->seek_delta(pos,pos-cpos); } else { player->seek(pos,true); } key_editor->set_anim_pos(pos); updating=true; }; void AnimationPlayerEditor::_animation_player_changed(Object *p_pl) { if (player==p_pl && is_visible()) { _update_player(); if (blend_editor.dialog->is_visible()) _animation_blend(); //update } } void AnimationPlayerEditor::_list_changed() { if(is_visible()) _update_player(); } #if 0 void AnimationPlayerEditor::_editor_store() { if (animation->get_item_count()==0) return; String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); if (key_editor->get_current_animation()==anim) return; //already there undo_redo->create_action("Store anim in editor"); undo_redo->add_do_method(key_editor,"set_animation",anim); undo_redo->add_undo_method(key_editor,"remove_animation",anim); undo_redo->commit_action(); } void AnimationPlayerEditor::_editor_load(){ Ref anim = key_editor->get_current_animation(); if (anim.is_null()) return; String existing = player->find_animation(anim); if (existing!="") { _select_anim_by_name(existing); return; //already has } int count=1; String base=anim->get_name(); bool noname=false; if (base=="") { base="New Anim"; noname=true; } while(true) { String attempt = base; if (count>1) attempt+=" ("+itos(count)+")"; if (player->has_animation(attempt)) { count++; continue; } base=attempt; break; } if (noname) anim->set_name(base); undo_redo->create_action("Add Animation From Editor"); undo_redo->add_do_method(player,"add_animation",base,anim); undo_redo->add_undo_method(player,"remove_animation",base); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); _select_anim_by_name(base); } #endif void AnimationPlayerEditor::_animation_key_editor_anim_len_changed(float p_len) { frame->set_max(p_len); } void AnimationPlayerEditor::_animation_key_editor_anim_step_changed(float p_len) { if (p_len) frame->set_step(p_len); else frame->set_step(0.00001); } void AnimationPlayerEditor::_animation_key_editor_seek(float p_pos,bool p_drag) { if (!is_visible()) return; if (!player) return; if (player->is_playing() ) return; updating=true; frame->set_value(p_pos); updating=false; _seek_value_changed(p_pos,!p_drag); EditorNode::get_singleton()->get_property_editor()->refresh(); //seekit } void AnimationPlayerEditor::_hide_anim_editors() { player=NULL; hide(); set_process(false); key_editor->set_animation(Ref()); key_editor->set_root(NULL); key_editor->show_select_node_warning(true); // editor->animation_editor_make_visible(false); } void AnimationPlayerEditor::_animation_tool_menu(int p_option) { switch(p_option) { case TOOL_COPY_ANIM: { if (!animation->get_item_count()) { error_dialog->set_text(TTR("ERROR: No animation to copy!")); error_dialog->popup_centered_minsize(); return; } String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); //editor->edit_resource(anim); EditorSettings::get_singleton()->set_resource_clipboard(anim); } break; case TOOL_PASTE_ANIM: { Ref anim = EditorSettings::get_singleton()->get_resource_clipboard(); if (!anim.is_valid()) { error_dialog->set_text(TTR("ERROR: No animation resource on clipboard!")); error_dialog->popup_centered_minsize(); return; } String name = anim->get_name(); if (name=="") { name=TTR("Pasted Animation"); } int idx=1; String base = name; while (player->has_animation(name)) { idx++; name=base+" "+itos(idx); } undo_redo->create_action(TTR("Paste Animation")); undo_redo->add_do_method(player,"add_animation",name,anim); undo_redo->add_undo_method(player,"remove_animation",name); undo_redo->add_do_method(this,"_animation_player_changed",player); undo_redo->add_undo_method(this,"_animation_player_changed",player); undo_redo->commit_action(); _select_anim_by_name(name); } break; case TOOL_EDIT_RESOURCE: { if (!animation->get_item_count()) { error_dialog->set_text(TTR("ERROR: No animation to edit!")); error_dialog->popup_centered_minsize(); return; } String current = animation->get_item_text(animation->get_selected()); Ref anim = player->get_animation(current); editor->edit_resource(anim); } break; } } void AnimationPlayerEditor::_animation_save_menu(int p_option) { String current = animation->get_item_text(animation->get_selected()); if (current != "") { Ref anim = player->get_animation(current); switch (p_option) { case ANIM_SAVE: _animation_save(anim); break; case ANIM_SAVE_AS: _animation_save_as(anim); break; } } } void AnimationPlayerEditor::_unhandled_key_input(const InputEvent& p_ev) { if (is_visible() && p_ev.type==InputEvent::KEY && p_ev.key.pressed && !p_ev.key.echo && !p_ev.key.mod.alt && !p_ev.key.mod.control && !p_ev.key.mod.meta) { switch(p_ev.key.scancode) { case KEY_A: { if (!p_ev.key.mod.shift) _play_bw_from_pressed(); else _play_bw_pressed(); } break; case KEY_S: { _stop_pressed(); } break; case KEY_D: { if (!p_ev.key.mod.shift) _play_from_pressed(); else _play_pressed(); } break; } } } void AnimationPlayerEditor::_bind_methods() { ClassDB::bind_method(_MD("_gui_input"),&AnimationPlayerEditor::_gui_input); ClassDB::bind_method(_MD("_node_removed"),&AnimationPlayerEditor::_node_removed); ClassDB::bind_method(_MD("_play_pressed"),&AnimationPlayerEditor::_play_pressed); ClassDB::bind_method(_MD("_play_from_pressed"),&AnimationPlayerEditor::_play_from_pressed); ClassDB::bind_method(_MD("_play_bw_pressed"),&AnimationPlayerEditor::_play_bw_pressed); ClassDB::bind_method(_MD("_play_bw_from_pressed"),&AnimationPlayerEditor::_play_bw_from_pressed); ClassDB::bind_method(_MD("_stop_pressed"),&AnimationPlayerEditor::_stop_pressed); ClassDB::bind_method(_MD("_autoplay_pressed"),&AnimationPlayerEditor::_autoplay_pressed); ClassDB::bind_method(_MD("_pause_pressed"),&AnimationPlayerEditor::_pause_pressed); ClassDB::bind_method(_MD("_animation_selected"),&AnimationPlayerEditor::_animation_selected); ClassDB::bind_method(_MD("_animation_name_edited"),&AnimationPlayerEditor::_animation_name_edited); ClassDB::bind_method(_MD("_animation_new"),&AnimationPlayerEditor::_animation_new); ClassDB::bind_method(_MD("_animation_rename"),&AnimationPlayerEditor::_animation_rename); ClassDB::bind_method(_MD("_animation_load"),&AnimationPlayerEditor::_animation_load); ClassDB::bind_method(_MD("_animation_remove"),&AnimationPlayerEditor::_animation_remove); ClassDB::bind_method(_MD("_animation_blend"),&AnimationPlayerEditor::_animation_blend); ClassDB::bind_method(_MD("_animation_edit"),&AnimationPlayerEditor::_animation_edit); ClassDB::bind_method(_MD("_animation_resource_edit"),&AnimationPlayerEditor::_animation_resource_edit); ClassDB::bind_method(_MD("_dialog_action"),&AnimationPlayerEditor::_dialog_action); ClassDB::bind_method(_MD("_seek_value_changed"),&AnimationPlayerEditor::_seek_value_changed,DEFVAL(true)); ClassDB::bind_method(_MD("_animation_player_changed"),&AnimationPlayerEditor::_animation_player_changed); ClassDB::bind_method(_MD("_blend_edited"),&AnimationPlayerEditor::_blend_edited); // ClassDB::bind_method(_MD("_seek_frame_changed"),&AnimationPlayerEditor::_seek_frame_changed); ClassDB::bind_method(_MD("_scale_changed"),&AnimationPlayerEditor::_scale_changed); //ClassDB::bind_method(_MD("_editor_store_all"),&AnimationPlayerEditor::_editor_store_all); ///jectTypeDB::bind_method(_MD("_editor_load_all"),&AnimationPlayerEditor::_editor_load_all); ClassDB::bind_method(_MD("_list_changed"),&AnimationPlayerEditor::_list_changed); ClassDB::bind_method(_MD("_animation_key_editor_seek"),&AnimationPlayerEditor::_animation_key_editor_seek); ClassDB::bind_method(_MD("_animation_key_editor_anim_len_changed"),&AnimationPlayerEditor::_animation_key_editor_anim_len_changed); ClassDB::bind_method(_MD("_animation_key_editor_anim_step_changed"),&AnimationPlayerEditor::_animation_key_editor_anim_step_changed); ClassDB::bind_method(_MD("_hide_anim_editors"),&AnimationPlayerEditor::_hide_anim_editors); ClassDB::bind_method(_MD("_animation_duplicate"),&AnimationPlayerEditor::_animation_duplicate); ClassDB::bind_method(_MD("_blend_editor_next_changed"),&AnimationPlayerEditor::_blend_editor_next_changed); ClassDB::bind_method(_MD("_unhandled_key_input"),&AnimationPlayerEditor::_unhandled_key_input); ClassDB::bind_method(_MD("_animation_tool_menu"),&AnimationPlayerEditor::_animation_tool_menu); ClassDB::bind_method(_MD("_animation_save_menu"), &AnimationPlayerEditor::_animation_save_menu); } AnimationPlayerEditor *AnimationPlayerEditor::singleton=NULL; AnimationPlayer *AnimationPlayerEditor::get_player() const { return player; } AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { editor=p_editor; singleton=this; updating=false; set_focus_mode(FOCUS_ALL); player=NULL; add_style_override("panel", get_stylebox("panel","Panel")); Label * l; /*l= memnew( Label ); l->set_text("Animation Player:"); add_child(l);*/ HBoxContainer *hb = memnew( HBoxContainer ); add_child(hb); play_bw_from = memnew( ToolButton ); play_bw_from->set_tooltip(TTR("Play selected animation backwards from current pos. (A)")); hb->add_child(play_bw_from); play_bw = memnew( ToolButton ); play_bw->set_tooltip(TTR("Play selected animation backwards from end. (Shift+A)")); hb->add_child(play_bw); stop = memnew( ToolButton ); stop->set_toggle_mode(true); hb->add_child(stop); stop->set_tooltip(TTR("Stop animation playback. (S)")); play = memnew( ToolButton ); play->set_tooltip(TTR("Play selected animation from start. (Shift+D)")); hb->add_child(play); play_from = memnew( ToolButton ); play_from->set_tooltip(TTR("Play selected animation from current pos. (D)")); hb->add_child(play_from); //pause = memnew( Button ); //pause->set_toggle_mode(true); //hb->add_child(pause); frame = memnew( SpinBox ); hb->add_child(frame); frame->set_custom_minimum_size(Size2(60,0)); frame->set_stretch_ratio(2); frame->set_tooltip(TTR("Animation position (in seconds).")); hb->add_child( memnew( VSeparator)); scale = memnew( LineEdit ); hb->add_child(scale); scale->set_h_size_flags(SIZE_EXPAND_FILL); scale->set_stretch_ratio(1); scale->set_tooltip(TTR("Scale animation playback globally for the node.")); scale->hide(); add_anim = memnew( ToolButton ); ED_SHORTCUT("animation_player_editor/add_animation", TTR("Create new animation in player.")); add_anim->set_shortcut(ED_GET_SHORTCUT("animation_player_editor/add_animation")); add_anim->set_tooltip(TTR("Create new animation in player.")); hb->add_child(add_anim); load_anim = memnew( ToolButton ); ED_SHORTCUT("animation_player_editor/load_from_disk", TTR("Load animation from disk.")); add_anim->set_shortcut(ED_GET_SHORTCUT("animation_player_editor/load_from_disk")); load_anim->set_tooltip(TTR("Load an animation from disk.")); hb->add_child(load_anim); save_anim = memnew(MenuButton); save_anim->set_tooltip(TTR("Save the current animation")); save_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/save", TTR("Save")), ANIM_SAVE); save_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/save_as", TTR("Save As")), ANIM_SAVE_AS); save_anim->set_focus_mode(Control::FOCUS_NONE); hb->add_child(save_anim); accept = memnew(AcceptDialog); add_child(accept); accept->connect("confirmed", this, "_menu_confirm_current"); duplicate_anim = memnew( ToolButton ); hb->add_child(duplicate_anim); ED_SHORTCUT("animation_player_editor/duplicate_animation", TTR("Duplicate Animation")); duplicate_anim->set_shortcut(ED_GET_SHORTCUT("animation_player_editor/duplicate_animation")); duplicate_anim->set_tooltip(TTR("Duplicate Animation")); rename_anim = memnew( ToolButton ); hb->add_child(rename_anim); ED_SHORTCUT("animation_player_editor/rename_animation", TTR("Rename Animation")); rename_anim->set_shortcut(ED_GET_SHORTCUT("animation_player_editor/rename_animation")); rename_anim->set_tooltip(TTR("Rename Animation")); remove_anim = memnew( ToolButton ); hb->add_child(remove_anim); ED_SHORTCUT("animation_player_editor/remove_animation", TTR("Remove Animation")); remove_anim->set_shortcut(ED_GET_SHORTCUT("animation_player_editor/remove_animation")); remove_anim->set_tooltip(TTR("Remove Animation")); animation = memnew( OptionButton ); hb->add_child(animation); animation->set_h_size_flags(SIZE_EXPAND_FILL); animation->set_tooltip(TTR("Display list of animations in player.")); animation->set_clip_text(true); autoplay = memnew( ToolButton ); hb->add_child(autoplay); autoplay->set_tooltip(TTR("Autoplay on Load")); blend_anim = memnew( ToolButton ); hb->add_child(blend_anim); blend_anim->set_tooltip(TTR("Edit Target Blend Times")); tool_anim = memnew( MenuButton); //tool_anim->set_flat(false); tool_anim->set_tooltip(TTR("Animation Tools")); tool_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/copy_animation", TTR("Copy Animation")),TOOL_COPY_ANIM); tool_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/paste_animation", TTR("Paste Animation")),TOOL_PASTE_ANIM); //tool_anim->get_popup()->add_separator(); //tool_anim->get_popup()->add_item("Edit Anim Resource",TOOL_PASTE_ANIM); hb->add_child(tool_anim); nodename = memnew( Button ); hb->add_child(nodename); pin = memnew( ToolButton ); pin->set_toggle_mode(true); hb->add_child(pin); resource_edit_anim= memnew( Button ); hb->add_child(resource_edit_anim); resource_edit_anim->hide(); file = memnew(EditorFileDialog); add_child(file); name_dialog = memnew( ConfirmationDialog ); name_dialog->set_title(TTR("Create New Animation")); name_dialog->set_hide_on_ok(false); add_child(name_dialog); name = memnew( LineEdit ); name_dialog->add_child(name); name->set_pos(Point2(18,30)); name->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,10); name_dialog->register_text_enter(name); l = memnew( Label ); l->set_text(TTR("Animation Name:")); l->set_pos( Point2(10,10) ); name_dialog->add_child(l); name_title=l; error_dialog = memnew( ConfirmationDialog ); error_dialog->get_ok()->set_text(TTR("Close")); //error_dialog->get_cancel()->set_text("Close"); error_dialog->set_text(TTR("Error!")); add_child(error_dialog); name_dialog->connect("confirmed", this,"_animation_name_edited"); blend_editor.dialog = memnew( AcceptDialog ); add_child(blend_editor.dialog); blend_editor.dialog->get_ok()->set_text(TTR("Close")); blend_editor.dialog->set_hide_on_ok(true); VBoxContainer *blend_vb = memnew( VBoxContainer); blend_editor.dialog->add_child(blend_vb); blend_editor.dialog->set_child_rect(blend_vb); blend_editor.tree = memnew( Tree ); blend_editor.tree->set_columns(2); blend_vb->add_margin_child(TTR("Blend Times:"),blend_editor.tree,true); blend_editor.next = memnew( OptionButton ); blend_vb->add_margin_child(TTR("Next (Auto Queue):"),blend_editor.next); blend_editor.dialog->set_title(TTR("Cross-Animation Blend Times")); updating_blends=false; blend_editor.tree->connect("item_edited",this,"_blend_edited"); autoplay->connect("pressed", this,"_autoplay_pressed"); autoplay->set_toggle_mode(true); play->connect("pressed", this,"_play_pressed"); play_from->connect("pressed", this,"_play_from_pressed"); play_bw->connect("pressed", this,"_play_bw_pressed"); play_bw_from->connect("pressed", this,"_play_bw_from_pressed"); stop->connect("pressed", this,"_stop_pressed"); //pause->connect("pressed", this,"_pause_pressed"); add_anim->connect("pressed", this,"_animation_new"); rename_anim->connect("pressed", this,"_animation_rename"); load_anim->connect("pressed", this,"_animation_load"); duplicate_anim->connect("pressed", this,"_animation_duplicate"); //frame->connect("text_entered", this,"_seek_frame_changed"); blend_anim->connect("pressed", this,"_animation_blend"); remove_anim->connect("pressed", this,"_animation_remove"); animation->connect("item_selected", this,"_animation_selected",Vector(),true); resource_edit_anim->connect("pressed", this,"_animation_resource_edit"); file->connect("file_selected", this,"_dialog_action"); frame->connect("value_changed", this, "_seek_value_changed",Vector(),true); scale->connect("text_entered", this, "_scale_changed",Vector(),true); renaming=false; last_active=false; set_process_unhandled_key_input(true); key_editor = memnew( AnimationKeyEditor); add_child(key_editor); add_constant_override("separation",get_constant("separation","VBoxContainer")); key_editor->set_v_size_flags(SIZE_EXPAND_FILL); key_editor->connect("timeline_changed",this,"_animation_key_editor_seek"); key_editor->connect("animation_len_changed",this,"_animation_key_editor_anim_len_changed"); key_editor->connect("animation_step_changed",this,"_animation_key_editor_anim_step_changed"); _update_player(); } void AnimationPlayerEditorPlugin::edit(Object *p_object) { anim_editor->set_undo_redo(&get_undo_redo()); if (!p_object) return; anim_editor->edit(p_object->cast_to()); } bool AnimationPlayerEditorPlugin::handles(Object *p_object) const { return p_object->is_class("AnimationPlayer"); } void AnimationPlayerEditorPlugin::make_visible(bool p_visible) { if (p_visible) { editor->make_bottom_panel_item_visible(anim_editor); anim_editor->set_process(true); anim_editor->ensure_visibility(); // editor->animation_panel_make_visible(true); } else { // anim_editor->hide(); // anim_editor->set_idle_process(false); } } AnimationPlayerEditorPlugin::AnimationPlayerEditorPlugin(EditorNode *p_node) { editor=p_node; anim_editor = memnew( AnimationPlayerEditor(editor) ); anim_editor->set_undo_redo(editor->get_undo_redo()); editor->add_bottom_panel_item(TTR("Animation"),anim_editor); /* editor->get_viewport()->add_child(anim_editor); anim_editor->set_area_as_parent_rect(); anim_editor->set_anchor( MARGIN_TOP, Control::ANCHOR_END); anim_editor->set_margin( MARGIN_TOP, 75 ); anim_editor->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END); anim_editor->set_margin( MARGIN_RIGHT, 0 );*/ anim_editor->hide(); } AnimationPlayerEditorPlugin::~AnimationPlayerEditorPlugin() { }